reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-26 21:20:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
aae7632409
wine/dlls/user/tests/msg.c

6738 lines
274 KiB
C
Raw Normal View History

Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/*
* Unit tests for window message handling
*
* Copyright 1999 Ove Kaaven
* Copyright 2003 Dimitrie O. Paun
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
* Copyright 2004, 2005 Dmitry Timoshkov
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
*
* 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>
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
#include <stdio.h>
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Define _WIN32_WINNT otherwise we are missing some definitions with the Windows headers.
2004-08-11 18:50:40 +00:00
#define _WIN32_WINNT 0x0500 /* For WM_CHANGEUISTATE */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
#include "winnls.h"
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
#include "wine/test.h"
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
#define MDI_FIRST_CHILD_ID 2004
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
/* undocumented SWP flags - from SDK 3.1 */
#define SWP_NOCLIENTSIZE 0x0800
#define SWP_NOCLIENTMOVE 0x1000
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
#define WND_PARENT_ID 1
#define WND_POPUP_ID 2
#define WND_CHILD_ID 3
static BOOL test_DestroyWindow_flag;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
static HWINEVENTHOOK hEvent_hook;
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
static HWND (WINAPI *pGetAncestor)(HWND,UINT);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/*
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
*/
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
typedef enum {
sent=0x1,
posted=0x2,
parent=0x4,
wparam=0x8,
lparam=0x10,
defwinproc=0x20,
beginpaint=0x40,
optional=0x80,
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
hook=0x100,
winevent_hook=0x200
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
} msg_flags_t;
struct message {
UINT message; /* the WM_* code */
msg_flags_t flags; /* message props */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
WPARAM wParam; /* expected value of wParam */
LPARAM lParam; /* expected value of lParam */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
};
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
/* Empty message sequence */
static const struct message WmEmptySeq[] =
{
{ 0 }
};
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/* CreateWindow (for overlapped window, not initially visible) (16/32) */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmCreateOverlappedSeq[] = {
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_CREATEWND, hook },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_GETMINMAXINFO, sent },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
* for a not visible overlapped window.
*/
static const struct message WmSWP_ShowOverlappedSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
{ HCBT_ACTIVATE, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|defwinproc|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
/* Win9x adds SWP_NOZORDER below */
{ WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ 0 }
};
/* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
* for a visible overlapped window.
*/
static const struct message WmSWP_HideOverlappedSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ 0 }
};
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
/* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
* for a visible overlapped window.
*/
static const struct message WmSWP_ResizeSeq[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE },
{ WM_GETMINMAXINFO, sent|defwinproc },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
{ WM_NCCALCSIZE, sent|wparam|optional, TRUE },
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
{ 0 }
};
/* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
* for a visible popup window.
*/
static const struct message WmSWP_ResizePopupSeq[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
{ WM_NCCALCSIZE, sent|wparam|optional, TRUE },
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
{ 0 }
};
/* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
* for a visible overlapped window.
*/
static const struct message WmSWP_MoveSeq[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE },
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE },
{ WM_MOVE, sent|defwinproc|wparam, 0 },
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
{ 0 }
};
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
/* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
SWP_NOZORDER|SWP_FRAMECHANGED)
* for a visible overlapped window with WS_CLIPCHILDREN style set.
*/
static const struct message WmSWP_FrameChanged_clip[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
{ WM_NCCALCSIZE, sent|wparam|parent, 1 },
{ WM_NCPAINT, sent|parent }, /* wparam != 1 */
Fix a number of tests failing on windows.
2005-10-19 19:06:35 +00:00
{ WM_GETTEXT, sent|parent|defwinproc|optional },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
{ WM_NCPAINT, sent }, /* wparam != 1 */
{ WM_ERASEBKGND, sent },
{ WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_PAINT, sent },
{ 0 }
};
/* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
SWP_NOZORDER|SWP_FRAMECHANGED)
* for a visible overlapped window.
*/
static const struct message WmSWP_FrameChangedDeferErase[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
{ WM_NCCALCSIZE, sent|wparam|parent, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_PAINT, sent|parent },
{ WM_NCPAINT, sent|beginpaint|parent }, /* wparam != 1 */
Fix a number of tests failing on windows.
2005-10-19 19:06:35 +00:00
{ WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
/* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
SWP_NOZORDER|SWP_FRAMECHANGED)
* for a visible overlapped window without WS_CLIPCHILDREN style set.
*/
static const struct message WmSWP_FrameChanged_noclip[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
{ WM_NCCALCSIZE, sent|wparam|parent, 1 },
{ WM_NCPAINT, sent|parent }, /* wparam != 1 */
Fix a number of tests failing on windows.
2005-10-19 19:06:35 +00:00
{ WM_GETTEXT, sent|parent|defwinproc|optional },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
{ WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* ShowWindow(SW_SHOW) for a not visible overlapped window */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmShowOverlappedSeq[] = {
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_NCPAINT, sent|wparam|optional, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_ACTIVATE, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add WM_QUERYNEWPALETTE in appropriate places of the message test.
2004-04-12 23:13:14 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
A couple of changes to avoid some failures on XP.
2004-05-05 22:01:49 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ACTIVATE, sent|wparam, 1 },
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_SETFOCUS, hook },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|defwinproc|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
/* Win9x adds SWP_NOZORDER below */
{ WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
A couple of changes to avoid some failures on XP.
2004-05-05 22:01:49 +00:00
{ WM_NCCALCSIZE, sent|optional },
{ WM_NCPAINT, sent|optional },
{ WM_ERASEBKGND, sent|optional },
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
#if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
* messages. Does that mean that CreateWindow doesn't set initial
* window dimensions for overlapped windows?
*/
{ WM_SIZE, sent },
{ WM_MOVE, sent },
#endif
{ 0 }
};
Add a test for ShowWindow(SW_SHOWMAXIMIZED) called for a not visible overlapped window, which shows that WM_SHOWWINDOW is not sent in that case and that it should activate a window and bring it to top.
2005-09-12 10:09:40 +00:00
/* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
static const struct message WmShowMaxOverlappedSeq[] = {
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
{ WM_GETMINMAXINFO, sent|defwinproc },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
{ HCBT_ACTIVATE, hook },
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
{ WM_IME_NOTIFY, sent|defwinproc|optional },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
/* Win9x adds SWP_NOZORDER below */
{ WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
{ WM_NCCALCSIZE, sent|optional },
{ WM_NCPAINT, sent|optional },
{ WM_ERASEBKGND, sent|optional },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* ShowWindow(SW_HIDE) for a visible overlapped window */
static const struct message WmHideOverlappedSeq[] = {
{ WM_SHOWWINDOW, sent|wparam, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_SIZE, sent|optional }, /* XP doesn't send it */
{ WM_MOVE, sent|optional }, /* XP doesn't send it */
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
{ WM_NCACTIVATE, sent|wparam, 0 },
{ WM_ACTIVATE, sent|wparam, 0 },
{ WM_ACTIVATEAPP, sent|wparam, 0 },
{ WM_KILLFOCUS, sent|wparam, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|optional|defwinproc },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* DestroyWindow for a visible overlapped window */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmDestroyOverlappedSeq[] = {
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_DESTROYWND, hook },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCACTIVATE, sent|wparam, 0 },
{ WM_ACTIVATE, sent|wparam, 0 },
{ WM_ACTIVATEAPP, sent|wparam, 0 },
{ WM_KILLFOCUS, sent|wparam, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
CreateWindow should not activate invisible minimized or maximized windows. Add several tests to show the correct behavior.
2005-11-30 11:32:22 +00:00
/* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
static const struct message WmCreateMaxPopupSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000*/ },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOZORDER|0x8000*/ },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ HCBT_ACTIVATE, hook },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_SYNCPAINT, sent|wparam|optional, 4 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOSIZE },
{ 0 }
};
/* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
static const struct message WmCreateInvisibleMaxPopupSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000*/ },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOZORDER|0x8000*/ },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
{ 0 }
};
/* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
static const struct message WmShowMaxPopupResizedSeq[] = {
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ HCBT_ACTIVATE, hook },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOZORDER },
/* WinNT4.0 sends WM_MOVE */
{ WM_MOVE, sent|defwinproc|optional },
{ WM_SIZE, sent|defwinproc },
{ 0 }
};
/* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
static const struct message WmShowMaxPopupSeq[] = {
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ HCBT_ACTIVATE, hook },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_SYNCPAINT, sent|wparam|optional, 4 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
{ 0 }
};
/* CreateWindow(WS_VISIBLE) for popup window */
static const struct message WmCreatePopupSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ HCBT_ACTIVATE, hook },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_SYNCPAINT, sent|wparam|optional, 4 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOSIZE },
{ 0 }
};
/* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
static const struct message WmShowVisMaxPopupSeq[] = {
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_GETTEXT, sent|optional },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, TRUE },
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOZORDER|0x8000 },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
{ 0 }
};
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
/* 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 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
{ 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 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ 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 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add WM_QUERYNEWPALETTE in appropriate places of the message test.
2004-04-12 23:13:14 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, 0 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_KILLFOCUS, sent|parent },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|defwinproc|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ 0 }
};
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/* CreateWindow (for child window, not initially visible) */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmCreateChildSeq[] = {
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_CREATEWND, hook },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCCREATE, sent },
/* child is inserted into parent's child list after WM_NCCREATE returns */
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
Replace wParam values for WM_PARENTNOTIFY message by appropriate symbolic names.
2004-04-30 04:15:13 +00:00
{ WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 0 }
};
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
/* CreateWindow (for maximized child window, not initially visible) */
static const struct message WmCreateMaximizedChildSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Replace wParam values for WM_PARENTNOTIFY message by appropriate symbolic names.
2004-04-30 04:15:13 +00:00
{ WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
{ 0 }
};
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
/* CreateWindow (for a child window, initially visible) */
static const struct message WmCreateVisibleChildSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
/* child is inserted into parent's child list after WM_NCCREATE returns */
{ WM_NCCALCSIZE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* ShowWindow(SW_SHOW) for a not visible child window */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmShowChildSeq[] = {
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ 0 }
};
/* ShowWindow(SW_HIDE) for a visible child window */
static const struct message WmHideChildSeq[] = {
{ WM_SHOWWINDOW, sent|wparam, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 0 }
};
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
/* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
* for a not visible child window
*/
static const struct message WmShowChildSeq_2[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ WM_CHILDACTIVATE, sent },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ 0 }
};
/* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
* for a not visible child window
*/
static const struct message WmShowChildSeq_3[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
{ 0 }
};
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
/* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
* for a visible child window with a caption
*/
static const struct message WmShowChildSeq_4[] = {
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ WM_CHILDACTIVATE, sent },
{ 0 }
};
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
/* ShowWindow(SW_SHOW) for child with invisible parent */
static const struct message WmShowChildInvisibleParentSeq[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ 0 }
};
/* ShowWindow(SW_HIDE) for child with invisible parent */
static const struct message WmHideChildInvisibleParentSeq[] = {
{ WM_SHOWWINDOW, sent|wparam, 0 },
{ 0 }
};
/* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
static const struct message WmShowChildInvisibleParentSeq_2[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ 0 }
};
/* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
static const struct message WmHideChildInvisibleParentSeq_2[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ 0 }
};
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* DestroyWindow for a visible child window */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmDestroyChildSeq[] = {
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{ HCBT_DESTROYWND, hook },
Replace wParam values for WM_PARENTNOTIFY message by appropriate symbolic names.
2004-04-30 04:15:13 +00:00
{ WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SHOWWINDOW, sent|wparam, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Make DestroyWindow() not mess with a window focus, this should be taken care of by ShowWindow(SW_HIDE). Add a test for DestroyWindow() on a focused child.
2004-03-26 01:06:15 +00:00
{ HCBT_SETFOCUS, hook }, /* set focus to a parent */
{ WM_KILLFOCUS, sent },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_SETFOCUS, sent|parent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_DESTROY, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_DESTROY, sent|optional }, /* some other (IME?) window */
{ WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCDESTROY, sent },
{ 0 }
};
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
/* DestroyWindow for a visible child window with invisible parent */
static const struct message WmDestroyInvisibleChildSeq[] = {
{ HCBT_DESTROYWND, hook },
{ WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
{ WM_SHOWWINDOW, sent|wparam, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/* Moving the mouse in nonclient area */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCHITTEST, sent },
{ WM_SETCURSOR, sent },
{ WM_NCMOUSEMOVE, posted },
{ 0 }
};
/* Moving the mouse in client area */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCHITTEST, sent },
{ WM_SETCURSOR, sent },
{ WM_MOUSEMOVE, posted },
{ 0 }
};
/* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
{ WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
{ WM_GETMINMAXINFO, sent|defwinproc },
{ WM_ENTERSIZEMOVE, sent|defwinproc },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_MOVE, sent|defwinproc },
{ WM_EXITSIZEMOVE, sent|defwinproc },
{ 0 }
};
/* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
Make DestroyWindow() not mess with a window focus, this should be taken care of by ShowWindow(SW_HIDE). Add a test for DestroyWindow() on a focused child.
2004-03-26 01:06:15 +00:00
static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 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 */
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_GETMINMAXINFO, sent|defwinproc },
{ WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
{ WM_NCPAINT, sent|defwinproc|wparam, 1 },
{ WM_GETTEXT, sent|defwinproc },
{ WM_ERASEBKGND, sent|defwinproc },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
{ WM_EXITSIZEMOVE, sent|defwinproc },
{ 0 }
};
/* Resizing child window with MoveWindow (32) */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmResizingChildWithMoveWindowSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_ERASEBKGND, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 0 }
};
/* Clicking on inactive button */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 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. */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SHOWWINDOW, sent|wparam, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 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 }
};
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
/* Creation of a custom dialog (32) */
static const struct message WmCreateCustomDialogSeq[] = {
{ HCBT_CREATEWND, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_GETMINMAXINFO, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_NCCREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_NCCALCSIZE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
{ HCBT_ACTIVATE, hook },
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Fix WmCreateCustomDialogSeq message sequence for 256 color mode.
2005-01-11 15:45:32 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Fix WmCreateCustomDialogSeq message sequence for 256 color mode.
2005-01-11 15:45:32 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_NCACTIVATE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_ACTIVATE, sent|wparam, 1 },
{ WM_KILLFOCUS, sent|parent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_SETFOCUS, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_NCPAINT, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_ERASEBKGND, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_CTLCOLORDLG, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_NCCALCSIZE, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_NCPAINT, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional|defwinproc },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_ERASEBKGND, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_CTLCOLORDLG, sent|optional|defwinproc },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_SIZE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
{ WM_MOVE, sent },
{ 0 }
};
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
/* Calling EndDialog for a custom dialog (32) */
static const struct message WmEndCustomDialogSeq[] = {
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
{ HCBT_ACTIVATE, hook },
{ WM_NCACTIVATE, sent|wparam, 0 },
{ WM_GETTEXT, sent|optional|defwinproc },
{ WM_GETTEXT, sent|optional|defwinproc },
{ WM_ACTIVATE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_IME_NOTIFY, sent|optional },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_SETFOCUS, sent|parent|defwinproc },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ 0 }
};
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
static const struct message WmShowCustomDialogSeq[] = {
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
{ HCBT_ACTIVATE, hook },
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_ACTIVATEAPP, sent|wparam|optional, 1 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_ACTIVATE, sent|wparam, 1 },
{ WM_KILLFOCUS, sent|parent },
{ WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ WM_IME_NOTIFY, sent|optional|defwinproc },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_NCPAINT, sent|wparam, 1 },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_ERASEBKGND, sent },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_CTLCOLORDLG, sent|defwinproc },
{ EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ 0 }
};
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
/* Creation and destruction of a modal dialog (32) */
static const struct message WmModalDialogSeq[] = {
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_CANCELMODE, sent|parent },
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
{ HCBT_SETFOCUS, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_KILLFOCUS, sent|parent },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ENABLE, sent|parent|wparam, 0 },
Add dialog class name to the list of classes handled by hook, add hook messages to the modal dialog message test.
2004-06-01 19:39:26 +00:00
{ HCBT_CREATEWND, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SETFONT, sent },
{ WM_INITDIALOG, sent },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_CHANGEUISTATE, sent|optional },
{ WM_SHOWWINDOW, sent },
Add dialog class name to the list of classes handled by hook, add hook messages to the modal dialog message test.
2004-06-01 19:39:26 +00:00
{ HCBT_ACTIVATE, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCACTIVATE, sent|wparam, 1 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ACTIVATE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCPAINT, sent },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ERASEBKGND, sent },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_CTLCOLORDLG, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_NCCALCSIZE, sent|optional },
{ WM_NCPAINT, sent|optional },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_ERASEBKGND, sent|optional },
{ WM_CTLCOLORDLG, sent|optional },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_PAINT, sent|optional },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_CTLCOLORBTN, sent },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_ENTERIDLE, sent|parent|optional },
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
{ WM_ENTERIDLE, sent|parent|optional },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_TIMER, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ENABLE, sent|parent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
{ HCBT_ACTIVATE, hook },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCACTIVATE, sent|wparam, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_ACTIVATE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_WINDOWPOSCHANGING, sent|optional },
{ HCBT_SETFOCUS, hook },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
{ WM_SETFOCUS, sent|parent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
Add dialog class name to the list of classes handled by hook, add hook messages to the modal dialog message test.
2004-06-01 19:39:26 +00:00
{ HCBT_DESTROYWND, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
/* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/* (inside dialog proc, handling WM_INITDIALOG) */
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCCALCSIZE, sent },
{ WM_NCACTIVATE, sent|parent|wparam, 0 },
{ WM_GETTEXT, sent|defwinproc },
{ WM_ACTIVATE, sent|parent|wparam, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_WINDOWPOSCHANGING, sent|parent },
{ WM_NCACTIVATE, sent|wparam, 1 },
{ WM_ACTIVATE, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_SIZE, sent|defwinproc },
/* (setting focus) */
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ WM_NCPAINT, sent },
{ WM_GETTEXT, sent|defwinproc },
{ WM_ERASEBKGND, sent },
{ WM_CTLCOLORDLG, sent|defwinproc },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, 0 },
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{ 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 should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
/* SetMenu for NonVisible windows with size change*/
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW },
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|optional },
{ WM_NCCALCSIZE, sent|wparam|optional, 1 },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ 0 }
};
/* SetMenu for NonVisible windows with no size change */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ 0 }
};
/* SetMenu for Visible windows with size change */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_NCPAINT, sent }, /* wparam != 1 */
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_ERASEBKGND, sent|optional },
{ WM_ACTIVATE, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_NCPAINT, sent|optional }, /* wparam != 1 */
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_ERASEBKGND, sent|optional },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ 0 }
};
/* SetMenu for Visible windows with no size change */
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_NCPAINT, sent }, /* wparam != 1 */
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{ WM_ERASEBKGND, sent|optional },
{ WM_ACTIVATE, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
{ 0 }
};
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
/* DrawMenuBar for a visible window */
static const struct message WmDrawMenuBarSeq[] =
{
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
{ WM_NCPAINT, sent }, /* wparam != 1 */
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
{ 0 }
};
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
static const struct message WmSetRedrawFalseSeq[] =
{
{ WM_SETREDRAW, sent|wparam, 0 },
{ 0 }
};
static const struct message WmSetRedrawTrueSeq[] =
{
{ WM_SETREDRAW, sent|wparam, 1 },
{ 0 }
};
Add a test for window state when a window receives WM_ENABLE message.
2005-06-07 20:29:09 +00:00
static const struct message WmEnableWindowSeq_1[] =
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
{
Add a test for window state when a window receives WM_ENABLE message.
2005-06-07 20:29:09 +00:00
{ WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
Add a test for window state when a window receives WM_ENABLE message.
2005-06-07 20:29:09 +00:00
{ WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
{ 0 }
};
static const struct message WmEnableWindowSeq_2[] =
{
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
{ WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
{ 0 }
};
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
static const struct message WmGetScrollRangeSeq[] =
{
{ SBM_GETRANGE, sent },
{ 0 }
};
static const struct message WmGetScrollInfoSeq[] =
{
{ SBM_GETSCROLLINFO, sent },
{ 0 }
};
static const struct message WmSetScrollRangeSeq[] =
{
/* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
sends SBM_SETSCROLLINFO.
*/
{ SBM_SETSCROLLINFO, sent },
{ 0 }
};
/* SetScrollRange for a window without a non-client area */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
static const struct message WmSetScrollRangeHSeq_empty[] =
{
{ EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
{ 0 }
};
static const struct message WmSetScrollRangeVSeq_empty[] =
{
{ EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
{ 0 }
};
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
static const struct message WmSetScrollRangeHVSeq[] =
{
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ 0 }
};
/* SetScrollRange for a window with a non-client area */
static const struct message WmSetScrollRangeHV_NC_Seq[] =
{
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER*/ },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ WM_NCPAINT, sent|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ WM_ERASEBKGND, sent|optional },
{ WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|0x1000*/ },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
{ WM_GETTEXT, sent|optional },
{ WM_GETTEXT, sent|optional },
{ WM_GETTEXT, sent|optional },
{ WM_GETTEXT, sent|optional },
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
{ 0 }
};
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
/* test if we receive the right sequence of messages */
/* after calling ShowWindow( SW_SHOWNA) */
static const struct message WmSHOWNAChildInvisParInvis[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ 0 }
};
static const struct message WmSHOWNAChildVisParInvis[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ 0 }
};
static const struct message WmSHOWNAChildVisParVis[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
{ 0 }
};
static const struct message WmSHOWNAChildInvisParVis[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER},
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
{ WM_ERASEBKGND, sent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ 0 }
};
static const struct message WmSHOWNATopVisible[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
{ 0 }
};
static const struct message WmSHOWNATopInvisible[] = {
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
{ WM_NCPAINT, sent|wparam, 1 },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent|optional },
Fix one test failing on all windows versions.
2005-10-17 09:23:11 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 },
{ WM_NCPAINT, sent|wparam|optional, 1 },
{ WM_ERASEBKGND, sent|optional },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ 0 }
};
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
static int after_end_dialog;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
static int sequence_cnt, sequence_size;
static struct message* sequence;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
static int log_all_parent_messages;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static void add_message(const struct message *msg)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
if (!sequence)
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{
sequence_size = 10;
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
if (sequence_cnt == sequence_size)
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
{
sequence_size *= 2;
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
assert(sequence);
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
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++;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
}
Fix some more -Wstrict-prototypes warnings.
2005-06-21 20:53:13 +00:00
static void flush_sequence(void)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
HeapFree(GetProcessHeap(), 0, sequence);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
sequence = 0;
sequence_cnt = sequence_size = 0;
}
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
#define ok_sequence( exp, contx, todo) \
ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
static void ok_sequence_(const struct message *expected, const char *context, int todo,
const char *file, int line)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
static const struct message end_of_sequence = { 0, 0, 0, 0 };
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
const struct message *actual;
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
int failcount = 0;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
add_message(&end_of_sequence);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
actual = sequence;
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
while (expected->message && actual->message)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
if (expected->message == actual->message)
{
if (expected->flags & wparam)
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{
if (expected->wParam != actual->wParam && todo)
{
todo_wine {
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
failcount ++;
ok_( file, line) (FALSE,
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
"%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
context, expected->message, expected->wParam, actual->wParam);
}
}
else
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) (expected->wParam == actual->wParam,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
"%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
context, expected->message, expected->wParam, actual->wParam);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
if (expected->flags & lparam)
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) (expected->lParam == actual->lParam,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
"%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
context, expected->message, expected->lParam, actual->lParam);
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
"%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
"%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
"%s: the msg 0x%04x should have been %s\n",
context, expected->message, (expected->flags & posted) ? "posted" : "sent");
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
"%s: the msg 0x%04x was expected in %s\n",
context, expected->message, (expected->flags & parent) ? "parent" : "child");
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
Workaround a msvcrt.realloc bug under Win9x by using Win32 APIs instead. Take into account that HeapRealloc may move the allocated memory block.
2004-03-27 20:41:43 +00:00
"%s: the msg 0x%04x should have been sent by a hook\n",
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
context, expected->message);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
"%s: the msg 0x%04x should have been sent by a winevent hook\n",
context, expected->message);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
expected++;
actual++;
}
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/* silently drop winevent messages if there is no support for them */
else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
expected++;
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
else if (todo)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
failcount++;
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
todo_wine {
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
context, expected->message, actual->message);
}
Stop testing a sequence upon the first expected error, to avoid spurious errors later on.
2004-09-14 00:46:03 +00:00
flush_sequence();
return;
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
}
else
{
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
context, expected->message, actual->message);
expected++;
actual++;
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
}
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
/* skip all optional trailing messages */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
while (expected->message && ((expected->flags & optional) ||
((expected->flags & winevent_hook) && !hEvent_hook)))
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
expected++;
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
if (todo)
{
todo_wine {
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
if (expected->message || actual->message) {
failcount++;
ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
context, expected->message, actual->message);
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
}
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
}
}
else
{
if (expected->message || actual->message)
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
context, expected->message, actual->message);
}
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
if( todo && !failcount) /* succeeded yet marked todo */
todo_wine {
ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
}
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
flush_sequence();
}
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
/******************************** MDI test **********************************/
/* CreateWindow for MDI frame window, initially visible */
static const struct message WmCreateMDIframeSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_GETMINMAXINFO, sent },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ HCBT_ACTIVATE, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
{ WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* Win9x */
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_ACTIVATEAPP, sent|wparam, 1 },
{ WM_NCACTIVATE, sent|wparam, 1 },
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_ACTIVATE, sent|wparam, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
/* Win9x adds SWP_NOZORDER below */
{ WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ 0 }
};
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
/* DestroyWindow for MDI frame window, initially visible */
static const struct message WmDestroyMDIframeSeq[] = {
{ HCBT_DESTROYWND, hook },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_NCACTIVATE, sent|wparam, 0 },
{ WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
{ WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
/* CreateWindow for MDI client window, initially visible */
static const struct message WmCreateMDIclientSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_NCCALCSIZE, sent|wparam, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ 0 }
};
/* DestroyWindow for MDI client window, initially visible */
static const struct message WmDestroyMDIclientSeq[] = {
{ HCBT_DESTROYWND, hook },
{ WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
{ WM_SHOWWINDOW, sent|wparam, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ 0 }
};
/* CreateWindow for MDI child window, initially visible */
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
static const struct message WmCreateMDIchildVisibleSeq[] = {
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
/* Win2k sends wparam set to
* MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SHOWWINDOW, sent|wparam, 1 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
/* Win9x: message sequence terminates here. */
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook }, /* in MDI client */
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
{ 0 }
};
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
/* DestroyWindow for MDI child window, initially visible */
static const struct message WmDestroyMDIchildVisibleSeq[] = {
{ HCBT_DESTROYWND, hook },
/* Win2k sends wparam set to
* MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 0 },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
/* { WM_DESTROY, sent }
* Win9x: message sequence terminates here.
*/
{ HCBT_SETFOCUS, hook }, /* set focus to MDI client */
{ WM_KILLFOCUS, sent },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ HCBT_SETFOCUS, hook }, /* set focus to MDI client */
{ WM_KILLFOCUS, sent },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ WM_DESTROY, sent },
{ HCBT_SETFOCUS, hook }, /* set focus to MDI client */
{ WM_KILLFOCUS, sent },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ WM_NCDESTROY, sent },
{ 0 }
};
/* CreateWindow for MDI child window, initially invisible */
static const struct message WmCreateMDIchildInvisibleSeq[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
/* Win2k sends wparam set to
* MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
{ 0 }
};
/* DestroyWindow for MDI child window, initially invisible */
static const struct message WmDestroyMDIchildInvisibleSeq[] = {
{ HCBT_DESTROYWND, hook },
/* Win2k sends wparam set to
* MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* CreateWindow for the 1st MDI child window, initially visible and maximized */
static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* Win2k sends wparam set to
* MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
/* Win9x: message sequence terminates here. */
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ 0 }
};
/* CreateWindow for the 2nd MDI child window, initially visible and maximized */
static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
/* restore the 1st MDI child */
{ WM_SETREDRAW, sent|wparam, 0 },
{ HCBT_MINMAX, hook },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
/* create the 2nd MDI child */
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* Win2k sends wparam set to
* MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
{ WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
/* Win9x: message sequence terminates here. */
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ 0 }
};
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* WM_MDICREATE MDI child window, initially visible and maximized */
static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
{ WM_MDICREATE, sent },
{ HCBT_CREATEWND, hook },
{ WM_NCCREATE, sent },
{ WM_NCCALCSIZE, sent|wparam, 0 },
{ WM_CREATE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SIZE, sent },
{ WM_MOVE, sent },
{ HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* Win2k sends wparam set to
* MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
/* Win9x: message sequence terminates here. */
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
/* in MDI client */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ 0 }
};
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
{ WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
{ HCBT_SYSCOMMAND, hook },
{ WM_CLOSE, sent|defwinproc },
{ WM_MDIDESTROY, sent }, /* in MDI client */
/* bring the 1st MDI child to top */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
{ WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
{ WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
/* maximize the 1st MDI child */
{ HCBT_MINMAX, hook },
{ WM_GETMINMAXINFO, sent|defwinproc },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
{ WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* restore the 2nd MDI child */
{ WM_SETREDRAW, sent|defwinproc|wparam, 0 },
{ HCBT_MINMAX, hook },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOZORDER|0x8000 },
{ WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETREDRAW, sent|defwinproc|wparam, 1 },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* bring the 1st MDI child to top */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent|defwinproc },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
/* apparently ShowWindow(SW_SHOW) on an MDI client */
{ WM_SHOWWINDOW, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ WM_MDIREFRESHMENU, sent },
{ HCBT_DESTROYWND, hook },
/* Win2k sends wparam set to
* MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
{ WM_DESTROY, sent|defwinproc },
{ WM_NCDESTROY, sent|defwinproc },
{ 0 }
};
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
{ WM_MDIDESTROY, sent }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SETFOCUS, sent },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
/* in MDI client */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent|defwinproc },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
/* in MDI client */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_NCACTIVATE, sent|wparam, 0 },
{ WM_MDIACTIVATE, sent },
{ HCBT_MINMAX, hook },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI child */
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_MOVE, sent|defwinproc },
{ WM_SIZE, sent|defwinproc },
/* in MDI client */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
{ WM_SIZE, sent },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ WM_MDIREFRESHMENU, sent }, /* in MDI client */
{ HCBT_DESTROYWND, hook },
/* Win2k sends wparam set to
* MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
* while Win9x doesn't bother to set child window id according to
* CLIENTCREATESTRUCT.idFirstChild
*/
{ WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
{ WM_SHOWWINDOW, sent|wparam, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_ERASEBKGND, sent|parent|optional },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
{ WM_DESTROY, sent },
{ WM_NCDESTROY, sent },
{ 0 }
};
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
/* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
{ HCBT_MINMAX, hook },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
{ WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ WM_SETFOCUS, sent }, /* in MDI client */
{ HCBT_SETFOCUS, hook },
{ WM_KILLFOCUS, sent }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ WM_SETFOCUS, sent|defwinproc },
{ WM_MDIACTIVATE, sent|defwinproc },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ 0 }
};
/* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
static const struct message WmMaximizeMDIchildVisibleSeq[] = {
{ HCBT_MINMAX, hook },
{ WM_GETMINMAXINFO, sent },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ 0 }
};
/* ShowWindow(SW_RESTORE) for a visible MDI child window */
static const struct message WmRestoreMDIchildVisibleSeq[] = {
{ HCBT_MINMAX, hook },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ 0 }
};
/* ShowWindow(SW_RESTORE) for a not visible MDI child window */
static const struct message WmRestoreMDIchildInisibleSeq[] = {
{ HCBT_MINMAX, hook },
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
{ WM_NCCALCSIZE, sent|wparam, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
{ WM_SIZE, sent|defwinproc },
/* in MDI frame */
{ WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
{ WM_NCCALCSIZE, sent|wparam, 1 },
{ WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
{ 0 }
};
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
static HWND mdi_client;
static WNDPROC old_mdi_client_proc;
static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
struct message msg;
/* do not log painting messages */
if (message != WM_PAINT &&
message != WM_ERASEBKGND &&
message != WM_NCPAINT &&
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
message != WM_NCHITTEST &&
- WM_MDISETMENU handler should update new frame menu only if an active and maximized MDI child is visible. - Add a test case for MDI child activation sequence.
2004-10-11 19:55:28 +00:00
message != WM_GETTEXT &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_MDIGETACTIVE &&
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
message != WM_GETICON &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_DEVICECHANGE)
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{
trace("mdi client: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
switch (message)
{
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
msg.message = message;
msg.flags = sent|wparam|lparam;
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
msg.wParam = wParam;
msg.lParam = lParam;
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
add_message(&msg);
}
return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
}
static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static long defwndproc_counter = 0;
LRESULT ret;
struct message msg;
/* do not log painting messages */
if (message != WM_PAINT &&
message != WM_ERASEBKGND &&
message != WM_NCPAINT &&
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
message != WM_NCHITTEST &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_GETTEXT &&
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
message != WM_GETICON &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_DEVICECHANGE)
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{
trace("mdi child: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
switch (message)
{
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
break;
}
- WM_MDISETMENU handler should update new frame menu only if an active and maximized MDI child is visible. - Add a test case for MDI child activation sequence.
2004-10-11 19:55:28 +00:00
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;
}
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
}
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
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 = DefMDIChildProcA(hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
}
static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static long defwndproc_counter = 0;
LRESULT ret;
struct message msg;
/* do not log painting messages */
if (message != WM_PAINT &&
message != WM_ERASEBKGND &&
message != WM_NCPAINT &&
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
message != WM_NCHITTEST &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_GETTEXT &&
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
message != WM_GETICON &&
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
message != WM_DEVICECHANGE)
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
{
trace("mdi frame: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
switch (message)
{
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
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 = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
defwndproc_counter--;
return ret;
}
static BOOL mdi_RegisterWindowClasses(void)
{
WNDCLASSA cls;
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, (LPSTR)IDC_ARROW);
cls.hbrBackground = GetStockObject(WHITE_BRUSH);
cls.lpszMenuName = NULL;
cls.lpszClassName = "MDI_frame_class";
if (!RegisterClassA(&cls)) return FALSE;
cls.lpfnWndProc = mdi_child_wnd_proc;
cls.lpszClassName = "MDI_child_class";
if (!RegisterClassA(&cls)) return FALSE;
if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
old_mdi_client_proc = cls.lpfnWndProc;
cls.hInstance = GetModuleHandleA(0);
cls.lpfnWndProc = mdi_client_hook_proc;
cls.lpszClassName = "MDI_client_class";
if (!RegisterClassA(&cls)) assert(0);
return TRUE;
}
static void test_mdi_messages(void)
{
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
MDICREATESTRUCTA mdi_cs;
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
CLIENTCREATESTRUCT client_cs;
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
HWND mdi_frame, mdi_child, mdi_child2, active_child;
BOOL zoomed;
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
HMENU hMenu = CreateMenu();
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
assert(mdi_RegisterWindowClasses());
flush_sequence();
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,
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
GetDesktopWindow(), hMenu,
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
GetModuleHandleA(0), NULL);
assert(mdi_frame);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", TRUE);
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
trace("creating MDI client window\n");
client_cs.hWindowMenu = 0;
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
mdi_client = CreateWindowExA(0, "MDI_client_class",
NULL,
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
0, 0, 0, 0,
mdi_frame, 0, GetModuleHandleA(0), &client_cs);
assert(mdi_client);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
SetFocus(0);
flush_sequence();
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
ShowWindow activates only a being maximized child window, add a couple of message tests for MDI child activation.
2004-12-06 16:38:19 +00:00
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);
assert(mdi_child);
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();
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
trace("creating visible MDI child window\n");
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
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);
assert(mdi_child);
If an MDI child becomes active restore previously maximized MDI child.
2005-03-22 16:45:31 +00:00
ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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();
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
DestroyWindow(mdi_child);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* 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);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
flush_sequence();
trace("creating invisible MDI child window\n");
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
WS_CHILD,
0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
mdi_client, 0, GetModuleHandleA(0), NULL);
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
assert(mdi_child2);
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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");
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* 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();
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ShowWindow(mdi_child2, SW_MAXIMIZE);
ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", TRUE);
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(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", TRUE);
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);
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
ShowWindow(mdi_child2, SW_SHOW);
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
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", TRUE);
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):MDI child", TRUE);
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
SetFocus(0);
flush_sequence();
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
ShowWindow(mdi_child2, SW_HIDE);
ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
DestroyWindow(mdi_child2);
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* test for maximized MDI children */
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);
assert(mdi_child);
ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child || /* win2k */
GetFocus() == 0, /* win9x */
"wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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();
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);
assert(mdi_child2);
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");
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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();
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
trace("destroying maximized visible MDI child window 2\n");
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
DestroyWindow(mdi_child2);
ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* 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();
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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);
assert(mdi_child2);
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");
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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");
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
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);
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
Add a bunch of new MDI tests.
2004-09-13 19:16:31 +00:00
/* 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();
/* end of test for maximized MDI children */
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
mdi_cs.szClass = "MDI_child_Class";
mdi_cs.szTitle = "MDI child";
mdi_cs.hOwner = GetModuleHandleA(0);
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
mdi_cs.x = 0;
mdi_cs.y = 0;
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
mdi_cs.cx = CW_USEDEFAULT;
mdi_cs.cy = CW_USEDEFAULT;
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
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");
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
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");
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
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();
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
If there no MDI child to activate set hwndActiveChild to 0 in WM_MDIDESTROY hander, add a test case.
2004-10-05 02:10:04 +00:00
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();
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
DestroyWindow(mdi_client);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
Add more MDI message tests.
2004-06-30 18:16:08 +00:00
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
DestroyWindow(mdi_frame);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
}
/************************* End of MDI test **********************************/
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
static void test_WM_SETREDRAW(HWND hwnd)
{
DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
flush_sequence();
SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
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);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
Add trailing '\n's to ok() calls.
2004-05-05 01:35:37 +00:00
ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
/* restore original WS_VISIBLE state */
SetWindowLongA(hwnd, GWL_STYLE, style);
flush_sequence();
}
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
struct message msg;
trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
switch (message)
{
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
msg.message = message;
msg.flags = sent|wparam|lparam;
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
if (message == WM_TIMER) EndDialog( hwnd, 0 );
return 0;
}
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
{
DWORD style, exstyle;
INT xmin, xmax;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
BOOL ret;
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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);
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
else
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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 */
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
xmin = 0xdeadbeef;
xmax = 0xdeadbeef;
trace("Ignore GetScrollRange error below if you are on Win9x\n");
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
ok( ret, "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
ok(xmin == min, "unexpected min scroll value %d\n", xmin);
ok(xmax == max, "unexpected max scroll value %d\n", xmax);
}
static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
{
DWORD style, exstyle;
SCROLLINFO si;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
BOOL ret;
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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))
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
else
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
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);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
si.fMask = SIF_PAGE;
si.nPage = 5;
SetScrollInfo(hwnd, ctl, &si, FALSE);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
si.fMask = SIF_POS;
si.nPos = max - 1;
SetScrollInfo(hwnd, ctl, &si, FALSE);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
si.fMask = SIF_RANGE;
si.nMin = 0xdeadbeef;
si.nMax = 0xdeadbeef;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = GetScrollInfo(hwnd, ctl, &si);
ok( ret, "GetScrollInfo error %ld\n", GetLastError());
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
}
/* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
static void test_scroll_messages(HWND hwnd)
{
SCROLLINFO si;
INT min, max;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
BOOL ret;
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
min = 0xdeadbeef;
max = 0xdeadbeef;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
ok( ret, "GetScrollRange error %ld\n", GetLastError());
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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();
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
ok( ret, "SetScrollRange error %ld\n", GetLastError());
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
if (sequence->message != WmSetScrollRangeSeq[0].message)
trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
flush_sequence();
min = 0xdeadbeef;
max = 0xdeadbeef;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
ok( ret, "GetScrollRange error %ld\n", GetLastError());
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = GetScrollInfo(hwnd, SB_CTL, &si);
ok( ret, "GetScrollInfo error %ld\n", GetLastError());
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
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);
}
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
static void test_showwindow(void)
{
HWND hwnd, hchild;
CreateWindow should not activate invisible minimized or maximized windows. Add several tests to show the correct behavior.
2005-11-30 11:32:22 +00:00
RECT rc;
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
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");
hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
0, 0, 10, 10, hwnd, 0, 0, NULL);
ok (hchild != 0, "Failed to create child\n");
flush_sequence();
/* ShowWindow( SW_SHOWNA) for invisible top level window */
trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
/* ShowWindow( SW_SHOWNA) for now visible top level window */
trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
/* back to invisible */
ShowWindow(hchild, SW_HIDE);
ShowWindow(hwnd, SW_HIDE);
flush_sequence();
/* ShowWindow(SW_SHOWNA) with child and parent invisible */
trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
/* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
flush_sequence();
trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
/* ShowWindow(SW_SHOWNA) with child visible and parent visible */
ShowWindow( hwnd, SW_SHOW);
flush_sequence();
trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
/* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
ShowWindow( hchild, SW_HIDE);
flush_sequence();
trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
trace("done\n");
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
SetCapture(hchild);
ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
DestroyWindow(hchild);
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
DestroyWindow(hwnd);
flush_sequence();
CreateWindow should not activate invisible minimized or maximized windows. Add several tests to show the correct behavior.
2005-11-30 11:32:22 +00:00
/* Popup windows */
/* Test 1:
* 1. Create invisible maximized popup window.
* 2. Move and resize it.
* 3. Show it maximized.
*/
trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hwnd != 0, "Failed to create popup window\n");
ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
trace("done\n");
GetWindowRect(hwnd, &rc);
ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
"Invalid maximized size before ShowWindow (%ld,%ld)-(%ld,%ld)\n",
rc.left, rc.top, rc.right, rc.bottom);
/* Reset window's size & position */
SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
flush_sequence();
trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible popup window\n");
ShowWindow(hwnd, SW_SHOWMAXIMIZED);
ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", TRUE);
trace("done\n");
GetWindowRect(hwnd, &rc);
todo_wine ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
"Invalid maximized size after ShowWindow (%ld,%ld)-(%ld,%ld)\n",
rc.left, rc.top, rc.right, rc.bottom);
DestroyWindow(hwnd);
flush_sequence();
/* Test 2:
* 1. Create invisible maximized popup window.
* 2. Show it maximized.
*/
trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hwnd != 0, "Failed to create popup window\n");
ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
trace("done\n");
trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible popup window\n");
ShowWindow(hwnd, SW_SHOWMAXIMIZED);
ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", TRUE);
trace("done\n");
DestroyWindow(hwnd);
flush_sequence();
/* Test 3:
* 1. Create visible maximized popup window.
*/
trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hwnd != 0, "Failed to create popup window\n");
ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", TRUE);
trace("done\n");
DestroyWindow(hwnd);
flush_sequence();
/* Test 4:
* 1. Create visible popup window.
* 2. Maximize it.
*/
trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hwnd != 0, "Failed to create popup window\n");
ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", TRUE);
trace("done\n");
trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
ShowWindow(hwnd, SW_SHOWMAXIMIZED);
ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", TRUE);
trace("done\n");
DestroyWindow(hwnd);
flush_sequence();
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
}
- Make GetSystemMenu respect CS_NOCLOSE. - EnableMenuItem should not generate WM_WINDOWPOSCHANGING message. - Make nonclient code check for presence of SC_CLOSE, not CS_NOCLOSE window class style. - Add a test case.
2005-03-30 18:59:27 +00:00
static void test_sys_menu(HWND hwnd)
{
HMENU hmenu;
UINT state;
/* test existing window without CS_NOCLOSE style */
hmenu = GetSystemMenu(hwnd, FALSE);
ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
EnableMenuItem(hmenu, SC_CLOSE, 0);
ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
/* test new window with CS_NOCLOSE style */
hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hwnd != 0, "Failed to create overlapped window\n");
hmenu = GetSystemMenu(hwnd, FALSE);
ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
DestroyWindow(hwnd);
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
/* test if we receive the right sequence of messages */
static void test_messages(void)
{
HWND hwnd, hparent, hchild;
HWND hchild2, hbutton;
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
HMENU hmenu;
Fixed handling of NULL pointer in PeekMessageW, with test (reported by Eric Frias).
2004-11-23 17:39:13 +00:00
MSG msg;
Add a MsgWaitForMultipleObjects test.
2005-07-07 17:20:44 +00:00
DWORD ret;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
flush_sequence();
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
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");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
Ignore attempts to hide an already invisible window. Add a test case for this behaviour, passes on Wine and Windows 2000.
2004-06-03 23:26:35 +00:00
/* test ShowWindow(SW_HIDE) on a newly created invisible window */
ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
Ignore attempts to hide an already invisible window. Add a test case for this behaviour, passes on Wine and Windows 2000.
2004-06-03 23:26:35 +00:00
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
/* test WM_SETREDRAW on a not visible top level window */
test_WM_SETREDRAW(hwnd);
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
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);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", TRUE);
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
ShowWindow(hwnd, SW_SHOW);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
Add a test for ShowWindow(SW_SHOWMAXIMIZED) called for a not visible overlapped window, which shows that WM_SHOWWINDOW is not sent in that case and that it should activate a window and bring it to top.
2005-09-12 10:09:40 +00:00
ShowWindow(hwnd, SW_HIDE);
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
Add a test for ShowWindow(SW_SHOWMAXIMIZED) called for a not visible overlapped window, which shows that WM_SHOWWINDOW is not sent in that case and that it should activate a window and bring it to top.
2005-09-12 10:09:40 +00:00
ShowWindow(hwnd, SW_SHOWMAXIMIZED);
ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
ShowWindow(hwnd, SW_RESTORE);
/* FIXME: add ok_sequence() here */
flush_sequence();
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
ShowWindow(hwnd, SW_SHOW);
ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
ok(GetActiveWindow() == hwnd, "window should be active\n");
ok(GetFocus() == hwnd, "window should have input focus\n");
SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
Deactivate active window in ShowWindow(,SW_HIDE).
2005-06-17 21:05:16 +00:00
ok(GetActiveWindow() == hwnd, "window should still be active\n");
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
/* test WM_SETREDRAW on a visible top level window */
Add more ShowWindow/SetWindowPos tests.
2004-05-10 19:59:20 +00:00
ShowWindow(hwnd, SW_SHOW);
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
test_WM_SETREDRAW(hwnd);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
trace("testing scroll APIs on a visible top level window %p\n", hwnd);
test_scroll_messages(hwnd);
Added a couple of SetWindowPos tests.
2005-01-25 11:31:52 +00:00
/* test resizing and moving */
SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE );
ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE );
ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
/* 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_NOZORDER|SWP_NOACTIVATE );
ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
- Make GetSystemMenu respect CS_NOCLOSE. - EnableMenuItem should not generate WM_WINDOWPOSCHANGING message. - Make nonclient code check for presence of SC_CLOSE, not CS_NOCLOSE window class style. - Add a test case.
2005-03-30 18:59:27 +00:00
test_sys_menu(hwnd);
flush_sequence();
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
DestroyWindow(hwnd);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
100, 100, 200, 200, 0, 0, 0, NULL);
ok (hparent != 0, "Failed to create parent window\n");
flush_sequence();
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
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");
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", TRUE);
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
DestroyWindow(hchild);
flush_sequence();
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
/* visible child window with a caption */
hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
WS_CHILD | WS_VISIBLE | WS_CAPTION,
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
0, 0, 10, 10, hparent, 0, 0, NULL);
ok (hchild != 0, "Failed to create child window\n");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
trace("testing scroll APIs on a visible child window %p\n", hchild);
test_scroll_messages(hchild);
Make message flow for MDI creation/activation/destruction more like in Windows. Add a bunch of MDI message tests.
2004-09-21 00:24:22 +00:00
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);
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
DestroyWindow(hchild);
flush_sequence();
hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
0, 0, 10, 10, hparent, 0, 0, NULL);
ok (hchild != 0, "Failed to create child window\n");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
100, 100, 50, 50, hparent, 0, 0, NULL);
ok (hchild2 != 0, "Failed to create child2 window\n");
flush_sequence();
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
0, 100, 50, 50, hchild, 0, 0, NULL);
ok (hbutton != 0, "Failed to create button window\n");
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
/* test WM_SETREDRAW on a not visible child window */
test_WM_SETREDRAW(hchild);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
ShowWindow(hchild, SW_SHOW);
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
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);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add WM_SETREDRAW test.
2004-04-08 19:07:06 +00:00
/* test WM_SETREDRAW on a visible child window */
test_WM_SETREDRAW(hchild);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
MoveWindow(hchild, 10, 10, 20, 20, TRUE);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
ShowWindow(hchild, SW_HIDE);
flush_sequence();
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
ShowWindow(hchild, SW_HIDE);
flush_sequence();
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
/* DestroyWindow sequence below expects that a child has focus */
SetFocus(hchild);
flush_sequence();
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
DestroyWindow(hchild);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
DestroyWindow(hchild2);
DestroyWindow(hbutton);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
flush_sequence();
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
flush_sequence();
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
flush_sequence();
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
DestroyWindow(hchild);
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
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");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/*
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
trace("testing scroll APIs on a visible dialog %p\n", hwnd);
test_scroll_messages(hwnd);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
*/
Add a test case for scroll APIs, fix a few bugs spotted by it.
2004-07-09 19:25:26 +00:00
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
flush_sequence();
after_end_dialog = 1;
EndDialog( hwnd, 0 );
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
DestroyWindow(hwnd);
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
after_end_dialog = 0;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
ok(hwnd != 0, "Failed to create custom dialog window\n");
flush_sequence();
trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
ShowWindow(hwnd, SW_SHOW);
ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
DestroyWindow(hwnd);
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
flush_sequence();
DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
/* test showing child with hidden parent */
ShowWindow( hparent, SW_HIDE );
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);
ShowWindow( hchild, SW_SHOW );
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
ok_sequence(WmShowChildInvisibleParentSeq, "ShowWindow:show child with invisible parent", FALSE);
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
ShowWindow( hchild, SW_HIDE );
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
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);
Tweak SetWindowPos flags handling to make a few more of the messaging tests pass.
2005-01-21 17:06:07 +00:00
ok_sequence(WmShowChildInvisibleParentSeq_2, "SetWindowPos:show child with invisible parent", FALSE);
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
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);
Tweak SetWindowPos flags handling to make a few more of the messaging tests pass.
2005-01-21 17:06:07 +00:00
ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
Fixed some message sequences to succeed on XP. Added some tests for showing/hiding a child window with an invisible parent.
2004-09-08 22:02:23 +00:00
ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
flush_sequence();
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
DestroyWindow(hchild);
Don't call SetWindowPos in ShowWindow if a parent window is not visible, only toggle the WS_VISIBLE flag.
2005-11-09 10:35:48 +00:00
ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
DestroyWindow(hparent);
flush_sequence();
/* Message sequence for SetMenu */
Properly handle the case when last MDI child is being destroyed.
2004-10-08 23:36:18 +00:00
ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
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);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
Add trailing '\n's to ok() calls.
2004-05-05 01:35:37 +00:00
ok (SetMenu(hwnd, 0), "SetMenu\n");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
Add trailing '\n's to ok() calls.
2004-05-05 01:35:37 +00:00
ok (SetMenu(hwnd, 0), "SetMenu\n");
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
ShowWindow(hwnd, SW_SHOW);
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
UpdateWindow( hwnd );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
flush_sequence();
Add trailing '\n's to ok() calls.
2004-05-05 01:35:37 +00:00
ok (SetMenu(hwnd, 0), "SetMenu\n");
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
Add trailing '\n's to ok() calls.
2004-05-05 01:35:37 +00:00
ok (SetMenu(hwnd, hmenu), "SetMenu\n");
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
SetMenu should always call SetWindowPos whether the window is visible or not. However we shouldn't call SWP from CreateWindowEx. Added a test for this behaviour.
2004-02-17 20:29:05 +00:00
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
UpdateWindow( hwnd );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
Add message test for DrawMenuBar.
2004-05-24 19:08:54 +00:00
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
DestroyWindow(hwnd);
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
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");
Add tests for child activation by ShowWindow/SetWindowPos.
2004-06-18 19:33:55 +00:00
hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
0, 0, 10, 10, hparent, 0, 0, NULL);
ok (hchild != 0, "Failed to create child window\n");
SetFocus(hchild);
flush_sequence();
EnableWindow(hparent, FALSE);
Add a test for window state when a window receives WM_ENABLE message.
2005-06-07 20:29:09 +00:00
ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
EnableWindow(hparent, TRUE);
ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
Fixed handling of NULL pointer in PeekMessageW, with test (reported by Eric Frias).
2004-11-23 17:39:13 +00:00
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Add a MsgWaitForMultipleObjects test.
2005-07-07 17:20:44 +00:00
/* MsgWaitForMultipleObjects test */
ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
PostMessageA(hparent, WM_USER, 0, 0);
ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
ok(PeekMessageW( &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);
/* end of MsgWaitForMultipleObjects test */
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/* the following test causes an exception in user.exe under win9x */
if (!PostMessageW( hparent, WM_USER, 0, 0 )) return;
PostMessageW( hparent, WM_USER+1, 0, 0 );
Fixed handling of NULL pointer in PeekMessageW, with test (reported by Eric Frias).
2004-11-23 17:39:13 +00:00
/* PeekMessage(NULL) fails, but still removes the message */
SetLastError(0xdeadbeef);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
GetLastError() == 0xdeadbeef, /* NT4 */
"last error is %ld\n", GetLastError() );
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
Fixed handling of NULL pointer in PeekMessageW, with test (reported by Eric Frias).
2004-11-23 17:39:13 +00:00
ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
DestroyWindow(hchild);
EnableWindow should not remove the focus of child windows.
2004-06-03 00:08:55 +00:00
DestroyWindow(hparent);
flush_sequence();
Make ShowWindow(...,SW_SHOWNA) also work on already visible windows with some conformance tests.
2005-01-25 11:21:20 +00:00
test_showwindow();
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
}
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
/****************** button message test *************************/
static const struct message WmSetFocusButtonSeq[] =
{
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
{ WM_SETFOCUS, sent|wparam, 0 },
{ WM_CTLCOLORBTN, sent|defwinproc },
{ 0 }
};
static const struct message WmKillFocusButtonSeq[] =
{
{ HCBT_SETFOCUS, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
{ WM_KILLFOCUS, sent|wparam, 0 },
{ WM_CTLCOLORBTN, sent|defwinproc },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ 0 }
};
static const struct message WmSetFocusStaticSeq[] =
{
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
{ WM_SETFOCUS, sent|wparam, 0 },
{ WM_CTLCOLORSTATIC, sent|defwinproc },
{ 0 }
};
static const struct message WmKillFocusStaticSeq[] =
{
{ HCBT_SETFOCUS, hook },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
{ WM_KILLFOCUS, sent|wparam, 0 },
{ WM_CTLCOLORSTATIC, sent|defwinproc },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ 0 }
};
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
static const struct message WmLButtonDownSeq[] =
{
{ WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_CTLCOLORBTN, sent|defwinproc },
{ BM_SETSTATE, sent|wparam|defwinproc, TRUE },
{ WM_CTLCOLORBTN, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
{ 0 }
};
static const struct message WmLButtonUpSeq[] =
{
{ WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
{ BM_SETSTATE, sent|wparam|defwinproc, FALSE },
{ WM_CTLCOLORBTN, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
{ WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
{ 0 }
};
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
static WNDPROC old_button_proc;
static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static long defwndproc_counter = 0;
LRESULT ret;
struct message msg;
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
trace("button: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
msg.message = message;
msg.flags = sent|wparam|lparam;
if (defwndproc_counter) msg.flags |= defwinproc;
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
if (message == BM_SETSTATE)
ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
defwndproc_counter++;
ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
}
static void subclass_button(void)
{
WNDCLASSA cls;
if (!GetClassInfoA(0, "button", &cls)) assert(0);
old_button_proc = cls.lpfnWndProc;
cls.hInstance = GetModuleHandle(0);
cls.lpfnWndProc = button_hook_proc;
cls.lpszClassName = "my_button_class";
if (!RegisterClassA(&cls)) assert(0);
}
static void test_button_messages(void)
{
static const struct
{
DWORD style;
Make button return exactly the same dialog codes as Windows does. Add a test case.
2004-10-26 21:18:10 +00:00
DWORD dlg_code;
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
const struct message *setfocus;
const struct message *killfocus;
} button[] = {
Make button return exactly the same dialog codes as Windows does. Add a test case.
2004-10-26 21:18:10 +00:00
{ BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
WmSetFocusButtonSeq, WmKillFocusButtonSeq },
{ BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
WmSetFocusButtonSeq, WmKillFocusButtonSeq },
{ BS_CHECKBOX, DLGC_BUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_AUTOCHECKBOX, DLGC_BUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_3STATE, DLGC_BUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_AUTO3STATE, DLGC_BUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_GROUPBOX, DLGC_STATIC,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
WmSetFocusButtonSeq, WmKillFocusButtonSeq },
{ BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
WmSetFocusStaticSeq, WmKillFocusStaticSeq },
{ BS_OWNERDRAW, DLGC_BUTTON,
WmSetFocusButtonSeq, WmKillFocusButtonSeq }
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
};
Fix signed/unsigned comparison warnings.
2004-09-22 02:46:38 +00:00
unsigned int i;
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
HWND hwnd;
Make button return exactly the same dialog codes as Windows does. Add a test case.
2004-10-26 21:18:10 +00:00
DWORD dlg_code;
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
subclass_button();
for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
{
hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
0, 0, 50, 14, 0, 0, 0, NULL);
ok(hwnd != 0, "Failed to create button window\n");
Make button return exactly the same dialog codes as Windows does. Add a test case.
2004-10-26 21:18:10 +00:00
dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
ok(dlg_code == button[i].dlg_code, "%d: wrong dlg_code %08lx\n", i, dlg_code);
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
ShowWindow(hwnd, SW_SHOW);
UpdateWindow(hwnd);
SetFocus(0);
flush_sequence();
trace("button style %08lx\n", button[i].style);
SetFocus(hwnd);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
SetFocus(0);
Allow enabling or disabling todo_wine for each message sequence so that we can properly test the sequences that are already correct.
2004-08-25 17:35:06 +00:00
ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
DestroyWindow(hwnd);
}
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
Make button return exactly the same dialog codes as Windows does. Add a test case.
2004-10-26 21:18:10 +00:00
hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
0, 0, 50, 14, 0, 0, 0, NULL);
ok(hwnd != 0, "Failed to create button window\n");
SetFocus(0);
flush_sequence();
SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
Button should send BM_SETSTATE message after it has changed its internal state.
2004-08-26 18:31:56 +00:00
DestroyWindow(hwnd);
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
}
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
/************* painting message test ********************/
ScrollDC and X11DRV_SCROLLDC should scroll only pixels coming from within the visible region, clipped to the clipping region if that exists. Add the destination of pixels coming from the outside of this region to the update region. With tests that depend on this.
2005-03-25 17:11:04 +00:00
void dump_region(HRGN hrgn)
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{
DWORD i, size;
RGNDATA *data = NULL;
RECT *rect;
if (!hrgn)
{
printf( "null region\n" );
return;
}
if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
GetRegionData( hrgn, size, data );
printf("%ld rects:", data->rdh.nCount );
for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
printf( " (%ld,%ld)-(%ld,%ld)", rect->left, rect->top, rect->right, rect->bottom );
printf("\n");
HeapFree( GetProcessHeap(), 0, data );
}
static void check_update_rgn( HWND hwnd, HRGN hrgn )
{
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( !hrgn, "Update region shouldn't be empty\n" );
}
else
{
if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
{
ok( 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( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
"Rectangles are different: %ld,%ld-%ld,%ld / %ld,%ld-%ld,%ld\n",
r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
DeleteObject( tmp );
DeleteObject( update );
}
static const struct message WmInvalidateRgn[] = {
{ WM_NCPAINT, sent },
Fix msg test failures when run under win2k.
2004-08-26 18:21:56 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{ 0 }
};
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
static const struct message WmGetUpdateRect[] = {
{ WM_NCPAINT, sent },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_PAINT, sent },
{ 0 }
};
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
static const struct message WmInvalidateFull[] = {
{ WM_NCPAINT, sent|wparam, 1 },
Fix msg test failures when run under win2k.
2004-08-26 18:21:56 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{ 0 }
};
static const struct message WmInvalidateErase[] = {
{ WM_NCPAINT, sent|wparam, 1 },
Fix msg test failures when run under win2k.
2004-08-26 18:21:56 +00:00
{ WM_GETTEXT, sent|defwinproc|optional },
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{ WM_ERASEBKGND, sent },
{ 0 }
};
static const struct message WmInvalidatePaint[] = {
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|wparam|beginpaint, 1 },
Fix msg test failures when run under win2k.
2004-08-26 18:21:56 +00:00
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{ 0 }
};
static const struct message WmInvalidateErasePaint[] = {
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|wparam|beginpaint, 1 },
Fix msg test failures when run under win2k.
2004-08-26 18:21:56 +00:00
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
static const struct message WmInvalidateErasePaint2[] = {
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint },
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
static const struct message WmErase[] = {
{ WM_ERASEBKGND, sent },
{ 0 }
};
static const struct message WmPaint[] = {
{ WM_PAINT, sent },
{ 0 }
};
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
static const struct message WmParentOnlyPaint[] = {
{ WM_PAINT, sent|parent },
{ 0 }
};
static const struct message WmInvalidateParent[] = {
{ WM_NCPAINT, sent|parent },
{ WM_GETTEXT, sent|defwinproc|parent|optional },
{ WM_ERASEBKGND, sent|parent },
{ 0 }
};
static const struct message WmInvalidateParentChild[] = {
{ WM_NCPAINT, sent|parent },
{ WM_GETTEXT, sent|defwinproc|parent|optional },
{ WM_ERASEBKGND, sent|parent },
{ WM_NCPAINT, sent },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent },
{ 0 }
};
static const struct message WmInvalidateParentChild2[] = {
{ WM_ERASEBKGND, sent|parent },
{ WM_NCPAINT, sent },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent },
{ 0 }
};
static const struct message WmParentPaint[] = {
{ WM_PAINT, sent|parent },
{ WM_PAINT, sent },
{ 0 }
};
static const struct message WmParentPaintNc[] = {
{ WM_PAINT, sent|parent },
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint },
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
static const struct message WmChildPaintNc[] = {
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint },
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
static const struct message WmParentErasePaint[] = {
{ WM_PAINT, sent|parent },
{ WM_NCPAINT, sent|parent|beginpaint },
{ WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
{ WM_ERASEBKGND, sent|parent|beginpaint },
{ WM_PAINT, sent },
{ WM_NCPAINT, sent|beginpaint },
{ WM_GETTEXT, sent|beginpaint|defwinproc|optional },
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
static const struct message WmParentOnlyNcPaint[] = {
{ WM_PAINT, sent|parent },
{ WM_NCPAINT, sent|parent|beginpaint },
{ WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
{ 0 }
};
static const struct message WmSetParentStyle[] = {
{ WM_STYLECHANGING, sent|parent },
{ WM_STYLECHANGED, sent|parent },
{ 0 }
};
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
static void test_paint_messages(void)
{
RECT rect;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
POINT pt;
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
MSG msg;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
HWND hparent, hchild;
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
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 );
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
/* try to flush pending X expose events */
MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
check_update_rgn( hwnd, 0 );
SetRectRgn( hrgn, 10, 10, 20, 20 );
RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
check_update_rgn( hwnd, hrgn );
SetRectRgn( hrgn2, 20, 20, 30, 30 );
RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
check_update_rgn( hwnd, hrgn );
/* validate everything */
RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
check_update_rgn( hwnd, 0 );
Add the tests for behaviour of [In]validateRect and [In]validateRgn with hwnd set to 0, make them pass under Wine.
2005-10-31 15:45:16 +00:00
/* flush pending messages */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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.
*/
trace("testing InvalidateRect(0, NULL, FALSE)\n");
SetRectEmpty( &rect );
ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
check_update_rgn( hwnd, hrgn );
ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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.
*/
trace("testing ValidateRect(0, NULL)\n");
SetRectEmpty( &rect );
Add trailing '\n's to ok() and TRACE() calls.
2005-11-10 11:17:38 +00:00
ok(ValidateRect(0, &rect), "ValidateRect(0, &rc) should not fail\n");
Add the tests for behaviour of [In]validateRect and [In]validateRgn with hwnd set to 0, make them pass under Wine.
2005-10-31 15:45:16 +00:00
check_update_rgn( hwnd, hrgn );
ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmPaint, "Paint", FALSE );
RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
check_update_rgn( hwnd, 0 );
trace("testing InvalidateRgn(0, NULL, FALSE)\n");
SetLastError(0xdeadbeef);
ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %ld\n", GetLastError());
check_update_rgn( hwnd, 0 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
trace("testing ValidateRgn(0, NULL)\n");
SetLastError(0xdeadbeef);
Add trailing '\n's to ok() and TRACE() calls.
2005-11-10 11:17:38 +00:00
ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
Add the tests for behaviour of [In]validateRect and [In]validateRgn with hwnd set to 0, make them pass under Wine.
2005-10-31 15:45:16 +00:00
ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %ld\n", GetLastError());
check_update_rgn( hwnd, 0 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
/* now with frame */
SetRectRgn( hrgn, -5, -5, 20, 20 );
Flush pending messages before testing painting message sequences.
2004-10-27 21:18:01 +00:00
/* flush pending messages */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
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 );
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
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 );
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence( WmPaint, "Paint", FALSE );
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
flush_sequence();
SetRectRgn( hrgn, -4, -4, -2, -2 );
RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
SetRectRgn( hrgn, -200, -200, -198, -198 );
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
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 );
- make sure that tests marked as todo_wine and actually succeed under wine will be counted as failures - remove todo_wine from a bunch of tests - log the line numbers of the actual tests, not those of a helper function.
2004-12-20 16:59:26 +00:00
ok_sequence( WmPaint, "Paint", FALSE );
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
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 */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
flush_sequence();
SetRectRgn( hrgn, -4, -4, -1, -1 );
RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
while (PeekMessage( &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 );
}
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
DispatchMessage( &msg );
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
}
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
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 );
/* try to flush pending X expose events */
MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 );
SetWindowLong( hparent, GWL_STYLE, GetWindowLong(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 */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
SetWindowLong( hparent, GWL_STYLE, GetWindowLong(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 */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &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 (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &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 (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmEmptySeq, "No other message", FALSE );
/* same thing with WS_CLIPCHILDREN in parent */
flush_sequence();
SetWindowLong( hparent, GWL_STYLE, GetWindowLong(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 (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
/* WM_PAINT in parent first */
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
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 );
/* test RDW_INTERNALPAINT behavior */
flush_sequence();
RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
assert( GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
UpdateWindow( hparent );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
UpdateWindow( hparent );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
assert( !(GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
UpdateWindow( hparent );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
UpdateWindow( hparent );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
log_all_parent_messages--;
DestroyWindow( hparent );
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
GetUpdateRect should return TRUE even if only the non-client area is invalid (reported by Rein Klazes).
2004-09-02 20:13:19 +00:00
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
DeleteObject( hrgn );
DeleteObject( hrgn2 );
}
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
struct wnd_event
{
HWND hwnd;
HANDLE event;
};
static DWORD WINAPI thread_proc(void *param)
{
MSG msg;
struct wnd_event *wnd_event = (struct wnd_event *)param;
wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
100, 100, 200, 200, 0, 0, 0, NULL);
ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
SetEvent(wnd_event->event);
while (GetMessage(&msg, 0, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
return 0;
}
static void test_interthread_messages(void)
{
HANDLE hThread;
DWORD tid;
WNDPROC proc;
MSG msg;
char buf[256];
int len, expected_len;
struct wnd_event wnd_event;
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
BOOL ret;
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
Skip interthread message test under win9x, it causes a crash there.
2004-10-06 18:51:27 +00:00
wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
if (!wnd_event.event)
{
trace("skipping interthread message test under win9x\n");
return;
}
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(wnd_event.event);
SetLastError(0xdeadbeef);
ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
ok(GetLastError() == ERROR_ACCESS_DENIED, "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,
"DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %ld\n", len, GetLastError());
Skip interthread message test under win9x, it causes a crash there.
2004-10-06 18:51:27 +00:00
/* the following test causes an exception in user.exe under win9x */
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
msg.hwnd = wnd_event.hwnd;
msg.message = WM_TIMER;
msg.wParam = 0;
Skip interthread message test under win9x, it causes a crash there.
2004-10-06 18:51:27 +00:00
msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
SetLastError(0xdeadbeef);
len = DispatchMessageA(&msg);
ok(!len && GetLastError() == 0xdeadbeef,
"DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
ok( ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(hThread);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
}
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
static const struct message WmVkN[] = {
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYDOWN, wparam|lparam, 'N', 1 },
{ WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_CHAR, wparam|lparam, 'n', 1 },
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ 0 }
};
static const struct message WmShiftVkN[] = {
{ WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYDOWN, wparam|lparam, 'N', 1 },
{ WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_CHAR, wparam|lparam, 'N', 1 },
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
{ 0 }
};
static const struct message WmCtrlVkN[] = {
{ WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYDOWN, wparam|lparam, 'N', 1 },
{ WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_CHAR, wparam|lparam, 0x000e, 1 },
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
{ 0 }
};
static const struct message WmCtrlVkN_2[] = {
{ WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYDOWN, wparam|lparam, 'N', 1 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
{ 0 }
};
static const struct message WmAltVkN[] = {
{ WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
{ WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
{ WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
{ WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
{ HCBT_SYSCOMMAND, hook },
{ WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
{ 0x00AE, sent|defwinproc|optional }, /* XP */
{ WM_GETTEXT, sent|defwinproc|optional }, /* XP */
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_INITMENU, sent|defwinproc },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_CAPTURECHANGED, sent|defwinproc },
{ WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{ EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_EXITMENULOOP, sent|defwinproc },
{ WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
{ WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
{ WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ 0 }
};
static const struct message WmAltVkN_2[] = {
{ WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
{ WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ 0 }
};
static const struct message WmCtrlAltVkN[] = {
{ WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
{ WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
{ WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
{ WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{ WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
{ 0 }
};
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
static const struct message WmCtrlShiftVkN[] = {
{ WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
{ WM_KEYDOWN, wparam|lparam, 'N', 1 },
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
{ WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
{ WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
{ WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
{ 0 }
};
static const struct message WmCtrlAltShiftVkN[] = {
{ WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
{ WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
{ WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
{ WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
{ WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
{ WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
{ WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
{ WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
{ WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
{ 0 }
};
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
static const struct message WmAltPressRelease[] = {
{ WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
{ WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
{ HCBT_SYSCOMMAND, hook },
{ WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
{ WM_INITMENU, sent|defwinproc },
{ EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
{ WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
{ WM_CAPTURECHANGED, sent|defwinproc },
{ WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
{ EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
{ WM_EXITMENULOOP, sent|defwinproc },
{ WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ 0 }
};
static const struct message WmAltMouseButton[] = {
{ WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
{ WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
{ WM_MOUSEMOVE, wparam|optional, 0, 0 },
{ WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
{ WM_LBUTTONDOWN, wparam, MK_LBUTTON, 0 },
{ WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON, 0 },
{ WM_LBUTTONUP, wparam, 0, 0 },
{ WM_LBUTTONUP, sent|wparam, 0, 0 },
{ WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
{ WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
{ 0 }
};
Add test for undocumented 0x4D message sent on F1.
2005-10-27 12:31:04 +00:00
static const struct message WmF1Seq[] = {
{ WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
{ WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
{ 0x4d, wparam|lparam, 0, 0 },
{ 0x4d, sent|wparam|lparam, 0, 0 },
{ WM_HELP, sent|defwinproc },
{ WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
{ WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
{ 0 }
};
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
{
MSG msg;
while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
{
struct message log_msg;
trace("accel: %p, %04x, %08x, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
/* ignore some unwanted messages */
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
if (msg.message == WM_MOUSEMOVE ||
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
msg.message == WM_GETICON ||
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
msg.message == WM_DEVICECHANGE)
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
continue;
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
log_msg.message = msg.message;
log_msg.flags = wparam|lparam;
log_msg.wParam = msg.wParam;
log_msg.lParam = msg.lParam;
add_message(&log_msg);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
static void test_accelerators(void)
{
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
RECT rc;
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
SHORT state;
HACCEL hAccel;
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
100, 100, 200, 200, 0, 0, 0, NULL);
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
BOOL ret;
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
assert(hwnd != 0);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
UpdateWindow(hwnd);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
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 = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
assert(hAccel != 0);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
pump_msg_loop(hwnd, 0);
flush_sequence();
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
trace("testing VK_N press/release\n");
flush_sequence();
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmVkN, "VK_N press/release", FALSE);
trace("testing Shift+VK_N press/release\n");
flush_sequence();
keybd_event(VK_SHIFT, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
trace("testing Ctrl+VK_N press/release\n");
flush_sequence();
keybd_event(VK_CONTROL, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
trace("testing Alt+VK_N press/release\n");
flush_sequence();
keybd_event(VK_MENU, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
trace("testing Ctrl+Alt+VK_N press/release 1\n");
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
flush_sequence();
keybd_event(VK_CONTROL, 0, 0, 0);
keybd_event(VK_MENU, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
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);
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = DestroyAcceleratorTable(hAccel);
ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
assert(hAccel != 0);
trace("testing VK_N press/release\n");
flush_sequence();
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmVkN, "VK_N press/release", FALSE);
trace("testing Shift+VK_N press/release\n");
flush_sequence();
keybd_event(VK_SHIFT, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
trace("testing Ctrl+VK_N press/release 2\n");
flush_sequence();
keybd_event(VK_CONTROL, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
trace("testing Alt+VK_N press/release 2\n");
flush_sequence();
keybd_event(VK_MENU, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, hAccel);
ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
trace("testing Ctrl+Alt+VK_N press/release 2\n");
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
flush_sequence();
keybd_event(VK_CONTROL, 0, 0, 0);
keybd_event(VK_MENU, 0, 0, 0);
VK_0-9 and VK_A-Z are not defined in the Windows headers, removed them (spotted by Francois Gouget).
2004-10-22 20:29:10 +00:00
keybd_event('N', 0, 0, 0);
keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
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);
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
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);
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);
Correct cases where arguments of ok() calls depend on the order in which they are evaluated.
2004-12-27 17:26:37 +00:00
ret = DestroyAcceleratorTable(hAccel);
ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
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);
trace("testing Alt+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);
pump_msg_loop(hwnd, 0);
flush_sequence();
keybd_event(VK_MENU, 0, 0, 0);
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
pump_msg_loop(hwnd, 0);
ok_sequence(WmAltMouseButton, "Alt+MouseButton press/release", FALSE);
Add test for undocumented 0x4D message sent on F1.
2005-10-27 12:31:04 +00:00
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", TRUE);
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
DestroyWindow(hwnd);
}
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
/************* window procedures ********************/
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
{
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
static long defwndproc_counter = 0;
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
static long beginpaint_counter = 0;
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
LRESULT ret;
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
struct message msg;
trace("%p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
switch (message)
{
Add a test for window state when a window receives WM_ENABLE message.
2005-06-07 20:29:09 +00:00
case WM_ENABLE:
{
LONG style = GetWindowLongA(hwnd, GWL_STYLE);
ok((BOOL)wParam == !(style & WS_DISABLED),
"wrong WS_DISABLED state: %d != %d\n", wParam, !(style & WS_DISABLED));
break;
}
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
case WM_CAPTURECHANGED:
if (test_DestroyWindow_flag)
{
DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
if (style & WS_CHILD)
Use Get/SetWindowLongPtr instead of Get/SetWindowLong where appropriate.
2005-09-09 15:20:04 +00:00
lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
else if (style & WS_POPUP)
lParam = WND_POPUP_ID;
else
lParam = WND_PARENT_ID;
}
break;
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
case WM_NCDESTROY:
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{
HWND capture;
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
capture = GetCapture();
if (capture)
{
ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
trace("current capture %p, releasing...\n", capture);
ReleaseCapture();
}
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
/* fall through */
case WM_DESTROY:
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if (pGetAncestor)
ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
if (test_DestroyWindow_flag)
{
DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
if (style & WS_CHILD)
Use Get/SetWindowLongPtr instead of Get/SetWindowLong where appropriate.
2005-09-09 15:20:04 +00:00
lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
else if (style & WS_POPUP)
lParam = WND_POPUP_ID;
else
lParam = WND_PARENT_ID;
}
break;
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
/* test_accelerators() depends on this */
case WM_NCHITTEST:
return HTCLIENT;
/* ignore */
case WM_MOUSEMOVE:
case WM_SETCURSOR:
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
case WM_DEVICECHANGE:
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
return 0;
Log flags for WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED messages, make the tests pass on Win95/Win98/Win2000, fix some test failures under Wine.
2004-09-13 18:03:09 +00:00
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
msg.message = message;
msg.flags = sent|wparam|lparam;
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
if (defwndproc_counter) msg.flags |= defwinproc;
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
if (beginpaint_counter) msg.flags |= beginpaint;
Add 'optional' flag for messages, make the test run under win2k.
2004-03-25 23:35:52 +00:00
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add a test for creation of a maximized child window.
2004-04-29 20:00:40 +00:00
if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
{
HWND parent = GetParent(hwnd);
RECT rc;
MINMAXINFO *minmax = (MINMAXINFO *)lParam;
GetClientRect(parent, &rc);
trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
trace("ptReserved = (%ld,%ld)\n"
"ptMaxSize = (%ld,%ld)\n"
"ptMaxPosition = (%ld,%ld)\n"
"ptMinTrackSize = (%ld,%ld)\n"
"ptMaxTrackSize = (%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);
}
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
if (message == WM_PAINT)
{
PAINTSTRUCT ps;
beginpaint_counter++;
BeginPaint( hwnd, &ps );
beginpaint_counter--;
EndPaint( hwnd, &ps );
return 0;
}
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
defwndproc_counter++;
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
: DefWindowProcA(hwnd, message, wParam, lParam);
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
defwndproc_counter--;
return ret;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
}
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
}
static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
}
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
static long defwndproc_counter = 0;
LRESULT ret;
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
struct message msg;
trace("popup: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
msg.message = message;
msg.flags = sent|wparam|lparam;
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
if (defwndproc_counter) msg.flags |= defwinproc;
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
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);
}
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
defwndproc_counter++;
ret = DefWindowProcA(hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
}
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
static long defwndproc_counter = 0;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
static long beginpaint_counter = 0;
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
LRESULT ret;
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
struct message msg;
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
trace("parent: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
if (log_all_parent_messages ||
message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
- Make new tests pass on win2k SP4 and win95 OSR2. - Add logging of some useful messages in the parent window. - Add logging of wparam for WM_IME_SETCONTEXT.
2004-05-20 01:17:28 +00:00
message == WM_SETFOCUS || message == WM_KILLFOCUS ||
message == WM_ENABLE || message == WM_ENTERIDLE ||
message == WM_IME_SETCONTEXT)
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
{
Make DrawMenuBar and SetMenu tests pass under Wine.
2005-09-28 15:13:10 +00:00
switch (message)
{
case WM_ERASEBKGND:
{
RECT rc;
INT ret = GetClipBox((HDC)wParam, &rc);
trace("WM_ERASEBKGND: GetClipBox()=%d, (%ld,%ld-%ld,%ld)\n",
ret, rc.left, rc.top, rc.right, rc.bottom);
break;
}
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
msg.message = message;
msg.flags = sent|parent|wparam|lparam;
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
if (defwndproc_counter) msg.flags |= defwinproc;
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
if (beginpaint_counter) msg.flags |= beginpaint;
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
}
Added a bunch of tests for various behaviors of RedrawWindow.
2004-12-07 17:34:19 +00:00
if (message == WM_PAINT)
{
PAINTSTRUCT ps;
beginpaint_counter++;
BeginPaint( hwnd, &ps );
beginpaint_counter--;
EndPaint( hwnd, &ps );
return 0;
}
Make use of the 'defwinproc' flag in the message test.
2004-04-06 20:09:59 +00:00
defwndproc_counter++;
ret = DefWindowProcA(hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
}
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static long defwndproc_counter = 0;
LRESULT ret;
struct message msg;
trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
Explicitly ignore WM_GETICON message in the message tests.
2005-09-28 18:11:10 +00:00
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
Added some optional messages to make all tests succeed on XP. Added tests for EndDialog and a simple modal dialog.
2004-05-18 20:44:23 +00:00
if (after_end_dialog)
ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
else
ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
switch (message)
{
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *winpos = (WINDOWPOS *)lParam;
trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
winpos->hwnd, winpos->hwndInsertAfter,
winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
/* Log only documented flags, win2k uses 0x1000 and 0x2000
* in the high word for internal purposes
*/
wParam = winpos->flags & 0xffff;
break;
}
}
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
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 = DefDlgProcA(hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
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";
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
if(!RegisterClassA(&cls)) return FALSE;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
Add new tests for various window creation/positioning behaviours.
2004-04-02 20:22:53 +00:00
cls.lpfnWndProc = PopupMsgCheckProcA;
cls.lpszClassName = "TestPopupClass";
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
if(!RegisterClassA(&cls)) return FALSE;
Add a procedure for logging WM_PARENTNOTIFY messages.
2004-03-26 02:28:28 +00:00
cls.lpfnWndProc = ParentMsgCheckProcA;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
cls.lpszClassName = "TestParentClass";
if(!RegisterClassA(&cls)) return FALSE;
cls.lpfnWndProc = DefWindowProcA;
cls.lpszClassName = "SimpleWindowClass";
if(!RegisterClassA(&cls)) return FALSE;
- Make GetSystemMenu respect CS_NOCLOSE. - EnableMenuItem should not generate WM_WINDOWPOSCHANGING message. - Make nonclient code check for presence of SC_CLOSE, not CS_NOCLOSE window class style. - Add a test case.
2005-03-30 18:59:27 +00:00
cls.style = CS_NOCLOSE;
cls.lpszClassName = "NoCloseWindowClass";
if(!RegisterClassA(&cls)) return FALSE;
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
cls.style = 0;
cls.hInstance = GetModuleHandleA(0);
cls.hbrBackground = 0;
Add a message test for custom dialog initialization.
2004-04-20 04:02:50 +00:00
cls.lpfnWndProc = TestDlgProcA;
cls.lpszClassName = "TestDialogClass";
if(!RegisterClassA(&cls)) return FALSE;
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
return TRUE;
}
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
static HHOOK hCBT_hook;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
static DWORD cbt_hook_thread_id;
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
{
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
static const char *CBT_code_name[10] = {
"HCBT_MOVESIZE",
"HCBT_MINMAX",
"HCBT_QS",
"HCBT_CREATEWND",
"HCBT_DESTROYWND",
"HCBT_ACTIVATE",
"HCBT_CLICKSKIPPED",
"HCBT_KEYSKIPPED",
"HCBT_SYSCOMMAND",
"HCBT_SETFOCUS" };
const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
HWND hwnd;
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
char buf[256];
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
trace("CBT: %d (%s), %08x, %08lx\n", nCode, code_name, wParam, lParam);
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
Add support for HCBT_SYSCOMMAND hook, add logging for HCBT_SYSCOMMAND in the message test.
2004-09-13 19:32:59 +00:00
if (nCode == HCBT_SYSCOMMAND)
{
struct message msg;
msg.message = nCode;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
msg.flags = hook|wparam|lparam;
Add support for HCBT_SYSCOMMAND hook, add logging for HCBT_SYSCOMMAND in the message test.
2004-09-13 19:32:59 +00:00
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
if (nCode == HCBT_DESTROYWND)
{
if (test_DestroyWindow_flag)
{
DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
if (style & WS_CHILD)
Use Get/SetWindowLongPtr instead of Get/SetWindowLong where appropriate.
2005-09-09 15:20:04 +00:00
lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
else if (style & WS_POPUP)
lParam = WND_POPUP_ID;
else
lParam = WND_PARENT_ID;
}
}
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
/* Log also SetFocus(0) calls */
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
hwnd = wParam ? (HWND)wParam : (HWND)lParam;
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
if (GetClassNameA(hwnd, buf, sizeof(buf)))
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
if (!lstrcmpiA(buf, "TestWindowClass") ||
!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") ||
Add a test for some edit control behaviours, make it pass under Wine.
2005-11-16 11:22:54 +00:00
!lstrcmpiA(buf, "my_edit_class") ||
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
!lstrcmpiA(buf, "static") ||
!lstrcmpiA(buf, "#32770"))
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
{
struct message msg;
msg.message = nCode;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
msg.flags = hook|wparam|lparam;
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
msg.wParam = wParam;
msg.lParam = lParam;
add_message(&msg);
}
}
return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
}
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
DWORD event,
HWND hwnd,
LONG object_id,
LONG child_id,
DWORD thread_id,
DWORD event_time)
{
char buf[256];
trace("WEH:%p,event %08lx,hwnd %p,obj %08lx,id %08lx,thread %08lx,time %08lx\n",
hevent, event, hwnd, object_id, child_id, thread_id, event_time);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/* ignore mouse cursor events */
if (object_id == OBJID_CURSOR) return;
if (!hwnd || GetClassNameA(hwnd, buf, sizeof(buf)))
{
if (!hwnd ||
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
!lstrcmpiA(buf, "TestWindowClass") ||
!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") ||
Add a test for some edit control behaviours, make it pass under Wine.
2005-11-16 11:22:54 +00:00
!lstrcmpiA(buf, "my_edit_class") ||
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
!lstrcmpiA(buf, "static") ||
!lstrcmpiA(buf, "#32770"))
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{
struct message msg;
msg.message = event;
msg.flags = winevent_hook|wparam|lparam;
msg.wParam = object_id;
msg.lParam = child_id;
add_message(&msg);
}
}
}
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
static const WCHAR wszAnsi[] = {'U',0};
static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case CB_FINDSTRINGEXACT:
trace("String: %p\n", (LPCWSTR)lParam);
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
return 1;
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
return 0;
return -1;
}
return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
static const struct message WmGetTextLengthAfromW[] = {
{ WM_GETTEXTLENGTH, sent },
{ WM_GETTEXT, sent },
{ 0 }
};
static const WCHAR testWindowClassW[] =
{ 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
/* dummy window proc for WM_GETTEXTLENGTH test */
static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
{
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 );
}
}
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
static void test_message_conversion(void)
{
static const WCHAR wszMsgConversionClass[] =
{'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
WNDCLASSW cls;
LRESULT lRes;
HWND hwnd;
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
WNDPROC wndproc, newproc;
BOOL ret;
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
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;
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
cls.style = 0;
cls.lpfnWndProc = MsgCheckProcW;
cls.cbClsExtra = 0;
cls.cbWndExtra = 0;
cls.hInstance = GetModuleHandleW(0);
cls.hIcon = 0;
cls.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
cls.hbrBackground = GetStockObject(WHITE_BRUSH);
cls.lpszMenuName = NULL;
cls.lpszClassName = testWindowClassW;
if(!RegisterClassW(&cls)) return;
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
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);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
"PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
"PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
SetLastError(0);
lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
SetLastError(0);
lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
Fix some msg.c and win.c failures running on NT4 and XP.
2005-03-14 10:05:50 +00:00
ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
Add more message conversion tests, make the tests pass under Wine.
2004-10-04 20:39:00 +00:00
"SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
When doing A->W WM_GETTEXTLENGTH, use WM_GETTEXT behind the scenes to obtain an exact length.
2005-10-18 10:45:18 +00:00
/* 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);
assert(hwnd);
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 %ld\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 %ld\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 ),
"got bad length %ld\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 ),
"got bad length %ld\n", lRes );
ret = DestroyWindow(hwnd);
ok( ret, "DestroyWindow() error %ld\n", GetLastError());
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
}
Added some tests for timer functions.
2004-11-29 18:21:14 +00:00
typedef struct _thread_info
{
HWND hWnd;
HANDLE handles[2];
DWORD id;
} thread_info;
static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT id, DWORD dwTime)
{
}
#define TIMER_ID 0x19
static DWORD WINAPI timer_thread_proc(LPVOID x)
{
thread_info *info = x;
DWORD r;
r = KillTimer(info->hWnd, 0x19);
ok(r,"KillTimer failed in thread\n");
r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
ok(r,"SetTimer failed in thread\n");
ok(r==TIMER_ID,"SetTimer id different\n");
r = SetEvent(info->handles[0]);
ok(r,"SetEvent failed in thread\n");
return 0;
}
static void test_timers(void)
{
thread_info info;
DWORD id;
info.hWnd = CreateWindow ("TestWindowClass", NULL,
WS_OVERLAPPEDWINDOW ,
CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
NULL, NULL, 0);
info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
Add trailing '\n's to ok() calls.
2004-12-14 11:41:24 +00:00
ok(info.id, "SetTimer failed\n");
ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
Added some tests for timer functions.
2004-11-29 18:21:14 +00:00
info.handles[0] = CreateEvent(NULL,0,0,NULL);
info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
WaitForSingleObject(info.handles[1], INFINITE);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
CloseHandle(info.handles[0]);
CloseHandle(info.handles[1]);
Added some tests for timer functions.
2004-11-29 18:21:14 +00:00
ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
}
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
/* Various win events with arbitrary parameters */
static const struct message WmWinEventsSeq[] = {
{ EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
{ EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
{ EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
{ EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
{ EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
{ EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
{ EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
/* our win event hook ignores OBJID_CURSOR events */
/*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
{ EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
{ EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
{ EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
{ EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
{ EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
{ EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
{ EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
{ EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
{ EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
{ EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
{ EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
{ EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
{ EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
{ 0 }
};
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
static const struct message WmWinEventCaretSeq[] = {
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
{ EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
{ 0 }
};
static const struct message WmWinEventCaretSeq_2[] = {
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
{ EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
{ 0 }
};
static const struct message WmWinEventAlertSeq[] = {
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
{ 0 }
};
static const struct message WmWinEventAlertSeq_2[] = {
/* create window in the thread proc */
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
/* our test event */
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
{ 0 }
};
static const struct message WmGlobalHookSeq_1[] = {
/* create window in the thread proc */
{ HCBT_CREATEWND, hook|lparam, 0, 2 },
/* our test events */
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
{ 0 }
};
static const struct message WmGlobalHookSeq_2[] = {
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
{ HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
{ 0 }
};
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
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)
{
char buf[256];
trace("WEH_2:%p,event %08lx,hwnd %p,obj %08lx,id %08lx,thread %08lx,time %08lx\n",
hevent, event, hwnd, object_id, child_id, thread_id, event_time);
if (GetClassNameA(hwnd, buf, sizeof(buf)))
{
if (!lstrcmpiA(buf, "TestWindowClass") ||
!lstrcmpiA(buf, "static"))
{
struct message msg;
msg.message = event;
msg.flags = winevent_hook|wparam|lparam;
msg.wParam = object_id;
msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
add_message(&msg);
}
}
}
static HHOOK hCBT_global_hook;
static DWORD cbt_global_hook_thread_id;
static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
{
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
HWND hwnd;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
char buf[256];
trace("CBT_2: %d, %08x, %08lx\n", nCode, wParam, lParam);
if (nCode == HCBT_SYSCOMMAND)
{
struct message msg;
msg.message = nCode;
msg.flags = hook|wparam|lparam;
msg.wParam = wParam;
msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
add_message(&msg);
return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
}
/* Log also SetFocus(0) calls */
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
hwnd = wParam ? (HWND)wParam : (HWND)lParam;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
if (GetClassNameA(hwnd, buf, sizeof(buf)))
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
{
if (!lstrcmpiA(buf, "TestWindowClass") ||
!lstrcmpiA(buf, "static"))
{
struct message msg;
msg.message = nCode;
msg.flags = hook|wparam|lparam;
msg.wParam = wParam;
msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
add_message(&msg);
}
}
return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
}
static DWORD WINAPI win_event_global_thread_proc(void *param)
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
{
HWND hwnd;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
MSG msg;
HANDLE hevent = *(HANDLE *)param;
HMODULE user32 = GetModuleHandleA("user32.dll");
FARPROC pNotifyWinEvent = GetProcAddress(user32, "NotifyWinEvent");
assert(pNotifyWinEvent);
hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
assert(hwnd);
trace("created thread window %p\n", hwnd);
*(HWND *)param = hwnd;
flush_sequence();
/* this event should be received only by our new hook proc,
* an old one does not expect an event from another thread.
*/
pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
SetEvent(hevent);
while (GetMessage(&msg, 0, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
{
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);
assert(hwnd);
trace("created thread window %p\n", hwnd);
*(HWND *)param = hwnd;
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
/* 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.
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
SetFocus(0);
- Pass original wParam to CallNextHookEx. - Avoid playing games with focus in a newly created thread, that leads to all kinds of misbehaviours and failures in window activation under Windows.
2005-02-23 12:44:06 +00:00
SetFocus(hwnd);*/
DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
SetEvent(hevent);
while (GetMessage(&msg, 0, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
static void test_winevents(void)
{
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
BOOL ret;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
MSG msg;
HWND hwnd, hwnd2;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
UINT i;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
HANDLE hthread, hevent;
DWORD tid;
HWINEVENTHOOK hhook;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
const struct message *events = WmWinEventsSeq;
HMODULE user32 = GetModuleHandleA("user32.dll");
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
FARPROC pNotifyWinEvent = GetProcAddress(user32, "NotifyWinEvent");
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
NULL, NULL, 0);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
assert(hwnd);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
/****** start of global hook test *************/
hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
assert(hCBT_global_hook);
hevent = CreateEventA(NULL, 0, 0, NULL);
assert(hevent);
hwnd2 = (HWND)hevent;
hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
flush_sequence();
/* this one should be received only by old hook proc */
DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
/* this one should be received only by old hook proc */
DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = UnhookWindowsHookEx(hCBT_global_hook);
Add trailing '\n's to ok() calls.
2005-04-19 09:48:44 +00:00
ok( ret, "UnhookWindowsHookEx error %ld\n", GetLastError());
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
PostThreadMessageA(tid, WM_QUIT, 0, 0);
ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(hthread);
CloseHandle(hevent);
ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
/****** end of global hook test *************/
if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
{
ok(DestroyWindow(hwnd), "failed to destroy window\n");
return;
}
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
flush_sequence();
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
#if 0 /* this test doesn't pass under Win9x */
/* win2k ignores events with hwnd == 0 */
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
SetLastError(0xdeadbeef);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
#endif
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
/****** start of event filtering test *************/
hhook = (HWINEVENTHOOK)pSetWinEventHook(
EVENT_OBJECT_SHOW, /* 0x8002 */
EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
GetModuleHandleA(0), win_event_global_hook_proc,
GetCurrentProcessId(), 0,
WINEVENT_INCONTEXT);
ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
hevent = CreateEventA(NULL, 0, 0, NULL);
assert(hevent);
hwnd2 = (HWND)hevent;
hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
flush_sequence();
/* this one should be received only by old hook proc */
pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
/* this one should be received only by old hook proc */
pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hhook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
PostThreadMessageA(tid, WM_QUIT, 0, 0);
ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(hthread);
CloseHandle(hevent);
ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
/****** end of event filtering test *************/
/****** start of out of context event test *************/
hhook = (HWINEVENTHOOK)pSetWinEventHook(
EVENT_MIN, EVENT_MAX,
0, win_event_global_hook_proc,
GetCurrentProcessId(), 0,
WINEVENT_OUTOFCONTEXT);
ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
hevent = CreateEventA(NULL, 0, 0, NULL);
assert(hevent);
hwnd2 = (HWND)hevent;
flush_sequence();
hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
/* process pending winevent messages */
ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
flush_sequence();
/* this one should be received only by old hook proc */
pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
/* this one should be received only by old hook proc */
pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
/* process pending winevent messages */
ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hhook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
PostThreadMessageA(tid, WM_QUIT, 0, 0);
ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(hthread);
CloseHandle(hevent);
ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
/****** end of out of context event test *************/
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
ok(DestroyWindow(hwnd), "failed to destroy window\n");
}
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
static void test_set_hook(void)
{
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
BOOL ret;
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
HHOOK hhook;
HWINEVENTHOOK hwinevent_hook;
HMODULE user32 = GetModuleHandleA("user32.dll");
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
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);
#if 0 /* this test doesn't pass under Win9x: BUG! */
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());
#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 || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
SetLastError(0xdeadbeef);
ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
if (!pSetWinEventHook || !pUnhookWinEvent) return;
/* even process local incontext hooks require hmodule */
SetLastError(0xdeadbeef);
hwinevent_hook = (HWINEVENTHOOK)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 || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
/* even thread local incontext hooks require hmodule */
SetLastError(0xdeadbeef);
hwinevent_hook = (HWINEVENTHOOK)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 || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
#if 0 /* these 3 tests don't pass under Win9x */
SetLastError(0xdeadbeef);
hwinevent_hook = (HWINEVENTHOOK)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 = (HWINEVENTHOOK)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 = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
0, win_event_proc, 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %ld\n", GetLastError());
#endif
SetLastError(0xdeadbeef);
hwinevent_hook = (HWINEVENTHOOK)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());
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hwinevent_hook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
todo_wine {
/* This call succeeds under win2k SP4, but fails under Wine.
Does win2k test/use passed process id? */
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
SetLastError(0xdeadbeef);
hwinevent_hook = (HWINEVENTHOOK)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());
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hwinevent_hook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
}
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
SetLastError(0xdeadbeef);
ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
}
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
static const struct message ScrollWindowPaint1[] = {
{ WM_PAINT, sent },
{ WM_ERASEBKGND, sent|beginpaint },
{ 0 }
};
static const struct message ScrollWindowPaint2[] = {
{ WM_PAINT, sent },
{ 0 }
};
static void test_scrollwindowex(void)
{
HWND hwnd, hchild;
RECT rect={0,0,130,130};
MSG msg;
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);
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
/* scroll without the child window */
trace("start scroll\n");
ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
SW_ERASE|SW_INVALIDATE);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
trace("end scroll\n");
flush_sequence();
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
/* Now without the SW_ERASE flag */
trace("start scroll\n");
ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
trace("end scroll\n");
flush_sequence();
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
/* now scroll the child window as well */
trace("start scroll\n");
ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
todo_wine { /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
/* windows sometimes a WM_MOVE */
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
}
trace("end scroll\n");
flush_sequence();
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
ScrollWindow should call ScrollWindowEx with the SW_ERASE flag set. With conformance test.
2005-03-29 13:06:32 +00:00
/* now scroll with ScrollWindow() */
trace("start scroll with ScrollWindow\n");
ScrollWindow( hwnd, 5, 5, NULL, NULL);
trace("end scroll\n");
flush_sequence();
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
ok_sequence(ScrollWindowPaint1, "ScrollWindow", 0);
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
ok(DestroyWindow(hchild), "failed to destroy window\n");
ok(DestroyWindow(hwnd), "failed to destroy window\n");
flush_sequence();
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
static const struct message destroy_window_with_children[] = {
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
{ HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
{ HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
{ WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
{ WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
{ WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
Take Shift key state into account while processing an accelerator. Add a couple of test cases.
2005-02-21 18:33:27 +00:00
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
{ WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
{ WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
{ WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
{ WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
{ WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
{ WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
{ WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
{ WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
{ 0 }
};
static void test_DestroyWindow(void)
{
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
BOOL ret;
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
HWND parent, child1, child2, child3, child4, test;
UINT child_id = WND_CHILD_ID + 1;
parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
100, 100, 200, 200, 0, 0, 0, NULL);
assert(parent != 0);
child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
assert(child1 != 0);
child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
assert(child2 != 0);
child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
assert(child3 != 0);
child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
0, 0, 50, 50, parent, 0, 0, NULL);
assert(child4 != 0);
/* test owner/parent of child2 */
test = GetParent(child2);
ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(child2, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
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);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
todo_wine {
ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
}
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(parent, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
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);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(child1, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == parent, "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
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);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(child2, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == parent, "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
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);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(child3, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == child1, "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
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);
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
if(pGetAncestor) {
test = pGetAncestor(child4, GA_PARENT);
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
}
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
test = GetWindow(child4, GW_OWNER);
ok(test == parent, "wrong owner %p\n", test);
flush_sequence();
trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
parent, child1, child2, child3, child4);
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
SetCapture(child4);
Authors: Mike McCormack <mike@codeweavers.com>, Dmitry Timoshkov <dmitry@codeweavers.com> Release capture before sending WM_NCDESTROY message, do not send WM_CAPTURECHANGED in that case. Add a test case for that behaviour.
2005-02-24 17:03:51 +00:00
test = GetCapture();
Do not release capture before sending WM_NCDESTROY message, update the tests to reflect that.
2005-03-14 17:15:33 +00:00
ok(test == child4, "wrong capture window %p\n", test);
Authors: Mike McCormack <mike@codeweavers.com>, Dmitry Timoshkov <dmitry@codeweavers.com> Release capture before sending WM_NCDESTROY message, do not send WM_CAPTURECHANGED in that case. Add a test case for that behaviour.
2005-02-24 17:03:51 +00:00
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
test_DestroyWindow_flag = TRUE;
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = DestroyWindow(parent);
ok( ret, "DestroyWindow() error %ld\n", GetLastError());
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
test_DestroyWindow_flag = FALSE;
Cosmetic fixes.
2005-02-22 16:02:58 +00:00
ok_sequence(destroy_window_with_children, "destroy window with children", 0);
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
Protect SetParent from creating circular window dependencies. Add a test case.
2005-03-02 10:11:06 +00:00
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");
Authors: Mike McCormack <mike@codeweavers.com>, Dmitry Timoshkov <dmitry@codeweavers.com> Release capture before sending WM_NCDESTROY message, do not send WM_CAPTURECHANGED in that case. Add a test case for that behaviour.
2005-02-24 17:03:51 +00:00
test = GetCapture();
ok(!test, "wrong capture window %p\n", test);
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
}
DispatchMessage needs to repaint the non-client area if the WM_PAINT handler didn't do it.
2005-02-22 14:58:52 +00:00
static const struct message WmDispatchPaint[] = {
{ WM_NCPAINT, sent },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_GETTEXT, sent|defwinproc|optional },
{ WM_ERASEBKGND, sent },
{ 0 }
};
static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
Silently ignore WM_PAINT in msg tests.
2005-10-26 10:11:52 +00:00
if (message == WM_PAINT) return 0;
DispatchMessage needs to repaint the non-client area if the WM_PAINT handler didn't do it.
2005-02-22 14:58:52 +00:00
return MsgCheckProcA( hwnd, message, wParam, lParam );
}
static void test_DispatchMessage(void)
{
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 );
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
Use Get/SetWindowLongPtr instead of Get/SetWindowLong where appropriate.
2005-09-09 15:20:04 +00:00
SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
DispatchMessage needs to repaint the non-client area if the WM_PAINT handler didn't do it.
2005-02-22 14:58:52 +00:00
SetRect( &rect, -5, -5, 5, 5 );
RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
count = 0;
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
{
if (msg.message != WM_PAINT) DispatchMessage( &msg );
else
{
flush_sequence();
DispatchMessage( &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" );
trace("now without DispatchMessage\n");
flush_sequence();
RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
count = 0;
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
{
if (msg.message != WM_PAINT) DispatchMessage( &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;
}
}
}
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
static const struct message WmUser[] = {
{ WM_USER, sent },
{ 0 }
};
struct thread_info
{
HWND hwnd;
DWORD timeout;
DWORD ret;
};
static DWORD CALLBACK send_msg_thread( LPVOID arg )
{
struct thread_info *info = arg;
info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT, "unexpected error %ld\n", GetLastError());
return 0;
}
static void wait_for_thread( HANDLE thread )
{
while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
{
MSG msg;
while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage(&msg);
}
}
static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if (message == WM_USER) Sleep(200);
return MsgCheckProcA( hwnd, message, wParam, lParam );
}
static void test_SendMessageTimeout(void)
{
MSG msg;
HANDLE thread;
struct thread_info info;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
DWORD tid;
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
100, 100, 200, 200, 0, 0, 0, NULL);
while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
flush_sequence();
info.timeout = 1000;
info.ret = 0xdeadbeef;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
wait_for_thread( thread );
CloseHandle( thread );
ok( info.ret == 1, "SendMessageTimeout failed\n" );
ok_sequence( WmUser, "WmUser", FALSE );
info.timeout = 1;
info.ret = 0xdeadbeef;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
Sleep(100); /* SendMessageTimeout should timeout here */
wait_for_thread( thread );
CloseHandle( thread );
ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
/* 0 means infinite timeout */
info.timeout = 0;
info.ret = 0xdeadbeef;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
Sleep(100);
wait_for_thread( thread );
CloseHandle( thread );
ok( info.ret == 1, "SendMessageTimeout failed\n" );
ok_sequence( WmUser, "WmUser", FALSE );
/* timeout is treated as signed despite the prototype */
info.timeout = 0x7fffffff;
info.ret = 0xdeadbeef;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
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;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
Sleep(100);
wait_for_thread( thread );
CloseHandle( thread );
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;
Don't pass CreateThread() with a NULL pointer to TID as Win9x does not create a thread then.
2005-10-28 10:41:48 +00:00
thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
wait_for_thread( thread );
CloseHandle( thread );
/* we should timeout but still get the message */
ok( info.ret == 0, "SendMessageTimeout failed\n" );
ok_sequence( WmUser, "WmUser", FALSE );
DestroyWindow( info.hwnd );
}
Add a test for some edit control behaviours, make it pass under Wine.
2005-11-16 11:22:54 +00:00
/****************** edit message test *************************/
#define ID_EDIT 0x1234
static const struct message sl_edit_setfocus[] =
{
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent|wparam, 0 },
{ WM_CTLCOLOREDIT, sent|parent },
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
{ 0 }
};
static const struct message ml_edit_setfocus[] =
{
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent|wparam, 0 },
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
{ 0 }
};
static const struct message sl_edit_killfocus[] =
{
{ HCBT_SETFOCUS, hook },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_KILLFOCUS, sent|wparam, 0 },
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
{ WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
{ 0 }
};
static const struct message sl_edit_lbutton_dblclk[] =
{
{ WM_LBUTTONDBLCLK, sent },
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
{ 0 }
};
static const struct message sl_edit_lbutton_down[] =
{
{ WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ WM_CTLCOLOREDIT, sent|parent },
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ 0 }
};
static const struct message ml_edit_lbutton_down[] =
{
{ WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
{ EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
{ HCBT_SETFOCUS, hook },
{ WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
{ EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
{ WM_SETFOCUS, sent|wparam|defwinproc, 0 },
{ EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
{ 0 }
};
static const struct message sl_edit_lbutton_up[] =
{
{ WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
{ EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
{ WM_CAPTURECHANGED, sent|defwinproc },
{ EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
{ 0 }
};
static const struct message ml_edit_lbutton_up[] =
{
{ WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
{ EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
{ WM_CAPTURECHANGED, sent|defwinproc },
{ 0 }
};
static WNDPROC old_edit_proc;
static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static long defwndproc_counter = 0;
LRESULT ret;
struct message msg;
trace("edit: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
/* explicitly ignore WM_GETICON message */
if (message == WM_GETICON) return 0;
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 = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
defwndproc_counter--;
return ret;
}
static void subclass_edit(void)
{
WNDCLASSA cls;
if (!GetClassInfoA(0, "edit", &cls)) assert(0);
old_edit_proc = cls.lpfnWndProc;
cls.hInstance = GetModuleHandle(0);
cls.lpfnWndProc = edit_hook_proc;
cls.lpszClassName = "my_edit_class";
if (!RegisterClassA(&cls)) assert(0);
}
static void test_edit_messages(void)
{
HWND hwnd, parent;
DWORD dlg_code;
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);
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--;
}
/**************************** End of Edit test ******************************/
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
START_TEST(msg)
{
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
BOOL ret;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
HMODULE user32 = GetModuleHandleA("user32.dll");
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
FARPROC pIsWinEventHookInstalled = 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
Make user32_crosstest.exe loadable on NT 3.51.
2005-02-22 15:43:54 +00:00
pGetAncestor = (void*) GetProcAddress(user32, "GetAncestor");
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
if (!RegisterWindowClasses()) assert(0);
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
if (pSetWinEventHook)
{
hEvent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
GetModuleHandleA(0),
win_event_proc,
0,
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
GetCurrentThreadId(),
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
WINEVENT_INCONTEXT);
assert(hEvent_hook);
if (pIsWinEventHookInstalled)
{
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
UINT event;
Add a windows events hook to the message test.
2005-01-06 20:43:34 +00:00
for (event = EVENT_MIN; event <= EVENT_MAX; event++)
ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
}
}
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
cbt_hook_thread_id = GetCurrentThreadId();
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
assert(hCBT_hook);
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
test_winevents();
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
/* Fix message sequences before removing 4 lines below */
#if 1
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hEvent_hook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
pUnhookWinEvent = 0;
hEvent_hook = 0;
Fix message tests to run cleanly on Windows XP SP1.
2005-11-14 11:24:06 +00:00
#endif
Add support for winevent hooks.
2005-02-03 16:40:20 +00:00
ScrollWindowEx when called with the SW_ERASE flag does not send a WM_ERASEBKGND message, it just sets the erase flag. With some tests that show this behavior.
2005-02-08 14:27:39 +00:00
test_scrollwindowex();
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
test_messages();
Add a prototype for MDI message tests.
2004-06-23 20:51:21 +00:00
test_mdi_messages();
Fix button behaviour on WM_SETFOCUS/WM_KILLFOCUS with a test case.
2004-08-09 23:38:40 +00:00
test_button_messages();
Added some tests for paint messages and update regions.
2004-08-26 00:49:06 +00:00
test_paint_messages();
Added a test case for inter-thread DispatchMessage.
2004-10-05 22:35:00 +00:00
test_interthread_messages();
Add tests for conversion of message parameters.
2004-10-04 19:10:37 +00:00
test_message_conversion();
Add a test case for accelerators, make the test pass on Wine.
2004-10-05 23:45:35 +00:00
test_accelerators();
Added some tests for timer functions.
2004-11-29 18:21:14 +00:00
test_timers();
Add more tests for old style hooks and winevent hooks, make them pass under Wine.
2005-01-27 11:14:19 +00:00
test_set_hook();
- Always unlink children before sending WM_NCDESTROY message. - Fix order of WM_DESTROY messages for the children's recursion. - DestroyWindow should hide only visible windows. - Add a test case for the above fixes.
2005-02-18 20:01:41 +00:00
test_DestroyWindow();
DispatchMessage needs to repaint the non-client area if the WM_PAINT handler didn't do it.
2005-02-22 14:58:52 +00:00
test_DispatchMessage();
Timeout 0 means infinite wait for SendMessageTimeout. Remove the message from the receiver queue if it times out before being received.
2005-09-13 14:46:46 +00:00
test_SendMessageTimeout();
Add a test for some edit control behaviours, make it pass under Wine.
2005-11-16 11:22:54 +00:00
test_edit_messages();
Add 'hook' flag for messages. Add a test for CBT hook messages.
2004-03-26 00:18:20 +00:00
UnhookWindowsHookEx(hCBT_hook);
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
if (pUnhookWinEvent)
{
Fix some incorrect uses of the ok macro where the result depends on the evaluation order of its arguments.
2005-03-31 19:07:08 +00:00
ret = pUnhookWinEvent(hEvent_hook);
ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
Add more tests for keyboard/menu activation behaviour, make the tests pass under Wine.
2005-01-11 10:38:31 +00:00
SetLastError(0xdeadbeef);
ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
GetLastError() == 0xdeadbeef, /* Win9x */
"unexpected error %ld\n", GetLastError());
}
Move the message sequences documented in documentation/gui into a unit test.
2003-10-02 04:32:56 +00:00
}
Reference in New Issue Copy Permalink