| /* |
| * Unit tests for window message handling |
| * |
| * Copyright 1999 Ove Kaaven |
| * Copyright 2003 Dimitrie O. Paun |
| * Copyright 2004 Dmitry Timoshkov |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <assert.h> |
| #include <stdarg.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| |
| #include "wine/test.h" |
| |
| |
| /* |
| FIXME: add tests for these |
| Window Edge Styles (Win31/Win95/98 look), in order of precedence: |
| WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed |
| WS_THICKFRAME: thick border |
| WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway) |
| WS_BORDER (default for overlapped windows): single black border |
| none (default for child (and popup?) windows): no border |
| */ |
| |
| typedef enum { |
| sent=0x1, posted=0x2, parent=0x4, wparam=0x8, lparam=0x10, |
| defwinproc=0x20, optional=0x40, hook=0x80 |
| } msg_flags_t; |
| |
| struct message { |
| UINT message; /* the WM_* code */ |
| msg_flags_t flags; /* message props */ |
| WPARAM wParam; /* expected value of wParam */ |
| LPARAM lParam; /* expected value of lParam */ |
| }; |
| |
| /* CreateWindow (for overlapped window, not initially visible) (16/32) */ |
| static const struct message WmCreateOverlappedSeq[] = { |
| { HCBT_CREATEWND, hook }, |
| { WM_GETMINMAXINFO, sent }, |
| { WM_NCCREATE, sent }, |
| { WM_NCCALCSIZE, sent|wparam, 0 }, |
| { WM_CREATE, sent }, |
| { 0 } |
| }; |
| /* ShowWindow (for overlapped window) (16/32) */ |
| static const struct message WmShowOverlappedSeq[] = { |
| { WM_SHOWWINDOW, sent|wparam, 1 }, |
| { WM_NCPAINT, sent|wparam|optional, 1 }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| /* FIXME: WM_QUERYNEWPALETTE, if in 256-color mode */ |
| { WM_NCPAINT, sent|wparam|optional, 1 }, |
| { WM_GETTEXT, sent|defwinproc|optional }, |
| { WM_ERASEBKGND, sent|optional }, |
| { HCBT_ACTIVATE, hook }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_ACTIVATEAPP, sent|wparam, 1 }, |
| { WM_NCACTIVATE, sent|wparam, 1 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ACTIVATE, sent|wparam, 1 }, |
| { HCBT_SETFOCUS, hook }, |
| { WM_IME_SETCONTEXT, sent|defwinproc|optional }, |
| { WM_SETFOCUS, sent|wparam|defwinproc, 0 }, |
| { WM_NCPAINT, sent|wparam|optional, 1 }, |
| { WM_GETTEXT, sent|defwinproc|optional }, |
| { WM_ERASEBKGND, sent|optional }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { WM_SIZE, sent }, |
| { WM_MOVE, sent }, |
| { 0 } |
| }; |
| /* DestroyWindow (for overlapped window) (32) */ |
| static const struct message WmDestroyOverlappedSeq[] = { |
| { HCBT_DESTROYWND, hook }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { WM_NCACTIVATE, sent|wparam, 0 }, |
| { WM_ACTIVATE, sent|wparam, 0 }, |
| { WM_ACTIVATEAPP, sent|wparam, 0 }, |
| { WM_KILLFOCUS, sent|wparam, 0 }, |
| { WM_IME_SETCONTEXT, sent|optional }, |
| { WM_DESTROY, sent }, |
| { WM_NCDESTROY, sent }, |
| { 0 } |
| }; |
| /* CreateWindow (for a child popup window, not initially visible) */ |
| static const struct message WmCreateChildPopupSeq[] = { |
| { HCBT_CREATEWND, hook }, |
| { WM_NCCREATE, sent }, |
| { WM_NCCALCSIZE, sent|wparam, 0 }, |
| { WM_CREATE, sent }, |
| { WM_SIZE, sent }, |
| { WM_MOVE, sent }, |
| { 0 } |
| }; |
| /* CreateWindow (for a popup window, not initially visible, |
| * which sets WS_VISIBLE in WM_CREATE handler) |
| */ |
| static const struct message WmCreateInvisiblePopupSeq[] = { |
| { HCBT_CREATEWND, hook }, |
| { WM_NCCREATE, sent }, |
| { WM_NCCALCSIZE, sent|wparam, 0 }, |
| { WM_CREATE, sent }, |
| { WM_STYLECHANGING, sent }, |
| { WM_STYLECHANGED, sent }, |
| { WM_SIZE, sent }, |
| { WM_MOVE, sent }, |
| { 0 } |
| }; |
| /* ShowWindow (for a popup window with WS_VISIBLE style set) */ |
| static const struct message WmShowVisiblePopupSeq[] = { |
| { 0 } |
| }; |
| /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER) |
| * for a popup window with WS_VISIBLE style set |
| */ |
| static const struct message WmShowVisiblePopupSeq_2[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { 0 } |
| }; |
| /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE) |
| * for a popup window with WS_VISIBLE style set |
| */ |
| static const struct message WmShowVisiblePopupSeq_3[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { HCBT_ACTIVATE, hook }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_NCACTIVATE, sent|wparam, 1 }, |
| { WM_ACTIVATE, sent|wparam, 1 }, |
| { HCBT_SETFOCUS, hook }, |
| { WM_IME_SETCONTEXT, sent|defwinproc|optional }, |
| { WM_SETFOCUS, sent|defwinproc }, |
| { 0 } |
| }; |
| /* CreateWindow (for child window, not initially visible) */ |
| static const struct message WmCreateChildSeq[] = { |
| { HCBT_CREATEWND, hook }, |
| { WM_NCCREATE, sent }, |
| /* child is inserted into parent's child list after WM_NCCREATE returns */ |
| { WM_NCCALCSIZE, sent|wparam, 0 }, |
| { WM_CREATE, sent }, |
| { WM_SIZE, sent }, |
| { WM_MOVE, sent }, |
| { WM_PARENTNOTIFY, sent|parent|wparam, 1 }, |
| { 0 } |
| }; |
| /* ShowWindow (for child window) */ |
| static const struct message WmShowChildSeq[] = { |
| { WM_SHOWWINDOW, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_ERASEBKGND, sent|parent|optional }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { 0 } |
| }; |
| /* DestroyWindow (for child window) */ |
| static const struct message WmDestroyChildSeq[] = { |
| { HCBT_DESTROYWND, hook }, |
| { WM_PARENTNOTIFY, sent|parent|wparam, 2 }, |
| { WM_SHOWWINDOW, sent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_ERASEBKGND, sent|parent|optional }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { HCBT_SETFOCUS, hook }, /* set focus to a parent */ |
| { WM_KILLFOCUS, sent }, |
| { WM_IME_SETCONTEXT, sent|optional }, |
| { WM_DESTROY, sent }, |
| { WM_DESTROY, sent|optional }, /* a bug in win2k sp4 ? */ |
| { WM_NCDESTROY, sent }, |
| { WM_NCDESTROY, sent|optional }, /* a bug in win2k sp4 ? */ |
| { 0 } |
| }; |
| /* Moving the mouse in nonclient area */ |
| static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */ |
| { WM_NCHITTEST, sent }, |
| { WM_SETCURSOR, sent }, |
| { WM_NCMOUSEMOVE, posted }, |
| { 0 } |
| }; |
| /* Moving the mouse in client area */ |
| static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */ |
| { WM_NCHITTEST, sent }, |
| { WM_SETCURSOR, sent }, |
| { WM_MOUSEMOVE, posted }, |
| { 0 } |
| }; |
| /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */ |
| static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */ |
| { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION }, |
| { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 }, |
| { WM_GETMINMAXINFO, sent|defwinproc }, |
| { WM_ENTERSIZEMOVE, sent|defwinproc }, |
| { WM_WINDOWPOSCHANGING, sent|defwinproc }, |
| { WM_WINDOWPOSCHANGED, sent|defwinproc }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_EXITSIZEMOVE, sent|defwinproc }, |
| { 0 } |
| }; |
| /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */ |
| static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */ |
| { WM_NCLBUTTONDOWN, sent|wparam, 0xd }, |
| { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 }, |
| { WM_GETMINMAXINFO, sent|defwinproc }, |
| { WM_ENTERSIZEMOVE, sent|defwinproc }, |
| { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */ |
| { WM_WINDOWPOSCHANGING, sent|defwinproc }, |
| { WM_GETMINMAXINFO, sent|defwinproc }, |
| { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 }, |
| { WM_NCPAINT, sent|defwinproc|wparam, 1 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent|defwinproc }, |
| { WM_WINDOWPOSCHANGED, sent|defwinproc }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_SIZE, sent|defwinproc }, |
| { WM_EXITSIZEMOVE, sent|defwinproc }, |
| { 0 } |
| }; |
| /* Resizing child window with MoveWindow (32) */ |
| static const struct message WmResizingChildWithMoveWindowSeq[] = { |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_NCCALCSIZE, sent|wparam, 1 }, |
| { WM_ERASEBKGND, sent|optional }, |
| { WM_WINDOWPOSCHANGED, sent }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_SIZE, sent|defwinproc }, |
| { 0 } |
| }; |
| /* Clicking on inactive button */ |
| static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */ |
| { WM_NCHITTEST, sent }, |
| { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN }, |
| { WM_MOUSEACTIVATE, sent }, |
| { WM_MOUSEACTIVATE, sent|parent|defwinproc }, |
| { WM_SETCURSOR, sent }, |
| { WM_SETCURSOR, sent|parent|defwinproc }, |
| { WM_LBUTTONDOWN, posted }, |
| { WM_KILLFOCUS, posted|parent }, |
| { WM_SETFOCUS, posted }, |
| { WM_CTLCOLORBTN, posted|parent }, |
| { BM_SETSTATE, posted }, |
| { WM_CTLCOLORBTN, posted|parent }, |
| { WM_LBUTTONUP, posted }, |
| { BM_SETSTATE, posted }, |
| { WM_CTLCOLORBTN, posted|parent }, |
| { WM_COMMAND, posted|parent }, |
| { 0 } |
| }; |
| /* Reparenting a button (16/32) */ |
| /* The last child (button) reparented gets topmost for its new parent. */ |
| static const struct message WmReparentButtonSeq[] = { /* FIXME: add */ |
| { WM_SHOWWINDOW, sent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER }, |
| { WM_ERASEBKGND, sent|parent }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER }, |
| { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOZORDER }, |
| { WM_CHILDACTIVATE, sent }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_SHOWWINDOW, sent|wparam, 1 }, |
| { 0 } |
| }; |
| /* Creation of a modal dialog (32) */ |
| static const struct message WmCreateModalDialogSeq[] = { /* FIXME: add */ |
| { WM_CANCELMODE, sent|parent }, |
| { WM_KILLFOCUS, sent|parent }, |
| { WM_ENABLE, sent|parent|wparam, 0 }, |
| /* (window proc creation messages not tracked yet, because...) */ |
| { WM_SETFONT, sent }, |
| { WM_INITDIALOG, sent }, |
| /* (...the window proc message hook was installed here, IsVisible still FALSE) */ |
| { WM_NCACTIVATE, sent|parent|wparam, 0 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ACTIVATE, sent|parent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_WINDOWPOSCHANGING, sent|parent }, |
| { WM_NCACTIVATE, sent|wparam, 1 }, |
| { WM_ACTIVATE, sent|wparam, 1 }, |
| /* (setting focus) */ |
| { WM_SHOWWINDOW, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_NCPAINT, sent }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent }, |
| { WM_CTLCOLORDLG, sent|defwinproc }, |
| { WM_WINDOWPOSCHANGED, sent }, |
| { WM_PAINT, sent }, |
| /* FIXME: (bunch of WM_CTLCOLOR* for each control) */ |
| { WM_PAINT, sent|parent }, |
| { WM_ENTERIDLE, sent|parent|wparam, 0}, |
| { WM_SETCURSOR, sent|parent }, |
| { 0 } |
| }; |
| /* Destruction of a modal dialog (32) */ |
| static const struct message WmDestroyModalDialogSeq[] = { /* FIXME: add */ |
| /* (inside dialog proc: EndDialog is called) */ |
| { WM_ENABLE, sent|parent|wparam, 1 }, |
| { WM_SETFOCUS, sent }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_NCPAINT, sent|parent }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent|parent }, |
| { WM_WINDOWPOSCHANGED, sent }, |
| { WM_NCACTIVATE, sent|wparam, 0 }, |
| { WM_ACTIVATE, sent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_WINDOWPOSCHANGING, sent|parent }, |
| { WM_NCACTIVATE, sent|parent|wparam, 1 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ACTIVATE, sent|parent|wparam, 1 }, |
| { WM_KILLFOCUS, sent }, |
| { WM_SETFOCUS, sent|parent }, |
| { WM_DESTROY, sent }, |
| { WM_NCDESTROY, sent }, |
| { 0 } |
| }; |
| /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */ |
| static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */ |
| /* (inside dialog proc, handling WM_INITDIALOG) */ |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_NCCALCSIZE, sent }, |
| { WM_NCACTIVATE, sent|parent|wparam, 0 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ACTIVATE, sent|parent|wparam, 0 }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_WINDOWPOSCHANGING, sent|parent }, |
| { WM_NCACTIVATE, sent|wparam, 1 }, |
| { WM_ACTIVATE, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGED, sent }, |
| { WM_SIZE, sent|defwinproc }, |
| /* (setting focus) */ |
| { WM_SHOWWINDOW, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGING, sent }, |
| { WM_NCPAINT, sent }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent }, |
| { WM_CTLCOLORDLG, sent|defwinproc }, |
| { WM_WINDOWPOSCHANGED, sent }, |
| { WM_PAINT, sent }, |
| /* (bunch of WM_CTLCOLOR* for each control) */ |
| { WM_PAINT, sent|parent }, |
| { WM_ENTERIDLE, sent|parent|wparam, 0 }, |
| { WM_SETCURSOR, sent|parent }, |
| { 0 } |
| }; |
| /* SetMenu for NonVisible windows with size change*/ |
| static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_NCCALCSIZE, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_SIZE, sent|defwinproc }, |
| { 0 } |
| }; |
| /* SetMenu for NonVisible windows with no size change */ |
| static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_NCCALCSIZE, sent|wparam, 1 }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { 0 } |
| }; |
| /* SetMenu for Visible windows with size change */ |
| static const struct message WmSetMenuVisibleSizeChangeSeq[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_NCCALCSIZE, sent|wparam, 1 }, |
| { WM_NCPAINT, sent|wparam, 1 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent|optional }, |
| { WM_ACTIVATE, sent|optional }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { WM_MOVE, sent|defwinproc }, |
| { WM_SIZE, sent|defwinproc }, |
| { 0 } |
| }; |
| /* SetMenu for Visible windows with no size change */ |
| static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = { |
| { WM_WINDOWPOSCHANGING, sent|wparam, 0 }, |
| { WM_NCCALCSIZE, sent|wparam, 1 }, |
| { WM_NCPAINT, sent|wparam, 1 }, |
| { WM_GETTEXT, sent|defwinproc }, |
| { WM_ERASEBKGND, sent|optional }, |
| { WM_ACTIVATE, sent|optional }, |
| { WM_WINDOWPOSCHANGED, sent|wparam, 0 }, |
| { 0 } |
| }; |
| |
| static const struct message WmSetRedrawFalseSeq[] = |
| { |
| { WM_SETREDRAW, sent|wparam, 0 }, |
| { 0 } |
| }; |
| |
| static const struct message WmSetRedrawTrueSeq[] = |
| { |
| { WM_SETREDRAW, sent|wparam, 1 }, |
| { 0 } |
| }; |
| |
| static int sequence_cnt, sequence_size; |
| static struct message* sequence; |
| |
| static void add_message(const struct message *msg) |
| { |
| if (!sequence) |
| { |
| sequence_size = 10; |
| sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) ); |
| } |
| if (sequence_cnt == sequence_size) |
| { |
| sequence_size *= 2; |
| sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) ); |
| } |
| assert(sequence); |
| |
| sequence[sequence_cnt].message = msg->message; |
| sequence[sequence_cnt].flags = msg->flags; |
| sequence[sequence_cnt].wParam = msg->wParam; |
| sequence[sequence_cnt].lParam = msg->lParam; |
| |
| sequence_cnt++; |
| } |
| |
| static void flush_sequence() |
| { |
| HeapFree(GetProcessHeap(), 0, sequence); |
| sequence = 0; |
| sequence_cnt = sequence_size = 0; |
| } |
| |
| static void ok_sequence(const struct message *expected, const char *context) |
| { |
| static const struct message end_of_sequence = { 0, 0, 0, 0 }; |
| const struct message *actual; |
| |
| add_message(&end_of_sequence); |
| |
| actual = sequence; |
| |
| while (expected->message && actual->message) |
| { |
| trace("expected %04x - actual %04x\n", expected->message, actual->message); |
| |
| if (expected->message == actual->message) |
| { |
| if (expected->flags & wparam) |
| ok (expected->wParam == actual->wParam, |
| "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n", |
| context, expected->message, expected->wParam, actual->wParam); |
| if (expected->flags & lparam) |
| ok (expected->lParam == actual->lParam, |
| "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n", |
| context, expected->message, expected->lParam, actual->lParam); |
| ok ((expected->flags & defwinproc) == (actual->flags & defwinproc), |
| "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n", |
| context, expected->message, (expected->flags & defwinproc) ? "" : "NOT "); |
| ok ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)), |
| "%s: the msg 0x%04x should have been %s\n", |
| context, expected->message, (expected->flags & posted) ? "posted" : "sent"); |
| ok ((expected->flags & parent) == (actual->flags & parent), |
| "%s: the msg 0x%04x was expected in %s\n", |
| context, expected->message, (expected->flags & parent) ? "parent" : "child"); |
| ok ((expected->flags & hook) == (actual->flags & hook), |
| "%s: the msg 0x%04x should have been sent by a hook\n", |
| context, expected->message); |
| expected++; |
| actual++; |
| } |
| else if (expected->flags & optional) |
| expected++; |
| else |
| { |
| todo_wine { |
| ok (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n", |
| context, expected->message, actual->message); |
| expected++; |
| actual++; |
| } |
| } |
| } |
| |
| todo_wine { |
| if (expected->message || actual->message) |
| ok (FALSE, "%s: the msg sequence is not complete\n", context); |
| } |
| |
| flush_sequence(); |
| } |
| |
| static void test_WM_SETREDRAW(HWND hwnd) |
| { |
| DWORD style = GetWindowLongA(hwnd, GWL_STYLE); |
| |
| flush_sequence(); |
| |
| SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0); |
| ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE"); |
| |
| ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n"); |
| ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n"); |
| |
| flush_sequence(); |
| SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0); |
| ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE"); |
| |
| ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n"); |
| ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE"); |
| |
| /* restore original WS_VISIBLE state */ |
| SetWindowLongA(hwnd, GWL_STYLE, style); |
| |
| flush_sequence(); |
| } |
| |
| /* test if we receive the right sequence of messages */ |
| static void test_messages(void) |
| { |
| HWND hwnd, hparent, hchild; |
| HWND hchild2, hbutton; |
| HMENU hmenu; |
| |
| 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"); |
| |
| /* test WM_SETREDRAW on a not visible top level window */ |
| test_WM_SETREDRAW(hwnd); |
| |
| ShowWindow(hwnd, SW_SHOW); |
| ok_sequence(WmShowOverlappedSeq, "ShowWindow:overlapped"); |
| |
| /* test WM_SETREDRAW on a visible top level window */ |
| test_WM_SETREDRAW(hwnd); |
| |
| DestroyWindow(hwnd); |
| ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped"); |
| |
| 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_CHILDWINDOW, |
| 0, 0, 10, 10, hparent, 0, 0, NULL); |
| ok (hchild != 0, "Failed to create child window\n"); |
| ok_sequence(WmCreateChildSeq, "CreateWindow:child"); |
| |
| hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILDWINDOW, |
| 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_CHILDWINDOW, |
| 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:child"); |
| |
| /* test WM_SETREDRAW on a visible child window */ |
| test_WM_SETREDRAW(hchild); |
| |
| SetFocus(hchild); |
| flush_sequence(); |
| |
| MoveWindow(hchild, 10, 10, 20, 20, TRUE); |
| ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child"); |
| |
| DestroyWindow(hchild); |
| ok_sequence(WmDestroyChildSeq, "DestroyWindow:child"); |
| 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"); |
| 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"); |
| 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(WmShowVisiblePopupSeq, "CreateWindow:show_visible_popup"); |
| flush_sequence(); |
| SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER); |
| ok_sequence(WmShowVisiblePopupSeq_2, "CreateWindow:show_visible_popup_2"); |
| flush_sequence(); |
| SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE); |
| ok_sequence(WmShowVisiblePopupSeq_3, "CreateWindow:show_visible_popup_3"); |
| 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"); |
| 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(WmShowVisiblePopupSeq, "CreateWindow:show_visible_popup"); |
| flush_sequence(); |
| SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER); |
| ok_sequence(WmShowVisiblePopupSeq_2, "CreateWindow:show_visible_popup_2"); |
| DestroyWindow(hchild); |
| |
| DestroyWindow(hparent); |
| flush_sequence(); |
| |
| /* Message sequence for SetMenu */ |
| 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"); |
| ok (SetMenu(hwnd, 0), "SetMenu"); |
| ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange"); |
| ok (SetMenu(hwnd, 0), "SetMenu"); |
| ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange"); |
| ShowWindow(hwnd, SW_SHOW); |
| flush_sequence(); |
| ok (SetMenu(hwnd, 0), "SetMenu"); |
| ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange"); |
| ok (SetMenu(hwnd, hmenu), "SetMenu"); |
| ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange"); |
| DestroyWindow(hwnd); |
| |
| } |
| |
| static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) |
| { |
| static long defwndproc_counter = 0; |
| LRESULT ret; |
| struct message msg; |
| |
| trace("%p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam); |
| |
| msg.message = message; |
| msg.flags = sent|wparam|lparam; |
| if (defwndproc_counter) msg.flags |= defwinproc; |
| msg.wParam = wParam; |
| msg.lParam = lParam; |
| add_message(&msg); |
| |
| defwndproc_counter++; |
| ret = DefWindowProcA(hwnd, message, wParam, lParam); |
| defwndproc_counter--; |
| |
| return ret; |
| } |
| |
| static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) |
| { |
| static long defwndproc_counter = 0; |
| LRESULT ret; |
| struct message msg; |
| |
| trace("popup: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam); |
| |
| msg.message = message; |
| msg.flags = sent|wparam|lparam; |
| if (defwndproc_counter) msg.flags |= defwinproc; |
| msg.wParam = wParam; |
| msg.lParam = lParam; |
| 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; |
| } |
| |
| static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) |
| { |
| static long defwndproc_counter = 0; |
| LRESULT ret; |
| struct message msg; |
| |
| trace("parent: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam); |
| |
| if (message == WM_PARENTNOTIFY) |
| { |
| msg.message = message; |
| msg.flags = sent|parent|wparam|lparam; |
| if (defwndproc_counter) msg.flags |= defwinproc; |
| msg.wParam = wParam; |
| msg.lParam = lParam; |
| add_message(&msg); |
| } |
| |
| defwndproc_counter++; |
| ret = DefWindowProcA(hwnd, message, wParam, lParam); |
| defwndproc_counter--; |
| |
| return ret; |
| } |
| |
| static BOOL RegisterWindowClasses(void) |
| { |
| WNDCLASSA cls; |
| |
| cls.style = 0; |
| cls.lpfnWndProc = MsgCheckProcA; |
| cls.cbClsExtra = 0; |
| cls.cbWndExtra = 0; |
| cls.hInstance = GetModuleHandleA(0); |
| cls.hIcon = 0; |
| cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW); |
| cls.hbrBackground = GetStockObject(WHITE_BRUSH); |
| cls.lpszMenuName = NULL; |
| cls.lpszClassName = "TestWindowClass"; |
| if(!RegisterClassA(&cls)) return FALSE; |
| |
| cls.lpfnWndProc = PopupMsgCheckProcA; |
| cls.lpszClassName = "TestPopupClass"; |
| if(!RegisterClassA(&cls)) return FALSE; |
| |
| cls.lpfnWndProc = ParentMsgCheckProcA; |
| cls.lpszClassName = "TestParentClass"; |
| if(!RegisterClassA(&cls)) return FALSE; |
| |
| cls.lpfnWndProc = DefWindowProcA; |
| cls.lpszClassName = "SimpleWindowClass"; |
| if(!RegisterClassA(&cls)) return FALSE; |
| |
| return TRUE; |
| } |
| |
| static HHOOK hCBT_hook; |
| |
| static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) |
| { |
| char buf[256]; |
| |
| trace("CBT: %d, %08x, %08lx\n", nCode, wParam, lParam); |
| |
| if (GetClassNameA((HWND)wParam, buf, sizeof(buf))) |
| { |
| if (!strcmp(buf, "TestWindowClass") || |
| !strcmp(buf, "TestParentClass") || |
| !strcmp(buf, "TestPopupClass") || |
| !strcmp(buf, "SimpleWindowClass")) |
| { |
| struct message msg; |
| |
| msg.message = nCode; |
| msg.flags = hook; |
| msg.wParam = wParam; |
| msg.lParam = lParam; |
| add_message(&msg); |
| } |
| } |
| return CallNextHookEx(hCBT_hook, nCode, wParam, lParam); |
| } |
| |
| START_TEST(msg) |
| { |
| if (!RegisterWindowClasses()) assert(0); |
| |
| hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId()); |
| assert(hCBT_hook); |
| |
| test_messages(); |
| |
| UnhookWindowsHookEx(hCBT_hook); |
| } |