#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "dbt.h"
#include "commctrl.h"
#include "imm.h"
#include "wine/test.h"

Include dependency graph for msg.c:

Classes
struct	DRAW_ITEM_STRUCT

struct	MEASURE_ITEM_STRUCT

struct	message

struct	recvd_message

struct	run_in_temp_desktop_args

struct	wnd_event

struct	timer_info

struct	sendmsg_info

struct	peekmsg_info

struct	rbuttonup_thread_data

struct	layered_window_info

struct	test_hook_cleanup_data

Macros
#define	MDI_FIRST_CHILD_ID 2004

#define	SWP_NOCLIENTSIZE 0x0800

#define	SWP_NOCLIENTMOVE 0x1000

#define	SWP_STATECHANGED 0x8000

#define	SW_NORMALNA 0xCC /* undoc. flag in MinMaximize */

#define	WM_KEYF1 0x004d

#define	WM_SYSTIMER 0x0118

#define	WND_PARENT_ID 1

#define	WND_POPUP_ID 2

#define	WND_CHILD_ID 3

#define	WM_LBTRACKPOINT 0x0131

#define	ARCH "none"

#define	GET_PROC(dll, func)

#define	DUMP(flag) do { if (flags & flag) { strcat( buffer, "\|" #flag ); flags &= ~flag; } } while(0)

#define	add_message(msg) add_message_(__LINE__,msg);

#define	ok_sequence(exp, contx, todo) ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)

#define	expect(EXPECTED, GOT) ok((GOT)==(EXPECTED), "Expected %d, got %ld\n", (EXPECTED), (GOT))

#define	test_msg_setpos(expected_list, flags, todo) test_msg_setpos_( (expected_list), (flags), (todo), __FILE__, __LINE__)

#define	ID_BUTTON 0x000e

#define	ID_RADIO1 501

#define	ID_RADIO2 502

#define	ID_RADIO3 503

#define	ID_TEXT 504

#define	test_radio(r1, s1, r2, s2, r3, s3) test_radio_dbg(r1, s1, r2, s2, r3, s3, __LINE__)

#define	ID_COMBOBOX 0x000f

#define	check_update_rgn(hwnd, hrgn) check_update_rgn_( __LINE__, hwnd, hrgn )

#define	subtest_swp_paint_regions(w, p, c) subtest_swp_paint_regions_(__LINE__,w,p,c)

#define	run_in_temp_desktop(f) run_in_temp_desktop_(__FILE__, __LINE__, #f, f)

#define	TIMER_ID 0x19

#define	TIMER_COUNT 500 /* 499 samples */

#define	TIMER_DURATION_EXPECTED 10000 /* 10 ms */

#define	TIMER_DURATION_ALT 15600 /* 15.6 ms */

#define	TIMER_DURATION_TOLERANCE 1000 /* 1 ms */

#define	ID_EDIT 0x1234

#define	EV_STOP 0

#define	EV_SENDMSG 1

#define	EV_ACK 2

#define	STEP 5

#define	track_hover(track_hwnd, track_hover_time)

#define	track_query(expected_track_flags, expected_track_hwnd, expected_hover_time)

#define	track_hover_cancel(track_hwnd)

#define	WS_BASE (WS_CAPTION\|WS_SYSMENU\|WS_MINIMIZEBOX\|WS_MAXIMIZEBOX\|WS_POPUP\|WS_CLIPSIBLINGS)

#define	set_selection(hctl, start, end)

#define	check_selection(hctl, start, end)

#define	ID_LISTBOX 0x000f

#define	check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)

#define	TEST_MOUSEACTIVATE(A, B, C)

#define	open_clipboard(hwnd) open_clipboard_(__LINE__, hwnd)

#define	clear_clipboard(hwnd) clear_clipboard_(__LINE__, (hwnd))

#define	expect_HWND(expected, got) expect_HWND_(__LINE__, (expected), (got))

Enumerations
enum	msg_flags_t { sent = 0x1 , posted = 0x2 , parent = 0x4 , wparam = 0x8 , lparam = 0x10 , defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 , hook = 0x100 , winevent_hook = 0x200 , kbd_hook = 0x400 , sent = 0x1 , posted = 0x2 , parent = 0x4 , wparam = 0x8 , lparam = 0x10 , defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 , hook = 0x100 , winevent_hook =0x200 , id = 0x400 , custdraw = 0x800 , sent = 0x1 , posted = 0x2 , parent = 0x4 , wparam = 0x8 , lparam = 0x10 , defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 , hook = 0x100 , winevent_hook =0x200 , id = 0x400 , sent =0x1 , posted =0x2 , parent =0x4 , wparam =0x8 , lparam =0x10 , defwinproc =0x20 , beginpaint =0x40 , optional =0x80 , hook =0x100 , winevent_hook =0x200 , kbd_hook =0x400 , msg_todo =0x800 , wine_only =0x1000 }

Functions
static void	pump_msg_loop (HWND hwnd, HACCEL hAccel)

static LRESULT WINAPI	ParentMsgCheckProcA (HWND, UINT, WPARAM, LPARAM)

static void	register_class (const WNDCLASSA *class)

static	void (WINAPI *pNotifyWinEvent)(DWORD

static	HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD

static	BOOL (WINAPI pTrackMouseEvent)(TRACKMOUSEEVENT )

static	UINT_PTR (WINAPI *pSetSystemTimer)(HWND

static void	init_procs (void)

static const char *	get_winpos_flags (UINT flags)

static BOOL	ignore_message (UINT message)

static unsigned	hash_Ly_W (const WCHAR *str)

static unsigned	hash_Ly (const char *str)

static void	add_message_ (int line, const struct recvd_message *msg)

static void	flush_events (void)

static void	flush_sequence (void)

static const char *	message_type_name (int flags)

static BOOL	can_skip_message (const struct message *expected)

static BOOL	messages_equal (const struct message expected, const struct recvd_message actual, BOOL expect_equal, const char *file, int line)

static BOOL	sequence_contains_message (const struct message expected, const struct recvd_message actual)

static void	dump_sequence (const struct message expected, const char context, const char *file, int line)

static void	ok_sequence_ (const struct message expected_list, const char context, BOOL todo, const char *file, int line)

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

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

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

static void	mdi_register_classes (void)

static void	test_mdi_messages (void)

static void	test_WM_SETREDRAW (HWND hwnd)

static INT_PTR CALLBACK	TestModalDlgProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static INT_PTR CALLBACK	TestModalDlgProc2 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	test_hv_scroll_1 (HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)

static void	test_hv_scroll_2 (HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)

static void	test_scroll_messages (HWND hwnd)

static void	test_showwindow (void)

static void	test_sys_menu (void)

static void CALLBACK	apc_test_proc (ULONG_PTR param)

static void	test_MsgWaitForMultipleObjects (HWND hwnd)

static void	test_WM_DEVICECHANGE (HWND hwnd)

static DWORD CALLBACK	hide_window_thread (LPVOID arg)

static DWORD CALLBACK	show_window_thread (LPVOID arg)

static void	test_msg_setpos_ (const struct message expected_list, UINT flags, BOOL todo, const char file, int line)

static void	test_messages (void)

static void	test_setwindowpos (void)

static void	invisible_parent_tests (void)

static LRESULT CALLBACK	button_hook_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	subclass_button (void)

static void	test_button_messages (void)

static void	test_button_bm_get_set_image (void)

static INT_PTR WINAPI	radio_test_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	test_autoradio_BM_CLICK (void)

static void	test_radio_dbg (HWND radio1, int state1, HWND radio2, int state2, HWND radio3, int state3, int line)

static void	set_radio (HWND radio1, int state1, HWND radio2, int state2, HWND radio3, int state3)

static void	test_autoradio_kbd_move (void)

static LRESULT CALLBACK	static_hook_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	subclass_static (void)

static void	test_static_messages (void)

static LRESULT CALLBACK	combobox_edit_subclass_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static LRESULT CALLBACK	combobox_lbox_subclass_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static LRESULT CALLBACK	combobox_hook_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	subclass_combobox (void)

static void	test_combobox_messages (void)

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

static void	register_wmime_keydown_class (void)

static void	test_wmime_keydown_message (void)

void	dump_region (HRGN hrgn)

static void	check_update_rgn_ (int line, HWND hwnd, HRGN hrgn)

static void	test_paint_messages (void)

static void	visualize_region_differences (HWND hwnd, HWND hother, HRGN hrgn_expect, HRGN hrgn_actual)

static void	subtest_swp_paint_regions_ (int line, int wrap_toplevel, LPCSTR parent_class, LPCSTR child_class)

static void	test_swp_paint_regions (void)

static void	test_swp_paint_region_on_show (void)

static void	test_swp_paint_region_on_extend_zerosize (void)

static void	subtest_hvredraw (HWND hparent, UINT class_style, DWORD style)

static void	test_hvredraw (void)

static DWORD WINAPI	run_in_temp_desktop_thread_func (LPVOID param)

static void	run_in_temp_desktop_ (const char file, int line, const char name, void(*test_func)(void))

static DWORD WINAPI	thread_proc (void *param)

static DWORD CALLBACK	create_grand_child_thread (void *param)

static DWORD CALLBACK	create_child_thread (void *param)

static void	create_manifest_file (const char filename, const char manifest)

static HANDLE	test_create (const char *file)

static void	test_interthread_messages (void)

static void	test_accelerators (void)

static LRESULT	MsgCheckProc (BOOL unicode, HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

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

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

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

static LRESULT CALLBACK	StopQuitMsgCheckProcA (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

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

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

static LRESULT WINAPI	PaintLoopProcA (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

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

static void	register_classes (void)

static BOOL	is_our_logged_class (HWND hwnd)

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

static void CALLBACK	win_event_proc (HWINEVENTHOOK hevent, DWORD event, HWND hwnd, LONG object_id, LONG child_id, DWORD thread_id, DWORD event_time)

static LRESULT CALLBACK	MsgConversionProcW (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

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

static void	test_message_conversion (void)

static VOID CALLBACK	tfunc (HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)

static int	compare_ulonglong (const void a, const void b)

static void	timer_fired (void)

static void CALLBACK	callback_count (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)

static void CALLBACK	callback_exception (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)

static DWORD WINAPI	timer_thread_proc (LPVOID x)

static void	test_timers (void)

static void	test_timers_no_wnd (void)

static void	test_timers_exception (DWORD code)

static void	test_timers_exceptions (void)

static void CALLBACK	win_event_global_hook_proc (HWINEVENTHOOK hevent, DWORD event, HWND hwnd, LONG object_id, LONG child_id, DWORD thread_id, DWORD event_time)

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

static DWORD WINAPI	win_event_global_thread_proc (void *param)

static DWORD WINAPI	cbt_global_hook_thread_proc (void *param)

static DWORD WINAPI	mouse_ll_global_thread_proc (void *param)

static void	test_winevents (void)

static char *	get_test_dll_path (void)

static void	test_set_hook (void)

static void	simulate_click (BOOL left, int x, int y)

static LRESULT WINAPI	rec_get_message_hook (int code, WPARAM w, LPARAM l)

static LRESULT CALLBACK	keyboard_recursive_hook_proc (int code, WPARAM wp, LPARAM lp)

static LRESULT CALLBACK	mouse_recursive_hook_proc (int code, WPARAM wp, LPARAM lp)

static LRESULT CALLBACK	keyboard_recursive_cbt_hook_proc (int code, WPARAM wp, LPARAM lp)

static LRESULT CALLBACK	mouse_recursive_cbt_hook_proc (int code, WPARAM wp, LPARAM lp)

static void	test_recursive_hook (void)

static LRESULT WINAPI	recursive_messages_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

static void	test_recursive_messages (void)

static void	test_scrollwindowex (void)

static void	test_DestroyWindow (void)

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

static void	test_DispatchMessage (void)

static DWORD CALLBACK	send_msg_thread (LPVOID arg)

static void	wait_for_thread (HANDLE thread)

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

static void	test_SendMessageTimeout (void)

static LRESULT CALLBACK	edit_hook_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static LRESULT CALLBACK	edit_ime_subclass_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static DWORD WINAPI	test_edit_ime_messages (void *unused_arg)

static void	subclass_edit (void)

static void	test_edit_messages (void)

static DWORD CALLBACK	send_msg_thread_2 (void *param)

static void	test_PeekMessage (void)

static void	wait_move_event (HWND hwnd, int x, int y)

static void	test_PeekMessage2 (void)

static void	test_PeekMessage3 (void)

static INT_PTR CALLBACK	wm_quit_dlg_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

static void	test_quit_message (void)

static void	test_notify_message (void)

static void	pump_msg_loop_timeout (DWORD timeout, BOOL inject_mouse_move)

static void	test_TrackMouseEvent (void)

static void	test_SetWindowRgn (void)

static void	test_ShowWindow (void)

static INT_PTR WINAPI	test_dlg_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static LRESULT WINAPI	dlg_creation_edit_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

static INT_PTR WINAPI	test_dlg_proc2 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static INT_PTR WINAPI	test_dlg_proc3 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

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

static void	test_dialog_messages (void)

static void	test_enddialog_seq (HWND dialog, HWND owner)

static void	test_enddialog_seq2 (HWND dialog, HWND owner)

static void	test_EndDialog (void)

static void	test_nullCallback (void)

static void	test_SetActiveWindow (void)

static void	test_SetForegroundWindow (void)

static DWORD	get_input_codepage (void)

static void	test_dbcs_wm_char (void)

static void	test_unicode_wm_char (void)

static	LRESULT (WINAPI *listbox_orig_proc)(HWND

static LRESULT WINAPI	listbox_hook_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

static void	check_lb_state_dbg (HWND listbox, int count, int cur_sel, int caret_index, int top_index, int line)

static void	test_listbox_messages (void)

static LRESULT WINAPI	parent_menu_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

static void	set_menu_style (HMENU hmenu, DWORD style)

static DWORD	get_menu_style (HMENU hmenu)

static void	test_menu_messages (void)

static void	test_paintingloop (void)

static DWORD CALLBACK	post_rbuttonup_msg (void *arg)

static void	test_defwinproc (void)

static void	test_desktop_winproc (void)

static BOOL	open_clipboard_ (int line, HWND hwnd)

static void	clear_clipboard_ (int line, HWND hWnd)

static void	expect_HWND_ (int line, HWND expected, HWND got)

static LRESULT CALLBACK	recursive_viewer_proc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	test_clipboard_viewers (void)

static void	test_PostMessage (void)

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

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

static void	test_broadcast (void)

static DWORD CALLBACK	do_wait_idle_child_thread (void *arg)

static void	do_wait_idle_child (int arg)

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

static DWORD CALLBACK	wait_idle_thread (void *arg)

static void	test_WaitForInputIdle (char *argv0)

static void	test_SetParent (void)

static void	test_keyflags (void)

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

static void	test_hotkey (void)

static void	test_SetFocus (void)

static DWORD CALLBACK	update_layered_proc (void *param)

static void	test_layered_window (void)

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

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

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

static void	test_TrackPopupMenu (void)

static void	test_TrackPopupMenuEmpty (void)

static DWORD WINAPI	SendMessage_thread_1 (void *param)

static void	test_SendMessage_other_thread (void)

static DWORD WINAPI	SetParent_thread (void *param)

static void	test_setparent_status (void)

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

static void CALLBACK	msg_callback (HWND hwnd, UINT msg, ULONG_PTR arg, LRESULT result)

static DWORD WINAPI	send_message_thread (void *arg)

static void	test_InSendMessage (void)

static void	test_DoubleSetCapture (void)

static void	test_restore_messages (void)

static void	test_invalid_window (void)

static void	test_button_style (void)

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

static void	test_create_name (void)

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

static LRESULT WINAPI	call_window_proc_hook (INT code, WPARAM wparam, LPARAM lparam)

static void	test_hook_changing_window_proc (void)

static void	test_radiobutton_focus (void)

static void CALLBACK	test_hook_cleanup_hook_proc (HWINEVENTHOOK hook, DWORD event_id, HWND hwnd, LONG obj_id, LONG child_id, DWORD thread_id, DWORD event_time)

static DWORD WINAPI	test_hook_cleanup_thread_proc (void *context)

static void	test_hook_cleanup (void)

	START_TEST (msg)

Variables
static BOOL	test_DestroyWindow_flag

static BOOL	test_context_menu

static BOOL	ignore_mouse_messages = TRUE

static HWINEVENTHOOK	hEvent_hook

static HHOOK	hKBD_hook

static HHOOK	hCBT_hook

static DWORD	cbt_hook_thread_id

static DWORD	winevent_hook_thread_id

static const WCHAR	testWindowClassW []

static const struct message	WmEmptySeq []

static const struct message	WmCreateOverlappedSeq []

static const struct message	WmSWP_ShowOverlappedSeq []

static const struct message	WmSWP_HideOverlappedSeq []

static const struct message	WmSWP_ResizeSeq []

static const struct message	WmSWP_ResizePopupSeq []

static const struct message	WmSWP_MoveSeq []

static const struct message	WmSWP_ResizeNoZOrder []

static const struct message	WmSwitchChild []

static const struct message	WmSwitchNotMaximizedChild []

static const struct message	WmSWP_FrameChanged_clip []

static const struct message	WmSWP_FrameChangedDeferErase []

static const struct message	WmSWP_FrameChanged_noclip []

static const struct message	WmShowOverlappedSeq []

static const struct message	WmShowMaxOverlappedSeq []

static const struct message	WmShowRestoreMaxOverlappedSeq []

static const struct message	WmShowRestoreMinOverlappedSeq []

static const struct message	WmShowMinOverlappedSeq []

static const struct message	WmHideOverlappedSeq []

static const struct message	WmDestroyOverlappedSeq []

static const struct message	WmCreateMaxPopupSeq []

static const struct message	WmCreateInvisibleMaxPopupSeq []

static const struct message	WmShowMaxPopupResizedSeq []

static const struct message	WmShowMaxPopupSeq []

static const struct message	WmCreatePopupSeq []

static const struct message	WmShowVisMaxPopupSeq []

static const struct message	WmShowRestoreMinimizedOverlappedSeq []

static const struct message	WmShowNoActivateMinimizedOverlappedSeq []

static const struct message	WmShowRestoreActiveMinimizedOverlappedSeq []

static const struct message	WmShowNoActivateActiveMinimizedOverlappedSeq []

static const struct message	WmCreateChildPopupSeq []

static const struct message	WmCreateInvisiblePopupSeq []

static const struct message	WmShowVisiblePopupSeq_2 []

static const struct message	WmShowVisiblePopupSeq_3 []

static const struct message	WmShowPopupExtremeLocationSeq []

static const struct message	WmShowPopupFirstDrawSeq_1 []

static const struct message	WmShowPopupFirstDrawSeq_2 []

static const struct message	WmFirstDrawSetWindowPosSeq1 []

static const struct message	WmFirstDrawSetWindowPosSeq2 []

static const struct message	WmFirstDrawSetWindowPosSeq3 []

static const struct message	WmFirstDrawSetWindowPosSeq4 []

static const struct message	WmFirstDrawSetWindowPosSeq5 []

static const struct message	WmFirstDrawSetWindowPosSeq6 []

static const struct message	WmFirstDrawChildSeq1 []

static const struct message	WmFirstDrawChildSeq2 []

static const struct message	WmCreateChildSeq []

static const struct message	WmCreateMaximizedChildSeq []

static const struct message	WmCreateVisibleChildSeq []

static const struct message	WmShowChildSeq []

static const struct message	WmHideChildSeq []

static const struct message	WmHideChildSeq2 []

static const struct message	WmShowChildSeq_2 []

static const struct message	WmShowChildSeq_3 []

static const struct message	WmShowChildSeq_4 []

static const struct message	WmShowChildInvisibleParentSeq_1 []

static const struct message	WmShowChildInvisibleParentSeq_1r []

static const struct message	WmShowChildInvisibleParentSeq_2 []

static const struct message	WmShowChildInvisibleParentSeq_2r []

static const struct message	WmShowChildInvisibleParentSeq_3 []

static const struct message	WmShowChildInvisibleParentSeq_3r []

static const struct message	WmShowChildInvisibleParentSeq_4 []

static const struct message	WmShowChildInvisibleParentSeq_4r []

static const struct message	WmShowChildInvisibleParentSeq_5 []

static const struct message	WmHideChildInvisibleParentSeq []

static const struct message	WmShowChildInvisibleParentSeq_6 []

static const struct message	WmHideChildInvisibleParentSeq_2 []

static const struct message	WmDestroyChildSeq []

static const struct message	WmExitThreadSeq []

static const struct message	WmDestroyInvisibleChildSeq []

static const struct message	WmResizingChildWithMoveWindowSeq []

static const struct message	WmCreateCustomDialogSeq []

static const struct message	WmEndCustomDialogSeq []

static const struct message	WmShowCustomDialogSeq []

static const struct message	WmModalDialogSeq []

static const struct message	WmModalDialogSeq_2 []

static const struct message	WmSetMenuNonVisibleSizeChangeSeq []

static const struct message	WmSetMenuNonVisibleNoSizeChangeSeq []

static const struct message	WmSetMenuVisibleSizeChangeSeq []

static const struct message	WmSetMenuVisibleNoSizeChangeSeq []

static const struct message	WmDrawMenuBarSeq []

static const struct message	WmSetRedrawFalseSeq []

static const struct message	WmSetRedrawTrueSeq []

static const struct message	WmEnableWindowSeq_1 []

static const struct message	WmEnableWindowSeq_2 []

static const struct message	WmEnableWindowSeq_3 []

static const struct message	WmEnableWindowSeq_4 []

static const struct message	WmGetScrollRangeSeq []

static const struct message	WmGetScrollInfoSeq []

static const struct message	WmSetScrollRangeSeq []

static const struct message	WmSetScrollRangeHSeq_empty []

static const struct message	WmSetScrollRangeVSeq_empty []

static const struct message	WmSetScrollRangeHVSeq []

static const struct message	WmSetScrollRangeHV_NC_Seq []

static const struct message	WmSHOWNAChildInvisParInvis []

static const struct message	WmSHOWNAChildVisParInvis []

static const struct message	WmSHOWNAChildVisParVis []

static const struct message	WmSHOWNAChildInvisParVis []

static const struct message	WmSHOWNATopVisible []

static const struct message	WmSHOWNATopInvisible []

static const struct message	WmTrackPopupMenuMinimizeWindow []

static const struct message	WmTrackPopupMenu []

static const struct message	WmTrackPopupMenuEsc []

static const struct message	WmTrackPopupMenuCapture []

static const struct message	WmTrackPopupMenuEmpty []

static const struct message	WmTrackPopupMenuAbort []

static BOOL	after_end_dialog

static BOOL	test_def_id

static BOOL	paint_loop_done

static int	sequence_cnt

static int	sequence_size

static struct recvd_message *	sequence

static int	log_all_parent_messages

static CRITICAL_SECTION	sequence_cs

static	HWND

static	LONG

static	DWORD

static	HMODULE

static	WINEVENTPROC

static	HDC

static POINT SIZE POINT	COLORREF

static	UINT_PTR

static	UINT

static	TIMERPROC

static	ULONG

static	LPCPINFOEXA

static const struct message	WmCreateMDIframeSeq []

static const struct message	WmDestroyMDIframeSeq []

static const struct message	WmCreateMDIclientSeq []

static const struct message	WmShowMDIclientSeq []

static const struct message	WmHideMDIclientSeq []

static const struct message	WmDestroyMDIclientSeq []

static const struct message	WmCreateMDIchildVisibleSeq []

static const struct message	WmChildActivateDisabledWindowSeq []

static const struct message	WmChildActivateWindowSeq []

static const struct message	WmCreateMDIchildInvisibleParentSeq []

static const struct message	WmDestroyMDIchildVisibleSeq []

static const struct message	WmCreateMDIchildInvisibleSeq []

static const struct message	WmDestroyMDIchildInvisibleSeq []

static const struct message	WmCreateMDIchildVisibleMaxSeq1 []

static const struct message	WmCreateMDIchildVisibleMaxSeq2 []

static const struct message	WmCreateMDIchildVisibleMaxSeq3 []

static const struct message	WmCreateMDIchildInvisibleMaxSeq4 []

static const struct message	WmDestroyMDIchildVisibleMaxSeq2 []

static const struct message	WmDestroyMDIchildVisibleMaxSeq1 []

static const struct message	WmMaximizeMDIchildInvisibleSeq []

static const struct message	WmMaximizeMDIchildInvisibleSeq2 []

static const struct message	WmMaximizeMDIchildInvisibleParentSeq []

static const struct message	WmMaximizeMDIchildVisibleSeq []

static const struct message	WmRestoreMDIchildVisibleSeq []

static const struct message	WmRestoreMDIchildVisibleSeq_2 []

static const struct message	WmMinimizeMDIchildVisibleSeq []

static const struct message	WmRestoreMDIchildInvisibleSeq []

static HWND	mdi_client

static WNDPROC	old_mdi_client_proc

static const struct message	WmSetIcon_1 []

static const struct message	WmSetIcon_2 []

static const struct message	WmInitEndSession []

static const struct message	WmInitEndSession_2 []

static const struct message	WmInitEndSession_3 []

static const struct message	WmInitEndSession_4 []

static const struct message	WmInitEndSession_5 []

static const struct message	WmOptionalPaint []

static const struct message	WmZOrder []

static const struct message	WmFrameChanged []

static const struct message	WmFrameChanged_move []

static const struct message	WmMove_mouse []

static const struct message	WmMove_mouse2 []

static const struct message	WmSetFocusButtonSeq []

static const struct message	WmKillFocusButtonSeq []

static const struct message	WmSetFocusStaticSeq []

static const struct message	WmKillFocusStaticSeq []

static const struct message	WmSetFocusOwnerdrawSeq []

static const struct message	WmKillFocusOwnerdrawSeq []

static const struct message	WmLButtonDownSeq []

static const struct message	WmLButtonDownStaticSeq []

static const struct message	WmLButtonUpSeq []

static const struct message	WmLButtonUpStaticSeq []

static const struct message	WmLButtonUpAutoSeq []

static const struct message	WmLButtonUpBrokenSeq []

static const struct message	WmSetFontButtonSeq []

static const struct message	WmSetFontOwnerdrawSeq []

static const struct message	WmSetFontStaticSeq []

static const struct message	WmSetTextButtonSeq []

static const struct message	WmSetTextStaticSeq []

static const struct message	WmSetTextGroupSeq []

static const struct message	WmSetTextInvisibleSeq []

static const struct message	WmSetStyleButtonSeq []

static const struct message	WmSetStyleStaticSeq []

static const struct message	WmSetStyleUserSeq []

static const struct message	WmSetStyleOwnerdrawSeq []

static const struct message	WmSetStateButtonSeq []

static const struct message	WmSetStateStaticSeq []

static const struct message	WmSetStateUserSeq []

static const struct message	WmSetStateOwnerdrawSeq []

static const struct message	WmClearStateButtonSeq []

static const struct message	WmDisableButtonSeq []

static const struct message	WmClearStateOwnerdrawSeq []

static const struct message	WmSetCheckIgnoredSeq []

static const struct message	WmSetCheckStaticSeq []

static WNDPROC	old_button_proc

static const struct message	auto_radio_button_BM_CLICK []

static const struct message	auto_radio_button_VK_UP_child []

static const struct message	auto_radio_button_VK_UP_parent []

static const struct message	auto_radio_button_VK_UP_dialog []

static const struct message	auto_radio_button_VK_DOWN_dialog []

static const struct message	auto_radio_button_VK_DOWN_radio3 []

static const struct message	auto_radio_button_VK_UP_radio1 []

static const struct message	WmSetFontStaticSeq2 []

static WNDPROC	old_static_proc

static const struct message	SetCurSelComboSeq []

static const struct message	SetCurSelComboSeq2 []

static const struct message	SetCurSelComboSeq_edit []

static const struct message	WmKeyDownComboSeq []

static const struct message	WmSetPosComboSeq []

static const struct message	WMSetFocusComboBoxSeq []

static const struct message	SetFocusButtonSeq []

static const struct message	SetFocusComboBoxSeq []

static const struct message	SetFocusButtonSeq2 []

static WNDPROC	old_combobox_proc

static WNDPROC	edit_window_proc

static WNDPROC	lbox_window_proc

static const struct message	WmImeKeydownMsgSeq_0 []

static const struct message	WmImeKeydownMsgSeq_1 []

static const struct message	WmInvalidateRgn []

static const struct message	WmGetUpdateRect []

static const struct message	WmInvalidateFull []

static const struct message	WmInvalidateErase []

static const struct message	WmInvalidatePaint []

static const struct message	WmInvalidateErasePaint []

static const struct message	WmInvalidateErasePaint2 []

static const struct message	WmErase []

static const struct message	WmPaint []

static const struct message	WmParentOnlyPaint []

static const struct message	WmInvalidateParent []

static const struct message	WmInvalidateParentChild []

static const struct message	WmInvalidateParentChild2 []

static const struct message	WmParentPaint []

static const struct message	WmParentPaintNc []

static const struct message	WmChildPaintNc []

static const struct message	WmParentErasePaint []

static const struct message	WmParentOnlyNcPaint []

static const struct message	WmSetParentStyle []

static const char	manifest_dep []

static const char	manifest_main []

static const struct message	WmVkN []

static const struct message	WmShiftVkN []

static const struct message	WmCtrlVkN []

static const struct message	WmCtrlVkN_2 []

static const struct message	WmAltVkN []

static const struct message	WmAltVkN_2 []

static const struct message	WmCtrlAltVkN []

static const struct message	WmCtrlShiftVkN []

static const struct message	WmCtrlAltShiftVkN []

static const struct message	WmAltPressRelease []

static const struct message	WmShiftMouseButton []

static const struct message	WmF1Seq []

static const struct message	WmVkAppsSeq []

static const struct message	WmVkF10Seq []

static const struct message	WmShiftF10Seq []

static const WCHAR	wszUnicode [] = {'U','n','i','c','o','d','e',0}

static const WCHAR	wszAnsi [] = {'U',0}

static const GUID	iface_guid = {0x66666666}

static const struct message	WmGetTextLengthAfromW []

static const WCHAR	dummy_window_text [] = {'d','u','m','m','y',' ','t','e','x','t',0}

static int	count = 0

static ULONGLONG	timer_ticks [TIMER_COUNT]

static int	timer_duration = 0

static DWORD	exception

static const struct message	WmWinEventsSeq []

static const struct message	WmWinEventCaretSeq []

static const struct message	WmWinEventCaretSeq_2 []

static const struct message	WmWinEventAlertSeq []

static const struct message	WmWinEventAlertSeq_2 []

static const struct message	WmGlobalHookSeq_1 []

static const struct message	WmGlobalHookSeq_2 []

static const struct message	WmMouseLLHookSeq []

static HHOOK	hCBT_global_hook

static DWORD	cbt_global_hook_thread_id

static HWND	hook_hwnd

static HHOOK	recursive_hook

static int	hook_depth

static int	max_hook_depth

static BOOL	skip_WH_KEYBOARD_hook

static BOOL	skip_WH_MOUSE_hook

static int	max_msg_depth

static const struct message	ScrollWindowPaint1 []

static const struct message	ScrollWindowPaint2 []

static const struct message	destroy_window_with_children []

static const struct message	WmDispatchPaint []

static const struct message	WmUser []

static const struct message	sl_edit_setfocus []

static const struct message	sl_edit_invisible []

static const struct message	ml_edit_setfocus []

static const struct message	sl_edit_killfocus []

static const struct message	sl_edit_lbutton_dblclk []

static const struct message	sl_edit_lbutton_down []

static const struct message	ml_edit_lbutton_down []

static const struct message	sl_edit_lbutton_up []

static const struct message	ml_edit_lbutton_up []

static WNDPROC	old_edit_proc

static const struct message	edit_wm_ime_composition_seq []

static const struct message	edit_wm_ime_composition_korean_seq []

static const struct message	edit_wm_ime_char_seq []

static const struct message	edit_eimes_getcompstratonce_seq []

static const struct message	edit_eimes_getcompstratonce_korean_seq []

static const struct message	WmKeyDownSkippedSeq []

static const struct message	WmKeyDownWasDownSkippedSeq []

static const struct message	WmKeyUpSkippedSeq []

static const struct message	WmUserKeyUpSkippedSeq []

static const struct message	WmQuitDialogSeq []

static const struct message	WmStopQuitSeq []

static const struct message	WmNotifySeq []

static const struct message	WmMouseHoverSeq []

static const struct message	WmSetWindowRgn []

static const struct message	WmSetWindowRgn_no_redraw []

static const struct message	WmSetWindowRgn_clear []

static const struct message	WmShowNormal []

static const struct message	WmShow []

static const struct message	WmShowNoActivate_1 []

static const struct message	WmShowNoActivate_2 []

static const struct message	WmShowNA_1 []

static const struct message	WmShowNA_2 []

static const struct message	WmRestore_1 []

static const struct message	WmRestore_2 []

static const struct message	WmRestore_3 []

static const struct message	WmRestore_4 []

static const struct message	WmRestore_5 []

static const struct message	WmHide_1 []

static const struct message	WmHide_2 []

static const struct message	WmHide_3 []

static const struct message	WmShowMinimized_1 []

static const struct message	WmMinimize_1 []

static const struct message	WmMinimize_2 []

static const struct message	WmMinimize_3 []

static const struct message	WmShowMinNoActivate []

static const struct message	WmMinMax_1 []

static const struct message	WmMinMax_2 []

static const struct message	WmMinMax_3 []

static const struct message	WmMinMax_4 []

static const struct message	WmShowMaximized_1 []

static const struct message	WmShowMaximized_2 []

static const struct message	WmShowMaximized_3 []

static WNDPROC	orig_edit_proc

static const struct message	WmDefDlgSetFocus_1 []

static const struct message	WmDefDlgSetFocus_2 []

static const struct message	WmCreateDialogParamSeq_0 []

static const struct message	WmCreateDialogParamSeq_1 []

static const struct message	WmCreateDialogParamSeq_2 []

static const struct message	WmCreateDialogParamSeq_3 []

static const struct message	WmCreateDialogParamSeq_4 []

static const struct message	SetActiveWindowSeq0 []

static const struct message	SetActiveWindowSeq1 []

static const struct message	SetActiveWindowSeq2 []

static const struct message	SetActiveWindowSeq3 []

static const struct message	SetActiveWindowSeq4 []

static const struct message	SetForegroundWindowSeq []

static const struct message	wm_lb_setcursel_0 []

static const struct message	wm_lb_setcursel_1 []

static const struct message	wm_lb_setcursel_2 []

static const struct message	wm_lb_click_0 []

static const struct message	wm_lb_deletestring []

static const struct message	wm_lb_deletestring_reset []

static const struct message	wm_lb_addstring []

static const struct message	wm_lb_addstring_ownerdraw []

static const struct message	wm_lb_addstring_sort_ownerdraw []

static const struct message	wm_lb_dblclick_0 []

static	WPARAM

static	LPARAM

static const struct message	wm_popup_menu_1 []

static const struct message	wm_popup_menu_2 []

static const struct message	wm_popup_menu_3 []

static const struct message	wm_single_menu_item []

static const struct message	NCRBUTTONDOWNSeq []

static const struct message	NCXBUTTONUPSeq1 []

static const struct message	NCXBUTTONUPSeq2 []

static const struct message	WmRestoreMinimizedOverlappedSeq []

static const struct message	WmRestoreActiveMinimizedOverlappedSeq []

static struct message	WmContextMenuSeq []

static WNDPROC	pOldViewerProc

static WPARAM	g_broadcast_wparam

static UINT	g_broadcast_msg

static WNDPROC *	g_oldproc_sub

static WPARAM *	g_broadcast_sub_wparam

struct {
DWORD exp

DWORD broken

BOOL todo

}	wait_idle_expect []

static const struct message	WmSetParentSeq_1 []

static const struct message	WmSetParentSeq_2 []

static const struct message	WmKeyReleaseOnly []

static const struct message	WmKeyPressNormal []

static const struct message	WmKeyPressRepeat []

static const struct message	WmKeyReleaseNormal []

static const struct message	WmHotkeyPressLWIN []

static const struct message	WmHotkeyPress []

static const struct message	WmHotkeyRelease []

static const struct message	WmHotkeyReleaseLWIN []

static const struct message	WmHotkeyCombined []

static const struct message	WmHotkeyPrevious []

static const struct message	WmHotkeyNew []

static const struct message	WmHotkeyPressALT []

static const struct message	WmHotkeyPressWithALT []

static const struct message	WmHotkeyReleaseWithALT []

static const struct message	WmHotkeyReleaseALT []

static int	hotkey_letter

static const struct message	WmSetFocus_1 []

static const struct message	WmSetFocus_2 []

static const struct message	WmSetFocus_3 []

static const struct message	WmSetLayeredStyle []

static const struct message	WmSetLayeredStyle2 []

static const struct message	WmLayeredWinEmptySeq []

static HMENU	hpopupmenu

static const struct message	send_message_1 []

static const struct message	send_message_2 []

static const struct message	send_message_3 []

static const struct message	send_message_5 []

static const struct message	DoubleSetCaptureSeq []

static const struct message	WmRestoreMinimizedSeq []

static LONG	test_hook_cleanup_hook_proc_child_id

static DWORD	test_hook_cleanup_hook_proc_thread_id

static DWORD	test_hook_cleanup_hook_proc_call_thread_id

Macro Definition Documentation

◆ add_message

#define add_message ( msg ) add_message_(__LINE__,msg);

Definition at line 2438 of file msg.c.

◆ ARCH

#define ARCH "none"

Definition at line 73 of file msg.c.

◆ check_lb_state

#define check_lb_state	(	a1,
		a2,
		a3,
		a4,
		a5
	)	check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)

Definition at line 17107 of file msg.c.

◆ check_selection

#define check_selection	(	hctl,
		start,
		end
	)

Value:

ret = SendMessageA(hctl, EM_GETSEL, 0, 0); \

ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));

ret

return ret

Definition: mutex.c:146

start

GLuint start

Definition: gl.h:1545

end

GLuint GLuint end

Definition: gl.h:1545

LOWORD

#define LOWORD(l)

Definition: pedump.c:82

HIWORD

#define HIWORD(l)

Definition: typedefs.h:247

EM_GETSEL

#define EM_GETSEL

Definition: winuser.h:2026

SendMessageA

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

MAKELRESULT

#define MAKELRESULT(l, h)

Definition: winuser.h:4118

◆ check_update_rgn

#define check_update_rgn	(	hwnd,
		hrgn
	)	check_update_rgn_( __LINE__, hwnd, hrgn )

Definition at line 8312 of file msg.c.

◆ clear_clipboard

#define clear_clipboard ( hwnd ) clear_clipboard_(__LINE__, (hwnd))

Definition at line 18225 of file msg.c.

◆ DUMP

#define DUMP ( flag ) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)

◆ EV_ACK

#define EV_ACK 2

Definition at line 13832 of file msg.c.

◆ EV_SENDMSG

#define EV_SENDMSG 1

Definition at line 13831 of file msg.c.

◆ EV_STOP

#define EV_STOP 0

Definition at line 13830 of file msg.c.

◆ expect

#define expect	(	EXPECTED,
		GOT
	)	ok((GOT)==(EXPECTED), "Expected %d, got %ld\n", (EXPECTED), (GOT))

Definition at line 2971 of file msg.c.

◆ expect_HWND

#define expect_HWND	(	expected,
		got
	)	expect_HWND_(__LINE__, (expected), (got))

Definition at line 18237 of file msg.c.

◆ GET_PROC

#define GET_PROC	(	dll,
		func
	)

Value:

    p ## func = (void*)GetProcAddress(dll, #func); \
    if(!p ## func) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }

◆ ID_BUTTON

#define ID_BUTTON 0x000e

Definition at line 6455 of file msg.c.

◆ ID_COMBOBOX

#define ID_COMBOBOX 0x000f

Definition at line 7842 of file msg.c.

◆ ID_EDIT

#define ID_EDIT 0x1234

Definition at line 13277 of file msg.c.

◆ ID_LISTBOX

#define ID_LISTBOX 0x000f

Definition at line 16976 of file msg.c.

◆ ID_RADIO1

#define ID_RADIO1 501

Definition at line 7317 of file msg.c.

◆ ID_RADIO2

#define ID_RADIO2 502

Definition at line 7318 of file msg.c.

◆ ID_RADIO3

#define ID_RADIO3 503

Definition at line 7319 of file msg.c.

◆ ID_TEXT

#define ID_TEXT 504

Definition at line 7320 of file msg.c.

◆ MDI_FIRST_CHILD_ID

#define MDI_FIRST_CHILD_ID 2004

Definition at line 39 of file msg.c.

◆ ok_sequence

#define ok_sequence	(	exp,
		contx,
		todo
	)	ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)

Definition at line 2798 of file msg.c.

◆ open_clipboard

#define open_clipboard ( hwnd ) open_clipboard_(__LINE__, hwnd)

Definition at line 18195 of file msg.c.

◆ run_in_temp_desktop

#define run_in_temp_desktop ( f ) run_in_temp_desktop_(__FILE__, __LINE__, #f, f)

Definition at line 9954 of file msg.c.

◆ set_selection

#define set_selection	(	hctl,
		start,
		end
	)

Value:

ret = SendMessageA(hctl, EM_SETSEL, start, end); \

ok(ret == 1, "EM_SETSEL returned %Id\n", ret);

EM_SETSEL

#define EM_SETSEL

Definition: winuser.h:2047

◆ STEP

#define STEP 5

Definition at line 14392 of file msg.c.

◆ subtest_swp_paint_regions

#define subtest_swp_paint_regions	(	w,
		p,
		c
	)	subtest_swp_paint_regions_(__LINE__,w,p,c)

Definition at line 9277 of file msg.c.

◆ SW_NORMALNA

#define SW_NORMALNA 0xCC /* undoc. flag in MinMaximize */

Definition at line 46 of file msg.c.

◆ SWP_NOCLIENTMOVE

#define SWP_NOCLIENTMOVE 0x1000

Definition at line 43 of file msg.c.

◆ SWP_NOCLIENTSIZE

#define SWP_NOCLIENTSIZE 0x0800

Definition at line 42 of file msg.c.

◆ SWP_STATECHANGED

#define SWP_STATECHANGED 0x8000

Definition at line 44 of file msg.c.

◆ TEST_MOUSEACTIVATE

#define TEST_MOUSEACTIVATE	(	A,
		B,
		C
	)

Value:

       res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,0)); \
       ok(res == B, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res); \
       res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,WM_LBUTTONDOWN)); \
       ok(res == C, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res);

◆ test_msg_setpos

#define test_msg_setpos	(	expected_list,
		flags,
		todo
	)	test_msg_setpos_( (expected_list), (flags), (todo), __FILE__, __LINE__)

Definition at line 5539 of file msg.c.

◆ test_radio

#define test_radio	(	r1,
		s1,
		r2,
		s2,
		r3,
		s3
	)	test_radio_dbg(r1, s1, r2, s2, r3, s3, __LINE__)

Definition at line 7566 of file msg.c.

◆ TIMER_COUNT

#define TIMER_COUNT 500 /* 499 samples */

Definition at line 11667 of file msg.c.

◆ TIMER_DURATION_ALT

#define TIMER_DURATION_ALT 15600 /* 15.6 ms */

Definition at line 11669 of file msg.c.

◆ TIMER_DURATION_EXPECTED

#define TIMER_DURATION_EXPECTED 10000 /* 10 ms */

Definition at line 11668 of file msg.c.

◆ TIMER_DURATION_TOLERANCE

#define TIMER_DURATION_TOLERANCE 1000 /* 1 ms */

Definition at line 11670 of file msg.c.

◆ TIMER_ID

#define TIMER_ID 0x19

Definition at line 11666 of file msg.c.

◆ track_hover

#define track_hover	(	track_hwnd,
		track_hover_time
	)

Value:

    tme.cbSize = sizeof(tme); \
    tme.dwFlags = TME_HOVER; \
    tme.hwndTrack = track_hwnd; \
    tme.dwHoverTime = track_hover_time; \
    SetLastError(0xdeadbeef); \
    ret = pTrackMouseEvent(&tme); \
    ok(ret, "TrackMouseEvent(TME_HOVER) error %ld\n", GetLastError())

◆ track_hover_cancel

#define track_hover_cancel ( track_hwnd )

Value:

    tme.cbSize = sizeof(tme); \
    tme.dwFlags = TME_HOVER | TME_CANCEL; \
    tme.hwndTrack = track_hwnd; \
    tme.dwHoverTime = 0xdeadbeef; \
    SetLastError(0xdeadbeef); \
    ret = pTrackMouseEvent(&tme); \
    ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %ld\n", GetLastError())

◆ track_query

#define track_query	(	expected_track_flags,
		expected_track_hwnd,
		expected_hover_time
	)

Value:

    tme.cbSize = sizeof(tme); \
    tme.dwFlags = TME_QUERY; \
    tme.hwndTrack = (HWND)0xdeadbeef; \
    tme.dwHoverTime = 0xdeadbeef; \
    SetLastError(0xdeadbeef); \
    ret = pTrackMouseEvent(&tme); \
    ok(ret, "TrackMouseEvent(TME_QUERY) error %ld\n", GetLastError());\
    ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %lu\n", tme.cbSize); \
    ok(tme.dwFlags == (expected_track_flags), \
       "wrong tme.dwFlags %08lx, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
    ok(tme.hwndTrack == (expected_track_hwnd), \
       "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
    ok(tme.dwHoverTime == (expected_hover_time), \
       "wrong tme.dwHoverTime %lu, expected %u\n", tme.dwHoverTime, (expected_hover_time))

◆ WM_KEYF1

#define WM_KEYF1 0x004d

Definition at line 49 of file msg.c.

◆ WM_LBTRACKPOINT

#define WM_LBTRACKPOINT 0x0131

Definition at line 61 of file msg.c.

◆ WM_SYSTIMER

#define WM_SYSTIMER 0x0118

Definition at line 53 of file msg.c.

◆ WND_CHILD_ID

#define WND_CHILD_ID 3

Definition at line 58 of file msg.c.

◆ WND_PARENT_ID

#define WND_PARENT_ID 1

Definition at line 56 of file msg.c.

◆ WND_POPUP_ID

#define WND_POPUP_ID 2

Definition at line 57 of file msg.c.

◆ WS_BASE

Enumeration Type Documentation

◆ msg_flags_t

enum msg_flags_t

Enumerator
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
kbd_hook
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
id
custdraw
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
id
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
kbd_hook
msg_todo
wine_only

Definition at line 146 of file msg.c.

             {
    sent=0x1,
    posted=0x2,
    parent=0x4,
    wparam=0x8,
    lparam=0x10,
    defwinproc=0x20,
    beginpaint=0x40,
    optional=0x80,
    hook=0x100,
    winevent_hook=0x200,
    kbd_hook=0x400,
    msg_todo=0x800,
    wine_only=0x1000
} msg_flags_t;

Function Documentation

◆ add_message_()

static void add_message_	(	int	line,
		const struct recvd_message *	msg
	)

static

Definition at line 2439 of file msg.c.

{
    struct recvd_message *seq;
 
    EnterCriticalSection( &sequence_cs );
    if (!sequence)
    {
        sequence_size = 10;
        sequence = malloc( sequence_size * sizeof(*sequence) );
    }
    if (sequence_cnt == sequence_size) 
    {
        sequence_size *= 2;
        sequence = realloc( sequence, sequence_size * sizeof(*sequence) );
    }
 
    seq = &sequence[sequence_cnt++];
    seq->hwnd = msg->hwnd;
    seq->message = msg->message;
    seq->flags = msg->flags;
    seq->wParam = msg->wParam;
    seq->lParam = msg->lParam;
    seq->line   = line;
    seq->descr  = msg->descr;
    seq->output[0] = 0;
    LeaveCriticalSection( &sequence_cs );
 
    if (msg->descr)
    {
        if (msg->flags & hook)
        {
            static const char * const 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 = (msg->message <= HCBT_SETFOCUS) ? CBT_code_name[msg->message] : "Unknown";
 
            sprintf( seq->output, "%s: hook %d (%s) wp %08Ix lp %08Ix",
                     msg->descr, msg->message, code_name, msg->wParam, msg->lParam );
        }
        else if (msg->flags & winevent_hook)
        {
            sprintf( seq->output, "%s: winevent %p %08x %08Ix %08Ix",
                     msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
        }
        else
        {
            switch (msg->message)
            {
            case WM_WINDOWPOSCHANGING:
            case WM_WINDOWPOSCHANGED:
            {
                WINDOWPOS *winpos = (WINDOWPOS *)msg->lParam;
 
                sprintf( seq->output, "%s: %p WM_WINDOWPOS%s wp %08Ix lp %08Ix after %p x %d y %d cx %d cy %d flags %s",
                          msg->descr, msg->hwnd,
                          (msg->message == WM_WINDOWPOSCHANGING) ? "CHANGING" : "CHANGED",
                          msg->wParam, msg->lParam, winpos->hwndInsertAfter,
                          winpos->x, winpos->y, winpos->cx, winpos->cy,
                          get_winpos_flags(winpos->flags) );
 
                /* Log only documented flags, win2k uses 0x1000 and 0x2000
                 * in the high word for internal purposes
                 */
                seq->wParam = winpos->flags & 0xffff;
                /* We are not interested in the flags that don't match under XP and Win9x */
                seq->wParam &= ~SWP_NOZORDER;
                seq->lParam = (!!winpos->cx) | ((!!winpos->cy) << 1)
                        | ((!!winpos->x) << 2) | ((!!winpos->y) << 3);
                break;
            }
 
            case WM_NCCALCSIZE:
                if (msg->wParam)
                {
                    NCCALCSIZE_PARAMS *p = (NCCALCSIZE_PARAMS *)msg->lParam;
                    WINDOWPOS *winpos = p->lppos;
 
                    sprintf(seq->output, "%s: %p WM_NCCALCSIZE: winpos->cx %u, winpos->cy %u",
                            msg->descr, msg->hwnd, winpos->cx, winpos->cy);
                    seq->lParam = (!!winpos->cx) | ((!!winpos->cy) << 1)
                            | ((!!winpos->x) << 2) | ((!!winpos->y) << 3);
                }
                else
                {
                    RECT *rect = (RECT*)msg->lParam;
 
                    sprintf(seq->output, "%s: %p WM_NCCALCSIZE: %s",
                            msg->descr, msg->hwnd, wine_dbgstr_rect(rect));
                    seq->lParam = 0;
                }
                break;
            case WM_DRAWITEM:
            {
                DRAW_ITEM_STRUCT di;
                DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)msg->lParam;
 
                sprintf( seq->output, "%s: %p WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x",
                         msg->descr, msg->hwnd, dis->CtlType, dis->CtlID,
                         dis->itemID, dis->itemAction, dis->itemState);
 
                di.u.lp = 0;
                di.u.item.type = dis->CtlType;
                di.u.item.ctl_id = dis->CtlID;
                if (dis->CtlType == ODT_LISTBOX ||
                    dis->CtlType == ODT_COMBOBOX ||
                    dis->CtlType == ODT_MENU)
                    di.u.item.item_id = dis->itemID;
                di.u.item.action = dis->itemAction;
                di.u.item.state = dis->itemState;
 
                seq->lParam = di.u.lp;
                break;
            }
 
            case WM_MEASUREITEM:
            {
                MEASURE_ITEM_STRUCT mi;
                MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)msg->lParam;
                BOOL is_unicode_data = TRUE;
 
                sprintf( seq->output, "%s: %p WM_MEASUREITEM: CtlType %#x, CtlID %#x, itemID %#x, itemData %#Ix",
                         msg->descr, msg->hwnd, mis->CtlType, mis->CtlID,
                         mis->itemID, mis->itemData);
 
                if (mis->CtlType == ODT_LISTBOX)
                {
                    HWND ctrl = GetDlgItem(msg->hwnd, mis->CtlID);
                    is_unicode_data = GetWindowLongA(ctrl, GWL_STYLE) & LBS_HASSTRINGS;
                }
 
                mi.u.wp = 0;
                mi.u.item.CtlType = mis->CtlType;
                mi.u.item.CtlID = mis->CtlID;
                mi.u.item.itemID = mis->itemID;
                mi.u.item.wParam = msg->wParam;
                seq->wParam = mi.u.wp;
                if (is_unicode_data)
                    seq->lParam = mis->itemData ? hash_Ly_W((const WCHAR *)mis->itemData) : 0;
                else
                    seq->lParam = mis->itemData ? hash_Ly((const char *)mis->itemData) : 0;
                break;
            }
 
            case WM_COMPAREITEM:
            {
                COMPAREITEMSTRUCT *cis = (COMPAREITEMSTRUCT *)msg->lParam;
                HWND ctrl = GetDlgItem(msg->hwnd, cis->CtlID);
                BOOL is_unicode_data = TRUE;
 
                ok(msg->wParam == cis->CtlID, "expected %#x, got %#Ix\n", cis->CtlID, msg->wParam);
                ok(cis->hwndItem == ctrl, "expected %p, got %p\n", ctrl, cis->hwndItem);
                ok((int)cis->itemID1 >= 0, "expected >= 0, got %d\n", cis->itemID1);
                ok((int)cis->itemID2 == -1, "expected -1, got %d\n", cis->itemID2);
 
                sprintf( seq->output, "%s: %p WM_COMPAREITEM: CtlType %#x, CtlID %#x, itemID1 %#x, itemData1 %#Ix, itemID2 %#x, itemData2 %#Ix",
                         msg->descr, msg->hwnd, cis->CtlType, cis->CtlID,
                         cis->itemID1, cis->itemData1, cis->itemID2, cis->itemData2);
 
                if (cis->CtlType == ODT_LISTBOX)
                    is_unicode_data = GetWindowLongA(ctrl, GWL_STYLE) & LBS_HASSTRINGS;
 
                if (is_unicode_data)
                {
                    seq->wParam = cis->itemData1 ? hash_Ly_W((const WCHAR *)cis->itemData1) : 0;
                    seq->lParam = cis->itemData2 ? hash_Ly_W((const WCHAR *)cis->itemData2) : 0;
                }
                else
                {
                    seq->wParam = cis->itemData1 ? hash_Ly((const char *)cis->itemData1) : 0;
                    seq->lParam = cis->itemData2 ? hash_Ly((const char *)cis->itemData2) : 0;
                }
                break;
            }
 
            default:
                if (msg->message >= 0xc000) return;  /* ignore registered messages */
                sprintf( seq->output, "%s: %p %04x wp %08Ix lp %08Ix",
                         msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
            }
            if (msg->flags & (sent|posted|parent|defwinproc|beginpaint))
                sprintf( seq->output + strlen(seq->output), " (flags %x)", msg->flags );
        }
    }
}

◆ apc_test_proc()

static void CALLBACK apc_test_proc ( ULONG_PTR param )

static

Definition at line 5398 of file msg.c.

{
    /* nothing */
}

Referenced by test_MsgWaitForMultipleObjects().

◆ BOOL()

static BOOL ( WINAPI * pTrackMouseEvent )

static

◆ broadcast_test_proc()

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

static

Definition at line 18455 of file msg.c.

{
    WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 
    if (message == g_broadcast_msg)
        g_broadcast_wparam = wParam;
 
    return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
}

Referenced by test_broadcast().

◆ broadcast_test_sub_proc()

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

static

Definition at line 18466 of file msg.c.

{
    int sub_index = GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 
    if (message == g_broadcast_msg)
        g_broadcast_sub_wparam[sub_index] = wParam;
 
    return CallWindowProcA(g_oldproc_sub[sub_index], hwnd, message, wParam, lParam);
}

Referenced by test_broadcast().

◆ button_hook_proc()

static LRESULT CALLBACK button_hook_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 6801 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    switch (message)
    {
    case WM_SYNCPAINT:
        break;
    case BM_SETSTATE:
        if (GetCapture())
            ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
 
        lParam = (ULONG_PTR)GetMenu(hwnd);
        goto log_it;
 
    case WM_GETDLGCODE:
        if (lParam)
        {
            MSG *msg = (MSG *)lParam;
            lParam = MAKELPARAM(msg->message, msg->wParam);
        }
        wParam = (ULONG_PTR)GetMenu(hwnd);
        goto log_it;
 
    case BM_SETCHECK:
    case BM_GETCHECK:
        lParam = (ULONG_PTR)GetMenu(hwnd);
        /* fall through */
log_it:
    default:
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "button";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by subclass_button().

◆ call_window_proc_hook()

static LRESULT WINAPI call_window_proc_hook	(	INT	code,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 20674 of file msg.c.

{
    CWPSTRUCT *cwp = (CWPSTRUCT *)lparam;
 
    ok( cwp->message == WM_USER, "message = %u\n", cwp->message );
    SetWindowLongPtrW( cwp->hwnd, GWLP_WNDPROC, (LONG_PTR)changed_window_proc );
    return CallNextHookEx( NULL, code, wparam, lparam );
}

Referenced by test_hook_changing_window_proc().

◆ callback_count()

static void CALLBACK callback_count	(	HWND	hwnd,
		UINT	uMsg,
		UINT_PTR	idEvent,
		DWORD	dwTime
	)

static

Definition at line 11718 of file msg.c.

{
    timer_fired();
}

Referenced by test_timers(), and test_timers_no_wnd().

◆ callback_exception()

static void CALLBACK callback_exception	(	HWND	hwnd,
		UINT	uMsg,
		UINT_PTR	idEvent,
		DWORD	dwTime
	)

static

Definition at line 11724 of file msg.c.

{
    timer_fired();
    RaiseException(exception, 0, 0, NULL);
}

Referenced by test_timers_exception().

◆ can_skip_message()

static BOOL can_skip_message ( const struct message * expected )

static

Definition at line 2666 of file msg.c.

{
    if (expected->flags & optional) return TRUE;
 
    if ((expected->flags & winevent_hook) && !hEvent_hook) return TRUE;
    if ((expected->flags & kbd_hook) && !hKBD_hook) return TRUE;
    if ((expected->flags & hook) && !hCBT_hook) return TRUE;
 
    if ((expected->flags & msg_todo) && !strcmp(winetest_platform, "wine")) return TRUE;
 
    if ((expected->flags & wine_only) && strcmp(winetest_platform, "wine")) return TRUE;
 
    return FALSE;
}

Referenced by dump_sequence(), messages_equal(), and ok_sequence_().

◆ cancel_init_proc()

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

static

Definition at line 20041 of file msg.c.

{
    if (ignore_message( message )) return 0;
 
    switch (message) {
    case WM_ENTERMENULOOP:
        ok(EndMenu() == TRUE, "EndMenu() failed\n");
        break;
    }
 
    return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
}

Referenced by test_TrackPopupMenu().

◆ cancel_popup_proc()

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

static

Definition at line 20019 of file msg.c.

{
    if (ignore_message( message )) return 0;
 
    switch (message) {
    case WM_ENTERIDLE:
        todo_wine ok(GetCapture() == hwnd, "expected %p, got %p\n", hwnd, GetCapture());
        EndMenu();
        break;
    case WM_INITMENU:
    case WM_INITMENUPOPUP:
    case WM_UNINITMENUPOPUP:
        ok((HMENU)wParam == hpopupmenu, "expected %p, got %Ix\n", hpopupmenu, wParam);
        break;
    case WM_CAPTURECHANGED:
        todo_wine ok(!lParam || (HWND)lParam == hwnd, "lost capture to %Ix\n", lParam);
        break;
    }
 
    return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
}

Referenced by test_TrackPopupMenu(), and test_TrackPopupMenuEmpty().

◆ cbt_global_hook_proc()

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

static

Definition at line 12018 of file msg.c.

{ 
    HWND hwnd;
    char buf[256];
 
    if (nCode == HCBT_SYSCOMMAND)
    {
    struct recvd_message msg;
 
        msg.hwnd = 0;
    msg.message = nCode;
    msg.flags = hook|wparam|lparam;
    msg.wParam = wParam;
    msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
        msg.descr = "CBT_2";
    add_message(&msg);
 
    return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
    }
    /* WH_MOUSE_LL hook */
    if (nCode == HC_ACTION)
    {
        MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
 
        /* we can't test for real mouse events */
        if (mhll->flags & LLMHF_INJECTED)
        {
        struct recvd_message msg;
 
        memset (&msg, 0, sizeof (msg));
        msg.message = wParam;
        msg.flags = hook;
            msg.descr = "CBT_2";
        add_message(&msg);
        }
    return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
    }
 
    /* Log also SetFocus(0) calls */
    hwnd = wParam ? (HWND)wParam : (HWND)lParam;
 
    if (GetClassNameA(hwnd, buf, sizeof(buf)))
    {
    if (!lstrcmpiA(buf, "TestWindowClass") ||
        !lstrcmpiA(buf, "static"))
    {
        struct recvd_message msg;
 
            msg.hwnd = hwnd;
        msg.message = nCode;
        msg.flags = hook|wparam|lparam;
        msg.wParam = wParam;
        msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
            msg.descr = "CBT_2";
        add_message(&msg);
    }
    }
    return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
}

Referenced by test_winevents().

◆ cbt_global_hook_thread_proc()

static DWORD WINAPI cbt_global_hook_thread_proc ( void * param )

static

Definition at line 12105 of file msg.c.

{
    HWND hwnd;
    MSG msg;
    HANDLE hevent = *(HANDLE *)param;
 
    flush_sequence();
    /* these events should be received only by our new hook proc,
     * an old one does not expect an event from another thread.
     */
 
    hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    if (winetest_debug > 1) trace("created thread window %p\n", hwnd);
 
    *(HWND *)param = hwnd;
 
    /* Windows doesn't like when a thread plays games with the focus,
       that leads to all kinds of misbehaviours and failures to activate
       a window. So, better keep next lines commented out.
    SetFocus(0);
    SetFocus(hwnd);*/
 
    DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
    DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
 
    SetEvent(hevent);
 
    while (GetMessageA(&msg, 0, 0, 0))
    {
    TranslateMessage(&msg);
    DispatchMessageA(&msg);
    }
    return 0;
}

Referenced by test_winevents().

◆ cbt_hook_proc()

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

static

Definition at line 11373 of file msg.c.

{ 
    HWND hwnd;
 
    ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
 
    if (nCode == HCBT_CLICKSKIPPED)
    {
        /* ignore this event, XP sends it a lot when switching focus between windows */
    return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
    }
 
    if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
    {
    struct recvd_message msg;
 
        msg.hwnd = 0;
    msg.message = nCode;
    msg.flags = hook|wparam|lparam;
    msg.wParam = wParam;
    msg.lParam = lParam;
        msg.descr = "CBT";
    add_message(&msg);
 
    return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
    }
 
    if (nCode == HCBT_DESTROYWND)
    {
    if (test_DestroyWindow_flag)
    {
        DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
        if (style & WS_CHILD)
        lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
        else if (style & WS_POPUP)
        lParam = WND_POPUP_ID;
        else
        lParam = WND_PARENT_ID;
    }
    }
 
    /* Log also SetFocus(0) calls */
    hwnd = wParam ? (HWND)wParam : (HWND)lParam;
 
    if (is_our_logged_class(hwnd))
    {
        struct recvd_message msg;
 
        msg.hwnd = hwnd;
        msg.message = nCode;
        msg.flags = hook|wparam|lparam;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "CBT";
        add_message(&msg);
    }
    return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
}

Referenced by START_TEST(), and test_set_hook().

◆ changed_window_proc()

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

static

Definition at line 20668 of file msg.c.

{
    if (msg == WM_USER) return 3;
    return DefWindowProcW( hwnd, msg, wparam, lparam );
}

Referenced by call_window_proc_hook().

◆ check_lb_state_dbg()

static void check_lb_state_dbg	(	HWND	listbox,
		int	count,
		int	cur_sel,
		int	caret_index,
		int	top_index,
		int	line
	)

static

Definition at line 17146 of file msg.c.

{
    LRESULT ret;
 
    /* calling an orig proc helps to avoid unnecessary message logging */
    ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
    ok_(__FILE__, line)(ret == count, "expected count %d, got %Id\n", count, ret);
    ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
    ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %Id\n", cur_sel, ret);
    ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
    ok_(__FILE__, line)(ret == caret_index ||
                        broken(cur_sel == -1 && caret_index == 0 && ret == -1),  /* nt4 */
                        "expected caret index %d, got %Id\n", caret_index, ret);
    ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
    ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %Id\n", top_index, ret);
}

◆ check_update_rgn_()

static void check_update_rgn_	(	int	line,
		HWND	hwnd,
		HRGN	hrgn
	)

static

Definition at line 8313 of file msg.c.

{
    INT ret;
    RECT r1, r2;
    HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
    HRGN update = CreateRectRgn( 0, 0, 0, 0 );
 
    ret = GetUpdateRgn( hwnd, update, FALSE );
    ok( ret != ERROR, "GetUpdateRgn failed\n" );
    if (ret == NULLREGION)
    {
        ok_(__FILE__,line)( !hrgn, "Update region shouldn't be empty\n" );
    }
    else
    {
        if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
        {
            ok_(__FILE__,line)( 0, "Regions are different\n" );
            if (winetest_debug > 0)
            {
                printf( "Update region: " );
                dump_region( update );
                printf( "Wanted region: " );
                dump_region( hrgn );
            }
        }
    }
    GetRgnBox( update, &r1 );
    GetUpdateRect( hwnd, &r2, FALSE );
    ok_(__FILE__,line)( EqualRect( &r1, &r2 ), "Rectangles are different: %s / %s\n",
                        wine_dbgstr_rect( &r1 ), wine_dbgstr_rect( &r2 ));
 
    DeleteObject( tmp );
    DeleteObject( update );
}

◆ clear_clipboard_()

static void clear_clipboard_	(	int	line,
		HWND	hWnd
	)

static

Definition at line 18226 of file msg.c.

{
    BOOL succ;
    succ = open_clipboard_(line, hWnd);
    ok_(__FILE__, line)(succ, "OpenClipboard failed, err=%lu\n", GetLastError());
    succ = EmptyClipboard();
    ok_(__FILE__, line)(succ, "EmptyClipboard failed, err=%lu\n", GetLastError());
    succ = CloseClipboard();
    ok_(__FILE__, line)(succ, "CloseClipboard failed, err=%lu\n", GetLastError());
}

◆ combobox_edit_subclass_proc()

static LRESULT CALLBACK combobox_edit_subclass_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 7965 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "combo edit";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = CallWindowProcA(edit_window_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by test_combobox_messages().

◆ combobox_hook_proc()

static LRESULT CALLBACK combobox_hook_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 8030 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "combo";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by subclass_combobox().

◆ combobox_lbox_subclass_proc()

static LRESULT CALLBACK combobox_lbox_subclass_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 7998 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "combo lbox";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = CallWindowProcA(lbox_window_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by test_combobox_messages().

◆ compare_ulonglong()

static int compare_ulonglong	(	const void *	a,
		const void *	b
	)

static

Definition at line 11676 of file msg.c.

{
    ULONGLONG la, lb;
    la = *(ULONGLONG*)a;
    lb = *(ULONGLONG*)b;
    return (la > lb) - (la < lb);
}

Referenced by timer_fired().

◆ create_child_thread()

static DWORD CALLBACK create_child_thread ( void * param )

static

Definition at line 10029 of file msg.c.

{
    struct wnd_event *wnd_event = param;
    struct wnd_event child_event;
    DWORD ret, tid;
    MSG msg;
 
    child_event.hwnd = CreateWindowExA(0, "TestWindowClass", "Test child",
                             WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
    ok (child_event.hwnd != 0, "Failed to create child window\n");
    SetFocus( child_event.hwnd );
    flush_events();
    flush_sequence();
    child_event.start_event = wnd_event->start_event;
    wnd_event->grand_child = CreateThread(NULL, 0, create_grand_child_thread, &child_event, 0, &tid);
    for (;;)
    {
        DWORD ret = MsgWaitForMultipleObjects(1, &child_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
        if (ret != 1) break;
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    }
    ret = WaitForSingleObject( wnd_event->stop_event, 5000 );
    ok( !ret, "WaitForSingleObject failed %lx\n", ret );
    return 0;
}

Referenced by test_interthread_messages().

◆ create_grand_child_thread()

static DWORD CALLBACK create_grand_child_thread ( void * param )

static

Definition at line 10007 of file msg.c.

{
    struct wnd_event *wnd_event = param;
    HWND hchild;
    MSG msg;
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
                             WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    flush_events();
    flush_sequence();
    SetEvent( wnd_event->start_event );
 
    for (;;)
    {
        MsgWaitForMultipleObjects(0, NULL, FALSE, 1000, QS_ALLINPUT);
        if (!IsWindow( hchild )) break;  /* will be destroyed when parent thread exits */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    }
    return 0;
}

Referenced by create_child_thread().

◆ create_manifest_file()

static void create_manifest_file	(	const char *	filename,
		const char *	manifest
	)

static

Definition at line 10071 of file msg.c.

{
    WCHAR path[MAX_PATH];
    HANDLE file;
    DWORD size;
 
    MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
    file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %lu\n", GetLastError());
    WriteFile(file, manifest, strlen(manifest), &size, NULL);
    CloseHandle(file);
}

Referenced by test_interthread_messages().

◆ DispatchMessageCheckProc()

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

static

Definition at line 13058 of file msg.c.

{
    if (message == WM_PAINT) return 0;
    return MsgCheckProcA( hwnd, message, wParam, lParam );
}

Referenced by test_DispatchMessage().

◆ dlg_creation_edit_proc()

static LRESULT WINAPI dlg_creation_edit_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 15756 of file msg.c.

{
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    msg.wParam = wp;
    msg.lParam = lp;
    msg.descr = "edit";
    add_message(&msg);
 
    return CallWindowProcW(orig_edit_proc, hwnd, message, wp, lp);
}

Referenced by test_dlg_proc2(), and test_dlg_proc4().

◆ do_wait_idle_child()

static void do_wait_idle_child ( int arg )

static

Definition at line 18662 of file msg.c.

{
    WNDCLASSA cls;
    MSG msg;
    HWND hwnd = 0;
    HANDLE thread;
    DWORD id;
    HANDLE start_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_start" );
    HANDLE end_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_end" );
 
    memset( &cls, 0, sizeof(cls) );
    cls.lpfnWndProc   = DefWindowProcA;
    cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    cls.hCursor       = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.lpszClassName = "TestClass";
    register_class(&cls);
 
    PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );  /* create the msg queue */
 
    ok( start_event != 0, "failed to create start event, error %lu\n", GetLastError() );
    ok( end_event != 0, "failed to create end event, error %lu\n", GetLastError() );
 
    switch (arg)
    {
    case 0:
        SetEvent( start_event );
        break;
    case 1:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
        break;
    case 2:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
        PostThreadMessageA( GetCurrentThreadId(), WM_COMMAND, 0x1234, 0xabcd );
        PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
        break;
    case 3:
        SetEvent( start_event );
        Sleep( 200 );
        SendMessageA( HWND_BROADCAST, WM_WININICHANGE, 0, 0 );
        break;
    case 4:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
        break;
    case 5:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
        break;
    case 6:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        while (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
        {
            GetMessageA( &msg, 0, 0, 0 );
            DispatchMessageA( &msg );
        }
        break;
    case 7:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        SetTimer( hwnd, 3, 1, NULL );
        Sleep( 200 );
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
        break;
    case 8:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
        MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
        break;
    case 9:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
        for (;;) GetMessageA( &msg, 0, 0, 0 );
        break;
    case 10:
        SetEvent( start_event );
        Sleep( 200 );
        hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
        SetTimer( hwnd, 3, 1, NULL );
        Sleep( 200 );
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
        break;
    case 11:
        SetEvent( start_event );
        Sleep( 200 );
        return;  /* exiting the process makes WaitForInputIdle return success too */
    case 12:
        PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
        Sleep( 200 );
        MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
        SetEvent( start_event );
        break;
    case 13:
        SetEvent( start_event );
        PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
        Sleep( 200 );
        thread = CreateThread( NULL, 0, do_wait_idle_child_thread, NULL, 0, &id );
        WaitForSingleObject( thread, 10000 );
        CloseHandle( thread );
        break;
    case 14:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, HWND_TOPMOST, 0, 0, PM_NOREMOVE );
        break;
    case 15:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, HWND_BROADCAST, 0, 0, PM_NOREMOVE );
        break;
    case 16:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, HWND_BOTTOM, 0, 0, PM_NOREMOVE );
        break;
    case 17:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, (HWND)0xdeadbeef, 0, 0, PM_NOREMOVE );
        break;
    case 18:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, HWND_NOTOPMOST, 0, 0, PM_NOREMOVE );
        break;
    case 19:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, HWND_MESSAGE, 0, 0, PM_NOREMOVE );
        break;
    case 20:
        SetEvent( start_event );
        Sleep( 200 );
        PeekMessageA( &msg, GetDesktopWindow(), 0, 0, PM_NOREMOVE );
        break;
    }
    WaitForSingleObject( end_event, 2000 );
    CloseHandle( start_event );
    CloseHandle( end_event );
    if (hwnd) DestroyWindow( hwnd );
}

Referenced by START_TEST().

◆ do_wait_idle_child_thread()

static DWORD CALLBACK do_wait_idle_child_thread ( void * arg )

static

Definition at line 18652 of file msg.c.

{
    MSG msg;
 
    PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
    Sleep( 200 );
    MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
    return 0;
}

Referenced by do_wait_idle_child().

◆ dump_region()

void dump_region ( HRGN hrgn )

Definition at line 8291 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 = malloc( size ))) return;
    GetRegionData( hrgn, size, data );
    printf("%ld 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");
    free( data );
}

Referenced by check_update_rgn_(), subtest_hvredraw(), subtest_swp_paint_regions_(), test_scrolldc(), test_scrollvalidate(), test_swp_paint_region_on_extend_zerosize(), and test_swp_paint_region_on_show().

◆ dump_sequence()

static void dump_sequence	(	const struct message *	expected,
		const char *	context,
		const char *	file,
		int	line
	)

static

Definition at line 2745 of file msg.c.

{
    const struct recvd_message *actual = sequence;
    unsigned int count = 0;
 
    trace_(file, line)("Failed sequence %s:\n", context );
    while (expected->message && actual->message)
    {
        if (actual->output[0])
        {
            trace_(file, line)( "  %u: expected: %s %04x - actual: %s\n",
                                count, message_type_name(expected->flags), expected->message, actual->output );
        }
 
        if (messages_equal(expected, actual, FALSE, file, line))
        {
            expected++;
            actual++;
            count++;
        }
        else if (can_skip_message(expected) || sequence_contains_message(expected, actual))
    {
            expected++;
            count++;
        }
        else
        {
            actual++;
        }
    }
 
    /* optional trailing messages */
    while (can_skip_message(expected))
    {
        trace_(file, line)( "  %u: expected: msg %04x - actual: nothing\n", count, expected->message );
    expected++;
        count++;
    }
 
    if (expected->message)
    {
        trace_(file, line)( "  %u: expected: msg %04x - actual: nothing\n", count, expected->message );
        return;
    }
 
    while (actual->message && actual->output[0])
    {
        trace_(file, line)( "  %u: expected: nothing - actual: %s\n", count, actual->output );
        actual++;
        count++;
    }
}

Referenced by ok_sequence_().

◆ edit_hook_proc()

static LRESULT CALLBACK edit_hook_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 13405 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "edit";
    add_message(&msg);
 
    defwndproc_counter++;
    ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by subclass_edit().

◆ edit_ime_subclass_proc()

static LRESULT CALLBACK edit_ime_subclass_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 13482 of file msg.c.

{
    WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
    static LONG defwndproc_counter = 0;
    struct recvd_message msg = {0};
    LRESULT ret;
 
    msg.message = message;
    msg.flags = sent | wparam;
    if (defwndproc_counter)
        msg.flags |= defwinproc;
    msg.wParam = wParam;
 
    if (message < 0xc000 &&
        message != WM_GETTEXTLENGTH &&
        message != WM_GETTEXT &&
        message != WM_GETFONT &&
        message != WM_GETICON &&
        message != WM_IME_SETCONTEXT &&
        message != WM_IME_NOTIFY &&
        message != WM_CTLCOLOREDIT &&
        message != WM_PAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_SETCURSOR &&
        message != WM_MOUSEMOVE &&
        message != WM_MOUSEACTIVATE &&
        message != WM_KEYUP &&
        (message < EM_GETSEL || message > EM_GETIMESTATUS))
    {
        add_message(&msg);
    }
 
    defwndproc_counter++;
    if (IsWindowUnicode(hwnd))
        ret = CallWindowProcW(oldproc, hwnd, message, wParam, lParam);
    else
        ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by test_edit_ime_messages().

◆ expect_HWND_()

static void expect_HWND_	(	int	line,
		HWND	expected,
		HWND	got
	)

static

Definition at line 18238 of file msg.c.

{
    ok_(__FILE__, line)(got==expected, "Expected %p, got %p\n", expected, got);
}

◆ flush_events()

static void flush_events ( void )

static

Definition at line 2635 of file msg.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;
        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
        diff = time - GetTickCount();
    }
}

Referenced by create_child_thread(), create_grand_child_thread(), invisible_parent_tests(), subtest_hvredraw(), subtest_swp_paint_regions_(), test_accelerators(), test_autoradio_BM_CLICK(), test_autoradio_kbd_move(), test_broadcast(), test_button_messages(), test_dbcs_wm_char(), test_defwinproc(), test_DispatchMessage(), test_DoubleSetCapture(), test_hotkey(), test_interthread_messages(), test_keyflags(), test_layered_window(), test_menu_messages(), test_messages(), test_msg_setpos_(), test_notify_message(), test_nullCallback(), test_paint_messages(), test_PeekMessage(), test_PeekMessage2(), test_PeekMessage3(), test_PostMessage(), test_quit_message(), test_radiobutton_focus(), test_recursive_hook(), test_recursive_messages(), test_restore_messages(), test_scroll_messages(), test_scrollwindowex(), test_SendMessage_other_thread(), test_SendMessageTimeout(), test_SetFocus(), test_SetParent(), test_setwindowpos(), test_SetWindowRgn(), test_showwindow(), test_ShowWindow(), test_swp_paint_region_on_extend_zerosize(), test_swp_paint_region_on_show(), test_TrackMouseEvent(), test_TrackPopupMenu(), test_TrackPopupMenuEmpty(), test_WM_SETREDRAW(), and test_wmime_keydown_message().

◆ flush_sequence()

static void flush_sequence ( void )

static

Definition at line 2650 of file msg.c.

{
    EnterCriticalSection( &sequence_cs );
    free( sequence );
    sequence = 0;
    sequence_cnt = sequence_size = 0;
    LeaveCriticalSection( &sequence_cs );
}

Referenced by cbt_global_hook_thread_proc(), create_child_thread(), create_grand_child_thread(), invisible_parent_tests(), mouse_ll_global_thread_proc(), ok_sequence_(), test_accelerators(), test_autoradio_BM_CLICK(), test_autoradio_kbd_move(), test_button_messages(), test_clipboard_viewers(), test_combobox_messages(), test_dbcs_wm_char(), test_defwinproc(), test_DestroyWindow(), test_dialog_messages(), test_DispatchMessage(), test_DoubleSetCapture(), test_edit_ime_messages(), test_edit_messages(), test_EndDialog(), test_enddialog_seq(), test_enddialog_seq2(), test_hotkey(), test_interthread_messages(), test_keyflags(), test_layered_window(), test_listbox_messages(), test_mdi_messages(), test_menu_messages(), test_message_conversion(), test_messages(), test_msg_setpos_(), test_notify_message(), test_paint_messages(), test_PeekMessage(), test_quit_message(), test_radiobutton_focus(), test_restore_messages(), test_scroll_messages(), test_scrollwindowex(), test_SendMessage_other_thread(), test_SendMessageTimeout(), test_SetActiveWindow(), test_SetFocus(), test_SetForegroundWindow(), test_SetParent(), test_setwindowpos(), test_SetWindowRgn(), test_showwindow(), test_ShowWindow(), test_static_messages(), test_sys_menu(), test_TrackMouseEvent(), test_TrackPopupMenu(), test_TrackPopupMenuEmpty(), test_unicode_wm_char(), test_winevents(), test_WM_SETREDRAW(), test_wmime_keydown_message(), and win_event_global_thread_proc().

◆ get_input_codepage()

static DWORD get_input_codepage ( void )

static

Definition at line 16553 of file msg.c.

{
    DWORD cp;
    int ret;
    HKL hkl = GetKeyboardLayout( 0 );
 
    ret = GetLocaleInfoW( LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
                          (WCHAR *)&cp, sizeof(cp) / sizeof(WCHAR) );
    if (!ret) cp = CP_ACP;
    return cp;
}

Referenced by test_dbcs_wm_char().

◆ get_menu_style()

static DWORD get_menu_style ( HMENU hmenu )

static

Definition at line 17619 of file msg.c.

{
    MENUINFO mi;
    BOOL ret;
 
    mi.cbSize = sizeof(mi);
    mi.fMask = MIM_STYLE;
    mi.dwStyle = 0;
    SetLastError(0xdeadbeef);
    ret = GetMenuInfo(hmenu, &mi);
    ok(ret, "GetMenuInfo error %lu\n", GetLastError());
 
    return mi.dwStyle;
}

Referenced by test_menu_messages().

◆ get_test_dll_path()

static char * get_test_dll_path ( void )

static

Definition at line 12377 of file msg.c.

{
    static const char *dll_name = "testdll.dll";
    static char path[MAX_PATH];
    DWORD written;
    HANDLE file;
    HRSRC res;
    void *ptr;
 
    GetTempPathA(ARRAY_SIZE(path), path);
    strcat(path, dll_name);
 
    file = CreateFileA(path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
    ok(file != INVALID_HANDLE_VALUE, "Failed to create file %s: %lu.\n", debugstr_a(path), GetLastError());
 
    res = FindResourceA(NULL, dll_name, "TESTDLL");
#ifdef __REACTOS__
    ok(!!res || broken(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND) /* WS03 */, "Failed to load resource: %lu\n", GetLastError());
#else
    ok(!!res, "Failed to load resource: %lu\n", GetLastError());
#endif
    ptr = LockResource(LoadResource(GetModuleHandleA(NULL), res));
    WriteFile(file, ptr, SizeofResource(GetModuleHandleA(NULL), res), &written, NULL);
    ok(written == SizeofResource(GetModuleHandleA(NULL), res), "Failed to write resource\n");
    CloseHandle(file);
 
    return path;
}

Referenced by test_set_hook().

◆ get_text_len_proc()

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

static

Definition at line 11502 of file msg.c.

{
    switch(msg)
    {
    case WM_GETTEXTLENGTH:
        return lstrlenW(dummy_window_text) + 37;  /* some random length */
    case WM_GETTEXT:
        lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
        return lstrlenW( (LPWSTR)lp );
    default:
        return DefWindowProcW( hwnd, msg, wp, lp );
    }
}

Referenced by test_message_conversion().

◆ get_winpos_flags()

static const char * get_winpos_flags ( UINT flags )

static

Definition at line 2379 of file msg.c.

{
    static char buffer[300];
 
    buffer[0] = 0;
#define DUMP(flag) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)
    DUMP( SWP_SHOWWINDOW );
    DUMP( SWP_HIDEWINDOW );
    DUMP( SWP_NOACTIVATE );
    DUMP( SWP_FRAMECHANGED );
    DUMP( SWP_NOCOPYBITS );
    DUMP( SWP_NOOWNERZORDER );
    DUMP( SWP_NOSENDCHANGING );
    DUMP( SWP_DEFERERASE );
    DUMP( SWP_ASYNCWINDOWPOS );
    DUMP( SWP_NOZORDER );
    DUMP( SWP_NOREDRAW );
    DUMP( SWP_NOSIZE );
    DUMP( SWP_NOMOVE );
    DUMP( SWP_NOCLIENTSIZE );
    DUMP( SWP_NOCLIENTMOVE );
    if (flags) sprintf(buffer + strlen(buffer),"|0x%04x", flags);
    return buffer + 1;
#undef DUMP
}

Referenced by add_message_().

◆ hash_Ly()

static unsigned hash_Ly ( const char * str )

static

Definition at line 2428 of file msg.c.

{
    unsigned hash = 0;
 
    for (; *str; str++)
        hash = hash * 1664525u + (unsigned char)(*str) + 1013904223u;
 
    return hash;
}

Referenced by add_message_(), and listbox_hook_proc().

◆ hash_Ly_W()

static unsigned hash_Ly_W ( const WCHAR * str )

static

Definition at line 2418 of file msg.c.

{
    unsigned hash = 0;
 
    for (; *str; str++)
        hash = hash * 1664525u + (unsigned char)(*str) + 1013904223u;
 
    return hash;
}

Referenced by add_message_().

◆ hide_window_thread()

static DWORD CALLBACK hide_window_thread ( LPVOID arg )

static

Definition at line 5518 of file msg.c.

{
   HWND hwnd = arg;
 
   /* function will not return if ShowWindow(SW_HIDE) calls SendMessage() */
   ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
 
   return 0;
}

Referenced by test_messages().

◆ HotkeyMsgCheckProcA()

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

static

Definition at line 11227 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
    DWORD queue_status;
 
    if (ignore_message( message )) return 0;
 
    if ((message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
        message == WM_HOTKEY || message >= WM_APP)
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "HotkeyMsgCheckProcA";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    if (message == WM_APP)
    {
        queue_status = GetQueueStatus(QS_HOTKEY);
        ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
        queue_status = GetQueueStatus(QS_POSTMESSAGE);
        ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %lx\n", queue_status);
        PostMessageA(hwnd, WM_APP+1, 0, 0);
    }
    else if (message == WM_APP+1)
    {
        queue_status = GetQueueStatus(QS_HOTKEY);
        ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %lx\n", queue_status);
    }
 
    return ret;
}

Referenced by register_classes().

◆ HWINEVENTHOOK()

static HWINEVENTHOOK ( WINAPI * pSetWinEventHook )

static

Referenced by NtUserSetWinEventHook(), test_hook_cleanup_thread_proc(), test_set_hook(), test_winevents(), and uia_event_thread_proc().

◆ ignore_message()

static BOOL ignore_message ( UINT message )

static

Definition at line 2405 of file msg.c.

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

Referenced by button_hook_proc(), cancel_init_proc(), cancel_popup_proc(), combobox_edit_subclass_proc(), combobox_hook_proc(), combobox_lbox_subclass_proc(), dlg_creation_edit_proc(), edit_hook_proc(), HotkeyMsgCheckProcA(), listbox_hook_proc(), mdi_child_wnd_proc(), mdi_client_hook_proc(), mdi_frame_wnd_proc(), minimize_popup_proc(), MsgCheckProc(), ParentMsgCheckProcA(), PopupMsgCheckProcA(), pump_msg_loop(), static_hook_proc(), test_dlg_proc(), test_dlg_proc2(), test_dlg_proc4(), test_SendMessage_other_thread(), test_unicode_wm_char(), TestDlgProcA(), TestModalDlgProc2(), TestModalDlgProcA(), and wm_quit_dlg_proc().

◆ init_procs()

static void init_procs ( void )

static

Definition at line 2354 of file msg.c.

{
    HMODULE user32 = GetModuleHandleA("user32.dll");
    HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
 
#define GET_PROC(dll, func) \
    p ## func = (void*)GetProcAddress(dll, #func); \
    if(!p ## func) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }
 
    GET_PROC(user32, NotifyWinEvent)
    GET_PROC(user32, SetWinEventHook)
    GET_PROC(user32, TrackMouseEvent)
    GET_PROC(user32, UnhookWinEvent)
    GET_PROC(user32, UpdateLayeredWindow)
    GET_PROC(user32, SetSystemTimer)
    GET_PROC(user32, KillSystemTimer)
    GET_PROC(user32, SetCoalescableTimer)
 
    GET_PROC(kernel32, GetCPInfoExA)
 
#undef GET_PROC
}

Referenced by START_TEST().

◆ insendmessage_wnd_proc()

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

static

Definition at line 20344 of file msg.c.

{
    DWORD flags = InSendMessageEx( NULL );
    BOOL ret;
 
    switch (msg)
    {
    case WM_USER:
        ok( flags == ISMEX_SEND, "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        ret = ReplyMessage( msg );
        ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
        flags = InSendMessageEx( NULL );
        ok( flags == (ISMEX_SEND | ISMEX_REPLIED) || broken( flags == (ISMEX_NOTIFY | ISMEX_REPLIED) ),
            "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        break;
    case WM_USER + 1:
        ok( flags == ISMEX_NOTIFY, "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        ret = ReplyMessage( msg );
        ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
        flags = InSendMessageEx( NULL );
        ok( flags == ISMEX_NOTIFY, "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        break;
    case WM_USER + 2:
        ok( flags == ISMEX_CALLBACK, "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        ret = ReplyMessage( msg );
        ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
        flags = InSendMessageEx( NULL );
        ok( flags == (ISMEX_CALLBACK | ISMEX_REPLIED) || flags == ISMEX_SEND, "wrong flags %lx\n", flags );
        ok( InSendMessage(), "InSendMessage returned false\n" );
        break;
    case WM_USER + 3:
        ok( flags == ISMEX_NOSEND, "wrong flags %lx\n", flags );
        ok( !InSendMessage(), "InSendMessage returned true\n" );
        ret = ReplyMessage( msg );
        ok( !ret, "ReplyMessage succeeded\n" );
        break;
    }
 
    return DefWindowProcA( hwnd, msg, wp, lp );
}

Referenced by test_InSendMessage().

◆ invisible_parent_tests()

static void invisible_parent_tests ( void )

static

Definition at line 6289 of file msg.c.

{
    HWND hparent, hchild;
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
    flush_sequence();
 
    /* test showing child with hidden parent */
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
 
    ShowWindow( hchild, SW_MINIMIZE );
    ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_MINIMIZE );
    ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_MAXIMIZE );
    ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_MAXIMIZE );
    ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_RESTORE );
    ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_SHOWMINIMIZED );
    ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_SHOWMINIMIZED );
    ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
    ShowWindow( hchild, SW_SHOWMAXIMIZED );
    ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_SHOWMINNOACTIVE );
    ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_SHOWMINNOACTIVE );
    ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
    ShowWindow( hchild, SW_FORCEMINIMIZE );
    ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
todo_wine {
    ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
}
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_SHOWNA );
    ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_SHOWNA );
    ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
 
    DestroyWindow(hchild);
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    flush_sequence();
 
    ShowWindow( hchild, SW_SHOW );
    ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    /* repeat */
    flush_events();
    flush_sequence();
    ShowWindow( hchild, SW_SHOW );
    ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
 
    ShowWindow( hchild, SW_HIDE );
    ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
    ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
    ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
    ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
    ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
    ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
 
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
    flush_sequence();
    DestroyWindow(hchild);
    ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
 
    DestroyWindow(hparent);
    flush_sequence();
}

Referenced by START_TEST().

◆ is_our_logged_class()

static BOOL is_our_logged_class ( HWND hwnd )

static

Definition at line 11345 of file msg.c.

{
    char buf[256];
 
    if (GetClassNameA(hwnd, buf, sizeof(buf)))
    {
    if (!lstrcmpiA(buf, "TestWindowClass") ||
        !lstrcmpiA(buf, "ShowWindowClass") ||
        !lstrcmpiA(buf, "TestParentClass") ||
        !lstrcmpiA(buf, "TestPopupClass") ||
        !lstrcmpiA(buf, "SimpleWindowClass") ||
        !lstrcmpiA(buf, "TestDialogClass") ||
        !lstrcmpiA(buf, "MDI_frame_class") ||
        !lstrcmpiA(buf, "MDI_client_class") ||
        !lstrcmpiA(buf, "MDI_child_class") ||
        !lstrcmpiA(buf, "my_button_class") ||
        !lstrcmpiA(buf, "my_edit_class") ||
        !lstrcmpiA(buf, "static") ||
        !lstrcmpiA(buf, "ListBox") ||
        !lstrcmpiA(buf, "ComboBox") ||
        !lstrcmpiA(buf, "MyDialogClass") ||
        !lstrcmpiA(buf, "#32770") ||
        !lstrcmpiA(buf, "#32768"))
        return TRUE;
    }
    return FALSE;
}

Referenced by cbt_hook_proc(), and win_event_proc().

◆ keyboard_recursive_cbt_hook_proc()

static LRESULT CALLBACK keyboard_recursive_cbt_hook_proc	(	int	code,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 12644 of file msg.c.

{
    MSG msg;
 
    if (code < 0)
        return CallNextHookEx(0, code, wp, lp);
 
    if (code == HCBT_KEYSKIPPED)
    {
        hook_depth++;
        max_hook_depth = max(max_hook_depth, hook_depth);
        PeekMessageW(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE);
        hook_depth--;
    }
 
    return CallNextHookEx(0, code, wp, lp);
}

Referenced by test_recursive_hook().

◆ keyboard_recursive_hook_proc()

static LRESULT CALLBACK keyboard_recursive_hook_proc	(	int	code,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 12610 of file msg.c.

{
    MSG msg;
 
    if (code < 0)
        return CallNextHookEx(0, code, wp, lp);
 
    if (skip_WH_KEYBOARD_hook)
        return 1;
 
    hook_depth++;
    max_hook_depth = max(max_hook_depth, hook_depth);
    PeekMessageW(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE);
    hook_depth--;
    return CallNextHookEx(0, code, wp, lp);
}

Referenced by test_recursive_hook().

◆ KeyboardHookProc()

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

static

Definition at line 19249 of file msg.c.

{
    struct recvd_message msg;
 
    if (nCode == HC_ACTION)
    {
        KBDLLHOOKSTRUCT *kdbhookstruct = (KBDLLHOOKSTRUCT*)lParam;
 
        msg.hwnd = 0;
        msg.message = wParam;
        msg.flags = kbd_hook|wparam|lparam;
        msg.wParam = kdbhookstruct->vkCode;
        msg.lParam = kdbhookstruct->flags;
        msg.descr = "KeyboardHookProc";
        add_message(&msg);
 
        if (wParam == WM_KEYUP || wParam == WM_KEYDOWN ||
            wParam == WM_SYSKEYUP || wParam == WM_SYSKEYDOWN)
        {
            ok(kdbhookstruct->vkCode == VK_LWIN ||
               kdbhookstruct->vkCode == VK_LMENU ||
               kdbhookstruct->vkCode == hotkey_letter,
               "unexpected keycode %lx\n", kdbhookstruct->vkCode);
       }
    }
 
    return CallNextHookEx(hKBD_hook, nCode, wParam, lParam);
}

Referenced by DlgMainProc(), and test_hotkey().

◆ listbox_hook_proc()

static LRESULT WINAPI listbox_hook_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 17111 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wp;
        if (message == LB_ADDSTRING)
            msg.lParam = lp ? hash_Ly((const char *)lp) : 0;
        else
            msg.lParam = lp;
        msg.descr = "listbox";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
    defwndproc_counter--;
 
    return ret;
}

Referenced by test_listbox_messages().

◆ LRESULT()

static LRESULT ( WINAPI * listbox_orig_proc )

static

◆ mdi_child_wnd_proc()

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

static

Definition at line 4067 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        !ignore_message( message ))
    {
        switch (message)
        {
            case WM_MDIACTIVATE:
            {
                HWND active, client = GetParent(hwnd);
 
                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;
            }
        }
 
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "mdi child";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by mdi_register_classes().

◆ mdi_client_hook_proc()

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

static

Definition at line 4041 of file msg.c.

{
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        message != WM_MDIGETACTIVE &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "mdi client";
        add_message(&msg);
    }
 
    return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
}

Referenced by mdi_register_classes().

◆ mdi_frame_wnd_proc()

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

static

Definition at line 4115 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_NCPAINT &&
        message != WM_SYNCPAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        !ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "mdi frame";
        add_message(&msg);
    }
 
    defwndproc_counter++;
    ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by mdi_register_classes().

◆ mdi_register_classes()

static void mdi_register_classes ( void )

static

Definition at line 4147 of file msg.c.

{
    WNDCLASSA cls;
    BOOL ret;
 
    cls.style = 0;
    cls.lpfnWndProc = mdi_frame_wnd_proc;
    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_frame_class";
    register_class(&cls);
 
    cls.lpfnWndProc = mdi_child_wnd_proc;
    cls.lpszClassName = "MDI_child_class";
    register_class(&cls);
 
    ret = GetClassInfoA(0, "MDIClient", &cls);
    ok(ret, "Failed to get class info, error %lu.\n", GetLastError());
    old_mdi_client_proc = cls.lpfnWndProc;
    cls.hInstance = GetModuleHandleA(0);
    cls.lpfnWndProc = mdi_client_hook_proc;
    cls.lpszClassName = "MDI_client_class";
    register_class(&cls);
}

Referenced by test_mdi_messages().

◆ message_type_name()

static const char * message_type_name ( int flags )

static

Definition at line 2659 of file msg.c.

                                                {
    if (flags & hook) return "hook";
    if (flags & kbd_hook) return "kbd_hook";
    if (flags & winevent_hook) return "winevent_hook";
    return "msg";
}

Referenced by dump_sequence(), and messages_equal().

◆ messages_equal()

static BOOL messages_equal	(	const struct message *	expected,
		const struct recvd_message *	actual,
		BOOL	expect_equal,
		const char *	file,
		int	line
	)

static

Definition at line 2681 of file msg.c.

{
    int todo = (expected->flags & msg_todo) != 0;
    int msg_wine_only = (expected->flags & wine_only) != 0;
    const int message_type_flags = hook|winevent_hook|kbd_hook;
    static int todo_reported;
 
    if (!todo && can_skip_message(expected))
        expect_equal = FALSE;
 
    if (msg_wine_only && strcmp(winetest_platform, "wine"))
    {
        /* Ignore Wine-only message records on Windows. */
        return FALSE;
    }
 
    if (!expected->message || !actual->message) {
        if (expect_equal && (!todo || !todo_reported++))
            todo_wine_if(todo || msg_wine_only)
            ok_( file, line) (msg_wine_only, "the msg sequence is not complete: expected %s %04x - actual %s %04x\n",
                              message_type_name(expected->flags), expected->message, message_type_name(actual->flags), actual->message);
        return FALSE;
    }
 
    if (expected->message != actual->message ||
        (expected->flags & message_type_flags) != (actual->flags & message_type_flags))
    {
        if (expect_equal && (!todo || !todo_reported++))
            todo_wine_if(todo || msg_wine_only)
            ok_( file, line) (msg_wine_only, "the %s 0x%04x was expected, but got %s 0x%04x instead\n",
                              message_type_name(expected->flags), expected->message, message_type_name(actual->flags), actual->message);
        return FALSE;
    }
 
    if (expected->flags & optional)
    {
        /* If a message can be sent in 2 different ways at the same time, we may need to treat
         * them as unequal so that the optional message can be properly skipped. */
        if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) {
            /* don't match messages if their defwinproc status differs */
            return FALSE;
        }
    }
 
    if (expect_equal)
        todo_wine_if(todo || msg_wine_only)
        ok_( file, line) (!msg_wine_only, "got %s 0x%04x as expected\n",
                          message_type_name(expected->flags), expected->message);
 
    return TRUE;
}

Referenced by dump_sequence(), ok_sequence_(), and sequence_contains_message().

◆ minimize_popup_proc()

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

static

Definition at line 20000 of file msg.c.

{
    LRESULT ret;
 
    if (ignore_message( message )) return 0;
    ret = MsgCheckProc( FALSE, hwnd, message, wParam, lParam );
 
    switch (message) {
    case WM_ENTERIDLE:
        ShowWindow(hwnd, SW_MINIMIZE);
        break;
    case WM_TIMER:
        EndMenu();
        break;
    }
 
    return ret;
}

Referenced by test_TrackPopupMenu().

◆ mouse_ll_global_thread_proc()

static DWORD WINAPI mouse_ll_global_thread_proc ( void * param )

static

Definition at line 12141 of file msg.c.

{
    HWND hwnd;
    MSG msg;
    HANDLE hevent = *(HANDLE *)param;
 
    hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    if (winetest_debug > 1) trace("created thread window %p\n", hwnd);
 
    *(HWND *)param = hwnd;
 
    flush_sequence();
 
    /* Windows doesn't like when a thread plays games with the focus,
     * that leads to all kinds of misbehaviours and failures to activate
     * a window. So, better don't generate a mouse click message below.
     */
    mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
    mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
 
    SetEvent(hevent);
    while (GetMessageA(&msg, 0, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
    return 0;
}

Referenced by test_winevents().

◆ mouse_recursive_cbt_hook_proc()

static LRESULT CALLBACK mouse_recursive_cbt_hook_proc	(	int	code,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 12662 of file msg.c.

{
    MSG msg;
 
    if (code < 0)
        return CallNextHookEx(0, code, wp, lp);
 
    if (code == HCBT_CLICKSKIPPED)
    {
        hook_depth++;
        max_hook_depth = max(max_hook_depth, hook_depth);
        PeekMessageW(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE);
        hook_depth--;
    }
 
    return CallNextHookEx(0, code, wp, lp);
}

Referenced by test_recursive_hook().

◆ mouse_recursive_hook_proc()

static LRESULT CALLBACK mouse_recursive_hook_proc	(	int	code,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 12627 of file msg.c.

{
    MSG msg;
 
    if (code < 0)
        return CallNextHookEx(0, code, wp, lp);
 
    if (skip_WH_MOUSE_hook)
        return 1;
 
    hook_depth++;
    max_hook_depth = max(max_hook_depth, hook_depth);
    PeekMessageW(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE);
    hook_depth--;
    return CallNextHookEx(0, code, wp, lp);
}

Referenced by test_recursive_hook().

◆ msg_callback()

static void CALLBACK msg_callback	(	HWND	hwnd,
		UINT	msg,
		ULONG_PTR	arg,
		LRESULT	result
	)

static

Definition at line 20390 of file msg.c.

{
    ok( msg == WM_USER + 2, "wrong msg %x\n", msg );
    ok( result == WM_USER + 2, "wrong result %Ix\n", result );
}

Referenced by send_message_thread().

◆ MsgCheckProc()

static LRESULT MsgCheckProc	(	BOOL	unicode,
		HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 10849 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    static LONG beginpaint_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    switch (message)
    {
    case WM_ENABLE:
    {
        LONG style = GetWindowLongA(hwnd, GWL_STYLE);
        ok((BOOL)wParam == !(style & WS_DISABLED),
        "wrong WS_DISABLED state: %Id != %d\n", wParam, !(style & WS_DISABLED));
        break;
    }
 
    case WM_CAPTURECHANGED:
        if (test_DestroyWindow_flag)
        {
        DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
        if (style & WS_CHILD)
            lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
        else if (style & WS_POPUP)
            lParam = WND_POPUP_ID;
        else
            lParam = WND_PARENT_ID;
        }
        break;
 
    case WM_NCDESTROY:
    {
        HWND capture;
 
        ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
        capture = GetCapture();
        if (capture)
        {
        ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
        if (winetest_debug > 1) trace("current capture %p, releasing...\n", capture);
        ReleaseCapture();
        }
    }
    /* fall through */
    case WM_DESTROY:
        ok(GetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
        if (test_DestroyWindow_flag)
        {
        DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
        if (style & WS_CHILD)
            lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
        else if (style & WS_POPUP)
            lParam = WND_POPUP_ID;
        else
            lParam = WND_PARENT_ID;
        }
        break;
 
    /* test_accelerators() depends on this */
    case WM_NCHITTEST:
        return HTCLIENT;
 
    case WM_USER+10:
    {
        ACTIVATION_CONTEXT_BASIC_INFORMATION basicinfo;
        HANDLE handle, event = (HANDLE)lParam;
        BOOL ret;
 
        handle = (void*)0xdeadbeef;
        ret = GetCurrentActCtx(&handle);
        ok(ret, "failed to get current context, %lu\n", GetLastError());
        ok(handle == 0, "got active context %p\n", handle);
 
        memset(&basicinfo, 0xff, sizeof(basicinfo));
        ret = QueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, handle, 0, ActivationContextBasicInformation,
            &basicinfo, sizeof(basicinfo), NULL);
        ok(ret, "got %d, error %ld\n", ret, GetLastError());
        ok(basicinfo.hActCtx == NULL, "got %p\n", basicinfo.hActCtx);
        ok(basicinfo.dwFlags == 0, "got %lx\n", basicinfo.dwFlags);
 
        if (event) SetEvent(event);
        return 1;
    }
 
    /* ignore */
    case WM_MOUSEMOVE:
    case WM_MOUSEACTIVATE:
    case WM_NCMOUSEMOVE:
    case WM_SETCURSOR:
    case WM_IME_SELECT:
        if (ignore_mouse_messages) return 0;
        break;
    }
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    if (beginpaint_counter) msg.flags |= beginpaint;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "MsgCheckProc";
    add_message(&msg);
 
    if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
    {
    HWND parent = GetParent(hwnd);
    RECT rc;
    MINMAXINFO *minmax = (MINMAXINFO *)lParam;
 
    GetClientRect(parent, &rc);
    if (winetest_debug > 1)
        {
            trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
            trace("Reserved=%ld,%ld MaxSize=%ld,%ld MaxPos=%ld,%ld MinTrack=%ld,%ld MaxTrack=%ld,%ld\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);
        }
    ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %ld != %ld\n",
       minmax->ptMaxSize.x, rc.right);
    ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %ld != %ld\n",
       minmax->ptMaxSize.y, rc.bottom);
    }
 
    if (message == WM_PAINT)
    {
        PAINTSTRUCT ps;
        beginpaint_counter++;
        BeginPaint( hwnd, &ps );
        beginpaint_counter--;
        EndPaint( hwnd, &ps );
        return 0;
    }
 
    if (!test_context_menu && message == WM_CONTEXTMENU)
    {
        /* don't create context menu */
        return 0;
    }
 
    defwndproc_counter++;
    ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam) 
          : DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by cancel_init_proc(), cancel_popup_proc(), minimize_popup_proc(), MsgCheckProcA(), and MsgCheckProcW().

◆ MsgCheckProcA()

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

static

Definition at line 11003 of file msg.c.

{
    return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
}

Referenced by DispatchMessageCheckProc(), register_classes(), and send_msg_delay_proc().

◆ MsgCheckProcW()

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

static

Definition at line 11008 of file msg.c.

{
    return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
}

Referenced by register_classes().

◆ MsgConversionProcW()

static LRESULT CALLBACK MsgConversionProcW	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 11464 of file msg.c.

{
    const DEV_BROADCAST_DEVICEINTERFACE_A *ifaceA = (const void *)lParam;
 
    switch (uMsg)
    {
    case CB_FINDSTRINGEXACT:
        if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
            return 1;
        if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
            return 0;
        return -1;
 
    case WM_DEVICECHANGE:
        if (wParam == DBT_DEVICEARRIVAL && IsEqualGUID(&ifaceA->dbcc_classguid, &iface_guid))
        {
            DWORD expect_size = offsetof(DEV_BROADCAST_DEVICEINTERFACE_A, dbcc_name[strlen(ifaceA->dbcc_name)]);
 
            ok(ifaceA->dbcc_size == expect_size, "Expected %lu, got %lu.\n", expect_size, ifaceA->dbcc_size);
            ok(ifaceA->dbcc_devicetype == DBT_DEVTYP_DEVICEINTERFACE,
                    "Got notification type %#lx.\n", ifaceA->dbcc_devicetype);
            ok(!ifaceA->dbcc_reserved, "Got reserved %#lx.\n", ifaceA->dbcc_reserved);
            ok(!strcmp(ifaceA->dbcc_name, "test name"), "Got name %s.\n", debugstr_a(ifaceA->dbcc_name));
            return 2;
        }
    }
    return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}

Referenced by test_message_conversion().

◆ ok_sequence_()

static void ok_sequence_	(	const struct message *	expected_list,
		const char *	context,
		BOOL	todo,
		const char *	file,
		int	line
	)

static

Definition at line 2802 of file msg.c.

{
    static const struct recvd_message end_of_sequence;
    const struct message *expected = expected_list;
    const struct recvd_message *actual;
    int failcount = 0, dump = 0;
    unsigned int count = 0;
    BOOL is_wine = !strcmp(winetest_platform, "wine");
 
    add_message(&end_of_sequence);
 
    actual = sequence;
 
    winetest_push_context("%s: %u", context, count);
 
    while (expected->message && actual->message)
    {
    if (messages_equal(expected, actual, !todo, file, line))
    {
        if (expected->flags & wparam)
        {
        if (((expected->wParam ^ actual->wParam) & ~expected->wp_mask) && todo)
        {
            todo_wine {
                        failcount ++;
                        dump++;
                        ok_( file, line) (FALSE,
                "in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
                            expected->message, expected->wParam, actual->wParam);
            }
                    if (is_wine) goto done;
        }
        else
                {
                    ok_( file, line)( ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) == 0,
                                     "in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
                                     expected->message, expected->wParam, actual->wParam);
                    if ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) dump++;
                }
 
        }
        if (expected->flags & lparam)
            {
        if (((expected->lParam ^ actual->lParam) & ~expected->lp_mask) && todo)
        {
            todo_wine {
                        failcount ++;
                        dump++;
                        ok_( file, line) (FALSE,
                "in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
                            expected->message, expected->lParam, actual->lParam);
            }
                    if (is_wine) goto done;
        }
        else
                {
                    ok_( file, line)(((expected->lParam ^ actual->lParam) & ~expected->lp_mask) == 0,
                                     "in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
                                     expected->message, expected->lParam, actual->lParam);
                    if ((expected->lParam ^ actual->lParam) & ~expected->lp_mask) dump++;
                }
            }
        if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
        {
            todo_wine {
                        failcount ++;
                        dump++;
                        ok_( file, line) (FALSE,
                            "the msg 0x%04x should %shave been sent by DefWindowProc\n",
                            expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
            }
                    if (is_wine) goto done;
        }
        else
            {
            ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
            "the msg 0x%04x should %shave been sent by DefWindowProc\n",
                    expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
                if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) dump++;
            }
 
        ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
        "the msg 0x%04x should %shave been sent by BeginPaint\n",
                expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
            if ((expected->flags & beginpaint) != (actual->flags & beginpaint)) dump++;
 
        ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
        "the msg 0x%04x should have been %s\n",
                expected->message, (expected->flags & posted) ? "posted" : "sent");
            if ((expected->flags & (sent|posted)) != (actual->flags & (sent|posted))) dump++;
 
        ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
        "the msg 0x%04x was expected in %s\n",
                expected->message, (expected->flags & parent) ? "parent" : "child");
            if ((expected->flags & parent) != (actual->flags & parent)) dump++;
 
        expected++;
            count++;
        actual++;
    }
    /*
         * silently drop hook messages if there is no support for them
         */
    else if (can_skip_message(expected))
        {
        expected++;
            count++;
        }
    else if (todo)
    {
            todo_wine messages_equal(expected, actual, TRUE, file, line);
            failcount++;
            dump++;
            goto done;
        }
        else if (sequence_contains_message(expected, actual))
        {
            dump++;
            expected++;
            count++;
        }
        else
        {
            dump++;
            actual++;
        }
 
        winetest_pop_context();
        winetest_push_context("%s: %u", context, count);
    }
 
    /* skip all optional trailing messages */
    while (can_skip_message(expected))
    {
        messages_equal(expected, actual, TRUE, file, line); /* check for message todo's */
    expected++;
    }
 
    if (todo)
    {
        todo_wine {
            if (expected->message || actual->message) {
                failcount++;
                dump++;
                messages_equal(expected, actual, TRUE, file, line);
            }
        }
        if (is_wine && !failcount) /* succeeded yet marked todo */
            todo_wine {
                dump++;
                ok_( file, line)( TRUE, "marked \"todo_wine\" but succeeds\n");
            }
    }
    else
    {
        if (expected->message || actual->message)
        {
            dump++;
            messages_equal(expected, actual, TRUE, file, line);
        }
    }
 
done:
    winetest_pop_context();
    if (dump && (!is_wine || winetest_debug > 1)) dump_sequence(expected_list, context, file, line);
    flush_sequence();
}

Referenced by test_msg_setpos_().

◆ open_clipboard_()

static BOOL open_clipboard_	(	int	line,
		HWND	hwnd
	)

static

Definition at line 18196 of file msg.c.

{
    DWORD start = GetTickCount();
    while (1)
    {
        BOOL ret = OpenClipboard(hwnd);
        if (ret || GetLastError() != ERROR_ACCESS_DENIED)
            return ret;
        if (GetTickCount() - start > 100)
        {
            char classname[256];
            DWORD le = GetLastError();
            HWND clipwnd = GetOpenClipboardWindow();
            /* Provide a hint as to the source of interference:
             * - The class name would typically be CLIPBRDWNDCLASS if the
             *   clipboard was opened by a Windows application using the
             *   ole32 API.
             * - And it would be __wine_clipboard_manager if it was opened in
             *   response to a native application.
             */
            GetClassNameA(clipwnd, classname, ARRAY_SIZE(classname));
            trace_(__FILE__, line)("%p (%s) opened the clipboard\n", clipwnd, classname);
            SetLastError(le);
            return ret;
        }
        Sleep(15);
    }
}

Referenced by clear_clipboard_().

◆ PaintLoopProcA()

static LRESULT WINAPI PaintLoopProcA	(	HWND	hWnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 11198 of file msg.c.

{
    switch (msg)
    {
        case WM_CREATE: return 0;
        case WM_PAINT:
        {
            MSG msg2;
            static int i = 0;
 
            if (i < 256)
            {
                i++;
                if (PeekMessageA(&msg2, 0, 0, 0, 1))
                {
                    TranslateMessage(&msg2);
                    DispatchMessageA(&msg2);
                }
                i--;
            }
            else ok(broken(1), "infinite loop\n");
            if ( i == 0)
                paint_loop_done = TRUE;
            return DefWindowProcA(hWnd,msg,wParam,lParam);
        }
    }
    return DefWindowProcA(hWnd,msg,wParam,lParam);
}

Referenced by register_classes().

◆ parent_menu_proc()

static LRESULT WINAPI parent_menu_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 17573 of file msg.c.

{
    if (message == WM_ENTERIDLE ||
        message == WM_INITMENU ||
        message == WM_INITMENUPOPUP ||
        message == WM_MENUSELECT ||
        message == WM_PARENTNOTIFY ||
        message == WM_ENTERMENULOOP ||
        message == WM_EXITMENULOOP ||
        message == WM_UNINITMENUPOPUP ||
        message == WM_KEYDOWN ||
        message == WM_KEYUP ||
        message == WM_CHAR ||
        message == WM_SYSKEYDOWN ||
        message == WM_SYSKEYUP ||
        message == WM_SYSCHAR ||
        message == WM_COMMAND ||
        message == WM_MENUCOMMAND)
    {
        struct recvd_message msg;
 
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        msg.wParam = wp;
        msg.lParam = lp;
        msg.descr = "parent_menu_proc";
        add_message(&msg);
    }
 
    return DefWindowProcA(hwnd, message, wp, lp);
}

Referenced by test_menu_messages().

◆ ParentMsgCheckProcA()

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

static

Definition at line 11051 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    static LONG beginpaint_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    if (log_all_parent_messages ||
        message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
    message == WM_SETFOCUS || message == WM_KILLFOCUS ||
    message == WM_ENABLE || message == WM_ENTERIDLE ||
    message == WM_DRAWITEM || message == WM_MEASUREITEM || message == WM_COMPAREITEM ||
    message == WM_COMMAND || message == WM_IME_SETCONTEXT)
    {
        switch (message)
        {
            /* ignore */
            case WM_NCHITTEST:
                return HTCLIENT;
            case WM_SETCURSOR:
            case WM_MOUSEMOVE:
            case WM_NCMOUSEMOVE:
                return 0;
        }
 
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|parent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        if (beginpaint_counter) msg.flags |= beginpaint;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "parent";
        add_message(&msg);
    }
 
    if (message == WM_PAINT)
    {
        PAINTSTRUCT ps;
        beginpaint_counter++;
        BeginPaint( hwnd, &ps );
        beginpaint_counter--;
        EndPaint( hwnd, &ps );
        return 0;
    }
 
    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return message == WM_COMPAREITEM ? -1 : ret;
}

Referenced by radio_test_dlg_proc(), and register_classes().

◆ PopupMsgCheckProcA()

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

static

Definition at line 11013 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    switch (message)
    {
    case WM_QUERYENDSESSION:
    case WM_ENDSESSION:
        lParam &= ~0x01;  /* Vista adds a 0x01 flag */
        break;
    }
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "popup";
    add_message(&msg);
 
    if (message == WM_CREATE)
    {
    DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
    SetWindowLongA(hwnd, GWL_STYLE, style);
    }
 
    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by register_classes().

◆ post_rbuttonup_msg()

static DWORD CALLBACK post_rbuttonup_msg ( void * arg )

static

Definition at line 17953 of file msg.c.

{
    struct rbuttonup_thread_data *data = arg;
    DWORD ret;
 
    ret = WaitForSingleObject( data->wndproc_finished, 500 );
    todo_wine ok( ret == WAIT_OBJECT_0, "WaitForSingleObject returned %lx\n", ret );
    if( ret == WAIT_OBJECT_0 ) return 0;
 
    PostMessageA( data->hwnd, WM_RBUTTONUP, 0, 0 );
    return 0;
}

Referenced by test_defwinproc().

◆ pump_msg_loop()

static void pump_msg_loop	(	HWND	hwnd,
		HACCEL	hAccel
	)

static

Definition at line 10576 of file msg.c.

{
    MSG msg;
 
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        struct recvd_message log_msg;
 
        /* ignore some unwanted messages */
        if (msg.message == WM_MOUSEMOVE ||
            msg.message == WM_TIMER ||
            ignore_message( msg.message ))
            continue;
 
        log_msg.hwnd = msg.hwnd;
        log_msg.message = msg.message;
        log_msg.flags = wparam|lparam;
        log_msg.wParam = msg.wParam;
        log_msg.lParam = msg.lParam;
        log_msg.descr = "accel";
        add_message(&log_msg);
 
        if (!hAccel || !TranslateAcceleratorA(hwnd, hAccel, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessageA(&msg);
        }
    }
}

Referenced by test_accelerators(), and test_setwindowpos().

◆ pump_msg_loop_timeout()

static void pump_msg_loop_timeout	(	DWORD	timeout,
		BOOL	inject_mouse_move
	)

static

Definition at line 14831 of file msg.c.

{
    MSG msg;
    DWORD start_ticks, end_ticks;
 
    start_ticks = GetTickCount();
    /* add some deviation (50%) to cover not expected delays */
    start_ticks += timeout / 2;
 
    do
    {
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
        {
            /* Timer proc messages are not dispatched to the window proc,
             * and therefore not logged.
             */
            if ((msg.message == WM_TIMER || msg.message == WM_SYSTIMER) && msg.hwnd)
            {
                struct recvd_message s_msg;
 
                s_msg.hwnd = msg.hwnd;
                s_msg.message = msg.message;
                s_msg.flags = sent|wparam|lparam;
                s_msg.wParam = msg.wParam;
                s_msg.lParam = msg.lParam;
                s_msg.descr = "msg_loop";
                add_message(&s_msg);
            }
            DispatchMessageA(&msg);
        }
 
        end_ticks = GetTickCount();
 
        /* inject WM_MOUSEMOVE to see how it changes tracking */
        if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
        {
            mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
            mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
 
            inject_mouse_move = FALSE;
        }
    } while (start_ticks + timeout >= end_ticks);
}

Referenced by test_TrackMouseEvent().

◆ radio_test_dlg_proc()

static INT_PTR WINAPI radio_test_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 7480 of file msg.c.

{
    ParentMsgCheckProcA(hwnd, msg, wp, lp);
    return 1;
}

Referenced by test_autoradio_BM_CLICK(), and test_autoradio_kbd_move().

◆ rec_get_message_hook()

static LRESULT WINAPI rec_get_message_hook	(	int	code,
		WPARAM	w,
		LPARAM	l
	)

static

Definition at line 12591 of file msg.c.

{
    LRESULT res;
    MSG msg;
    BOOL b;
 
    hook_depth++;
    if(hook_depth > max_hook_depth)
        max_hook_depth = hook_depth;
 
    b = PeekMessageW(&msg, hook_hwnd, 0, 0, PM_NOREMOVE);
    ok(b, "PeekMessage failed\n");
 
    res = CallNextHookEx(recursive_hook, code, w, l);
 
    hook_depth--;
    return res;
}

Referenced by test_recursive_hook().

◆ recursive_messages_proc()

static LRESULT WINAPI recursive_messages_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 12782 of file msg.c.

{
    static int msg_depth;
    MSG msg;
 
    if (message == WM_SETCURSOR && max_msg_depth < 15)
    {
        msg_depth++;
        max_msg_depth = max(max_msg_depth, msg_depth);
        PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE);
        msg_depth--;
    }
    return DefWindowProcA(hwnd, message, wp, lp);
}

Referenced by test_recursive_messages().

◆ recursive_viewer_proc()

static LRESULT CALLBACK recursive_viewer_proc	(	HWND	hWnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 18245 of file msg.c.

{
    static BOOL recursion_guard;
 
    if (message == WM_DRAWCLIPBOARD && !recursion_guard)
    {
        recursion_guard = TRUE;
        clear_clipboard(hWnd);
        recursion_guard = FALSE;
    }
    return CallWindowProcA(pOldViewerProc, hWnd, message, wParam, lParam);
}

Referenced by test_clipboard_viewers().

◆ register_class()

static void register_class ( const WNDCLASSA * class )

static

Definition at line 129 of file msg.c.

{
    BOOL ret = RegisterClassA(class);
    ok(ret, "Failed to register class %s, error %lu.\n",
            debugstr_a(class->lpszClassName), GetLastError());
}

◆ register_classes()

static void register_classes ( void )

static

Definition at line 11270 of file msg.c.

{
    WNDCLASSA cls;
    WNDCLASSW clsW;
 
    cls.style = 0;
    cls.lpfnWndProc = MsgCheckProcA;
    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 = "TestWindowClass";
    register_class(&cls);
 
    cls.lpfnWndProc = HotkeyMsgCheckProcA;
    cls.lpszClassName = "HotkeyWindowClass";
    register_class(&cls);
 
    cls.lpfnWndProc = ShowWindowProcA;
    cls.lpszClassName = "ShowWindowClass";
    register_class(&cls);
 
    cls.lpfnWndProc = PopupMsgCheckProcA;
    cls.lpszClassName = "TestPopupClass";
    register_class(&cls);
 
    cls.lpfnWndProc = ParentMsgCheckProcA;
    cls.lpszClassName = "TestParentClass";
    register_class(&cls);
 
    cls.lpfnWndProc = StopQuitMsgCheckProcA;
    cls.lpszClassName = "StopQuitClass";
    register_class(&cls);
 
    cls.lpfnWndProc = DefWindowProcA;
    cls.lpszClassName = "SimpleWindowClass";
    register_class(&cls);
 
    cls.lpfnWndProc = PaintLoopProcA;
    cls.lpszClassName = "PaintLoopWindowClass";
    register_class(&cls);
 
    cls.style = CS_NOCLOSE;
    cls.lpszClassName = "NoCloseWindowClass";
    register_class(&cls);
 
    ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
    cls.style = 0;
    cls.hInstance = GetModuleHandleA(0);
    cls.hbrBackground = 0;
    cls.lpfnWndProc = TestDlgProcA;
    cls.lpszClassName = "TestDialogClass";
    register_class(&cls);
 
    cls.lpfnWndProc = DefWindowProcA;
    cls.style = CS_PARENTDC;
    cls.lpszClassName = "SimpleWindowClassWithParentDC";
    register_class(&cls);
 
    clsW.style = 0;
    clsW.lpfnWndProc = MsgCheckProcW;
    clsW.cbClsExtra = 0;
    clsW.cbWndExtra = 0;
    clsW.hInstance = GetModuleHandleW(0);
    clsW.hIcon = 0;
    clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
    clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
    clsW.lpszMenuName = NULL;
    clsW.lpszClassName = testWindowClassW;
    RegisterClassW(&clsW);  /* ignore error, this fails on Win9x */
}

Referenced by START_TEST().

◆ register_wmime_keydown_class()

static void register_wmime_keydown_class ( void )

static

Definition at line 8250 of file msg.c.

{
    WNDCLASSA cls;
 
    ZeroMemory(&cls, sizeof(WNDCLASSA));
    cls.lpfnWndProc = wmime_keydown_procA;
    cls.hInstance = GetModuleHandleA(0);
    cls.lpszClassName = "wmime_keydown_class";
    register_class(&cls);
}

Referenced by test_wmime_keydown_message().

◆ run_in_temp_desktop_()

static void run_in_temp_desktop_	(	const char *	file,
		int	line,
		const char *	name,
		void(*)(void)	test_func
	)

static

Definition at line 9955 of file msg.c.

{
    struct run_in_temp_desktop_args args;
    HANDLE thread;
    DWORD result;
 
    args.file = file;
    args.line = line;
    args.name = name;
    args.test_func = test_func;
 
    thread = CreateThread( NULL, 0, run_in_temp_desktop_thread_func, &args, 0, NULL );
    ok_(file, line)( thread != NULL, "CreateThread error %lu\n", GetLastError() );
 
    result = WaitForSingleObject( thread, INFINITE );
    ok_(file, line)( result == WAIT_OBJECT_0, "WaitForSingleObject returned %lu, error %lu\n",
                     result, GetLastError() );
 
    CloseHandle( thread );
}

◆ run_in_temp_desktop_thread_func()

static DWORD WINAPI run_in_temp_desktop_thread_func ( LPVOID param )

static

Definition at line 9836 of file msg.c.

{
    HDESK prev_thr_desktop, prev_inp_desktop, post_inp_desktop, temp_desktop;
    char temp_desktop_name[1024], curr_desktop_name[1024];
    struct run_in_temp_desktop_args *args = param;
    const char *file = args->file;
    int line = args->line;
    LARGE_INTEGER qpc;
    DWORD length;
    int result;
 
    result = QueryPerformanceCounter( &qpc );
    ok_(file, line)( result, "QueryPerformanceCounter error %lu\n", GetLastError() );
 
    /*
     * Temporary desktops from previous runs may leak due to a Windows bug.
     * Generate a unique name that is unlikely to collide with previous runs.
     */
    result = snprintf( temp_desktop_name, ARRAY_SIZE(temp_desktop_name),
                       "WineTest-%08lX-%08lX-%08lX%08lX-%s",
                       GetCurrentProcessId(), GetCurrentThreadId(),
                       qpc.HighPart, qpc.LowPart, args->name );
    ok_(file, line)( result > 0 && result < ARRAY_SIZE(temp_desktop_name),
                     "sprintf returned %d (out of memory, or name too long?)\n", result );
 
    if (winetest_debug > 1)
        trace_(file, line)( "creating desktop: %s\n", debugstr_a( temp_desktop_name ) );
 
    temp_desktop = CreateDesktopA( temp_desktop_name, NULL, NULL, 0, GENERIC_ALL, NULL );
    ok_(file, line)( temp_desktop != NULL, "CreateDesktopA(%s, ..) error %lu\n",
                     debugstr_a( temp_desktop_name ), GetLastError() );
 
    prev_inp_desktop = OpenInputDesktop( 0, FALSE, DESKTOP_SWITCHDESKTOP );
    ok_(file, line)( prev_inp_desktop != NULL, "OpenInputDesktop [prev] error %lu\n", GetLastError() );
 
    if (winetest_debug > 1)
        trace_(file, line)( "sanity check: no concurrent WineTest desktop\n" );
 
    /*
     * Check if the desktop has not been properly restored.  This is done to
     * avoid any possible hard-to-debug failures due to unexpected desktop.
     */
    result = GetUserObjectInformationA( prev_inp_desktop, UOI_NAME,
                                        curr_desktop_name, sizeof(curr_desktop_name), &length );
    ok_(file, line)( result, "GetUserObjectInformationA error %lu [rl = %lu]\n",
                     GetLastError(), length );
    ok_(file, line)( _strnicmp( curr_desktop_name, temp_desktop_name, 8 ) != 0,
                     "unexpected input desktop name %s (concurrent WineTest run?)\n",
                     debugstr_a( curr_desktop_name ) );
 
    if (winetest_debug > 1)
        trace_(file, line)( "switching desktop to: %s (%p)\n", debugstr_a( temp_desktop_name ), temp_desktop );
 
    result = SwitchDesktop( temp_desktop );
    ok_(file, line)( result, "SwitchDesktop(temp_desktop=%p) error %lu\n",
                     temp_desktop, GetLastError() );
 
    prev_thr_desktop = GetThreadDesktop( GetCurrentThreadId() );
    ok_(file, line)( prev_thr_desktop != NULL, "GetThreadDesktop error %lu\n", GetLastError() );
 
    result = SetThreadDesktop( temp_desktop );
    ok_(file, line)( result, "SetThreadDesktop(temp_desktop=%p) error %lu\n",
                     temp_desktop, GetLastError() );
 
    if (winetest_debug > 1)
        trace_(file, line)( "running test function %s()\n", args->name );
 
    args->test_func();
 
    if (winetest_debug > 1)
        trace_(file, line)( "sanity check: input desktop has not been changed\n" );
 
    /*
     * Check if the input desktop has been tampered with.  This is done to
     * avoid any possible hard-to-debug failures due to unexpected desktop.
     */
    post_inp_desktop = OpenInputDesktop( 0, FALSE, DESKTOP_ENUMERATE );
    ok_(file, line)( post_inp_desktop != NULL, "OpenInputDesktop [post] error %lu\n", GetLastError() );
 
    result = GetUserObjectInformationA( post_inp_desktop, UOI_NAME,
                                        curr_desktop_name, sizeof(curr_desktop_name), &length );
    ok_(file, line)( result, "GetUserObjectInformationA(post_inp_desktop=%p) error %lu [rl = %lu]\n",
                     post_inp_desktop, GetLastError(), length );
    ok_(file, line)( strcmp( curr_desktop_name, temp_desktop_name ) == 0,
                     "different desktop name: %s != %s (no switch or concurrent WineTest run?)\n",
                     debugstr_a( curr_desktop_name ), debugstr_a( temp_desktop_name ) );
 
    result = CloseDesktop( post_inp_desktop );
    ok_(file, line)( result, "CloseDesktop(post_inp_desktop=%p) error %lu\n",
                     post_inp_desktop, GetLastError() );
 
    if (winetest_debug > 1)
        trace_(file, line)( "restoring previous desktop\n" );
 
    result = SetThreadDesktop( prev_thr_desktop );
    ok_(file, line)( result || broken( GetLastError() == ERROR_BUSY ) /* == W10 */,
                     "SetThreadDesktop(prev_thr_desktop=%p) error %lu\n",
                     prev_thr_desktop, GetLastError() );
 
    result = SwitchDesktop( prev_inp_desktop );
    ok_(file, line)( result, "SwitchDesktop(prev_inp_desktop=%p) error %lu\n",
                     prev_inp_desktop, GetLastError() );
 
    result = CloseDesktop( prev_inp_desktop );
    ok_(file, line)( result, "CloseDesktop(prev_inp_desktop=%p) error %lu\n",
                     prev_inp_desktop, GetLastError() );
 
    if (winetest_debug > 1)
        trace_(file, line)( "closing desktop: %s (%p)\n", debugstr_a( temp_desktop_name ), temp_desktop );
 
    result = CloseDesktop( temp_desktop );
    ok_(file, line)( result || broken( GetLastError() == ERROR_BUSY ) /* == W10 */,
                     "CloseDesktop(temp_desktop=%p) error %lu\n",
                     temp_desktop, GetLastError() );
 
    return 0;
}

Referenced by run_in_temp_desktop_().

◆ send_message_thread()

static DWORD WINAPI send_message_thread ( void * arg )

static

Definition at line 20396 of file msg.c.

{
    HWND win = arg;
 
    SendMessageA( win, WM_USER, 0, 0 );
    SendNotifyMessageA( win, WM_USER + 1, 0, 0 );
    SendMessageCallbackA( win, WM_USER + 2, 0, 0, msg_callback, 0 );
    PostMessageA( win, WM_USER + 3, 0, 0 );
    PostMessageA( win, WM_QUIT, 0, 0 );
    return 0;
}

Referenced by test_InSendMessage().

◆ send_msg_delay_proc()

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

static

Definition at line 13174 of file msg.c.

{
    if (message == WM_USER) Sleep(200);
    return MsgCheckProcA( hwnd, message, wParam, lParam );
}

Referenced by test_SendMessageTimeout().

◆ send_msg_thread()

static DWORD CALLBACK send_msg_thread ( LPVOID arg )

static

Definition at line 13153 of file msg.c.

{
    struct sendmsg_info *info = arg;
    SetLastError( 0xdeadbeef );
    SetEvent( info->ready );
    info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
    if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT ||
                        broken(GetLastError() == 0),  /* win9x */
                        "unexpected error %ld\n", GetLastError());
    return 0;
}

Referenced by test_SendMessageTimeout().

◆ send_msg_thread_2()

static DWORD CALLBACK send_msg_thread_2 ( void * param )

static

Definition at line 13840 of file msg.c.

{
    DWORD ret;
    struct peekmsg_info *info = param;
 
    if (winetest_debug > 1) trace("thread: looping\n");
    SetEvent(info->hevent[EV_ACK]);
 
    while (1)
    {
        ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
 
        switch (ret)
        {
        case WAIT_OBJECT_0 + EV_STOP:
            if (winetest_debug > 1) trace("thread: exiting\n");
            return 0;
 
        case WAIT_OBJECT_0 + EV_SENDMSG:
            if (winetest_debug > 1) trace("thread: sending message\n");
            ret = SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
            ok(ret, "SendNotifyMessageA failed error %lu\n", GetLastError());
            SetEvent(info->hevent[EV_ACK]);
            break;
 
        default:
            ok(0, "Unexpected return %#lx.\n", ret);
            break;
        }
    }
    return 0;
}

Referenced by test_PeekMessage().

◆ SendMessage_thread_1()

static DWORD WINAPI SendMessage_thread_1 ( void * param )

static

Definition at line 20180 of file msg.c.

{
    struct wnd_event *wnd_event = param;
    DWORD ret;
 
    if (winetest_debug > 1) trace("thread: starting\n");
    WaitForSingleObject(wnd_event->start_event, INFINITE);
 
    if (winetest_debug > 1) trace("thread: call PostMessage\n");
    PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
 
    if (winetest_debug > 1) trace("thread: call PostMessage\n");
    PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
 
    if (winetest_debug > 1) trace("thread: call SendMessage\n");
    SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
    SetEvent(wnd_event->stop_event);
    ret = WaitForSingleObject(wnd_event->getmessage_complete, 100);
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed, ret:%lx\n", ret);
 
    if (winetest_debug > 1) trace("thread: call SendMessage\n");
    SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
 
    return 0;
}

Referenced by test_SendMessage_other_thread().

◆ sequence_contains_message()

static BOOL sequence_contains_message	(	const struct message *	expected,
		const struct recvd_message *	actual
	)

static

Definition at line 2734 of file msg.c.

{
    while (expected->message)
    {
        if (messages_equal(expected, actual, FALSE, __FILE__, __LINE__))
            return TRUE;
        expected++;
    }
    return FALSE;
}

Referenced by dump_sequence(), and ok_sequence_().

◆ set_menu_style()

static void set_menu_style	(	HMENU	hmenu,
		DWORD	style
	)

static

Definition at line 17606 of file msg.c.

{
    MENUINFO mi;
    BOOL ret;
 
    mi.cbSize = sizeof(mi);
    mi.fMask = MIM_STYLE;
    mi.dwStyle = style;
    SetLastError(0xdeadbeef);
    ret = SetMenuInfo(hmenu, &mi);
    ok(ret, "SetMenuInfo error %lu\n", GetLastError());
}

Referenced by test_menu_messages().

◆ set_radio()

static void set_radio	(	HWND	radio1,
		int	state1,
		HWND	radio2,
		int	state2,
		HWND	radio3,
		int	state3
	)

static

Definition at line 7579 of file msg.c.

{
    SendMessageA(radio1, BM_SETCHECK, state1 ? BST_CHECKED : BST_UNCHECKED, 0);
    SendMessageA(radio2, BM_SETCHECK, state2 ? BST_CHECKED : BST_UNCHECKED, 0);
    SendMessageA(radio3, BM_SETCHECK, state3 ? BST_CHECKED : BST_UNCHECKED, 0);
}

Referenced by test_autoradio_kbd_move().

◆ SetParent_thread()

static DWORD WINAPI SetParent_thread ( void * param )

static

Definition at line 20295 of file msg.c.

{
    struct wnd_event *wnd_event = param;
 
    if (winetest_debug > 1) trace("thread: started\n");
    SetEvent(wnd_event->start_event);
 
    /* this leads to sending an internal message under Wine */
    if (winetest_debug > 1) trace("thread: call SetParent\n");
    SetParent(wnd_event->hwnd, wnd_event->hwnd);
 
    return 0;
}

Referenced by test_setparent_status().

◆ show_window_thread()

static DWORD CALLBACK show_window_thread ( LPVOID arg )

static

Definition at line 5528 of file msg.c.

{
    HWND hwnd = arg;
 
    /* function will not return if ShowWindow(SW_SHOW) calls SendMessage() */
    ok( ShowWindow( hwnd, SW_SHOW ), "ShowWindow(SW_SHOW) expected TRUE\n" ); /* actually it's 24... */
 
    return 0;
}

Referenced by test_messages().

◆ ShowWindowProcA()

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

static

Definition at line 11155 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    /* log only specific messages we are interested in */
    switch (message)
    {
#if 0 /* probably log these as well */
    case WM_ACTIVATE:
    case WM_SETFOCUS:
    case WM_KILLFOCUS:
#endif
    case WM_SHOWWINDOW:
    case WM_SIZE:
    case WM_MOVE:
    case WM_GETMINMAXINFO:
    case WM_WINDOWPOSCHANGING:
    case WM_WINDOWPOSCHANGED:
        break;
 
    default: /* ignore */
        /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
        return DefWindowProcA(hwnd, message, wParam, lParam);
    }
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "show";
    add_message(&msg);
 
    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by register_classes().

◆ simulate_click()

static void simulate_click	(	BOOL	left,
		int	x,
		int	y
	)

static

Definition at line 12569 of file msg.c.

{
    POINT old_pt;
    INPUT input[2];
    UINT events_no;
 
    GetCursorPos(&old_pt);
    SetCursorPos(x, y);
    memset(input, 0, sizeof(input));
    input[0].type = INPUT_MOUSE;
    input[0].mi.dx = x;
    input[0].mi.dy = y;
    input[0].mi.dwFlags = left ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_RIGHTDOWN;
    input[1].type = INPUT_MOUSE;
    input[1].mi.dx = x;
    input[1].mi.dy = y;
    input[1].mi.dwFlags = left ? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_RIGHTUP;
    events_no = SendInput(2, input, sizeof(input[0]));
    ok(events_no == 2, "SendInput returned %d\n", events_no);
    SetCursorPos(old_pt.x, old_pt.y);
}

Referenced by test_recursive_hook(), and test_recursive_messages().

◆ START_TEST()

START_TEST ( msg )

Definition at line 20880 of file msg.c.

{
    char **test_argv;
    BOOL ret;
    BOOL (WINAPI *pIsWinEventHookInstalled)(DWORD)= 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
    int argc;
 
#ifdef __REACTOS__
    // Temp for now to see where this is crashing on WS03 testbot
    winetest_debug = 2;
#endif
    argc = winetest_get_mainargs( &test_argv );
    if (argc >= 3)
    {
        unsigned int arg;
        /* Child process. */
        sscanf (test_argv[2], "%d", (unsigned int *) &arg);
        do_wait_idle_child( arg );
        return;
    }
 
    InitializeCriticalSection( &sequence_cs );
    init_procs();
    ImmDisableIME(0);
 
    register_classes();
 
    if (pSetWinEventHook)
    {
        hEvent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX,
                                       GetModuleHandleA(0), win_event_proc,
                                       0, GetCurrentThreadId(),
                                       WINEVENT_INCONTEXT);
        if (pIsWinEventHookInstalled && hEvent_hook)
    {
        UINT event;
        for (event = EVENT_MIN; event <= EVENT_MAX; event++)
        ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
    }
    }
    if (!hEvent_hook) win_skip( "no win event hook support\n" );
 
    cbt_hook_thread_id = winevent_hook_thread_id = GetCurrentThreadId();
    hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
    if (!hCBT_hook) win_skip( "cannot set global hook, will skip hook tests\n" );
 
    test_winevents();
    test_SendMessage_other_thread();
    test_setparent_status();
    test_InSendMessage();
    test_SetFocus();
    test_radiobutton_focus();
    test_SetParent();
    test_PostMessage();
    test_broadcast();
    test_ShowWindow();
    test_PeekMessage();
    test_PeekMessage2();
    test_PeekMessage3();
    test_WaitForInputIdle( test_argv[0] );
    test_scrollwindowex();
    test_messages();
    test_setwindowpos();
    test_showwindow();
    invisible_parent_tests();
    test_mdi_messages();
    test_button_messages();
    test_button_bm_get_set_image();
    test_button_style();
    test_autoradio_BM_CLICK();
    test_autoradio_kbd_move();
    test_static_messages();
    test_listbox_messages();
    test_combobox_messages();
    test_wmime_keydown_message();
    test_paint_messages();
    run_in_temp_desktop(test_swp_paint_regions);
    run_in_temp_desktop(test_swp_paint_region_on_show);
    run_in_temp_desktop(test_swp_paint_region_on_extend_zerosize);
    run_in_temp_desktop(test_hvredraw);
    test_interthread_messages();
    test_message_conversion();
    test_accelerators();
    test_timers();
    test_timers_no_wnd();
    test_timers_exceptions();
    if (hCBT_hook)
    {
        test_set_hook();
        test_recursive_hook();
    }
    test_recursive_messages();
    test_DestroyWindow();
    test_DispatchMessage();
    test_SendMessageTimeout();
    test_edit_messages();
    test_quit_message();
    test_notify_message();
    test_SetActiveWindow();
    test_restore_messages();
    test_invalid_window();
    test_menu_messages();
    test_paintingloop();
 
    if (!pTrackMouseEvent)
        win_skip("TrackMouseEvent is not available\n");
    else
        test_TrackMouseEvent();
 
    test_SetWindowRgn();
    test_sys_menu();
    test_dialog_messages();
    test_EndDialog();
    test_nullCallback();
    test_dbcs_wm_char();
    test_unicode_wm_char();
#ifdef __REACTOS__
    trace("Running test_defwinproc()...\n");
    test_defwinproc();
    trace("Running test_desktop_winproc()...\n");
    test_desktop_winproc();
    trace("Running test_clipboard_viewers()...\n");
    test_clipboard_viewers();
    trace("Running test_keyflags()...\n");
    test_keyflags();
    trace("Running test_hotkey()...\n");
    test_hotkey();
    trace("Running test_layered_window()...\n");
    test_layered_window();
    trace("Running test_TrackPopupMenu()...\n");
    test_TrackPopupMenu();
    trace("Running test_TrackPopupMenuEmpty()...\n");
    test_TrackPopupMenuEmpty();
    trace("Running test_DoubleSetCapture()...\n");
    test_DoubleSetCapture();
    trace("Running test_create_name()...\n");
    test_create_name();
    trace("Running test_hook_changing_window_proc()...\n");
    test_hook_changing_window_proc();
    trace("Running test_hook_cleanup()...\n");
    test_hook_cleanup();
#else
    test_defwinproc();
    test_desktop_winproc();
    test_clipboard_viewers();
    test_keyflags();
    test_hotkey();
    test_layered_window();
    test_TrackPopupMenu();
    test_TrackPopupMenuEmpty();
    test_DoubleSetCapture();
    test_create_name();
    test_hook_changing_window_proc();
#endif
    /* keep it the last test, under Windows it tends to break the tests
     * which rely on active/foreground windows being correct.
     */
#ifdef __REACTOS__
    trace("Running test_SetForegroundWindow()...");
#endif
    test_SetForegroundWindow();
 
    UnhookWindowsHookEx(hCBT_hook);
    if (pUnhookWinEvent && hEvent_hook)
    {
    ret = pUnhookWinEvent(hEvent_hook);
    ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
       GetLastError() == 0xdeadbeef, /* Win9x */
           "unexpected error %ld\n", GetLastError());
    }
    DeleteCriticalSection( &sequence_cs );
}

◆ static_hook_proc()

static LRESULT CALLBACK static_hook_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 7760 of file msg.c.

{
    static LONG defwndproc_counter = 0;
    LRESULT ret;
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "static";
    add_message(&msg);
 
    defwndproc_counter++;
    ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
    defwndproc_counter--;
 
    return ret;
}

Referenced by subclass_static().

◆ StopQuitMsgCheckProcA()

static LRESULT CALLBACK StopQuitMsgCheckProcA	(	HWND	hwnd,
		UINT	message,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 11106 of file msg.c.

{
    if (message == WM_CREATE)
        PostMessageA(hwnd, WM_CLOSE, 0, 0);
    else if (message == WM_CLOSE)
    {
        /* Only the first WM_QUIT will survive the window destruction */
        PostMessageA(hwnd, WM_USER, 0x1234, 0x5678);
        PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
        PostMessageA(hwnd, WM_QUIT, 0x4321, 0x8765);
    }
 
    return DefWindowProcA(hwnd, message, wp, lp);
}

Referenced by register_classes().

◆ subclass_button()

static void subclass_button ( void )

static

Definition at line 6852 of file msg.c.

{
    WNDCLASSA cls;
    BOOL ret;
 
    ret = GetClassInfoA(0, "button", &cls);
    ok(ret, "Failed to get class info, error %lu.\n", GetLastError());
 
    old_button_proc = cls.lpfnWndProc;
 
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpfnWndProc = button_hook_proc;
    cls.lpszClassName = "my_button_class";
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
    register_class(&cls);
}

Referenced by test_autoradio_BM_CLICK(), test_autoradio_kbd_move(), and test_button_messages().

◆ subclass_combobox()

static void subclass_combobox ( void )

static

Definition at line 8062 of file msg.c.

{
    WNDCLASSA cls;
    BOOL ret;
 
    ret = GetClassInfoA(0, "ComboBox", &cls);
    ok(ret, "Failed to get class info, error %lu.\n", GetLastError());
 
    old_combobox_proc = cls.lpfnWndProc;
 
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpfnWndProc = combobox_hook_proc;
    cls.lpszClassName = "my_combobox_class";
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
    register_class(&cls);
}

Referenced by test_combobox_messages().

◆ subclass_edit()

static void subclass_edit ( void )

static

Definition at line 13679 of file msg.c.

{
    WNDCLASSA cls;
    BOOL ret;
 
    ret = GetClassInfoA(0, "edit", &cls);
    ok(ret, "Failed to get class info, error %lu.\n", GetLastError());
 
    old_edit_proc = cls.lpfnWndProc;
 
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpfnWndProc = edit_hook_proc;
    cls.lpszClassName = "my_edit_class";
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
    register_class(&cls);
}

Referenced by test_dialog_messages(), and test_edit_messages().

◆ subclass_static()

static void subclass_static ( void )

static

Definition at line 7784 of file msg.c.

{
    WNDCLASSA cls;
    BOOL ret;
 
    ret = GetClassInfoA(0, "static", &cls);
    ok(ret, "Failed to get class info, error %lu.\n", GetLastError());
 
    old_static_proc = cls.lpfnWndProc;
 
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpfnWndProc = static_hook_proc;
    cls.lpszClassName = "my_static_class";
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
    register_class(&cls);
}

Referenced by test_static_messages().

◆ subtest_hvredraw()

static void subtest_hvredraw	(	HWND	hparent,
		UINT	class_style,
		DWORD	style
	)

static

Definition at line 9703 of file msg.c.

{
    static const struct movesize_test {
        int dx, dy, dw, dh;
    } movesize_tests[] = {
        {  0,  0,  0,  5 },
        {  0,  0,  5,  0 },
        {  0,  0,  5,  5 },
        {  0,  0, -5, -5 },
        { -5, -5,  0,  5 },
        { -5, -5,  5,  0 },
        { -5, -5,  5,  5 },
    };
    HRGN hrgn_old_vis = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_new_vis = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_expect = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_actual = CreateRectRgn( 0, 0, 0, 0 );
    const int x0 = 100, y0 = 100, w0 = 150, h0 = 150;
    size_t i;
    HWND hwnd;
    WNDCLASSA cls = {
        .style = class_style,
        .lpfnWndProc = DefWindowProcA,
        .hInstance = GetModuleHandleA(0),
        .hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW),
        .hbrBackground = GetStockObject(WHITE_BRUSH),
        .lpszClassName = "TestHVRedrawClass"
    };
 
    register_class(&cls);
 
    hwnd = CreateWindowExA( 0, cls.lpszClassName, "Test window", style, x0, y0, w0, h0, hparent, 0, 0, NULL );
    ok(hwnd != NULL, "Failed to create the window\n");
 
    ShowWindow( hwnd, SW_SHOW );
    UpdateWindow( hwnd );
 
    for (i = 0; i < ARRAY_SIZE(movesize_tests); i++)
    {
        const struct movesize_test *test = &movesize_tests[i];
        int is_redraw = (test->dw != 0 && (class_style & CS_HREDRAW)) ||
                        (test->dh != 0 && (class_style & CS_VREDRAW));
        RECT rect_old_vis, rect_new_vis;
        BOOL rgn_ok;
 
        winetest_push_context( "%x %08lx SetWindowPos redraw #%Id (%d, %d, %d, %d)",
                               class_style, style, i, test->dx, test->dy, test->dw, test->dh );
 
        SetWindowPos( hwnd, HWND_TOP, x0, y0, w0, h0, SWP_NOACTIVATE );
 
        GetClientRect( hwnd, &rect_old_vis );
        SetRectRgn( hrgn_old_vis, rect_old_vis.left, rect_old_vis.top, rect_old_vis.right, rect_old_vis.bottom );
 
        UpdateWindow( hparent );
        flush_events();
 
        SetWindowPos( hwnd, HWND_TOP,
                      x0 + test->dx, y0 + test->dy,
                      w0 + test->dw, h0 + test->dh, SWP_NOACTIVATE );
        ok( GetUpdateRgn( hwnd, hrgn_actual, FALSE ) != ERROR, "GetUpdateRgn shall succeed\n" );
 
        GetClientRect( hwnd, &rect_new_vis );
        SetRectRgn( hrgn_new_vis, rect_new_vis.left, rect_new_vis.top, rect_new_vis.right, rect_new_vis.bottom );
        CombineRgn( hrgn_expect, hrgn_new_vis, hrgn_old_vis, is_redraw ? RGN_COPY : RGN_DIFF );
 
        rgn_ok = EqualRgn( hrgn_expect, hrgn_actual );
#ifdef __REACTOS__
        ok( !!rgn_ok || broken(GetNTVersion() == _WIN32_WINNT_WINBLUE), "Update region shall match expected region\n" );
#else
        ok( !!rgn_ok, "Update region shall match expected region\n" );
#endif
 
        if (!rgn_ok)
        {
            trace( "Expected update region: " );
            dump_region( hrgn_expect );
            trace( "Actual update region: " );
            dump_region( hrgn_actual );
            trace( "Old window visible area: %s\n", wine_dbgstr_rect( &rect_old_vis ) );
            trace( "New window visible area: %s\n", wine_dbgstr_rect( &rect_new_vis ) );
        }
 
        if (winetest_interactive)
        {
            if (!rgn_ok)
            {
                visualize_region_differences( hwnd, NULL, hrgn_expect, hrgn_actual );
            }
 
            /* Let the position change be visible to the user */
            flush_events();
        }
 
        winetest_pop_context();
    }
 
    DestroyWindow( hwnd );
    DeleteObject( hrgn_actual );
    DeleteObject( hrgn_expect );
    DeleteObject( hrgn_new_vis );
    DeleteObject( hrgn_old_vis );
    UnregisterClassA( cls.lpszClassName, cls.hInstance );
}

Referenced by test_hvredraw().

◆ subtest_swp_paint_regions_()

static void subtest_swp_paint_regions_	(	int	line,
		int	wrap_toplevel,
		LPCSTR	parent_class,
		LPCSTR	child_class
	)

static

Definition at line 9279 of file msg.c.

{
    static const struct exposure_test {
        int ex_style, style;
        BOOL shuffle_zorder;
    } exposure_tests[] = {
        {                0, WS_CLIPCHILDREN, FALSE },
        {                0,               0, FALSE },
        { WS_EX_COMPOSITED, WS_CLIPCHILDREN, TRUE  },
        { WS_EX_COMPOSITED,               0, FALSE },
        { WS_EX_COMPOSITED,               0, TRUE  },
    };
    size_t i;
    HWND htoplevel = NULL, hparent, hchild, hauxchild;
    const RECT rect_old = { 10, 10, 100, 100 };
    HRGN hrgn_old_vis = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_new_vis = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_expect = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_actual = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_old_vis_child = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_new_vis_child = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_expect_child = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn_actual_child = CreateRectRgn( 0, 0, 0, 0 );
    int base_style;
    BOOL is_composition_possible, has_parentdc_anomaly;
    WNDCLASSA parent_wc;
 
    if (wrap_toplevel)
    {
        htoplevel = CreateWindowExA( 0, "SimpleWindowClass", "Test toplevel", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                                     100, 100, 400, 400, 0, 0, 0, NULL );
        ok( htoplevel != 0, "Failed to create top-level window: %lu\n", GetLastError() );
        base_style = WS_CHILD | WS_VISIBLE;
    }
    else
    {
        base_style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
    }
 
    ok( GetClassInfoA( GetModuleHandleA( NULL ), parent_class, &parent_wc ),
        "GetClassInfoA failed\n" );
 
    is_composition_possible = (base_style & (WS_POPUP|WS_CHILD)) != WS_CHILD ||
                              (parent_wc.style & CS_PARENTDC) == 0;
 
    has_parentdc_anomaly = (base_style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
                           (parent_wc.style & CS_PARENTDC) != 0;
 
    hparent = CreateWindowExA( 0, parent_class, "Test parent", base_style,
                               80, 80, 200, 200, htoplevel, 0, 0, NULL );
    ok( hparent != 0, "Creating parent window (%s) returned error %lu\n",
        debugstr_a( parent_class ), GetLastError() );
 
    hchild = CreateWindowExA( 0, child_class, "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
                              rect_old.left, rect_old.top,
                              rect_old.right - rect_old.left, rect_old.bottom - rect_old.top,
                              hparent, 0, 0, NULL );
    ok( hchild != 0, "Creating child window (%s) returned error %lu\n",
        debugstr_a( child_class ), GetLastError() );
 
    hauxchild = CreateWindowExA( 0, child_class, "Auxiliary child for z order test", WS_CHILD | WS_VISIBLE,
                                 110, 0, 0, 0, hparent, 0, 0, NULL );
    ok( hauxchild != 0, "Creating child window (%s) returned error %lu\n",
        debugstr_a( child_class ), GetLastError() );
 
    SetWindowPos( htoplevel ? htoplevel : hparent, NULL, 0, 0, 0, 0,
                  SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW );
 
    for (i = 0; i < ARRAY_SIZE(exposure_tests); i++)
    {
        const struct exposure_test *extest = &exposure_tests[i];
        BOOL has_ws_ex_composited = (extest->ex_style & WS_EX_COMPOSITED) != 0;
        BOOL is_composited = is_composition_possible && has_ws_ex_composited;
        BOOL is_zorder_redraw = is_composited && extest->shuffle_zorder;
        int delta;
 
        winetest_push_context( "%d: SetWindowPos redraw #%Id (ex_style = %#x, style = %#x, shuffle_zorder = %d)",
                               line, i, extest->ex_style, extest->style, extest->shuffle_zorder );
 
        SetWindowLongA( hparent, GWL_EXSTYLE, extest->ex_style );
        SetWindowLongA( hparent, GWL_STYLE, base_style | extest->style );
        RedrawWindow( hparent, NULL, NULL, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
 
        for (delta = -20; delta <= 0; delta += 20)
        {
            RECT rect_old_vis, rect_new, rect_new_vis;
            RECT rect_parent_clip, rect_child_clip;
            RECT rect_old_vis_child, rect_new_vis_child;
            BOOL rgn_ok;
 
            winetest_push_context( "delta = %+d", delta );
 
            SetWindowPos( hchild, HWND_TOP,
                          rect_old.left,
                          rect_old.top,
                          rect_old.right - rect_old.left,
                          rect_old.bottom - rect_old.top,
                          SWP_NOACTIVATE );
 
            rect_new = rect_old;
            OffsetRect( &rect_new, delta, delta );
 
            rect_old_vis_child = rect_old;
            MapWindowPoints( hparent, hchild, (POINT *)&rect_old_vis_child, 2 );
 
            SetRectRgn( hrgn_actual, 0, 0, 0, 0 );
            SetRectRgn( hrgn_actual_child, 0, 0, 0, 0 );
 
            UpdateWindow( hparent );
            flush_events();
 
            if (extest->shuffle_zorder)
            {
                /* bring sibling to top/bottom first so we can trigger z-order change */
                SetWindowPos( hauxchild, HWND_TOP, 0, 0, 0, 0,
                              SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
            }
 
            SetWindowPos( hchild, HWND_TOP,
                          rect_new.left,
                          rect_new.top,
                          rect_new.right - rect_new.left,
                          rect_new.bottom - rect_new.top,
                          SWP_NOACTIVATE |
                          (extest->shuffle_zorder ? 0 : SWP_NOZORDER) );
 
            ok( GetUpdateRgn( hparent, hrgn_actual, FALSE ) != ERROR,
                "GetUpdateRgn on parentshall succeed\n" );
            ok( GetUpdateRgn( hchild, hrgn_actual_child, FALSE ) != ERROR,
                "GetUpdateRgn on child shall succeed\n" );
 
            /* Compute parent window expose region */
            GetClientRect( hparent, &rect_parent_clip );
            IntersectRect( &rect_old_vis, &rect_old, &rect_parent_clip );
            SetRectRgn( hrgn_old_vis, rect_old_vis.left, rect_old_vis.top, rect_old_vis.right, rect_old_vis.bottom );
            IntersectRect( &rect_new_vis, &rect_new, &rect_parent_clip );
            SetRectRgn( hrgn_new_vis, rect_new_vis.left, rect_new_vis.top, rect_new_vis.right, rect_new_vis.bottom );
 
            if (!EqualRect( &rect_old, &rect_new ) || is_zorder_redraw)
            {
                CombineRgn( hrgn_expect, hrgn_old_vis, hrgn_new_vis, is_composited ? RGN_OR : RGN_DIFF );
            }
            else
            {
                SetRectRgn( hrgn_expect, 0, 0, 0, 0 );
            }
 
            rgn_ok = EqualRgn( hrgn_expect, hrgn_actual );
            if (!rgn_ok && broken( has_parentdc_anomaly && is_composited /* Win7 */ ))
            {
                if (winetest_debug > 1)
                {
                    trace( "Forcing non-composited update region (broken)\n" );
                }
                rgn_ok = 1;
            }
            else
            {
                ok( !!rgn_ok, "Parent update region shall match expected region\n" );
            }
 
            if (!rgn_ok)
            {
                trace( "Expected parent update region: " );
                dump_region( hrgn_expect );
                trace( "Actual parent update region: " );
                dump_region( hrgn_actual );
                trace( "Old child window visible area: %s\n", wine_dbgstr_rect( &rect_old_vis ) );
                trace( "New child window visible area: %s\n", wine_dbgstr_rect( &rect_new_vis ) );
            }
 
            if (winetest_interactive)
            {
                if (!rgn_ok)
                {
                    visualize_region_differences( hparent, hchild, hrgn_expect, hrgn_actual );
                }
 
                /* Let the position change be visible to the user */
                flush_events();
            }
 
            rect_new_vis_child = rect_new;
            MapWindowPoints( hparent, hchild, (POINT *)&rect_new_vis_child, 2 );
 
            /* Compute child window expose region */
            GetClientRect( hchild, &rect_child_clip );
            if (is_composited)
            {
                RECT rect_outer_clip;
                GetClientRect( hparent, &rect_outer_clip );
                MapWindowPoints( hparent, hchild, (POINT *)&rect_outer_clip, 2 );
                IntersectRect( &rect_child_clip, &rect_child_clip, &rect_outer_clip );
            }
            IntersectRect( &rect_old_vis_child, &rect_old_vis_child, &rect_child_clip );
            SetRectRgn( hrgn_old_vis_child, rect_old_vis_child.left, rect_old_vis_child.top, rect_old_vis_child.right, rect_old_vis_child.bottom );
            IntersectRect( &rect_new_vis_child, &rect_new_vis_child, &rect_child_clip );
            SetRectRgn( hrgn_new_vis_child, rect_new_vis_child.left, rect_new_vis_child.top, rect_new_vis_child.right, rect_new_vis_child.bottom );
 
            if (!EqualRect( &rect_old, &rect_new ) || is_zorder_redraw)
            {
                CombineRgn( hrgn_expect_child, hrgn_new_vis_child, hrgn_old_vis_child, is_composited ? RGN_OR : RGN_DIFF );
            }
            else
            {
                SetRectRgn( hrgn_expect_child, 0, 0, 0, 0 );
            }
 
            rgn_ok = EqualRgn( hrgn_expect_child, hrgn_actual_child );
            if (!rgn_ok && broken( has_parentdc_anomaly && is_composited /* Win7 */ ))
            {
                if (winetest_debug > 1)
                {
                    trace( "Forcing non-composited update region (broken)\n" );
                }
                rgn_ok = 1;
            }
            else
            {
                ok( !!rgn_ok, "Child update region shall match expected region\n" );
            }
 
            if (!rgn_ok)
            {
                trace( "Expected child update region: " );
                dump_region( hrgn_expect_child );
                trace( "Actual child update region: " );
                dump_region( hrgn_actual_child );
                trace( "Old child window client visible area: %s\n", wine_dbgstr_rect( &rect_old_vis_child ) );
                trace( "New child window client visible area: %s\n", wine_dbgstr_rect( &rect_new_vis_child ) );
            }
 
            if (winetest_interactive)
            {
                if (!rgn_ok)
                {
                    visualize_region_differences( hchild, NULL, hrgn_expect_child, hrgn_actual_child );
                }
 
                /* Let the position change be visible to the user */
                flush_events();
            }
 
            winetest_pop_context();
        }
 
        winetest_pop_context();
    }
 
    DestroyWindow( hauxchild );
    DestroyWindow( hchild );
    DestroyWindow( hparent );
    if (htoplevel) DestroyWindow( htoplevel );
 
    DeleteObject( hrgn_actual_child );
    DeleteObject( hrgn_expect_child );
    DeleteObject( hrgn_new_vis_child );
    DeleteObject( hrgn_old_vis_child );
    DeleteObject( hrgn_actual );
    DeleteObject( hrgn_expect );
    DeleteObject( hrgn_new_vis );
    DeleteObject( hrgn_old_vis );
}

◆ test_accelerators()

static void test_accelerators ( void )

static

Definition at line 10606 of file msg.c.

{
    RECT rc;
    POINT pt;
    SHORT state;
    HACCEL hAccel;
    HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                                100, 100, 200, 200, 0, 0, 0, NULL);
    BOOL us_kbd = (GetKeyboardLayout(0) == (HKL)(ULONG_PTR)0x04090409);
    BOOL ret;
 
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    UpdateWindow(hwnd);
    flush_events();
    flush_sequence();
 
    SetFocus(hwnd);
    ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
 
    state = GetKeyState(VK_SHIFT);
    ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
    state = GetKeyState(VK_CAPITAL);
    ok(state == 0, "wrong CapsLock state %04x\n", state);
 
    hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
    ok(!!hAccel, "Failed to load accelerators, error %lu.\n", GetLastError());
 
    flush_events();
    pump_msg_loop(hwnd, 0);
    flush_sequence();
 
    if (!us_kbd)
    {
        skip("skipping ascii VK events on non-us keyboard\n");
        goto done;
    }
 
    if (winetest_debug > 1) trace("testing VK_N press/release\n");
    flush_sequence();
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    if (!sequence_cnt)  /* we didn't get any message */
    {
        skip( "queuing key events not supported\n" );
        goto done;
    }
    ok_sequence(WmVkN, "VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Shift+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_SHIFT, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
#ifdef __REACTOS__
    if (0) // Test failures on WS03-Win10 1607
#endif
    ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Alt+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+Alt+VK_N press/release 1\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
 
    ret = DestroyAcceleratorTable(hAccel);
    ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
 
    hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(2));
    ok(!!hAccel, "Failed to load accelerators, error %lu.\n", GetLastError());
 
    if (winetest_debug > 1) trace("testing VK_N press/release\n");
    flush_sequence();
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmVkN, "VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Shift+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_SHIFT, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+VK_N press/release 2\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
 
    if (winetest_debug > 1) trace("testing Alt+VK_N press/release 2\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+Alt+VK_N press/release 2\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+Shift+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event(VK_SHIFT, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
    flush_sequence();
    keybd_event(VK_CONTROL, 0, 0, 0);
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event(VK_SHIFT, 0, 0, 0);
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, hAccel);
    ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
 
    ret = DestroyAcceleratorTable(hAccel);
    ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
    hAccel = 0;
 
    if (winetest_debug > 1) trace("testing Alt press/release\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, 0);
    /* this test doesn't pass in Wine for managed windows */
    ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
 
    if (winetest_debug > 1) trace("testing VK_F1 press/release\n");
    keybd_event(VK_F1, 0, 0, 0);
    keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, 0);
    ok_sequence(WmF1Seq, "F1 press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing VK_APPS press/release\n");
    keybd_event(VK_APPS, 0, 0, 0);
    keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, 0);
    ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
 
    if (winetest_debug > 1) trace("testing VK_F10 press/release\n");
    keybd_event(VK_F10, 0, 0, 0);
    keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_F10, 0, 0, 0);
    keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, 0);
    ok_sequence(WmVkF10Seq, "VK_F10 press/release", TRUE);
 
    if (winetest_debug > 1) trace("testing SHIFT+F10 press/release\n");
    keybd_event(VK_SHIFT, 0, 0, 0);
    keybd_event(VK_F10, 0, 0, 0);
    keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_ESCAPE, 0, 0, 0);
    keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
    pump_msg_loop(hwnd, 0);
    ok_sequence(WmShiftF10Seq, "SHIFT+F10 press/release", TRUE);
 
    if (winetest_debug > 1) trace("testing Shift+MouseButton press/release\n");
    /* first, move mouse pointer inside of the window client area */
    GetClientRect(hwnd, &rc);
    MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
    rc.left += (rc.right - rc.left)/2;
    rc.top += (rc.bottom - rc.top)/2;
    SetCursorPos(rc.left, rc.top);
    SetActiveWindow(hwnd);
 
    flush_events();
    flush_sequence();
    GetCursorPos(&pt);
    if (pt.x == rc.left && pt.y == rc.top)
    {
        int i;
        keybd_event(VK_SHIFT, 0, 0, 0);
        mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
        mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
        keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
        pump_msg_loop(hwnd, 0);
        for (i = 0; i < sequence_cnt; i++) if (sequence[i].message == WM_LBUTTONDOWN) break;
        if (i < sequence_cnt)
            ok_sequence(WmShiftMouseButton, "Shift+MouseButton press/release", FALSE);
        else
            skip( "Shift+MouseButton event didn't get to the window\n" );
    }
 
done:
    if (hAccel) DestroyAcceleratorTable(hAccel);
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_autoradio_BM_CLICK()

static void test_autoradio_BM_CLICK ( void )

static

Definition at line 7486 of file msg.c.

{
    HWND parent, radio1, radio2, radio3;
    RECT rc;
    MSG msg;
    DWORD ret;
 
    subclass_button();
 
    parent = CreateDialogParamA(0, "AUTORADIO_TEST_DIALOG_1", 0, radio_test_dlg_proc, 0);
    ok(parent != 0, "failed to create parent window\n");
 
    radio1 = GetDlgItem(parent, ID_RADIO1);
    radio2 = GetDlgItem(parent, ID_RADIO2);
    radio3 = GetDlgItem(parent, ID_RADIO3);
 
    /* this avoids focus messages in the generated sequence */
    SetFocus(radio2);
 
    flush_events();
    flush_sequence();
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
 
    SendMessageA(radio1, BM_SETCHECK, BST_CHECKED, 0);
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
 
    SendMessageA(radio2, BM_SETCHECK, BST_CHECKED, 0);
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
 
    SendMessageA(radio3, BM_SETCHECK, BST_CHECKED, 0);
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
 
    GetWindowRect(radio2, &rc);
    SetCursorPos(rc.left+1, rc.top+1);
 
    flush_events();
    flush_sequence();
 
    log_all_parent_messages++;
 
    SendMessageA(radio2, BM_CLICK, 0, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_BM_CLICK, "BM_CLICK on auto-radio button", FALSE);
 
    log_all_parent_messages--;
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok(ret == BST_CHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
 
    DestroyWindow(parent);
}

Referenced by START_TEST().

◆ test_autoradio_kbd_move()

static void test_autoradio_kbd_move ( void )

static

Definition at line 7586 of file msg.c.

{
    HWND parent, radio1, radio2, radio3, hwnd;
    RECT rc;
    MSG msg;
    DWORD ret;
 
    subclass_button();
 
    parent = CreateDialogParamA(0, "AUTORADIO_TEST_DIALOG_2", 0, radio_test_dlg_proc, 0);
    ok(parent != 0, "failed to create parent window\n");
 
    radio1 = GetDlgItem(parent, ID_RADIO1);
    radio2 = GetDlgItem(parent, ID_RADIO2);
    radio3 = GetDlgItem(parent, ID_RADIO3);
 
    flush_events();
    flush_sequence();
 
    test_radio(radio1, 0, radio2, 0, radio3, 0);
    set_radio(radio1, 1, radio2, 1, radio3, 1);
    test_radio(radio1, 1, radio2, 1, radio3, 1);
 
    SetFocus(radio3);
 
    flush_events();
    flush_sequence();
 
    log_all_parent_messages++;
 
    SendMessageA(radio3, WM_KEYDOWN, VK_UP, 0);
    SendMessageA(radio3, WM_KEYUP, VK_UP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_VK_UP_child, "press/release VK_UP on auto-radio button", FALSE);
 
    test_radio(radio1, 1, radio2, 1, radio3, 1);
 
    flush_events();
    flush_sequence();
 
    DefDlgProcA(parent, WM_KEYDOWN, VK_UP, 0);
    DefDlgProcA(parent, WM_KEYUP, VK_UP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_VK_UP_parent, "press/release VK_UP on dialog", FALSE);
 
    test_radio(radio1, 1, radio2, 1, radio3, 1);
 
    SetFocus(radio3);
    GetWindowRect(radio3, &rc);
 
    flush_events();
    flush_sequence();
 
    msg.hwnd = parent;
    msg.message = WM_KEYDOWN;
    msg.wParam = VK_UP;
    msg.lParam = 0;
    msg.pt.x = rc.left + 1;
    msg.pt.y = rc.top + 1;
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    if (0) /* actual message sequence is different on every run in some Windows setups */
        ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #1", FALSE);
    /* what really matters is that nothing has changed */
    test_radio(radio1, 1, radio2, 1, radio3, 1);
 
    set_radio(radio1, 0, radio2, 1, radio3, 1);
    test_radio(radio1, 0, radio2, 1, radio3, 1);
 
    flush_events();
    flush_sequence();
 
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    if (0) /* actual message sequence is different on every run in some Windows setups */
        ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #2", FALSE);
    /* what really matters is that nothing has changed */
    test_radio(radio1, 0, radio2, 1, radio3, 1);
 
    /* switch from radio3 ro radio1 */
    SetFocus(radio3);
    GetWindowRect(radio3, &rc);
 
    flush_events();
    flush_sequence();
 
    msg.hwnd = parent;
    msg.message = WM_KEYDOWN;
    msg.wParam = VK_DOWN;
    msg.lParam = 0;
    msg.pt.x = rc.left + 1;
    msg.pt.y = rc.top + 1;
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_VK_DOWN_dialog, "IsDialogMessage(VK_DOWN)", TRUE);
 
    test_radio(radio1, 1, radio2, 0, radio3, 0);
 
    hwnd = GetFocus();
    ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
    GetWindowRect(radio1, &rc);
 
    msg.hwnd = parent;
    msg.message = WM_KEYDOWN;
    msg.wParam = VK_DOWN;
    msg.lParam = 0;
    msg.pt.x = rc.left + 1;
    msg.pt.y = rc.top + 1;
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_VK_DOWN_radio3, "down to radio3", TRUE);
 
    test_radio(radio1, 1, radio2, 0, radio3, 0);
 
    hwnd = GetFocus();
    ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
 
    flush_events();
    flush_sequence();
 
    msg.hwnd = parent;
    msg.message = WM_KEYDOWN;
    msg.wParam = VK_UP;
    msg.lParam = 0;
    msg.pt.x = rc.left + 1;
    msg.pt.y = rc.top + 1;
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(auto_radio_button_VK_UP_radio1, "up to radio1", TRUE);
 
    test_radio(radio1, 1, radio2, 0, radio3, 0);
 
    hwnd = GetFocus();
    ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
 
    flush_events();
    flush_sequence();
 
    msg.hwnd = parent;
    msg.message = WM_KEYDOWN;
    msg.wParam = VK_UP;
    msg.lParam = 0;
    msg.pt.x = rc.left + 1;
    msg.pt.y = rc.top + 1;
    ret = IsDialogMessageA(parent, &msg);
    ok(ret, "IsDialogMessage should return TRUE\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    if (0) /* actual message sequence is different on every run in some Windows setups */
        ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #3", FALSE);
    /* what really matters is that nothing has changed */
    test_radio(radio1, 1, radio2, 0, radio3, 0);
 
    log_all_parent_messages--;
 
    DestroyWindow(parent);
}

Referenced by START_TEST().

◆ test_broadcast()

static void test_broadcast ( void )

static

Definition at line 18476 of file msg.c.

{
    static const UINT messages[] =
    {
        WM_USER-1,
        WM_USER,
        WM_USER+1,
        0xc000-1,
        0xc000, /* lowest possible atom returned by RegisterWindowMessage */
        0xffff,
    };
    static const struct
    {
        LONG style;
        BOOL receive;
    } bcast_expect[] =
    {
        {WS_OVERLAPPED,             TRUE},
        {WS_OVERLAPPED|WS_DLGFRAME, TRUE},
        {WS_OVERLAPPED|WS_BORDER,   TRUE},
        {WS_OVERLAPPED|WS_CAPTION,  TRUE},
        {WS_CHILD,                  FALSE},
        {WS_CHILD|WS_DLGFRAME,      FALSE},
        {WS_CHILD|WS_BORDER,        FALSE},
        {WS_CHILD|WS_CAPTION,       FALSE},
        {WS_CHILD|WS_POPUP,         TRUE},
        {WS_POPUP,                  TRUE},
        {WS_POPUP|WS_DLGFRAME,      TRUE},
        {WS_POPUP|WS_BORDER,        TRUE},
        {WS_POPUP|WS_CAPTION,       TRUE},
    };
    WNDPROC oldproc;
    unsigned int i, j;
    HWND hwnd;
    HWND *hwnd_sub;
 
    hwnd_sub = malloc(ARRAY_SIZE(bcast_expect) * sizeof(*hwnd_sub));
    g_oldproc_sub = malloc(ARRAY_SIZE(bcast_expect) * sizeof(*g_oldproc_sub));
    g_broadcast_sub_wparam = malloc(ARRAY_SIZE(bcast_expect) * sizeof(*g_broadcast_sub_wparam));
 
    hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, NULL);
    ok(hwnd != NULL, "got %p\n", hwnd);
 
    oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)broadcast_test_proc);
    SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 
    for (i = 0; i < ARRAY_SIZE(messages); i++)
    {
        BOOL ret;
        BOOL msg_expected = (messages[i] < WM_USER || messages[i] >= 0xc000);
        MSG msg;
 
        flush_events();
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
            ;
 
        /* post, broadcast */
        ret = PostMessageA(HWND_BROADCAST, messages[i], 0, 0);
        ok(ret, "%d: got %d, error %ld\n", i, ret, GetLastError());
 
        memset(&msg, 0xab, sizeof(msg));
        ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
        ok(ret == msg_expected, "%d: message %04x, got %d, error %ld\n", i, messages[i], ret, GetLastError());
        if (msg_expected)
            ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
 
        /* post, topmost */
        ret = PostMessageA(HWND_TOPMOST, messages[i], 0, 0);
        ok(ret, "%d: got %d, error %ld\n", i, ret, GetLastError());
 
        memset(&msg, 0xab, sizeof(msg));
        ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
        ok(ret == msg_expected, "%d: message %04x, got %d, error %ld\n", i, messages[i], ret, GetLastError());
        if (msg_expected)
            ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
    }
 
    for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
    {
        hwnd_sub[j] = CreateWindowA("static", NULL, bcast_expect[j].style, 0, 0, 0, 0, hwnd, 0, 0, NULL);
        ok(hwnd_sub[j] != NULL, "got %p\n", hwnd_sub[j]);
        /* CreateWindow adds extra style flags, so call SetWindowLong to clear some of those. */
        SetWindowLongA(hwnd_sub[j], GWL_STYLE, bcast_expect[j].style);
 
        g_oldproc_sub[j] = (WNDPROC)SetWindowLongPtrA(hwnd_sub[j], GWLP_WNDPROC, (LONG_PTR)broadcast_test_sub_proc);
        SetWindowLongPtrA(hwnd_sub[j], GWLP_USERDATA, (LONG_PTR)j);
    }
 
    for (i = 0; i < ARRAY_SIZE(messages); i++)
    {
        BOOL ret;
        BOOL msg_expected = (messages[i] < WM_USER || messages[i] >= 0xc000);
 
        /* send, broadcast */
        g_broadcast_wparam = 0xdead;
        for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
            g_broadcast_sub_wparam[j] = 0xdead;
        g_broadcast_msg = messages[i];
        ret = SendMessageTimeoutA(HWND_BROADCAST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
        if (!ret && GetLastError() == ERROR_TIMEOUT)
            win_skip("broadcasting test %d, timeout\n", i);
        else
        {
            WPARAM wparam_expected = msg_expected ? 0xbaadbeef : 0xdead;
            ok(g_broadcast_wparam == wparam_expected, "%d: message %04x, got %#Ix, error %ld\n",
                i, messages[i], g_broadcast_wparam, GetLastError());
            for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
            {
                wparam_expected = (msg_expected && bcast_expect[j].receive) ? 0xbaadbeef : 0xdead;
                ok(g_broadcast_sub_wparam[j] == wparam_expected,
                    "%d,%d: message %04x, got %#Ix, error %ld\n", i, j, messages[i],
                    g_broadcast_sub_wparam[j], GetLastError());
            }
        }
 
        /* send, topmost */
        g_broadcast_wparam = 0xdead;
        for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
            g_broadcast_sub_wparam[j] = 0xdead;
        ret = SendMessageTimeoutA(HWND_TOPMOST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
        if (!ret && GetLastError() == ERROR_TIMEOUT)
            win_skip("broadcasting test %d, timeout\n", i);
        else
        {
            WPARAM wparam_expected = msg_expected ? 0xbaadbeef : 0xdead;
            ok(g_broadcast_wparam == wparam_expected, "%d: message %04x, got %#Ix, error %ld\n",
                i, messages[i], g_broadcast_wparam, GetLastError());
            for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
            {
                wparam_expected = (msg_expected && bcast_expect[j].receive) ? 0xbaadbeef : 0xdead;
                ok(g_broadcast_sub_wparam[j] == wparam_expected,
                    "%d,%d: message %04x, got %#Ix, error %ld\n", i, j, messages[i],
                    g_broadcast_sub_wparam[j], GetLastError());
            }
        }
    }
 
    for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
        DestroyWindow(hwnd_sub[j]);
 
    free(g_broadcast_sub_wparam);
    free(g_oldproc_sub);
    free(hwnd_sub);
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_button_bm_get_set_image()

static void test_button_bm_get_set_image ( void )

static

Definition at line 7202 of file msg.c.

{
    HWND hwnd;
    HDC hdc;
    HBITMAP hbmp1x1;
    HBITMAP hbmp2x2;
    HBITMAP hmask2x2;
    ICONINFO icon_info2x2;
    HICON hicon2x2;
    HBITMAP hbmp;
    HICON hicon;
    ICONINFO icon_info;
    BITMAP bm;
    DWORD default_style = BS_PUSHBUTTON | WS_TABSTOP | WS_POPUP | WS_VISIBLE;
    LRESULT ret;
 
    hdc = GetDC(0);
    hbmp1x1 = CreateCompatibleBitmap(hdc, 1, 1);
    hbmp2x2 = CreateCompatibleBitmap(hdc, 2, 2);
    ZeroMemory(&bm, sizeof(bm));
    ok(GetObjectW(hbmp1x1, sizeof(bm), &bm), "Expect GetObjectW() success\n");
    ok(bm.bmWidth == 1 && bm.bmHeight == 1, "Expect bitmap size: %d,%d, got: %d,%d\n", 1, 1,
       bm.bmWidth, bm.bmHeight);
    ZeroMemory(&bm, sizeof(bm));
    ok(GetObjectW(hbmp2x2, sizeof(bm), &bm), "Expect GetObjectW() success\n");
    ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
       bm.bmWidth, bm.bmHeight);
 
    hmask2x2 = CreateCompatibleBitmap(hdc, 2, 2);
    ZeroMemory(&icon_info2x2, sizeof(icon_info2x2));
    icon_info2x2.fIcon = TRUE;
    icon_info2x2.hbmMask = hmask2x2;
    icon_info2x2.hbmColor = hbmp2x2;
    hicon2x2 = CreateIconIndirect(&icon_info2x2);
 
    ZeroMemory(&icon_info, sizeof(icon_info));
    ok(GetIconInfo(hicon2x2, &icon_info), "Expect GetIconInfo() success\n");
    ZeroMemory(&bm, sizeof(bm));
    ok(GetObjectW(icon_info.hbmColor, sizeof(bm), &bm), "Expect GetObjectW() success\n");
    ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
       bm.bmWidth, bm.bmHeight);
    DeleteObject(icon_info.hbmColor);
    DeleteObject(icon_info.hbmMask);
 
    /* Set bitmap with BS_BITMAP */
    hwnd = CreateWindowA("Button", "test", default_style | BS_BITMAP, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd not NULL\n");
    SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
    hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
    ok(hbmp != 0, "Expect hbmp not 0\n");
    ZeroMemory(&bm, sizeof(bm));
    ok(GetObjectW(hbmp, sizeof(bm), &bm), "Expect GetObjectW() success\n");
    ok(bm.bmWidth == 1 && bm.bmHeight == 1, "Expect bitmap size: %d,%d, got: %d,%d\n", 1, 1,
       bm.bmWidth, bm.bmHeight);
    DestroyWindow(hwnd);
 
    /* Set bitmap without BS_BITMAP */
    hwnd = CreateWindowA("Button", "test", default_style, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd not NULL\n");
    ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
    ok(ret == 0, "Expect ret to be 0\n");
    hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
    ok(hbmp == NULL, "Expect hbmp to be NULL\n");
    DestroyWindow(hwnd);
 
    /* Set icon with BS_ICON */
    hwnd = CreateWindowA("Button", "test", default_style | BS_ICON, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd not NULL\n");
    SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
    hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
    ok(hicon != NULL, "Expect hicon not NULL\n");
    ZeroMemory(&icon_info, sizeof(icon_info));
    ok(GetIconInfo(hicon, &icon_info), "Expect GetIconInfo() success\n");
    ZeroMemory(&bm, sizeof(bm));
    ok(GetObjectW(icon_info.hbmColor, sizeof(bm), &bm), "Expect GetObjectW() success\n");
    ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
       bm.bmWidth, bm.bmHeight);
    DeleteObject(icon_info.hbmColor);
    DeleteObject(icon_info.hbmMask);
    DestroyWindow(hwnd);
 
    /* Set icon without BS_ICON */
    hwnd = CreateWindowA("Button", "test", default_style, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd not NULL\n");
    ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
    ok(ret == 0, "Expect ret to be 0\n");
    hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
    ok(hicon == NULL, "Expect hicon to be NULL\n");
    DestroyWindow(hwnd);
 
    /* Set icon with BS_BITMAP */
    hwnd = CreateWindowA("Button", "test", default_style | BS_BITMAP, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd to be not NULL\n");
    ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
    ok(ret == 0, "Expect ret to be 0\n");
    hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
    ok(hicon == NULL, "Expect hicon to be NULL\n");
    DestroyWindow(hwnd);
 
    /* Set bitmap with BS_ICON */
    hwnd = CreateWindowA("Button", "test", default_style | BS_ICON, 0, 0, 100, 100, 0, 0, 0, 0);
    ok(hwnd != NULL, "Expect hwnd to be not NULL\n");
    ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
    ok(ret == 0, "Expect ret to be 0\n");
    hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
    ok(hbmp == NULL, "Expect hbmp to be NULL\n");
    DestroyWindow(hwnd);
 
    DestroyIcon(hicon2x2);
    DeleteObject(hmask2x2);
    DeleteObject(hbmp2x2);
    DeleteObject(hbmp1x1);
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

◆ test_button_messages()

static void test_button_messages ( void )

static

Definition at line 6869 of file msg.c.

{
    static const struct
    {
        DWORD style;
        DWORD dlg_code;
        const struct message *setfocus;
        const struct message *killfocus;
        const struct message *setstyle;
        const struct message *setstate;
        const struct message *clearstate;
        const struct message *setcheck;
        const struct message *lbuttondown;
        const struct message *lbuttonup;
        const struct message *setfont;
        const struct message *settext;
    } button[] = {
        { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
          WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
          WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
          WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
          WmSetTextButtonSeq },
        { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
          WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
          WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
          WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
          WmSetTextButtonSeq },
        { BS_CHECKBOX, DLGC_BUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_AUTOCHECKBOX, DLGC_BUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_3STATE, DLGC_BUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_AUTO3STATE, DLGC_BUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_GROUPBOX, DLGC_STATIC,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckIgnoredSeq,
          WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
          WmSetTextGroupSeq },
        { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
          WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleUserSeq,
          WmSetStateUserSeq, WmClearStateButtonSeq, WmSetCheckIgnoredSeq,
          WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
          WmSetTextButtonSeq },
        { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
          WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
          WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
          NULL /* avoid infinite loop */, WmLButtonUpBrokenSeq, WmSetFontStaticSeq,
          WmSetTextStaticSeq },
        { BS_OWNERDRAW, DLGC_BUTTON,
          WmSetFocusOwnerdrawSeq, WmKillFocusOwnerdrawSeq, WmSetStyleOwnerdrawSeq,
          WmSetStateOwnerdrawSeq, WmClearStateOwnerdrawSeq, WmSetCheckIgnoredSeq,
          WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontOwnerdrawSeq,
          WmSetTextButtonSeq },
    };
    LOGFONTA logfont = { 0 };
    HFONT zfont, hfont2;
    unsigned int i;
    HWND hwnd, parent;
    DWORD dlg_code;
 
    /* selection with VK_SPACE should capture button window */
    hwnd = CreateWindowExA(0, "button", "test", BS_CHECKBOX | WS_VISIBLE | WS_POPUP,
                           0, 0, 50, 14, 0, 0, 0, NULL);
    ok(hwnd != 0, "Failed to create button window\n");
    ReleaseCapture();
    SetFocus(hwnd);
    SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
    ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n");
    SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
    DestroyWindow(hwnd);
 
    subclass_button();
 
    parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             100, 100, 200, 200, 0, 0, 0, NULL);
    ok(parent != 0, "Failed to create parent window\n");
 
    memset(&logfont, 0, sizeof(logfont));
    logfont.lfHeight = -12;
    logfont.lfWeight = FW_NORMAL;
    strcpy(logfont.lfFaceName, "Tahoma");
 
    hfont2 = CreateFontIndirectA(&logfont);
    ok(hfont2 != NULL, "Failed to create Tahoma font\n");
 
    for (i = 0; i < ARRAY_SIZE(button); i++)
    {
        MSG msg;
        DWORD style, state;
        HFONT prevfont;
        char desc[64];
        HDC hdc;
 
        if (winetest_debug > 1) trace("button style %08lx\n", button[i].style);
 
        hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_CHILD | BS_NOTIFY,
                               0, 0, 50, 14, parent, (HMENU)ID_BUTTON, 0, NULL);
        ok(hwnd != 0, "Failed to create button window\n");
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_CHILD | BS_NOTIFY);
        /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
        if (button[i].style == BS_USERBUTTON)
            ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %lx\n", style);
        else
            ok(style == button[i].style, "expected style %lx got %lx\n", button[i].style, style);
 
        dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
        ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08lx\n", i, dlg_code);
 
        ShowWindow(hwnd, SW_SHOW);
        UpdateWindow(hwnd);
        SetFocus(0);
        flush_events();
        SetFocus(0);
        flush_sequence();
 
        log_all_parent_messages++;
 
        ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
        SetFocus(hwnd);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
 
        SetFocus(0);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
 
        ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
 
        SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].setstyle, "BM_SETSTYLE on a button", FALSE);
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY);
        /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */
        ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
 
        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
        ok(state == 0, "expected state 0, got %04lx\n", state);
 
        flush_sequence();
 
        SendMessageA(hwnd, BM_SETSTATE, TRUE, 0);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].setstate, "BM_SETSTATE/TRUE on a button", FALSE);
 
        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
        ok(state == 0x0004, "expected state 0x0004, got %04lx\n", state);
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
        ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
 
        flush_sequence();
 
        SendMessageA(hwnd, BM_SETSTATE, FALSE, 0);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].clearstate, "BM_SETSTATE/FALSE on a button", FALSE);
 
        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
        ok(state == 0, "expected state 0, got %04lx\n", state);
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
        ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
 
        state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
        ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04lx\n", state);
 
        flush_sequence();
 
        SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(WmSetCheckIgnoredSeq, "BM_SETCHECK on a button", FALSE);
 
        state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
        ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04lx\n", state);
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
        ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
 
        flush_sequence();
 
        SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        ok_sequence(button[i].setcheck, "BM_SETCHECK on a button", FALSE);
 
        SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 1");
        sprintf(desc, "button[%i]: WM_SETTEXT on a visible button", i);
        ok_sequence(button[i].settext, desc, FALSE);
 
        ShowWindow(hwnd, SW_HIDE);
        flush_events();
        flush_sequence();
 
        SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 2");
        sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
        ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
 
        ShowWindow(hwnd, SW_SHOW);
        ShowWindow(parent, SW_HIDE);
        flush_events();
        flush_sequence();
 
        SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 3");
        sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
        ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
 
        ShowWindow(parent, SW_SHOW);
        flush_events();
 
        state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
        if (button[i].style == BS_PUSHBUTTON ||
            button[i].style == BS_DEFPUSHBUTTON ||
            button[i].style == BS_GROUPBOX ||
            button[i].style == BS_USERBUTTON ||
            button[i].style == BS_OWNERDRAW)
            ok(state == BST_UNCHECKED, "expected check 0, got %04lx\n", state);
        else
            ok(state == BST_CHECKED, "expected check 1, got %04lx\n", state);
 
        style = GetWindowLongA(hwnd, GWL_STYLE);
        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
        if (button[i].style == BS_RADIOBUTTON ||
            button[i].style == BS_AUTORADIOBUTTON)
            ok(style == (button[i].style | WS_TABSTOP), "expected style %04lx | WS_TABSTOP got %04lx\n", button[i].style, style);
        else
            ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
 
        log_all_parent_messages--;
 
        DestroyWindow(hwnd);
 
        hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP | WS_VISIBLE,
                               0, 0, 50, 14, 0, 0, 0, NULL);
        ok(hwnd != 0, "Failed to create button window\n");
 
        SetForegroundWindow(hwnd);
        flush_events();
 
        SetActiveWindow(hwnd);
        SetFocus(0);
        flush_sequence();
 
        if (button[i].lbuttondown)
        {
            SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
            sprintf(desc, "button[%i]: WM_LBUTTONDOWN on a button", i);
            ok_sequence(button[i].lbuttondown, desc, FALSE);
        }
 
        SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
        sprintf(desc, "button[%i]: WM_LBUTTONUP on a button", i);
        ok_sequence(button[i].lbuttonup, desc, FALSE);
 
        flush_sequence();
        zfont = GetStockObject(DEFAULT_GUI_FONT);
        SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
        UpdateWindow(hwnd);
        sprintf(desc, "button[%i]: WM_SETFONT on a button", i);
        ok_sequence(button[i].setfont, desc, FALSE);
 
        /* Test that original font is not selected back after painting */
        hdc = CreateCompatibleDC(0);
 
        prevfont = SelectObject(hdc, hfont2);
        ok(prevfont == GetStockObject(SYSTEM_FONT), "Unexpected default font\n");
        SendMessageA(hwnd, WM_PRINTCLIENT, (WPARAM)hdc, 0);
        ok(hfont2 != GetCurrentObject(hdc, OBJ_FONT), "button[%u]: unexpected font selected after WM_PRINTCLIENT\n", i);
        SelectObject(hdc, prevfont);
 
        prevfont = SelectObject(hdc, hfont2);
        ok(prevfont == GetStockObject(SYSTEM_FONT), "Unexpected default font\n");
        SendMessageA(hwnd, WM_PAINT, (WPARAM)hdc, 0);
        ok(hfont2 != GetCurrentObject(hdc, OBJ_FONT), "button[%u]: unexpected font selected after WM_PAINT\n", i);
        SelectObject(hdc, prevfont);
 
        DeleteDC(hdc);
 
        DestroyWindow(hwnd);
    }
 
    DeleteObject(hfont2);
    DestroyWindow(parent);
 
    /* Test if WM_LBUTTONDOWN and WM_LBUTTONUP to a disabled button leads to a WM_COMMAND for the parent */
 
    parent = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
            100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
 
    hwnd = CreateWindowExA(0, "my_button_class", "test", BS_DEFPUSHBUTTON | WS_VISIBLE | WS_CHILD,
                                   0, 0, 50, 14, parent, 0, 0, NULL);
 
    EnableWindow(hwnd, FALSE);
    flush_sequence();
    SendMessageA(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, 0);
    SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
    ok_sequence(WmDisableButtonSeq, "Mouseclick on a disabled button", FALSE);
 
    DestroyWindow(hwnd);
    DestroyWindow(parent);
}

Referenced by START_TEST().

◆ test_button_style()

static void test_button_style ( void )

static

Definition at line 20591 of file msg.c.

{
    DWORD type, expected_type;
    HWND button;
    LRESULT ret;
    DWORD i, j;
 
    for (i = BS_PUSHBUTTON; i <= BS_DEFCOMMANDLINK; ++i)
    {
        button = CreateWindowA(WC_BUTTONA, "test", i, 0, 0, 50, 50, NULL, 0, 0, NULL);
        ok(button != NULL, "Expected button not null.\n");
 
        type = GetWindowLongW(button, GWL_STYLE) & BS_TYPEMASK;
        expected_type = (i == BS_USERBUTTON ? BS_PUSHBUTTON : i);
        ok(type == expected_type, "Expected type %#lx, got %#lx.\n", expected_type, type);
 
        for (j = BS_PUSHBUTTON; j <= BS_DEFCOMMANDLINK; ++j)
        {
            ret = SendMessageA(button, BM_SETSTYLE, j, FALSE);
            ok(ret == 0, "Expected %#x, got %#Ix.\n", 0, ret);
 
            type = GetWindowLongW(button, GWL_STYLE) & BS_TYPEMASK;
            expected_type = j;
 
            ok(type == expected_type, "Original type %#lx, expected new type %#lx, got %#lx.\n", i,
                    expected_type, type);
        }
        DestroyWindow(button);
    }
}

Referenced by START_TEST().

◆ test_clipboard_viewers()

static void test_clipboard_viewers ( void )

static

Definition at line 18258 of file msg.c.

{
    static struct message wm_change_cb_chain[] =
    {
        { WM_CHANGECBCHAIN, sent|wparam|lparam, 0, 0 },
        { 0 }
    };
    static const struct message wm_clipboard_destroyed[] =
    {
        { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
        { 0 }
    };
    static struct message wm_clipboard_changed[] =
    {
        { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
        { 0 }
    };
    static struct message wm_clipboard_changed_and_owned[] =
    {
        { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
        { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
        { 0 }
    };
 
    HINSTANCE hInst = GetModuleHandleA(NULL);
    HWND hWnd1, hWnd2, hWnd3;
    HWND hOrigViewer;
    HWND hRet;
 
    hWnd1 = CreateWindowExA(0, "TestWindowClass", "Clipboard viewer test wnd 1",
        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        GetDesktopWindow(), NULL, hInst, NULL);
    ok(!!hWnd1, "Failed to create window, error %lu.\n", GetLastError());
    hWnd2 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 2",
        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        GetDesktopWindow(), NULL, hInst, NULL);
    ok(!!hWnd2, "Failed to create window, error %lu.\n", GetLastError());
    hWnd3 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 3",
        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        GetDesktopWindow(), NULL, hInst, NULL);
    ok(!!hWnd3, "Failed to create window, error %lu.\n", GetLastError());
    if (winetest_debug > 1) trace("clipbd viewers: hWnd1=%p, hWnd2=%p, hWnd3=%p\n", hWnd1, hWnd2, hWnd3);
 
    CountClipboardFormats(); /* Ensure that we do not have an X11 update to the clipboard */
    flush_sequence();
 
    /* Test getting the clipboard viewer and setting the viewer to NULL. */
    hOrigViewer = GetClipboardViewer();
    hRet = SetClipboardViewer(NULL);
    ok_sequence(WmEmptySeq, "set viewer to NULL", FALSE);
    expect_HWND(hOrigViewer, hRet);
    expect_HWND(NULL, GetClipboardViewer());
 
    /* Test registering hWnd1 as a viewer. */
    hRet = SetClipboardViewer(hWnd1);
    wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
    ok_sequence(wm_clipboard_changed, "set viewer NULL->1", FALSE);
    expect_HWND(NULL, hRet);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    /* Test that changing the clipboard actually refreshes the registered viewer. */
    clear_clipboard(hWnd1);
    wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
    ok_sequence(wm_clipboard_changed, "clear clipbd (viewer=owner=1)", FALSE);
 
    /* Again, but with different owner. */
    clear_clipboard(hWnd2);
    wm_clipboard_changed_and_owned[1].wParam = (WPARAM) GetClipboardOwner();
    ok_sequence(wm_clipboard_changed_and_owned, "clear clipbd (viewer=1, owner=2)", FALSE);
 
    /* Test re-registering same window. */
    hRet = SetClipboardViewer(hWnd1);
    wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
    ok_sequence(wm_clipboard_changed, "set viewer 1->1", FALSE);
    expect_HWND(hWnd1, hRet);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    /* Test ChangeClipboardChain. */
    ChangeClipboardChain(hWnd2, hWnd3);
    wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
    wm_change_cb_chain[0].lParam = (LPARAM) hWnd3;
    ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=3)", FALSE);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    ChangeClipboardChain(hWnd2, NULL);
    wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
    wm_change_cb_chain[0].lParam = 0;
    ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=NULL)", FALSE);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    ChangeClipboardChain(NULL, hWnd2);
    ok_sequence(WmEmptySeq, "change chain (viewer=1, remove=NULL, next=2)", FALSE);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    /* Actually change clipboard viewer with ChangeClipboardChain. */
    ChangeClipboardChain(hWnd1, hWnd2);
    ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=2)", FALSE);
    expect_HWND(hWnd2, GetClipboardViewer());
 
    /* Test that no refresh messages are sent when viewer has unregistered. */
    clear_clipboard(hWnd2);
    ok_sequence(WmEmptySeq, "clear clipd (viewer=2, owner=1)", FALSE);
 
    /* Register hWnd1 again. */
    ChangeClipboardChain(hWnd2, hWnd1);
    ok_sequence(WmEmptySeq, "change chain (viewer=remove=2, next=1)", FALSE);
    expect_HWND(hWnd1, GetClipboardViewer());
 
    /* Subclass hWnd1 so that when it receives a WM_DRAWCLIPBOARD message, it
     * changes the clipboard. When this happens, the system shouldn't send
     * another WM_DRAWCLIPBOARD (as this could cause an infinite loop).
     */
    pOldViewerProc = (WNDPROC) SetWindowLongPtrA(hWnd1, GWLP_WNDPROC, (LONG_PTR) recursive_viewer_proc);
    clear_clipboard(hWnd2);
    /* The clipboard owner is changed in recursive_viewer_proc: */
    wm_clipboard_changed[0].wParam = (WPARAM) hWnd2;
    ok_sequence(wm_clipboard_changed, "recursive clear clipbd (viewer=1, owner=2)", TRUE);
 
    /* Test unregistering. */
    ChangeClipboardChain(hWnd1, NULL);
    ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=NULL)", FALSE);
    expect_HWND(NULL, GetClipboardViewer());
 
    clear_clipboard(hWnd1);
    ok_sequence(wm_clipboard_destroyed, "clear clipbd (no viewer, owner=1)", FALSE);
 
    DestroyWindow(hWnd1);
    DestroyWindow(hWnd2);
    DestroyWindow(hWnd3);
    SetClipboardViewer(hOrigViewer);
}

Referenced by START_TEST().

◆ test_combobox_messages()

static void test_combobox_messages ( void )

static

Definition at line 8079 of file msg.c.

{
    HWND parent, combo, button, edit, lbox;
    LRESULT ret;
    COMBOBOXINFO cbInfo;
    BOOL res;
 
    subclass_combobox();
 
    parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             100, 100, 200, 200, 0, 0, 0, NULL);
    ok(parent != 0, "Failed to create parent window\n");
    flush_sequence();
 
    combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
                           0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
    ok(combo != 0, "Failed to create combobox window\n");
 
    UpdateWindow(combo);
 
    ret = SendMessageA(combo, WM_GETDLGCODE, 0, 0);
    ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08Ix\n", ret);
 
    ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
    ok(ret == 2, "expected 2, got %Id\n", ret);
 
    SendMessageA(combo, CB_SETCURSEL, 0, 0);
    SetFocus(combo);
    flush_sequence();
 
    log_all_parent_messages++;
    SendMessageA(combo, WM_KEYDOWN, VK_DOWN, 0);
    SendMessageA(combo, WM_KEYUP, VK_DOWN, 0);
    log_all_parent_messages--;
    ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
 
    flush_sequence();
    SetWindowPos(combo, 0, 10, 10, 120, 130, SWP_NOZORDER);
    ok_sequence(WmSetPosComboSeq, "repositioning messages on a ComboBox", FALSE);
 
    DestroyWindow(combo);
    DestroyWindow(parent);
 
    /* Start again. Test combobox text selection when getting and losing focus */
    parent = CreateWindowExA(0, "TestParentClass", "Parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             10, 10, 300, 300, NULL, NULL, NULL, NULL);
    ok(parent != 0, "Failed to create parent window\n");
 
    combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
                            5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
    ok(combo != 0, "Failed to create combobox window\n");
 
    cbInfo.cbSize = sizeof(COMBOBOXINFO);
    SetLastError(0xdeadbeef);
    res = GetComboBoxInfo(combo, &cbInfo);
    ok(res, "Failed to get COMBOBOXINFO structure; LastError: %lu\n", GetLastError());
    edit = cbInfo.hwndItem;
 
    edit_window_proc = (WNDPROC)SetWindowLongPtrA(edit, GWLP_WNDPROC,
            (ULONG_PTR)combobox_edit_subclass_proc);
 
    button = CreateWindowExA(0, "Button", "OK", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
                             5, 50, 100, 20, parent, NULL,
                             (HINSTANCE)GetWindowLongPtrA(parent, GWLP_HINSTANCE), NULL);
    ok(button != 0, "Failed to create button window\n");
 
    flush_sequence();
    log_all_parent_messages++;
    SendMessageA(combo, WM_SETFOCUS, 0, (LPARAM)edit);
    log_all_parent_messages--;
    ok_sequence(WMSetFocusComboBoxSeq, "WM_SETFOCUS on a ComboBox", TRUE);
 
    flush_sequence();
    log_all_parent_messages++;
    SetFocus(button);
    log_all_parent_messages--;
    ok_sequence(SetFocusButtonSeq, "SetFocus on a Button", TRUE);
 
    SendMessageA(combo, WM_SETTEXT, 0, (LPARAM)"Wine Test");
 
    flush_sequence();
    log_all_parent_messages++;
    SetFocus(combo);
    log_all_parent_messages--;
    ok_sequence(SetFocusComboBoxSeq, "SetFocus on a ComboBox", TRUE);
 
    flush_sequence();
    log_all_parent_messages++;
    SetFocus(button);
    log_all_parent_messages--;
    ok_sequence(SetFocusButtonSeq2, "SetFocus on a Button (2)", TRUE);
 
    SetFocus(combo);
    SendMessageA(combo, WM_SETREDRAW, FALSE, 0);
    flush_sequence();
    log_all_parent_messages++;
    SendMessageA(combo, CB_SETCURSEL, 0, 0);
    log_all_parent_messages--;
    ok_sequence(SetCurSelComboSeq_edit, "CB_SETCURSEL on a ComboBox with edit control", FALSE);
 
    DestroyWindow(button);
    DestroyWindow(combo);
 
    combo = CreateWindowExA(0, "my_combobox_class", "test",
                            WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED | CBS_DROPDOWNLIST,
                            5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
    ok(combo != 0, "Failed to create combobox window\n");
 
    ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 0, "expected 0, got %Id\n", ret);
 
    cbInfo.cbSize = sizeof(COMBOBOXINFO);
    SetLastError(0xdeadbeef);
    res = GetComboBoxInfo(combo, &cbInfo);
    ok(res, "Failed to get COMBOBOXINFO structure; LastError: %lu\n", GetLastError());
    lbox = cbInfo.hwndList;
    lbox_window_proc = (WNDPROC)SetWindowLongPtrA(lbox, GWLP_WNDPROC,
            (ULONG_PTR)combobox_lbox_subclass_proc);
    flush_sequence();
 
    log_all_parent_messages++;
    SendMessageA(combo, CB_SETCURSEL, 0, 0);
    log_all_parent_messages--;
    ok_sequence(SetCurSelComboSeq, "CB_SETCURSEL on a ComboBox", FALSE);
 
    ShowWindow(combo, SW_HIDE);
    flush_sequence();
    log_all_parent_messages++;
    SendMessageA(combo, CB_SETCURSEL, 0, 0);
    log_all_parent_messages--;
    ok_sequence(SetCurSelComboSeq2, "CB_SETCURSEL on a ComboBox", FALSE);
 
    DestroyWindow(combo);
    DestroyWindow(parent);
}

Referenced by START_TEST().

◆ test_create()

static HANDLE test_create ( const char * file )

static

Definition at line 10084 of file msg.c.

{
    WCHAR path[MAX_PATH];
    ACTCTXW actctx;
    HANDLE handle;
 
    MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(ACTCTXW);
    actctx.lpSource = path;
 
    handle = CreateActCtxW(&actctx);
    ok(handle != INVALID_HANDLE_VALUE, "failed to create context, error %lu\n", GetLastError());
 
    ok(actctx.cbSize == sizeof(actctx), "cbSize=%ld\n", actctx.cbSize);
    ok(actctx.dwFlags == 0, "dwFlags=%ld\n", actctx.dwFlags);
    ok(actctx.lpSource == path, "lpSource=%p\n", actctx.lpSource);
    ok(actctx.wProcessorArchitecture == 0, "wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
    ok(actctx.wLangId == 0, "wLangId=%d\n", actctx.wLangId);
    ok(actctx.lpAssemblyDirectory == NULL, "lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
    ok(actctx.lpResourceName == NULL, "lpResourceName=%p\n", actctx.lpResourceName);
    ok(actctx.lpApplicationName == NULL, "lpApplicationName=%p\n", actctx.lpApplicationName);
    ok(actctx.hModule == NULL, "hModule=%p\n", actctx.hModule);
 
    return handle;
}

◆ test_create_name()

static void test_create_name ( void )

static

Definition at line 20641 of file msg.c.

{
    WNDCLASSW clsW = { 0 };
    WCHAR name_buf[3];
    HWND hwnd;
 
    clsW.lpfnWndProc = test_create_name_procW;
    clsW.lpszClassName = L"TestCreateNameClassW";
    RegisterClassW( &clsW );
 
    hwnd = CreateWindowExW( 0, L"TestCreateNameClassW", L"\xffff\x6162",
                            WS_POPUP, 0,0,0,0,0,0,0, name_buf );
    ok( hwnd != NULL, "CreateWindowEx failed: %lu\n", GetLastError() );
    ok(!memcmp(name_buf, L"\xffff\x6162", 2 * sizeof(WCHAR)),
       "name param = %s\n", debugstr_wn(name_buf, 2));
    DestroyWindow( hwnd );
 
    hwnd = CreateWindowExA( 0, "TestCreateNameClassW", "\xff\0\x61\x60",
                            WS_POPUP, 0,0,0,0,0,0,0, name_buf );
    ok( hwnd != NULL, "CreateWindowEx failed: %lu\n", GetLastError() );
    ok(!memcmp(name_buf, L"\xffff\x6100", 2 * sizeof(WCHAR)),
       "name param = %s\n", debugstr_wn(name_buf, 2));
    DestroyWindow( hwnd );
 
    UnregisterClassW( L"TestCreateNameClassW", NULL );
}

Referenced by START_TEST().

◆ test_create_name_procW()

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

static

Definition at line 20622 of file msg.c.

{
    switch (msg)
    {
    case WM_NCCREATE:
    case WM_CREATE:
        {
            CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
            memcpy( cs->lpCreateParams, cs->lpszName, 3 * sizeof(WCHAR) );
            break;
        }
    case WM_SETTEXT:
        if (winetest_debug > 1) trace("%s\n", debugstr_w((const WCHAR *)lparam));
        break;
    }
 
    return DefWindowProcW( hwnd, msg, wparam, lparam );
}

Referenced by test_create_name().

◆ test_dbcs_wm_char()

static void test_dbcs_wm_char ( void )

static

Definition at line 16565 of file msg.c.

{
    BYTE dbch[2];
    WCHAR wch, bad_wch;
    HWND hwnd, hwnd2;
    MSG msg;
    DWORD time;
    POINT pt;
    DWORD_PTR res;
    CPINFOEXA cpinfo;
    UINT i, j, k;
    struct message wmCharSeq[2];
    BOOL ret;
    DWORD cp = get_input_codepage();
 
    if (!pGetCPInfoExA)
    {
        win_skip("GetCPInfoExA is not available\n");
        return;
    }
 
    pGetCPInfoExA( cp, 0, &cpinfo );
    if (cpinfo.MaxCharSize != 2)
    {
        skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
        return;
    }
 
    dbch[0] = dbch[1] = 0;
    wch = 0;
    bad_wch = cpinfo.UnicodeDefaultChar;
    for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
        for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
            for (k = 128; k <= 255; k++)
            {
                char str[2];
                WCHAR wstr[2];
                str[0] = j;
                str[1] = k;
                if (MultiByteToWideChar( cp, 0, str, 2, wstr, 2 ) == 1 &&
                    WideCharToMultiByte( cp, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
                    (BYTE)str[0] == j && (BYTE)str[1] == k &&
                    HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
                {
                    dbch[0] = j;
                    dbch[1] = k;
                    wch = wstr[0];
                    break;
                }
            }
 
    if (!wch)
    {
        skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
        return;
    }
    if (winetest_debug > 1) trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
           dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
 
    hwnd = CreateWindowExW(0, testWindowClassW, NULL,
                           WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
    hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
                           WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
    ok (hwnd2 != 0, "Failed to create overlapped window\n");
    flush_events();
    flush_sequence();
 
    memset( wmCharSeq, 0, sizeof(wmCharSeq) );
    wmCharSeq[0].message = WM_CHAR;
    wmCharSeq[0].flags = sent|wparam;
    wmCharSeq[0].wParam = wch;
 
    /* posted message */
    PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
    PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* posted thread message */
    PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
    PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* sent message */
    flush_sequence();
    SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* sent message with timeout */
    flush_sequence();
    SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* sent message with timeout and callback */
    flush_sequence();
    SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* sent message with callback */
    flush_sequence();
    SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* direct window proc call */
    flush_sequence();
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
 
    /* dispatch message */
    msg.hwnd = hwnd;
    msg.message = WM_CHAR;
    msg.wParam = dbch[0];
    msg.lParam = 0;
    DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    msg.wParam = dbch[1];
    DispatchMessageA( &msg );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
 
    /* window handle is irrelevant */
    flush_sequence();
    SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* interleaved post and send */
    flush_sequence();
    PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
    SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
    PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
    SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* interleaved sent message and winproc */
    flush_sequence();
    SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
 
    /* interleaved winproc and dispatch */
    msg.hwnd = hwnd;
    msg.message = WM_CHAR;
    msg.wParam = dbch[0];
    msg.lParam = 0;
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
    DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    msg.wParam = dbch[1];
    DispatchMessageA( &msg );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
 
    /* interleaved sends */
    flush_sequence();
    SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
    SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
    ok_sequence( WmEmptySeq, "no messages", FALSE );
    SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
 
    /* dbcs WM_CHAR */
    flush_sequence();
    SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
    ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* other char messages are not magic */
    PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == bad_wch, "bad wparam %Ix/%x\n", msg.wParam, bad_wch );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
    PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == bad_wch, "bad wparam %Ix/%x\n", msg.wParam, bad_wch );
    ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* test retrieving messages */
 
    PostMessageW( hwnd, WM_CHAR, wch, 0 );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* message filters */
    PostMessageW( hwnd, WM_CHAR, wch, 0 );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    /* message id is filtered, hwnd is not */
    ret = PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE );
    ok( !ret, "no message\n" );
    ret = PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* mixing GetMessage and PostMessage */
    PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
    ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ok( msg.lParam == 0xbeef, "bad lparam %Ix\n", msg.lParam );
    time = msg.time;
    pt = msg.pt;
    ok( time - GetTickCount() <= 100, "bad time %lx\n", msg.time );
    ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ok( msg.lParam == 0xbeef, "bad lparam %Ix\n", msg.lParam );
    ok( msg.time == time, "bad time %lx/%lx\n", msg.time, time );
    ok( msg.pt.x == pt.x && msg.pt.y == pt.y, "bad point %lu,%lu/%lu,%lu\n", msg.pt.x, msg.pt.y, pt.x, pt.y );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    /* without PM_REMOVE */
    PostMessageW( hwnd, WM_CHAR, wch, 0 );
    ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
    ok( ret, "no message\n" );
    ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
    ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
    ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
    ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
    ok( !ret, "got message %x\n", msg.message );
 
    DestroyWindow(hwnd);
    DestroyWindow(hwnd2);
}

Referenced by START_TEST().

◆ test_defwinproc()

static void test_defwinproc ( void )

static

Definition at line 17966 of file msg.c.

{
    HWND hwnd, child[3];
    MSG msg;
    BOOL gotwmquit = FALSE;
    POINT pos;
    RECT rect;
    INT x, y;
    LRESULT res;
    struct rbuttonup_thread_data data;
    char buffA[64];
    HANDLE thread;
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "test_defwndproc",
            WS_VISIBLE | WS_CAPTION | WS_OVERLAPPEDWINDOW, 0,0,500,100,0,0,0, NULL);
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    flush_events();
 
    buffA[0] = 0;
    GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
    ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
 
    /* Zero high word of the lParam */
    res = DefWindowProcA(hwnd, WM_SETTEXT, 0, 0x1234);
    ok(res == 0, "WM_SETTEXT was expected to fail, %Id\n", res);
 
    GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
    ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
 
    res = DefWindowProcW(hwnd, WM_SETTEXT, 0, 0x1234);
    ok(res == 0, "WM_SETTEXT was expected to fail, %Id\n", res);
 
    GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
    ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
 
    ShowWindow(hwnd, SW_MINIMIZE);
    flush_events();
    flush_sequence();
 
    DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
    flush_events();
#if !defined(__REACTOS__) || !defined(_MSC_VER) // Fails on Windows when built with MSVC
    ok_sequence(WmRestoreMinimizedOverlappedSeq, "DefWindowProcA(SC_RESTORE):overlapped", TRUE);
#endif
 
    ShowWindow(hwnd, SW_MINIMIZE);
    SetActiveWindow(hwnd);
    ok(GetActiveWindow() == hwnd, "Unexpected active window\n");
    flush_events();
    flush_sequence();
    DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
    flush_events();
#ifdef __REACTOS__
    if (GetNTVersion() != _WIN32_WINNT_VISTA && GetNTVersion() != _WIN32_WINNT_WIN7)
#endif
    ok_sequence(WmRestoreActiveMinimizedOverlappedSeq, "DefWindowProcA(SC_RESTORE):active minimized overlapped", TRUE);
 
#ifdef __REACTOS__
    if (!is_reactos() && GetNTVersion() == _WIN32_WINNT_WS03) {
        skip("The rest of these tests crash on WHS testbot!\n");
        flush_sequence();
        DestroyWindow(hwnd);
        return;
    }
#endif
    child[0] = CreateWindowExA(0, "TestWindowClass", "1st child",
                               WS_VISIBLE | WS_CHILD, 0,0,500,100, hwnd, 0, 0, NULL);
    child[1] = CreateWindowExA(0, "TestWindowClass", "2nd child",
                               WS_VISIBLE | WS_CHILD, 0,0,500,100, child[0], 0, 0, NULL);
    child[2] = CreateWindowExA(0, "TestWindowClass", "3rd child",
                               WS_VISIBLE | WS_CHILD, 0,0,500,100, child[1], 0, 0, NULL);
    flush_events();
    flush_sequence();
    test_context_menu = TRUE;
    DefWindowProcA(child[2], WM_CONTEXTMENU, 0xcafe, 0);
    test_context_menu = FALSE;
    WmContextMenuSeq[0].wParam = (WPARAM)child[2];
    WmContextMenuSeq[1].wParam = (WPARAM)child[1];
    WmContextMenuSeq[2].wParam = (WPARAM)child[0];
    ok_sequence(WmContextMenuSeq, "DefWindowProcA(WM_CONTEXTMENU)", FALSE);
    DestroyWindow(child[0]);
 
    GetCursorPos(&pos);
    GetWindowRect(hwnd, &rect);
    x = (rect.left+rect.right) / 2;
    y = rect.top + GetSystemMetrics(SM_CYFRAME) + 1;
    SetCursorPos(x, y);
    flush_events();
    res = DefWindowProcA( hwnd, WM_NCHITTEST, 0, MAKELPARAM(x, y));
    ok(res == HTCAPTION, "WM_NCHITTEST returned %Id\n", res);
 
    mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );
    mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );
    flush_events();
 
    flush_sequence();
    mouse_event( MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0 );
    /* workaround for missing support for clicking on window frame */
    data.hwnd = hwnd;
    data.wndproc_finished = CreateEventA( NULL, FALSE, FALSE, NULL );
    thread = CreateThread( NULL, 0, post_rbuttonup_msg, (void*)&data, 0, NULL );
 
    DefWindowProcA( hwnd, WM_NCRBUTTONDOWN, HTCAPTION, MAKELPARAM(x, y));
    ok_sequence(NCRBUTTONDOWNSeq, "WM_NCRBUTTONDOWN on caption", FALSE);
 
    res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, 0, MAKELPARAM(x, y));
    ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
    ok_sequence(WmEmptySeq, "WM_NCXBUTTONUP without button", FALSE);
 
    res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, XBUTTON1), MAKELPARAM(x, y));
    ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
    ok_sequence(NCXBUTTONUPSeq1, "WM_NCXBUTTONUP with XBUTTON1", FALSE);
 
    res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, XBUTTON2), MAKELPARAM(x, y));
    ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
    ok_sequence(NCXBUTTONUPSeq2, "WM_NCXBUTTONUP with XBUTTON2", FALSE);
 
    res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, 3), MAKELPARAM(x, y));
    ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
    ok_sequence(WmEmptySeq, "WM_NCXBUTTONUP with invalid button", FALSE);
 
    /* Test WM_MOUSEACTIVATE */
#define TEST_MOUSEACTIVATE(A,B,C) \
       res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,0)); \
       ok(res == B, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res); \
       res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,WM_LBUTTONDOWN)); \
       ok(res == C, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res);
 
    TEST_MOUSEACTIVATE(HTERROR,       MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTTRANSPARENT, MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTNOWHERE,     MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTCLIENT,      MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTCAPTION,     MA_ACTIVATE, MA_NOACTIVATE);
    TEST_MOUSEACTIVATE(HTSYSMENU,     MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTSIZE,        MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTMENU,        MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTHSCROLL,     MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTVSCROLL,     MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTMINBUTTON,   MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTMAXBUTTON,   MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTLEFT,        MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTRIGHT,       MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTTOP,         MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTTOPLEFT,     MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTTOPRIGHT,    MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTBOTTOM,      MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTBOTTOMLEFT,  MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTBOTTOMRIGHT, MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTBORDER,      MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTOBJECT,      MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTCLOSE,       MA_ACTIVATE, MA_ACTIVATE);
    TEST_MOUSEACTIVATE(HTHELP,        MA_ACTIVATE, MA_ACTIVATE);
 
    SetEvent( data.wndproc_finished );
    WaitForSingleObject( thread, 1000 );
    CloseHandle( data.wndproc_finished );
    CloseHandle( thread );
 
    SetCursorPos(pos.x, pos.y);
 
    DefWindowProcA( hwnd, WM_ENDSESSION, 1, 0);
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) {
        if( msg.message == WM_QUIT) gotwmquit = TRUE;
        DispatchMessageA( &msg );
    }
    ok(!gotwmquit, "Unexpected WM_QUIT message!\n");
    DestroyWindow( hwnd);
}

Referenced by START_TEST().

◆ test_desktop_winproc()

static void test_desktop_winproc ( void )

static

Definition at line 18135 of file msg.c.

{
    HINSTANCE instance = GetModuleHandleA(NULL);
    RECT rect, default_rect;
    WNDPROC desktop_proc;
    char buffer[256];
    WNDCLASSA cls;
    LRESULT res;
    HWND hwnd;
    BOOL ret;
 
    ret = GetClassInfoA(instance, (const CHAR *)MAKEINTATOM(32769), &cls);
    ok(ret, "Failed to get desktop class.\n");
    desktop_proc = cls.lpfnWndProc;
 
    memset(&cls, 0, sizeof(cls));
    cls.lpfnWndProc = desktop_proc;
    cls.hInstance = instance;
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszClassName = "TestDesktopClass";
    register_class(&cls);
 
    hwnd = CreateWindowExA(0, cls.lpszClassName, "test_desktop_wndproc",
            WS_VISIBLE | WS_CAPTION | WS_OVERLAPPEDWINDOW, 0, 0, 500, 100, 0, 0, 0, NULL);
    if (!hwnd) /* win2003 */
    {
        skip("Failed to create window with desktop window procedure.\n");
        goto out_unregister;
    }
 
    memset(&cls, 0, sizeof(cls));
    ret = GetClassInfoA(instance, "TestDesktopClass", &cls);
    ok(ret, "Failed to get class info.\n");
    ok(cls.lpfnWndProc == desktop_proc, "Got %p, expected %p.\n", cls.lpfnWndProc, desktop_proc);
 
    GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer));
    todo_wine ok(!strcmp(buffer, "test_desktop_wndproc"), "Got unexpected window text: %s.\n", buffer);
 
    res = CallWindowProcA(desktop_proc, hwnd, WM_SETTEXT, 0, (LPARAM)"test");
    ok(res == TRUE, "Failed to set text, %Id.\n", res);
    GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer));
    ok(!strcmp(buffer, "test"), "Got unexpected window text: %s.\n", buffer);
 
    SetRect(&default_rect, 0, 0, 100, 100);
    res = DefWindowProcW(hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&default_rect);
    ok(!res, "Got unexpected result %Id.\n", res);
 
    SetRect(&rect, 0, 0, 100, 100);
    res = CallWindowProcA(desktop_proc, hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect);
    ok(!res, "Got unexpected result %Id.\n", res);
    todo_wine ok(EqualRect(&rect, &default_rect), "rect Got %s, expected %s.\n",
            wine_dbgstr_rect(&rect), wine_dbgstr_rect(&default_rect));
 
    DestroyWindow(hwnd);
 
out_unregister:
    UnregisterClassA("TestDesktopClass", instance);
}

Referenced by START_TEST().

◆ test_DestroyWindow()

static void test_DestroyWindow ( void )

static

Definition at line 12945 of file msg.c.

{
    BOOL ret;
    HWND parent, child1, child2, child3, child4, test;
    UINT_PTR child_id = WND_CHILD_ID + 1;
 
    parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                 100, 100, 200, 200, 0, 0, 0, NULL);
    ok(!!parent, "Failed to create window, error %lu.\n", GetLastError());
    child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
                 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
    ok(!!child1, "Failed to create window, error %lu.\n", GetLastError());
    child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
                 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
    ok(!!child2, "Failed to create window, error %lu.\n", GetLastError());
    child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
                 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
    ok(!!child3, "Failed to create window, error %lu.\n", GetLastError());
    child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
                 0, 0, 50, 50, parent, 0, 0, NULL);
    ok(!!child4, "Failed to create window, error %lu.\n", GetLastError());
 
    /* test owner/parent of child2 */
    test = GetParent(child2);
    ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
    ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
    test = GetAncestor(child2, GA_PARENT);
    ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
    test = GetWindow(child2, GW_OWNER);
    ok(!test, "wrong owner %p\n", test);
 
    test = SetParent(child2, parent);
    ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
 
    /* test owner/parent of the parent */
    test = GetParent(parent);
    ok(!test, "wrong parent %p\n", test);
    ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
    test = GetAncestor(parent, GA_PARENT);
    ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
    test = GetWindow(parent, GW_OWNER);
    ok(!test, "wrong owner %p\n", test);
 
    /* test owner/parent of child1 */
    test = GetParent(child1);
    ok(test == parent, "wrong parent %p\n", test);
    ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
    test = GetAncestor(child1, GA_PARENT);
    ok(test == parent, "wrong parent %p\n", test);
    test = GetWindow(child1, GW_OWNER);
    ok(!test, "wrong owner %p\n", test);
 
    /* test owner/parent of child2 */
    test = GetParent(child2);
    ok(test == parent, "wrong parent %p\n", test);
    ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
    test = GetAncestor(child2, GA_PARENT);
    ok(test == parent, "wrong parent %p\n", test);
    test = GetWindow(child2, GW_OWNER);
    ok(!test, "wrong owner %p\n", test);
 
    /* test owner/parent of child3 */
    test = GetParent(child3);
    ok(test == child1, "wrong parent %p\n", test);
    ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
    test = GetAncestor(child3, GA_PARENT);
    ok(test == child1, "wrong parent %p\n", test);
    test = GetWindow(child3, GW_OWNER);
    ok(!test, "wrong owner %p\n", test);
 
    /* test owner/parent of child4 */
    test = GetParent(child4);
    ok(test == parent, "wrong parent %p\n", test);
    ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
    test = GetAncestor(child4, GA_PARENT);
    ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
    test = GetWindow(child4, GW_OWNER);
    ok(test == parent, "wrong owner %p\n", test);
 
    flush_sequence();
 
    if (winetest_debug > 1) trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
       parent, child1, child2, child3, child4);
 
    SetCapture(child4);
    test = GetCapture();
    ok(test == child4, "wrong capture window %p\n", test);
 
    test_DestroyWindow_flag = TRUE;
    ret = DestroyWindow(parent);
    ok( ret, "DestroyWindow() error %ld\n", GetLastError());
    test_DestroyWindow_flag = FALSE;
    ok_sequence(destroy_window_with_children, "destroy window with children", FALSE);
 
    ok(!IsWindow(parent), "parent still exists\n");
    ok(!IsWindow(child1), "child1 still exists\n");
    ok(!IsWindow(child2), "child2 still exists\n");
    ok(!IsWindow(child3), "child3 still exists\n");
    ok(!IsWindow(child4), "child4 still exists\n");
 
    test = GetCapture();
    ok(!test, "wrong capture window %p\n", test);
}

Referenced by START_TEST().

◆ test_dialog_messages()

static void test_dialog_messages ( void )

static

Definition at line 15988 of file msg.c.

{
    WNDCLASSA cls;
    HWND hdlg, hedit1, hedit2, hfocus, parent, child, child2;
    LRESULT ret;
 
#define set_selection(hctl, start, end) \
    ret = SendMessageA(hctl, EM_SETSEL, start, end); \
    ok(ret == 1, "EM_SETSEL returned %Id\n", ret);
 
#define check_selection(hctl, start, end) \
    ret = SendMessageA(hctl, EM_GETSEL, 0, 0); \
    ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
 
    subclass_edit();
 
    hdlg = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
                          WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
                          0, 0, 100, 100, 0, 0, 0, NULL);
    ok(hdlg != 0, "Failed to create custom dialog window\n");
 
    hedit1 = CreateWindowExA(0, "my_edit_class", NULL,
                           WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
                           0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
    ok(hedit1 != 0, "Failed to create edit control\n");
    hedit2 = CreateWindowExA(0, "my_edit_class", NULL,
                           WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
                           0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
    ok(hedit2 != 0, "Failed to create edit control\n");
 
    SendMessageA(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
    SendMessageA(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
 
    hfocus = GetFocus();
    ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
 
    SetFocus(hedit2);
    hfocus = GetFocus();
    ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
 
    check_selection(hedit1, 0, 0);
    check_selection(hedit2, 0, 0);
 
    set_selection(hedit2, 0, -1);
    check_selection(hedit2, 0, 3);
 
    SetFocus(0);
    hfocus = GetFocus();
    ok(hfocus == 0, "wrong focus %p\n", hfocus);
 
    flush_sequence();
    ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
    ok(ret == 0, "WM_SETFOCUS returned %Id\n", ret);
    ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
 
    hfocus = GetFocus();
    ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
 
    check_selection(hedit1, 0, 5);
    check_selection(hedit2, 0, 3);
 
    flush_sequence();
    ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
    ok(ret == 0, "WM_SETFOCUS returned %Id\n", ret);
    ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
 
    hfocus = GetFocus();
    ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
 
    check_selection(hedit1, 0, 5);
    check_selection(hedit2, 0, 3);
 
    EndDialog(hdlg, 0);
    DestroyWindow(hedit1);
    DestroyWindow(hedit2);
    DestroyWindow(hdlg);
    flush_sequence();
 
#undef set_selection
#undef check_selection
 
    ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
    cls.lpszClassName = "MyDialogClass";
    cls.hInstance = GetModuleHandleA(NULL);
    /* need a cast since a dlgproc is used as a wndproc */
    cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
    register_class(&cls);
 
    SetFocus(0);
    flush_sequence();
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
    ok_sequence(WmCreateDialogParamSeq_0, "CreateDialogParam_0", FALSE);
    hfocus = GetFocus();
    ok(hfocus == 0, "wrong focus %p\n", hfocus);
    EndDialog(hdlg, 0);
    DestroyWindow(hdlg);
    flush_sequence();
 
    SetFocus(0);
    flush_sequence();
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 1);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
    ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
    hfocus = GetFocus();
    ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
    EndDialog(hdlg, 0);
    DestroyWindow(hdlg);
    flush_sequence();
 
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
    ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
    EndDialog(hdlg, 0);
    DestroyWindow(hdlg);
    flush_sequence();
 
    hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_3", 0, test_dlg_proc2, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok_sequence(WmCreateDialogParamSeq_3, "CreateDialogParam_3", TRUE);
    EndDialog(hdlg, 0);
    DestroyWindow(hdlg);
    flush_sequence();
 
    UnregisterClassA( cls.lpszClassName, cls.hInstance );
    cls.lpfnWndProc = test_dlg_proc4;
    register_class(&cls);
    hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_4", 0, test_dlg_proc3, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok_sequence(WmCreateDialogParamSeq_4, "CreateDialogParam_4", TRUE);
    EndDialog(hdlg, 0);
    DestroyWindow(hdlg);
    flush_sequence();
 
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
 
    parent = CreateWindowExA(0, "TestParentClass", "Test parent",
                             WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             100, 100, 200, 200, 0, 0, 0, NULL);
    ok (parent != 0, "Failed to create parent window\n");
 
    /* This child has no parent set. We will later call SetParent on it,
     * so that it will have a parent set, but no WS_CHILD style. */
    child = CreateWindowExA(0, "TestWindowClass", "Test child",
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                            100, 100, 200, 200, 0, 0, 0, NULL);
    ok (child != 0, "Failed to create child window\n");
 
    /* This is a regular child window. When used as an owner, the other
     * child window will be used. */
    child2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2",
                             WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CHILD,
                             100, 100, 200, 200, child, 0, 0, NULL);
    ok (child2 != 0, "Failed to create child window\n");
 
    SetParent(child, parent);
    SetFocus(child);
 
    flush_sequence();
    DialogBoxA( 0, "TEST_DIALOG", child2, TestModalDlgProc2 );
    ok_sequence(WmModalDialogSeq_2, "ModalDialog2", TRUE);
 
    DestroyWindow(child2);
    DestroyWindow(child);
    DestroyWindow(parent);
    flush_sequence();
}

Referenced by START_TEST().

◆ test_DispatchMessage()

static void test_DispatchMessage ( void )

static

Definition at line 13064 of file msg.c.

{
    RECT rect;
    MSG msg;
    int count;
    HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                               100, 100, 200, 200, 0, 0, 0, NULL);
    ShowWindow( hwnd, SW_SHOW );
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
    SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
 
    SetRect( &rect, -5, -5, 5, 5 );
    RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
    count = 0;
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
    {
        if (msg.message != WM_PAINT) DispatchMessageA( &msg );
        else
        {
            flush_sequence();
            DispatchMessageA( &msg );
            /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
            if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
            else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
            if (++count > 10) break;
        }
    }
    ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
 
    if (winetest_debug > 1) trace("now without DispatchMessage\n");
    flush_sequence();
    RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
    count = 0;
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
    {
        if (msg.message != WM_PAINT) DispatchMessageA( &msg );
        else
        {
            HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
            flush_sequence();
            /* this will send WM_NCCPAINT just like DispatchMessage does */
            GetUpdateRgn( hwnd, hrgn, TRUE );
            ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
            DeleteObject( hrgn );
            GetClientRect( hwnd, &rect );
            ValidateRect( hwnd, &rect );  /* this will stop WM_PAINTs */
            ok( !count, "Got multiple WM_PAINTs\n" );
            if (++count > 10) break;
        }
    }
 
    flush_sequence();
    RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
    count = 0;
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
    {
        if (msg.message != WM_PAINT) DispatchMessageA( &msg );
        else
        {
            HDC hdc;
 
            flush_sequence();
            hdc = BeginPaint( hwnd, NULL );
            ok( !hdc, "got valid hdc %p from BeginPaint\n", hdc );
            ok( !EndPaint( hwnd, NULL ), "EndPaint succeeded\n" );
            ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
            ok( !count, "Got multiple WM_PAINTs\n" );
            if (++count > 10) break;
        }
    }
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_dlg_proc()

static INT_PTR WINAPI test_dlg_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 15728 of file msg.c.

{
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "dialog";
    add_message(&msg);
 
    /* calling DefDlgProc leads to a recursion under XP */
 
    switch (message)
    {
    case WM_INITDIALOG:
        return lParam;
 
    case WM_GETDLGCODE:
        return 0;
    }
    return 1;
}

Referenced by test_dialog_messages(), and test_EndDialog().

◆ test_dlg_proc2()

static INT_PTR WINAPI test_dlg_proc2	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 15773 of file msg.c.

{
    struct recvd_message msg;
 
    if (ignore_message( message )) return 0;
 
    msg.hwnd = hwnd;
    msg.message = message;
    msg.flags = sent|wparam|lparam|parent;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.descr = "dialog";
    add_message(&msg);
 
    if (message == WM_INITDIALOG)
    {
        orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
                GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
    }
 
    return 1;
}

Referenced by test_dialog_messages().

◆ test_dlg_proc3()

static INT_PTR WINAPI test_dlg_proc3	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 15796 of file msg.c.

{
    ok( 0, "should not be called since DefDlgProc is not used\n" );
    return 0;
}

Referenced by test_dialog_messages().

◆ test_dlg_proc4()

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

static

Definition at line 15802 of file msg.c.

{
    struct recvd_message msg;
 
    if (!ignore_message( message ))
    {
        msg.hwnd = hwnd;
        msg.message = message;
        msg.flags = sent|wparam|lparam|parent;
        msg.wParam = wParam;
        msg.lParam = lParam;
        msg.descr = "dialog";
        add_message(&msg);
    }
    if (message == WM_INITDIALOG)
    {
        orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
                GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
        return 1;
    }
    return DefWindowProcW( hwnd, message, wParam, lParam );
}

Referenced by test_dialog_messages().

◆ test_DoubleSetCapture()

static void test_DoubleSetCapture ( void )

static

Definition at line 20446 of file msg.c.

{
    HWND hwnd;
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test DoubleSetCapture",
                           WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
 
    ShowWindow( hwnd, SW_SHOW );
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
 
    SetCapture( hwnd );
    SetCapture( hwnd );
    ok_sequence(DoubleSetCaptureSeq, "SetCapture( hwnd ) twice", FALSE);
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_edit_ime_messages()

static DWORD WINAPI test_edit_ime_messages ( void * unused_arg )

static

Definition at line 13525 of file msg.c.

{
    static const HKL korean_hkl = (HKL)0x04120412;
    WNDPROC old_proc;
    LRESULT lr;
    HIMC himc;
    HWND hwnd;
    BOOL ret;
    HKL hkl;
    MSG msg;
 
    hkl = GetKeyboardLayout(0);
 
    hwnd = CreateWindowA(WC_EDITA, "Test", WS_POPUP | WS_VISIBLE, 10, 10, 300, 300, NULL, NULL,
                         NULL, NULL);
    ok(hwnd != NULL, "CreateWindowA failed.\n");
 
    /* Test EM_{GET|SET}IMESTATUS */
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
 
    /* Note that EM_SETIMESTATUS always return 1, which is contrary to what MSDN says about
     * returning the previous LPARAM value */
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == EIMES_GETCOMPSTRATONCE, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_CANCELCOMPSTRINFOCUS);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == EIMES_CANCELCOMPSTRINFOCUS, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_COMPLETECOMPSTRKILLFOCUS);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == EIMES_COMPLETECOMPSTRKILLFOCUS, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE
                      | EIMES_CANCELCOMPSTRINFOCUS | EIMES_COMPLETECOMPSTRKILLFOCUS);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == (EIMES_GETCOMPSTRATONCE | EIMES_CANCELCOMPSTRINFOCUS | EIMES_COMPLETECOMPSTRKILLFOCUS),
       "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
 
    /* Invalid EM_{GET|SET}IMESTATUS status types and flags */
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, 0, 0);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING + 1, 0);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, 0, EIMES_GETCOMPSTRATONCE);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING + 1, EIMES_GETCOMPSTRATONCE);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0xFFFFFFFF);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0xFFFF, "Got unexpected lr %#Ix.\n", lr);
 
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
 
    /* Test IME messages when EIMES_GETCOMPSTRATONCE is not set */
    old_proc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)edit_ime_subclass_proc);
    SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)old_proc);
 
    himc = ImmGetContext(hwnd);
    ret = ImmSetCompositionStringA(himc, SCS_SETSTR, "Wine", 4, NULL, 0);
#ifdef __REACTOS__
    ok(ret || broken(GetNTVersion() < _WIN32_WINNT_VISTA), "ImmSetCompositionStringA failed.\n");
#else
    ok(ret, "ImmSetCompositionStringA failed.\n");
#endif
    flush_sequence();
    ret = ImmNotifyIME(himc, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
#ifdef __REACTOS__
    ok(ret || broken(GetNTVersion() < _WIN32_WINNT_VISTA), "ImmNotifyIME failed.\n");
#else
    ok(ret, "ImmNotifyIME failed.\n");
#endif
    /* Note that the following message loop is necessary to get the WM_CHAR messages because they
     * are posted. Same for the later message loops in this function. */
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    if (hkl == korean_hkl)
        ok_sequence(edit_wm_ime_composition_korean_seq,
                    "korean WM_IME_COMPOSITION", TRUE);
    else
#ifdef __REACTOS__
        if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
        ok_sequence(edit_wm_ime_composition_seq, "WM_IME_COMPOSITION", TRUE);
 
    /* Test that WM_IME_CHAR is passed to DefWindowProc() to get WM_CHAR */
    flush_sequence();
    SendMessageA(hwnd, WM_IME_CHAR, '0', 1);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(edit_wm_ime_char_seq, "WM_IME_CHAR", FALSE);
 
    /* Test IME messages when EIMES_GETCOMPSTRATONCE is set */
    lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE);
    ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
    lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
    ok(lr == EIMES_GETCOMPSTRATONCE, "Got unexpected lr %#Ix.\n", lr);
 
    ret = ImmSetCompositionStringA(himc, SCS_SETSTR, "Wine", 4, NULL, 0);
#ifdef __REACTOS__
    ok(ret || broken(GetNTVersion() < _WIN32_WINNT_VISTA), "ImmSetCompositionStringA failed.\n");
#else
    ok(ret, "ImmSetCompositionStringA failed.\n");
#endif
    flush_sequence();
    ret = ImmNotifyIME(himc, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
#ifdef __REACTOS__
    ok(ret || broken(GetNTVersion() < _WIN32_WINNT_VISTA), "ImmNotifyIME failed.\n");
#else
    ok(ret, "ImmNotifyIME failed.\n");
#endif
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    if (hkl == korean_hkl)
        ok_sequence(edit_eimes_getcompstratonce_korean_seq,
                    "korean WM_IME_COMPOSITION with EIMES_GETCOMPSTRATONCE", TRUE);
    else
#ifdef __REACTOS__
        if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
        ok_sequence(edit_eimes_getcompstratonce_seq,
                    "WM_IME_COMPOSITION with EIMES_GETCOMPSTRATONCE", TRUE);
 
    /* Test that WM_IME_CHAR is passed to DefWindowProc() to get WM_CHAR with EIMES_GETCOMPSTRATONCE */
    flush_sequence();
    SendMessageA(hwnd, WM_IME_CHAR, '0', 1);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(edit_wm_ime_char_seq, "WM_IME_CHAR", FALSE);
 
    ImmReleaseContext(hwnd, himc);
    DestroyWindow(hwnd);
    return 0;
}

Referenced by test_edit_messages().

◆ test_edit_messages()

static void test_edit_messages ( void )

static

Definition at line 13696 of file msg.c.

{
    HWND hwnd, parent;
    DWORD dlg_code;
    HANDLE thread;
 
#ifdef __REACTOS__
    /* test_edit_messages() crashes on Windows Vista and Windows 7 */
    if (!is_reactos() && (GetNTVersion() >= _WIN32_WINNT_VISTA && GetNTVersion() <= _WIN32_WINNT_WIN7)) {
        skip("This test crashes on Windows Vista and Windows 7.\n");
        return;
    }
#endif
    subclass_edit();
    log_all_parent_messages++;
 
    parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             100, 100, 200, 200, 0, 0, 0, NULL);
    ok (parent != 0, "Failed to create parent window\n");
 
    /* test single line edit */
    hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
               0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
    ok(hwnd != 0, "Failed to create edit window\n");
 
    dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
    ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08lx\n", dlg_code);
 
    flush_sequence();
    SetFocus(hwnd);
    ok_sequence(sl_edit_invisible, "SetFocus(hwnd) on an invisible edit", FALSE);
 
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    SetFocus(0);
    flush_sequence();
 
    SetFocus(hwnd);
    ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
 
    SetFocus(0);
    ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
 
    SetFocus(0);
    ReleaseCapture();
    flush_sequence();
 
    SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
    ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
 
    SetFocus(0);
    ReleaseCapture();
    flush_sequence();
 
    SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
    ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
 
    SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
    ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
 
    DestroyWindow(hwnd);
 
    /* test multiline edit */
    hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
               0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
    ok(hwnd != 0, "Failed to create edit window\n");
 
    dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
    ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
       "wrong dlg_code %08lx\n", dlg_code);
 
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    SetFocus(0);
    flush_sequence();
 
    SetFocus(hwnd);
    ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
 
    SetFocus(0);
    ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
 
    SetFocus(0);
    ReleaseCapture();
    flush_sequence();
 
    SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
    ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
 
    SetFocus(0);
    ReleaseCapture();
    flush_sequence();
 
    SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
    ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
 
    SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
    ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
 
    DestroyWindow(hwnd);
    DestroyWindow(parent);
 
    log_all_parent_messages--;
 
    /* Test IME messages in another thread because IME is disabled in the current thread */
    thread = CreateThread(NULL, 0, test_edit_ime_messages, NULL, 0, NULL);
    WaitForSingleObject(thread, INFINITE);
    CloseHandle(thread);
}

Referenced by START_TEST().

◆ test_EndDialog()

static void test_EndDialog ( void )

static

Definition at line 16214 of file msg.c.

{
    HWND hparent, hother, hactive, hdlg, hchild;
    WNDCLASSA cls;
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
                              WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hother = CreateWindowExA(0, "TestParentClass", "Test parent 2",
                              WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                              200, 100, 200, 200, 0, 0, 0, NULL);
    ok (hother != 0, "Failed to create parent window\n");
 
    ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
    cls.lpszClassName = "MyDialogClass";
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
    register_class(&cls);
 
    flush_sequence();
    SetForegroundWindow(hother);
    hactive = GetForegroundWindow();
    ok(hother == hactive, "Wrong window has focus (%p != %p)\n", hother, hactive);
 
    /* create a dialog where the parent is disabled, this parent should be
     * enabled and receive focus when dialog exits */
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hparent, test_dlg_proc, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
    SetForegroundWindow(hdlg);
    hactive = GetForegroundWindow();
    ok(hdlg == hactive, "Wrong window has focus (%p != %p)\n", hdlg, hactive);
    EndDialog(hdlg, 0);
    ok(IsWindowEnabled(hparent), "parent is not enabled\n");
    hactive = GetForegroundWindow();
    ok(hparent == hactive, "Wrong window has focus (parent != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
    DestroyWindow(hdlg);
    flush_sequence();
 
    /* create a dialog where the parent is disabled and set active window to other window before calling EndDialog */
    EnableWindow(hparent, FALSE);
    hdlg = CreateWindowExA(0, "TestDialogClass", NULL,
                          WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
                          0, 0, 100, 100, hparent, 0, 0, NULL);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
    flush_sequence();
    SetForegroundWindow(hother);
    flush_sequence();
    hactive = GetForegroundWindow();
    ok(hactive == hother, "Wrong foreground (%p != %p)\n", hactive, hother);
    hactive = GetActiveWindow();
    ok(hactive == hother, "Wrong active window (%p != %p)\n", hactive, hother);
    EndDialog(hdlg, 0);
    ok(IsWindowEnabled(hparent), "parent is not enabled\n");
    hactive = GetForegroundWindow();
    ok(hother == hactive, "Wrong window has focus (other != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
    DestroyWindow(hdlg);
    flush_sequence();
 
    DestroyWindow( hparent );
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
                              WS_POPUP | WS_VISIBLE | WS_DISABLED,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
                             WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
                             0, 0, 0, 0, 0, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
 
    SetParent(hchild, hparent);
 
    flush_sequence();
    SetForegroundWindow(hother);
    hactive = GetForegroundWindow();
    ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
 
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
 
    SetForegroundWindow(hdlg);
    test_enddialog_seq(hdlg, hchild);
 
    hactive = GetForegroundWindow();
    ok(hactive == hchild, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
 
    DestroyWindow(hdlg);
 
    /* Now set WS_CHILD style flag so that it's a real child and its parent will be dialog's owner. */
    SetWindowLongW(hchild, GWL_STYLE, GetWindowLongW(hchild, GWL_STYLE) | WS_CHILD);
 
    SetForegroundWindow(hother);
    hactive = GetForegroundWindow();
    ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
 
    hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
    ok(IsWindow(hdlg), "CreateDialogParam failed\n");
 
    SetForegroundWindow(hdlg);
    test_enddialog_seq2(hdlg, hparent);
 
    hactive = GetForegroundWindow();
    ok(hactive == hparent, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
    DestroyWindow(hdlg);
    DestroyWindow(hchild);
    DestroyWindow(hparent);
    DestroyWindow(hother);
    flush_sequence();
 
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
}

Referenced by START_TEST().

◆ test_enddialog_seq()

static void test_enddialog_seq	(	HWND	dialog,
		HWND	owner
	)

static

Definition at line 16162 of file msg.c.

{
    const struct message seq[] = {
        { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
        { WM_ENABLE, sent },
        { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
        { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
        { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
        { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
        { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
        /* FIXME: Following two are optional because Wine sends WM_QUERYNEWPALETTE instead of WM_WINDOWPOSCHANGING */
        { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
        { WM_QUERYNEWPALETTE, sent|optional },
        { WM_NCACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
        { WM_GETTEXT, sent|optional|defwinproc },
        { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
        { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
        { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
        { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
        { WM_SETFOCUS, sent|defwinproc|wparam, (WPARAM)dialog },
        { 0 }
    };
 
    flush_sequence();
    EndDialog(dialog, 0);
    ok_sequence(seq, "EndDialog", FALSE);
}

Referenced by test_EndDialog().

◆ test_enddialog_seq2()

static void test_enddialog_seq2	(	HWND	dialog,
		HWND	owner
	)

static

Definition at line 16190 of file msg.c.

{
    const struct message seq[] = {
        { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
        { WM_ENABLE, parent|sent },
        { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
        { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
        { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
        { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
        { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
        { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
        { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
        { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
        { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
        { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
        { WM_SETFOCUS, sent|parent|defwinproc|wparam, (WPARAM)dialog },
        { 0 }
    };
 
    flush_sequence();
    EndDialog(dialog, 0);
    ok_sequence(seq, "EndDialog2", FALSE);
}

Referenced by test_EndDialog().

◆ test_hook_changing_window_proc()

static void test_hook_changing_window_proc ( void )

static

Definition at line 20683 of file msg.c.

{
    HWND hwnd;
    HHOOK hook;
    LRESULT res;
 
    hwnd = CreateWindowExW( 0, L"static", NULL, WS_POPUP, 0,0,0,0,GetDesktopWindow(),0,0, NULL );
    hook = SetWindowsHookExW( WH_CALLWNDPROC, call_window_proc_hook, NULL, GetCurrentThreadId() );
    ok( hook != NULL, "SetWindowsHookExW failed: %lu\n", GetLastError() );
 
    res = SendMessageW( hwnd, WM_USER, 1, 2 );
    ok( res == 3, "SendMessageW(WM_USER) returned %Iu\n", res );
 
    UnhookWindowsHookEx( hook );
    DestroyWindow( hwnd );
}

Referenced by START_TEST().

◆ test_hook_cleanup()

static void test_hook_cleanup ( void )

static

Definition at line 20848 of file msg.c.

{
    struct test_hook_cleanup_data d;
    HANDLE thread;
 
    d.main_thread_id = GetCurrentThreadId();
    d.hwnd = CreateWindowA ("static", "window", WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0 );
    d.hook_installed_event = CreateEventW( NULL, FALSE, FALSE, NULL );
    d.done_event = CreateEventW( NULL, FALSE, FALSE, NULL );
 
    thread = CreateThread( NULL, 0, test_hook_cleanup_thread_proc, &d, 0, NULL );
    WaitForSingleObject( d.hook_installed_event, INFINITE );
 
    test_hook_cleanup_hook_proc_child_id = -1;
    NotifyWinEvent( EVENT_MIN, d.hwnd, 1, 2 );
    ok( test_hook_cleanup_hook_proc_child_id == 2, "got %ld.\n", test_hook_cleanup_hook_proc_child_id );
    ok( test_hook_cleanup_hook_proc_thread_id == GetCurrentThreadId(), "got %#lx.\n",
        test_hook_cleanup_hook_proc_thread_id );
    ok( test_hook_cleanup_hook_proc_call_thread_id == GetCurrentThreadId(), "got %#lx.\n",
        test_hook_cleanup_hook_proc_call_thread_id );
 
    SetEvent( d.done_event );
    WaitForSingleObject( thread, INFINITE );
 
    /* Hook is removed when thread which created it is terminated. */
    test_hook_cleanup_hook_proc_child_id = -1;
    NotifyWinEvent( EVENT_MIN, d.hwnd, 1, 3 );
    ok( test_hook_cleanup_hook_proc_child_id == -1, "got %ld.\n", test_hook_cleanup_hook_proc_child_id );
 
    DestroyWindow( d.hwnd );
}

Referenced by START_TEST().

◆ test_hook_cleanup_hook_proc()

static void CALLBACK test_hook_cleanup_hook_proc	(	HWINEVENTHOOK	hook,
		DWORD	event_id,
		HWND	hwnd,
		LONG	obj_id,
		LONG	child_id,
		DWORD	thread_id,
		DWORD	event_time
	)

static

Definition at line 20810 of file msg.c.

{
    test_hook_cleanup_hook_proc_child_id = child_id;
    test_hook_cleanup_hook_proc_call_thread_id = GetCurrentThreadId();
    test_hook_cleanup_hook_proc_thread_id = thread_id;
}

Referenced by test_hook_cleanup_thread_proc().

◆ test_hook_cleanup_thread_proc()

static DWORD WINAPI test_hook_cleanup_thread_proc ( void * context )

static

Definition at line 20826 of file msg.c.

{
    struct test_hook_cleanup_data *d = context;
    HWINEVENTHOOK hook;
 
    hook = SetWinEventHook( EVENT_MIN, EVENT_MAX, GetModuleHandleW( NULL ), test_hook_cleanup_hook_proc,
                            GetCurrentProcessId(), 0, WINEVENT_INCONTEXT );
    ok( !!hook, "got error %ld.\n", GetLastError() );
 
    test_hook_cleanup_hook_proc_child_id = -1;
    NotifyWinEvent( EVENT_MIN, d->hwnd, 1, 1 );
    ok( test_hook_cleanup_hook_proc_child_id == 1, "got %ld.\n", test_hook_cleanup_hook_proc_child_id );
    todo_wine ok( test_hook_cleanup_hook_proc_thread_id == d->main_thread_id, "got %#lx.\n",
        test_hook_cleanup_hook_proc_thread_id );
    ok( test_hook_cleanup_hook_proc_call_thread_id == GetCurrentThreadId(), "got %#lx.\n",
        test_hook_cleanup_hook_proc_call_thread_id );
 
    SetEvent( d->hook_installed_event );
    WaitForSingleObject( d->done_event, INFINITE );
    return 0;
}

Referenced by test_hook_cleanup().

◆ test_hotkey()

static void test_hotkey ( void )

static

Definition at line 19278 of file msg.c.

{
    HWND test_window, taskbar_window;
    BOOL ret;
    MSG msg;
    DWORD queue_status;
    SHORT key_state;
 
    SetLastError(0xdeadbeef);
    ret = UnregisterHotKey(NULL, 0);
    if (ret == TRUE)
    {
        skip("hotkeys not supported\n");
        return;
    }
 
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    test_window = CreateWindowExA(0, "HotkeyWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                                  0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
                                  0, 0, 0, NULL);
 
    SetForegroundWindow(test_window);
    flush_events();
    flush_sequence();
 
    SetLastError(0xdeadbeef);
    ret = UnregisterHotKey(test_window, 0);
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    /* Search for a Windows Key + letter combination that hasn't been registered */
    for (hotkey_letter = 'A'; hotkey_letter <= 'Z'; hotkey_letter ++)
    {
        SetLastError(0xdeadbeef);
        ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
 
        if (ret == TRUE)
        {
            break;
        }
        else
        {
            ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
               "unexpected error %ld\n", GetLastError());
        }
    }
 
    if (hotkey_letter > 'Z')
    {
        ok(0, "Couldn't find any free Windows Key + letter combination\n");
        goto end;
    }
 
    hKBD_hook = SetWindowsHookExA(WH_KEYBOARD_LL, KeyboardHookProc, GetModuleHandleA(NULL), 0);
    if (!hKBD_hook) win_skip("WH_KEYBOARD_LL is not supported\n");
 
    /* Same key combination, different id */
    SetLastError(0xdeadbeef);
    ret = RegisterHotKey(test_window, 4, MOD_WIN, hotkey_letter);
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    /* Same key combination, different window */
    SetLastError(0xdeadbeef);
    ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    /* Register the same hotkey twice */
    SetLastError(0xdeadbeef);
    ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    /* Window on another thread */
    taskbar_window = FindWindowA("Shell_TrayWnd", NULL);
    if (!taskbar_window)
    {
        skip("no taskbar?\n");
    }
    else
    {
        SetLastError(0xdeadbeef);
        ret = RegisterHotKey(taskbar_window, 5, 0, hotkey_letter);
        ok(ret == FALSE, "expected FALSE, got %i\n", ret);
        ok(GetLastError() == ERROR_WINDOW_OF_OTHER_THREAD || broken(GetLastError() == 0xdeadbeef),
           "unexpected error %ld\n", GetLastError());
    }
 
    /* Inject the appropriate key sequence */
    keybd_event(VK_LWIN, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyPressLWIN, "window hotkey press LWIN", FALSE);
 
    keybd_event(hotkey_letter, 0, 0, 0);
    queue_status = GetQueueStatus(QS_HOTKEY);
    ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_HOTKEY)
        {
            ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
            ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
        }
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyPress, "window hotkey press", FALSE);
 
    queue_status = GetQueueStatus(QS_HOTKEY);
    ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %lx\n", queue_status);
 
    key_state = GetAsyncKeyState(hotkey_letter);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyRelease, "window hotkey release", TRUE);
 
    keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyReleaseLWIN, "window hotkey release LWIN", FALSE);
 
    /* normal posted WM_HOTKEY messages set QS_HOTKEY */
    PostMessageA(test_window, WM_HOTKEY, 0, 0);
    queue_status = GetQueueStatus(QS_HOTKEY);
    ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
    queue_status = GetQueueStatus(QS_POSTMESSAGE);
    ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %lx\n", queue_status);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    flush_sequence();
 
    /* Send and process all messages at once */
    PostMessageA(test_window, WM_APP, 0, 0);
    keybd_event(VK_LWIN, 0, 0, 0);
    keybd_event(hotkey_letter, 0, 0, 0);
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
 
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_HOTKEY)
        {
            ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
            ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
        }
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyCombined, "window hotkey combined", FALSE);
 
    /* Register same hwnd/id with different key combination */
    ret = RegisterHotKey(test_window, 5, 0, hotkey_letter);
    ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
 
    /* Previous key combination does not work */
    keybd_event(VK_LWIN, 0, 0, 0);
    keybd_event(hotkey_letter, 0, 0, 0);
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
 
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyPrevious, "window hotkey previous", FALSE);
 
    /* New key combination works */
    keybd_event(hotkey_letter, 0, 0, 0);
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
 
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_HOTKEY)
        {
            ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
            ok(msg.lParam == MAKELPARAM(0, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
        }
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyNew, "window hotkey new", FALSE);
 
    /* Unregister hotkey properly */
    ret = UnregisterHotKey(test_window, 5);
    ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
 
    /* Unregister hotkey again */
    SetLastError(0xdeadbeef);
    ret = UnregisterHotKey(test_window, 5);
    ok(ret == FALSE, "expected FALSE, got %i\n", ret);
    ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
       "unexpected error %ld\n", GetLastError());
 
    /* Register thread hotkey */
    ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
    ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
 
    /* Inject the appropriate key sequence */
    keybd_event(VK_LWIN, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyPressLWIN, "thread hotkey press LWIN", FALSE);
 
    keybd_event(hotkey_letter, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_HOTKEY)
        {
            struct recvd_message message;
            ok(msg.hwnd == NULL, "unexpected hwnd %p\n", msg.hwnd);
            ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
            message.message = msg.message;
            message.flags = sent|wparam|lparam;
            message.wParam = msg.wParam;
            message.lParam = msg.lParam;
            message.descr = "test_hotkey thread message";
            add_message(&message);
        }
        else
            ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyPress, "thread hotkey press", FALSE);
 
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyRelease, "thread hotkey release", TRUE);
 
    keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyReleaseLWIN, "thread hotkey release LWIN", FALSE);
 
    /* Search for an ALT + letter combination that hasn't been registered */
    for (hotkey_letter = 'A'; hotkey_letter <= 'Z'; hotkey_letter ++)
    {
        SetLastError(0xdeadbeef);
        ret = RegisterHotKey(test_window, 6, MOD_ALT, hotkey_letter);
 
        if (ret == TRUE)
        {
            break;
        }
        else
        {
            ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
               "unexpected error %ld\n", GetLastError());
        }
    }
 
    if (hotkey_letter > 'Z')
    {
        ok(0, "Couldn't find any free ALT + letter combination\n");
        goto end;
    }
 
    keybd_event(VK_LMENU, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyPressALT, "window hotkey press ALT", TRUE);
 
    keybd_event(hotkey_letter, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_HOTKEY)
        {
            ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
            ok(msg.lParam == MAKELPARAM(MOD_ALT, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
        }
        DispatchMessageA(&msg);
    }
    ok_sequence(WmHotkeyPressWithALT, "window hotkey press with ALT", FALSE);
 
    keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyReleaseWithALT, "window hotkey release with ALT", TRUE);
 
    keybd_event(VK_LMENU, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmHotkeyReleaseALT, "window hotkey release ALT", FALSE);
 
    /* Unregister thread hotkey */
    ret = UnregisterHotKey(NULL, 5);
    ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
 
    if (hKBD_hook) UnhookWindowsHookEx(hKBD_hook);
    hKBD_hook = NULL;
 
end:
    UnregisterHotKey(NULL, 5);
    UnregisterHotKey(test_window, 5);
    UnregisterHotKey(test_window, 6);
    DestroyWindow(test_window);
    flush_sequence();
}

Referenced by START_TEST().

◆ test_hv_scroll_1()

static void test_hv_scroll_1	(	HWND	hwnd,
		INT	ctl,
		DWORD	clear,
		DWORD	set,
		INT	min,
		INT	max
	)

static

Definition at line 4853 of file msg.c.

{
    DWORD style, exstyle;
    INT xmin, xmax;
    BOOL ret;
 
    exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
    style = GetWindowLongA(hwnd, GWL_STYLE);
    /* do not be confused by WS_DLGFRAME set */
    if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
 
    if (clear) ok(style & clear, "style %08lx should be set\n", clear);
    if (set) ok(!(style & set), "style %08lx should not be set\n", set);
 
    ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
    ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
    if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
        ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
    else
        ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
 
    style = GetWindowLongA(hwnd, GWL_STYLE);
    if (set) ok(style & set, "style %08lx should be set\n", set);
    if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
 
    /* a subsequent call should do nothing */
    ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
    ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
    ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
 
    xmin = 0xdeadbeef;
    xmax = 0xdeadbeef;
    ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
    ok( ret, "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
    ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
    ok(xmin == min, "unexpected min scroll value %d\n", xmin);
    ok(xmax == max, "unexpected max scroll value %d\n", xmax);
}

Referenced by test_scroll_messages().

◆ test_hv_scroll_2()

static void test_hv_scroll_2	(	HWND	hwnd,
		INT	ctl,
		DWORD	clear,
		DWORD	set,
		INT	min,
		INT	max
	)

static

Definition at line 4892 of file msg.c.

{
    DWORD style, exstyle;
    SCROLLINFO si;
    BOOL ret;
 
    exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
    style = GetWindowLongA(hwnd, GWL_STYLE);
    /* do not be confused by WS_DLGFRAME set */
    if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
 
    if (clear) ok(style & clear, "style %08lx should be set\n", clear);
    if (set) ok(!(style & set), "style %08lx should not be set\n", set);
 
    si.cbSize = sizeof(si);
    si.fMask = SIF_RANGE;
    si.nMin = min;
    si.nMax = max;
    SetScrollInfo(hwnd, ctl, &si, TRUE);
    if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
        ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
    else
        ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
 
    style = GetWindowLongA(hwnd, GWL_STYLE);
    if (set) ok(style & set, "style %08lx should be set\n", set);
    if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
 
    /* a subsequent call should do nothing */
    SetScrollInfo(hwnd, ctl, &si, TRUE);
    if (style & WS_HSCROLL)
        ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
    else if (style & WS_VSCROLL)
        ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
    else
        ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
 
    si.fMask = SIF_PAGE;
    si.nPage = 5;
    SetScrollInfo(hwnd, ctl, &si, FALSE);
    ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
 
    si.fMask = SIF_POS;
    si.nPos = max - 1;
    SetScrollInfo(hwnd, ctl, &si, FALSE);
    ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
 
    si.fMask = SIF_RANGE;
    si.nMin = 0xdeadbeef;
    si.nMax = 0xdeadbeef;
    ret = GetScrollInfo(hwnd, ctl, &si);
    ok( ret, "GetScrollInfo error %ld\n", GetLastError());
    ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
    ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
    ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
}

Referenced by test_scroll_messages().

◆ test_hvredraw()

static void test_hvredraw ( void )

static

Definition at line 9808 of file msg.c.

{
    HWND htoplevel;
 
    subtest_hvredraw( NULL, CS_HREDRAW, WS_OVERLAPPEDWINDOW );
    subtest_hvredraw( NULL, CS_VREDRAW, WS_OVERLAPPEDWINDOW );
    subtest_hvredraw( NULL, CS_HREDRAW|CS_VREDRAW, WS_OVERLAPPEDWINDOW );
 
    htoplevel = CreateWindowExA( 0, "SimpleWindowClass", "Test toplevel",
                                 WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_VISIBLE,
                                 100, 100, 400, 400, 0, 0, 0, NULL );
    ok( htoplevel != 0, "Failed to create top-level window: %lu\n", GetLastError() );
 
    subtest_hvredraw( htoplevel, CS_HREDRAW, WS_CHILD | WS_BORDER );
    subtest_hvredraw( htoplevel, CS_VREDRAW, WS_CHILD | WS_BORDER );
    subtest_hvredraw( htoplevel, CS_HREDRAW|CS_VREDRAW, WS_CHILD | WS_BORDER );
 
    DestroyWindow( htoplevel );
}

Referenced by START_TEST().

◆ test_InSendMessage()

static void test_InSendMessage ( void )

static

Definition at line 20408 of file msg.c.

{
    WNDCLASSA cls;
    HWND win;
    MSG msg;
    HANDLE thread;
    DWORD tid;
 
    memset(&cls, 0, sizeof(cls));
    cls.lpfnWndProc = insendmessage_wnd_proc;
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpszClassName = "InSendMessage_test";
    register_class(&cls);
 
    win = CreateWindowA( "InSendMessage_test", NULL, 0, 0, 0, 0, 0, NULL, 0, NULL, 0 );
    ok( win != NULL, "CreateWindow failed: %ld\n", GetLastError() );
 
    thread = CreateThread( NULL, 0, send_message_thread, win, 0, &tid );
    ok( thread != NULL, "CreateThread failed: %ld\n", GetLastError() );
 
    while (GetMessageA(&msg, NULL, 0, 0)) DispatchMessageA( &msg );
 
    ok( WaitForSingleObject( thread, 30000 ) == WAIT_OBJECT_0, "WaitForSingleObject failed\n" );
    CloseHandle( thread );
 
    DestroyWindow( win );
    UnregisterClassA( "InSendMessage_test", GetModuleHandleA(NULL) );
}

Referenced by START_TEST().

◆ test_interthread_messages()

static void test_interthread_messages ( void )

static

Definition at line 10111 of file msg.c.

{
    HANDLE hThread, context, handle, event;
    ULONG_PTR cookie;
    DWORD tid;
    WNDPROC proc;
    MSG msg;
    char buf[256];
    int len, expected_len;
    struct wnd_event wnd_event;
    BOOL ret;
 
    wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
    if (!wnd_event.start_event)
    {
        win_skip("skipping interthread message test under win9x\n");
        return;
    }
 
    hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
    ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
 
    ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
 
    CloseHandle(wnd_event.start_event);
 
    SetLastError(0xdeadbeef);
    ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeeded\n");
    ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
       "wrong error code %ld\n", GetLastError());
 
    proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
    ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %ld\n", GetLastError());
 
    expected_len = lstrlenA("window caption text");
    memset(buf, 0, sizeof(buf));
    SetLastError(0xdeadbeef);
    len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
    ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %ld, len %d, expected len %d\n", GetLastError(), len, expected_len);
    ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
 
    msg.hwnd = wnd_event.hwnd;
    msg.message = WM_GETTEXT;
    msg.wParam = sizeof(buf);
    msg.lParam = (LPARAM)buf;
    memset(buf, 0, sizeof(buf));
    SetLastError(0xdeadbeef);
    len = DispatchMessageA(&msg);
    ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
       "DispatchMessageA(WM_GETTEXT) succeeded on another thread window: ret %d, error %ld\n", len, GetLastError());
 
    /* the following test causes an exception in user.exe under win9x */
    msg.hwnd = wnd_event.hwnd;
    msg.message = WM_TIMER;
    msg.wParam = 0;
    msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
    SetLastError(0xdeadbeef);
    len = DispatchMessageA(&msg);
    ok(!len && GetLastError() == 0xdeadbeef,
       "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
 
    ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
    ok( ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
 
    ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(hThread);
 
    ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
 
    wnd_event.hwnd = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (wnd_event.hwnd != 0, "Failed to create parent window\n");
    flush_events();
    flush_sequence();
    log_all_parent_messages++;
    wnd_event.start_event = CreateEventA( NULL, TRUE, FALSE, NULL );
    wnd_event.stop_event = CreateEventA( NULL, TRUE, FALSE, NULL );
    hThread = CreateThread( NULL, 0, create_child_thread, &wnd_event, 0, &tid );
    for (;;)
    {
        ret = MsgWaitForMultipleObjects(1, &wnd_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
        if (ret != 1) break;
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    }
    ok( !ret, "MsgWaitForMultipleObjects failed %x\n", ret );
    /* now wait for the thread without processing messages; this shouldn't deadlock */
    SetEvent( wnd_event.stop_event );
    ret = WaitForSingleObject( hThread, 5000 );
    ok( !ret, "WaitForSingleObject failed %x\n", ret );
    CloseHandle( hThread );
 
    ret = WaitForSingleObject( wnd_event.grand_child, 5000 );
    ok( !ret, "WaitForSingleObject failed %x\n", ret );
    CloseHandle( wnd_event.grand_child );
 
    CloseHandle( wnd_event.start_event );
    CloseHandle( wnd_event.stop_event );
    flush_events();
    ok_sequence(WmExitThreadSeq, "destroy child on thread exit", FALSE);
    log_all_parent_messages--;
    DestroyWindow( wnd_event.hwnd );
 
    /* Activation context tests */
    create_manifest_file("testdep1.manifest", manifest_dep);
    create_manifest_file("main.manifest", manifest_main);
 
    context = test_create("main.manifest");
    DeleteFileA("testdep1.manifest");
    DeleteFileA("main.manifest");
 
    handle = (void*)0xdeadbeef;
    ret = GetCurrentActCtx(&handle);
    ok(ret, "GetCurrentActCtx failed: %lu\n", GetLastError());
    ok(handle == 0, "active context %p\n", handle);
 
    wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
    hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
    ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
    ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(wnd_event.start_event);
 
    /* context is activated after thread creation, so it doesn't inherit it by default */
    ret = ActivateActCtx(context, &cookie);
    ok(ret, "activation failed: %lu\n", GetLastError());
 
    handle = 0;
    ret = GetCurrentActCtx(&handle);
    ok(ret, "GetCurrentActCtx failed: %lu\n", GetLastError());
    ok(handle != 0, "active context %p\n", handle);
    ReleaseActCtx(handle);
 
    /* destination window will test for active context */
    ret = SendMessageA(wnd_event.hwnd, WM_USER+10, 0, 0);
    ok(ret, "thread window returned %d\n", ret);
 
    event = CreateEventW(NULL, 0, 0, NULL);
    ret = PostMessageA(wnd_event.hwnd, WM_USER+10, 0, (LPARAM)event);
    ok(ret, "thread window returned %d\n", ret);
    ok(WaitForSingleObject(event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(event);
 
    ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
    ok(ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
 
    ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(hThread);
 
    ret = DeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %lu\n", GetLastError());
    ReleaseActCtx(context);
}

Referenced by START_TEST().

◆ test_invalid_window()

static void test_invalid_window ( void )

static

Definition at line 20575 of file msg.c.

{
    MSG msg;
    BOOL ret;
 
    SetLastError(0xdeadbeef);
    ret = GetMessageA(&msg, (HWND)0xdeadbeef, 0, 0);
    ok(ret == -1, "wrong ret %d\n", ret);
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = PeekMessageA(&msg, (HWND)0xdeadbeef, 0, 0, PM_REMOVE);
    ok(!ret, "wrong ret %d\n", ret);
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %lu\n", GetLastError());
}

Referenced by START_TEST().

◆ test_keyflags()

static void test_keyflags ( void )

static

Definition at line 19055 of file msg.c.

{
    HWND test_window;
    SHORT key_state;
    BYTE keyboard_state[256];
    MSG msg;
 
    test_window = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                                  0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
                                  0, 0, 0, NULL);
 
    flush_events();
    flush_sequence();
 
    /* keyup without a keydown */
    keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyReleaseOnly, "key release only", TRUE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    /* keydown */
    keybd_event(0x41, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyPressNormal, "key press only", FALSE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    /* keydown repeat */
    keybd_event(0x41, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyPressRepeat, "key press repeat", FALSE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    /* keyup */
    keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyReleaseNormal, "key release repeat", FALSE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    /* set the key state in this thread */
    GetKeyboardState(keyboard_state);
    keyboard_state[0x41] = 0x80;
    SetKeyboardState(keyboard_state);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    /* keydown */
    keybd_event(0x41, 0, 0, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyPressRepeat, "key press after setkeyboardstate", TRUE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    /* clear the key state in this thread */
    GetKeyboardState(keyboard_state);
    keyboard_state[0x41] = 0;
    SetKeyboardState(keyboard_state);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
 
    /* keyup */
    keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
        DispatchMessageA(&msg);
    ok_sequence(WmKeyReleaseOnly, "key release after setkeyboardstate", TRUE);
 
    key_state = GetAsyncKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    key_state = GetKeyState(0x41);
    ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
 
    DestroyWindow(test_window);
    flush_sequence();
}

Referenced by START_TEST().

◆ test_layered_window()

static void test_layered_window ( void )

static

Definition at line 19868 of file msg.c.

{
    HWND hwnd;
    HDC hdc;
    HBITMAP bmp;
    BOOL ret;
    SIZE size;
    POINT pos, src;
    RECT rect, client;
    HANDLE thread;
    DWORD tid;
    struct layered_window_info info;
 
    if (!pUpdateLayeredWindow)
    {
        win_skip( "UpdateLayeredWindow not supported\n" );
        return;
    }
 
    hdc = CreateCompatibleDC( 0 );
    bmp = CreateCompatibleBitmap( hdc, 300, 300 );
    SelectObject( hdc, bmp );
 
    hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_CAPTION | WS_THICKFRAME | WS_SYSMENU,
                           100, 100, 300, 300, 0, 0, 0, NULL);
    ok( hwnd != 0, "failed to create window\n" );
    ShowWindow( hwnd, SW_SHOWNORMAL );
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
 
    GetWindowRect( hwnd, &rect );
    GetClientRect( hwnd, &client );
    ok( client.right < rect.right - rect.left, "wrong client area\n" );
    ok( client.bottom < rect.bottom - rect.top, "wrong client area\n" );
 
    src.x = src.y = 0;
    pos.x = pos.y = 300;
    size.cx = size.cy = 250;
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
    SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
    ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
 
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
    ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
    GetWindowRect( hwnd, &rect );
    ok( rect.left == 300 && rect.top == 300 && rect.right == 550 && rect.bottom == 550,
        "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
    GetClientRect( hwnd, &rect );
    ok( rect.right == client.right - 50 && rect.bottom == client.bottom - 50,
        "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
 
    size.cx = 150;
    pos.y = 200;
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
    ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
    GetWindowRect( hwnd, &rect );
    ok( rect.left == 300 && rect.top == 200 && rect.right == 450 && rect.bottom == 450,
        "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
    GetClientRect( hwnd, &rect );
    ok( rect.right == client.right - 150 && rect.bottom == client.bottom - 50,
        "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
 
    SetWindowLongA( hwnd, GWL_STYLE,
                   GetWindowLongA(hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_SYSMENU) );
    ok_sequence( WmSetLayeredStyle2, "WmSetLayeredStyle2", FALSE );
 
    size.cx = 200;
    pos.x = 200;
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
    ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
    GetWindowRect( hwnd, &rect );
    ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
        "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
    GetClientRect( hwnd, &rect );
    ok( (rect.right == 200 && rect.bottom == 250) ||
        broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
        "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
 
    size.cx = 0;
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == ERROR_MR_MID_NOT_FOUND) ||
        broken(GetLastError() == ERROR_GEN_FAILURE) /* win7 */, "wrong error %lu\n", GetLastError() );
    size.cx = 1;
    size.cy = -1;
    ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
    ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
    SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED );
    ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
    GetWindowRect( hwnd, &rect );
    ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
        "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
    GetClientRect( hwnd, &rect );
    ok( (rect.right == 200 && rect.bottom == 250) ||
        broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
        "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
 
    SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
    info.hwnd = hwnd;
    info.hdc = hdc;
    info.size.cx = 250;
    info.size.cy = 300;
    info.event = CreateEventA( NULL, TRUE, FALSE, NULL );
    info.ret = FALSE;
    thread = CreateThread( NULL, 0, update_layered_proc, &info, 0, &tid );
    ok( WaitForSingleObject( info.event, 1000 ) == 0, "wait failed\n" );
    ok( info.ret, "UpdateLayeredWindow failed in other thread\n" );
    WaitForSingleObject( thread, 1000 );
    CloseHandle( thread );
    GetWindowRect( hwnd, &rect );
    ok( rect.left == 200 && rect.top == 200 && rect.right == 450 && rect.bottom == 500,
        "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
    GetClientRect( hwnd, &rect );
    ok( (rect.right == 250 && rect.bottom == 300) ||
        broken(rect.right == client.right - 50 && rect.bottom == client.bottom),
        "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
 
    DestroyWindow( hwnd );
    DeleteDC( hdc );
    DeleteObject( bmp );
}

Referenced by START_TEST().

◆ test_listbox_messages()

static void test_listbox_messages ( void )

static

Definition at line 17164 of file msg.c.

{
    HWND parent, listbox;
    LRESULT ret;
 
    parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW  | WS_VISIBLE,
                             100, 100, 200, 200, 0, 0, 0, NULL);
    /* with LBS_HASSTRINGS */
    listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
                              WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
                              10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
    listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
 
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
 
    flush_sequence();
 
    log_all_parent_messages++;
 
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
    ok(ret == 2, "expected 2, got %Id\n", ret);
 
    ok_sequence(wm_lb_addstring_ownerdraw, "LB_ADDSTRING", FALSE);
    check_lb_state(listbox, 3, LB_ERR, 0, 0);
 
    flush_sequence();
 
    if (winetest_debug > 1) trace("selecting item 0\n");
    ret = SendMessageA(listbox, LB_SETCURSEL, 0, 0);
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
    check_lb_state(listbox, 3, 0, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("selecting item 1\n");
    ret = SendMessageA(listbox, LB_SETCURSEL, 1, 0);
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
    check_lb_state(listbox, 3, 1, 1, 0);
 
    if (winetest_debug > 1) trace("selecting item 2\n");
    ret = SendMessageA(listbox, LB_SETCURSEL, 2, 0);
    ok(ret == 2, "expected 2, got %Id\n", ret);
    ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
    check_lb_state(listbox, 3, 2, 2, 0);
 
    if (winetest_debug > 1) trace("clicking on item 0\n");
    ret = SendMessageA(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
    check_lb_state(listbox, 3, 0, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("deleting item 0\n");
    ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
    ok(ret == 2, "expected 2, got %Id\n", ret);
    ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
    check_lb_state(listbox, 2, -1, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("deleting item 0\n");
    ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
    check_lb_state(listbox, 1, -1, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("deleting item 0\n");
    ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ok_sequence(wm_lb_deletestring_reset, "LB_DELETESTRING 0", FALSE );
    check_lb_state(listbox, 0, -1, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("deleting item 0\n");
    ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
    ok(ret == LB_ERR, "expected LB_ERR, got %Id\n", ret);
    check_lb_state(listbox, 0, -1, 0, 0);
    flush_sequence();
 
    ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
    ok(ret == LB_ERR, "expected LB_ERR, got %Id\n", ret);
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    ret = SendMessageA(listbox, LB_RESETCONTENT, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("clicking on item 0\n");
    ret = SendMessageA(listbox, WM_LBUTTONDBLCLK, 0, MAKELPARAM(1, 1));
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ok_sequence(wm_lb_dblclick_0, "WM_LBUTTONDBLCLK 0", FALSE );
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    log_all_parent_messages--;
 
    DestroyWindow(listbox);
 
    /* with LBS_SORT and without LBS_HASSTRINGS */
    listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
                              WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_SORT | WS_VISIBLE,
                              10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
    listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
 
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
 
    flush_sequence();
 
    log_all_parent_messages++;
 
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
    ok(ret == 2, "expected 2, got %Id\n", ret);
 
    ok_sequence(wm_lb_addstring_sort_ownerdraw, "LB_ADDSTRING", FALSE);
    check_lb_state(listbox, 3, LB_ERR, 0, 0);
 
    ret = SendMessageA(listbox, LB_RESETCONTENT, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    SetFocus(listbox); /* avoid focus messages */
    flush_sequence();
 
    if (winetest_debug > 1) trace("clicking on item 0\n");
    ret = SendMessageA(listbox, WM_LBUTTONDBLCLK, 0, MAKELPARAM(1, 1));
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ok_sequence(wm_lb_dblclick_0, "WM_LBUTTONDBLCLK 0", FALSE );
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    log_all_parent_messages--;
 
    DestroyWindow(listbox);
 
    /* with LBS_HASSTRINGS */
    listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
                              WS_CHILD | LBS_NOTIFY | LBS_HASSTRINGS | WS_VISIBLE,
                              10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
    listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
 
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
 
    flush_sequence();
 
    log_all_parent_messages++;
 
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 1, "expected 1, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
    ok(ret == 2, "expected 2, got %Id\n", ret);
 
    ok_sequence(wm_lb_addstring, "LB_ADDSTRING", FALSE);
    check_lb_state(listbox, 3, LB_ERR, 0, 0);
 
    ret = SendMessageA(listbox, LB_RESETCONTENT, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    SetFocus(listbox); /* avoid focus messages */
    flush_sequence();
 
    if (winetest_debug > 1) trace("clicking on item 0\n");
    ret = SendMessageA(listbox, WM_LBUTTONDBLCLK, 0, MAKELPARAM(1, 1));
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ok_sequence(wm_lb_dblclick_0, "WM_LBUTTONDBLCLK 0", FALSE );
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    log_all_parent_messages--;
 
    DestroyWindow(listbox);
 
    /* with LBS_HASSTRINGS and LBS_SORT */
    listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
                              WS_CHILD | LBS_NOTIFY | LBS_HASSTRINGS | LBS_SORT | WS_VISIBLE,
                              10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
    listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
 
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
 
    flush_sequence();
 
    log_all_parent_messages++;
 
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
    ok(ret == 0, "expected 0, got %Id\n", ret);
    ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
    ok(ret == 1, "expected 1, got %Id\n", ret);
 
    ok_sequence(wm_lb_addstring, "LB_ADDSTRING", FALSE);
    check_lb_state(listbox, 3, LB_ERR, 0, 0);
 
    ret = SendMessageA(listbox, LB_RESETCONTENT, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    SetFocus(listbox); /* avoid focus messages */
    flush_sequence();
 
    if (winetest_debug > 1) trace("clicking on item 0\n");
    ret = SendMessageA(listbox, WM_LBUTTONDBLCLK, 0, MAKELPARAM(1, 1));
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
    ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
    ok_sequence(wm_lb_dblclick_0, "WM_LBUTTONDBLCLK 0", FALSE );
    check_lb_state(listbox, 0, LB_ERR, 0, 0);
    flush_sequence();
 
    log_all_parent_messages--;
 
    DestroyWindow(listbox);
    DestroyWindow(parent);
}

Referenced by START_TEST().

◆ test_mdi_messages()

static void test_mdi_messages ( void )

static

Definition at line 4177 of file msg.c.

{
    MDICREATESTRUCTA mdi_cs;
    CLIENTCREATESTRUCT client_cs;
    HWND mdi_frame, mdi_child, mdi_child2, active_child;
    BOOL zoomed;
    RECT rc;
    HMENU hMenu = CreateMenu();
    LONG val;
 
    mdi_register_classes();
 
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating MDI frame window\n");
    mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
                                WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
                                WS_MAXIMIZEBOX | WS_VISIBLE,
                                100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
                                GetDesktopWindow(), hMenu,
                                GetModuleHandleA(0), NULL);
    ok(!!mdi_frame, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
 
    if (winetest_debug > 1) trace("creating MDI client window\n");
    GetClientRect(mdi_frame, &rc);
    client_cs.hWindowMenu = 0;
    client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
    mdi_client = CreateWindowExA(0, "MDI_client_class",
                                 NULL,
                                 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
                                 rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
                                 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
    ok(!!mdi_client, "Failed to create window, error %lu.\n", GetLastError());
    SetWindowLongA(mdi_client, 0, 0xdeadbeef);
 
    ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(!active_child, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    SetFocus(0);
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating invisible MDI child window\n");
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child, "Failed to create window, error %lu.\n", GetLastError());
 
    flush_sequence();
    ShowWindow(mdi_child, SW_SHOWNORMAL);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
 
    ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(!active_child, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    ShowWindow(mdi_child, SW_HIDE);
    ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
    flush_sequence();
 
    ShowWindow(mdi_child, SW_SHOW);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
 
    ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(!active_child, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    DestroyWindow(mdi_child);
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating visible MDI child window\n");
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
 
    ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    DestroyWindow(mdi_child);
    ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    /* Win2k: MDI client still returns a just destroyed child as active
     * Win9x: MDI client returns 0
     */
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child || /* win2k */
       !active_child, /* win9x */
       "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating invisible MDI child window\n");
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child2, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
 
    ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
    ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    /* Win2k: MDI client still returns a just destroyed child as active
     * Win9x: MDI client returns mdi_child2
     */
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child || /* win2k */
       active_child == mdi_child2, /* win9x */
       "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    ShowWindow(mdi_child2, SW_MAXIMIZE);
    ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
 
    ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child2 || /* win2k */
       GetFocus() == 0, /* win9x */
       "wrong focus window %p\n", GetFocus());
 
    SetFocus(0);
    flush_sequence();
 
    ShowWindow(mdi_child2, SW_HIDE);
    ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
 
    ShowWindow(mdi_child2, SW_RESTORE);
    ok_sequence(WmRestoreMDIchildInvisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
    flush_sequence();
 
    ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    SetFocus(0);
    flush_sequence();
 
    ShowWindow(mdi_child2, SW_HIDE);
    ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
 
    ShowWindow(mdi_child2, SW_SHOW);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    ShowWindow(mdi_child2, SW_MAXIMIZE);
    ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    ShowWindow(mdi_child2, SW_RESTORE);
    ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    ShowWindow(mdi_child2, SW_MINIMIZE);
    ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    ShowWindow(mdi_child2, SW_RESTORE);
    ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    SetFocus(0);
    flush_sequence();
 
    ShowWindow(mdi_child2, SW_HIDE);
    ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    DestroyWindow(mdi_child2);
    ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    if (winetest_debug > 1) trace("Testing WM_CHILDACTIVATE\n");
 
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_DISABLED,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
 
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX,
                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                 mdi_client, 0, GetModuleHandleA(0), NULL);
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    flush_sequence();
    SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
    ok_sequence(WmChildActivateDisabledWindowSeq, "WM_CHILDACTIVATE sent to disabled window", FALSE);
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    EnableWindow(mdi_child, TRUE);
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
 
    flush_sequence();
    SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
    ok_sequence(WmChildActivateWindowSeq, "WM_CHILDACTIVATE sent to enabled window", FALSE);
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
    ok(!zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    DestroyWindow(mdi_child);
    DestroyWindow(mdi_child2);
    flush_sequence();
 
    /* test for maximized MDI children */
    if (winetest_debug > 1) trace("creating maximized visible MDI child window 1\n");
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
    ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child || /* win2k */
       GetFocus() == 0, /* win9x */
       "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating maximized visible MDI child window 2\n");
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child2, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
    ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
    ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    if (winetest_debug > 1) trace("destroying maximized visible MDI child window 2\n");
    DestroyWindow(mdi_child2);
    ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
 
    ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    /* Win2k: MDI client still returns a just destroyed child as active
     * Win9x: MDI client returns 0
     */
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2 || /* win2k */
       !active_child, /* win9x */
       "wrong active MDI child %p\n", active_child);
    flush_sequence();
 
    ShowWindow(mdi_child, SW_MAXIMIZE);
    ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
    flush_sequence();
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
 
    if (winetest_debug > 1) trace("re-creating maximized visible MDI child window 2\n");
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child2, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
    ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
    ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
    ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
    ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
 
    ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    DestroyWindow(mdi_child);
    ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
 
    /* Win2k: MDI client still returns a just destroyed child as active
     * Win9x: MDI client returns 0
     */
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child || /* win2k */
       !active_child, /* win9x */
       "wrong active MDI child %p\n", active_child);
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating maximized invisible MDI child window\n");
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child2, "Failed to create window, error %lu.\n", GetLastError());
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_WINBLUE)
#endif
    ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
    ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
    ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
    ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
 
    /* Win2k: MDI client still returns a just destroyed child as active
     * Win9x: MDI client returns 0
     */
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child || /* win2k */
       !active_child || active_child == mdi_child2, /* win9x */
       "wrong active MDI child %p\n", active_child);
    flush_sequence();
 
    if (winetest_debug > 1) trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
    ShowWindow(mdi_child2, SW_MAXIMIZE);
    ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
    ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
    ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
    ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
    flush_sequence();
 
    /* end of test for maximized MDI children */
    SetFocus(0);
    flush_sequence();
    if (winetest_debug > 1) trace("creating maximized visible MDI child window 1(Switch test)\n");
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
    ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
    ok(GetFocus() == mdi_child || /* win2k */
       GetFocus() == 0, /* win9x */
       "wrong focus window %p(Switch test)\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
    ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
    flush_sequence();
 
    if (winetest_debug > 1) trace("creating maximized visible MDI child window 2(Switch test)\n");
    mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
                                0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok(!!mdi_child2, "Failed to create window, error %lu.\n", GetLastError());
    ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
 
    ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
    ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
 
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
    ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
    ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
    flush_sequence();
 
    if (winetest_debug > 1) trace("Switch child window.\n");
    SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
    ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
    if (winetest_debug > 1) trace("end of test for switch maximized MDI children\n");
    flush_sequence();
 
    /* Prepare for switching test of not maximized MDI children  */
    ShowWindow( mdi_child, SW_NORMAL );
    ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
    ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
    ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
    flush_sequence();
 
    SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
    ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
    if (winetest_debug > 1) trace("end of test for switch not maximized MDI children\n");
    flush_sequence();
 
    SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
    flush_sequence();
 
    SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
    flush_sequence();
 
    SetFocus(0);
    flush_sequence();
    /* end of tests for switch maximized/not maximized MDI children */
 
    mdi_cs.szClass = "MDI_child_Class";
    mdi_cs.szTitle = "MDI child";
    mdi_cs.hOwner = GetModuleHandleA(0);
    mdi_cs.x = 0;
    mdi_cs.y = 0;
    mdi_cs.cx = CW_USEDEFAULT;
    mdi_cs.cy = CW_USEDEFAULT;
    mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
    mdi_cs.lParam = 0;
    mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
    ok(mdi_child != 0, "MDI child creation failed\n");
    ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
 
    ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
 
    ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
    ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
    ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
 
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
    flush_sequence();
 
    SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
    ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
 
    ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
    active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
    ok(!active_child, "wrong active MDI child %p\n", active_child);
 
    SetFocus(0);
    flush_sequence();
 
    val = GetWindowLongA(mdi_client, 0);
    ok(val == 0xdeadbeef || broken(val == 0) /* >= Win Vista */, "Expected 0xdeadbeef, got 0x%lx\n", val);
    DestroyWindow(mdi_client);
    ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
 
    /* test maximization of MDI child with invisible parent */
    client_cs.hWindowMenu = 0;
    mdi_client = CreateWindowA("MDI_client_class",
                                 NULL,
                                 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
                                 0, 0, 660, 430,
                                 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
    ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
 
    ShowWindow(mdi_client, SW_HIDE);
    ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
 
    mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
                                WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
                                0, 0, 650, 440,
                                mdi_client, 0, GetModuleHandleA(0), NULL);
    ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
 
    SendMessageA(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
    ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
    zoomed = IsZoomed(mdi_child);
    ok(zoomed, "wrong zoomed state %d\n", zoomed);
 
    ShowWindow(mdi_client, SW_SHOW);
    ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
 
    DestroyWindow(mdi_child);
    ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
 
    /* end of test for maximization of MDI child with invisible parent */
 
    DestroyWindow(mdi_client);
    ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
 
    DestroyWindow(mdi_frame);
    ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
}

Referenced by START_TEST().

◆ test_menu_messages()

static void test_menu_messages ( void )

static

Definition at line 17634 of file msg.c.

{
    MSG msg;
    WNDCLASSA cls;
    HMENU hmenu, hmenu_popup;
    HWND hwnd;
    DWORD style;
    BOOL us_kbd = (GetKeyboardLayout(0) == (HKL)(ULONG_PTR)0x04090409);
 
    cls.style = 0;
    cls.lpfnWndProc = parent_menu_proc;
    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 = "TestMenuClass";
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
    register_class(&cls);
 
    SetLastError(0xdeadbeef);
    hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok(hwnd != 0, "LoadMenuA error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
    ok(hmenu != 0, "LoadMenuA error %lu\n", GetLastError());
 
    SetMenu(hwnd, hmenu);
    SetForegroundWindow( hwnd );
    flush_events();
 
    set_menu_style(hmenu, MNS_NOTIFYBYPOS);
    style = get_menu_style(hmenu);
    ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %lu\n", style);
 
    hmenu_popup = GetSubMenu(hmenu, 0);
    ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
    style = get_menu_style(hmenu_popup);
    ok(style == 0, "expected 0, got %lu\n", style);
 
    hmenu_popup = GetSubMenu(hmenu_popup, 0);
    ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
    style = get_menu_style(hmenu_popup);
    ok(style == 0, "expected 0, got %lu\n", style);
 
    if (!us_kbd)
    {
        skip("skipping ascii VK events on non-us keyboard\n");
        goto done;
    }
 
    /* Alt+E, Enter */
    if (winetest_debug > 1) trace("testing a popup menu command\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('E', 0, 0, 0);
    keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_RETURN, 0, 0, 0);
    keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
    if (!sequence_cnt)  /* we didn't get any message */
    {
        skip( "queuing key events not supported\n" );
        goto done;
    }
    /* win98 queues only a WM_KEYUP and doesn't start menu tracking */
    if (sequence[0].message == WM_KEYUP && sequence[0].wParam == VK_MENU)
    {
        win_skip( "menu tracking through VK_MENU not supported\n" );
        goto done;
    }
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
 
    /* Alt+F, Right, Enter */
    if (winetest_debug > 1) trace("testing submenu of a popup menu command\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('F', 0, 0, 0);
    keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_RIGHT, 0, 0, 0);
    keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_RETURN, 0, 0, 0);
    keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA && GetNTVersion() != _WIN32_WINNT_WIN7)
#endif
    ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
 
    if (winetest_debug > 1) trace("testing single menu item command\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('Q', 0, 0, 0);
    keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_ESCAPE, 0, 0, 0);
    keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
#ifdef __REACTOS__
    if (GetNTVersion() != _WIN32_WINNT_WIN7)
#endif
    ok_sequence(wm_single_menu_item, "single menu item command", FALSE);
 
    set_menu_style(hmenu, 0);
    style = get_menu_style(hmenu);
    ok(style == 0, "expected 0, got %lu\n", style);
 
    hmenu_popup = GetSubMenu(hmenu, 0);
    ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
    set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
    style = get_menu_style(hmenu_popup);
    ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %lu\n", style);
 
    hmenu_popup = GetSubMenu(hmenu_popup, 0);
    ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
    style = get_menu_style(hmenu_popup);
    ok(style == 0, "expected 0, got %lu\n", style);
 
    /* Alt+F, Right, Enter */
    if (winetest_debug > 1) trace("testing submenu of a popup menu command\n");
    flush_sequence();
    keybd_event(VK_MENU, 0, 0, 0);
    keybd_event('F', 0, 0, 0);
    keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_RIGHT, 0, 0, 0);
    keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_RETURN, 0, 0, 0);
    keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA && GetNTVersion() != _WIN32_WINNT_WIN7)
#endif
    ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
 
done:
    DestroyWindow(hwnd);
    DestroyMenu(hmenu);
}

Referenced by START_TEST().

◆ test_message_conversion()

static void test_message_conversion ( void )

static

Definition at line 11516 of file msg.c.

{
    static const WCHAR wszMsgConversionClass[] =
        {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
    char buffer[200];
    DEV_BROADCAST_DEVICEINTERFACE_A *dev_interface = (void *)buffer;
    WNDCLASSW cls;
    LRESULT lRes;
    HWND hwnd;
    WNDPROC wndproc, newproc;
    BOOL ret;
 
    cls.style = 0;
    cls.lpfnWndProc = MsgConversionProcW;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleW(NULL);
    cls.hIcon = NULL;
    cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
    cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
    cls.lpszMenuName = NULL;
    cls.lpszClassName = wszMsgConversionClass;
    /* this call will fail on Win9x, but that doesn't matter as this test is
     * meaningless on those platforms */
    if(!RegisterClassW(&cls)) return;
 
    hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok(hwnd != NULL, "Window creation failed\n");
 
    /* {W, A} -> A */
 
    wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
    lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0, "String should have been converted\n");
    lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 1, "String shouldn't have been converted\n");
 
    /* {W, A} -> W */
 
    wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
    lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 1, "String shouldn't have been converted\n");
    lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 1, "String shouldn't have been converted\n");
 
    /* Synchronous messages */
 
    lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0, "String should have been converted\n");
    lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 1, "String shouldn't have been converted\n");
 
    /* Asynchronous messages */
 
    SetLastError(0);
    lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "PostMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "PostMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "PosThreadtMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "PosThreadtMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "SendNotifyMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "SendNotifyMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "SendMessageCallback on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
    SetLastError(0);
    lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
    ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
        "SendMessageCallback on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
 
    /* Test WM_DEVICECHANGE. */
 
    dev_interface->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    dev_interface->dbcc_reserved = 0;
    dev_interface->dbcc_classguid = iface_guid;
    strcpy(dev_interface->dbcc_name, "test name");
    dev_interface->dbcc_size = offsetof(DEV_BROADCAST_DEVICEINTERFACE_A,
            dbcc_name[strlen(dev_interface->dbcc_name)]);
    lRes = SendMessageA(hwnd, WM_DEVICECHANGE, DBT_DEVICEARRIVAL, (LPARAM)dev_interface);
    ok(lRes == 2, "Got %Id, error %lu.\n", lRes, GetLastError());
 
    DestroyWindow(hwnd);
 
    /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
 
    hwnd = CreateWindowW (testWindowClassW, wszUnicode,
                          WS_OVERLAPPEDWINDOW,
                          100, 100, 200, 200, 0, 0, 0, NULL);
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    flush_sequence();
    lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
    ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
    ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
        "got bad length %Id\n", lRes );
 
    flush_sequence();
    lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
                            hwnd, WM_GETTEXTLENGTH, 0, 0);
    ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
    ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
        "got bad length %Id\n", lRes );
 
    wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
    newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
    lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
    ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
                                     NULL, 0, NULL, NULL ) ||
        broken(lRes == lstrlenW(dummy_window_text) + 37),
        "got bad length %Id\n", lRes );
 
    SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc );  /* restore old wnd proc */
    lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
    ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
                                     NULL, 0, NULL, NULL ) ||
        broken(lRes == lstrlenW(dummy_window_text) + 37),
        "got bad length %Id\n", lRes );
 
    ret = DestroyWindow(hwnd);
    ok( ret, "DestroyWindow() error %ld\n", GetLastError());
}

Referenced by START_TEST().

◆ test_messages()

static void test_messages ( void )

static

Definition at line 5556 of file msg.c.

{
    DWORD tid;
    HANDLE hthread;
    HWND hwnd, hparent, hchild;
    HWND hchild2, hbutton;
    HMENU hmenu;
    MSG msg;
    LRESULT res;
    POINT pos;
    BOOL ret;
 
    flush_sequence();
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
    ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
 
    /* test ShowWindow(SW_HIDE) on a newly created invisible window */
    ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
    ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
 
    /* test WM_SETREDRAW on a not visible top level window */
    test_WM_SETREDRAW(hwnd);
 
    SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
    flush_events();
    ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
    ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
 
    ok(GetActiveWindow() == hwnd, "window should be active\n");
    ok(GetFocus() == hwnd, "window should have input focus\n");
    ShowWindow(hwnd, SW_HIDE);
    flush_events();
    ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
 
    /* test ShowWindow(SW_HIDE) on a hidden window - single threaded */
    ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
    flush_events();
    ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
 
    /* test ShowWindow(SW_HIDE) on a hidden window -  multi-threaded */
    hthread = CreateThread( NULL, 0, hide_window_thread, hwnd, 0, &tid );
    ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
    ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(hthread);
    flush_events();
    ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
 
    ShowWindow(hwnd, SW_SHOW);
    flush_events();
    ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
 
    /* test ShowWindow(SW_SHOW) on a visible window -  multi-threaded */
    hthread = CreateThread( NULL, 0, show_window_thread, hwnd, 0, &tid );
    ok( hthread != NULL, "CreateThread failed, error %ld\n", GetLastError() );
    ok( WaitForSingleObject( hthread, INFINITE ) == WAIT_OBJECT_0, "WaitForSingleObject failed\n" );
    CloseHandle( hthread );
    flush_events();
    ok_sequence( WmEmptySeq, "ShowWindow(SW_SHOW):overlapped", FALSE );
 
    ShowWindow(hwnd, SW_HIDE);
    flush_events();
    ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
 
    ShowWindow(hwnd, SW_SHOWMAXIMIZED);
    flush_events();
    ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
    flush_sequence();
 
    if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZE)
    {
        ShowWindow(hwnd, SW_RESTORE);
        flush_events();
        ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
        flush_sequence();
    }
 
    ShowWindow(hwnd, SW_MINIMIZE);
    flush_events();
    ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", FALSE);
    flush_sequence();
 
    if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)
    {
        ShowWindow(hwnd, SW_RESTORE);
        flush_events();
        ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", FALSE);
        flush_sequence();
    }
 
    ShowWindow(hwnd, SW_SHOW);
    flush_events();
    ok_sequence(WmOptionalPaint, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
 
    SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
    ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
    ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
    ok(GetActiveWindow() == hwnd, "window should still be active\n");
 
    /* test WM_SETREDRAW on a visible top level window */
    ShowWindow(hwnd, SW_SHOW);
    flush_events();
    test_WM_SETREDRAW(hwnd);
 
    if (winetest_debug > 1) trace("testing scroll APIs on a visible top level window %p\n", hwnd);
    test_scroll_messages(hwnd);
 
    /* test resizing and moving */
    SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
    ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
    flush_events();
    flush_sequence();
    SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
    ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
    flush_events();
    flush_sequence();
    SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
    ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
    flush_events();
    flush_sequence();
 
    /* popups don't get WM_GETMINMAXINFO */
    SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
    SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
    flush_sequence();
    SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
    ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
 
    DestroyWindow(hwnd);
    ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
 
    /* Test if windows are correctly drawn when first shown */
 
    /* Visible, redraw */
    flush_events();
    flush_sequence();
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP | WS_VISIBLE,
                             10, 10, 100, 100, NULL, 0, 0, NULL );
    ok (hwnd != 0, "Failed to create popup window\n");
    RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
    ok_sequence(WmShowPopupFirstDrawSeq_1, "RedrawWindow:show_popup_first_draw_visible", FALSE);
    DestroyWindow(hwnd);
 
    /* Invisible, show, message */
    flush_events();
    flush_sequence();
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
                             10, 10, 100, 100, NULL, 0, 0, NULL );
    ok (hwnd != 0, "Failed to create popup window\n");
    ShowWindow(hwnd, SW_SHOW);
    SendMessageW(hwnd, WM_PAINT, 0, 0);
    ok_sequence(WmShowPopupFirstDrawSeq_1, "RedrawWindow:show_popup_first_draw_show", FALSE);
    DestroyWindow(hwnd);
 
    /* Invisible, show maximized, redraw */
    flush_events();
    flush_sequence();
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
                             10, 10, 100, 100, NULL, 0, 0, NULL );
    ok (hwnd != 0, "Failed to create popup window\n");
    ShowWindow(hwnd, SW_SHOWMAXIMIZED);
    RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
    ok_sequence(WmShowPopupFirstDrawSeq_2, "RedrawWindow:show_popup_first_draw_show_maximized", FALSE);
    DestroyWindow(hwnd);
 
    /* Test SetWindowPos */
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, 0, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq6,
            SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER, FALSE);
 
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq4, SWP_SHOWWINDOW | SWP_NOMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCLIENTSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCLIENTMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOZORDER, FALSE);
 
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOCLIENTMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOCLIENTSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq5, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOZORDER, FALSE);
 
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOCLIENTMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOCLIENTSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq4, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOZORDER, FALSE);
 
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCLIENTMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCLIENTSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq5, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOSIZE, FALSE);
    test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOZORDER, FALSE);
 
    /* Test SetWindowPos with child windows */
    flush_events();
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    flush_sequence();
    SetWindowPos(hparent, NULL, 0, 0, 100, 100, SWP_SHOWWINDOW);
    ok_sequence(WmFirstDrawChildSeq1, /* Expect no messages for the child */
                "SetWindowPos:show_popup_first_show_window_child1", FALSE);
    DestroyWindow(hchild);
    DestroyWindow(hparent);
 
    flush_events();
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    flush_sequence();
    SetWindowPos(hparent, NULL, 0, 0, 100, 100, SWP_SHOWWINDOW);
    ok_sequence(WmFirstDrawChildSeq2, /* Expect child to be redrawn */
                "SetWindowPos:show_popup_first_show_window_child2", FALSE);
    DestroyWindow(hchild);
    DestroyWindow(hparent);
 
    /* Test message sequence for extreme position and size */
 
    flush_sequence();
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP | WS_VISIBLE,
                             -10, -10, 10000, 10000, NULL, 0, 0, NULL );
    ok (hwnd != 0, "Failed to create popup window\n");
    ok_sequence(WmShowPopupExtremeLocationSeq, "RedrawWindow:show_popup_extreme_location", FALSE);
    DestroyWindow(hwnd);
 
 
    /* Test child windows */
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
    flush_sequence();
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
    DestroyWindow(hchild);
    flush_sequence();
 
    /* visible child window with a caption */
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
                             WS_CHILD | WS_VISIBLE | WS_CAPTION,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_WINBLUE)
#endif
    ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
 
    if (winetest_debug > 1) trace("testing scroll APIs on a visible child window %p\n", hchild);
    test_scroll_messages(hchild);
 
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
    ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
 
    DestroyWindow(hchild);
    flush_sequence();
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
    ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
 
    hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
                               100, 100, 50, 50, hparent, 0, 0, NULL);
    ok (hchild2 != 0, "Failed to create child2 window\n");
    flush_sequence();
 
    hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
                              0, 100, 50, 50, hchild, 0, 0, NULL);
    ok (hbutton != 0, "Failed to create button window\n");
 
    /* test WM_SETREDRAW on a not visible child window */
    test_WM_SETREDRAW(hchild);
 
    ShowWindow(hchild, SW_SHOW);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
 
    /* check parent messages too */
    log_all_parent_messages++;
    ShowWindow(hchild, SW_HIDE);
    ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
    log_all_parent_messages--;
 
    ShowWindow(hchild, SW_SHOW);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
 
    ShowWindow(hchild, SW_HIDE);
    ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
 
    ShowWindow(hchild, SW_SHOW);
    ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
 
    /* test WM_SETREDRAW on a visible child window */
    test_WM_SETREDRAW(hchild);
 
    log_all_parent_messages++;
    MoveWindow(hchild, 10, 10, 20, 20, TRUE);
    ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
    log_all_parent_messages--;
 
    ShowWindow(hchild, SW_HIDE);
    flush_sequence();
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
    ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
 
    ShowWindow(hchild, SW_HIDE);
    flush_sequence();
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
    ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
 
    /* DestroyWindow sequence below expects that a child has focus */
    SetFocus(hchild);
    flush_sequence();
 
    DestroyWindow(hchild);
    ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
    DestroyWindow(hchild2);
    DestroyWindow(hbutton);
 
    flush_sequence();
    hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
                             0, 0, 100, 100, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child popup window\n");
    ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
    DestroyWindow(hchild);
 
    /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
    flush_sequence();
    hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
                             0, 0, 100, 100, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create popup window\n");
    ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
    flush_sequence();
    ShowWindow(hchild, SW_SHOW);
    ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
    flush_sequence();
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
    ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
    flush_sequence();
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
    ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
    DestroyWindow(hchild);
 
    /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
     * changes nothing in message sequences.
     */
    flush_sequence();
    hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
                             0, 0, 100, 100, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create popup window\n");
    ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
    ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
    ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
    flush_sequence();
    ShowWindow(hchild, SW_SHOW);
    ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
    flush_sequence();
    SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
    ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
    DestroyWindow(hchild);
 
    flush_sequence();
    hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
                           0, 0, 100, 100, hparent, 0, 0, NULL);
    ok(hwnd != 0, "Failed to create custom dialog window\n");
    ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
 
    if(0) {
    if (winetest_debug > 1) trace("testing scroll APIs on a visible dialog %p\n", hwnd);
    test_scroll_messages(hwnd);
    }
 
    flush_sequence();
 
    test_def_id = TRUE;
    SendMessageA(hwnd, WM_NULL, 0, 0);
 
    flush_sequence();
    after_end_dialog = TRUE;
    EndDialog( hwnd, 0 );
    ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
 
    DestroyWindow(hwnd);
    after_end_dialog = FALSE;
    test_def_id = FALSE;
 
    ok(GetCursorPos(&pos), "GetCursorPos failed\n");
    ok(SetCursorPos(109, 109), "SetCursorPos failed\n");
 
    hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP|WS_CHILD,
                           0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
    ok(hwnd != 0, "Failed to create custom dialog window\n");
    flush_sequence();
    if (winetest_debug > 1) trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
    ShowWindow(hwnd, SW_SHOW);
    ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
 
    flush_events();
    flush_sequence();
    ret = DrawMenuBar(hwnd);
    ok(ret, "DrawMenuBar failed: %ld\n", GetLastError());
    flush_events();
    ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
    ok(SetCursorPos(pos.x, pos.y), "SetCursorPos failed\n");
 
    DestroyWindow(hwnd);
 
    hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_CHILD|WS_VISIBLE,
            0, 0, 100, 100, hparent, 0, GetModuleHandleA(0), NULL);
    ok(hwnd != 0, "Failed to create custom dialog window\n");
    flush_events();
    flush_sequence();
    ret = DrawMenuBar(hwnd);
    ok(ret, "DrawMenuBar failed: %ld\n", GetLastError());
    flush_events();
    ok_sequence(WmEmptySeq, "DrawMenuBar for a child window", FALSE);
 
    DestroyWindow(hwnd);
 
    flush_sequence();
    DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
    ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
 
    DestroyWindow(hparent);
    flush_sequence();
 
    /* Message sequence for SetMenu */
    ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a destroyed window\n");
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "last error is %ld\n", GetLastError());
    ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
 
    hmenu = CreateMenu();
    ok (hmenu != 0, "Failed to create menu\n");
    ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
                           100, 100, 200, 200, 0, hmenu, 0, NULL);
    ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
    ok (SetMenu(hwnd, 0), "SetMenu\n");
    ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
    ok (SetMenu(hwnd, 0), "SetMenu\n");
    ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
    ok (SetMenu(hwnd, 0), "SetMenu\n");
    ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
    ok (SetMenu(hwnd, hmenu), "SetMenu\n");
    ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
 
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
    ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
    flush_events();
    ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
 
    DestroyWindow(hwnd);
    flush_sequence();
 
    /* Message sequence for EnableWindow */
    hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
                             0, 0, 10, 10, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
 
    SetFocus(hchild);
    flush_events();
    flush_sequence();
 
    EnableWindow(hparent, FALSE);
    ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
 
    EnableWindow(hparent, FALSE);
    ok_sequence(WmEnableWindowSeq_2, "EnableWindow(FALSE)", FALSE);
 
    EnableWindow(hparent, TRUE);
    ok_sequence(WmEnableWindowSeq_3, "EnableWindow(TRUE)", FALSE);
 
    EnableWindow(hparent, TRUE);
    ok_sequence(WmEnableWindowSeq_4, "EnableWindow(TRUE)", FALSE);
 
    flush_events();
    flush_sequence();
 
    test_MsgWaitForMultipleObjects(hparent);
    test_WM_DEVICECHANGE(hparent);
 
    /* the following test causes an exception in user.exe under win9x */
    if (!PostMessageW( hparent, WM_USER, 0, 0 ))
    {
        DestroyWindow(hparent);
        flush_sequence();
        return;
    }
    PostMessageW( hparent, WM_USER+1, 0, 0 );
    /* PeekMessage(NULL) fails, but still removes the message */
    SetLastError(0xdeadbeef);
    ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
    ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
        GetLastError() == 0xdeadbeef, /* NT4 */
        "last error is %ld\n", GetLastError() );
    ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
    ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
 
    DestroyWindow(hchild);
    DestroyWindow(hparent);
    flush_sequence();
 
    /* Message sequences for WM_SETICON */
    if (winetest_debug > 1) trace("testing WM_SETICON\n");
    hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
                           NULL, NULL, 0);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    flush_events();
    flush_sequence();
    SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
    ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
 
    ShowWindow(hwnd, SW_HIDE);
    flush_events();
    flush_sequence();
    SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
    ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
    DestroyWindow(hwnd);
    flush_sequence();
 
    hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
                           CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
                           NULL, NULL, 0);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    flush_events();
    flush_sequence();
    SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
    ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
 
    ShowWindow(hwnd, SW_HIDE);
    flush_events();
    flush_sequence();
    SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
    ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
 
    flush_sequence();
    res = SendMessageA(hwnd, 0x3B, 0x8000000b, 0);
    if (!res)
    {
        todo_wine win_skip( "Message 0x3b not supported\n" );
        goto done;
    }
    ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
    ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %Id\n", res);
    res = SendMessageA(hwnd, 0x3B, 0x0000000b, 0);
    ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
    ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %Id\n", res);
    res = SendMessageA(hwnd, 0x3B, 0x0000000f, 0);
    ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
    ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %Id\n", res);
 
    flush_sequence();
    res = SendMessageA(hwnd, 0x3B, 0x80000008, 0);
    ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
    ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %Id\n", res);
    res = SendMessageA(hwnd, 0x3B, 0x00000008, 0);
    ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
    ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %Id\n", res);
 
    res = SendMessageA(hwnd, 0x3B, 0x80000004, 0);
    ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
    ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %Id\n", res);
 
    res = SendMessageA(hwnd, 0x3B, 0x80000001, 0);
    ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
    ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %Id\n", res);
 
done:
    DestroyWindow(hwnd);
    flush_sequence();
}

Referenced by START_TEST().

◆ test_msg_setpos_()

static void test_msg_setpos_	(	const struct message *	expected_list,
		UINT	flags,
		BOOL	todo,
		const char *	file,
		int	line
	)

static

Definition at line 5541 of file msg.c.

{
    HWND hwnd;
 
    flush_events();
    flush_sequence();
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
                             10, 10, 100, 100, NULL, 0, 0, NULL );
    ok (hwnd != 0, "Failed to create popup window\n");
    SetWindowPos(hwnd, NULL, 0, 0, 100, 100, flags);
    ok_sequence_(expected_list, "SetWindowPos:show_popup_first_show_window", todo, file, line);
    DestroyWindow(hwnd);
}

◆ test_MsgWaitForMultipleObjects()

static void test_MsgWaitForMultipleObjects ( HWND hwnd )

static

Definition at line 5403 of file msg.c.

{
    DWORD ret;
    MSG msg;
 
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    PostMessageA(hwnd, WM_USER, 0, 0);
 
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    PostMessageA(hwnd, WM_USER, 0, 0);
 
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    PostMessageA(hwnd, WM_USER, 0, 0);
 
    /* new incoming message causes it to become signaled again */
    ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
    ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
 
    ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
    ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    /* MWMO_INPUTAVAILABLE should succeed even if the message was already seen */
    PostMessageA( hwnd, WM_USER, 0, 0 );
    ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_INPUTAVAILABLE );
    ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
 
    ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    /* without MWMO_ALERTABLE the result is never WAIT_IO_COMPLETION */
    ret = QueueUserAPC( apc_test_proc, GetCurrentThread(), 0 );
    ok(ret, "QueueUserAPC failed %lu\n", GetLastError());
 
    ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, 0 );
    ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
 
    /* but even with MWMO_ALERTABLE window events are preferred */
    PostMessageA( hwnd, WM_USER, 0, 0 );
 
    ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
    ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
 
    ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
    ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
 
    /* the APC call is still queued */
    ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
    ok(ret == WAIT_IO_COMPLETION, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
}

Referenced by test_messages().

◆ test_notify_message()

static void test_notify_message ( void )

static

Definition at line 14762 of file msg.c.

{
    HWND hwnd;
    BOOL ret;
    MSG msg;
 
    hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0, NULL, NULL, 0);
    ok(hwnd != 0, "Failed to create window\n");
    flush_events();
    flush_sequence();
 
    ret = SendNotifyMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "SendNotifyMessageA failed with error %lu\n", GetLastError());
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = SendNotifyMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "SendNotifyMessageW failed with error %lu\n", GetLastError());
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = SendMessageCallbackA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
    ok(ret == TRUE, "SendMessageCallbackA failed with error %lu\n", GetLastError());
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = SendMessageCallbackW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
    ok(ret == TRUE, "SendMessageCallbackW failed with error %lu\n", GetLastError());
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = PostMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "PostMessageA failed with error %lu\n", GetLastError());
    flush_events();
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = PostMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "PostMessageW failed with error %lu\n", GetLastError());
    flush_events();
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = PostThreadMessageA(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "PostThreadMessageA failed with error %lu\n", GetLastError());
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        msg.hwnd = hwnd;
        DispatchMessageA(&msg);
    }
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    ret = PostThreadMessageW(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
    ok(ret == TRUE, "PostThreadMessageW failed with error %lu\n", GetLastError());
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        msg.hwnd = hwnd;
        DispatchMessageA(&msg);
    }
    ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_nullCallback()

static void test_nullCallback ( void )

static

Definition at line 16328 of file msg.c.

{
    HWND hwnd;
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
 
    SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
    flush_events();
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_paint_messages()

static void test_paint_messages ( void )

static

Definition at line 8487 of file msg.c.

{
    BOOL ret;
    RECT rect, rect2;
    DWORD style;
    POINT pt;
    MSG msg;
    HWND hparent, hchild;
    HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
    HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
    HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
                                100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
 
    ShowWindow( hwnd, SW_SHOW );
    UpdateWindow( hwnd );
    flush_events();
    flush_sequence();
 
    check_update_rgn( hwnd, 0 );
    SetRectRgn( hrgn, 10, 10, 20, 20 );
    ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, hrgn );
    SetRectRgn( hrgn2, 20, 20, 30, 30 );
    ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
    check_update_rgn( hwnd, hrgn );
    /* validate everything */
    ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
 
    /* test empty region */
    SetRectRgn( hrgn, 10, 10, 10, 15 );
    ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
    /* test empty rect */
    SetRect( &rect, 10, 10, 10, 15 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
 
    /* test a zeroed rectangle */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 0, 0, 0, 0 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
 
    /* a well ordered rectangle */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 10, 5, 17, 21 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    SetRectRgn( hrgn, 10, 5, 17, 21 );
    check_update_rgn( hwnd, hrgn );
 
    /* empty rectangle, top and bottom are swapped but left and right have
       the same value */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 5, 30, 5, 10 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
 
    /* empty rectangle, left and right are swapped but top and bottom have
       the same value */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 17, 10, 5, 10 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    check_update_rgn( hwnd, 0 );
 
    /* Left and right are swapped */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 21, 12, 7, 30 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    SetRectRgn( hrgn, 7, 12, 21, 30 );
    check_update_rgn( hwnd, hrgn );
 
    /* Top and bottom are swapped */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 7, 30, 21, 12 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    SetRectRgn( hrgn, 7, 12, 21, 30 );
    check_update_rgn( hwnd, hrgn );
 
    /* both reference points are swapped */
    RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
    SetRect( &rect, 21, 30, 7, 12 );
    ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
    ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
    SetRectRgn( hrgn, 7, 12, 21, 30 );
    check_update_rgn( hwnd, hrgn );
 
    /* flush pending messages */
    flush_events();
    flush_sequence();
 
    GetClientRect( hwnd, &rect );
    SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
    /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
     * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
     */
    SetRectEmpty( &rect );
    ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) failed\n");
    check_update_rgn( hwnd, hrgn );
    ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    flush_events();
    ok_sequence( WmPaint, "Paint", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    check_update_rgn( hwnd, 0 );
 
    SetRectEmpty( &rect );
    ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, 0 );
 
    SetRectEmpty( &rect );
    ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_VALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, 0 );
 
    GetWindowRect( hwnd, &rect );
    ok(RedrawWindow(0, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, 0 );
 
    flush_events();
    ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, hrgn );
    ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    flush_events();
    ok_sequence( WmPaint, "Paint", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    check_update_rgn( hwnd, 0 );
 
    ok(RedrawWindow(GetDesktopWindow(), &rect, 0,
                    RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    ret = GetUpdateRgn( hwnd, hrgn2, FALSE );
    ok( ret == NULLREGION || broken(ret == SIMPLEREGION), /* <= win7 */
        "region should be null (%d)\n", ret );
    if (ret == SIMPLEREGION) ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    flush_events();
 
    ok(RedrawWindow(GetDesktopWindow(), NULL, 0,
                    RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    ret = GetUpdateRgn( hwnd, hrgn2, FALSE );
    ok( ret == NULLREGION || broken(ret == SIMPLEREGION), /* <= win7 */
        "region should be null (%d)\n", ret );
    if (ret == SIMPLEREGION) ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    flush_events();
 
    SetRectRgn( hrgn2, rect.left, rect.top, rect.right, rect.bottom );
    ok(RedrawWindow(0, NULL, hrgn2, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, hrgn );
    ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    flush_events();
    ok_sequence( WmPaint, "Paint", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    check_update_rgn( hwnd, 0 );
 
    ok(RedrawWindow(0, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, 0 );
 
    ok(RedrawWindow(0, NULL, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW ),
       "RedrawWindow failed\n");
    check_update_rgn( hwnd, hrgn );
    ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
    flush_events();
    ok_sequence( WmPaint, "Paint", FALSE );
    RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
    check_update_rgn( hwnd, 0 );
 
    /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
     * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
     */
    SetRectEmpty( &rect );
    if (ValidateRect(0, &rect) && /* not supported on Win9x */
        GetUpdateRect(hwnd, NULL, FALSE))  /* or >= Win 8 */
    {
        check_update_rgn( hwnd, hrgn );
        ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
        flush_events();
        ok_sequence( WmPaint, "Paint", FALSE );
        RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
        check_update_rgn( hwnd, 0 );
    }
 
    SetLastError(0xdeadbeef);
    ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
       "wrong error code %ld\n", GetLastError());
    check_update_rgn( hwnd, 0 );
    flush_events();
    ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
 
    SetLastError(0xdeadbeef);
    ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
       broken( GetLastError() == 0xdeadbeef ) /* win9x */,
       "wrong error code %ld\n", GetLastError());
    check_update_rgn( hwnd, 0 );
    flush_events();
    ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
 
    SetLastError(0xdeadbeef);
    ok(!UpdateWindow(NULL), "UpdateWindow(NULL) should fail\n");
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
       broken( GetLastError() == 0xdeadbeef ) /* win9x */,
       "wrong error code %ld\n", GetLastError());
    check_update_rgn( hwnd, 0 );
    flush_events();
    ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
 
    /* now with frame */
    SetRectRgn( hrgn, -5, -5, 20, 20 );
 
    /* flush pending messages */
    flush_events();
    flush_sequence();
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
    ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
 
    SetRectRgn( hrgn, 0, 0, 20, 20 );  /* GetUpdateRgn clips to client area */
    check_update_rgn( hwnd, hrgn );
 
    flush_sequence();
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
    ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
 
    flush_sequence();
    RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
    ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
 
    GetClientRect( hwnd, &rect );
    SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
    check_update_rgn( hwnd, hrgn );
 
    flush_sequence();
    RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
    ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
 
    flush_sequence();
    RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
    ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
    check_update_rgn( hwnd, 0 );
 
    flush_sequence();
    RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
    ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
    check_update_rgn( hwnd, 0 );
 
    flush_sequence();
    SetRectRgn( hrgn, 0, 0, 100, 100 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
    SetRectRgn( hrgn, 0, 0, 50, 100 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
    SetRectRgn( hrgn, 50, 0, 100, 100 );
    check_update_rgn( hwnd, hrgn );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
    ok_sequence( WmEmptySeq, "EmptySeq", FALSE );  /* must not generate messages, everything is valid */
    check_update_rgn( hwnd, 0 );
 
    flush_sequence();
    SetRectRgn( hrgn, 0, 0, 100, 100 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
    SetRectRgn( hrgn, 0, 0, 100, 50 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
    ok_sequence( WmErase, "Erase", FALSE );
    SetRectRgn( hrgn, 0, 50, 100, 100 );
    check_update_rgn( hwnd, hrgn );
 
    flush_sequence();
    SetRectRgn( hrgn, 0, 0, 100, 100 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
    SetRectRgn( hrgn, 0, 0, 50, 50 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
    ok_sequence( WmPaint, "Paint", FALSE );
 
    flush_sequence();
    SetRectRgn( hrgn, -4, -4, -2, -2 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
    SetRectRgn( hrgn, -200, -200, -198, -198 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
    ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
 
    flush_sequence();
    SetRectRgn( hrgn, -4, -4, -2, -2 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
    SetRectRgn( hrgn, -4, -4, -3, -3 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
    SetRectRgn( hrgn, 0, 0, 1, 1 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
    ok_sequence( WmPaint, "Paint", FALSE );
 
    flush_sequence();
    SetRectRgn( hrgn, -4, -4, -1, -1 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
    RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
    /* make sure no WM_PAINT was generated */
    flush_events();
    ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
 
    flush_sequence();
    SetRectRgn( hrgn, -4, -4, -1, -1 );
    RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
    {
        if (msg.hwnd == hwnd && msg.message == WM_PAINT)
        {
            /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
            INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
            ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
            ret = GetUpdateRect( hwnd, &rect, FALSE );
            ok( ret, "Invalid GetUpdateRect result %d\n", ret );
            /* this will send WM_NCPAINT and validate the non client area */
            ret = GetUpdateRect( hwnd, &rect, TRUE );
            ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
        }
        DispatchMessageA( &msg );
    }
    ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
 
    DestroyWindow( hwnd );
 
    /* now test with a child window */
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
                           10, 10, 100, 100, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
 
    ShowWindow( hparent, SW_SHOW );
    UpdateWindow( hparent );
    UpdateWindow( hchild );
    flush_events();
    flush_sequence();
    log_all_parent_messages++;
 
    SetRect( &rect, 0, 0, 50, 50 );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
    ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
 
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    pt.x = pt.y = 0;
    MapWindowPoints( hchild, hparent, &pt, 1 );
    SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
    check_update_rgn( hchild, hrgn );
    SetRectRgn( hrgn, 0, 0, 50, 50 );
    check_update_rgn( hparent, hrgn );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
    RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
 
    flush_events();
    ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
 
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
    RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
 
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
    ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
 
    SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
    flush_sequence();
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
 
    /* flush all paint messages */
    flush_events();
    flush_sequence();
 
    /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
    SetRectRgn( hrgn, 0, 0, 50, 50 );
    check_update_rgn( hparent, hrgn );
    RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
    ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
    SetRectRgn( hrgn, 0, 0, 50, 50 );
    check_update_rgn( hparent, hrgn );
 
    /* flush all paint messages */
    flush_events();
    SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
    flush_sequence();
 
    /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetRectRgn( hrgn, 0, 0, 50, 50 );
    check_update_rgn( hparent, hrgn );
    RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
    ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
    SetRectRgn( hrgn2, 10, 10, 50, 50 );
    CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
    check_update_rgn( hparent, hrgn );
    /* flush all paint messages */
    flush_events();
    flush_sequence();
 
    /* same as above but parent gets completely validated */
    SetRect( &rect, 20, 20, 30, 30 );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetRectRgn( hrgn, 20, 20, 30, 30 );
    check_update_rgn( hparent, hrgn );
    RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
    ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
    check_update_rgn( hparent, 0 );  /* no update region */
    flush_events();
    ok_sequence( WmEmptySeq, "WmEmpty", FALSE );  /* and no paint messages */
 
    /* make sure RDW_VALIDATE on child doesn't have the same effect */
    flush_sequence();
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetRectRgn( hrgn, 20, 20, 30, 30 );
    check_update_rgn( hparent, hrgn );
    RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
    SetRectRgn( hrgn, 20, 20, 30, 30 );
    check_update_rgn( hparent, hrgn );
 
    /* same as above but normal WM_PAINT doesn't validate parent */
    flush_sequence();
    SetRect( &rect, 20, 20, 30, 30 );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetRectRgn( hrgn, 20, 20, 30, 30 );
    check_update_rgn( hparent, hrgn );
    /* no WM_PAINT in child while parent still pending */
    while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
    while (PeekMessageA( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
 
    flush_sequence();
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    /* no WM_PAINT in child while parent still pending */
    while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
    RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
    /* now that parent is valid child should get WM_PAINT */
    while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "No other message", FALSE );
 
    /* same thing with WS_CLIPCHILDREN in parent */
    flush_sequence();
    SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
    ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
    /* changing style invalidates non client area, but we need to invalidate something else to see it */
    RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
    ok_sequence( WmEmptySeq, "No message", FALSE );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
    ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
 
    flush_sequence();
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
    SetRectRgn( hrgn, 20, 20, 30, 30 );
    check_update_rgn( hparent, hrgn );
    /* no WM_PAINT in child while parent still pending */
    while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
    /* WM_PAINT in parent first */
    while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
    ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
 
    /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
    flush_sequence();
    SetRect( &rect, 0, 0, 30, 30 );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
    SetRectRgn( hrgn, 0, 0, 30, 30 );
    check_update_rgn( hparent, hrgn );
    flush_events();
    ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
 
    /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
    flush_sequence();
    SetRect( &rect, -10, 0, 30, 30 );
    RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
    SetRect( &rect, 0, 0, 20, 20 );
    RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
    RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
    ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
 
    /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
    flush_sequence();
    SetRect( &rect, -10, 0, 30, 30 );
    RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
    SetRect( &rect, 0, 0, 100, 100 );
    RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
    RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
    ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
    RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
    ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
 
    /* WS_CLIPCHILDREN doesn't exclude children from update region */
    flush_sequence();
    RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
    GetClientRect( hparent, &rect );
    SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
    check_update_rgn( hparent, hrgn );
    flush_events();
 
    RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
    GetClientRect( hparent, &rect );
    SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
    check_update_rgn( hparent, hrgn );
    flush_events();
 
    /* test RDW_INTERNALPAINT behavior */
 
    flush_sequence();
    RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
    flush_events();
    ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
 
    RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
    flush_events();
    ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
 
    RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
    flush_events();
    ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
 
    style = GetWindowLongA(hparent, GWL_STYLE);
    ok(style & WS_CLIPCHILDREN, "Got unexpected style %#lx.\n", style);
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
    RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
    flush_events();
    ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
 
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
    RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
    flush_events();
    ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
 
    SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
    ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
    RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
    flush_events();
    ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
 
    style = GetWindowLongA(hparent, GWL_STYLE);
    ok(!(style & WS_CLIPCHILDREN), "Got unexpected style %#lx.\n", style);
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
    RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
    flush_events();
    ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
 
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
    RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
    SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
    flush_events();
    ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
 
    ok(GetWindowLongA( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
    ok(GetWindowLongA( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
 
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SetWindowPos(-10000, -10000) on child\n");
    SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
    check_update_rgn( hchild, 0 );
    flush_events();
 
#if 0 /* this one doesn't pass under Wine yet */
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing ShowWindow(SW_MINIMIZE) on child\n");
    ShowWindow( hchild, SW_MINIMIZE );
    check_update_rgn( hchild, 0 );
    flush_events();
#endif
 
    UpdateWindow( hparent );
    flush_events();
    flush_sequence();
    if (winetest_debug > 1) trace("testing SetWindowPos(-10000, -10000) on parent\n");
    SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
    check_update_rgn( hparent, 0 );
    flush_events();
 
    log_all_parent_messages--;
    DestroyWindow( hparent );
    ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
 
    /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
 
    hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hparent != 0, "Failed to create parent window\n");
 
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
                           10, 10, 100, 100, hparent, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child window\n");
 
    ShowWindow( hparent, SW_SHOW );
    UpdateWindow( hparent );
    UpdateWindow( hchild );
    flush_events();
    flush_sequence();
 
    /* moving child outside of parent boundaries changes update region */
    SetRect( &rect, 0, 0, 40, 40 );
    RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
    SetRectRgn( hrgn, 0, 0, 40, 40 );
    check_update_rgn( hchild, hrgn );
    MoveWindow( hchild, -10, 10, 100, 100, FALSE );
    SetRectRgn( hrgn, 10, 0, 40, 40 );
    check_update_rgn( hchild, hrgn );
    MoveWindow( hchild, -10, -10, 100, 100, FALSE );
    SetRectRgn( hrgn, 10, 10, 40, 40 );
    check_update_rgn( hchild, hrgn );
 
    /* moving parent off-screen does too */
    SetRect( &rect, 0, 0, 100, 100 );
    RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
    SetRectRgn( hrgn, 0, 0, 100, 100 );
    check_update_rgn( hparent, hrgn );
    SetRectRgn( hrgn, 10, 10, 40, 40 );
    check_update_rgn( hchild, hrgn );
    MoveWindow( hparent, -20, -20, 200, 200, FALSE );
    GetUpdateRect( hparent, &rect2, FALSE );
    if (!EqualRect( &rect2, &rect )) /* Win 8 and later don't crop update to screen */
    {
        rect.left += 20;
        rect.top += 20;
    }
    SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
    check_update_rgn( hparent, hrgn );
    SetRectRgn( hrgn, rect.left + 10, rect.top + 10, 40, 40 );
    check_update_rgn( hchild, hrgn );
 
    /* invalidated region is cropped by the parent rects */
    SetRect( &rect, 0, 0, 50, 50 );
    RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
    SetRectRgn( hrgn, rect2.left + 10, rect2.top + 10, 50, 50 );
    check_update_rgn( hchild, hrgn );
 
    DestroyWindow( hparent );
    ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
    flush_sequence();
 
    DeleteObject( hrgn );
    DeleteObject( hrgn2 );
}

Referenced by START_TEST().

◆ test_paintingloop()

static void test_paintingloop ( void )

static

Definition at line 17800 of file msg.c.

{
    HWND hwnd;
 
#ifdef __REACTOS__
    if (!is_reactos() && GetNTVersion() == _WIN32_WINNT_WS03) {
        skip("I think this test crashes on our WS03 test bot!\n");
        return;
    }
#endif
    paint_loop_done = FALSE;
    hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
                               "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
                                100, 100, 100, 100, 0, 0, 0, NULL );
    ok(hwnd != 0, "PaintLoop window error %lu\n", GetLastError());
    ShowWindow(hwnd,SW_NORMAL);
    SetFocus(hwnd);
 
    while (!paint_loop_done)
    {
        MSG msg;
        if (PeekMessageA(&msg, 0, 0, 0, 1))
        {
            TranslateMessage(&msg);
            DispatchMessageA(&msg);
        }
    }
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_PeekMessage()

static void test_PeekMessage ( void )

static

Definition at line 13873 of file msg.c.

{
    MSG msg;
    HANDLE hthread;
    DWORD tid, qstatus;
    UINT qs_all_input = QS_ALLINPUT;
    UINT qs_input = QS_INPUT;
    BOOL ret, broken_flags = FALSE;
    struct peekmsg_info info;
 
    info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                              100, 100, 200, 200, 0, 0, 0, NULL);
    ok(!!info.hwnd, "Failed to create window, error %lu.\n", GetLastError());
    ShowWindow(info.hwnd, SW_SHOW);
    UpdateWindow(info.hwnd);
    SetFocus(info.hwnd);
 
    info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
    info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
    info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
 
    hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
    WaitForSingleObject(info.hevent[EV_ACK], 10000);
 
    flush_events();
    flush_sequence();
 
    SetLastError(0xdeadbeef);
    qstatus = GetQueueStatus(qs_all_input);
    if (GetLastError() == ERROR_INVALID_FLAGS)
    {
        trace("QS_RAWINPUT not supported on this platform\n");
        qs_all_input &= ~QS_RAWINPUT;
        qs_input &= ~QS_RAWINPUT;
 
        SetLastError(0xdeadbeef);
        qstatus = GetQueueStatus(qs_all_input);
        if (GetLastError() == ERROR_INVALID_FLAGS)
            broken_flags = TRUE;
        ok(GetLastError() == 0xdeadbeef || broken(GetLastError() == ERROR_INVALID_FLAGS) /* win7 */,
            "wrong error %ld\n", GetLastError());
    }
    if (qstatus & QS_POSTMESSAGE)
    {
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) /* nothing */ ;
        qstatus = GetQueueStatus(qs_all_input);
    }
    ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
 
    /* pass invalid QS_xxxx flags */
    SetLastError(0xdeadbeef);
    qstatus = GetQueueStatus(0xffffffff);
    ok(qstatus == 0 || broken(qstatus)  /* win9x */, "GetQueueStatus should fail: %08lx\n", qstatus);
    if (!qstatus)
    {
        ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %ld\n", GetLastError());
        SetLastError(0xdeadbeef);
        qstatus = GetQueueStatus(qs_all_input);
        ok(GetLastError() == 0xdeadbeef || broken(broken_flags && GetLastError() == ERROR_INVALID_FLAGS),
            "wrong error %ld\n", GetLastError());
    }
    qstatus &= ~MAKELONG( 0x4000, 0x4000 );  /* sometimes set on Win95 */
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE) ||
        broken(broken_flags && qstatus == 0),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmUser, "WmUser", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
 
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    qstatus = GetQueueStatus(qs_all_input);
    if (!(qstatus & MAKELONG(QS_KEY, QS_KEY)))
    {
        skip( "queuing key events not supported\n" );
        goto done;
    }
    ok(qstatus == MAKELONG(QS_KEY, QS_KEY) ||
       /* keybd_event seems to trigger a sent message on NT4 */
       qstatus == MAKELONG(QS_KEY|QS_SENDMESSAGE, QS_KEY|QS_SENDMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY) ||
       qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    InvalidateRect(info.hwnd, NULL, FALSE);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY) ||
       qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
    if (ret && msg.message == WM_CHAR)
    {
        win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
        goto done;
    }
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    if (!sequence_cnt)  /* nt4 doesn't fetch anything with PM_QS_* flags */
    {
        win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
        goto done;
    }
    ok_sequence(WmUser, "WmUser", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE );
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmUser, "WmUser", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
    ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
       "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
       ret, msg.message, msg.wParam);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
    ok(ret && msg.message == WM_PAINT,
       "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
    DispatchMessageA(&msg);
    ok_sequence(WmPaint, "WmPaint", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
    ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
       "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
       ret, msg.message, msg.wParam);
    ok_sequence(WmUser, "WmUser", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmUser, "WmUser", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
        ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
    else /* workaround for a missing QS_RAWINPUT support */
        ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
    ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
       "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
       ret, msg.message, msg.wParam);
    ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
        ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
    else /* workaround for a missing QS_RAWINPUT support */
        ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
    ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
       "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYUP wParam 'N'\n",
       ret, msg.message, msg.wParam);
    ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
       "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
       ret, msg.message, msg.wParam);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == 0,
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == 0,
       "wrong qstatus %08lx\n", qstatus);
 
    /* test whether presence of the quit flag in the queue affects
     * the queue state
     */
    PostQuitMessage(0x1234abcd);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_USER, 0, 0);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(ret && msg.message == WM_USER,
       "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(ret && msg.message == WM_QUIT,
       "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
    ok(msg.wParam == 0x1234abcd, "got wParam %08Ix instead of 0x1234abcd\n", msg.wParam);
    ok(msg.lParam == 0, "got lParam %08Ix instead of 0\n", msg.lParam);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
todo_wine {
    ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
       "wrong qstatus %08lx\n", qstatus);
}
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
    ok(!ret,
       "PeekMessageA should have returned FALSE instead of msg %04x\n",
        msg.message);
    ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
 
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == 0,
       "wrong qstatus %08lx\n", qstatus);
 
    /* some GetMessage tests */
 
    keybd_event('N', 0, 0, 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    if (qstatus)
    {
        ret = GetMessageA( &msg, 0, 0, 0 );
        ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
           ret, msg.message, msg.wParam);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == MAKELONG(0, QS_KEY), "wrong qstatus %08lx\n", qstatus);
    }
 
    if (qstatus)
    {
        ret = GetMessageA( &msg, 0, 0, 0 );
        ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
           ret, msg.message, msg.wParam);
        ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
    }
 
    keybd_event('N', 0, 0, 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    if (qstatus & (QS_KEY << 16))
    {
        ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
        ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
           ret, msg.message, msg.wParam);
        ok_sequence(WmKeyDownWasDownSkippedSeq, "WmKeyDownWasDownSkippedSeq", FALSE);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08lx\n", qstatus);
    }
 
    if (qstatus)
    {
        ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
        ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
           ret, msg.message, msg.wParam);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
    }
 
    keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
 
    if (winetest_debug > 1) trace("signalling to send message\n");
    SetEvent(info.hevent[EV_SENDMSG]);
    WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
    qstatus = GetQueueStatus(qs_all_input);
    ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
       "wrong qstatus %08lx\n", qstatus);
 
    if (qstatus & (QS_KEY << 16))
    {
        ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
        ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
           ret, msg.message, msg.wParam);
        ok_sequence(WmUserKeyUpSkippedSeq, "WmUserKeyUpSkippedSeq", FALSE);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08lx\n", qstatus);
    }
 
    if (qstatus)
    {
        ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
        ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
           "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
           ret, msg.message, msg.wParam);
        qstatus = GetQueueStatus(qs_all_input);
        ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
    }
 
    PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
    ret = PeekMessageA(&msg, (HWND)-1, 0, 0, PM_NOREMOVE);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
    ret = GetMessageA(&msg, (HWND)-1, 0, 0);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
 
    PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
    ret = PeekMessageA(&msg, (HWND)1, 0, 0, PM_NOREMOVE);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
    ret = GetMessageA(&msg, (HWND)1, 0, 0);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
 
    PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
    ret = PeekMessageA(&msg, (HWND)0xffff, 0, 0, PM_NOREMOVE);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
    ret = GetMessageA(&msg, (HWND)0xffff, 0, 0);
    ok(ret == TRUE, "wrong ret %d\n", ret);
    ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
 
done:
    if (winetest_debug > 1) trace("signalling to exit\n");
    SetEvent(info.hevent[EV_STOP]);
 
    WaitForSingleObject(hthread, INFINITE);
 
    CloseHandle(hthread);
    CloseHandle(info.hevent[0]);
    CloseHandle(info.hevent[1]);
    CloseHandle(info.hevent[2]);
 
    DestroyWindow(info.hwnd);
}

Referenced by START_TEST().

◆ test_PeekMessage2()

static void test_PeekMessage2 ( void )

static

Definition at line 14393 of file msg.c.

{
    HWND hwnd;
    BOOL ret;
    MSG msg;
    UINT message;
    DWORD time1, time2, time3;
    int x1, y1, x2, y2, x3, y3;
    POINT pos;
 
    time1 = time2 = time3 = 0;
    x1 = y1 = x2 = y2 = x3 = y3 = 0;
 
    /* Initialise window and make sure it is ready for events */
    hwnd = CreateWindowA("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
                        10, 10, 800, 800, NULL, NULL, NULL, NULL);
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
    if (winetest_debug > 1) trace("Window for test_PeekMessage2 %p\n", hwnd);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    SetFocus(hwnd);
    GetCursorPos(&pos);
    SetCursorPos(100, 100);
    mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
    flush_events();
 
    /* Do initial mousemove, wait until we can see it
       and then do our test peek with PM_NOREMOVE. */
    mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
    wait_move_event(hwnd, 100-STEP, 100-STEP);
 
    ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
    if (!ret)
    {
        skip( "queuing mouse events not supported\n" );
        goto done;
    }
    else
    {
    if (winetest_debug > 1) trace("1st move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
    message = msg.message;
    time1 = msg.time;
    x1 = msg.pt.x;
    y1 = msg.pt.y;
        ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
    }
 
    /* Allow time to advance a bit, and then simulate the user moving their
     * mouse around. After that we peek again with PM_NOREMOVE.
     * Although the previous mousemove message was never removed, the
     * mousemove we now peek should reflect the recent mouse movements
     * because the input queue will merge the move events. */
    Sleep(100);
    mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
    wait_move_event(hwnd, x1, y1);
 
    ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
    ok(ret, "no message available\n");
    if (ret) {
    if (winetest_debug > 1) trace("2nd move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
    message = msg.message;
    time2 = msg.time;
    x2 = msg.pt.x;
    y2 = msg.pt.y;
        ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
    ok(time2 > time1, "message time not advanced: %lx %lx\n", time1, time2);
    ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
    }
 
    /* Have another go, to drive the point home */
    Sleep(100);
    mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
    wait_move_event(hwnd, x2, y2);
 
    ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
    ok(ret, "no message available\n");
    if (ret) {
    if (winetest_debug > 1) trace("3rd move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
    message = msg.message;
    time3 = msg.time;
    x3 = msg.pt.x;
    y3 = msg.pt.y;
        ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
    ok(time3 > time2, "message time not advanced: %lx %lx\n", time2, time3);
    ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
    }
 
done:
    DestroyWindow(hwnd);
    SetCursorPos(pos.x, pos.y);
    flush_events();
}

Referenced by START_TEST().

◆ test_PeekMessage3()

static void test_PeekMessage3 ( void )

static

Definition at line 14486 of file msg.c.

{
    HWND parent_hwnd, hwnd;
    BOOL ret;
    MSG msg;
 
    parent_hwnd = CreateWindowA("SimpleWindowClass", "PeekMessage3", WS_OVERLAPPEDWINDOW,
                         10, 10, 800, 800, NULL, NULL, NULL, NULL);
    ok(parent_hwnd != NULL, "expected parent_hwnd != NULL\n");
 
    hwnd = CreateWindowA("TestWindowClass", "PeekMessage3", WS_CHILD, 0, 0, 1, 1,
        parent_hwnd, NULL, NULL, NULL);
    ok(hwnd != NULL, "expected hwnd != NULL\n");
 
    flush_events();
 
    /* GetMessage() and PeekMessage(..., PM_REMOVE) should prefer messages which
     * were already seen. */
 
    SetTimer(hwnd, 1, 100, NULL);
    while (!PeekMessageA(&msg, hwnd, 0, 0, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    PostMessageA(hwnd, WM_USER, 0, 0);
    ret = PeekMessageA(&msg, hwnd, 0, 0, PM_NOREMOVE);
    todo_wine
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    SetTimer(hwnd, 1, 100, NULL);
    while (!PeekMessageA(&msg, hwnd, 0, 0, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    PostMessageA(hwnd, WM_USER, 0, 0);
    ret = PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE);
    todo_wine
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE);
    todo_wine
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    /* It doesn't matter if a message range is specified or not. */
 
    SetTimer(hwnd, 1, 100, NULL);
    while (!PeekMessageA(&msg, hwnd, WM_TIMER, WM_TIMER, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    PostMessageA(hwnd, WM_USER, 0, 0);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    /* But not if the post messages were added before the PeekMessage() call. */
 
    PostMessageA(hwnd, WM_USER, 0, 0);
    SetTimer(hwnd, 1, 100, NULL);
    while (!PeekMessageA(&msg, hwnd, WM_TIMER, WM_TIMER, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    /* More complicated test with multiple messages. */
 
    PostMessageA(hwnd, WM_USER, 0, 0);
    SetTimer(hwnd, 1, 100, NULL);
    while (!PeekMessageA(&msg, hwnd, WM_TIMER, WM_TIMER, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    PostMessageA(hwnd, WM_USER + 1, 0, 0);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    todo_wine
    ok(ret && msg.message == WM_USER + 1, "msg.message = %u instead of WM_USER + 1\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    /* Also works for posted messages, but the situation is a bit different,
     * because both messages are in the same queue. */
 
    PostMessageA(hwnd, WM_TIMER, 0, 0);
    while (!PeekMessageA(&msg, hwnd, WM_TIMER, WM_TIMER, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    PostMessageA(hwnd, WM_USER, 0, 0);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    PostMessageA(hwnd, WM_USER, 0, 0);
    PostMessageA(hwnd, WM_TIMER, 0, 0);
    while (!PeekMessageA(&msg, hwnd, WM_TIMER, WM_TIMER, PM_NOREMOVE));
    ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
    ret = GetMessageA(&msg, hwnd, 0, 0);
    ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
    ret = PeekMessageA(&msg, hwnd, 0, 0, 0);
    ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
 
    DestroyWindow(parent_hwnd);
    flush_events();
}

Referenced by START_TEST().

◆ test_PostMessage()

static void test_PostMessage ( void )

static

Definition at line 18393 of file msg.c.

{
    static const struct
    {
        HWND hwnd;
        BOOL ret;
    } data[] =
    {
        { HWND_TOP /* 0 */, TRUE },
        { HWND_BROADCAST, TRUE },
        { HWND_BOTTOM, TRUE },
        { HWND_TOPMOST, TRUE },
        { HWND_NOTOPMOST, FALSE },
        { HWND_MESSAGE, FALSE },
        { (HWND)0xdeadbeef, FALSE }
    };
    int i;
    HWND hwnd;
    BOOL ret;
    MSG msg;
    static const WCHAR staticW[] = {'s','t','a','t','i','c',0};
 
    SetLastError(0xdeadbeef);
    hwnd = CreateWindowExW(0, staticW, NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
    if (!hwnd && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        win_skip("Skipping some PostMessage tests on Win9x/WinMe\n");
        return;
    }
    ok(!!hwnd, "Failed to create window, error %lu.\n", GetLastError());
 
    flush_events();
 
    PostMessageA(hwnd, WM_USER+1, 0x1234, 0x5678);
    PostMessageA(0, WM_USER+2, 0x5678, 0x1234);
 
    for (i = 0; i < ARRAY_SIZE(data); i++)
    {
        memset(&msg, 0xab, sizeof(msg));
        ret = PeekMessageA(&msg, data[i].hwnd, 0, 0, PM_NOREMOVE);
        ok(ret == data[i].ret, "%d: hwnd %p expected %d, got %d\n", i, data[i].hwnd, data[i].ret, ret);
        if (data[i].ret)
        {
            if (data[i].hwnd)
                ok(ret && msg.hwnd == 0 && msg.message == WM_USER+2 &&
                   msg.wParam == 0x5678 && msg.lParam == 0x1234,
                   "%d: got ret %d hwnd %p msg %04x wParam %08Ix lParam %08Ix instead of TRUE/0/WM_USER+2/0x5678/0x1234\n",
                   i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam);
            else
                ok(ret && msg.hwnd == hwnd && msg.message == WM_USER+1 &&
                   msg.wParam == 0x1234 && msg.lParam == 0x5678,
                   "%d: got ret %d hwnd %p msg %04x wParam %08Ix lParam %08Ix instead of TRUE/%p/WM_USER+1/0x1234/0x5678\n",
                   i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam, msg.hwnd);
        }
    }
 
    DestroyWindow(hwnd);
    flush_events();
}

Referenced by START_TEST().

◆ test_quit_message()

static void test_quit_message ( void )

static

Definition at line 14663 of file msg.c.

{
    MSG msg;
    BOOL ret;
 
    /* test using PostQuitMessage */
    flush_events();
    PostQuitMessage(0xbeef);
 
    msg.message = 0;
    ret = PeekMessageA(&msg, 0, 0, 0, PM_QS_SENDMESSAGE);
    ok(!ret, "got %x message\n", msg.message);
 
    ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
    ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
    ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
    ok(msg.wParam == 0xbeef, "wParam was 0x%Ix instead of 0xbeef\n", msg.wParam);
 
    ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
    ok(ret, "PostMessage failed with error %ld\n", GetLastError());
 
    ret = GetMessageA(&msg, NULL, 0, 0);
    ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
    ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
 
    /* note: WM_QUIT message received after WM_USER message */
    ret = GetMessageA(&msg, NULL, 0, 0);
    ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
    ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
    ok(msg.wParam == 0xbeef, "wParam was 0x%Ix instead of 0xbeef\n", msg.wParam);
 
    ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
    ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
 
    /* now test with PostThreadMessage - different behaviour! */
    PostThreadMessageA(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
 
    ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
    ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
    ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
    ok(msg.wParam == 0xdead, "wParam was 0x%Ix instead of 0xdead\n", msg.wParam);
 
    ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
    ok(ret, "PostMessage failed with error %ld\n", GetLastError());
 
    /* note: we receive the WM_QUIT message first this time */
    ret = GetMessageA(&msg, NULL, 0, 0);
    ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
    ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
    ok(msg.wParam == 0xdead, "wParam was 0x%Ix instead of 0xdead\n", msg.wParam);
 
    ret = GetMessageA(&msg, NULL, 0, 0);
    ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
    ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
 
    flush_events();
    flush_sequence();
    ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, wm_quit_dlg_proc, 0);
    ok(ret == 1, "expected 1, got %d\n", ret);
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok_sequence(WmQuitDialogSeq, "WmQuitDialogSeq", FALSE);
    memset(&msg, 0xab, sizeof(msg));
    ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
    ok(ret, "PeekMessage failed\n");
    ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
    ok(msg.wParam == 0x1234, "wParam was 0x%Ix instead of 0x1234\n", msg.wParam);
    ok(msg.lParam == 0, "lParam was 0x%Ix instead of 0\n", msg.lParam);
 
    /* Check what happens to a WM_QUIT message posted to a window that gets
     * destroyed.
     */
    CreateWindowExA(0, "StopQuitClass", "Stop Quit Test", WS_OVERLAPPEDWINDOW,
                    0, 0, 100, 100, NULL, NULL, NULL, NULL);
    flush_sequence();
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
    {
        struct recvd_message rmsg;
        rmsg.hwnd = msg.hwnd;
        rmsg.message = msg.message;
        rmsg.flags = posted|wparam|lparam;
        rmsg.wParam = msg.wParam;
        rmsg.lParam = msg.lParam;
        rmsg.descr = "stop/quit";
        if (msg.message == WM_QUIT)
            /* The hwnd can only be checked here */
            ok(!msg.hwnd, "The WM_QUIT hwnd was %p instead of NULL\n", msg.hwnd);
        add_message(&rmsg);
        DispatchMessageA(&msg);
    }
    ok_sequence(WmStopQuitSeq, "WmStopQuitSeq", FALSE);
}

Referenced by START_TEST().

◆ test_radio_dbg()

static void test_radio_dbg	(	HWND	radio1,
		int	state1,
		HWND	radio2,
		int	state2,
		HWND	radio3,
		int	state3,
		int	line
	)

static

Definition at line 7567 of file msg.c.

{
    DWORD ret;
 
    ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
    ok_(__FILE__,line)(ret == state1 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
    ok_(__FILE__,line)(ret == state2 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
    ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
    ok_(__FILE__,line)(ret == state3 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
}

◆ test_radiobutton_focus()

static void test_radiobutton_focus ( void )

static

Definition at line 20700 of file msg.c.

{
    HWND hwnd, button;
    DWORD style;
    int i;
    DWORD types[] = { BS_RADIOBUTTON, BS_AUTORADIOBUTTON };
 
    static const struct message set_focus_default_seq[] =
    {
        { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
        { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_BUTTON, BN_CLICKED) },
        { 0 }
    };
 
    static const struct message set_focus_checked_seq[] =
    {
        { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
        { 0 }
    };
 
    static const struct message WM_LBUTTONDOWN_seq[] =
    {
        { WM_KILLFOCUS, sent|parent },
        { WM_IME_SETCONTEXT, sent|optional|parent },
        { WM_IME_SETCONTEXT, sent|optional|defwinproc },
        { WM_COMMAND, sent|parent },
        { 0 }
    };
 
    static const struct message set_focus_without_notify_seq[] =
    {
        { WM_COMMAND, sent|parent|wparam, ID_BUTTON },
        { 0 }
    };
 
    hwnd = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok(hwnd != 0, "Failed to create parent window\n");
 
    for (i = 0; i < ARRAY_SIZE(types); i++)
    {
        /* Test default button */
        style = types[i] | WS_CHILD | WS_VISIBLE | BS_NOTIFY;
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        ok(button != NULL, "failed to create a button, 0x%08lx, %p\n", style, hwnd);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        flush_events();
        ok_sequence(set_focus_default_seq, "WM_SETFOCUS on default radiobutton", FALSE);
        DestroyWindow(button);
 
        /* Test already checked button */
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        SendMessageA(button, BM_SETCHECK, BST_CHECKED, 0);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        flush_events();
        ok_sequence(set_focus_checked_seq, "WM_SETFOCUS on checked radiobutton", FALSE);
        DestroyWindow(button);
 
        /* Test already focused button */
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        SendMessageA(button, BM_SETCHECK, BST_UNCHECKED, 0);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        flush_events();
        ok_sequence(set_focus_default_seq, "WM_SETFOCUS on focused radiobutton", FALSE);
        DestroyWindow(button);
 
        /* Test WM_LBUTTONDOWN */
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_LBUTTONDOWN, 0, MAKELPARAM(7, 7));
        flush_events();
        ok_sequence(WM_LBUTTONDOWN_seq, "WM_LBUTTONDOWN on radiobutton", FALSE);
        DestroyWindow(button);
 
        /* Test without BS_NOTIFY */
        style = types[i] | WS_CHILD | WS_VISIBLE;
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        flush_events();
        ok_sequence(set_focus_without_notify_seq, "WM_SETFOCUS on radiobutton without BS_NOTIFY", FALSE);
        DestroyWindow(button);
 
        /* Test disabled button */
        style = types[i] | WS_CHILD | WS_VISIBLE | BS_NOTIFY;
        button = CreateWindowExA(0, WC_BUTTONA, "test", style, 0, 0, 50, 14, hwnd, (HMENU)ID_BUTTON, 0, NULL);
        EnableWindow(button, FALSE);
        flush_events();
        flush_sequence();
        SendMessageA(button, WM_SETFOCUS, 0, 0);
        flush_events();
        ok_sequence(set_focus_default_seq, "WM_SETFOCUS on disabled radiobutton", FALSE);
        DestroyWindow(button);
    }
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_recursive_hook()

static void test_recursive_hook ( void )

static

Definition at line 12680 of file msg.c.

{
    HHOOK hook, cbt_hook;
    INPUT input = {0};
    MSG msg;
    BOOL b;
 
#ifdef __REACTOS__
    if (is_reactos()) {
        ok(FALSE, "FIXME: Recursive msg tests crash on ReactOS!\n");
        return;
    }
#endif
    hook_hwnd = CreateWindowExA(WS_EX_TOPMOST, "Static", NULL, WS_POPUP | WS_VISIBLE, 0, 0, 200, 60,
                                NULL, NULL, NULL, NULL);
    ok(hook_hwnd != NULL, "CreateWindow failed\n");
 
    recursive_hook = SetWindowsHookExW(WH_GETMESSAGE, rec_get_message_hook, NULL, GetCurrentThreadId());
    ok(recursive_hook != NULL, "SetWindowsHookEx failed\n");
 
    PostMessageW(hook_hwnd, WM_USER, 0, 0);
    PostMessageW(hook_hwnd, WM_USER+1, 0, 0);
 
    hook_depth = 0;
    GetMessageW(&msg, hook_hwnd, 0, 0);
    ok(15 <= max_hook_depth && max_hook_depth < 45, "max_hook_depth = %d\n", max_hook_depth);
    if (winetest_debug > 1) trace("max_hook_depth = %d\n", max_hook_depth);
 
    b = UnhookWindowsHookEx(recursive_hook);
    ok(b, "UnhokWindowsHookEx failed\n");
 
    /* Test possible recursive hook conditions */
    b = SetForegroundWindow(hook_hwnd);
    ok(b, "SetForegroundWindow failed, error %ld.\n", GetLastError());
 
    /* Test a possible recursive WH_KEYBOARD hook condition */
    max_hook_depth = 0;
    hook = SetWindowsHookExA(WH_KEYBOARD, keyboard_recursive_hook_proc, NULL, GetCurrentThreadId());
    ok(!!hook, "SetWindowsHookExA failed, error %ld.\n", GetLastError());
 
    flush_events();
    input.type = INPUT_KEYBOARD;
    input.ki.wVk = VK_F3;
    SendInput(1, &input, sizeof(INPUT));
    flush_events();
 
    /* Expect the WH_KEYBOARD hook not gets called recursively */
    ok(max_hook_depth == 1, "Got expected %d.\n", max_hook_depth);
 
    /* Test a possible recursive WH_CBT HCBT_KEYSKIPPED hook condition */
    max_hook_depth = 0;
    skip_WH_KEYBOARD_hook = 1;
    cbt_hook = SetWindowsHookExA(WH_CBT, keyboard_recursive_cbt_hook_proc, NULL, GetCurrentThreadId());
    ok(!!cbt_hook, "SetWindowsHookExA failed, error %ld.\n", GetLastError());
 
    flush_events();
    input.type = INPUT_KEYBOARD;
    input.ki.wVk = VK_F3;
    SendInput(1, &input, sizeof(INPUT));
    while (PeekMessageA(&msg, hook_hwnd, WM_KEYFIRST, WM_KEYLAST, 0)) DispatchMessageA(&msg);
 
    /* Expect the WH_CBT HCBT_KEYSKIPPED hook not gets called recursively */
    ok(max_hook_depth == 1, "Got expected %d.\n", max_hook_depth);
 
    UnhookWindowsHookEx(cbt_hook);
    UnhookWindowsHookEx(hook);
 
    /* Test a recursive WH_MOUSE hook condition */
    SetCapture(hook_hwnd);
 
    max_hook_depth = 0;
    hook = SetWindowsHookExA(WH_MOUSE, mouse_recursive_hook_proc, NULL, GetCurrentThreadId());
    ok(!!hook, "SetWindowsHookExA failed, error %ld.\n", GetLastError());
 
    flush_events();
    simulate_click(FALSE, 50, 50);
    flush_events();
 
    /* Expect the WH_MOUSE hook gets called recursively */
    ok(max_hook_depth > 10, "Got expected %d.\n", max_hook_depth);
 
    /* Test a possible recursive WH_CBT HCBT_CLICKSKIPPED hook condition */
    max_hook_depth = 0;
    skip_WH_MOUSE_hook = 1;
    cbt_hook = SetWindowsHookExA(WH_CBT, mouse_recursive_cbt_hook_proc, NULL, GetCurrentThreadId());
    ok(!!cbt_hook, "SetWindowsHookExA failed, error %ld.\n", GetLastError());
 
    flush_events();
    simulate_click(FALSE, 50, 50);
    flush_events();
 
    /* Expect the WH_CBT HCBT_CLICKSKIPPED hook not gets called recursively */
    ok(max_hook_depth <= 10, "Got expected %d.\n", max_hook_depth);
 
    UnhookWindowsHookEx(cbt_hook);
    UnhookWindowsHookEx(hook);
    ReleaseCapture();
    DestroyWindow(hook_hwnd);
}

Referenced by START_TEST().

◆ test_recursive_messages()

static void test_recursive_messages ( void )

static

Definition at line 12797 of file msg.c.

{
    WNDCLASSA cls = {0};
    HWND hwnd;
 
#ifdef __REACTOS__
    if (is_reactos()) {
        ok(FALSE, "FIXME: Recursive msg tests crash on ReactOS!\n");
        return;
    }
#endif
    cls.lpfnWndProc = recursive_messages_proc;
    cls.hInstance = GetModuleHandleA(0);
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszClassName = "TestRecursiveMsgClass";
    register_class(&cls);
 
    hwnd = CreateWindowExA(WS_EX_TOPMOST, "TestRecursiveMsgClass", NULL, WS_POPUP | WS_DISABLED | WS_VISIBLE, 0, 0,
                           100, 100, NULL, NULL, NULL, NULL);
    ok(hwnd != NULL, "CreateWindowExA failed, error %ld.\n", GetLastError());
    SetForegroundWindow(hwnd);
    flush_events();
 
    max_msg_depth = 0;
    simulate_click(FALSE, 50, 50);
    flush_events();
 
    /* Expect recursive_messages_proc() gets called recursively for WM_SETCURSOR */
#ifdef __REACTOS__
    ok(max_msg_depth == 15 || broken(max_msg_depth == 14) /* 64-bit */, "Got expected %d.\n", max_msg_depth);
#else
    ok(max_msg_depth == 15, "Got expected %d.\n", max_msg_depth);
#endif
 
    DestroyWindow(hwnd);
    UnregisterClassA(cls.lpszClassName, cls.hInstance);
}

Referenced by START_TEST().

◆ test_restore_messages()

static void test_restore_messages ( void )

static

Definition at line 20522 of file msg.c.

{
    INPUT ip = {0};
    HWND hwnd;
    INT i;
 
#ifdef __REACTOS__
    if (GetNTVersion() == _WIN32_WINNT_WIN7 && !is_reactos()) {
        skip("The Alt+Tab tests here can cause Windows 7 to lock up\n");
        return;
    }
#endif
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100,
                           100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
    SetForegroundWindow(hwnd);
    ShowWindow(hwnd, SW_MINIMIZE);
    flush_events();
    flush_sequence();
 
    for (i = 0; i < 5; i++)
    {
        /* Send Alt+Tab to restore test window from minimized state */
        ip.type = INPUT_KEYBOARD;
        ip.ki.wVk = VK_MENU;
        SendInput(1, &ip, sizeof(INPUT));
        ip.ki.wVk = VK_TAB;
        SendInput(1, &ip, sizeof(INPUT));
        ip.ki.wVk = VK_MENU;
        ip.ki.dwFlags = KEYEVENTF_KEYUP;
        SendInput(1, &ip, sizeof(INPUT));
        ip.ki.wVk = VK_TAB;
        ip.ki.dwFlags = KEYEVENTF_KEYUP;
        SendInput(1, &ip, sizeof(INPUT));
        flush_events();
        if (!IsIconic(hwnd))
            break;
    }
 
    if (IsIconic(hwnd))
    {
        skip("Alt+Tab failed to bring up test window.\n");
        goto done;
    }
#ifdef __REACTOS__
    if (GetNTVersion() != _WIN32_WINNT_VISTA)
#endif
    ok_sequence(WmRestoreMinimizedSeq, "Restore minimized window", TRUE);
 
done:
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_scroll_messages()

static void test_scroll_messages ( HWND hwnd )

static

Definition at line 4950 of file msg.c.

{
    SCROLLINFO si;
    INT min, max;
    BOOL ret;
 
    flush_events();
    flush_sequence();
 
    min = 0xdeadbeef;
    max = 0xdeadbeef;
    ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
    ok( ret, "GetScrollRange error %ld\n", GetLastError());
    if (sequence->message != WmGetScrollRangeSeq[0].message)
        trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
    /* values of min and max are undefined */
    flush_sequence();
 
    ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
    ok( ret, "SetScrollRange error %ld\n", GetLastError());
    if (sequence->message != WmSetScrollRangeSeq[0].message)
        trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
    flush_sequence();
 
    min = 0xdeadbeef;
    max = 0xdeadbeef;
    ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
    ok( ret, "GetScrollRange error %ld\n", GetLastError());
    if (sequence->message != WmGetScrollRangeSeq[0].message)
        trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
    /* values of min and max are undefined */
    flush_sequence();
 
    si.cbSize = sizeof(si);
    si.fMask = SIF_RANGE;
    si.nMin = 20;
    si.nMax = 160;
    SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
    if (sequence->message != WmSetScrollRangeSeq[0].message)
        trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
    flush_sequence();
 
    si.fMask = SIF_PAGE;
    si.nPage = 10;
    SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
    if (sequence->message != WmSetScrollRangeSeq[0].message)
        trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
    flush_sequence();
 
    si.fMask = SIF_POS;
    si.nPos = 20;
    SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
    if (sequence->message != WmSetScrollRangeSeq[0].message)
        trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
    flush_sequence();
 
    si.fMask = SIF_RANGE;
    si.nMin = 0xdeadbeef;
    si.nMax = 0xdeadbeef;
    ret = GetScrollInfo(hwnd, SB_CTL, &si);
    ok( ret, "GetScrollInfo error %ld\n", GetLastError());
    if (sequence->message != WmGetScrollInfoSeq[0].message)
        trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
    /* values of min and max are undefined */
    flush_sequence();
 
    /* set WS_HSCROLL */
    test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
    /* clear WS_HSCROLL */
    test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
 
    /* set WS_HSCROLL */
    test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
    /* clear WS_HSCROLL */
    test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
 
    /* set WS_VSCROLL */
    test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
    /* clear WS_VSCROLL */
    test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
 
    /* set WS_VSCROLL */
    test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
    /* clear WS_VSCROLL */
    test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
}

Referenced by test_messages().

◆ test_scrollwindowex()

static void test_scrollwindowex ( void )

static

Definition at line 12855 of file msg.c.

{
    HWND hwnd, hchild;
    RECT rect={0,0,130,130};
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
            WS_VISIBLE|WS_OVERLAPPEDWINDOW,
            100, 100, 200, 200, 0, 0, 0, NULL);
    ok (hwnd != 0, "Failed to create overlapped window\n");
    hchild = CreateWindowExA(0, "TestWindowClass", "Test child", 
            WS_VISIBLE|WS_CAPTION|WS_CHILD,
            10, 10, 150, 150, hwnd, 0, 0, NULL);
    ok (hchild != 0, "Failed to create child\n");
    UpdateWindow(hwnd);
    flush_events();
    flush_sequence();
 
    /* scroll without the child window */
    if (winetest_debug > 1) trace("start scroll\n");
    ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
            SW_ERASE|SW_INVALIDATE);
    ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
    if (winetest_debug > 1) trace("end scroll\n");
    flush_sequence();
    flush_events();
    ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
    flush_events();
    flush_sequence();
 
    /* Now without the SW_ERASE flag */
    if (winetest_debug > 1) trace("start scroll\n");
    ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
    ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
    if (winetest_debug > 1) trace("end scroll\n");
    flush_sequence();
    flush_events();
    ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", FALSE);
    flush_events();
    flush_sequence();
 
    /* now scroll the child window as well */
    if (winetest_debug > 1) trace("start scroll\n");
    ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
            SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
    /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
    /* windows sometimes a WM_MOVE */
    ok_sequence(WmEmptySeq, "ScrollWindowEx", TRUE);
    if (winetest_debug > 1) trace("end scroll\n");
    flush_sequence();
    flush_events();
    ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
    flush_events();
    flush_sequence();
 
    /* now scroll with ScrollWindow() */
    if (winetest_debug > 1) trace("start scroll with ScrollWindow\n");
    ScrollWindow( hwnd, 5, 5, NULL, NULL);
    if (winetest_debug > 1) trace("end scroll\n");
    flush_sequence();
    flush_events();
    ok_sequence(ScrollWindowPaint1, "ScrollWindow", FALSE);
 
    ok(DestroyWindow(hchild), "failed to destroy window\n");
    ok(DestroyWindow(hwnd), "failed to destroy window\n");
    flush_sequence();
}

Referenced by START_TEST().

◆ test_SendMessage_other_thread()

static void test_SendMessage_other_thread ( void )

static

Definition at line 20206 of file msg.c.

{
    DWORD qs_all_input = QS_ALLINPUT & ~QS_RAWINPUT;
    HANDLE hthread;
    struct wnd_event wnd_event;
    DWORD tid, ret;
    MSG msg;
 
    wnd_event.start_event = CreateEventA(NULL, 0, 0, NULL);
    wnd_event.stop_event = CreateEventA(NULL, 0, 0, NULL);
    wnd_event.getmessage_complete = CreateEventA(NULL, 0, 0, NULL);
 
    wnd_event.hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                                     100, 100, 200, 200, 0, 0, 0, NULL);
    ok(wnd_event.hwnd != 0, "CreateWindowEx failed\n");
 
    hthread = CreateThread(NULL, 0, SendMessage_thread_1, &wnd_event, 0, &tid);
    ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
    CloseHandle(hthread);
 
    flush_events();
    flush_sequence();
 
    ret = GetQueueStatus(QS_SENDMESSAGE);
    ok(ret == 0, "wrong status %08lx\n", ret);
 
    SetEvent(wnd_event.start_event);
 
    /* wait for other thread's SendMessage */
    for (;;)
    {
        ret = GetQueueStatus(QS_SENDMESSAGE);
        if (ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE)) break;
        Sleep(50);
    }
 
    ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
    ok(ret == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08lx\n", ret);
 
    if (winetest_debug > 1) trace("main: call GetMessage\n");
    GetMessageA(&msg, 0, 0, 0);
    ok(msg.message == WM_USER, "expected WM_USER, got %04x\n", msg.message);
    DispatchMessageA(&msg);
    ok_sequence(send_message_1, "SendMessage from other thread 1", FALSE);
 
    SetEvent(wnd_event.getmessage_complete);
 
    ret = WaitForSingleObject(wnd_event.stop_event, 100);
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed, ret:%lx\n", ret);
 
    /* intentionally yield */
    MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
 
    if (winetest_debug > 1) trace("main: call SendMessage\n");
    SendMessageA(wnd_event.hwnd, WM_USER+4, 0, 0);
    ok_sequence(send_message_2, "SendMessage from other thread 2", FALSE);
 
    ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
    ok(ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08lx\n", ret);
 
    if (winetest_debug > 1) trace("main: call PeekMessage\n");
    ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should not fail\n");
    ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
    DispatchMessageA(&msg);
    ok_sequence(send_message_3, "SendMessage from other thread 3", FALSE);
 
    /* intentionally yield */
    MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
 
    if (winetest_debug > 1) trace("main: call PeekMessage\n");
    while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
        ok(ignore_message(msg.message), "got unexpected message %04x from PeekMessageA\n", msg.message);
    }
    ok_sequence(send_message_5, "SendMessage from other thread 5", FALSE);
 
    ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
    ok(ret == 0, "wrong status %08lx\n", ret);
 
    if (winetest_debug > 1) trace("main: call DestroyWindow\n");
    DestroyWindow(msg.hwnd);
 
    flush_events();
    flush_sequence();
 
    CloseHandle(wnd_event.start_event);
    CloseHandle(wnd_event.stop_event);
    CloseHandle(wnd_event.getmessage_complete);
}

Referenced by START_TEST().

◆ test_SendMessageTimeout()

static void test_SendMessageTimeout ( void )

static

Definition at line 13180 of file msg.c.

{
    HANDLE thread;
    struct sendmsg_info info;
    DWORD tid;
    BOOL is_win9x;
 
    info.ready = CreateEventA( NULL, 0, 0, NULL );
    info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
                               100, 100, 200, 200, 0, 0, 0, NULL);
    flush_events();
    flush_sequence();
 
    info.timeout = 1000;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    wait_for_thread( thread );
    CloseHandle( thread );
    ok( info.ret == 1, "SendMessageTimeout failed\n" );
    ok_sequence( WmUser, "WmUser", FALSE );
 
    info.timeout = 1;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    Sleep(100);  /* SendMessageTimeout should time out here */
    wait_for_thread( thread );
    CloseHandle( thread );
    ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
    ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
 
    /* 0 means infinite timeout (but not on win9x) */
    info.timeout = 0;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    Sleep(100);
    wait_for_thread( thread );
    CloseHandle( thread );
    is_win9x = !info.ret;
    if (is_win9x) ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
    else ok_sequence( WmUser, "WmUser", FALSE );
 
    /* timeout is treated as signed despite the prototype (but not on win9x) */
    info.timeout = 0x7fffffff;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    Sleep(100);
    wait_for_thread( thread );
    CloseHandle( thread );
    ok( info.ret == 1, "SendMessageTimeout failed\n" );
    ok_sequence( WmUser, "WmUser", FALSE );
 
    info.timeout = 0x80000000;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    Sleep(100);
    wait_for_thread( thread );
    CloseHandle( thread );
    if (is_win9x)
    {
        ok( info.ret == 1, "SendMessageTimeout failed\n" );
        ok_sequence( WmUser, "WmUser", FALSE );
    }
    else
    {
        ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
        ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
    }
 
    /* now check for timeout during message processing */
    SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
    info.timeout = 100;
    info.ret = 0xdeadbeef;
    ResetEvent( info.ready );
    thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
    WaitForSingleObject( info.ready, INFINITE );
    wait_for_thread( thread );
    CloseHandle( thread );
    /* we should time out but still get the message */
    ok( info.ret == 0, "SendMessageTimeout failed\n" );
    ok_sequence( WmUser, "WmUser", FALSE );
 
    DestroyWindow( info.hwnd );
    CloseHandle( info.ready );
}

Referenced by START_TEST().

◆ test_set_hook()

static void test_set_hook ( void )

static

Definition at line 12406 of file msg.c.

{
    LRESULT (CALLBACK *p_dummy_hook_proc)(int code, WPARAM wp, LPARAM lp);
    HMODULE test_dll_module;
    char *test_dll_path;
    DWORD error;
    BOOL ret;
    HHOOK hhook;
    HWINEVENTHOOK hwinevent_hook;
    int i;
 
    hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
    ok(hhook != 0, "local hook does not require hModule set to 0\n");
    UnhookWindowsHookEx(hhook);
 
    SetLastError(0xdeadbeef);
    hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
    ok(!hhook, "global hook requires hModule != 0\n");
    ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hhook = SetWindowsHookExA(WH_JOURNALRECORD, cbt_hook_proc, 0, 0);
#ifdef __REACTOS__
    ok(!hhook || broken(GetNTVersion() == _WIN32_WINNT_VISTA || GetNTVersion() == _WIN32_WINNT_WIN7), "global hook requires hModule != 0\n");
    ok(GetLastError() == ERROR_ACCESS_DENIED
       || broken(GetLastError() == ERROR_HOOK_NEEDS_HMOD) /* WS03 */
       || broken(GetLastError() == 0xdeadbeef) /* Vista */,
       "unexpected error %ld\n", GetLastError());
#else
    ok(!hhook, "global hook requires hModule != 0\n");
    ok(GetLastError() == ERROR_ACCESS_DENIED, "unexpected error %ld\n", GetLastError());
#endif
 
    SetLastError(0xdeadbeef);
    hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
    ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
    ok(GetLastError() == ERROR_INVALID_FILTER_PROC, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
    ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE, "unexpected error %ld\n", GetLastError());
 
    test_dll_path = get_test_dll_path();
    test_dll_module = LoadLibraryA(test_dll_path);
    p_dummy_hook_proc = (void *)GetProcAddress(test_dll_module, "dummy_hook_proc");
#ifdef __REACTOS__
    /* Test failures on WS03-Win 10 1607 */
    if (0) {
#endif
    for (i = WH_MIN; i <= WH_MAX; i++)
    {
        winetest_push_context("ID %d", i);
 
        /* Test that setting hooks should succeed for hook procs in a library. But for WH_JOURNALRECORD
         * and WH_JOURNALPLAYBACK, ERROR_ACCESS_DENIED is returned, even with administrator rights */
        SetLastError(0xdeadbeef);
        hhook = SetWindowsHookExA(i, p_dummy_hook_proc, test_dll_module, 0);
        error = GetLastError();
        if (i == WH_JOURNALRECORD || i == WH_JOURNALPLAYBACK)
        {
            ok(!hhook, "SetWinEventHook succeeded.\n");
            ok(error == ERROR_ACCESS_DENIED, "Got unexpected error %ld.\n", GetLastError());
        }
        else
        {
            ok(!!hhook, "SetWinEventHook failed.\n");
            ok(error == NO_ERROR, "Got unexpected error %ld.\n", GetLastError());
        }
        if (hhook)
            UnhookWindowsHookEx(hhook);
 
        /* Test settings global hooks with a thread ID */
        SetLastError(0xdeadbeef);
        hhook = SetWindowsHookExA(i, p_dummy_hook_proc, test_dll_module, GetCurrentThreadId());
        error = GetLastError();
        if (i == WH_JOURNALRECORD || i == WH_JOURNALPLAYBACK || i == WH_SYSMSGFILTER
            || i == WH_KEYBOARD_LL || i == WH_MOUSE_LL)
        {
            ok(!hhook, "SetWinEventHook succeeded.\n");
            ok(error == ERROR_GLOBAL_ONLY_HOOK, "Got unexpected error %ld.\n", GetLastError());
        }
        else
        {
            ok(!!hhook, "SetWinEventHook failed.\n");
            ok(error == NO_ERROR, "Got unexpected error %ld.\n", GetLastError());
        }
        if (hhook)
            UnhookWindowsHookEx(hhook);
 
        winetest_pop_context();
    }
#ifdef __REACTOS__
    }
#endif
    FreeLibrary(test_dll_module);
    ret = DeleteFileA(test_dll_path);
    ok(ret, "Failed to remove the test dll, error %ld.\n", GetLastError());
 
    if (!pSetWinEventHook || !pUnhookWinEvent) return;
 
    /* even process local incontext hooks require hmodule */
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
        GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
    ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
    ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %ld\n", GetLastError());
 
    /* even thread local incontext hooks require hmodule */
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
        GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
    ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
    ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(1, 0, 0, win_event_proc,
        GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
    ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
    ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(-1, 1, 0, win_event_proc,
        GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
    ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
    ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
        0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
    ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
    todo_wine
    ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(0, 0, 0, win_event_proc,
        GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
    ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
    ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
    ret = pUnhookWinEvent(hwinevent_hook);
    ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
 
todo_wine {
    /* This call succeeds under win2k SP4, but fails under Wine.
       Does win2k test/use passed process id? */
    SetLastError(0xdeadbeef);
    hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
        0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
    ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
    ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
    ret = pUnhookWinEvent(hwinevent_hook);
    ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
}
 
    SetLastError(0xdeadbeef);
    ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE, "unexpected error %ld\n", GetLastError());
}

Referenced by START_TEST().

◆ test_SetActiveWindow()

static void test_SetActiveWindow ( void )

static

Definition at line 16456 of file msg.c.

{
    HWND hwnd, popup, ret;
 
    hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
                           WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                           100, 100, 200, 200, 0, 0, 0, NULL);
 
    popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
                           WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
                           100, 100, 200, 200, hwnd, 0, 0, NULL);
 
    ok(hwnd != 0, "Failed to create overlapped window\n");
    ok(popup != 0, "Failed to create popup window\n");
    SetForegroundWindow( popup );
    flush_sequence();
 
    if (winetest_debug > 1) trace("SetActiveWindow(0)\n");
    ret = SetActiveWindow(0);
    ok( ret == popup || broken(ret == 0) /* w1064v1809 */, "Failed to SetActiveWindow(0), ret:%p\n", ret);
    if (ret == popup) ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", FALSE);
    flush_sequence();
 
    if (winetest_debug > 1) trace("SetActiveWindow(hwnd), hwnd visible\n");
    ret = SetActiveWindow(hwnd);
    if (ret == hwnd) ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
    flush_sequence();
 
    if (winetest_debug > 1) trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
    ret = SetActiveWindow(popup);
    ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
    ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", FALSE);
    flush_sequence();
 
    ShowWindow(hwnd, SW_HIDE);
    ShowWindow(popup, SW_HIDE);
    flush_sequence();
 
    if (winetest_debug > 1) trace("SetActiveWindow(hwnd), hwnd not visible\n");
    ret = SetActiveWindow(hwnd);
#ifdef __REACTOS__
    ok( ret == NULL || broken(GetNTVersion() == _WIN32_WINNT_VISTA || GetNTVersion() == _WIN32_WINNT_WIN7), "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
#else
    ok( ret == NULL, "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
#endif
    ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
    flush_sequence();
 
    if (winetest_debug > 1) trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
    ret = SetActiveWindow(popup);
    ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
    ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
    flush_sequence();
 
    if (winetest_debug > 1) trace("done\n");
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

◆ test_SetFocus()

static void test_SetFocus ( void )

static

Definition at line 19625 of file msg.c.

{
    HWND parent, old_parent, child, old_focus, old_active;
    MSG msg;
    struct wnd_event wnd_event;
    HANDLE hthread;
    DWORD ret, tid;
 
    wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
    ok(wnd_event.start_event != 0, "CreateEvent error %ld\n", GetLastError());
    hthread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
    ok(hthread != 0, "CreateThread error %ld\n", GetLastError());
    ret = WaitForSingleObject(wnd_event.start_event, INFINITE);
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(wnd_event.start_event);
 
    parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
                            0, 0, 0, 0, 0, 0, 0, NULL);
    ok(parent != 0, "failed to create parent window\n");
    child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
                           0, 0, 0, 0, parent, 0, 0, NULL);
    ok(child != 0, "failed to create child window\n");
 
    if (winetest_debug > 1) trace("parent %p, child %p, thread window %p\n", parent, child, wnd_event.hwnd);
 
    SetFocus(0);
    SetActiveWindow(0);
 
    flush_events();
    flush_sequence();
 
    ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
 
    log_all_parent_messages++;
 
    old_focus = SetFocus(child);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmSetFocus_1, "SetFocus on a child window", TRUE);
    ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == child, "expected focus %p, got %p\n", child, GetFocus());
 
    old_focus = SetFocus(parent);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmSetFocus_2, "SetFocus on a parent window", FALSE);
    ok(old_focus == child, "expected old focus %p, got %p\n", child, old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_focus = SetFocus((HWND)0xdeadbeef);
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
       "expected ERROR_INVALID_WINDOW_HANDLE, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetFocus on an invalid window", FALSE);
    ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_focus = SetFocus(GetDesktopWindow());
    ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
       broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetFocus on a desktop window", TRUE);
    ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_focus = SetFocus(wnd_event.hwnd);
    ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
       broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetFocus on another thread window", TRUE);
    ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_active = SetActiveWindow((HWND)0xdeadbeef);
    ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
       "expected ERROR_INVALID_WINDOW_HANDLE, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetActiveWindow on an invalid window", FALSE);
    ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_active = SetActiveWindow(GetDesktopWindow());
    todo_wine
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetActiveWindow on a desktop window", TRUE);
    ok(old_active == 0, "expected old focus 0, got %p\n", old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_active = SetActiveWindow(wnd_event.hwnd);
    todo_wine
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmEmptySeq, "SetActiveWindow on another thread window", TRUE);
    ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
    ok(ret, "AttachThreadInput error %ld\n", GetLastError());
 
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    flush_events();
    flush_sequence();
 
    old_focus = SetFocus(wnd_event.hwnd);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok(old_focus == wnd_event.hwnd, "expected old focus %p, got %p\n", wnd_event.hwnd, old_focus);
    ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
    ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
 
    old_focus = SetFocus(parent);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    flush_events();
    flush_sequence();
 
    old_active = SetActiveWindow(wnd_event.hwnd);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok(old_active == parent, "expected old focus %p, got %p\n", parent, old_active);
    ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
    ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
 
    SetLastError(0xdeadbeef);
    ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
    ok(ret, "AttachThreadInput error %ld\n", GetLastError());
 
    ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
 
    old_parent = SetParent(child, GetDesktopWindow());
    ok(old_parent == parent, "expected old parent %p, got %p\n", parent, old_parent);
 
    ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
    ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
 
    old_focus = SetFocus(parent);
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    flush_events();
    flush_sequence();
 
    SetLastError(0xdeadbeef);
    old_focus = SetFocus(child);
    todo_wine
    ok(GetLastError() == ERROR_INVALID_PARAMETER /* Vista+ */ ||
       broken(GetLastError() == 0) /* XP */ ||
       broken(GetLastError() == 0xdeadbeef), "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
    ok_sequence(WmSetFocus_3, "SetFocus on a child window", TRUE);
    ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
    ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
    ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
 
    SetLastError(0xdeadbeef);
    old_active = SetActiveWindow(child);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n"

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ add_message

◆ ARCH

◆ check_lb_state

◆ check_selection

◆ check_update_rgn

◆ clear_clipboard

◆ DUMP

◆ EV_ACK

◆ EV_SENDMSG

◆ EV_STOP

◆ expect

◆ expect_HWND

◆ GET_PROC

◆ ID_BUTTON

◆ ID_COMBOBOX

◆ ID_EDIT

◆ ID_LISTBOX

◆ ID_RADIO1

◆ ID_RADIO2

◆ ID_RADIO3

◆ ID_TEXT

◆ MDI_FIRST_CHILD_ID

◆ ok_sequence

◆ open_clipboard

◆ run_in_temp_desktop

◆ set_selection

◆ STEP

◆ subtest_swp_paint_regions

◆ SW_NORMALNA

◆ SWP_NOCLIENTMOVE

◆ SWP_NOCLIENTSIZE

◆ SWP_STATECHANGED

◆ TEST_MOUSEACTIVATE

◆ test_msg_setpos

◆ test_radio

◆ TIMER_COUNT

◆ TIMER_DURATION_ALT

◆ TIMER_DURATION_EXPECTED

◆ TIMER_DURATION_TOLERANCE

◆ TIMER_ID

◆ track_hover

◆ track_hover_cancel

◆ track_query

◆ WM_KEYF1

◆ WM_LBTRACKPOINT

◆ WM_SYSTIMER

◆ WND_CHILD_ID

◆ WND_PARENT_ID

◆ WND_POPUP_ID

◆ WS_BASE

Enumeration Type Documentation

◆ msg_flags_t

Function Documentation

◆ add_message_()

◆ apc_test_proc()

◆ BOOL()

◆ broadcast_test_proc()

◆ broadcast_test_sub_proc()

◆ button_hook_proc()

◆ call_window_proc_hook()

◆ callback_count()

◆ callback_exception()

◆ can_skip_message()

◆ cancel_init_proc()

◆ cancel_popup_proc()

◆ cbt_global_hook_proc()

◆ cbt_global_hook_thread_proc()

◆ cbt_hook_proc()

◆ changed_window_proc()

◆ check_lb_state_dbg()

◆ check_update_rgn_()

◆ clear_clipboard_()

◆ combobox_edit_subclass_proc()

◆ combobox_hook_proc()