dlls/user/tests/msg.c

   1 /*
   2  * Unit tests for window message handling
   3  *
   4  * Copyright 1999 Ove Kaaven
   5  * Copyright 2003 Dimitrie O. Paun
   6  * Copyright 2004, 2005 Dmitry Timoshkov
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #define _WIN32_WINNT 0x0500 /* For WM_CHANGEUISTATE */
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33
  34 #include "wine/test.h"
  35
  36 #define MDI_FIRST_CHILD_ID 2004
  37
  38 /* undocumented SWP flags - from SDK 3.1 */
  39 #define SWP_NOCLIENTSIZE        0x0800
  40 #define SWP_NOCLIENTMOVE        0x1000
  41
  42 static HWINEVENTHOOK hEvent_hook;
  43
  44 /*
  45 FIXME: add tests for these
  46 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
  47  WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
  48  WS_THICKFRAME: thick border
  49  WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
  50  WS_BORDER (default for overlapped windows): single black border
  51  none (default for child (and popup?) windows): no border
  52 */
  53
  54 typedef enum {
  55     sent=0x1,
  56     posted=0x2,
  57     parent=0x4,
  58     wparam=0x8,
  59     lparam=0x10,
  60     defwinproc=0x20,
  61     beginpaint=0x40,
  62     optional=0x80,
  63     hook=0x100,
  64     winevent_hook=0x200
  65 } msg_flags_t;
  66
  67 struct message {
  68     UINT message;          /* the WM_* code */
  69     msg_flags_t flags;     /* message props */
  70     WPARAM wParam;         /* expected value of wParam */
  71     LPARAM lParam;         /* expected value of lParam */
  72 };
  73
  74 /* Empty message sequence */
  75 static const struct message WmEmptySeq[] =
  76 {
  77     { 0 }
  78 };
  79 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
  80 static const struct message WmCreateOverlappedSeq[] = {
  81     { HCBT_CREATEWND, hook },
  82     { WM_GETMINMAXINFO, sent },
  83     { WM_NCCREATE, sent },
  84     { WM_NCCALCSIZE, sent|wparam, 0 },
  85     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
  86     { WM_CREATE, sent },
  87     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
  88     { 0 }
  89 };
  90 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
  91  * for a not visible overlapped window.
  92  */
  93 static const struct message WmSWP_ShowOverlappedSeq[] = {
  94     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
  95     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
  96     { WM_NCPAINT, sent|wparam|optional, 1 },
  97     { WM_GETTEXT, sent|defwinproc|optional },
  98     { WM_ERASEBKGND, sent|optional },
  99     { HCBT_ACTIVATE, hook },
 100     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 101     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 102     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
 103     { WM_ACTIVATEAPP, sent|wparam, 1 },
 104     { WM_NCACTIVATE, sent|wparam, 1 },
 105     { WM_GETTEXT, sent|defwinproc|optional },
 106     { WM_ACTIVATE, sent|wparam, 1 },
 107     { HCBT_SETFOCUS, hook },
 108     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
 109     { WM_IME_NOTIFY, sent|defwinproc|optional },
 110     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 111     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
 112     { WM_NCPAINT, sent|wparam|optional, 1 },
 113     { WM_GETTEXT, sent|defwinproc|optional },
 114     { WM_ERASEBKGND, sent|optional },
 115     /* Win9x adds SWP_NOZORDER below */
 116     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
 117     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
 118     { WM_NCPAINT, sent|wparam|optional, 1 },
 119     { WM_ERASEBKGND, sent|optional },
 120     { 0 }
 121 };
 122 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
 123  * for a visible overlapped window.
 124  */
 125 static const struct message WmSWP_HideOverlappedSeq[] = {
 126     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 127     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 128     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 129     { 0 }
 130 };
 131 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
 132 static const struct message WmShowOverlappedSeq[] = {
 133     { WM_SHOWWINDOW, sent|wparam, 1 },
 134     { WM_NCPAINT, sent|wparam|optional, 1 },
 135     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 136     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 137     { WM_NCPAINT, sent|wparam|optional, 1 },
 138     { WM_GETTEXT, sent|defwinproc|optional },
 139     { WM_ERASEBKGND, sent|optional },
 140     { HCBT_ACTIVATE, hook },
 141     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 142     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 143     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
 144     { WM_ACTIVATEAPP, sent|wparam, 1 },
 145     { WM_NCACTIVATE, sent|wparam, 1 },
 146     { WM_GETTEXT, sent|defwinproc|optional },
 147     { WM_ACTIVATE, sent|wparam, 1 },
 148     { HCBT_SETFOCUS, hook },
 149     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
 150     { WM_IME_NOTIFY, sent|defwinproc|optional },
 151     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 152     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
 153     { WM_NCPAINT, sent|wparam|optional, 1 },
 154     { WM_GETTEXT, sent|defwinproc|optional },
 155     { WM_ERASEBKGND, sent|optional },
 156     /* Win9x adds SWP_NOZORDER below */
 157     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
 158     { WM_NCCALCSIZE, sent|optional },
 159     { WM_NCPAINT, sent|optional },
 160     { WM_ERASEBKGND, sent|optional },
 161 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
 162        * messages. Does that mean that CreateWindow doesn't set initial
 163        * window dimensions for overlapped windows?
 164        */
 165     { WM_SIZE, sent },
 166     { WM_MOVE, sent },
 167 #endif
 168     { 0 }
 169 };
 170 /* ShowWindow(SW_HIDE) for a visible overlapped window */
 171 static const struct message WmHideOverlappedSeq[] = {
 172     { WM_SHOWWINDOW, sent|wparam, 0 },
 173     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 174     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 175     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 176     { WM_SIZE, sent },
 177     { WM_MOVE, sent },
 178     { WM_NCACTIVATE, sent|wparam, 0 },
 179     { WM_ACTIVATE, sent|wparam, 0 },
 180     { WM_ACTIVATEAPP, sent|wparam, 0 },
 181     { WM_KILLFOCUS, sent|wparam, 0 },
 182     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
 183     { WM_IME_NOTIFY, sent|optional|defwinproc },
 184     { 0 }
 185 };
 186 /* ShowWindow(SW_HIDE) for an invisible overlapped window */
 187 static const struct message WmHideInvisibleOverlappedSeq[] = {
 188     { 0 }
 189 };
 190 /* DestroyWindow for a visible overlapped window */
 191 static const struct message WmDestroyOverlappedSeq[] = {
 192     { HCBT_DESTROYWND, hook },
 193     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 194     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 195     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 196     { WM_NCACTIVATE, sent|wparam, 0 },
 197     { WM_ACTIVATE, sent|wparam, 0 },
 198     { WM_ACTIVATEAPP, sent|wparam, 0 },
 199     { WM_KILLFOCUS, sent|wparam, 0 },
 200     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
 201     { WM_IME_NOTIFY, sent|optional|defwinproc },
 202     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
 203     { WM_DESTROY, sent },
 204     { WM_NCDESTROY, sent },
 205     { 0 }
 206 };
 207 /* CreateWindow (for a child popup window, not initially visible) */
 208 static const struct message WmCreateChildPopupSeq[] = {
 209     { HCBT_CREATEWND, hook },
 210     { WM_NCCREATE, sent },
 211     { WM_NCCALCSIZE, sent|wparam, 0 },
 212     { WM_CREATE, sent },
 213     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 214     { WM_SIZE, sent },
 215     { WM_MOVE, sent },
 216     { 0 }
 217 };
 218 /* CreateWindow (for a popup window, not initially visible,
 219  * which sets WS_VISIBLE in WM_CREATE handler)
 220  */
 221 static const struct message WmCreateInvisiblePopupSeq[] = {
 222     { HCBT_CREATEWND, hook },
 223     { WM_NCCREATE, sent },
 224     { WM_NCCALCSIZE, sent|wparam, 0 },
 225     { WM_CREATE, sent },
 226     { WM_STYLECHANGING, sent },
 227     { WM_STYLECHANGED, sent },
 228     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 229     { WM_SIZE, sent },
 230     { WM_MOVE, sent },
 231     { 0 }
 232 };
 233 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
 234  * for a popup window with WS_VISIBLE style set
 235  */
 236 static const struct message WmShowVisiblePopupSeq_2[] = {
 237     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 238     { 0 }
 239 };
 240 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
 241  * for a popup window with WS_VISIBLE style set
 242  */
 243 static const struct message WmShowVisiblePopupSeq_3[] = {
 244     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 245     { HCBT_ACTIVATE, hook },
 246     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 247     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 248     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 249     { WM_NCACTIVATE, sent|wparam, 1 },
 250     { WM_ACTIVATE, sent|wparam, 1 },
 251     { HCBT_SETFOCUS, hook },
 252     { WM_KILLFOCUS, sent|parent },
 253     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
 254     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
 255     { WM_IME_NOTIFY, sent|defwinproc|optional },
 256     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 257     { WM_SETFOCUS, sent|defwinproc },
 258     { 0 }
 259 };
 260 /* CreateWindow (for child window, not initially visible) */
 261 static const struct message WmCreateChildSeq[] = {
 262     { HCBT_CREATEWND, hook },
 263     { WM_NCCREATE, sent },
 264     /* child is inserted into parent's child list after WM_NCCREATE returns */
 265     { WM_NCCALCSIZE, sent|wparam, 0 },
 266     { WM_CREATE, sent },
 267     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 268     { WM_SIZE, sent },
 269     { WM_MOVE, sent },
 270     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
 271     { 0 }
 272 };
 273 /* CreateWindow (for maximized child window, not initially visible) */
 274 static const struct message WmCreateMaximizedChildSeq[] = {
 275     { HCBT_CREATEWND, hook },
 276     { WM_NCCREATE, sent },
 277     { WM_NCCALCSIZE, sent|wparam, 0 },
 278     { WM_CREATE, sent },
 279     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 280     { WM_SIZE, sent },
 281     { WM_MOVE, sent },
 282     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
 283     { WM_GETMINMAXINFO, sent },
 284     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
 285     { WM_NCCALCSIZE, sent|wparam, 1 },
 286     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
 287     { WM_SIZE, sent|defwinproc },
 288     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 289     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
 290     { 0 }
 291 };
 292 /* CreateWindow (for a child window, initially visible) */
 293 static const struct message WmCreateVisibleChildSeq[] = {
 294     { HCBT_CREATEWND, hook },
 295     { WM_NCCREATE, sent },
 296     /* child is inserted into parent's child list after WM_NCCREATE returns */
 297     { WM_NCCALCSIZE, sent|wparam, 0 },
 298     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 299     { WM_CREATE, sent },
 300     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 301     { WM_SIZE, sent },
 302     { WM_MOVE, sent },
 303     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
 304     { WM_SHOWWINDOW, sent|wparam, 1 },
 305     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
 306     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 307     { WM_ERASEBKGND, sent|parent|optional },
 308     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 309     { 0 }
 310 };
 311 /* ShowWindow(SW_SHOW) for a not visible child window */
 312 static const struct message WmShowChildSeq[] = {
 313     { WM_SHOWWINDOW, sent|wparam, 1 },
 314     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 315     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 316     { WM_ERASEBKGND, sent|parent|optional },
 317     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 318     { 0 }
 319 };
 320 /* ShowWindow(SW_HIDE) for a visible child window */
 321 static const struct message WmHideChildSeq[] = {
 322     { WM_SHOWWINDOW, sent|wparam, 0 },
 323     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 324     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 325     { WM_ERASEBKGND, sent|parent|optional },
 326     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 327     { 0 }
 328 };
 329 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
 330  * for a not visible child window
 331  */
 332 static const struct message WmShowChildSeq_2[] = {
 333     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 334     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 335     { WM_CHILDACTIVATE, sent },
 336     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 337     { 0 }
 338 };
 339 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
 340  * for a not visible child window
 341  */
 342 static const struct message WmShowChildSeq_3[] = {
 343     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
 344     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 345     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 346     { 0 }
 347 };
 348 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
 349  * for a visible child window with a caption
 350  */
 351 static const struct message WmShowChildSeq_4[] = {
 352     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 353     { WM_CHILDACTIVATE, sent },
 354     { 0 }
 355 };
 356 /* ShowWindow(SW_SHOW) for child with invisible parent */
 357 static const struct message WmShowChildInvisibleParentSeq[] = {
 358     { WM_SHOWWINDOW, sent|wparam, 1 },
 359     { 0 }
 360 };
 361 /* ShowWindow(SW_HIDE) for child with invisible parent */
 362 static const struct message WmHideChildInvisibleParentSeq[] = {
 363     { WM_SHOWWINDOW, sent|wparam, 0 },
 364     { 0 }
 365 };
 366 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
 367 static const struct message WmShowChildInvisibleParentSeq_2[] = {
 368     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
 369     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 370     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 371     { 0 }
 372 };
 373 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
 374 static const struct message WmHideChildInvisibleParentSeq_2[] = {
 375     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 376     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 377     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 378     { 0 }
 379 };
 380 /* DestroyWindow for a visible child window */
 381 static const struct message WmDestroyChildSeq[] = {
 382     { HCBT_DESTROYWND, hook },
 383     { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
 384     { WM_SHOWWINDOW, sent|wparam, 0 },
 385     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 386     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 387     { WM_ERASEBKGND, sent|parent|optional },
 388     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 389     { HCBT_SETFOCUS, hook }, /* set focus to a parent */
 390     { WM_KILLFOCUS, sent },
 391     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
 392     { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
 393     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 394     { WM_SETFOCUS, sent|parent },
 395     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
 396     { WM_DESTROY, sent },
 397     { WM_DESTROY, sent|optional }, /* some other (IME?) window */
 398     { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
 399     { WM_NCDESTROY, sent },
 400     { 0 }
 401 };
 402 /* Moving the mouse in nonclient area */
 403 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
 404     { WM_NCHITTEST, sent },
 405     { WM_SETCURSOR, sent },
 406     { WM_NCMOUSEMOVE, posted },
 407     { 0 }
 408 };
 409 /* Moving the mouse in client area */
 410 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
 411     { WM_NCHITTEST, sent },
 412     { WM_SETCURSOR, sent },
 413     { WM_MOUSEMOVE, posted },
 414     { 0 }
 415 };
 416 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
 417 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
 418     { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
 419     { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
 420     { WM_GETMINMAXINFO, sent|defwinproc },
 421     { WM_ENTERSIZEMOVE, sent|defwinproc },
 422     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
 423     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
 424     { WM_MOVE, sent|defwinproc },
 425     { WM_EXITSIZEMOVE, sent|defwinproc },
 426     { 0 }
 427 };
 428 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
 429 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
 430     { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
 431     { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
 432     { WM_GETMINMAXINFO, sent|defwinproc },
 433     { WM_ENTERSIZEMOVE, sent|defwinproc },
 434     { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
 435     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
 436     { WM_GETMINMAXINFO, sent|defwinproc },
 437     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
 438     { WM_NCPAINT, sent|defwinproc|wparam, 1 },
 439     { WM_GETTEXT, sent|defwinproc },
 440     { WM_ERASEBKGND, sent|defwinproc },
 441     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
 442     { WM_MOVE, sent|defwinproc },
 443     { WM_SIZE, sent|defwinproc },
 444     { WM_EXITSIZEMOVE, sent|defwinproc },
 445     { 0 }
 446 };
 447 /* Resizing child window with MoveWindow (32) */
 448 static const struct message WmResizingChildWithMoveWindowSeq[] = {
 449     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
 450     { WM_NCCALCSIZE, sent|wparam, 1 },
 451     { WM_ERASEBKGND, sent|optional },
 452     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
 453     { WM_MOVE, sent|defwinproc },
 454     { WM_SIZE, sent|defwinproc },
 455     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 456     { 0 }
 457 };
 458 /* Clicking on inactive button */
 459 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
 460     { WM_NCHITTEST, sent },
 461     { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
 462     { WM_MOUSEACTIVATE, sent },
 463     { WM_MOUSEACTIVATE, sent|parent|defwinproc },
 464     { WM_SETCURSOR, sent },
 465     { WM_SETCURSOR, sent|parent|defwinproc },
 466     { WM_LBUTTONDOWN, posted },
 467     { WM_KILLFOCUS, posted|parent },
 468     { WM_SETFOCUS, posted },
 469     { WM_CTLCOLORBTN, posted|parent },
 470     { BM_SETSTATE, posted },
 471     { WM_CTLCOLORBTN, posted|parent },
 472     { WM_LBUTTONUP, posted },
 473     { BM_SETSTATE, posted },
 474     { WM_CTLCOLORBTN, posted|parent },
 475     { WM_COMMAND, posted|parent },
 476     { 0 }
 477 };
 478 /* Reparenting a button (16/32) */
 479 /* The last child (button) reparented gets topmost for its new parent. */
 480 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
 481     { WM_SHOWWINDOW, sent|wparam, 0 },
 482     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
 483     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 484     { WM_ERASEBKGND, sent|parent },
 485     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
 486     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOZORDER },
 487     { WM_CHILDACTIVATE, sent },
 488     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER },
 489     { WM_MOVE, sent|defwinproc },
 490     { WM_SHOWWINDOW, sent|wparam, 1 },
 491     { 0 }
 492 };
 493 /* Creation of a custom dialog (32) */
 494 static const struct message WmCreateCustomDialogSeq[] = {
 495     { HCBT_CREATEWND, hook },
 496     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 497     { WM_GETMINMAXINFO, sent },
 498     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 499     { WM_NCCREATE, sent },
 500     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 501     { WM_NCCALCSIZE, sent|wparam, 0 },
 502     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 503     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 504     { WM_CREATE, sent },
 505     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 506     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 507     { WM_SHOWWINDOW, sent|wparam, 1 },
 508     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 509     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 510     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 511     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 512     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 513     { HCBT_ACTIVATE, hook },
 514     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 515
 516     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 517     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 518
 519     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 520     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
 521
 522     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 523     { WM_NCACTIVATE, sent|wparam, 1 },
 524     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 525     { WM_GETTEXT, sent|optional|defwinproc },
 526     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 527     { WM_GETICON, sent|optional|defwinproc },
 528     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 529     { WM_GETICON, sent|optional|defwinproc },
 530     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 531     { WM_GETICON, sent|optional|defwinproc },
 532     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 533     { WM_GETTEXT, sent|optional|defwinproc },
 534     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 535     { WM_ACTIVATE, sent|wparam, 1 },
 536     { WM_KILLFOCUS, sent|parent },
 537     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 538     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
 539     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 540     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
 541     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 542     { WM_IME_NOTIFY, sent|optional|defwinproc },
 543     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 544     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 545     { WM_SETFOCUS, sent },
 546     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 547     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
 548     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 549     { WM_NCPAINT, sent|wparam, 1 },
 550     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 551     { WM_GETTEXT, sent|optional|defwinproc },
 552     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 553     { WM_GETICON, sent|optional|defwinproc },
 554     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 555     { WM_GETICON, sent|optional|defwinproc },
 556     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 557     { WM_GETICON, sent|optional|defwinproc },
 558     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 559     { WM_GETTEXT, sent|optional|defwinproc },
 560     { WM_ERASEBKGND, sent },
 561     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 562     { WM_CTLCOLORDLG, sent|defwinproc },
 563     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 564     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 565     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 566     { WM_GETTEXT, sent|optional },
 567     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 568     { WM_GETICON, sent|optional },
 569     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 570     { WM_GETICON, sent|optional },
 571     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 572     { WM_GETICON, sent|optional },
 573     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 574     { WM_GETTEXT, sent|optional },
 575     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 576     { WM_NCCALCSIZE, sent|optional },
 577     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 578     { WM_NCPAINT, sent|optional },
 579     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 580     { WM_GETTEXT, sent|optional|defwinproc },
 581     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 582     { WM_GETICON, sent|optional|defwinproc },
 583     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 584     { WM_GETICON, sent|optional|defwinproc },
 585     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 586     { WM_GETICON, sent|optional|defwinproc },
 587     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 588     { WM_GETTEXT, sent|optional|defwinproc },
 589     { WM_ERASEBKGND, sent|optional },
 590     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 591     { WM_CTLCOLORDLG, sent|optional|defwinproc },
 592     { WM_SIZE, sent },
 593     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 594     { WM_MOVE, sent },
 595     { 0 }
 596 };
 597 /* Calling EndDialog for a custom dialog (32) */
 598 static const struct message WmEndCustomDialogSeq[] = {
 599     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 600     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 601     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 602     { WM_GETTEXT, sent|optional },
 603     { WM_GETICON, sent|optional },
 604     { WM_GETICON, sent|optional },
 605     { WM_GETICON, sent|optional },
 606     { HCBT_ACTIVATE, hook },
 607     { WM_NCACTIVATE, sent|wparam, 0 },
 608     { WM_GETTEXT, sent|optional|defwinproc },
 609     { WM_GETICON, sent|optional|defwinproc },
 610     { WM_GETICON, sent|optional|defwinproc },
 611     { WM_GETICON, sent|optional|defwinproc },
 612     { WM_GETTEXT, sent|optional|defwinproc },
 613     { WM_ACTIVATE, sent|wparam, 0 },
 614     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 615     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
 616     { HCBT_SETFOCUS, hook },
 617     { WM_KILLFOCUS, sent },
 618     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
 619     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
 620     { WM_IME_NOTIFY, sent|optional },
 621     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 622     { WM_SETFOCUS, sent|parent|defwinproc },
 623     { 0 }
 624 };
 625 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
 626 static const struct message WmShowCustomDialogSeq[] = {
 627     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 628     { WM_SHOWWINDOW, sent|wparam, 1 },
 629     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 630     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
 631     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 632     { HCBT_ACTIVATE, hook },
 633     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 634
 635     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 636     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 637
 638     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 639     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
 640     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 641     { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
 642     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 643     { WM_NCACTIVATE, sent|wparam, 1 },
 644     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 645     { WM_ACTIVATE, sent|wparam, 1 },
 646
 647     { WM_KILLFOCUS, sent|parent },
 648     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
 649     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 650     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
 651     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 652     { WM_IME_NOTIFY, sent|optional|defwinproc },
 653     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
 654     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 655     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 656     { WM_SETFOCUS, sent },
 657     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 658     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
 659     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 660     { WM_NCPAINT, sent|wparam, 1 },
 661     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 662     { WM_ERASEBKGND, sent },
 663     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 664     { WM_CTLCOLORDLG, sent|defwinproc },
 665
 666     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 667     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 668     { 0 }
 669 };
 670 /* Creation and destruction of a modal dialog (32) */
 671 static const struct message WmModalDialogSeq[] = {
 672     { WM_CANCELMODE, sent|parent },
 673     { HCBT_SETFOCUS, hook },
 674     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 675     { WM_KILLFOCUS, sent|parent },
 676     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
 677     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
 678     { WM_ENABLE, sent|parent|wparam, 0 },
 679     { HCBT_CREATEWND, hook },
 680     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 681     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
 682     { WM_SETFONT, sent },
 683     { WM_INITDIALOG, sent },
 684     { WM_CHANGEUISTATE, sent|optional },
 685     { WM_SHOWWINDOW, sent },
 686     { HCBT_ACTIVATE, hook },
 687     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 688     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
 689     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
 690     { WM_NCACTIVATE, sent|wparam, 1 },
 691     { WM_GETICON, sent|optional },
 692     { WM_GETICON, sent|optional },
 693     { WM_GETICON, sent|optional },
 694     { WM_GETTEXT, sent|optional },
 695     { WM_ACTIVATE, sent|wparam, 1 },
 696     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
 697     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
 698     { WM_NCPAINT, sent },
 699     { WM_GETICON, sent|optional },
 700     { WM_GETICON, sent|optional },
 701     { WM_GETICON, sent|optional },
 702     { WM_GETTEXT, sent|optional },
 703     { WM_ERASEBKGND, sent },
 704     { WM_CTLCOLORDLG, sent },
 705     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 706     { WM_GETICON, sent|optional },
 707     { WM_GETICON, sent|optional },
 708     { WM_GETICON, sent|optional },
 709     { WM_GETTEXT, sent|optional },
 710     { WM_NCCALCSIZE, sent|optional },
 711     { WM_NCPAINT, sent|optional },
 712     { WM_GETICON, sent|optional },
 713     { WM_GETICON, sent|optional },
 714     { WM_GETICON, sent|optional },
 715     { WM_GETTEXT, sent|optional },
 716     { WM_ERASEBKGND, sent|optional },
 717     { WM_CTLCOLORDLG, sent|optional },
 718     { WM_PAINT, sent|optional },
 719     { WM_CTLCOLORBTN, sent },
 720     { WM_ENTERIDLE, sent|parent|optional },
 721     { WM_TIMER, sent },
 722     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
 723     { WM_ENABLE, sent|parent|wparam, 1 },
 724     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
 725     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
 726     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 727     { WM_GETICON, sent|optional },
 728     { WM_GETICON, sent|optional },
 729     { WM_GETICON, sent|optional },
 730     { WM_GETTEXT, sent|optional },
 731     { HCBT_ACTIVATE, hook },
 732     { WM_NCACTIVATE, sent|wparam, 0 },
 733     { WM_GETICON, sent|optional },
 734     { WM_GETICON, sent|optional },
 735     { WM_GETICON, sent|optional },
 736     { WM_GETTEXT, sent|optional },
 737     { WM_ACTIVATE, sent|wparam, 0 },
 738     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
 739     { WM_WINDOWPOSCHANGING, sent|optional },
 740     { HCBT_SETFOCUS, hook },
 741     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
 742     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
 743     { WM_SETFOCUS, sent|parent|defwinproc },
 744     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
 745     { HCBT_DESTROYWND, hook },
 746     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
 747     { WM_DESTROY, sent },
 748     { WM_NCDESTROY, sent },
 749     { 0 }
 750 };
 751 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
 752 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
 753     /* (inside dialog proc, handling WM_INITDIALOG) */
 754     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 755     { WM_NCCALCSIZE, sent },
 756     { WM_NCACTIVATE, sent|parent|wparam, 0 },
 757     { WM_GETTEXT, sent|defwinproc },
 758     { WM_ACTIVATE, sent|parent|wparam, 0 },
 759     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 760     { WM_WINDOWPOSCHANGING, sent|parent },
 761     { WM_NCACTIVATE, sent|wparam, 1 },
 762     { WM_ACTIVATE, sent|wparam, 1 },
 763     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
 764     { WM_SIZE, sent|defwinproc },
 765     /* (setting focus) */
 766     { WM_SHOWWINDOW, sent|wparam, 1 },
 767     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 768     { WM_NCPAINT, sent },
 769     { WM_GETTEXT, sent|defwinproc },
 770     { WM_ERASEBKGND, sent },
 771     { WM_CTLCOLORDLG, sent|defwinproc },
 772     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
 773     { WM_PAINT, sent },
 774     /* (bunch of WM_CTLCOLOR* for each control) */
 775     { WM_PAINT, sent|parent },
 776     { WM_ENTERIDLE, sent|parent|wparam, 0 },
 777     { WM_SETCURSOR, sent|parent },
 778     { 0 }
 779 };
 780 /* SetMenu for NonVisible windows with size change*/
 781 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
 782     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 783     { WM_NCCALCSIZE, sent|wparam, 1 },
 784     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 785     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW },
 786     { WM_MOVE, sent|defwinproc },
 787     { WM_SIZE, sent|defwinproc },
 788     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 789     { WM_GETICON, sent|optional },
 790     { WM_GETICON, sent|optional },
 791     { WM_GETICON, sent|optional },
 792     { WM_GETTEXT, sent|optional },
 793     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
 794     { 0 }
 795 };
 796 /* SetMenu for NonVisible windows with no size change */
 797 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
 798     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 799     { WM_NCCALCSIZE, sent|wparam, 1 },
 800     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 801     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 802     { 0 }
 803 };
 804 /* SetMenu for Visible windows with size change */
 805 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
 806     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 807     { WM_NCCALCSIZE, sent|wparam, 1 },
 808     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 809     { WM_NCPAINT, sent|wparam, 1 },
 810     { WM_GETTEXT, sent|defwinproc|optional },
 811     { WM_ERASEBKGND, sent|optional },
 812     { WM_ACTIVATE, sent|optional },
 813     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 814     { WM_MOVE, sent|defwinproc },
 815     { WM_SIZE, sent|defwinproc },
 816     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 817     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
 818     { WM_NCPAINT, sent|wparam|optional, 1 },
 819     { WM_ERASEBKGND, sent|optional },
 820     { 0 }
 821 };
 822 /* SetMenu for Visible windows with no size change */
 823 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
 824     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 825     { WM_NCCALCSIZE, sent|wparam, 1 },
 826     { WM_NCPAINT, sent|wparam, 1 },
 827     { WM_GETTEXT, sent|defwinproc|optional },
 828     { WM_ERASEBKGND, sent|optional },
 829     { WM_ACTIVATE, sent|optional },
 830     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 831     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 832     { 0 }
 833 };
 834 /* DrawMenuBar for a visible window */
 835 static const struct message WmDrawMenuBarSeq[] =
 836 {
 837     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
 838     { WM_NCCALCSIZE, sent|wparam, 1 },
 839     { WM_NCPAINT, sent|wparam, 1 },
 840     { WM_GETTEXT, sent|defwinproc|optional },
 841     { WM_ERASEBKGND, sent|optional },
 842     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 843     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 844     { 0 }
 845 };
 846
 847 static const struct message WmSetRedrawFalseSeq[] =
 848 {
 849     { WM_SETREDRAW, sent|wparam, 0 },
 850     { 0 }
 851 };
 852
 853 static const struct message WmSetRedrawTrueSeq[] =
 854 {
 855     { WM_SETREDRAW, sent|wparam, 1 },
 856     { 0 }
 857 };
 858
 859 static const struct message WmEnableWindowSeq[] =
 860 {
 861     { WM_CANCELMODE, sent },
 862     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
 863     { WM_ENABLE, sent },
 864     { 0 }
 865 };
 866
 867 static const struct message WmGetScrollRangeSeq[] =
 868 {
 869     { SBM_GETRANGE, sent },
 870     { 0 }
 871 };
 872 static const struct message WmGetScrollInfoSeq[] =
 873 {
 874     { SBM_GETSCROLLINFO, sent },
 875     { 0 }
 876 };
 877 static const struct message WmSetScrollRangeSeq[] =
 878 {
 879     /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
 880        sends SBM_SETSCROLLINFO.
 881      */
 882     { SBM_SETSCROLLINFO, sent },
 883     { 0 }
 884 };
 885 /* SetScrollRange for a window without a non-client area */
 886 static const struct message WmSetScrollRangeHSeq_empty[] =
 887 {
 888     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
 889     { 0 }
 890 };
 891 static const struct message WmSetScrollRangeVSeq_empty[] =
 892 {
 893     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
 894     { 0 }
 895 };
 896 static const struct message WmSetScrollRangeHVSeq[] =
 897 {
 898     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
 899     { WM_NCCALCSIZE, sent|wparam, 1 },
 900     { WM_GETTEXT, sent|defwinproc|optional },
 901     { WM_ERASEBKGND, sent|optional },
 902     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
 903     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 904     { 0 }
 905 };
 906 /* SetScrollRange for a window with a non-client area */
 907 static const struct message WmSetScrollRangeHV_NC_Seq[] =
 908 {
 909     { WM_WINDOWPOSCHANGING, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER*/ },
 910     { WM_NCCALCSIZE, sent|wparam, 1 },
 911     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
 912     { WM_NCPAINT, sent|optional },
 913     { WM_GETTEXT, sent|defwinproc|optional },
 914     { WM_GETICON, sent|optional|defwinproc },
 915     { WM_GETICON, sent|optional|defwinproc },
 916     { WM_GETICON, sent|optional|defwinproc },
 917     { WM_GETTEXT, sent|defwinproc|optional },
 918     { WM_ERASEBKGND, sent|optional },
 919     { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
 920     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|0x1000*/ },
 921     { WM_SIZE, sent|defwinproc },
 922     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
 923     { WM_GETTEXT, sent|optional },
 924     { WM_GETICON, sent|optional },
 925     { WM_GETICON, sent|optional },
 926     { WM_GETICON, sent|optional },
 927     { WM_GETTEXT, sent|optional },
 928     { WM_GETICON, sent|optional },
 929     { WM_GETICON, sent|optional },
 930     { WM_GETICON, sent|optional },
 931     { WM_GETTEXT, sent|optional },
 932     { WM_GETICON, sent|optional },
 933     { WM_GETICON, sent|optional },
 934     { WM_GETICON, sent|optional },
 935     { WM_GETTEXT, sent|optional },
 936     { 0 }
 937 };
 938
 939 static int after_end_dialog;
 940 static int sequence_cnt, sequence_size;
 941 static struct message* sequence;
 942 static int log_all_parent_messages;
 943
 944 static void add_message(const struct message *msg)
 945 {
 946     if (!sequence)
 947     {
 948         sequence_size = 10;
 949         sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
 950     }
 951     if (sequence_cnt == sequence_size)
 952     {
 953         sequence_size *= 2;
 954         sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
 955     }
 956     assert(sequence);
 957
 958     sequence[sequence_cnt].message = msg->message;
 959     sequence[sequence_cnt].flags = msg->flags;
 960     sequence[sequence_cnt].wParam = msg->wParam;
 961     sequence[sequence_cnt].lParam = msg->lParam;
 962
 963     sequence_cnt++;
 964 }
 965
 966 static void flush_sequence()
 967 {
 968     HeapFree(GetProcessHeap(), 0, sequence);
 969     sequence = 0;
 970     sequence_cnt = sequence_size = 0;
 971 }
 972
 973 #define ok_sequence( exp, contx, todo) \
 974         ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
 975
 976
 977 static void ok_sequence_(const struct message *expected, const char *context, int todo,
 978         const char *file, int line)
 979 {
 980     static const struct message end_of_sequence = { 0, 0, 0, 0 };
 981     const struct message *actual;
 982     int failcount = 0;
 983
 984     add_message(&end_of_sequence);
 985
 986     actual = sequence;
 987
 988     while (expected->message && actual->message)
 989     {
 990         trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
 991
 992         if (expected->message == actual->message)
 993         {
 994             if (expected->flags & wparam)
 995             {
 996                 if (expected->wParam != actual->wParam && todo)
 997                 {
 998                     todo_wine {
 999                         failcount ++;
1000                         ok_( file, line) (FALSE,
1001                             "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1002                             context, expected->message, expected->wParam, actual->wParam);
1003                     }
1004                 }
1005                 else
1006                 ok_( file, line) (expected->wParam == actual->wParam,
1007                      "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1008                      context, expected->message, expected->wParam, actual->wParam);
1009             }
1010             if (expected->flags & lparam)
1011                  ok_( file, line) (expected->lParam == actual->lParam,
1012                      "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1013                      context, expected->message, expected->lParam, actual->lParam);
1014             ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
1015                 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1016                 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1017             ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
1018                 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
1019                 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
1020             ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
1021                 "%s: the msg 0x%04x should have been %s\n",
1022                 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
1023             ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
1024                 "%s: the msg 0x%04x was expected in %s\n",
1025                 context, expected->message, (expected->flags & parent) ? "parent" : "child");
1026             ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
1027                 "%s: the msg 0x%04x should have been sent by a hook\n",
1028                 context, expected->message);
1029             ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
1030                 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
1031                 context, expected->message);
1032             expected++;
1033             actual++;
1034         }
1035         /* silently drop winevent messages if there is no support for them */
1036         else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
1037             expected++;
1038         else if (todo)
1039         {
1040             failcount++;
1041             todo_wine {
1042                 ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1043                     context, expected->message, actual->message);
1044             }
1045             flush_sequence();
1046             return;
1047         }
1048         else
1049         {
1050             ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1051                 context, expected->message, actual->message);
1052             expected++;
1053             actual++;
1054         }
1055     }
1056
1057     /* skip all optional trailing messages */
1058     while (expected->message && ((expected->flags & optional) ||
1059             ((expected->flags & winevent_hook) && !hEvent_hook)))
1060         expected++;
1061
1062     if (todo)
1063     {
1064         todo_wine {
1065             if (expected->message || actual->message) {
1066                 failcount++;
1067                 ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1068                     context, expected->message, actual->message);
1069             }
1070         }
1071     }
1072     else
1073     {
1074         if (expected->message || actual->message)
1075             ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1076                 context, expected->message, actual->message);
1077     }
1078     if( todo && !failcount) /* succeeded yet marked todo */
1079         todo_wine {
1080             ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
1081         }
1082
1083     flush_sequence();
1084 }
1085
1086 /******************************** MDI test **********************************/
1087
1088 /* CreateWindow for MDI frame window, initially visible */
1089 static const struct message WmCreateMDIframeSeq[] = {
1090     { HCBT_CREATEWND, hook },
1091     { WM_GETMINMAXINFO, sent },
1092     { WM_NCCREATE, sent },
1093     { WM_NCCALCSIZE, sent|wparam, 0 },
1094     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1095     { WM_CREATE, sent },
1096     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1097     { WM_SHOWWINDOW, sent|wparam, 1 },
1098     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1099     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1100     { HCBT_ACTIVATE, hook },
1101     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1102     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1103     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1104     { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* Win9x */
1105     { WM_ACTIVATEAPP, sent|wparam, 1 },
1106     { WM_NCACTIVATE, sent|wparam, 1 },
1107     { WM_ACTIVATE, sent|wparam, 1 },
1108     { HCBT_SETFOCUS, hook },
1109     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1110     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1111     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
1112     /* Win9x adds SWP_NOZORDER below */
1113     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
1114     { WM_SIZE, sent },
1115     { WM_MOVE, sent },
1116     { 0 }
1117 };
1118 /* DestroyWindow for MDI frame window, initially visible */
1119 static const struct message WmDestroyMDIframeSeq[] = {
1120     { HCBT_DESTROYWND, hook },
1121     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1122     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1123     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1124     { WM_NCACTIVATE, sent|wparam, 0 },
1125     { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1126     { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
1127     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
1128     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1129     { WM_DESTROY, sent },
1130     { WM_NCDESTROY, sent },
1131     { 0 }
1132 };
1133 /* CreateWindow for MDI client window, initially visible */
1134 static const struct message WmCreateMDIclientSeq[] = {
1135     { HCBT_CREATEWND, hook },
1136     { WM_NCCREATE, sent },
1137     { WM_NCCALCSIZE, sent|wparam, 0 },
1138     { WM_CREATE, sent },
1139     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1140     { WM_SIZE, sent },
1141     { WM_MOVE, sent },
1142     { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
1143     { WM_SHOWWINDOW, sent|wparam, 1 },
1144     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE },
1145     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1146     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1147     { 0 }
1148 };
1149 /* DestroyWindow for MDI client window, initially visible */
1150 static const struct message WmDestroyMDIclientSeq[] = {
1151     { HCBT_DESTROYWND, hook },
1152     { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
1153     { WM_SHOWWINDOW, sent|wparam, 0 },
1154     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1155     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1156     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1157     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1158     { WM_DESTROY, sent },
1159     { WM_NCDESTROY, sent },
1160     { 0 }
1161 };
1162 /* CreateWindow for MDI child window, initially visible */
1163 static const struct message WmCreateMDIchildVisibleSeq[] = {
1164     { HCBT_CREATEWND, hook },
1165     { WM_NCCREATE, sent },
1166     { WM_NCCALCSIZE, sent|wparam, 0 },
1167     { WM_CREATE, sent },
1168     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1169     { WM_SIZE, sent },
1170     { WM_MOVE, sent },
1171     /* Win2k sends wparam set to
1172      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1173      * while Win9x doesn't bother to set child window id according to
1174      * CLIENTCREATESTRUCT.idFirstChild
1175      */
1176     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1177     { WM_SHOWWINDOW, sent|wparam, 1 },
1178     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1179     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1180     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1181     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1182     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1183     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1184     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1185
1186     /* Win9x: message sequence terminates here. */
1187
1188     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1189     { HCBT_SETFOCUS, hook }, /* in MDI client */
1190     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1191     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1192     { WM_SETFOCUS, sent }, /* in MDI client */
1193     { HCBT_SETFOCUS, hook },
1194     { WM_KILLFOCUS, sent }, /* in MDI client */
1195     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1196     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1197     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1198     { WM_SETFOCUS, sent|defwinproc },
1199     { WM_MDIACTIVATE, sent|defwinproc },
1200     { 0 }
1201 };
1202 /* DestroyWindow for MDI child window, initially visible */
1203 static const struct message WmDestroyMDIchildVisibleSeq[] = {
1204     { HCBT_DESTROYWND, hook },
1205     /* Win2k sends wparam set to
1206      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1207      * while Win9x doesn't bother to set child window id according to
1208      * CLIENTCREATESTRUCT.idFirstChild
1209      */
1210     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1211     { WM_SHOWWINDOW, sent|wparam, 0 },
1212     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1213     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1214     { WM_ERASEBKGND, sent|parent|optional },
1215     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1216
1217     /* { WM_DESTROY, sent }
1218      * Win9x: message sequence terminates here.
1219      */
1220
1221     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1222     { WM_KILLFOCUS, sent },
1223     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1224     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1225     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1226     { WM_SETFOCUS, sent }, /* in MDI client */
1227
1228     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1229     { WM_KILLFOCUS, sent }, /* in MDI client */
1230     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1231     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1232     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1233     { WM_SETFOCUS, sent }, /* in MDI client */
1234
1235     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1236
1237     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1238     { WM_KILLFOCUS, sent },
1239     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1240     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1241     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1242     { WM_SETFOCUS, sent }, /* in MDI client */
1243
1244     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1245     { WM_KILLFOCUS, sent }, /* in MDI client */
1246     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1247     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1248     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1249     { WM_SETFOCUS, sent }, /* in MDI client */
1250
1251     { WM_DESTROY, sent },
1252
1253     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1254     { WM_KILLFOCUS, sent },
1255     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1256     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1257     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1258     { WM_SETFOCUS, sent }, /* in MDI client */
1259
1260     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1261     { WM_KILLFOCUS, sent }, /* in MDI client */
1262     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1263     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1264     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1265     { WM_SETFOCUS, sent }, /* in MDI client */
1266
1267     { WM_NCDESTROY, sent },
1268     { 0 }
1269 };
1270 /* CreateWindow for MDI child window, initially invisible */
1271 static const struct message WmCreateMDIchildInvisibleSeq[] = {
1272     { HCBT_CREATEWND, hook },
1273     { WM_NCCREATE, sent },
1274     { WM_NCCALCSIZE, sent|wparam, 0 },
1275     { WM_CREATE, sent },
1276     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1277     { WM_SIZE, sent },
1278     { WM_MOVE, sent },
1279     /* Win2k sends wparam set to
1280      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1281      * while Win9x doesn't bother to set child window id according to
1282      * CLIENTCREATESTRUCT.idFirstChild
1283      */
1284     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1285     { 0 }
1286 };
1287 /* DestroyWindow for MDI child window, initially invisible */
1288 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
1289     { HCBT_DESTROYWND, hook },
1290     /* Win2k sends wparam set to
1291      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1292      * while Win9x doesn't bother to set child window id according to
1293      * CLIENTCREATESTRUCT.idFirstChild
1294      */
1295     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1296     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1297     { WM_DESTROY, sent },
1298     { WM_NCDESTROY, sent },
1299     { 0 }
1300 };
1301 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
1302 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
1303     { HCBT_CREATEWND, hook },
1304     { WM_NCCREATE, sent },
1305     { WM_NCCALCSIZE, sent|wparam, 0 },
1306     { WM_CREATE, sent },
1307     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1308     { WM_SIZE, sent },
1309     { WM_MOVE, sent },
1310     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1311     { WM_GETMINMAXINFO, sent },
1312     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1313     { WM_NCCALCSIZE, sent|wparam, 1 },
1314     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1315     { WM_SIZE, sent|defwinproc },
1316      /* in MDI frame */
1317     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1318     { WM_NCCALCSIZE, sent|wparam, 1 },
1319     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1320     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1321     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1322     /* Win2k sends wparam set to
1323      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1324      * while Win9x doesn't bother to set child window id according to
1325      * CLIENTCREATESTRUCT.idFirstChild
1326      */
1327     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1328     { WM_SHOWWINDOW, sent|wparam, 1 },
1329     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1330     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1331     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1332     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1333     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1334     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1335     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1336
1337     /* Win9x: message sequence terminates here. */
1338
1339     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1340     { HCBT_SETFOCUS, hook }, /* in MDI client */
1341     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1342     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1343     { WM_SETFOCUS, sent }, /* in MDI client */
1344     { HCBT_SETFOCUS, hook },
1345     { WM_KILLFOCUS, sent }, /* in MDI client */
1346     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1347     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1348     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1349     { WM_SETFOCUS, sent|defwinproc },
1350     { WM_MDIACTIVATE, sent|defwinproc },
1351      /* in MDI frame */
1352     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1353     { WM_NCCALCSIZE, sent|wparam, 1 },
1354     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1355     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1356     { 0 }
1357 };
1358 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
1359 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
1360     /* restore the 1st MDI child */
1361     { WM_SETREDRAW, sent|wparam, 0 },
1362     { HCBT_MINMAX, hook },
1363     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1364     { WM_NCCALCSIZE, sent|wparam, 1 },
1365     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1366     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1367     { WM_SIZE, sent|defwinproc },
1368      /* in MDI frame */
1369     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1370     { WM_NCCALCSIZE, sent|wparam, 1 },
1371     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1372     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1373     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1374     { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
1375     /* create the 2nd MDI child */
1376     { HCBT_CREATEWND, hook },
1377     { WM_NCCREATE, sent },
1378     { WM_NCCALCSIZE, sent|wparam, 0 },
1379     { WM_CREATE, sent },
1380     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1381     { WM_SIZE, sent },
1382     { WM_MOVE, sent },
1383     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1384     { WM_GETMINMAXINFO, sent },
1385     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1386     { WM_NCCALCSIZE, sent|wparam, 1 },
1387     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1388     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1389     { WM_SIZE, sent|defwinproc },
1390      /* in MDI frame */
1391     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1392     { WM_NCCALCSIZE, sent|wparam, 1 },
1393     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1394     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1395     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1396     /* Win2k sends wparam set to
1397      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1398      * while Win9x doesn't bother to set child window id according to
1399      * CLIENTCREATESTRUCT.idFirstChild
1400      */
1401     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1402     { WM_SHOWWINDOW, sent|wparam, 1 },
1403     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1404     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1405     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1406     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1407     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1408     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1409
1410     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1411     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1412
1413     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1414
1415     /* Win9x: message sequence terminates here. */
1416
1417     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1418     { HCBT_SETFOCUS, hook },
1419     { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
1420     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
1421     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1422     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1423     { WM_SETFOCUS, sent }, /* in MDI client */
1424     { HCBT_SETFOCUS, hook },
1425     { WM_KILLFOCUS, sent }, /* in MDI client */
1426     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1427     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1428     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1429     { WM_SETFOCUS, sent|defwinproc },
1430
1431     { WM_MDIACTIVATE, sent|defwinproc },
1432      /* in MDI frame */
1433     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1434     { WM_NCCALCSIZE, sent|wparam, 1 },
1435     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1436     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1437     { 0 }
1438 };
1439 /* WM_MDICREATE MDI child window, initially visible and maximized */
1440 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
1441     { WM_MDICREATE, sent },
1442     { HCBT_CREATEWND, hook },
1443     { WM_NCCREATE, sent },
1444     { WM_NCCALCSIZE, sent|wparam, 0 },
1445     { WM_CREATE, sent },
1446     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1447     { WM_SIZE, sent },
1448     { WM_MOVE, sent },
1449     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1450     { WM_GETMINMAXINFO, sent },
1451     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1452     { WM_NCCALCSIZE, sent|wparam, 1 },
1453     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1454     { WM_SIZE, sent|defwinproc },
1455
1456      /* in MDI frame */
1457     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1458     { WM_NCCALCSIZE, sent|wparam, 1 },
1459     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1460     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1461     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1462
1463     /* Win2k sends wparam set to
1464      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1465      * while Win9x doesn't bother to set child window id according to
1466      * CLIENTCREATESTRUCT.idFirstChild
1467      */
1468     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1469     { WM_SHOWWINDOW, sent|wparam, 1 },
1470     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1471
1472     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1473
1474     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1475     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1476     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1477
1478     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1479     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1480
1481     /* Win9x: message sequence terminates here. */
1482
1483     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1484     { HCBT_SETFOCUS, hook }, /* in MDI client */
1485     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1486     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1487     { WM_SETFOCUS, sent }, /* in MDI client */
1488     { HCBT_SETFOCUS, hook },
1489     { WM_KILLFOCUS, sent }, /* in MDI client */
1490     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1491     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1492     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1493     { WM_SETFOCUS, sent|defwinproc },
1494
1495     { WM_MDIACTIVATE, sent|defwinproc },
1496
1497      /* in MDI child */
1498     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1499     { WM_NCCALCSIZE, sent|wparam, 1 },
1500     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1501     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1502
1503      /* in MDI frame */
1504     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1505     { WM_NCCALCSIZE, sent|wparam, 1 },
1506     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1507     { WM_MOVE, sent|defwinproc },
1508     { WM_SIZE, sent|defwinproc },
1509
1510      /* in MDI client */
1511     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1512     { WM_NCCALCSIZE, sent|wparam, 1 },
1513     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1514     { WM_SIZE, sent },
1515
1516      /* in MDI child */
1517     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1518     { WM_NCCALCSIZE, sent|wparam, 1 },
1519     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1520     { WM_SIZE, sent|defwinproc },
1521
1522     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1523     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
1524     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1525
1526     { 0 }
1527 };
1528 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
1529 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
1530     { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
1531     { HCBT_SYSCOMMAND, hook },
1532     { WM_CLOSE, sent|defwinproc },
1533     { WM_MDIDESTROY, sent }, /* in MDI client */
1534
1535     /* bring the 1st MDI child to top */
1536     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
1537     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
1538
1539     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1540
1541     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
1542     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1543     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1544
1545     /* maximize the 1st MDI child */
1546     { HCBT_MINMAX, hook },
1547     { WM_GETMINMAXINFO, sent|defwinproc },
1548     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|0x8000 },
1549     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1550     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
1551     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1552     { WM_SIZE, sent|defwinproc },
1553
1554     /* restore the 2nd MDI child */
1555     { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
1556     { HCBT_MINMAX, hook },
1557     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOZORDER|0x8000 },
1558     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1559
1560     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1561
1562     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1563     { WM_SIZE, sent|defwinproc },
1564
1565     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1566
1567     { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
1568      /* in MDI frame */
1569     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1570     { WM_NCCALCSIZE, sent|wparam, 1 },
1571     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1572     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1573     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1574
1575     /* bring the 1st MDI child to top */
1576     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1577     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1578     { HCBT_SETFOCUS, hook },
1579     { WM_KILLFOCUS, sent|defwinproc },
1580     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
1581     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1582     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1583     { WM_SETFOCUS, sent }, /* in MDI client */
1584     { HCBT_SETFOCUS, hook },
1585     { WM_KILLFOCUS, sent }, /* in MDI client */
1586     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1587     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1588     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1589     { WM_SETFOCUS, sent|defwinproc },
1590     { WM_MDIACTIVATE, sent|defwinproc },
1591     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1592
1593     /* apparently ShowWindow(SW_SHOW) on an MDI client */
1594     { WM_SHOWWINDOW, sent|wparam, 1 },
1595     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1596     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1597     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1598     { WM_MDIREFRESHMENU, sent },
1599
1600     { HCBT_DESTROYWND, hook },
1601     /* Win2k sends wparam set to
1602      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1603      * while Win9x doesn't bother to set child window id according to
1604      * CLIENTCREATESTRUCT.idFirstChild
1605      */
1606     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1607     { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
1608     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1609     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1610     { WM_ERASEBKGND, sent|parent|optional },
1611     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1612
1613     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1614     { WM_DESTROY, sent|defwinproc },
1615     { WM_NCDESTROY, sent|defwinproc },
1616     { 0 }
1617 };
1618 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
1619 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
1620     { WM_MDIDESTROY, sent }, /* in MDI client */
1621     { WM_SHOWWINDOW, sent|wparam, 0 },
1622     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1623     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1624     { WM_ERASEBKGND, sent|parent|optional },
1625     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1626
1627     { HCBT_SETFOCUS, hook },
1628     { WM_KILLFOCUS, sent },
1629     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1630     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1631     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1632     { WM_SETFOCUS, sent }, /* in MDI client */
1633     { HCBT_SETFOCUS, hook },
1634     { WM_KILLFOCUS, sent }, /* in MDI client */
1635     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1636     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1637     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1638     { WM_SETFOCUS, sent },
1639
1640      /* in MDI child */
1641     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1642     { WM_NCCALCSIZE, sent|wparam, 1 },
1643     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1644     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1645
1646      /* in MDI frame */
1647     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1648     { WM_NCCALCSIZE, sent|wparam, 1 },
1649     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1650     { WM_MOVE, sent|defwinproc },
1651     { WM_SIZE, sent|defwinproc },
1652
1653      /* in MDI client */
1654     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1655     { WM_NCCALCSIZE, sent|wparam, 1 },
1656     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1657     { WM_SIZE, sent },
1658
1659      /* in MDI child */
1660     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1661     { WM_NCCALCSIZE, sent|wparam, 1 },
1662     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
1663     { WM_SIZE, sent|defwinproc },
1664
1665      /* in MDI child */
1666     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1667     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1668     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1669     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1670
1671      /* in MDI frame */
1672     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1673     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1674     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1675     { WM_MOVE, sent|defwinproc },
1676     { WM_SIZE, sent|defwinproc },
1677
1678      /* in MDI client */
1679     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1680     { WM_NCCALCSIZE, sent|wparam, 1 },
1681     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1682     { WM_SIZE, sent },
1683
1684      /* in MDI child */
1685     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOZORDER },
1686     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1687     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
1688     { WM_SIZE, sent|defwinproc },
1689     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1690     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
1691     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1692     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1693     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
1694     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1695
1696      /* in MDI frame */
1697     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1698     { WM_NCCALCSIZE, sent|wparam, 1 },
1699     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1700     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1701
1702     { WM_NCACTIVATE, sent|wparam, 0 },
1703     { WM_MDIACTIVATE, sent },
1704
1705     { HCBT_MINMAX, hook },
1706     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
1707     { WM_NCCALCSIZE, sent|wparam, 1 },
1708
1709     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1710
1711     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1712     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE|0x8000 },
1713     { WM_SIZE, sent|defwinproc },
1714
1715      /* in MDI child */
1716     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1717     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1718     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1719     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1720
1721      /* in MDI frame */
1722     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1723     { WM_NCCALCSIZE, sent|wparam, 1 },
1724     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1725     { WM_MOVE, sent|defwinproc },
1726     { WM_SIZE, sent|defwinproc },
1727
1728      /* in MDI client */
1729     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1730     { WM_NCCALCSIZE, sent|wparam, 1 },
1731     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1732     { WM_SIZE, sent },
1733     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1734     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
1735     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1736
1737     { HCBT_SETFOCUS, hook },
1738     { WM_KILLFOCUS, sent },
1739     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1740     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1741     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1742     { WM_SETFOCUS, sent }, /* in MDI client */
1743
1744     { WM_MDIREFRESHMENU, sent }, /* in MDI client */
1745
1746     { HCBT_DESTROYWND, hook },
1747     /* Win2k sends wparam set to
1748      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1749      * while Win9x doesn't bother to set child window id according to
1750      * CLIENTCREATESTRUCT.idFirstChild
1751      */
1752     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1753
1754     { WM_SHOWWINDOW, sent|wparam, 0 },
1755     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1756     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1757     { WM_ERASEBKGND, sent|parent|optional },
1758     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1759
1760     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1761     { WM_DESTROY, sent },
1762     { WM_NCDESTROY, sent },
1763     { 0 }
1764 };
1765 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
1766 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
1767     { HCBT_MINMAX, hook },
1768     { WM_GETMINMAXINFO, sent },
1769     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
1770     { WM_NCCALCSIZE, sent|wparam, 1 },
1771     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1772     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1773
1774     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1775     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1776     { HCBT_SETFOCUS, hook },
1777     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1778     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1779     { WM_SETFOCUS, sent }, /* in MDI client */
1780     { HCBT_SETFOCUS, hook },
1781     { WM_KILLFOCUS, sent }, /* in MDI client */
1782     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1783     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1784     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1785     { WM_SETFOCUS, sent|defwinproc },
1786     { WM_MDIACTIVATE, sent|defwinproc },
1787     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1788     { WM_SIZE, sent|defwinproc },
1789      /* in MDI frame */
1790     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1791     { WM_NCCALCSIZE, sent|wparam, 1 },
1792     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1793     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1794     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1795     { 0 }
1796 };
1797 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
1798 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
1799     { HCBT_MINMAX, hook },
1800     { WM_GETMINMAXINFO, sent },
1801     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1802     { WM_NCCALCSIZE, sent|wparam, 1 },
1803     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1804     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1805     { WM_SIZE, sent|defwinproc },
1806      /* in MDI frame */
1807     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1808     { WM_NCCALCSIZE, sent|wparam, 1 },
1809     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1810     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1811     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1812     { 0 }
1813 };
1814 /* ShowWindow(SW_RESTORE) for a visible MDI child window */
1815 static const struct message WmRestoreMDIchildVisibleSeq[] = {
1816     { HCBT_MINMAX, hook },
1817     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1818     { WM_NCCALCSIZE, sent|wparam, 1 },
1819     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1820     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1821     { WM_SIZE, sent|defwinproc },
1822      /* in MDI frame */
1823     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1824     { WM_NCCALCSIZE, sent|wparam, 1 },
1825     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1826     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1827     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1828     { 0 }
1829 };
1830 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
1831 static const struct message WmRestoreMDIchildInisibleSeq[] = {
1832     { HCBT_MINMAX, hook },
1833     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
1834     { WM_NCCALCSIZE, sent|wparam, 1 },
1835     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1836     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1837     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1838     { WM_SIZE, sent|defwinproc },
1839      /* in MDI frame */
1840     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1841     { WM_NCCALCSIZE, sent|wparam, 1 },
1842     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1843     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1844     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1845     { 0 }
1846 };
1847
1848 static HWND mdi_client;
1849 static WNDPROC old_mdi_client_proc;
1850
1851 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1852 {
1853     struct message msg;
1854
1855     /* do not log painting messages */
1856     if (message != WM_PAINT &&
1857         message != WM_ERASEBKGND &&
1858         message != WM_NCPAINT &&
1859         message != WM_NCHITTEST &&
1860         message != WM_GETTEXT &&
1861         message != WM_MDIGETACTIVE)
1862     {
1863         trace("mdi client: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1864
1865         switch (message)
1866         {
1867             case WM_WINDOWPOSCHANGING:
1868             case WM_WINDOWPOSCHANGED:
1869             {
1870                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1871
1872                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1873                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1874                       winpos->hwnd, winpos->hwndInsertAfter,
1875                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1876
1877                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1878                  * in the high word for internal purposes
1879                  */
1880                 wParam = winpos->flags & 0xffff;
1881                 break;
1882             }
1883         }
1884
1885         msg.message = message;
1886         msg.flags = sent|wparam|lparam;
1887         msg.wParam = wParam;
1888         msg.lParam = lParam;
1889         add_message(&msg);
1890     }
1891
1892     return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
1893 }
1894
1895 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1896 {
1897     static long defwndproc_counter = 0;
1898     LRESULT ret;
1899     struct message msg;
1900
1901     /* do not log painting messages */
1902     if (message != WM_PAINT &&
1903         message != WM_ERASEBKGND &&
1904         message != WM_NCPAINT &&
1905         message != WM_NCHITTEST &&
1906         message != WM_GETTEXT)
1907     {
1908         trace("mdi child: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1909
1910         switch (message)
1911         {
1912             case WM_WINDOWPOSCHANGING:
1913             case WM_WINDOWPOSCHANGED:
1914             {
1915                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1916
1917                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1918                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1919                       winpos->hwnd, winpos->hwndInsertAfter,
1920                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1921
1922                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1923                  * in the high word for internal purposes
1924                  */
1925                 wParam = winpos->flags & 0xffff;
1926                 break;
1927             }
1928
1929             case WM_MDIACTIVATE:
1930             {
1931                 HWND active, client = GetParent(hwnd);
1932
1933                 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
1934
1935                 if (hwnd == (HWND)lParam) /* if we are being activated */
1936                     ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
1937                 else
1938                     ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
1939                 break;
1940             }
1941         }
1942
1943         msg.message = message;
1944         msg.flags = sent|wparam|lparam;
1945         if (defwndproc_counter) msg.flags |= defwinproc;
1946         msg.wParam = wParam;
1947         msg.lParam = lParam;
1948         add_message(&msg);
1949     }
1950
1951     defwndproc_counter++;
1952     ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
1953     defwndproc_counter--;
1954
1955     return ret;
1956 }
1957
1958 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1959 {
1960     static long defwndproc_counter = 0;
1961     LRESULT ret;
1962     struct message msg;
1963
1964     /* do not log painting messages */
1965     if (message != WM_PAINT &&
1966         message != WM_ERASEBKGND &&
1967         message != WM_NCPAINT &&
1968         message != WM_NCHITTEST &&
1969         message != WM_GETTEXT)
1970     {
1971         trace("mdi frame: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1972
1973         switch (message)
1974         {
1975             case WM_WINDOWPOSCHANGING:
1976             case WM_WINDOWPOSCHANGED:
1977             {
1978                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1979
1980                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1981                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1982                       winpos->hwnd, winpos->hwndInsertAfter,
1983                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1984
1985                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1986                  * in the high word for internal purposes
1987                  */
1988                 wParam = winpos->flags & 0xffff;
1989                 break;
1990             }
1991         }
1992
1993         msg.message = message;
1994         msg.flags = sent|wparam|lparam;
1995         if (defwndproc_counter) msg.flags |= defwinproc;
1996         msg.wParam = wParam;
1997         msg.lParam = lParam;
1998         add_message(&msg);
1999     }
2000
2001     defwndproc_counter++;
2002     ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
2003     defwndproc_counter--;
2004
2005     return ret;
2006 }
2007
2008 static BOOL mdi_RegisterWindowClasses(void)
2009 {
2010     WNDCLASSA cls;
2011
2012     cls.style = 0;
2013     cls.lpfnWndProc = mdi_frame_wnd_proc;
2014     cls.cbClsExtra = 0;
2015     cls.cbWndExtra = 0;
2016     cls.hInstance = GetModuleHandleA(0);
2017     cls.hIcon = 0;
2018     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
2019     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
2020     cls.lpszMenuName = NULL;
2021     cls.lpszClassName = "MDI_frame_class";
2022     if (!RegisterClassA(&cls)) return FALSE;
2023
2024     cls.lpfnWndProc = mdi_child_wnd_proc;
2025     cls.lpszClassName = "MDI_child_class";
2026     if (!RegisterClassA(&cls)) return FALSE;
2027
2028     if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
2029     old_mdi_client_proc = cls.lpfnWndProc;
2030     cls.hInstance = GetModuleHandleA(0);
2031     cls.lpfnWndProc = mdi_client_hook_proc;
2032     cls.lpszClassName = "MDI_client_class";
2033     if (!RegisterClassA(&cls)) assert(0);
2034
2035     return TRUE;
2036 }
2037
2038 static void test_mdi_messages(void)
2039 {
2040     MDICREATESTRUCTA mdi_cs;
2041     CLIENTCREATESTRUCT client_cs;
2042     HWND mdi_frame, mdi_child, mdi_child2, active_child;
2043     BOOL zoomed;
2044     HMENU hMenu = CreateMenu();
2045
2046     assert(mdi_RegisterWindowClasses());
2047
2048     flush_sequence();
2049
2050     trace("creating MDI frame window\n");
2051     mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
2052                                 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
2053                                 WS_MAXIMIZEBOX | WS_VISIBLE,
2054                                 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
2055                                 GetDesktopWindow(), hMenu,
2056                                 GetModuleHandleA(0), NULL);
2057     assert(mdi_frame);
2058     ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", TRUE);
2059
2060     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2061     ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
2062
2063     trace("creating MDI client window\n");
2064     client_cs.hWindowMenu = 0;
2065     client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
2066     mdi_client = CreateWindowExA(0, "MDI_client_class",
2067                                  NULL,
2068                                  WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
2069                                  0, 0, 0, 0,
2070                                  mdi_frame, 0, GetModuleHandleA(0), &client_cs);
2071     assert(mdi_client);
2072     ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
2073
2074     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2075     ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
2076
2077     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2078     ok(!active_child, "wrong active MDI child %p\n", active_child);
2079     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2080
2081     SetFocus(0);
2082     flush_sequence();
2083
2084     trace("creating invisible MDI child window\n");
2085     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2086                                 WS_CHILD,
2087                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2088                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2089     assert(mdi_child);
2090
2091     flush_sequence();
2092     ShowWindow(mdi_child, SW_SHOWNORMAL);
2093     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
2094
2095     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2096     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2097
2098     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2099     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2100
2101     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2102     ok(!active_child, "wrong active MDI child %p\n", active_child);
2103     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2104
2105     ShowWindow(mdi_child, SW_HIDE);
2106     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
2107     flush_sequence();
2108
2109     ShowWindow(mdi_child, SW_SHOW);
2110     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
2111
2112     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2113     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2114
2115     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2116     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2117
2118     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2119     ok(!active_child, "wrong active MDI child %p\n", active_child);
2120     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2121
2122     DestroyWindow(mdi_child);
2123     flush_sequence();
2124
2125     trace("creating visible MDI child window\n");
2126     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2127                                 WS_CHILD | WS_VISIBLE,
2128                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2129                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2130     assert(mdi_child);
2131     ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", TRUE);
2132
2133     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2134     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2135
2136     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2137     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2138
2139     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2140     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2141     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2142     flush_sequence();
2143
2144     DestroyWindow(mdi_child);
2145     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2146
2147     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2148     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2149
2150     /* Win2k: MDI client still returns a just destroyed child as active
2151      * Win9x: MDI client returns 0
2152      */
2153     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2154     ok(active_child == mdi_child || /* win2k */
2155        !active_child, /* win9x */
2156        "wrong active MDI child %p\n", active_child);
2157     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2158
2159     flush_sequence();
2160
2161     trace("creating invisible MDI child window\n");
2162     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2163                                 WS_CHILD,
2164                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2165                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2166     assert(mdi_child2);
2167     ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
2168
2169     ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
2170     ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
2171
2172     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2173     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2174
2175     /* Win2k: MDI client still returns a just destroyed child as active
2176      * Win9x: MDI client returns mdi_child2
2177      */
2178     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2179     ok(active_child == mdi_child || /* win2k */
2180        active_child == mdi_child2, /* win9x */
2181        "wrong active MDI child %p\n", active_child);
2182     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2183     flush_sequence();
2184
2185     ShowWindow(mdi_child2, SW_MAXIMIZE);
2186     ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", TRUE);
2187
2188     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2189     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2190
2191     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2192     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2193     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2194     flush_sequence();
2195
2196     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2197     ok(GetFocus() == mdi_child2 || /* win2k */
2198        GetFocus() == 0, /* win9x */
2199        "wrong focus window %p\n", GetFocus());
2200
2201     SetFocus(0);
2202     flush_sequence();
2203
2204     ShowWindow(mdi_child2, SW_HIDE);
2205     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2206
2207     ShowWindow(mdi_child2, SW_RESTORE);
2208     ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", TRUE);
2209     flush_sequence();
2210
2211     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2212     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2213
2214     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2215     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2216     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2217     flush_sequence();
2218
2219     SetFocus(0);
2220     flush_sequence();
2221
2222     ShowWindow(mdi_child2, SW_HIDE);
2223     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2224
2225     ShowWindow(mdi_child2, SW_SHOW);
2226     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
2227
2228     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2229     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2230
2231     ShowWindow(mdi_child2, SW_MAXIMIZE);
2232     ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", TRUE);
2233
2234     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2235     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2236
2237     ShowWindow(mdi_child2, SW_RESTORE);
2238     ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):MDI child", TRUE);
2239
2240     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2241     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2242
2243     SetFocus(0);
2244     flush_sequence();
2245
2246     ShowWindow(mdi_child2, SW_HIDE);
2247     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2248
2249     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2250     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2251
2252     DestroyWindow(mdi_child2);
2253     ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
2254
2255     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2256     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2257
2258     /* test for maximized MDI children */
2259     trace("creating maximized visible MDI child window 1\n");
2260     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2261                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2262                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2263                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2264     assert(mdi_child);
2265     ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
2266     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2267
2268     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2269     ok(GetFocus() == mdi_child || /* win2k */
2270        GetFocus() == 0, /* win9x */
2271        "wrong focus window %p\n", GetFocus());
2272
2273     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2274     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2275     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2276     flush_sequence();
2277
2278     trace("creating maximized visible MDI child window 2\n");
2279     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2280                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2281                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2282                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2283     assert(mdi_child2);
2284     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
2285     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
2286     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2287
2288     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2289     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
2290
2291     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2292     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2293     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2294     flush_sequence();
2295
2296     trace("destroying maximized visible MDI child window 2\n");
2297     DestroyWindow(mdi_child2);
2298     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2299
2300     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2301
2302     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2303     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2304
2305     /* Win2k: MDI client still returns a just destroyed child as active
2306      * Win9x: MDI client returns 0
2307      */
2308     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2309     ok(active_child == mdi_child2 || /* win2k */
2310        !active_child, /* win9x */
2311        "wrong active MDI child %p\n", active_child);
2312     flush_sequence();
2313
2314     ShowWindow(mdi_child, SW_MAXIMIZE);
2315     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2316     flush_sequence();
2317
2318     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2319     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2320
2321     trace("re-creating maximized visible MDI child window 2\n");
2322     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2323                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2324                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2325                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2326     assert(mdi_child2);
2327     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
2328     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
2329     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2330
2331     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2332     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
2333
2334     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2335     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2336     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2337     flush_sequence();
2338
2339     SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
2340     ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
2341     ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
2342
2343     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2344     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2345     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2346
2347     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2348     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2349     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2350     flush_sequence();
2351
2352     DestroyWindow(mdi_child);
2353     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2354
2355     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2356     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2357
2358     /* Win2k: MDI client still returns a just destroyed child as active
2359      * Win9x: MDI client returns 0
2360      */
2361     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2362     ok(active_child == mdi_child || /* win2k */
2363        !active_child, /* win9x */
2364        "wrong active MDI child %p\n", active_child);
2365     flush_sequence();
2366     /* end of test for maximized MDI children */
2367
2368     mdi_cs.szClass = "MDI_child_Class";
2369     mdi_cs.szTitle = "MDI child";
2370     mdi_cs.hOwner = GetModuleHandleA(0);
2371     mdi_cs.x = 0;
2372     mdi_cs.y = 0;
2373     mdi_cs.cx = CW_USEDEFAULT;
2374     mdi_cs.cy = CW_USEDEFAULT;
2375     mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
2376     mdi_cs.lParam = 0;
2377     mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
2378     ok(mdi_child != 0, "MDI child creation failed\n");
2379     ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
2380
2381     ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
2382
2383     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2384     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2385
2386     ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
2387     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2388     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2389
2390     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2391     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2392     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2393     flush_sequence();
2394
2395     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
2396     ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
2397
2398     ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
2399     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2400     ok(!active_child, "wrong active MDI child %p\n", active_child);
2401
2402     SetFocus(0);
2403     flush_sequence();
2404
2405     DestroyWindow(mdi_client);
2406     ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
2407
2408     DestroyWindow(mdi_frame);
2409     ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
2410 }
2411 /************************* End of MDI test **********************************/
2412
2413 static void test_WM_SETREDRAW(HWND hwnd)
2414 {
2415     DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
2416
2417     flush_sequence();
2418
2419     SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
2420     ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
2421
2422     ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
2423     ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
2424
2425     flush_sequence();
2426     SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
2427     ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
2428
2429     ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2430     ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
2431
2432     /* restore original WS_VISIBLE state */
2433     SetWindowLongA(hwnd, GWL_STYLE, style);
2434
2435     flush_sequence();
2436 }
2437
2438 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2439 {
2440     struct message msg;
2441
2442     trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2443
2444     switch (message)
2445     {
2446         case WM_WINDOWPOSCHANGING:
2447         case WM_WINDOWPOSCHANGED:
2448         {
2449             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2450
2451             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2452             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2453                   winpos->hwnd, winpos->hwndInsertAfter,
2454                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2455
2456             /* Log only documented flags, win2k uses 0x1000 and 0x2000
2457              * in the high word for internal purposes
2458              */
2459             wParam = winpos->flags & 0xffff;
2460             break;
2461         }
2462     }
2463
2464     msg.message = message;
2465     msg.flags = sent|wparam|lparam;
2466     msg.wParam = wParam;
2467     msg.lParam = lParam;
2468     add_message(&msg);
2469
2470     if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
2471     if (message == WM_TIMER) EndDialog( hwnd, 0 );
2472     return 0;
2473 }
2474
2475 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2476 {
2477     DWORD style, exstyle;
2478     INT xmin, xmax;
2479     BOOL ret;
2480
2481     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2482     style = GetWindowLongA(hwnd, GWL_STYLE);
2483     /* do not be confused by WS_DLGFRAME set */
2484     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2485
2486     if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2487     if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2488
2489     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
2490     ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2491     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2492         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
2493     else
2494         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
2495
2496     style = GetWindowLongA(hwnd, GWL_STYLE);
2497     if (set) ok(style & set, "style %08lx should be set\n", set);
2498     if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2499
2500     /* a subsequent call should do nothing */
2501     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
2502     ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2503     ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2504
2505     xmin = 0xdeadbeef;
2506     xmax = 0xdeadbeef;
2507     trace("Ignore GetScrollRange error below if you are on Win9x\n");
2508     ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
2509     ok( ret, "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
2510     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2511     ok(xmin == min, "unexpected min scroll value %d\n", xmin);
2512     ok(xmax == max, "unexpected max scroll value %d\n", xmax);
2513 }
2514
2515 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2516 {
2517     DWORD style, exstyle;
2518     SCROLLINFO si;
2519     BOOL ret;
2520
2521     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2522     style = GetWindowLongA(hwnd, GWL_STYLE);
2523     /* do not be confused by WS_DLGFRAME set */
2524     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2525
2526     if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2527     if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2528
2529     si.cbSize = sizeof(si);
2530     si.fMask = SIF_RANGE;
2531     si.nMin = min;
2532     si.nMax = max;
2533     SetScrollInfo(hwnd, ctl, &si, TRUE);
2534     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2535         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
2536     else
2537         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
2538
2539     style = GetWindowLongA(hwnd, GWL_STYLE);
2540     if (set) ok(style & set, "style %08lx should be set\n", set);
2541     if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2542
2543     /* a subsequent call should do nothing */
2544     SetScrollInfo(hwnd, ctl, &si, TRUE);
2545     if (style & WS_HSCROLL)
2546         ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2547     else if (style & WS_VSCROLL)
2548         ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2549     else
2550         ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2551
2552     si.fMask = SIF_PAGE;
2553     si.nPage = 5;
2554     SetScrollInfo(hwnd, ctl, &si, FALSE);
2555     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2556
2557     si.fMask = SIF_POS;
2558     si.nPos = max - 1;
2559     SetScrollInfo(hwnd, ctl, &si, FALSE);
2560     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2561
2562     si.fMask = SIF_RANGE;
2563     si.nMin = 0xdeadbeef;
2564     si.nMax = 0xdeadbeef;
2565     ret = GetScrollInfo(hwnd, ctl, &si);
2566     ok( ret, "GetScrollInfo error %ld\n", GetLastError());
2567     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2568     ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
2569     ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
2570 }
2571
2572 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
2573 static void test_scroll_messages(HWND hwnd)
2574 {
2575     SCROLLINFO si;
2576     INT min, max;
2577     BOOL ret;
2578
2579     min = 0xdeadbeef;
2580     max = 0xdeadbeef;
2581     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
2582     ok( ret, "GetScrollRange error %ld\n", GetLastError());
2583     if (sequence->message != WmGetScrollRangeSeq[0].message)
2584         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2585     /* values of min and max are undefined */
2586     flush_sequence();
2587
2588     ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
2589     ok( ret, "SetScrollRange error %ld\n", GetLastError());
2590     if (sequence->message != WmSetScrollRangeSeq[0].message)
2591         trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2592     flush_sequence();
2593
2594     min = 0xdeadbeef;
2595     max = 0xdeadbeef;
2596     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
2597     ok( ret, "GetScrollRange error %ld\n", GetLastError());
2598     if (sequence->message != WmGetScrollRangeSeq[0].message)
2599         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2600     /* values of min and max are undefined */
2601     flush_sequence();
2602
2603     si.cbSize = sizeof(si);
2604     si.fMask = SIF_RANGE;
2605     si.nMin = 20;
2606     si.nMax = 160;
2607     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2608     if (sequence->message != WmSetScrollRangeSeq[0].message)
2609         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2610     flush_sequence();
2611
2612     si.fMask = SIF_PAGE;
2613     si.nPage = 10;
2614     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2615     if (sequence->message != WmSetScrollRangeSeq[0].message)
2616         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2617     flush_sequence();
2618
2619     si.fMask = SIF_POS;
2620     si.nPos = 20;
2621     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2622     if (sequence->message != WmSetScrollRangeSeq[0].message)
2623         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2624     flush_sequence();
2625
2626     si.fMask = SIF_RANGE;
2627     si.nMin = 0xdeadbeef;
2628     si.nMax = 0xdeadbeef;
2629     ret = GetScrollInfo(hwnd, SB_CTL, &si);
2630     ok( ret, "GetScrollInfo error %ld\n", GetLastError());
2631     if (sequence->message != WmGetScrollInfoSeq[0].message)
2632         trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2633     /* values of min and max are undefined */
2634     flush_sequence();
2635
2636     /* set WS_HSCROLL */
2637     test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2638     /* clear WS_HSCROLL */
2639     test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2640
2641     /* set WS_HSCROLL */
2642     test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2643     /* clear WS_HSCROLL */
2644     test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2645
2646     /* set WS_VSCROLL */
2647     test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
2648     /* clear WS_VSCROLL */
2649     test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
2650
2651     /* set WS_VSCROLL */
2652     test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
2653     /* clear WS_VSCROLL */
2654     test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
2655 }
2656
2657 /* test if we receive the right sequence of messages */
2658 static void test_messages(void)
2659 {
2660     HWND hwnd, hparent, hchild;
2661     HWND hchild2, hbutton;
2662     HMENU hmenu;
2663     MSG msg;
2664
2665     flush_sequence();
2666
2667     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
2668                            100, 100, 200, 200, 0, 0, 0, NULL);
2669     ok (hwnd != 0, "Failed to create overlapped window\n");
2670     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
2671
2672     /* test ShowWindow(SW_HIDE) on a newly created invisible window */
2673     ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
2674     ok_sequence(WmHideInvisibleOverlappedSeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
2675
2676     /* test WM_SETREDRAW on a not visible top level window */
2677     test_WM_SETREDRAW(hwnd);
2678
2679     SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2680     ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
2681     ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
2682
2683     ok(GetActiveWindow() == hwnd, "window should be active\n");
2684     ok(GetFocus() == hwnd, "window should have input focus\n");
2685     ShowWindow(hwnd, SW_HIDE);
2686     ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", TRUE);
2687
2688     ShowWindow(hwnd, SW_SHOW);
2689     ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
2690
2691     ok(GetActiveWindow() == hwnd, "window should be active\n");
2692     ok(GetFocus() == hwnd, "window should have input focus\n");
2693     SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2694     ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
2695     ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
2696
2697     /* test WM_SETREDRAW on a visible top level window */
2698     ShowWindow(hwnd, SW_SHOW);
2699     test_WM_SETREDRAW(hwnd);
2700
2701     trace("testing scroll APIs on a visible top level window %p\n", hwnd);
2702     test_scroll_messages(hwnd);
2703
2704     DestroyWindow(hwnd);
2705     ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
2706
2707     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
2708                               100, 100, 200, 200, 0, 0, 0, NULL);
2709     ok (hparent != 0, "Failed to create parent window\n");
2710     flush_sequence();
2711
2712     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
2713                              0, 0, 10, 10, hparent, 0, 0, NULL);
2714     ok (hchild != 0, "Failed to create child window\n");
2715     ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", TRUE);
2716     DestroyWindow(hchild);
2717     flush_sequence();
2718
2719     /* visible child window with a caption */
2720     hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
2721                              WS_CHILD | WS_VISIBLE | WS_CAPTION,
2722                              0, 0, 10, 10, hparent, 0, 0, NULL);
2723     ok (hchild != 0, "Failed to create child window\n");
2724     ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
2725
2726     trace("testing scroll APIs on a visible child window %p\n", hchild);
2727     test_scroll_messages(hchild);
2728
2729     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2730     ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
2731
2732     DestroyWindow(hchild);
2733     flush_sequence();
2734
2735     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
2736                              0, 0, 10, 10, hparent, 0, 0, NULL);
2737     ok (hchild != 0, "Failed to create child window\n");
2738     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
2739
2740     hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
2741                                100, 100, 50, 50, hparent, 0, 0, NULL);
2742     ok (hchild2 != 0, "Failed to create child2 window\n");
2743     flush_sequence();
2744
2745     hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
2746                               0, 100, 50, 50, hchild, 0, 0, NULL);
2747     ok (hbutton != 0, "Failed to create button window\n");
2748
2749     /* test WM_SETREDRAW on a not visible child window */
2750     test_WM_SETREDRAW(hchild);
2751
2752     ShowWindow(hchild, SW_SHOW);
2753     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
2754
2755     ShowWindow(hchild, SW_HIDE);
2756     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
2757
2758     ShowWindow(hchild, SW_SHOW);
2759     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
2760
2761     /* test WM_SETREDRAW on a visible child window */
2762     test_WM_SETREDRAW(hchild);
2763
2764     MoveWindow(hchild, 10, 10, 20, 20, TRUE);
2765     ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
2766
2767     ShowWindow(hchild, SW_HIDE);
2768     flush_sequence();
2769     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2770     ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
2771
2772     ShowWindow(hchild, SW_HIDE);
2773     flush_sequence();
2774     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
2775     ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
2776
2777     /* DestroyWindow sequence below expects that a child has focus */
2778     SetFocus(hchild);
2779     flush_sequence();
2780
2781     DestroyWindow(hchild);
2782     ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
2783     DestroyWindow(hchild2);
2784     DestroyWindow(hbutton);
2785
2786     flush_sequence();
2787     hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
2788                              0, 0, 100, 100, hparent, 0, 0, NULL);
2789     ok (hchild != 0, "Failed to create child popup window\n");
2790     ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
2791     DestroyWindow(hchild);
2792
2793     /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
2794     flush_sequence();
2795     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
2796                              0, 0, 100, 100, hparent, 0, 0, NULL);
2797     ok (hchild != 0, "Failed to create popup window\n");
2798     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
2799     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2800     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
2801     flush_sequence();
2802     ShowWindow(hchild, SW_SHOW);
2803     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
2804     flush_sequence();
2805     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2806     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
2807     flush_sequence();
2808     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2809     ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
2810     DestroyWindow(hchild);
2811
2812     /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
2813      * changes nothing in message sequences.
2814      */
2815     flush_sequence();
2816     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
2817                              0, 0, 100, 100, hparent, 0, 0, NULL);
2818     ok (hchild != 0, "Failed to create popup window\n");
2819     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
2820     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2821     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
2822     flush_sequence();
2823     ShowWindow(hchild, SW_SHOW);
2824     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
2825     flush_sequence();
2826     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2827     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
2828     DestroyWindow(hchild);
2829
2830     flush_sequence();
2831     hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
2832                            0, 0, 100, 100, hparent, 0, 0, NULL);
2833     ok(hwnd != 0, "Failed to create custom dialog window\n");
2834     ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
2835
2836     /*
2837     trace("testing scroll APIs on a visible dialog %p\n", hwnd);
2838     test_scroll_messages(hwnd);
2839     */
2840
2841     flush_sequence();
2842     after_end_dialog = 1;
2843     EndDialog( hwnd, 0 );
2844     ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
2845
2846     DestroyWindow(hwnd);
2847     after_end_dialog = 0;
2848
2849     hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
2850                            0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
2851     ok(hwnd != 0, "Failed to create custom dialog window\n");
2852     flush_sequence();
2853     trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
2854     ShowWindow(hwnd, SW_SHOW);
2855     ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
2856     DestroyWindow(hwnd);
2857
2858     flush_sequence();
2859     DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
2860     ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
2861
2862     /* test showing child with hidden parent */
2863     ShowWindow( hparent, SW_HIDE );
2864     flush_sequence();
2865
2866     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
2867                              0, 0, 10, 10, hparent, 0, 0, NULL);
2868     ok (hchild != 0, "Failed to create child window\n");
2869     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
2870
2871     ShowWindow( hchild, SW_SHOW );
2872     ok_sequence(WmShowChildInvisibleParentSeq, "ShowWindow:show child with invisible parent", TRUE);
2873     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2874     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2875
2876     ShowWindow( hchild, SW_HIDE );
2877     ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", TRUE);
2878     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
2879     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2880
2881     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2882     ok_sequence(WmShowChildInvisibleParentSeq_2, "SetWindowPos:show child with invisible parent", TRUE);
2883     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2884     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2885
2886     SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2887     ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", TRUE);
2888     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
2889     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2890
2891     DestroyWindow(hchild);
2892     DestroyWindow(hparent);
2893     flush_sequence();
2894
2895     /* Message sequence for SetMenu */
2896     ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
2897     ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
2898
2899     hmenu = CreateMenu();
2900     ok (hmenu != 0, "Failed to create menu\n");
2901     ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
2902     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
2903                            100, 100, 200, 200, 0, hmenu, 0, NULL);
2904     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
2905     ok (SetMenu(hwnd, 0), "SetMenu\n");
2906     ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
2907     ok (SetMenu(hwnd, 0), "SetMenu\n");
2908     ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
2909     ShowWindow(hwnd, SW_SHOW);
2910     flush_sequence();
2911     ok (SetMenu(hwnd, 0), "SetMenu\n");
2912     ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", TRUE);
2913     ok (SetMenu(hwnd, hmenu), "SetMenu\n");
2914     ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", TRUE);
2915
2916     ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
2917     ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", TRUE);
2918
2919     DestroyWindow(hwnd);
2920     flush_sequence();
2921
2922     /* Message sequence for EnableWindow */
2923     hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
2924                               100, 100, 200, 200, 0, 0, 0, NULL);
2925     ok (hparent != 0, "Failed to create parent window\n");
2926     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
2927                              0, 0, 10, 10, hparent, 0, 0, NULL);
2928     ok (hchild != 0, "Failed to create child window\n");
2929
2930     SetFocus(hchild);
2931     flush_sequence();
2932
2933     EnableWindow(hparent, FALSE);
2934     ok_sequence(WmEnableWindowSeq, "EnableWindow", FALSE);
2935
2936     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
2937     flush_sequence();
2938
2939     /* the following test causes an exception in user.exe under win9x */
2940     if (!PostMessageW( hparent, WM_USER, 0, 0 )) return;
2941     PostMessageW( hparent, WM_USER+1, 0, 0 );
2942     /* PeekMessage(NULL) fails, but still removes the message */
2943     SetLastError(0xdeadbeef);
2944     ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
2945     ok( GetLastError() == ERROR_NOACCESS, "last error is %ld\n", GetLastError() );
2946     ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
2947     ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
2948
2949     DestroyWindow(hchild);
2950     DestroyWindow(hparent);
2951     flush_sequence();
2952 }
2953
2954 /****************** button message test *************************/
2955 static const struct message WmSetFocusButtonSeq[] =
2956 {
2957     { HCBT_SETFOCUS, hook },
2958     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2959     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2960     { WM_SETFOCUS, sent|wparam, 0 },
2961     { WM_CTLCOLORBTN, sent|defwinproc },
2962     { 0 }
2963 };
2964 static const struct message WmKillFocusButtonSeq[] =
2965 {
2966     { HCBT_SETFOCUS, hook },
2967     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2968     { WM_KILLFOCUS, sent|wparam, 0 },
2969     { WM_CTLCOLORBTN, sent|defwinproc },
2970     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2971     { 0 }
2972 };
2973 static const struct message WmSetFocusStaticSeq[] =
2974 {
2975     { HCBT_SETFOCUS, hook },
2976     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2977     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2978     { WM_SETFOCUS, sent|wparam, 0 },
2979     { WM_CTLCOLORSTATIC, sent|defwinproc },
2980     { 0 }
2981 };
2982 static const struct message WmKillFocusStaticSeq[] =
2983 {
2984     { HCBT_SETFOCUS, hook },
2985     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2986     { WM_KILLFOCUS, sent|wparam, 0 },
2987     { WM_CTLCOLORSTATIC, sent|defwinproc },
2988     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2989     { 0 }
2990 };
2991 static const struct message WmLButtonDownSeq[] =
2992 {
2993     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
2994     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
2995     { HCBT_SETFOCUS, hook },
2996     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2997     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2998     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2999     { WM_CTLCOLORBTN, sent|defwinproc },
3000     { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
3001     { WM_CTLCOLORBTN, sent|defwinproc },
3002     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3003     { 0 }
3004 };
3005 static const struct message WmLButtonUpSeq[] =
3006 {
3007     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
3008     { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
3009     { WM_CTLCOLORBTN, sent|defwinproc },
3010     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3011     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
3012     { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
3013     { 0 }
3014 };
3015
3016 static WNDPROC old_button_proc;
3017
3018 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3019 {
3020     static long defwndproc_counter = 0;
3021     LRESULT ret;
3022     struct message msg;
3023
3024     trace("button: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3025
3026     msg.message = message;
3027     msg.flags = sent|wparam|lparam;
3028     if (defwndproc_counter) msg.flags |= defwinproc;
3029     msg.wParam = wParam;
3030     msg.lParam = lParam;
3031     add_message(&msg);
3032
3033     if (message == BM_SETSTATE)
3034         ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
3035
3036     defwndproc_counter++;
3037     ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
3038     defwndproc_counter--;
3039
3040     return ret;
3041 }
3042
3043 static void subclass_button(void)
3044 {
3045     WNDCLASSA cls;
3046
3047     if (!GetClassInfoA(0, "button", &cls)) assert(0);
3048
3049     old_button_proc = cls.lpfnWndProc;
3050
3051     cls.hInstance = GetModuleHandle(0);
3052     cls.lpfnWndProc = button_hook_proc;
3053     cls.lpszClassName = "my_button_class";
3054     if (!RegisterClassA(&cls)) assert(0);
3055 }
3056
3057 static void test_button_messages(void)
3058 {
3059     static const struct
3060     {
3061         DWORD style;
3062         DWORD dlg_code;
3063         const struct message *setfocus;
3064         const struct message *killfocus;
3065     } button[] = {
3066         { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
3067           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3068         { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
3069           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3070         { BS_CHECKBOX, DLGC_BUTTON,
3071           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3072         { BS_AUTOCHECKBOX, DLGC_BUTTON,
3073           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3074         { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
3075           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3076         { BS_3STATE, DLGC_BUTTON,
3077           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3078         { BS_AUTO3STATE, DLGC_BUTTON,
3079           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3080         { BS_GROUPBOX, DLGC_STATIC,
3081           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3082         { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
3083           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3084         { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
3085           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3086         { BS_OWNERDRAW, DLGC_BUTTON,
3087           WmSetFocusButtonSeq, WmKillFocusButtonSeq }
3088     };
3089     unsigned int i;
3090     HWND hwnd;
3091     DWORD dlg_code;
3092
3093     subclass_button();
3094
3095     for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
3096     {
3097         hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
3098                                0, 0, 50, 14, 0, 0, 0, NULL);
3099         ok(hwnd != 0, "Failed to create button window\n");
3100
3101         dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
3102         ok(dlg_code == button[i].dlg_code, "%d: wrong dlg_code %08lx\n", i, dlg_code);
3103
3104         ShowWindow(hwnd, SW_SHOW);
3105         UpdateWindow(hwnd);
3106         SetFocus(0);
3107         flush_sequence();
3108
3109         trace("button style %08lx\n", button[i].style);
3110         SetFocus(hwnd);
3111         ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
3112
3113         SetFocus(0);
3114         ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
3115
3116         DestroyWindow(hwnd);
3117     }
3118
3119     hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
3120                            0, 0, 50, 14, 0, 0, 0, NULL);
3121     ok(hwnd != 0, "Failed to create button window\n");
3122
3123     SetFocus(0);
3124     flush_sequence();
3125
3126     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
3127     ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
3128
3129     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
3130     ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
3131     DestroyWindow(hwnd);
3132 }
3133
3134 /************* painting message test ********************/
3135
3136 static void dump_region(HRGN hrgn)
3137 {
3138     DWORD i, size;
3139     RGNDATA *data = NULL;
3140     RECT *rect;
3141
3142     if (!hrgn)
3143     {
3144         printf( "null region\n" );
3145         return;
3146     }
3147     if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
3148     if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
3149     GetRegionData( hrgn, size, data );
3150     printf("%ld rects:", data->rdh.nCount );
3151     for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
3152         printf( " (%ld,%ld)-(%ld,%ld)", rect->left, rect->top, rect->right, rect->bottom );
3153     printf("\n");
3154     HeapFree( GetProcessHeap(), 0, data );
3155 }
3156
3157 static void check_update_rgn( HWND hwnd, HRGN hrgn )
3158 {
3159     INT ret;
3160     RECT r1, r2;
3161     HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
3162     HRGN update = CreateRectRgn( 0, 0, 0, 0 );
3163
3164     ret = GetUpdateRgn( hwnd, update, FALSE );
3165     ok( ret != ERROR, "GetUpdateRgn failed\n" );
3166     if (ret == NULLREGION)
3167     {
3168         ok( !hrgn, "Update region shouldn't be empty\n" );
3169     }
3170     else
3171     {
3172         if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
3173         {
3174             ok( 0, "Regions are different\n" );
3175             if (winetest_debug > 0)
3176             {
3177                 printf( "Update region: " );
3178                 dump_region( update );
3179                 printf( "Wanted region: " );
3180                 dump_region( hrgn );
3181             }
3182         }
3183     }
3184     GetRgnBox( update, &r1 );
3185     GetUpdateRect( hwnd, &r2, FALSE );
3186     ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
3187         "Rectangles are different: %ld,%ld-%ld,%ld / %ld,%ld-%ld,%ld\n",
3188         r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
3189
3190     DeleteObject( tmp );
3191     DeleteObject( update );
3192 }
3193
3194 static const struct message WmInvalidateRgn[] = {
3195     { WM_NCPAINT, sent },
3196     { WM_GETTEXT, sent|defwinproc|optional },
3197     { 0 }
3198 };
3199
3200 static const struct message WmGetUpdateRect[] = {
3201     { WM_NCPAINT, sent },
3202     { WM_GETTEXT, sent|defwinproc|optional },
3203     { WM_PAINT, sent },
3204     { 0 }
3205 };
3206
3207 static const struct message WmInvalidateFull[] = {
3208     { WM_NCPAINT, sent|wparam, 1 },
3209     { WM_GETTEXT, sent|defwinproc|optional },
3210     { 0 }
3211 };
3212
3213 static const struct message WmInvalidateErase[] = {
3214     { WM_NCPAINT, sent|wparam, 1 },
3215     { WM_GETTEXT, sent|defwinproc|optional },
3216     { WM_ERASEBKGND, sent },
3217     { 0 }
3218 };
3219
3220 static const struct message WmInvalidatePaint[] = {
3221     { WM_PAINT, sent },
3222     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
3223     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3224     { 0 }
3225 };
3226
3227 static const struct message WmInvalidateErasePaint[] = {
3228     { WM_PAINT, sent },
3229     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
3230     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3231     { WM_ERASEBKGND, sent|beginpaint },
3232     { 0 }
3233 };
3234
3235 static const struct message WmInvalidateErasePaint2[] = {
3236     { WM_PAINT, sent },
3237     { WM_NCPAINT, sent|beginpaint },
3238     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3239     { WM_ERASEBKGND, sent|beginpaint },
3240     { 0 }
3241 };
3242
3243 static const struct message WmErase[] = {
3244     { WM_ERASEBKGND, sent },
3245     { 0 }
3246 };
3247
3248 static const struct message WmPaint[] = {
3249     { WM_PAINT, sent },
3250     { 0 }
3251 };
3252
3253 static const struct message WmParentOnlyPaint[] = {
3254     { WM_PAINT, sent|parent },
3255     { 0 }
3256 };
3257
3258 static const struct message WmInvalidateParent[] = {
3259     { WM_NCPAINT, sent|parent },
3260     { WM_GETTEXT, sent|defwinproc|parent|optional },
3261     { WM_ERASEBKGND, sent|parent },
3262     { 0 }
3263 };
3264
3265 static const struct message WmInvalidateParentChild[] = {
3266     { WM_NCPAINT, sent|parent },
3267     { WM_GETTEXT, sent|defwinproc|parent|optional },
3268     { WM_ERASEBKGND, sent|parent },
3269     { WM_NCPAINT, sent },
3270     { WM_GETTEXT, sent|defwinproc|optional },
3271     { WM_ERASEBKGND, sent },
3272     { 0 }
3273 };
3274
3275 static const struct message WmInvalidateParentChild2[] = {
3276     { WM_ERASEBKGND, sent|parent },
3277     { WM_NCPAINT, sent },
3278     { WM_GETTEXT, sent|defwinproc|optional },
3279     { WM_ERASEBKGND, sent },
3280     { 0 }
3281 };
3282
3283 static const struct message WmParentPaint[] = {
3284     { WM_PAINT, sent|parent },
3285     { WM_PAINT, sent },
3286     { 0 }
3287 };
3288
3289 static const struct message WmParentPaintNc[] = {
3290     { WM_PAINT, sent|parent },
3291     { WM_PAINT, sent },
3292     { WM_NCPAINT, sent|beginpaint },
3293     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3294     { WM_ERASEBKGND, sent|beginpaint },
3295     { 0 }
3296 };
3297
3298 static const struct message WmChildPaintNc[] = {
3299     { WM_PAINT, sent },
3300     { WM_NCPAINT, sent|beginpaint },
3301     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3302     { WM_ERASEBKGND, sent|beginpaint },
3303     { 0 }
3304 };
3305
3306 static const struct message WmParentErasePaint[] = {
3307     { WM_PAINT, sent|parent },
3308     { WM_NCPAINT, sent|parent|beginpaint },
3309     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
3310     { WM_ERASEBKGND, sent|parent|beginpaint },
3311     { WM_PAINT, sent },
3312     { WM_NCPAINT, sent|beginpaint },
3313     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3314     { WM_ERASEBKGND, sent|beginpaint },
3315     { 0 }
3316 };
3317
3318 static const struct message WmParentOnlyNcPaint[] = {
3319     { WM_PAINT, sent|parent },
3320     { WM_NCPAINT, sent|parent|beginpaint },
3321     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
3322     { 0 }
3323 };
3324
3325 static const struct message WmSetParentStyle[] = {
3326     { WM_STYLECHANGING, sent|parent },
3327     { WM_STYLECHANGED, sent|parent },
3328     { 0 }
3329 };
3330
3331 static void test_paint_messages(void)
3332 {
3333     RECT rect;
3334     POINT pt;
3335     MSG msg;
3336     HWND hparent, hchild;
3337     HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
3338     HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
3339     HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3340                                 100, 100, 200, 200, 0, 0, 0, NULL);
3341     ok (hwnd != 0, "Failed to create overlapped window\n");
3342
3343     ShowWindow( hwnd, SW_SHOW );
3344     UpdateWindow( hwnd );
3345
3346     /* try to flush pending X expose events */
3347     MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
3348     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3349
3350     check_update_rgn( hwnd, 0 );
3351     SetRectRgn( hrgn, 10, 10, 20, 20 );
3352     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
3353     check_update_rgn( hwnd, hrgn );
3354     SetRectRgn( hrgn2, 20, 20, 30, 30 );
3355     RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
3356     CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
3357     check_update_rgn( hwnd, hrgn );
3358     /* validate everything */
3359     RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
3360     check_update_rgn( hwnd, 0 );
3361     /* now with frame */
3362     SetRectRgn( hrgn, -5, -5, 20, 20 );
3363
3364     /* flush pending messages */
3365     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3366
3367     flush_sequence();
3368     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
3369     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
3370
3371     SetRectRgn( hrgn, 0, 0, 20, 20 );  /* GetUpdateRgn clips to client area */
3372     check_update_rgn( hwnd, hrgn );
3373
3374     flush_sequence();
3375     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
3376     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
3377
3378     flush_sequence();
3379     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
3380     ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
3381
3382     GetClientRect( hwnd, &rect );
3383     SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
3384     check_update_rgn( hwnd, hrgn );
3385
3386     flush_sequence();
3387     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
3388     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
3389
3390     flush_sequence();
3391     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
3392     ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
3393     check_update_rgn( hwnd, 0 );
3394
3395     flush_sequence();
3396     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
3397     ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
3398     check_update_rgn( hwnd, 0 );
3399
3400     flush_sequence();
3401     SetRectRgn( hrgn, 0, 0, 100, 100 );
3402     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
3403     SetRectRgn( hrgn, 0, 0, 50, 100 );
3404     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
3405     SetRectRgn( hrgn, 50, 0, 100, 100 );
3406     check_update_rgn( hwnd, hrgn );
3407     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
3408     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );  /* must not generate messages, everything is valid */
3409     check_update_rgn( hwnd, 0 );
3410
3411     flush_sequence();
3412     SetRectRgn( hrgn, 0, 0, 100, 100 );
3413     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
3414     SetRectRgn( hrgn, 0, 0, 100, 50 );
3415     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
3416     ok_sequence( WmErase, "Erase", FALSE );
3417     SetRectRgn( hrgn, 0, 50, 100, 100 );
3418     check_update_rgn( hwnd, hrgn );
3419
3420     flush_sequence();
3421     SetRectRgn( hrgn, 0, 0, 100, 100 );
3422     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
3423     SetRectRgn( hrgn, 0, 0, 50, 50 );
3424     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
3425     ok_sequence( WmPaint, "Paint", FALSE );
3426
3427     flush_sequence();
3428     SetRectRgn( hrgn, -4, -4, -2, -2 );
3429     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
3430     SetRectRgn( hrgn, -200, -200, -198, -198 );
3431     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
3432     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
3433
3434     flush_sequence();
3435     SetRectRgn( hrgn, -4, -4, -2, -2 );
3436     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
3437     SetRectRgn( hrgn, -4, -4, -3, -3 );
3438     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
3439     SetRectRgn( hrgn, 0, 0, 1, 1 );
3440     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
3441     ok_sequence( WmPaint, "Paint", FALSE );
3442
3443     flush_sequence();
3444     SetRectRgn( hrgn, -4, -4, -1, -1 );
3445     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
3446     RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
3447     /* make sure no WM_PAINT was generated */
3448     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3449     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
3450
3451     flush_sequence();
3452     SetRectRgn( hrgn, -4, -4, -1, -1 );
3453     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
3454     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
3455     {
3456         if (msg.hwnd == hwnd && msg.message == WM_PAINT)
3457         {
3458             /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
3459             INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
3460             ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
3461             ret = GetUpdateRect( hwnd, &rect, FALSE );
3462             ok( ret, "Invalid GetUpdateRect result %d\n", ret );
3463             /* this will send WM_NCPAINT and validate the non client area */
3464             ret = GetUpdateRect( hwnd, &rect, TRUE );
3465             ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
3466         }
3467         DispatchMessage( &msg );
3468     }
3469     ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
3470
3471     DestroyWindow( hwnd );
3472
3473     /* now test with a child window */
3474
3475     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
3476                               100, 100, 200, 200, 0, 0, 0, NULL);
3477     ok (hparent != 0, "Failed to create parent window\n");
3478
3479     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
3480                            10, 10, 100, 100, hparent, 0, 0, NULL);
3481     ok (hchild != 0, "Failed to create child window\n");
3482
3483     ShowWindow( hparent, SW_SHOW );
3484     UpdateWindow( hparent );
3485     UpdateWindow( hchild );
3486     /* try to flush pending X expose events */
3487     MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
3488     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3489
3490     flush_sequence();
3491     log_all_parent_messages++;
3492
3493     SetRect( &rect, 0, 0, 50, 50 );
3494     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3495     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
3496     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
3497
3498     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3499     pt.x = pt.y = 0;
3500     MapWindowPoints( hchild, hparent, &pt, 1 );
3501     SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
3502     check_update_rgn( hchild, hrgn );
3503     SetRectRgn( hrgn, 0, 0, 50, 50 );
3504     check_update_rgn( hparent, hrgn );
3505     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
3506     ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
3507     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
3508     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
3509
3510     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3511     ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
3512
3513     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
3514     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
3515     ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
3516     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
3517     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
3518
3519     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
3520     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
3521     ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
3522
3523     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
3524     flush_sequence();
3525     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
3526     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
3527     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
3528
3529     /* flush all paint messages */
3530     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3531     flush_sequence();
3532
3533     /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
3534     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
3535     SetRectRgn( hrgn, 0, 0, 50, 50 );
3536     check_update_rgn( hparent, hrgn );
3537     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
3538     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
3539     SetRectRgn( hrgn, 0, 0, 50, 50 );
3540     check_update_rgn( hparent, hrgn );
3541
3542     /* flush all paint messages */
3543     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3544     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
3545     flush_sequence();
3546
3547     /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
3548     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3549     SetRectRgn( hrgn, 0, 0, 50, 50 );
3550     check_update_rgn( hparent, hrgn );
3551     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
3552     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
3553     SetRectRgn( hrgn2, 10, 10, 50, 50 );
3554     CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
3555     check_update_rgn( hparent, hrgn );
3556     /* flush all paint messages */
3557     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3558     flush_sequence();
3559
3560     /* same as above but parent gets completely validated */
3561     SetRect( &rect, 20, 20, 30, 30 );
3562     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3563     SetRectRgn( hrgn, 20, 20, 30, 30 );
3564     check_update_rgn( hparent, hrgn );
3565     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
3566     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
3567     check_update_rgn( hparent, 0 );  /* no update region */
3568     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3569     ok_sequence( WmEmptySeq, "WmEmpty", FALSE );  /* and no paint messages */
3570
3571     /* make sure RDW_VALIDATE on child doesn't have the same effect */
3572     flush_sequence();
3573     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3574     SetRectRgn( hrgn, 20, 20, 30, 30 );
3575     check_update_rgn( hparent, hrgn );
3576     RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
3577     SetRectRgn( hrgn, 20, 20, 30, 30 );
3578     check_update_rgn( hparent, hrgn );
3579
3580     /* same as above but normal WM_PAINT doesn't validate parent */
3581     flush_sequence();
3582     SetRect( &rect, 20, 20, 30, 30 );
3583     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3584     SetRectRgn( hrgn, 20, 20, 30, 30 );
3585     check_update_rgn( hparent, hrgn );
3586     /* no WM_PAINT in child while parent still pending */
3587     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3588     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
3589     while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3590     ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
3591
3592     flush_sequence();
3593     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
3594     /* no WM_PAINT in child while parent still pending */
3595     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3596     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
3597     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
3598     /* now that parent is valid child should get WM_PAINT */
3599     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3600     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
3601     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3602     ok_sequence( WmEmptySeq, "No other message", FALSE );
3603
3604     /* same thing with WS_CLIPCHILDREN in parent */
3605     flush_sequence();
3606     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
3607     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
3608     /* changing style invalidates non client area, but we need to invalidate something else to see it */
3609     RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
3610     ok_sequence( WmEmptySeq, "No message", FALSE );
3611     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
3612     ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
3613
3614     flush_sequence();
3615     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
3616     SetRectRgn( hrgn, 20, 20, 30, 30 );
3617     check_update_rgn( hparent, hrgn );
3618     /* no WM_PAINT in child while parent still pending */
3619     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3620     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
3621     /* WM_PAINT in parent first */
3622     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3623     ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
3624
3625     /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
3626     flush_sequence();
3627     SetRect( &rect, 0, 0, 30, 30 );
3628     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
3629     SetRectRgn( hrgn, 0, 0, 30, 30 );
3630     check_update_rgn( hparent, hrgn );
3631     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3632     ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
3633
3634     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
3635     flush_sequence();
3636     SetRect( &rect, -10, 0, 30, 30 );
3637     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
3638     SetRect( &rect, 0, 0, 20, 20 );
3639     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
3640     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
3641     ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
3642
3643     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
3644     flush_sequence();
3645     SetRect( &rect, -10, 0, 30, 30 );
3646     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
3647     SetRect( &rect, 0, 0, 100, 100 );
3648     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
3649     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
3650     ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
3651     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
3652     ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
3653
3654     /* test RDW_INTERNALPAINT behavior */
3655
3656     flush_sequence();
3657     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
3658     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3659     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
3660
3661     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
3662     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3663     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
3664
3665     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
3666     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3667     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
3668
3669     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
3670     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
3671     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
3672     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3673     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
3674
3675     log_all_parent_messages--;
3676     DestroyWindow( hparent );
3677
3678     DeleteObject( hrgn );
3679     DeleteObject( hrgn2 );
3680 }
3681
3682 struct wnd_event
3683 {
3684     HWND hwnd;
3685     HANDLE event;
3686 };
3687
3688 static DWORD WINAPI thread_proc(void *param)
3689 {
3690     MSG msg;
3691     struct wnd_event *wnd_event = (struct wnd_event *)param;
3692
3693     wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
3694                                       100, 100, 200, 200, 0, 0, 0, NULL);
3695     ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
3696
3697     SetEvent(wnd_event->event);
3698
3699     while (GetMessage(&msg, 0, 0, 0))
3700     {
3701         TranslateMessage(&msg);
3702         DispatchMessage(&msg);
3703     }
3704
3705     ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
3706
3707     return 0;
3708 }
3709
3710 static void test_interthread_messages(void)
3711 {
3712     HANDLE hThread;
3713     DWORD tid;
3714     WNDPROC proc;
3715     MSG msg;
3716     char buf[256];
3717     int len, expected_len;
3718     struct wnd_event wnd_event;
3719     BOOL ret;
3720
3721     wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
3722     if (!wnd_event.event)
3723     {
3724         trace("skipping interthread message test under win9x\n");
3725         return;
3726     }
3727
3728     hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
3729     ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
3730
3731     ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
3732
3733     CloseHandle(wnd_event.event);
3734
3735     SetLastError(0xdeadbeef);
3736     ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
3737     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error code %ld\n", GetLastError());
3738
3739     proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
3740     ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %ld\n", GetLastError());
3741
3742     expected_len = lstrlenA("window caption text");
3743     memset(buf, 0, sizeof(buf));
3744     SetLastError(0xdeadbeef);
3745     len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
3746     ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %ld, len %d, expected len %d\n", GetLastError(), len, expected_len);
3747     ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
3748
3749     msg.hwnd = wnd_event.hwnd;
3750     msg.message = WM_GETTEXT;
3751     msg.wParam = sizeof(buf);
3752     msg.lParam = (LPARAM)buf;
3753     memset(buf, 0, sizeof(buf));
3754     SetLastError(0xdeadbeef);
3755     len = DispatchMessageA(&msg);
3756     ok(!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3757        "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %ld\n", len, GetLastError());
3758
3759     /* the following test causes an exception in user.exe under win9x */
3760     msg.hwnd = wnd_event.hwnd;
3761     msg.message = WM_TIMER;
3762     msg.wParam = 0;
3763     msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
3764     SetLastError(0xdeadbeef);
3765     len = DispatchMessageA(&msg);
3766     ok(!len && GetLastError() == 0xdeadbeef,
3767        "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
3768
3769     ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
3770     ok( ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
3771
3772     ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
3773     CloseHandle(hThread);
3774
3775     ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
3776 }
3777
3778
3779 static const struct message WmVkN[] = {
3780     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
3781     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
3782     { WM_CHAR, wparam|lparam, 'n', 1 },
3783     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
3784     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
3785     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
3786     { 0 }
3787 };
3788 static const struct message WmShiftVkN[] = {
3789     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
3790     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
3791     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
3792     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
3793     { WM_CHAR, wparam|lparam, 'N', 1 },
3794     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
3795     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
3796     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
3797     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
3798     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
3799     { 0 }
3800 };
3801 static const struct message WmCtrlVkN[] = {
3802     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3803     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3804     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
3805     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
3806     { WM_CHAR, wparam|lparam, 0x000e, 1 },
3807     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
3808     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
3809     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
3810     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3811     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3812     { 0 }
3813 };
3814 static const struct message WmCtrlVkN_2[] = {
3815     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3816     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3817     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
3818     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
3819     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
3820     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
3821     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3822     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3823     { 0 }
3824 };
3825 static const struct message WmAltVkN[] = {
3826     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3827     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3828     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
3829     { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
3830     { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
3831     { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
3832     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
3833     { HCBT_SYSCOMMAND, hook },
3834     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
3835     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
3836     { WM_INITMENU, sent|defwinproc },
3837     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
3838     { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
3839     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
3840     { WM_CAPTURECHANGED, sent|defwinproc },
3841     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
3842     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
3843     { WM_EXITMENULOOP, sent|defwinproc },
3844     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
3845     { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
3846     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
3847     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
3848     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3849     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3850     { 0 }
3851 };
3852 static const struct message WmAltVkN_2[] = {
3853     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3854     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3855     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
3856     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
3857     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
3858     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
3859     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3860     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3861     { 0 }
3862 };
3863 static const struct message WmCtrlAltVkN[] = {
3864     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3865     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3866     { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3867     { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3868     { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
3869     { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
3870     { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
3871     { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
3872     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3873     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3874     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3875     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3876     { 0 }
3877 };
3878 static const struct message WmAltPressRelease[] = {
3879     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3880     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3881     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3882     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3883     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
3884     { HCBT_SYSCOMMAND, hook },
3885     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
3886     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
3887     { WM_INITMENU, sent|defwinproc },
3888     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
3889     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
3890     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
3891
3892     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
3893     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
3894     { WM_CAPTURECHANGED, sent|defwinproc },
3895     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
3896     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
3897     { WM_EXITMENULOOP, sent|defwinproc },
3898     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3899     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3900     { 0 }
3901 };
3902 static const struct message WmAltMouseButton[] = {
3903     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3904     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3905     { WM_MOUSEMOVE, wparam|optional, 0, 0 },
3906     { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
3907     { WM_LBUTTONDOWN, wparam, MK_LBUTTON, 0 },
3908     { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON, 0 },
3909     { WM_LBUTTONUP, wparam, 0, 0 },
3910     { WM_LBUTTONUP, sent|wparam, 0, 0 },
3911     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3912     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3913     { 0 }
3914 };
3915
3916 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
3917 {
3918     MSG msg;
3919
3920     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
3921     {
3922         struct message log_msg;
3923
3924         trace("accel: %p, %04x, %08x, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
3925
3926         /* ignore some unwanted messages */
3927         if (msg.message == WM_MOUSEMOVE)
3928             continue;
3929
3930         log_msg.message = msg.message;
3931         log_msg.flags = wparam|lparam;
3932         log_msg.wParam = msg.wParam;
3933         log_msg.lParam = msg.lParam;
3934         add_message(&log_msg);
3935
3936         if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
3937         {
3938             TranslateMessage(&msg);
3939             DispatchMessage(&msg);
3940         }
3941     }
3942 }
3943
3944 static void test_accelerators(void)
3945 {
3946     RECT rc;
3947     SHORT state;
3948     HACCEL hAccel;
3949     HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
3950                                 100, 100, 200, 200, 0, 0, 0, NULL);
3951     BOOL ret;
3952
3953     assert(hwnd != 0);
3954     UpdateWindow(hwnd);
3955     SetFocus(hwnd);
3956     ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
3957
3958     state = GetKeyState(VK_SHIFT);
3959     ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
3960     state = GetKeyState(VK_CAPITAL);
3961     ok(state == 0, "wrong CapsLock state %04x\n", state);
3962
3963     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
3964     assert(hAccel != 0);
3965
3966     pump_msg_loop(hwnd, 0);
3967     flush_sequence();
3968
3969     trace("testing VK_N press/release\n");
3970     flush_sequence();
3971     keybd_event('N', 0, 0, 0);
3972     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
3973     pump_msg_loop(hwnd, hAccel);
3974     ok_sequence(WmVkN, "VK_N press/release", FALSE);
3975
3976     trace("testing Shift+VK_N press/release\n");
3977     flush_sequence();
3978     keybd_event(VK_SHIFT, 0, 0, 0);
3979     keybd_event('N', 0, 0, 0);
3980     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
3981     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
3982     pump_msg_loop(hwnd, hAccel);
3983     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
3984
3985     trace("testing Ctrl+VK_N press/release\n");
3986     flush_sequence();
3987     keybd_event(VK_CONTROL, 0, 0, 0);
3988     keybd_event('N', 0, 0, 0);
3989     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
3990     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
3991     pump_msg_loop(hwnd, hAccel);
3992     ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
3993
3994     trace("testing Alt+VK_N press/release\n");
3995     flush_sequence();
3996     keybd_event(VK_MENU, 0, 0, 0);
3997     keybd_event('N', 0, 0, 0);
3998     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
3999     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4000     pump_msg_loop(hwnd, hAccel);
4001     ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
4002
4003     trace("testing Ctrl+Alt+VK_N press/release\n");
4004     flush_sequence();
4005     keybd_event(VK_CONTROL, 0, 0, 0);
4006     keybd_event(VK_MENU, 0, 0, 0);
4007     keybd_event('N', 0, 0, 0);
4008     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4009     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4010     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4011     pump_msg_loop(hwnd, hAccel);
4012     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
4013
4014     ret = DestroyAcceleratorTable(hAccel);
4015     ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
4016
4017     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
4018     assert(hAccel != 0);
4019
4020     trace("testing VK_N press/release\n");
4021     flush_sequence();
4022     keybd_event('N', 0, 0, 0);
4023     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4024     pump_msg_loop(hwnd, hAccel);
4025     ok_sequence(WmVkN, "VK_N press/release", FALSE);
4026
4027     trace("testing Shift+VK_N press/release\n");
4028     flush_sequence();
4029     keybd_event(VK_SHIFT, 0, 0, 0);
4030     keybd_event('N', 0, 0, 0);
4031     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4032     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
4033     pump_msg_loop(hwnd, hAccel);
4034     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
4035
4036     trace("testing Ctrl+VK_N press/release 2\n");
4037     flush_sequence();
4038     keybd_event(VK_CONTROL, 0, 0, 0);
4039     keybd_event('N', 0, 0, 0);
4040     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4041     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4042     pump_msg_loop(hwnd, hAccel);
4043     ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
4044
4045     trace("testing Alt+VK_N press/release 2\n");
4046     flush_sequence();
4047     keybd_event(VK_MENU, 0, 0, 0);
4048     keybd_event('N', 0, 0, 0);
4049     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4050     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4051     pump_msg_loop(hwnd, hAccel);
4052     ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
4053
4054     trace("testing Ctrl+Alt+VK_N press/release\n");
4055     flush_sequence();
4056     keybd_event(VK_CONTROL, 0, 0, 0);
4057     keybd_event(VK_MENU, 0, 0, 0);
4058     keybd_event('N', 0, 0, 0);
4059     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4060     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4061     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4062     pump_msg_loop(hwnd, hAccel);
4063     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
4064
4065     ret = DestroyAcceleratorTable(hAccel);
4066     ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
4067
4068     trace("testing Alt press/release\n");
4069     flush_sequence();
4070     keybd_event(VK_MENU, 0, 0, 0);
4071     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4072     keybd_event(VK_MENU, 0, 0, 0);
4073     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4074     pump_msg_loop(hwnd, 0);
4075     /* this test doesn't pass in Wine for managed windows */
4076     ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
4077
4078     trace("testing Alt+MouseButton press/release\n");
4079     /* first, move mouse pointer inside of the window client area */
4080     GetClientRect(hwnd, &rc);
4081     MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
4082     rc.left += (rc.right - rc.left)/2;
4083     rc.top += (rc.bottom - rc.top)/2;
4084     SetCursorPos(rc.left, rc.top);
4085
4086     pump_msg_loop(hwnd, 0);
4087     flush_sequence();
4088     keybd_event(VK_MENU, 0, 0, 0);
4089     mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
4090     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
4091     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4092     pump_msg_loop(hwnd, 0);
4093     ok_sequence(WmAltMouseButton, "Alt+MouseButton press/release", FALSE);
4094
4095     DestroyWindow(hwnd);
4096 }
4097
4098 /************* window procedures ********************/
4099
4100 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4101 {
4102     static long defwndproc_counter = 0;
4103     static long beginpaint_counter = 0;
4104     LRESULT ret;
4105     struct message msg;
4106
4107     trace("%p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
4108
4109     switch (message)
4110     {
4111         /* test_accelerators() depends on this */
4112         case WM_NCHITTEST:
4113             return HTCLIENT;
4114
4115         /* ignore */
4116         case WM_MOUSEMOVE:
4117         case WM_SETCURSOR:
4118             return 0;
4119
4120         case WM_WINDOWPOSCHANGING:
4121         case WM_WINDOWPOSCHANGED:
4122         {
4123             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
4124
4125             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
4126             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
4127                   winpos->hwnd, winpos->hwndInsertAfter,
4128                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
4129
4130             /* Log only documented flags, win2k uses 0x1000 and 0x2000
4131              * in the high word for internal purposes
4132              */
4133             wParam = winpos->flags & 0xffff;
4134             break;
4135         }
4136     }
4137
4138     msg.message = message;
4139     msg.flags = sent|wparam|lparam;
4140     if (defwndproc_counter) msg.flags |= defwinproc;
4141     if (beginpaint_counter) msg.flags |= beginpaint;
4142     msg.wParam = wParam;
4143     msg.lParam = lParam;
4144     add_message(&msg);
4145
4146     if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
4147     {
4148         HWND parent = GetParent(hwnd);
4149         RECT rc;
4150         MINMAXINFO *minmax = (MINMAXINFO *)lParam;
4151
4152         GetClientRect(parent, &rc);
4153         trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
4154
4155         trace("ptReserved = (%ld,%ld)\n"
4156               "ptMaxSize = (%ld,%ld)\n"
4157               "ptMaxPosition = (%ld,%ld)\n"
4158               "ptMinTrackSize = (%ld,%ld)\n"
4159               "ptMaxTrackSize = (%ld,%ld)\n",
4160               minmax->ptReserved.x, minmax->ptReserved.y,
4161               minmax->ptMaxSize.x, minmax->ptMaxSize.y,
4162               minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
4163               minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
4164               minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
4165
4166         ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %ld != %ld\n",
4167            minmax->ptMaxSize.x, rc.right);
4168         ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %ld != %ld\n",
4169            minmax->ptMaxSize.y, rc.bottom);
4170     }
4171
4172     if (message == WM_PAINT)
4173     {
4174         PAINTSTRUCT ps;
4175         beginpaint_counter++;
4176         BeginPaint( hwnd, &ps );
4177         beginpaint_counter--;
4178         EndPaint( hwnd, &ps );
4179         return 0;
4180     }
4181
4182     defwndproc_counter++;
4183     ret = DefWindowProcA(hwnd, message, wParam, lParam);
4184     defwndproc_counter--;
4185
4186     return ret;
4187 }
4188
4189 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4190 {
4191     static long defwndproc_counter = 0;
4192     LRESULT ret;
4193     struct message msg;
4194
4195     trace("popup: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
4196
4197     msg.message = message;
4198     msg.flags = sent|wparam|lparam;
4199     if (defwndproc_counter) msg.flags |= defwinproc;
4200     msg.wParam = wParam;
4201     msg.lParam = lParam;
4202     add_message(&msg);
4203
4204     if (message == WM_CREATE)
4205     {
4206         DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
4207         SetWindowLongA(hwnd, GWL_STYLE, style);
4208     }
4209
4210     defwndproc_counter++;
4211     ret = DefWindowProcA(hwnd, message, wParam, lParam);
4212     defwndproc_counter--;
4213
4214     return ret;
4215 }
4216
4217 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4218 {
4219     static long defwndproc_counter = 0;
4220     static long beginpaint_counter = 0;
4221     LRESULT ret;
4222     struct message msg;
4223
4224     trace("parent: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
4225
4226     if (log_all_parent_messages ||
4227         message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
4228         message == WM_SETFOCUS || message == WM_KILLFOCUS ||
4229         message == WM_ENABLE || message == WM_ENTERIDLE ||
4230         message == WM_IME_SETCONTEXT)
4231     {
4232         msg.message = message;
4233         msg.flags = sent|parent|wparam|lparam;
4234         if (defwndproc_counter) msg.flags |= defwinproc;
4235         if (beginpaint_counter) msg.flags |= beginpaint;
4236         msg.wParam = wParam;
4237         msg.lParam = lParam;
4238         add_message(&msg);
4239     }
4240
4241     if (message == WM_PAINT)
4242     {
4243         PAINTSTRUCT ps;
4244         beginpaint_counter++;
4245         BeginPaint( hwnd, &ps );
4246         beginpaint_counter--;
4247         EndPaint( hwnd, &ps );
4248         return 0;
4249     }
4250
4251     defwndproc_counter++;
4252     ret = DefWindowProcA(hwnd, message, wParam, lParam);
4253     defwndproc_counter--;
4254
4255     return ret;
4256 }
4257
4258 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4259 {
4260     static long defwndproc_counter = 0;
4261     LRESULT ret;
4262     struct message msg;
4263
4264     trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
4265
4266     DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
4267     ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
4268     if (after_end_dialog)
4269         ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
4270     else
4271         ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
4272
4273     switch (message)
4274     {
4275         case WM_WINDOWPOSCHANGING:
4276         case WM_WINDOWPOSCHANGED:
4277         {
4278             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
4279
4280             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
4281             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
4282                   winpos->hwnd, winpos->hwndInsertAfter,
4283                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
4284
4285             /* Log only documented flags, win2k uses 0x1000 and 0x2000
4286              * in the high word for internal purposes
4287              */
4288             wParam = winpos->flags & 0xffff;
4289             break;
4290         }
4291     }
4292
4293     msg.message = message;
4294     msg.flags = sent|wparam|lparam;
4295     if (defwndproc_counter) msg.flags |= defwinproc;
4296     msg.wParam = wParam;
4297     msg.lParam = lParam;
4298     add_message(&msg);
4299
4300     defwndproc_counter++;
4301     ret = DefDlgProcA(hwnd, message, wParam, lParam);
4302     defwndproc_counter--;
4303
4304     return ret;
4305 }
4306
4307 static BOOL RegisterWindowClasses(void)
4308 {
4309     WNDCLASSA cls;
4310
4311     cls.style = 0;
4312     cls.lpfnWndProc = MsgCheckProcA;
4313     cls.cbClsExtra = 0;
4314     cls.cbWndExtra = 0;
4315     cls.hInstance = GetModuleHandleA(0);
4316     cls.hIcon = 0;
4317     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
4318     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
4319     cls.lpszMenuName = NULL;
4320     cls.lpszClassName = "TestWindowClass";
4321     if(!RegisterClassA(&cls)) return FALSE;
4322
4323     cls.lpfnWndProc = PopupMsgCheckProcA;
4324     cls.lpszClassName = "TestPopupClass";
4325     if(!RegisterClassA(&cls)) return FALSE;
4326
4327     cls.lpfnWndProc = ParentMsgCheckProcA;
4328     cls.lpszClassName = "TestParentClass";
4329     if(!RegisterClassA(&cls)) return FALSE;
4330
4331     cls.lpfnWndProc = DefWindowProcA;
4332     cls.lpszClassName = "SimpleWindowClass";
4333     if(!RegisterClassA(&cls)) return FALSE;
4334
4335     ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
4336     cls.style = 0;
4337     cls.hInstance = GetModuleHandleA(0);
4338     cls.hbrBackground = 0;
4339     cls.lpfnWndProc = TestDlgProcA;
4340     cls.lpszClassName = "TestDialogClass";
4341     if(!RegisterClassA(&cls)) return FALSE;
4342
4343     return TRUE;
4344 }
4345
4346 static HHOOK hCBT_hook;
4347
4348 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
4349 {
4350     char buf[256];
4351
4352     trace("CBT: %d, %08x, %08lx\n", nCode, wParam, lParam);
4353
4354     if (nCode == HCBT_SYSCOMMAND)
4355     {
4356         struct message msg;
4357
4358         msg.message = nCode;
4359         msg.flags = hook;
4360         msg.wParam = wParam;
4361         msg.lParam = lParam;
4362         add_message(&msg);
4363
4364         return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
4365     }
4366
4367     /* Log also SetFocus(0) calls */
4368     if (!wParam) wParam = lParam;
4369
4370     if (GetClassNameA((HWND)wParam, buf, sizeof(buf)))
4371     {
4372         if (!strcmp(buf, "TestWindowClass") ||
4373             !strcmp(buf, "TestParentClass") ||
4374             !strcmp(buf, "TestPopupClass") ||
4375             !strcmp(buf, "SimpleWindowClass") ||
4376             !strcmp(buf, "TestDialogClass") ||
4377             !strcmp(buf, "MDI_frame_class") ||
4378             !strcmp(buf, "MDI_client_class") ||
4379             !strcmp(buf, "MDI_child_class") ||
4380             !strcmp(buf, "my_button_class") ||
4381             !strcmp(buf, "#32770"))
4382         {
4383             struct message msg;
4384
4385             msg.message = nCode;
4386             msg.flags = hook|wparam|lparam;
4387             msg.wParam = wParam;
4388             msg.lParam = lParam;
4389             add_message(&msg);
4390         }
4391     }
4392     return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
4393 }
4394
4395 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
4396                                     DWORD event,
4397                                     HWND hwnd,
4398                                     LONG object_id,
4399                                     LONG child_id,
4400                                     DWORD thread_id,
4401                                     DWORD event_time)
4402 {
4403     char buf[256];
4404
4405     trace("WEH:%p,event %08lx,hwnd %p,obj %08lx,id %08lx,thread %08lx,time %08lx\n",
4406            hevent, event, hwnd, object_id, child_id, thread_id, event_time);
4407
4408     /* ignore mouse cursor events */
4409     if (object_id == OBJID_CURSOR) return;
4410
4411     if (!hwnd || GetClassNameA(hwnd, buf, sizeof(buf)))
4412     {
4413         if (!hwnd ||
4414             !strcmp(buf, "TestWindowClass") ||
4415             !strcmp(buf, "TestParentClass") ||
4416             !strcmp(buf, "TestPopupClass") ||
4417             !strcmp(buf, "SimpleWindowClass") ||
4418             !strcmp(buf, "TestDialogClass") ||
4419             !strcmp(buf, "MDI_frame_class") ||
4420             !strcmp(buf, "MDI_client_class") ||
4421             !strcmp(buf, "MDI_child_class") ||
4422             !strcmp(buf, "my_button_class") ||
4423             !strcmp(buf, "#32770"))
4424         {
4425             struct message msg;
4426
4427             msg.message = event;
4428             msg.flags = winevent_hook|wparam|lparam;
4429             msg.wParam = object_id;
4430             msg.lParam = child_id;
4431             add_message(&msg);
4432         }
4433     }
4434 }
4435
4436 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
4437 static const WCHAR wszAnsi[] = {'U',0};
4438
4439 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
4440 {
4441     switch (uMsg)
4442     {
4443     case CB_FINDSTRINGEXACT:
4444         trace("String: %p\n", (LPCWSTR)lParam);
4445         if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
4446             return 1;
4447         if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
4448             return 0;
4449         return -1;
4450     }
4451     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
4452 }
4453
4454 static void test_message_conversion(void)
4455 {
4456     static const WCHAR wszMsgConversionClass[] =
4457         {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
4458     WNDCLASSW cls;
4459     LRESULT lRes;
4460     HWND hwnd;
4461     WNDPROC wndproc;
4462
4463     cls.style = 0;
4464     cls.lpfnWndProc = MsgConversionProcW;
4465     cls.cbClsExtra = 0;
4466     cls.cbWndExtra = 0;
4467     cls.hInstance = GetModuleHandleW(NULL);
4468     cls.hIcon = NULL;
4469     cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
4470     cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
4471     cls.lpszMenuName = NULL;
4472     cls.lpszClassName = wszMsgConversionClass;
4473     /* this call will fail on Win9x, but that doesn't matter as this test is
4474      * meaningless on those platforms */
4475     if(!RegisterClassW(&cls)) return;
4476
4477     hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
4478                            100, 100, 200, 200, 0, 0, 0, NULL);
4479     ok(hwnd != NULL, "Window creation failed\n");
4480
4481     /* {W, A} -> A */
4482
4483     wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
4484     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4485     ok(lRes == 0, "String should have been converted\n");
4486     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4487     ok(lRes == 1, "String shouldn't have been converted\n");
4488
4489     /* {W, A} -> W */
4490
4491     wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
4492     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4493     ok(lRes == 1, "String shouldn't have been converted\n");
4494     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4495     ok(lRes == 1, "String shouldn't have been converted\n");
4496
4497     /* Synchronous messages */
4498
4499     lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4500     ok(lRes == 0, "String should have been converted\n");
4501     lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4502     ok(lRes == 1, "String shouldn't have been converted\n");
4503
4504     /* Asynchronous messages */
4505
4506     SetLastError(0);
4507     lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4508     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4509         "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4510     SetLastError(0);
4511     lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4512     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4513         "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4514     SetLastError(0);
4515     lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4516     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4517         "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4518     SetLastError(0);
4519     lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4520     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4521         "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4522     SetLastError(0);
4523     lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4524     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4525         "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4526     SetLastError(0);
4527     lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
4528     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4529         "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4530     SetLastError(0);
4531     lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
4532     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4533         "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4534     SetLastError(0);
4535     lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
4536     ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4537         "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
4538 }
4539
4540 typedef struct _thread_info
4541 {
4542     HWND hWnd;
4543     HANDLE handles[2];
4544     DWORD id;
4545 } thread_info;
4546
4547 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT id, DWORD dwTime)
4548 {
4549 }
4550
4551 #define TIMER_ID  0x19
4552
4553 static DWORD WINAPI timer_thread_proc(LPVOID x)
4554 {
4555     thread_info *info = x;
4556     DWORD r;
4557
4558     r = KillTimer(info->hWnd, 0x19);
4559     ok(r,"KillTimer failed in thread\n");
4560     r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
4561     ok(r,"SetTimer failed in thread\n");
4562     ok(r==TIMER_ID,"SetTimer id different\n");
4563     r = SetEvent(info->handles[0]);
4564     ok(r,"SetEvent failed in thread\n");
4565     return 0;
4566 }
4567
4568 static void test_timers(void)
4569 {
4570     thread_info info;
4571     DWORD id;
4572
4573     info.hWnd = CreateWindow ("TestWindowClass", NULL,
4574        WS_OVERLAPPEDWINDOW ,
4575        CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4576        NULL, NULL, 0);
4577
4578     info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
4579     ok(info.id, "SetTimer failed\n");
4580     ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
4581     info.handles[0] = CreateEvent(NULL,0,0,NULL);
4582     info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
4583
4584     WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
4585
4586     WaitForSingleObject(info.handles[1], INFINITE);
4587
4588     ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
4589
4590     ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
4591 }
4592
4593 /* Various win events with arbitrary parameters */
4594 static const struct message WmWinEventsSeq[] = {
4595     { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
4596     { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
4597     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
4598     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
4599     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
4600     { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
4601     { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
4602     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
4603     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
4604     /* our win event hook ignores OBJID_CURSOR events */
4605     /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
4606     { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
4607     { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
4608     { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
4609     { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
4610     { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
4611     { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
4612     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
4613     { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
4614     { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
4615     { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
4616     { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
4617     { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
4618     { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
4619     { 0 }
4620 };
4621
4622 static void test_winevents(void)
4623 {
4624     HWND hwnd;
4625     UINT i;
4626     const struct message *events = WmWinEventsSeq;
4627     HMODULE user32 = GetModuleHandleA("user32.dll");
4628     FARPROC pNotifyWinEvent = GetProcAddress(user32, "NotifyWinEvent");
4629
4630     if (!pNotifyWinEvent) return;
4631
4632     hwnd = CreateWindow ("TestWindowClass", NULL,
4633                         WS_OVERLAPPEDWINDOW,
4634                         CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4635                         NULL, NULL, 0);
4636     assert(hwnd);
4637
4638     flush_sequence();
4639
4640     /* Windows ignores events with hwnd == 0 */
4641     SetLastError(0xdeadbeef);
4642     pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
4643     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
4644        GetLastError() == 0xdeadbeef, /* Win9x */
4645        "unexpected error %ld\n", GetLastError());
4646     ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
4647
4648     for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
4649         pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
4650
4651     ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
4652     ok(DestroyWindow(hwnd), "failed to destroy window\n");
4653 }
4654
4655 START_TEST(msg)
4656 {
4657     HMODULE user32 = GetModuleHandleA("user32.dll");
4658     FARPROC pSetWinEventHook = 0;/*GetProcAddress(user32, "SetWinEventHook");*/
4659     FARPROC pUnhookWinEvent = 0;/*GetProcAddress(user32, "UnhookWinEvent");*/
4660     FARPROC pIsWinEventHookInstalled = GetProcAddress(user32, "IsWinEventHookInstalled");
4661
4662     if (!RegisterWindowClasses()) assert(0);
4663
4664     if (pSetWinEventHook)
4665     {
4666         UINT event;
4667         hEvent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
4668                                                       GetModuleHandleA(0),
4669                                                       win_event_proc,
4670                                                       GetCurrentProcessId(),
4671                                                       0,
4672                                                       WINEVENT_INCONTEXT);
4673         assert(hEvent_hook);
4674
4675         if (pIsWinEventHookInstalled)
4676         {
4677             for (event = EVENT_MIN; event <= EVENT_MAX; event++)
4678                 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
4679         }
4680     }
4681
4682     hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
4683     assert(hCBT_hook);
4684
4685     test_messages();
4686     test_mdi_messages();
4687     test_button_messages();
4688     test_paint_messages();
4689     test_interthread_messages();
4690     test_message_conversion();
4691     test_accelerators();
4692     test_timers();
4693     test_winevents();
4694
4695     UnhookWindowsHookEx(hCBT_hook);
4696     if (pUnhookWinEvent)
4697     {
4698         ok(pUnhookWinEvent(hEvent_hook), "UnhookWinEvent error %ld\n", GetLastError());
4699         SetLastError(0xdeadbeef);
4700         ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
4701         ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
4702            GetLastError() == 0xdeadbeef, /* Win9x */
4703            "unexpected error %ld\n", GetLastError());
4704     }
4705 }