?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Menu item with a "magic" bitmap should not have MFT_BITMAP type set.
[wine.git] / dlls / user32 / tests / menu.c
blob7599431ab60c909c15101d40a250f340f84c856b
1 /*
2 * Unit tests for menus
3 *
4 * Copyright 2005 Robert Shearman
5 * Copyright 2007 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define _WIN32_WINNT 0x0501
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #define OEMRESOURCE /* For OBM_MNARROW */
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wingdi.h"
34 #include "winuser.h"
35
36 #include "wine/test.h"
37
38 static ATOM atomMenuCheckClass;
39
40 static BOOL (WINAPI *pGetMenuInfo)(HMENU,LPCMENUINFO);
41 static BOOL (WINAPI *pGetMenuBarInfo)(HWND,LONG,LONG,PMENUBARINFO);
42 static UINT (WINAPI *pSendInput)(UINT, INPUT*, size_t);
43 static BOOL (WINAPI *pSetMenuInfo)(HMENU,LPCMENUINFO);
44 static BOOL (WINAPI *pEndMenu) (void);
45
46 static void init_function_pointers(void)
47 {
48 HMODULE hdll = GetModuleHandleA("user32");
49
50 #define GET_PROC(func) \
51 p ## func = (void*)GetProcAddress(hdll, #func); \
52 if(!p ## func) \
53 trace("GetProcAddress(%s) failed\n", #func);
54
55 GET_PROC(GetMenuInfo)
56 GET_PROC(GetMenuBarInfo)
57 GET_PROC(SendInput)
58 GET_PROC(SetMenuInfo)
59 GET_PROC(EndMenu)
60
61 #undef GET_PROC
62 }
63
64 static BOOL correct_behavior(void)
65 {
66 HMENU hmenu;
67 MENUITEMINFOA info;
68 BOOL rc;
69
70 hmenu = CreateMenu();
71
72 memset(&info, 0, sizeof(MENUITEMINFOA));
73 info.cbSize= sizeof(MENUITEMINFOA);
74 SetLastError(0xdeadbeef);
75 rc = GetMenuItemInfoA(hmenu, 0, TRUE, &info);
76 /* Win9x : 0xdeadbeef
77 * NT4 : ERROR_INVALID_PARAMETER
78 * >= W2K : ERROR_MENU_ITEM_NOT_FOUND
79 */
80 if (!rc && GetLastError() != ERROR_MENU_ITEM_NOT_FOUND)
81 {
82 win_skip("NT4 and below can't handle a bigger MENUITEMINFO struct\n");
83 DestroyMenu(hmenu);
84 return FALSE;
85 }
86
87 DestroyMenu(hmenu);
88 return TRUE;
89 }
90
91 static LRESULT WINAPI menu_check_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
92 {
93 switch (msg)
94 {
95 case WM_ENTERMENULOOP:
96 /* mark window as having entered menu loop */
97 SetWindowLongPtrA(hwnd, GWLP_USERDATA, TRUE);
98 /* exit menu modal loop
99 * ( A SendMessage does not work on NT3.51 here ) */
100 return PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
101 }
102 return DefWindowProcA(hwnd, msg, wparam, lparam);
103 }
104
105 /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define
106 * our own type */
107 typedef struct
108 {
109 DWORD type;
110 union
111 {
112 MOUSEINPUT mi;
113 KEYBDINPUT ki;
114 HARDWAREINPUT hi;
115 } u;
116 } TEST_INPUT;
117
118 /* globals to communicate between test and wndproc */
119
120 static BOOL bMenuVisible;
121 static INT popmenu;
122 static BOOL got_input;
123 static HMENU hMenus[4];
124
125 #define MOD_SIZE 10
126 #define MOD_NRMENUS 8
127
128 /* menu texts with their sizes */
129 static struct {
130 LPCSTR text;
131 SIZE size; /* size of text up to any \t */
132 SIZE sc_size; /* size of the short-cut */
133 } MOD_txtsizes[] = {
134 { "Pinot &Noir" },
135 { "&Merlot\bF4" },
136 { "Shira&z\tAlt+S" },
137 { "" },
138 { NULL }
139 };
140
141 static unsigned int MOD_maxid;
142 static RECT MOD_rc[MOD_NRMENUS];
143 static int MOD_avec, MOD_hic;
144 static int MOD_odheight;
145 static SIZE MODsizes[MOD_NRMENUS]= { {MOD_SIZE, MOD_SIZE},{MOD_SIZE, MOD_SIZE},
146 {MOD_SIZE, MOD_SIZE},{MOD_SIZE, MOD_SIZE}};
147 static BOOL MOD_GotDrawItemMsg = FALSE;
148 static int gflag_initmenupopup,
149 gflag_entermenuloop,
150 gflag_initmenu,
151 gflag_enteridle;
152 static WPARAM selectitem_wp;
153 static LPARAM selectitem_lp;
154
155 /* wndproc used by test_menu_ownerdraw() */
156 static LRESULT WINAPI menu_ownerdraw_wnd_proc(HWND hwnd, UINT msg,
157 WPARAM wparam, LPARAM lparam)
158 {
159 static HMENU hmenupopup;
160 switch (msg)
161 {
162 case WM_INITMENUPOPUP:
163 gflag_initmenupopup++;
164 hmenupopup = (HMENU) wparam;
165 break;
166 case WM_ENTERMENULOOP:
167 gflag_entermenuloop++;
168 break;
169 case WM_INITMENU:
170 gflag_initmenu++;
171 break;
172 case WM_MEASUREITEM:
173 {
174 MEASUREITEMSTRUCT* pmis = (MEASUREITEMSTRUCT*)lparam;
175 if (winetest_debug > 1)
176 trace("WM_MEASUREITEM received data %lx size %dx%d\n",
177 pmis->itemData, pmis->itemWidth, pmis->itemHeight);
178 ok( !wparam, "wrong wparam %lx\n", wparam );
179 ok( pmis->CtlType == ODT_MENU, "wrong type %x\n", pmis->CtlType );
180 MOD_odheight = pmis->itemHeight;
181 pmis->itemWidth = MODsizes[pmis->itemData].cx;
182 pmis->itemHeight = MODsizes[pmis->itemData].cy;
183 return TRUE;
184 }
185 case WM_DRAWITEM:
186 {
187 DRAWITEMSTRUCT * pdis;
188 TEXTMETRICA tm;
189 HPEN oldpen;
190 char chrs[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
191 SIZE sz;
192 int i;
193 pdis = (DRAWITEMSTRUCT *) lparam;
194 if (winetest_debug > 1) {
195 RECT rc;
196 GetMenuItemRect( hwnd, (HMENU)pdis->hwndItem, pdis->itemData ,&rc);
197 trace("WM_DRAWITEM received hwnd %p hmenu %p itemdata %ld item %d rc %d,%d-%d,%d itemrc: %d,%d-%d,%d\n",
198 hwnd, pdis->hwndItem, pdis->itemData, pdis->itemID,
199 pdis->rcItem.left, pdis->rcItem.top,
200 pdis->rcItem.right,pdis->rcItem.bottom,
201 rc.left,rc.top,rc.right,rc.bottom);
202 oldpen=SelectObject( pdis->hDC, GetStockObject(
203 pdis->itemState & ODS_SELECTED ? WHITE_PEN :BLACK_PEN));
204 Rectangle( pdis->hDC, pdis->rcItem.left,pdis->rcItem.top,
205 pdis->rcItem.right,pdis->rcItem.bottom );
206 SelectObject( pdis->hDC, oldpen);
207 }
208 ok( !wparam, "wrong wparam %lx\n", wparam );
209 ok( pdis->CtlType == ODT_MENU, "wrong type %x\n", pdis->CtlType );
210 /* calculate widths of some menu texts */
211 if( ! MOD_txtsizes[0].size.cx)
212 for(i = 0; MOD_txtsizes[i].text; i++) {
213 char buf[100], *p;
214 RECT rc={0,0,0,0};
215 strcpy( buf, MOD_txtsizes[i].text);
216 if( ( p = strchr( buf, '\t'))) {
217 *p = '\0';
218 DrawTextA( pdis->hDC, p + 1, -1, &rc,
219 DT_SINGLELINE|DT_CALCRECT);
220 MOD_txtsizes[i].sc_size.cx= rc.right - rc.left;
221 MOD_txtsizes[i].sc_size.cy= rc.bottom - rc.top;
222 }
223 DrawTextA( pdis->hDC, buf, -1, &rc,
224 DT_SINGLELINE|DT_CALCRECT);
225 MOD_txtsizes[i].size.cx= rc.right - rc.left;
226 MOD_txtsizes[i].size.cy= rc.bottom - rc.top;
227 }
228
229 if( pdis->itemData > MOD_maxid) return TRUE;
230 /* store the rectangle */
231 MOD_rc[pdis->itemData] = pdis->rcItem;
232 /* calculate average character width */
233 GetTextExtentPointA( pdis->hDC, chrs, 52, &sz );
234 MOD_avec = (sz.cx + 26)/52;
235 GetTextMetricsA( pdis->hDC, &tm);
236 MOD_hic = tm.tmHeight;
237 MOD_GotDrawItemMsg = TRUE;
238 return TRUE;
239 }
240 case WM_ENTERIDLE:
241 {
242 gflag_enteridle++;
243 ok( lparam || broken(!lparam), /* win9x, nt4 */
244 "Menu window handle is NULL!\n");
245 if( lparam) {
246 HMENU hmenu = (HMENU)SendMessageA( (HWND)lparam, MN_GETHMENU, 0, 0);
247 ok( hmenupopup == hmenu, "MN_GETHMENU returns %p expected %p\n",
248 hmenu, hmenupopup);
249 }
250 PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
251 return TRUE;
252 }
253 case WM_MENUSELECT:
254 selectitem_wp = wparam;
255 selectitem_lp = lparam;
256 break;
257 }
258 return DefWindowProcA(hwnd, msg, wparam, lparam);
259 }
260
261 static void register_menu_check_class(void)
262 {
263 WNDCLASSA wc =
264 {
265 0,
266 menu_check_wnd_proc,
267 0,
268 0,
269 GetModuleHandleA(NULL),
270 NULL,
271 LoadCursorA(NULL, (LPCSTR)IDC_ARROW),
272 (HBRUSH)(COLOR_BTNFACE+1),
273 NULL,
274 "WineMenuCheck",
275 };
276
277 atomMenuCheckClass = RegisterClassA(&wc);
278 }
279
280 static void test_getmenubarinfo(void)
281 {
282 BOOL ret;
283 HMENU hmenu;
284 MENUBARINFO mbi;
285 RECT rcw, rci;
286 HWND hwnd;
287 INT err;
288
289 if (!pGetMenuBarInfo) {
290 win_skip("GetMenuBarInfo is not available\n");
291 return;
292 }
293
294 mbi.cbSize = sizeof(MENUBARINFO);
295
296 hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
297 WS_SYSMENU | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,
298 NULL, NULL, NULL, NULL);
299 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
300
301 /* no menu: getmenubarinfo should fail */
302 SetLastError(0xdeadbeef);
303 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
304 err = GetLastError();
305 ok(ret == FALSE, "GetMenuBarInfo should not have been successful\n");
306 ok(err == 0xdeadbeef, "err = %d\n", err);
307
308 /* create menubar, no items yet */
309 hmenu = CreateMenu();
310 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
311
312 ret = SetMenu(hwnd, hmenu);
313 ok(ret, "SetMenu failed with error %d\n", GetLastError());
314
315 SetLastError(0xdeadbeef);
316 ret = pGetMenuBarInfo(NULL, OBJID_CLIENT, 0, &mbi);
317 err = GetLastError();
318 ok(!ret, "GetMenuBarInfo succeeded\n");
319 ok(err == ERROR_INVALID_WINDOW_HANDLE, "err = %d\n", err);
320
321 SetLastError(0xdeadbeef);
322 ret = pGetMenuBarInfo(hwnd, OBJID_CLIENT, 0, &mbi);
323 err = GetLastError();
324 ok(!ret, "GetMenuBarInfo succeeded\n");
325 ok(err==ERROR_INVALID_MENU_HANDLE || broken(err==0xdeadbeef) /* NT, W2K, XP */, "err = %d\n", err);
326
327 SetLastError(0xdeadbeef);
328 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, -1, &mbi);
329 err = GetLastError();
330 ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
331 ok(err == 0xdeadbeef, "err = %d\n", err);
332
333 mbi.cbSize = 1000;
334 SetLastError(0xdeadbeef);
335 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
336 err = GetLastError();
337 ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
338 ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
339 mbi.cbSize = sizeof(MENUBARINFO);
340
341 SetLastError(0xdeadbeef);
342 ret = pGetMenuBarInfo(hwnd, 123, 0, &mbi);
343 err = GetLastError();
344 ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
345 ok(err == 0xdeadbeef, "err = %d\n", err);
346
347 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
348 ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
349
350 ok(mbi.rcBar.left == 0 && mbi.rcBar.top == 0 &&
351 mbi.rcBar.bottom == 0 && mbi.rcBar.right == 0,
352 "rcBar: Expected 0,0-0,0, got: %d,%d-%d,%d\n",
353 mbi.rcBar.left, mbi.rcBar.top, mbi.rcBar.right, mbi.rcBar.bottom);
354 ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n",
355 mbi.hMenu, hmenu);
356 ok(mbi.fBarFocused == 0, "fBarFocused: Got %d instead of 0.\n", mbi.fBarFocused);
357 ok(mbi.fFocused == 0, "fFocused: Got %d instead of 0.\n", mbi.fFocused);
358
359 /* add some items */
360 ret = AppendMenuA(hmenu, MF_STRING , 100, "item 1");
361 ok(ret, "AppendMenu failed.\n");
362 ret = AppendMenuA(hmenu, MF_STRING , 101, "item 2");
363 ok(ret, "AppendMenu failed.\n");
364 ret = SetMenu(hwnd, hmenu);
365 ok(ret, "SetMenu failed with error %d\n", GetLastError());
366
367 SetLastError(0xdeadbeef);
368 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 200, &mbi);
369 err = GetLastError();
370 ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
371 ok(err == 0xdeadbeef, "err = %d\n", err);
372
373 /* get info for the whole menu */
374 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
375 ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
376
377 /* calculate menu rectangle, from window rectangle and the position of the first item */
378 ret = GetWindowRect(hwnd, &rcw);
379 ok(ret, "GetWindowRect failed.\n");
380 ret = GetMenuItemRect(hwnd, hmenu, 0, &rci);
381 ok(ret, "GetMenuItemRect failed.\n");
382 todo_wine ok(mbi.rcBar.left == rci.left && mbi.rcBar.top == rci.top &&
383 mbi.rcBar.bottom == rci.bottom && mbi.rcBar.right == rcw.right - rci.left + rcw.left,
384 "rcBar: Got %d,%d-%d,%d instead of %d,%d-%d,%d\n",
385 mbi.rcBar.left, mbi.rcBar.top, mbi.rcBar.right, mbi.rcBar.bottom,
386 rci.left, rci.top, rcw.right - rci.left + rcw.left, rci.bottom);
387 ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n", mbi.hMenu, hmenu);
388 ok(mbi.fBarFocused == 0, "fBarFocused: got %d instead of 0\n", mbi.fBarFocused);
389 ok(mbi.fFocused == 0, "fFocused: got %d instead of 0\n", mbi.fFocused);
390
391 /* get info for item nr.2 */
392 ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 2, &mbi);
393 ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
394 ret = GetMenuItemRect(hwnd, hmenu, 1, &rci);
395 ok(ret, "GetMenuItemRect failed.\n");
396 ok(mbi.rcBar.left == rci.left && mbi.rcBar.top == rci.top &&
397 mbi.rcBar.bottom == rci.bottom && mbi.rcBar.right == rci.right,
398 "rcBar: Got %d,%d-%d,%d instead of %d,%d-%d,%d\n",
399 mbi.rcBar.left, mbi.rcBar.top, mbi.rcBar.right, mbi.rcBar.bottom,
400 rci.left, rci.top, rci.right, rci.bottom);
401 ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n", mbi.hMenu, hmenu);
402 ok(mbi.fBarFocused == 0, "fBarFocused: got %d instead of 0\n", mbi.fBarFocused);
403 ok(mbi.fFocused == 0, "fFocused: got %d instead of 0\n", mbi.fFocused);
404
405 DestroyWindow(hwnd);
406 }
407
408 /* demonstrates that windows locks the menu object so that it is still valid
409 * even after a client calls DestroyMenu on it */
410 static void test_menu_locked_by_window(void)
411 {
412 BOOL ret;
413 HMENU hmenu;
414 HWND hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
415 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
416 NULL, NULL, NULL, NULL);
417 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
418 hmenu = CreateMenu();
419 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
420 ret = InsertMenuA(hmenu, 0, MF_STRING, 0, "&Test");
421 ok(ret, "InsertMenu failed with error %d\n", GetLastError());
422 ret = SetMenu(hwnd, hmenu);
423 ok(ret, "SetMenu failed with error %d\n", GetLastError());
424 ret = DestroyMenu(hmenu);
425 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
426
427 ret = DrawMenuBar(hwnd);
428 ok(ret, "DrawMenuBar failed with error %d\n", GetLastError());
429 ret = IsMenu(GetMenu(hwnd));
430 ok(!ret || broken(ret) /* nt4 */, "Menu handle should have been destroyed\n");
431
432 SendMessageA(hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
433 /* did we process the WM_INITMENU message? */
434 ret = GetWindowLongPtrA(hwnd, GWLP_USERDATA);
435 todo_wine {
436 ok(ret, "WM_INITMENU should have been sent\n");
437 }
438
439 DestroyWindow(hwnd);
440 }
441
442 /* demonstrates that subpopup's are locked
443 * even after a client calls DestroyMenu on it */
444 static LRESULT WINAPI subpopuplocked_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
445 {
446 HWND hwndmenu;
447 switch (msg)
448 {
449 case WM_ENTERIDLE:
450 hwndmenu = GetCapture();
451 if( hwndmenu) {
452 PostMessageA( hwndmenu, WM_KEYDOWN, VK_DOWN, 0);
453 PostMessageA( hwndmenu, WM_KEYDOWN, VK_RIGHT, 0);
454 PostMessageA( hwndmenu, WM_KEYDOWN, VK_RETURN, 0);
455 }
456 }
457 return DefWindowProcA(hwnd, msg, wparam, lparam);
458 }
459
460 static void test_subpopup_locked_by_menu(void)
461 {
462 DWORD gle;
463 BOOL ret;
464 HMENU hmenu, hsubmenu;
465 MENUINFO mi = { sizeof( MENUINFO)};
466 MENUITEMINFOA mii = { sizeof( MENUITEMINFOA)};
467 HWND hwnd;
468 const int itemid = 0x1234567;
469 if( !pGetMenuInfo)
470 {
471 win_skip("GetMenuInfo is not available\n");
472 return;
473 }
474 /* create window, popupmenu with one subpopup */
475 hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
476 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
477 NULL, NULL, NULL, NULL);
478 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
479 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR) subpopuplocked_wnd_proc);
480 hmenu = CreatePopupMenu();
481 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
482 hsubmenu = CreatePopupMenu();
483 ok(hsubmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
484 ret = InsertMenuA(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hsubmenu,
485 "PopUpLockTest");
486 ok(ret, "InsertMenu failed with error %d\n", GetLastError());
487 ret = InsertMenuA(hsubmenu, 0, MF_BYPOSITION | MF_STRING, itemid, "PopUpMenu");
488 ok(ret, "InsertMenu failed with error %d\n", GetLastError());
489 /* first some tests that all this functions properly */
490 mii.fMask = MIIM_SUBMENU;
491 ret = GetMenuItemInfoA( hmenu, 0, TRUE, &mii);
492 ok( ret, "GetMenuItemInfo failed error %d\n", GetLastError());
493 ok( mii.hSubMenu == hsubmenu, "submenu is %p\n", mii.hSubMenu);
494 mi.fMask |= MIM_STYLE;
495 ret = pGetMenuInfo( hsubmenu, &mi);
496 ok( ret , "GetMenuInfo returned 0 with error %d\n", GetLastError());
497 ret = IsMenu( hsubmenu);
498 ok( ret , "Menu handle is not valid\n");
499 SetLastError( 0xdeadbeef);
500 ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
501 if( ret == (itemid & 0xffff)) {
502 win_skip("not on 16 bit menu subsystem\n");
503 DestroyMenu( hsubmenu);
504 } else {
505 gle = GetLastError();
506 ok( ret == itemid , "TrackPopupMenu returned %d error is %d\n", ret, gle);
507 ok( gle == 0 ||
508 broken( gle == 0xdeadbeef), /* win2k0 */
509 "Last error is %d\n", gle);
510 /* then destroy the sub-popup */
511 ret = DestroyMenu( hsubmenu);
512 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
513 /* and repeat the tests */
514 mii.fMask = MIIM_SUBMENU;
515 ret = GetMenuItemInfoA( hmenu, 0, TRUE, &mii);
516 ok( ret, "GetMenuItemInfo failed error %d\n", GetLastError());
517 /* GetMenuInfo fails now */
518 ok( mii.hSubMenu == hsubmenu, "submenu is %p\n", mii.hSubMenu);
519 mi.fMask |= MIM_STYLE;
520 ret = pGetMenuInfo( hsubmenu, &mi);
521 ok( !ret , "GetMenuInfo should have failed\n");
522 /* IsMenu says it is not */
523 ret = IsMenu( hsubmenu);
524 ok( !ret , "Menu handle should be invalid\n");
525 /* but TrackPopupMenu still works! */
526 SetLastError( 0xdeadbeef);
527 ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
528 gle = GetLastError();
529 todo_wine {
530 ok( ret == itemid , "TrackPopupMenu returned %d error is %d\n", ret, gle);
531 }
532 ok( gle == 0 ||
533 broken(gle == 0xdeadbeef) || /* wow64 */
534 broken(gle == ERROR_INVALID_PARAMETER), /* win2k0 */
535 "Last error is %d\n", gle);
536 }
537 /* clean up */
538 DestroyMenu( hmenu);
539 DestroyWindow(hwnd);
540 }
541
542 static void test_menu_ownerdraw(void)
543 {
544 int i,j,k;
545 BOOL ret;
546 HMENU hmenu;
547 MENUITEMINFOA mii;
548 LONG leftcol;
549 HWND hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
550 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
551 NULL, NULL, NULL, NULL);
552 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
553 if( !hwnd) return;
554 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
555 hmenu = CreatePopupMenu();
556 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
557 if( !hmenu) { DestroyWindow(hwnd);return;}
558 k=0;
559 for( j=0;j<2;j++) /* create columns */
560 for(i=0;i<2;i++) { /* create rows */
561 ret = AppendMenuA( hmenu, MF_OWNERDRAW |
562 (i==0 ? MF_MENUBREAK : 0), k, (LPCSTR)MAKEINTRESOURCE(k));
563 k++;
564 ok( ret, "AppendMenu failed for %d\n", k-1);
565 }
566 MOD_maxid = k-1;
567 assert( k <= sizeof(MOD_rc)/sizeof(RECT));
568 /* display the menu */
569 TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
570
571 /* columns have a 4 pixel gap between them */
572 ok( MOD_rc[0].right + 4 == MOD_rc[2].left,
573 "item rectangles are not separated by 4 pixels space\n");
574 /* height should be what the MEASUREITEM message has returned */
575 ok( MOD_rc[0].bottom - MOD_rc[0].top == MOD_SIZE,
576 "menu item has wrong height: %d should be %d\n",
577 MOD_rc[0].bottom - MOD_rc[0].top, MOD_SIZE);
578 /* no gaps between the rows */
579 ok( MOD_rc[0].bottom - MOD_rc[1].top == 0,
580 "There should not be a space between the rows, gap is %d\n",
581 MOD_rc[0].bottom - MOD_rc[1].top);
582 /* test the correct value of the item height that was sent
583 * by the WM_MEASUREITEM message */
584 ok( MOD_odheight == HIWORD( GetDialogBaseUnits()) || /* WinNT,2k,XP */
585 MOD_odheight == MOD_hic, /* Win95,98,ME */
586 "Wrong height field in MEASUREITEMSTRUCT, expected %d or %d actual %d\n",
587 HIWORD( GetDialogBaseUnits()), MOD_hic, MOD_odheight);
588 /* test what MF_MENUBREAK did at the first position. Also show
589 * that an MF_SEPARATOR is ignored in the height calculation. */
590 leftcol= MOD_rc[0].left;
591 ModifyMenuA( hmenu, 0, MF_BYCOMMAND| MF_OWNERDRAW| MF_SEPARATOR, 0, 0);
592 /* display the menu */
593 TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
594 /* left should be 4 pixels less now */
595 ok( leftcol == MOD_rc[0].left + 4,
596 "columns should be 4 pixels to the left (actual %d).\n",
597 leftcol - MOD_rc[0].left);
598 /* test width */
599 ok( MOD_rc[0].right - MOD_rc[0].left == 2 * MOD_avec + MOD_SIZE,
600 "width of owner drawn menu item is wrong. Got %d expected %d\n",
601 MOD_rc[0].right - MOD_rc[0].left , 2*MOD_avec + MOD_SIZE);
602 /* and height */
603 ok( MOD_rc[0].bottom - MOD_rc[0].top == MOD_SIZE,
604 "Height is incorrect. Got %d expected %d\n",
605 MOD_rc[0].bottom - MOD_rc[0].top, MOD_SIZE);
606
607 /* test owner-drawn callback bitmap */
608 ModifyMenuA( hmenu, 1, MF_BYPOSITION | MFT_BITMAP, 1, (LPCSTR)HBMMENU_CALLBACK );
609 mii.cbSize = sizeof(mii);
610 mii.fMask = MIIM_BITMAP | MIIM_FTYPE | MIIM_ID;
611 if (GetMenuItemInfoA( hmenu, 1, TRUE, &mii ))
612 {
613 ok( mii.fType == MFT_BITMAP, "wrong type %x\n", mii.fType );
614 ok( mii.wID == 1, "wrong id %x\n", mii.wID );
615 ok( mii.hbmpItem == HBMMENU_CALLBACK, "wrong data %p\n", mii.hbmpItem );
616 }
617 TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
618
619 /* test width/height of an ownerdraw menu bar as well */
620 ret = DestroyMenu(hmenu);
621 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
622 hmenu = CreateMenu();
623 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
624 if( !hmenu) { DestroyWindow(hwnd);return;}
625 MOD_maxid=1;
626 for(i=0;i<2;i++) {
627 ret = AppendMenuA( hmenu, MF_OWNERDRAW, i, 0 );
628 ok( ret, "AppendMenu failed for %d\n", i);
629 }
630 ret = SetMenu( hwnd, hmenu);
631 UpdateWindow( hwnd); /* hack for wine to draw the window + menu */
632 ok(ret, "SetMenu failed with error %d\n", GetLastError());
633 /* test width */
634 ok( MOD_rc[0].right - MOD_rc[0].left == 2 * MOD_avec + MOD_SIZE,
635 "width of owner drawn menu item is wrong. Got %d expected %d\n",
636 MOD_rc[0].right - MOD_rc[0].left , 2*MOD_avec + MOD_SIZE);
637 /* test hight */
638 ok( MOD_rc[0].bottom - MOD_rc[0].top == GetSystemMetrics( SM_CYMENU) - 1,
639 "Height of owner drawn menu item is wrong. Got %d expected %d\n",
640 MOD_rc[0].bottom - MOD_rc[0].top, GetSystemMetrics( SM_CYMENU) - 1);
641
642 /* clean up */
643 ret = DestroyMenu(hmenu);
644 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
645 DestroyWindow(hwnd);
646 }
647
648 /* helper for test_menu_bmp_and_string() */
649 static void test_mbs_help( int ispop, int hassub, int mnuopt,
650 HWND hwnd, int arrowwidth, int count, HBITMAP hbmp,
651 SIZE bmpsize, LPCSTR text, SIZE size, SIZE sc_size)
652 {
653 BOOL ret;
654 HMENU hmenu, submenu;
655 MENUITEMINFOA mii={ sizeof( MENUITEMINFOA )};
656 MENUINFO mi;
657 RECT rc;
658 CHAR text_copy[16];
659 int hastab, expect;
660 BOOL failed = FALSE;
661
662 MOD_GotDrawItemMsg = FALSE;
663 mii.fMask = MIIM_FTYPE | MIIM_DATA | MIIM_STATE;
664 mii.fType = 0;
665 /* check the menu item unless MNS_CHECKORBMP is set */
666 mii.fState = (mnuopt != 2 ? MFS_CHECKED : MFS_UNCHECKED);
667 mii.dwItemData =0;
668 MODsizes[0] = bmpsize;
669 hastab = 0;
670 if( text ) {
671 char *p;
672 mii.fMask |= MIIM_STRING;
673 strcpy(text_copy, text);
674 mii.dwTypeData = text_copy; /* structure member declared non-const */
675 if( ( p = strchr( text, '\t'))) {
676 hastab = *(p + 1) ? 2 : 1;
677 }
678 }
679 /* tabs don't make sense in menubars */
680 if(hastab && !ispop) return;
681 if( hbmp) {
682 mii.fMask |= MIIM_BITMAP;
683 mii.hbmpItem = hbmp;
684 }
685 submenu = CreateMenu();
686 ok( submenu != 0, "CreateMenu failed with error %d\n", GetLastError());
687 if( ispop)
688 hmenu = CreatePopupMenu();
689 else
690 hmenu = CreateMenu();
691 ok( hmenu != 0, "Create{Popup}Menu failed with error %d\n", GetLastError());
692 if( hassub) {
693 mii.fMask |= MIIM_SUBMENU;
694 mii.hSubMenu = submenu;
695 }
696 if( mnuopt) {
697 mi.cbSize = sizeof(mi);
698 mi.fMask = MIM_STYLE;
699 pGetMenuInfo( hmenu, &mi);
700 if( mnuopt) mi.dwStyle |= mnuopt == 1 ? MNS_NOCHECK : MNS_CHECKORBMP;
701 ret = pSetMenuInfo( hmenu, &mi);
702 ok( ret, "SetMenuInfo failed with error %d\n", GetLastError());
703 }
704 ret = InsertMenuItemA( hmenu, 0, FALSE, &mii);
705 ok( ret, "InsertMenuItem failed with error %d\n", GetLastError());
706 failed = !ret;
707 if( winetest_debug) {
708 HDC hdc=GetDC(hwnd);
709 RECT rc = {100, 50, 400, 70};
710 char buf[100];
711
712 sprintf( buf,"%d text \"%s\" mnuopt %d", count, text ? text: "(nil)", mnuopt);
713 FillRect( hdc, &rc, (HBRUSH) COLOR_WINDOW);
714 TextOutA( hdc, 10, 50, buf, strlen( buf));
715 ReleaseDC( hwnd, hdc);
716 }
717 if(ispop)
718 TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
719 else {
720 ret = SetMenu( hwnd, hmenu);
721 ok(ret, "SetMenu failed with error %d\n", GetLastError());
722 DrawMenuBar( hwnd);
723 }
724 ret = GetMenuItemRect( hwnd, hmenu, 0, &rc);
725 ok(ret, "GetMenuItemRect failed with error %d\n", GetLastError());
726
727 if (0) /* comment out menu size checks, behavior is different in almost every Windows version */
728 /* the tests should however succeed on win2000, XP and Wine (at least up to 1.1.15) */
729 /* with a variety of dpis and desktop font sizes */
730 {
731 /* check menu width */
732 if( ispop)
733 expect = ( text || hbmp ?
734 4 + (mnuopt != 1 ? GetSystemMetrics(SM_CXMENUCHECK) : 0)
735 : 0) +
736 arrowwidth + MOD_avec + (hbmp ?
737 ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ? bmpsize.cx + 2 : GetSystemMetrics( SM_CXMENUSIZE) + 2)
738 : 0) +
739 (text && hastab ? /* TAB space */
740 MOD_avec + ( hastab==2 ? sc_size.cx : 0) : 0) +
741 (text ? 2 + (text[0] ? size.cx :0): 0) ;
742 else
743 expect = !(text || hbmp) ? 0 :
744 ( hbmp ? (text ? 2:0) + bmpsize.cx : 0 ) +
745 (text ? 2 * MOD_avec + (text[0] ? size.cx :0): 0) ;
746 ok( rc.right - rc.left == expect,
747 "menu width wrong, got %d expected %d\n", rc.right - rc.left, expect);
748 failed = failed || !(rc.right - rc.left == expect);
749 /* check menu height */
750 if( ispop)
751 expect = max( ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 : 0),
752 max( (text ? max( 2 + size.cy, MOD_hic + 4) : 0),
753 (hbmp ?
754 ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ?
755 bmpsize.cy + 2
756 : GetSystemMetrics( SM_CYMENUSIZE) + 2)
757 : 0)));
758 else
759 expect = ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 :
760 max( GetSystemMetrics( SM_CYMENU) - 1, (hbmp ? bmpsize.cy : 0)));
761 ok( rc.bottom - rc.top == expect,
762 "menu height wrong, got %d expected %d (%d)\n",
763 rc.bottom - rc.top, expect, GetSystemMetrics( SM_CYMENU));
764 failed = failed || !(rc.bottom - rc.top == expect);
765 if( hbmp == HBMMENU_CALLBACK && MOD_GotDrawItemMsg) {
766 /* check the position of the bitmap */
767 /* horizontal */
768 if (!ispop)
769 expect = 3;
770 else if (mnuopt == 0)
771 expect = 4 + GetSystemMetrics(SM_CXMENUCHECK);
772 else if (mnuopt == 1)
773 expect = 4;
774 else /* mnuopt == 2 */
775 expect = 2;
776 ok( expect == MOD_rc[0].left,
777 "bitmap left is %d expected %d\n", MOD_rc[0].left, expect);
778 failed = failed || !(expect == MOD_rc[0].left);
779 /* vertical */
780 expect = (rc.bottom - rc.top - MOD_rc[0].bottom + MOD_rc[0].top) / 2;
781 ok( expect == MOD_rc[0].top,
782 "bitmap top is %d expected %d\n", MOD_rc[0].top, expect);
783 failed = failed || !(expect == MOD_rc[0].top);
784 }
785 }
786 /* if there was a failure, report details */
787 if( failed) {
788 trace("*** count %d %s text \"%s\" bitmap %p bmsize %d,%d textsize %d+%d,%d mnuopt %d hastab %d\n",
789 count, (ispop? "POPUP": "MENUBAR"),text ? text: "(nil)", hbmp, bmpsize.cx, bmpsize.cy,
790 size.cx, size.cy, sc_size.cx, mnuopt, hastab);
791 trace(" check %d,%d arrow %d avechar %d\n",
792 GetSystemMetrics(SM_CXMENUCHECK ),
793 GetSystemMetrics(SM_CYMENUCHECK ),arrowwidth, MOD_avec);
794 if( hbmp == HBMMENU_CALLBACK)
795 trace( " rc %d,%d-%d,%d bmp.rc %d,%d-%d,%d\n",
796 rc.left, rc.top, rc.top, rc.bottom, MOD_rc[0].left,
797 MOD_rc[0].top,MOD_rc[0].right, MOD_rc[0].bottom);
798 }
799 /* clean up */
800 ret = DestroyMenu(submenu);
801 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
802 ret = DestroyMenu(hmenu);
803 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
804 }
805
806
807 static void test_menu_bmp_and_string(void)
808 {
809 BYTE bmfill[300];
810 HBITMAP hbm_arrow;
811 BITMAP bm;
812 INT arrowwidth;
813 HWND hwnd;
814 HMENU hsysmenu;
815 MENUINFO mi= {sizeof(MENUINFO)};
816 MENUITEMINFOA mii= {sizeof(MENUITEMINFOA)};
817 int count, szidx, txtidx, bmpidx, hassub, mnuopt, ispop;
818 BOOL got;
819
820 if( !pGetMenuInfo)
821 {
822 win_skip("GetMenuInfo is not available\n");
823 return;
824 }
825
826 memset( bmfill, 0xcc, sizeof( bmfill));
827 hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL, WS_SYSMENU |
828 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
829 NULL, NULL, NULL, NULL);
830 hbm_arrow = LoadBitmapA( 0, (LPCSTR)OBM_MNARROW);
831 GetObjectA( hbm_arrow, sizeof(bm), &bm);
832 arrowwidth = bm.bmWidth;
833 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
834 if( !hwnd) return;
835 /* test system menu */
836 hsysmenu = GetSystemMenu( hwnd, FALSE);
837 ok( hsysmenu != NULL, "GetSystemMenu failed with error %d\n", GetLastError());
838 mi.fMask = MIM_STYLE;
839 mi.dwStyle = 0;
840 got = pGetMenuInfo( hsysmenu, &mi);
841 ok( got, "GetMenuInfo failed gle=%d\n", GetLastError());
842 ok( MNS_CHECKORBMP == mi.dwStyle, "System Menu Style is %08x, without the bit %08x\n",
843 mi.dwStyle, MNS_CHECKORBMP);
844 mii.fMask = MIIM_BITMAP;
845 mii.hbmpItem = NULL;
846 got = GetMenuItemInfoA( hsysmenu, SC_CLOSE, FALSE, &mii);
847 ok( got, "GetMenuItemInfoA failed gle=%d\n", GetLastError());
848 ok( HBMMENU_POPUP_CLOSE == mii.hbmpItem, "Item info did not get the right hbitmap: got %p expected %p\n",
849 mii.hbmpItem, HBMMENU_POPUP_CLOSE);
850
851 memset(&mii, 0x81, sizeof(mii));
852 mii.cbSize = sizeof(mii);
853 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
854 mii.dwTypeData = (LPSTR)bmfill;
855 mii.cch = sizeof(bmfill);
856 mii.dwItemData = 0x81818181;
857 got = GetMenuItemInfoA(hsysmenu, SC_RESTORE, FALSE, &mii);
858 ok(got, "GetMenuItemInfo failed\n");
859 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
860 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
861 ok(mii.wID == SC_RESTORE, "expected SC_RESTORE, got %#x\n", mii.wID);
862 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
863 ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
864 ok(mii.dwTypeData == (LPSTR)bmfill, "expected %p, got %p\n", bmfill, mii.dwTypeData);
865 ok(mii.cch != 0, "cch should not be 0\n");
866 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
867
868 mii.cbSize = sizeof(mii);
869 mii.fMask = MIIM_TYPE;
870 mii.hbmpItem = (HBITMAP)0x81818181;
871 got = GetMenuItemInfoA(hsysmenu, SC_CLOSE, FALSE, &mii);
872 ok(got, "GetMenuItemInfo failed\n");
873 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
874 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
875 ok(mii.wID == SC_RESTORE, "expected SC_RESTORE, got %#x\n", mii.wID);
876 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
877 ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
878 ok(mii.dwTypeData == (LPSTR)bmfill, "expected %p, got %p\n", bmfill, mii.dwTypeData);
879 ok(mii.cch != 0, "cch should not be 0\n");
880 ok(mii.hbmpItem == HBMMENU_POPUP_CLOSE, "expected HBMMENU_POPUP_CLOSE, got %p\n", mii.hbmpItem);
881
882 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
883
884 if( winetest_debug)
885 trace(" check %d,%d arrow %d avechar %d\n",
886 GetSystemMetrics(SM_CXMENUCHECK ),
887 GetSystemMetrics(SM_CYMENUCHECK ),arrowwidth, MOD_avec);
888 count = 0;
889 MOD_maxid = 0;
890 for( ispop=1; ispop >= 0; ispop--){
891 static SIZE bmsizes[]= {
892 {10,10},{38,38},{1,30},{55,5}};
893 for( szidx=0; szidx < sizeof( bmsizes) / sizeof( SIZE); szidx++) {
894 HBITMAP hbm = CreateBitmap( bmsizes[szidx].cx, bmsizes[szidx].cy,1,1,bmfill);
895 HBITMAP bitmaps[] = { HBMMENU_CALLBACK, hbm, HBMMENU_POPUP_CLOSE, NULL };
896 ok( hbm != 0, "CreateBitmap failed err %d\n", GetLastError());
897 for( txtidx = 0; txtidx < sizeof(MOD_txtsizes)/sizeof(MOD_txtsizes[0]); txtidx++) {
898 for( hassub = 0; hassub < 2 ; hassub++) { /* add submenu item */
899 for( mnuopt = 0; mnuopt < 3 ; mnuopt++){ /* test MNS_NOCHECK/MNS_CHECKORBMP */
900 for( bmpidx = 0; bmpidx <sizeof(bitmaps)/sizeof(HBITMAP); bmpidx++) {
901 /* no need to test NULL bitmaps of several sizes */
902 if( !bitmaps[bmpidx] && szidx > 0) continue;
903 /* the HBMMENU_POPUP not to test for menu bars */
904 if( !ispop &&
905 bitmaps[bmpidx] >= HBMMENU_POPUP_CLOSE &&
906 bitmaps[bmpidx] <= HBMMENU_POPUP_MINIMIZE) continue;
907 if( !ispop && hassub) continue;
908 test_mbs_help( ispop, hassub, mnuopt,
909 hwnd, arrowwidth, ++count,
910 bitmaps[bmpidx],
911 bmsizes[szidx],
912 MOD_txtsizes[txtidx].text,
913 MOD_txtsizes[txtidx].size,
914 MOD_txtsizes[txtidx].sc_size);
915 }
916 }
917 }
918 }
919 DeleteObject( hbm);
920 }
921 }
922 /* clean up */
923 DestroyWindow(hwnd);
924 }
925
926 static void test_menu_add_string( void )
927 {
928 HMENU hmenu;
929 MENUITEMINFOA info;
930 BOOL rc;
931 int ret;
932
933 char string[0x80];
934 char string2[0x80];
935
936 char strback[0x80];
937 WCHAR strbackW[0x80];
938 static CHAR blah[] = "blah";
939 static const WCHAR expectedString[] = {'D','u','m','m','y',' ','s','t','r','i','n','g', 0};
940
941 hmenu = CreateMenu();
942
943 memset( &info, 0, sizeof info );
944 info.cbSize = sizeof info;
945 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_ID;
946 info.dwTypeData = blah;
947 info.cch = 6;
948 info.dwItemData = 0;
949 info.wID = 1;
950 info.fState = 0;
951 InsertMenuItemA(hmenu, 0, TRUE, &info );
952
953 memset( &info, 0, sizeof info );
954 info.cbSize = sizeof info;
955 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
956 info.dwTypeData = string;
957 info.cch = sizeof string;
958 string[0] = 0;
959 GetMenuItemInfoA( hmenu, 0, TRUE, &info );
960
961 ok( !strcmp( string, "blah" ), "menu item name differed\n");
962
963 /* Test combination of ownerdraw and strings with GetMenuItemString(A/W) */
964 strcpy(string, "Dummy string");
965 memset(&info, 0x00, sizeof(info));
966 info.cbSize= sizeof(MENUITEMINFOA);
967 info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
968 info.fType= MFT_OWNERDRAW;
969 info.dwTypeData= string;
970 rc = InsertMenuItemA( hmenu, 0, TRUE, &info );
971 ok (rc, "InsertMenuItem failed\n");
972
973 strcpy(string,"Garbage");
974 ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
975 ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
976
977 SetLastError(0xdeadbeef);
978 ret = GetMenuStringW( hmenu, 0, strbackW, 99, MF_BYPOSITION );
979 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
980 win_skip("GetMenuStringW is not implemented\n");
981 else
982 {
983 ok (ret, "GetMenuStringW on ownerdraw entry failed\n");
984 ok (!lstrcmpW( strbackW, expectedString ), "Menu text from Unicode version incorrect\n");
985 }
986
987 /* Just try some invalid parameter tests */
988 SetLastError(0xdeadbeef);
989 rc = SetMenuItemInfoA( hmenu, 0, TRUE, NULL );
990 ret = GetLastError();
991 ok (!rc, "SetMenuItemInfoA succeeded unexpectedly\n");
992 ok (ret == ERROR_INVALID_PARAMETER, "Expected 87, got %d\n", ret);
993
994 SetLastError(0xdeadbeef);
995 rc = SetMenuItemInfoA( hmenu, 0, FALSE, NULL );
996 ret = GetLastError();
997 ok (!rc, "SetMenuItemInfoA succeeded unexpectedly\n");
998 ok (ret == ERROR_INVALID_PARAMETER, "Expected 87, got %d\n", ret);
999
1000 /* Just change ftype to string and see what text is stored */
1001 memset(&info, 0x00, sizeof(info));
1002 info.cbSize= sizeof(MENUITEMINFOA);
1003 info.fMask= MIIM_FTYPE; /* Set string type */
1004 info.fType= MFT_STRING;
1005 info.dwTypeData= (char *)0xdeadbeef;
1006 rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1007 ok (rc, "SetMenuItemInfo failed\n");
1008
1009 /* Did we keep the old dwTypeData? */
1010 ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
1011 ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
1012
1013 /* Ensure change to bitmap type fails */
1014 memset(&info, 0x00, sizeof(info));
1015 info.cbSize= sizeof(MENUITEMINFOA);
1016 info.fMask= MIIM_FTYPE; /* Set as bitmap type */
1017 info.fType= MFT_BITMAP;
1018 info.dwTypeData= (char *)0xdeadbee2;
1019 rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1020 ok (!rc, "SetMenuItemInfo unexpectedly worked\n");
1021
1022 /* Just change ftype back and ensure data hasn't been freed */
1023 info.fType= MFT_OWNERDRAW; /* Set as ownerdraw type */
1024 info.dwTypeData= (char *)0xdeadbee3;
1025 rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1026 ok (rc, "SetMenuItemInfo failed\n");
1027
1028 /* Did we keep the old dwTypeData? */
1029 ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
1030 ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
1031
1032 /* Just change string value (not type) */
1033 memset(&info, 0x00, sizeof(info));
1034 info.cbSize= sizeof(MENUITEMINFOA);
1035 info.fMask= MIIM_STRING; /* Set typeData */
1036 strcpy(string2, "string2");
1037 info.dwTypeData= string2;
1038 rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1039 ok (rc, "SetMenuItemInfo failed\n");
1040
1041 ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
1042 ok (!strcmp( strback, "string2" ), "Menu text from Ansi version incorrect\n");
1043
1044 /* crashes with wine 0.9.5 */
1045 memset(&info, 0x00, sizeof(info));
1046 info.cbSize= sizeof(MENUITEMINFOA);
1047 info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
1048 info.fType= MFT_OWNERDRAW;
1049 rc = InsertMenuItemA( hmenu, 0, TRUE, &info );
1050 ok (rc, "InsertMenuItem failed\n");
1051 ok (!GetMenuStringA( hmenu, 0, NULL, 0, MF_BYPOSITION),
1052 "GetMenuString on ownerdraw entry succeeded.\n");
1053 SetLastError(0xdeadbeef);
1054 ret = GetMenuStringW( hmenu, 0, NULL, 0, MF_BYPOSITION);
1055 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1056 win_skip("GetMenuStringW is not implemented\n");
1057 else
1058 ok (!ret, "GetMenuStringW on ownerdraw entry succeeded.\n");
1059
1060 DestroyMenu( hmenu );
1061 }
1062
1063 /* define building blocks for the menu item info tests */
1064 static int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
1065 {
1066 if (n <= 0) return 0;
1067 while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
1068 return *str1 - *str2;
1069 }
1070
1071 static WCHAR *strcpyW( WCHAR *dst, const WCHAR *src )
1072 {
1073 WCHAR *p = dst;
1074 while ((*p++ = *src++));
1075 return dst;
1076 }
1077
1078 static void insert_menu_item( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id,
1079 HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data,
1080 void *type_data, UINT len, HBITMAP item, BOOL expect )
1081 {
1082 MENUITEMINFOA info;
1083 BOOL ret;
1084
1085 /* magic bitmap handle to test smaller cbSize */
1086 if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
1087 info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
1088 else
1089 info.cbSize = sizeof(info);
1090 info.fMask = mask;
1091 info.fType = type;
1092 info.fState = state;
1093 info.wID = id;
1094 info.hSubMenu = submenu;
1095 info.hbmpChecked = checked;
1096 info.hbmpUnchecked = unchecked;
1097 info.dwItemData = data;
1098 info.dwTypeData = type_data;
1099 info.cch = len;
1100 info.hbmpItem = item;
1101 SetLastError( 0xdeadbeef );
1102 if (ansi) ret = InsertMenuItemA( hmenu, 0, TRUE, &info );
1103 else ret = InsertMenuItemW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
1104 if (!expect) ok_(__FILE__, line)( !ret, "InsertMenuItem should have failed.\n" );
1105 else ok_(__FILE__, line)( ret, "InsertMenuItem failed, err %u\n", GetLastError());
1106 }
1107
1108 static void check_menu_item_info( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state,
1109 UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked,
1110 ULONG_PTR data, void *type_data, UINT in_len, UINT out_len,
1111 HBITMAP item, LPCSTR expname, BOOL expect, BOOL expstring )
1112 {
1113 MENUITEMINFOA info;
1114 BOOL ret;
1115 WCHAR buffer[80];
1116
1117 SetLastError( 0xdeadbeef );
1118 memset( &info, 0xcc, sizeof(info) );
1119 info.cbSize = sizeof(info);
1120 info.fMask = mask;
1121 info.dwTypeData = type_data;
1122 info.cch = in_len;
1123
1124 ret = ansi ? GetMenuItemInfoA( hmenu, 0, TRUE, &info ) :
1125 GetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW *)&info );
1126 if (!expect)
1127 {
1128 ok_(__FILE__, line)( !ret, "GetMenuItemInfo should have failed.\n" );
1129 return;
1130 }
1131 ok_(__FILE__, line)( ret, "GetMenuItemInfo failed, err %u\n", GetLastError());
1132 if (mask & MIIM_TYPE)
1133 ok_(__FILE__, line)( info.fType == type || info.fType == LOWORD(type),
1134 "wrong type %x/%x\n", info.fType, type );
1135 if (mask & MIIM_STATE)
1136 ok_(__FILE__, line)( info.fState == state || info.fState == LOWORD(state),
1137 "wrong state %x/%x\n", info.fState, state );
1138 if (mask & MIIM_ID)
1139 ok_(__FILE__, line)( info.wID == id || info.wID == LOWORD(id),
1140 "wrong id %x/%x\n", info.wID, id );
1141 if (mask & MIIM_SUBMENU)
1142 ok_(__FILE__, line)( info.hSubMenu == submenu || (ULONG_PTR)info.hSubMenu == LOWORD(submenu),
1143 "wrong submenu %p/%p\n", info.hSubMenu, submenu );
1144 if (mask & MIIM_CHECKMARKS)
1145 {
1146 ok_(__FILE__, line)( info.hbmpChecked == checked || (ULONG_PTR)info.hbmpChecked == LOWORD(checked),
1147 "wrong bmpchecked %p/%p\n", info.hbmpChecked, checked );
1148 ok_(__FILE__, line)( info.hbmpUnchecked == unchecked || (ULONG_PTR)info.hbmpUnchecked == LOWORD(unchecked),
1149 "wrong bmpunchecked %p/%p\n", info.hbmpUnchecked, unchecked );
1150 }
1151 if (mask & MIIM_DATA)
1152 ok_(__FILE__, line)( info.dwItemData == data || info.dwItemData == LOWORD(data),
1153 "wrong item data %lx/%lx\n", info.dwItemData, data );
1154 if (mask & MIIM_BITMAP)
1155 ok_(__FILE__, line)( info.hbmpItem == item || (ULONG_PTR)info.hbmpItem == LOWORD(item),
1156 "wrong bmpitem %p/%p\n", info.hbmpItem, item );
1157 ok_(__FILE__, line)( info.dwTypeData == type_data || (ULONG_PTR)info.dwTypeData == LOWORD(type_data),
1158 "wrong type data %p/%p\n", info.dwTypeData, type_data );
1159 ok_(__FILE__, line)( info.cch == out_len ||
1160 broken(! ansi && info.cch == 2 * out_len) /* East-Asian */,
1161 "wrong len %x/%x\n", info.cch, out_len );
1162 if (expname)
1163 {
1164 if(ansi)
1165 ok_(__FILE__, line)( !strncmp( expname, info.dwTypeData, out_len ),
1166 "menu item name differed from '%s' '%s'\n", expname, info.dwTypeData );
1167 else
1168 ok_(__FILE__, line)( !strncmpW( (WCHAR *)expname, (WCHAR *)info.dwTypeData, out_len ),
1169 "menu item name wrong\n" );
1170
1171 SetLastError( 0xdeadbeef );
1172 ret = ansi ? GetMenuStringA( hmenu, 0, (char *)buffer, 80, MF_BYPOSITION ) :
1173 GetMenuStringW( hmenu, 0, buffer, 80, MF_BYPOSITION );
1174 if (expstring)
1175 ok_(__FILE__, line)( ret, "GetMenuString failed, err %u\n", GetLastError());
1176 else
1177 ok_(__FILE__, line)( !ret, "GetMenuString should have failed\n" );
1178 }
1179 }
1180
1181 static void modify_menu( int line, HMENU hmenu, BOOL ansi, UINT flags, UINT_PTR id, void *data )
1182 {
1183 BOOL ret;
1184
1185 SetLastError( 0xdeadbeef );
1186 if (ansi) ret = ModifyMenuA( hmenu, 0, flags, id, data );
1187 else ret = ModifyMenuW( hmenu, 0, flags, id, data );
1188 ok_(__FILE__,line)( ret, "ModifyMenuA failed, err %u\n", GetLastError());
1189 }
1190
1191 static void set_menu_item_info( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state,
1192 UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data,
1193 void *type_data, UINT len, HBITMAP item )
1194
1195 {
1196 MENUITEMINFOA info;
1197 BOOL ret;
1198
1199 /* magic bitmap handle to test smaller cbSize */
1200 if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
1201 info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
1202 else
1203 info.cbSize = sizeof(info);
1204 info.fMask = mask;
1205 info.fType = type;
1206 info.fState = state;
1207 info.wID = id;
1208 info.hSubMenu = submenu;
1209 info.hbmpChecked = checked;
1210 info.hbmpUnchecked = unchecked;
1211 info.dwItemData = data;
1212 info.dwTypeData = type_data;
1213 info.cch = len;
1214 info.hbmpItem = item;
1215 SetLastError( 0xdeadbeef );
1216 if (ansi) ret = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1217 else ret = SetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
1218 ok_(__FILE__, line)( ret, "SetMenuItemInfo failed, err %u\n", GetLastError());
1219 }
1220
1221 #define TMII_INSMI( c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,eret1 )\
1222 hmenu = CreateMenu();\
1223 submenu = CreateMenu();\
1224 if(ansi)strcpy( string, init );\
1225 else strcpyW( string, init );\
1226 insert_menu_item( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, eret1 )
1227
1228 /* GetMenuItemInfo + GetMenuString */
1229 #define TMII_GMII( c2,l2,\
1230 d3,e3,f3,g3,h3,i3,j3,k3,l3,m3,\
1231 expname, eret2, eret3)\
1232 check_menu_item_info( __LINE__, hmenu, ansi, c2, d3, e3, f3, g3, h3, i3, j3, k3, l2, l3, m3, \
1233 expname, eret2, eret3 )
1234
1235 #define TMII_DONE \
1236 RemoveMenu(hmenu, 0, TRUE );\
1237 DestroyMenu( hmenu );\
1238 DestroyMenu( submenu );
1239
1240 /* modify menu */
1241 #define TMII_MODM( flags, id, data ) \
1242 modify_menu( __LINE__, hmenu, ansi, flags, id, data )
1243
1244 /* SetMenuItemInfo */
1245 #define TMII_SMII( c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1 ) \
1246 set_menu_item_info( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1 )
1247
1248
1249 #define OK 1
1250 #define ER 0
1251
1252
1253 static void test_menu_iteminfo( void )
1254 {
1255 BOOL ansi = TRUE;
1256 char txtA[]="wine";
1257 char initA[]="XYZ";
1258 char emptyA[]="";
1259 WCHAR txtW[]={'W','i','n','e',0};
1260 WCHAR initW[]={'X','Y','Z',0};
1261 WCHAR emptyW[]={0};
1262 void *txt, *init, *empty, *string;
1263 HBITMAP hbm = CreateBitmap(1,1,1,1,NULL);
1264 char stringA[0x80];
1265 HMENU hmenu, submenu;
1266 HBITMAP dummy_hbm = (HBITMAP)(ULONG_PTR)0xdeadbeef;
1267
1268 do {
1269 if( ansi) {txt=txtA;init=initA;empty=emptyA;string=stringA;}
1270 else {txt=txtW;init=initW;empty=emptyW;string=stringA;}
1271 trace( "%s string %p hbm %p txt %p\n", ansi ? "ANSI tests: " : "Unicode tests:", string, hbm, txt);
1272 /* test all combinations of MFT_STRING, MFT_OWNERDRAW and MFT_BITMAP */
1273 /* (since MFT_STRING is zero, there are four of them) */
1274 TMII_INSMI( MIIM_TYPE, MFT_STRING, 0, 0, 0, 0, 0, 0, txt, 0, 0, OK );
1275 TMII_GMII ( MIIM_TYPE, 80,
1276 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1277 txt, OK, OK );
1278 TMII_DONE
1279 TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1280 TMII_GMII ( MIIM_TYPE, 80,
1281 MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1282 NULL, OK, ER );
1283 TMII_DONE
1284 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1285 TMII_GMII ( MIIM_TYPE, 80,
1286 MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1287 NULL, OK, ER );
1288 TMII_DONE
1289 TMII_INSMI( MIIM_TYPE, MFT_BITMAP|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1290 TMII_GMII ( MIIM_TYPE, 80,
1291 MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1292 NULL, OK, ER );
1293 TMII_DONE
1294 /* not enough space for name*/
1295 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1296 TMII_GMII ( MIIM_TYPE, 0,
1297 MFT_STRING, 0, 0, 0, 0, 0, 0, NULL, 4, 0,
1298 NULL, OK, OK );
1299 TMII_DONE
1300 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1301 TMII_GMII ( MIIM_TYPE, 5,
1302 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1303 txt, OK, OK );
1304 TMII_DONE
1305 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1306 TMII_GMII ( MIIM_TYPE, 4,
1307 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 3, 0,
1308 txt, OK, OK );
1309 TMII_DONE
1310 TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1311 TMII_GMII ( MIIM_TYPE, 0,
1312 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, 0,
1313 NULL, OK, ER );
1314 TMII_DONE
1315 /* cannot combine MIIM_TYPE with some other flags */
1316 TMII_INSMI( MIIM_TYPE|MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, ER );
1317 TMII_DONE
1318 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1319 TMII_GMII ( MIIM_TYPE|MIIM_STRING, 80,
1320 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1321 NULL, ER, OK );
1322 TMII_DONE
1323 TMII_INSMI( MIIM_TYPE|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, ER );
1324 TMII_DONE
1325 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1326 TMII_GMII ( MIIM_TYPE|MIIM_FTYPE, 80,
1327 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1328 NULL, ER, OK );
1329 TMII_DONE
1330 TMII_INSMI( MIIM_TYPE|MIIM_BITMAP, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, 6, hbm, ER );
1331 TMII_DONE
1332 /* but succeeds with some others */
1333 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1334 TMII_GMII ( MIIM_TYPE|MIIM_SUBMENU, 80,
1335 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1336 txt, OK, OK );
1337 TMII_DONE
1338 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1339 TMII_GMII ( MIIM_TYPE|MIIM_STATE, 80,
1340 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1341 txt, OK, OK );
1342 TMII_DONE
1343 TMII_INSMI( MIIM_TYPE|MIIM_ID, MFT_STRING, -1, 888, 0, 0, 0, -1, txt, 6, 0, OK );
1344 TMII_GMII ( MIIM_TYPE|MIIM_ID, 80,
1345 MFT_STRING, 0, 888, 0, 0, 0, 0, string, 4, 0,
1346 txt, OK, OK );
1347 TMII_DONE
1348 TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING, -1, -1, 0, 0, 0, 999, txt, 6, 0, OK );
1349 TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1350 MFT_STRING, 0, 0, 0, 0, 0, 999, string, 4, 0,
1351 txt, OK, OK );
1352 TMII_DONE
1353 /* to be continued */
1354 /* set text with MIIM_TYPE and retrieve with MIIM_STRING */
1355 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1356 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1357 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1358 txt, OK, OK );
1359 TMII_DONE
1360 /* set text with MIIM_TYPE and retrieve with MIIM_STRING; MFT_OWNERDRAW causes an empty string */
1361 TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1362 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1363 MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1364 empty, OK, ER );
1365 TMII_DONE
1366 TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1367 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1368 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1369 empty, OK, ER );
1370 TMII_DONE
1371 TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1372 TMII_GMII ( MIIM_FTYPE, 80,
1373 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 80, 0,
1374 init, OK, ER );
1375 TMII_DONE
1376 TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1377 TMII_GMII ( 0, 80,
1378 0, 0, 0, 0, 0, 0, 0, string, 80, 0,
1379 init, OK, OK );
1380 TMII_DONE
1381 /* contrary to MIIM_TYPE,you can set the text for an owner draw menu */
1382 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1383 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1384 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 4, 0,
1385 txt, OK, OK );
1386 TMII_DONE
1387 /* same but retrieve with MIIM_TYPE */
1388 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1389 TMII_GMII ( MIIM_TYPE, 80,
1390 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1391 NULL, OK, OK );
1392 TMII_DONE
1393 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1394 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1395 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1396 empty, OK, ER );
1397 TMII_DONE
1398 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1399 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1400 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 0, 0,
1401 empty, OK, ER );
1402 TMII_DONE
1403 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1404 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1405 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 0, 0,
1406 NULL, OK, ER );
1407 TMII_DONE
1408
1409 /* How is that with bitmaps? */
1410 TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1411 TMII_GMII ( MIIM_TYPE, 80,
1412 MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1413 NULL, OK, ER );
1414 TMII_DONE
1415 TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1416 TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1417 0, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1418 init, OK, ER );
1419 TMII_DONE
1420 /* MIIM_BITMAP does not like MFT_BITMAP */
1421 TMII_INSMI( MIIM_BITMAP|MIIM_FTYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, 0, -1, hbm, ER );
1422 TMII_DONE
1423 /* no problem with OWNERDRAWN */
1424 TMII_INSMI( MIIM_BITMAP|MIIM_FTYPE, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1425 TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1426 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1427 init, OK, ER );
1428 TMII_DONE
1429 /* setting MFT_BITMAP with MFT_FTYPE fails anyway */
1430 TMII_INSMI( MIIM_FTYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, 0, -1, 0, ER );
1431 TMII_DONE
1432
1433 /* menu with submenu */
1434 TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, txt, 0, 0, OK );
1435 TMII_GMII ( MIIM_SUBMENU, 80,
1436 0, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1437 init, OK, ER );
1438 TMII_DONE
1439 TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, empty, 0, 0, OK );
1440 TMII_GMII ( MIIM_SUBMENU, 80,
1441 0, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1442 init, OK, ER );
1443 TMII_DONE
1444 /* menu with submenu, without MIIM_SUBMENU the submenufield is cleared */
1445 TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, txt, 0, 0, OK );
1446 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1447 MFT_STRING|MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 0, 0,
1448 empty, OK, ER );
1449 TMII_GMII ( MIIM_SUBMENU|MIIM_FTYPE, 80,
1450 MFT_SEPARATOR, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1451 empty, OK, ER );
1452 TMII_DONE
1453 /* menu with invalid submenu */
1454 TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, (HMENU)999, 0, 0, -1, txt, 0, 0, ER );
1455 TMII_DONE
1456 /* Separator */
1457 TMII_INSMI( MIIM_TYPE, MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, txt, 0, 0, OK );
1458 TMII_GMII ( MIIM_TYPE, 80,
1459 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1460 NULL, OK, ER );
1461 TMII_DONE
1462 TMII_INSMI( MIIM_TYPE, MFT_BITMAP|MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1463 TMII_GMII ( MIIM_TYPE, 80,
1464 MFT_BITMAP|MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1465 NULL, OK, ER );
1466 TMII_DONE
1467 /* SEPARATOR and STRING go well together */
1468 /* BITMAP and STRING go well together */
1469 TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1470 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, 80,
1471 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, hbm,
1472 txt, OK, OK );
1473 TMII_DONE
1474 /* BITMAP, SEPARATOR and STRING go well together */
1475 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1476 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, 80,
1477 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 4, hbm,
1478 txt, OK, OK );
1479 TMII_DONE
1480 /* last two tests, but use MIIM_TYPE to retrieve info */
1481 TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1482 TMII_GMII ( MIIM_TYPE, 80,
1483 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1484 NULL, OK, OK );
1485 TMII_DONE
1486 TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1487 TMII_GMII ( MIIM_TYPE, 80,
1488 MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1489 NULL, OK, OK );
1490 TMII_DONE
1491 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1492 TMII_GMII ( MIIM_TYPE, 80,
1493 MFT_SEPARATOR|MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1494 NULL, OK, OK );
1495 TMII_DONE
1496 /* same three with MFT_OWNERDRAW */
1497 TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1498 TMII_GMII ( MIIM_TYPE, 80,
1499 MFT_SEPARATOR|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1500 NULL, OK, OK );
1501 TMII_DONE
1502 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1503 TMII_GMII ( MIIM_TYPE, 80,
1504 MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1505 NULL, OK, OK );
1506 TMII_DONE
1507 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1508 TMII_GMII ( MIIM_TYPE, 80,
1509 MFT_SEPARATOR|MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1510 NULL, OK, OK );
1511 TMII_DONE
1512
1513 TMII_INSMI( MIIM_STRING|MIIM_FTYPE|MIIM_ID, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1514 TMII_GMII ( MIIM_TYPE, 80,
1515 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1516 NULL, OK, OK );
1517 TMII_DONE
1518 /* test with modifymenu: string is preserved after setting OWNERDRAW */
1519 TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1520 TMII_MODM( MFT_OWNERDRAW, -1, (void*)787 );
1521 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_DATA, 80,
1522 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 787, string, 4, 0,
1523 txt, OK, OK );
1524 TMII_DONE
1525 /* same with bitmap: now the text is cleared */
1526 TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1527 TMII_MODM( MFT_BITMAP, 545, hbm );
1528 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1529 MFT_BITMAP, 0, 545, 0, 0, 0, 0, string, 0, hbm,
1530 empty, OK, ER );
1531 TMII_DONE
1532 /* start with bitmap: now setting text clears it (though he flag is raised) */
1533 TMII_INSMI( MIIM_BITMAP, MFT_STRING, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1534 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1535 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 0, hbm,
1536 empty, OK, ER );
1537 TMII_MODM( MFT_STRING, 545, txt );
1538 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1539 MFT_STRING, 0, 545, 0, 0, 0, 0, string, 4, 0,
1540 txt, OK, OK );
1541 TMII_DONE
1542 /*repeat with text NULL */
1543 TMII_INSMI( MIIM_BITMAP, MFT_STRING, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1544 TMII_MODM( MFT_STRING, 545, NULL );
1545 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1546 MFT_SEPARATOR, 0, 545, 0, 0, 0, 0, string, 0, 0,
1547 empty, OK, ER );
1548 TMII_DONE
1549 /* repeat with text "" */
1550 TMII_INSMI( MIIM_BITMAP, -1 , -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1551 TMII_MODM( MFT_STRING, 545, empty );
1552 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1553 MFT_STRING, 0, 545, 0, 0, 0, 0, string, 0, 0,
1554 empty, OK, ER );
1555 TMII_DONE
1556 /* start with bitmap: set ownerdraw */
1557 TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1558 TMII_MODM( MFT_OWNERDRAW, -1, (void *)232 );
1559 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_DATA, 80,
1560 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 232, string, 0, hbm,
1561 empty, OK, ER );
1562 TMII_DONE
1563 /* ask nothing */
1564 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1565 TMII_GMII ( 0, 80,
1566 0, 0, 0, 0, 0, 0, 0, string, 80, 0,
1567 init, OK, OK );
1568 TMII_DONE
1569 /* some tests with small cbSize: the hbmpItem is to be ignored */
1570 TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, dummy_hbm, OK );
1571 TMII_GMII ( MIIM_TYPE, 80,
1572 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1573 NULL, OK, ER );
1574 TMII_DONE
1575 TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, dummy_hbm, OK );
1576 TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1577 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 80, NULL,
1578 init, OK, ER );
1579 TMII_DONE
1580 TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1581 TMII_GMII ( MIIM_TYPE, 80,
1582 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, NULL,
1583 txt, OK, OK );
1584 TMII_DONE
1585 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1586 TMII_GMII ( MIIM_TYPE, 80,
1587 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1588 NULL, OK, OK );
1589 TMII_DONE
1590 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1591 TMII_GMII ( MIIM_TYPE, 80,
1592 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1593 NULL, OK, OK );
1594 TMII_DONE
1595 TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1596 TMII_GMII ( MIIM_TYPE, 80,
1597 MFT_SEPARATOR|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1598 NULL, OK, OK );
1599 TMII_DONE
1600 /* MIIM_TYPE by itself does not get/set the dwItemData for OwnerDrawn menus */
1601 TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1602 TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1603 MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 343, 0, 0, 0,
1604 NULL, OK, ER );
1605 TMII_DONE
1606 TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1607 TMII_GMII ( MIIM_TYPE, 80,
1608 MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1609 NULL, OK, ER );
1610 TMII_DONE
1611 TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1612 TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1613 MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1614 NULL, OK, ER );
1615 TMII_DONE
1616 /* set a string menu to ownerdraw with MIIM_TYPE */
1617 TMII_INSMI( MIIM_TYPE, MFT_STRING, -2, -2, 0, 0, 0, -2, txt, -2, 0, OK );
1618 TMII_SMII ( MIIM_TYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1619 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1620 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 4, 0,
1621 txt, OK, OK );
1622 TMII_DONE
1623 /* test with modifymenu add submenu */
1624 TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1625 TMII_MODM( MF_POPUP, (UINT_PTR)submenu, txt );
1626 TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_SUBMENU, 80,
1627 MFT_STRING, 0, 0, submenu, 0, 0, 0, string, 4, 0,
1628 txt, OK, OK );
1629 TMII_GMII ( MIIM_TYPE, 80,
1630 MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1631 txt, OK, OK );
1632 TMII_DONE
1633 /* MFT_SEPARATOR bit is kept when the text is added */
1634 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1635 TMII_SMII( MIIM_STRING, 0, 0, 0, 0, 0, 0, 0, txt, 0, 0 );
1636 TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1637 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 4, 0,
1638 txt, OK, OK );
1639 TMII_DONE
1640 /* MFT_SEPARATOR bit is kept when bitmap is added */
1641 TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1642 TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, hbm );
1643 TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1644 MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1645 init, OK, ER );
1646 TMII_DONE
1647 /* Bitmaps inserted with MIIM_TYPE and MFT_BITMAP:
1648 Only the low word of the dwTypeData is used.
1649 Use a magic bitmap here (Word 95 uses this to create its MDI menu buttons) */
1650 TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_RIGHTJUSTIFY, -1, -1, 0, 0, 0, -1,
1651 (HMENU)MAKELONG(HBMMENU_MBAR_CLOSE, 0x1234), -1, 0, OK );
1652 TMII_GMII ( MIIM_TYPE, 80,
1653 MFT_BITMAP | MFT_RIGHTJUSTIFY, 0, 0, 0, 0, 0, 0, HBMMENU_MBAR_CLOSE, 0, HBMMENU_MBAR_CLOSE,
1654 NULL, OK, OK );
1655 TMII_DONE
1656 /* Type flags */
1657 TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1658 TMII_GMII ( MIIM_TYPE, 80,
1659 MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1660 NULL, OK, OK );
1661 TMII_DONE
1662 /* State flags */
1663 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1664 TMII_SMII( MIIM_STATE, -1, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 0, 0 );
1665 TMII_GMII ( MIIM_STATE, 80,
1666 0, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 80, 0,
1667 NULL, OK, OK );
1668 TMII_DONE
1669 /* The style MFT_RADIOCHECK cannot be set with MIIM_CHECKMARKS only */
1670 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1671 TMII_SMII( MIIM_CHECKMARKS, MFT_RADIOCHECK, 0, 0, 0, hbm, hbm, 0, 0, 0, 0 );
1672 TMII_GMII ( MIIM_CHECKMARKS | MIIM_TYPE, 80,
1673 MFT_BITMAP, 0, 0, 0, hbm, hbm, 0, hbm, 0, hbm,
1674 NULL, OK, OK );
1675 TMII_DONE
1676 /* MFT_BITMAP is added automatically by GetMenuItemInfo() for MIIM_TYPE */
1677 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1678 TMII_SMII( MIIM_FTYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, (HBITMAP)0x1234, 0, 0 );
1679 TMII_GMII ( MIIM_FTYPE, 80,
1680 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1681 NULL, OK, OK );
1682 TMII_GMII ( MIIM_TYPE, 80,
1683 MFT_BITMAP | MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1684 NULL, OK, OK );
1685 TMII_GMII ( MIIM_FTYPE, 80,
1686 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1687 NULL, OK, OK );
1688 TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL );
1689 TMII_GMII ( MIIM_TYPE, 80,
1690 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1691 NULL, OK, OK );
1692 TMII_DONE
1693 /* Bitmaps inserted with MIIM_TYPE and MFT_BITMAP:
1694 Only the low word of the dwTypeData is used.
1695 Use a magic bitmap here (Word 95 uses this to create its MDI menu buttons) */
1696 TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_RIGHTJUSTIFY, -1, -1, 0, 0, 0, -1,
1697 (HMENU)MAKELONG(HBMMENU_MBAR_CLOSE, 0x1234), -1, 0, OK );
1698 TMII_GMII ( MIIM_TYPE, 80,
1699 MFT_BITMAP | MFT_RIGHTJUSTIFY, 0, 0, 0, 0, 0, 0, HBMMENU_MBAR_CLOSE, 0, HBMMENU_MBAR_CLOSE,
1700 NULL, OK, OK );
1701 TMII_DONE
1702 /* Type flags */
1703 TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1704 TMII_GMII ( MIIM_TYPE, 80,
1705 MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1706 NULL, OK, OK );
1707 TMII_DONE
1708 /* State flags */
1709 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1710 TMII_SMII( MIIM_STATE, -1, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 0, 0 );
1711 TMII_GMII ( MIIM_STATE, 80,
1712 0, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 80, 0,
1713 NULL, OK, OK );
1714 TMII_DONE
1715 /* The style MFT_RADIOCHECK cannot be set with MIIM_CHECKMARKS only */
1716 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1717 TMII_SMII( MIIM_CHECKMARKS, MFT_RADIOCHECK, 0, 0, 0, hbm, hbm, 0, 0, 0, 0 );
1718 TMII_GMII ( MIIM_CHECKMARKS | MIIM_TYPE, 80,
1719 MFT_BITMAP, 0, 0, 0, hbm, hbm, 0, hbm, 0, hbm,
1720 NULL, OK, OK );
1721 TMII_DONE
1722 /* MFT_BITMAP is added automatically by GetMenuItemInfo() for MIIM_TYPE */
1723 TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1724 TMII_SMII( MIIM_FTYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, (HBITMAP)0x1234, 0, 0 );
1725 TMII_GMII ( MIIM_FTYPE, 80,
1726 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1727 NULL, OK, OK );
1728 TMII_GMII ( MIIM_TYPE, 80,
1729 MFT_BITMAP | MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1730 NULL, OK, OK );
1731 TMII_GMII ( MIIM_FTYPE, 80,
1732 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1733 NULL, OK, OK );
1734 TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL );
1735 TMII_GMII ( MIIM_TYPE, 80,
1736 MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1737 NULL, OK, OK );
1738 TMII_DONE
1739 } while( !(ansi = !ansi) );
1740 DeleteObject( hbm);
1741 }
1742
1743 /*
1744 The following tests try to confirm the algorithm used to return the menu items
1745 when there is a collision between a menu item and a popup menu
1746 */
1747 static void test_menu_search_bycommand( void )
1748 {
1749 HMENU hmenu, hmenuSub, hmenuSub2;
1750 MENUITEMINFOA info;
1751 BOOL rc;
1752 UINT id;
1753 char strback[0x80];
1754 char strIn[0x80];
1755 static CHAR menuitem[] = "MenuItem",
1756 menuitem2[] = "MenuItem 2";
1757
1758 /* Case 1: Menu containing a menu item */
1759 hmenu = CreateMenu();
1760
1761 memset( &info, 0, sizeof info );
1762 info.cbSize = sizeof info;
1763 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1764 info.fType = MFT_STRING;
1765 strcpy(strIn, "Case 1 MenuItem");
1766 info.dwTypeData = strIn;
1767 info.wID = (UINT) 0x1234;
1768
1769 rc = InsertMenuItemA(hmenu, 0, TRUE, &info );
1770 ok (rc, "Inserting the menuitem failed\n");
1771
1772 id = GetMenuItemID(hmenu, 0);
1773 ok (id == 0x1234, "Getting the menuitem id failed(gave %x)\n", id);
1774
1775 /* Confirm the menuitem was given the id supplied (getting by position) */
1776 memset( &info, 0, sizeof info );
1777 strback[0] = 0x00;
1778 info.cbSize = sizeof(MENUITEMINFOA);
1779 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1780 info.dwTypeData = strback;
1781 info.cch = sizeof(strback);
1782
1783 rc = GetMenuItemInfoA(hmenu, 0, TRUE, &info); /* Get by position */
1784 ok (rc, "Getting the menu items info failed\n");
1785 ok (info.wID == 0x1234, "IDs differ for the menuitem\n");
1786 ok (!strcmp(info.dwTypeData, "Case 1 MenuItem"), "Returned item has wrong label\n");
1787
1788 /* Search by id - Should return the item */
1789 memset( &info, 0, sizeof info );
1790 strback[0] = 0x00;
1791 info.cbSize = sizeof(MENUITEMINFOA);
1792 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1793 info.dwTypeData = strback;
1794 info.cch = sizeof(strback);
1795 rc = GetMenuItemInfoA(hmenu, 0x1234, FALSE, &info); /* Get by ID */
1796
1797 ok (rc, "Getting the menu items info failed\n");
1798 ok (info.wID == 0x1234, "IDs differ for the menuitem\n");
1799 ok (!strcmp(info.dwTypeData, "Case 1 MenuItem"), "Returned item has wrong label\n");
1800
1801 DestroyMenu( hmenu );
1802
1803 /* Case 2: Menu containing a popup menu */
1804 hmenu = CreateMenu();
1805 hmenuSub = CreateMenu();
1806
1807 strcpy(strIn, "Case 2 SubMenu");
1808 rc = InsertMenuA(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, strIn);
1809 ok (rc, "Inserting the popup menu into the main menu failed\n");
1810
1811 id = GetMenuItemID(hmenu, 0);
1812 ok (id == -1, "Getting the menuitem id unexpectedly worked (gave %x)\n", id);
1813
1814 /* Confirm the menuitem itself was given an id the same as the HMENU, (getting by position) */
1815 memset( &info, 0, sizeof info );
1816 strback[0] = 0x00;
1817 info.cbSize = sizeof(MENUITEMINFOA);
1818 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1819 info.dwTypeData = strback;
1820 info.cch = sizeof(strback);
1821 info.wID = 0xdeadbeef;
1822
1823 rc = GetMenuItemInfoA(hmenu, 0, TRUE, &info); /* Get by position */
1824 ok (rc, "Getting the menu items info failed\n");
1825 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the menuitem\n");
1826 ok (!strcmp(info.dwTypeData, "Case 2 SubMenu"), "Returned item has wrong label\n");
1827
1828 /* Search by id - returns the popup menu itself */
1829 memset( &info, 0, sizeof info );
1830 strback[0] = 0x00;
1831 info.cbSize = sizeof(MENUITEMINFOA);
1832 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1833 info.dwTypeData = strback;
1834 info.cch = sizeof(strback);
1835 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1836
1837 ok (rc, "Getting the menu items info failed\n");
1838 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1839 ok (!strcmp(info.dwTypeData, "Case 2 SubMenu"), "Returned item has wrong label\n");
1840
1841 /*
1842 Now add an item after it with the same id
1843 */
1844 memset( &info, 0, sizeof info );
1845 info.cbSize = sizeof info;
1846 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1847 info.fType = MFT_STRING;
1848 strcpy(strIn, "Case 2 MenuItem 1");
1849 info.dwTypeData = strIn;
1850 info.wID = (UINT_PTR) hmenuSub;
1851 rc = InsertMenuItemA(hmenu, -1, TRUE, &info );
1852 ok (rc, "Inserting the menuitem failed\n");
1853
1854 /* Search by id - returns the item which follows the popup menu */
1855 memset( &info, 0, sizeof info );
1856 strback[0] = 0x00;
1857 info.cbSize = sizeof(MENUITEMINFOA);
1858 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1859 info.dwTypeData = strback;
1860 info.cch = sizeof(strback);
1861 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1862
1863 ok (rc, "Getting the menu items info failed\n");
1864 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1865 ok (!strcmp(info.dwTypeData, "Case 2 MenuItem 1"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1866
1867 /*
1868 Now add an item before the popup (with the same id)
1869 */
1870 memset( &info, 0, sizeof info );
1871 info.cbSize = sizeof info;
1872 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1873 info.fType = MFT_STRING;
1874 strcpy(strIn, "Case 2 MenuItem 2");
1875 info.dwTypeData = strIn;
1876 info.wID = (UINT_PTR) hmenuSub;
1877 rc = InsertMenuItemA(hmenu, 0, TRUE, &info );
1878 ok (rc, "Inserting the menuitem failed\n");
1879
1880 /* Search by id - returns the item which precedes the popup menu */
1881 memset( &info, 0, sizeof info );
1882 strback[0] = 0x00;
1883 info.cbSize = sizeof(MENUITEMINFOA);
1884 info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1885 info.dwTypeData = strback;
1886 info.cch = sizeof(strback);
1887 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1888
1889 ok (rc, "Getting the menu items info failed\n");
1890 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1891 ok (!strcmp(info.dwTypeData, "Case 2 MenuItem 2"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1892
1893 DestroyMenu( hmenu );
1894 DestroyMenu( hmenuSub );
1895
1896 /*
1897 Case 3: Menu containing a popup menu which in turn
1898 contains 2 items with the same id as the popup itself
1899 */
1900
1901 hmenu = CreateMenu();
1902 hmenuSub = CreateMenu();
1903
1904 memset( &info, 0, sizeof info );
1905 info.cbSize = sizeof info;
1906 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1907 info.fType = MFT_STRING;
1908 info.dwTypeData = menuitem;
1909 info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1910
1911 rc = InsertMenuA(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
1912 ok (rc, "Inserting the popup menu into the main menu failed\n");
1913
1914 rc = InsertMenuItemA(hmenuSub, 0, TRUE, &info );
1915 ok (rc, "Inserting the sub menu menuitem failed\n");
1916
1917 memset( &info, 0, sizeof info );
1918 info.cbSize = sizeof info;
1919 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1920 info.fType = MFT_STRING;
1921 info.dwTypeData = menuitem2;
1922 info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1923
1924 rc = InsertMenuItemA(hmenuSub, 1, TRUE, &info );
1925 ok (rc, "Inserting the sub menu menuitem 2 failed\n");
1926
1927 /* Prove that you can't query the id of a popup directly (By position) */
1928 id = GetMenuItemID(hmenu, 0);
1929 ok (id == -1, "Getting the sub menu id should have failed because it's a popup (gave %x)\n", id);
1930
1931 /* Prove getting the item info via ID returns the first item (not the popup or 2nd item)*/
1932 memset( &info, 0, sizeof info );
1933 strback[0] = 0x00;
1934 info.cbSize = sizeof(MENUITEMINFOA);
1935 info.fMask = MIIM_STRING | MIIM_ID;
1936 info.dwTypeData = strback;
1937 info.cch = sizeof(strback);
1938
1939 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub, FALSE, &info);
1940 ok (rc, "Getting the menus info failed\n");
1941 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for popup menu\n");
1942 ok (!strcmp(info.dwTypeData, "MenuItem"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1943 DestroyMenu( hmenu );
1944 DestroyMenu( hmenuSub );
1945
1946 /*
1947 Case 4: Menu containing 2 popup menus, the second
1948 contains 2 items with the same id as the first popup menu
1949 */
1950 hmenu = CreateMenu();
1951 hmenuSub = CreateMenu();
1952 hmenuSub2 = CreateMenu();
1953
1954 rc = InsertMenuA(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
1955 ok (rc, "Inserting the popup menu into the main menu failed\n");
1956
1957 rc = InsertMenuA(hmenu, 1, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub2, "Submenu2");
1958 ok (rc, "Inserting the popup menu into the main menu failed\n");
1959
1960 memset( &info, 0, sizeof info );
1961 info.cbSize = sizeof info;
1962 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1963 info.fType = MFT_STRING;
1964 info.dwTypeData = menuitem;
1965 info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1966
1967 rc = InsertMenuItemA(hmenuSub2, 0, TRUE, &info );
1968 ok (rc, "Inserting the sub menu menuitem failed\n");
1969
1970 memset( &info, 0, sizeof info );
1971 info.cbSize = sizeof info;
1972 info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1973 info.fType = MFT_STRING;
1974 info.dwTypeData = menuitem2;
1975 info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1976
1977 rc = InsertMenuItemA(hmenuSub2, 1, TRUE, &info );
1978 ok (rc, "Inserting the sub menu menuitem 2 failed\n");
1979
1980 /* Prove getting the item info via ID returns the first item (not the popup or 2nd item)*/
1981 memset( &info, 0, sizeof info );
1982 strback[0] = 0x00;
1983 info.cbSize = sizeof(MENUITEMINFOA);
1984 info.fMask = MIIM_STRING | MIIM_ID;
1985 info.dwTypeData = strback;
1986 info.cch = sizeof(strback);
1987
1988 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub, FALSE, &info);
1989 ok (rc, "Getting the menus info failed\n");
1990 ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for popup menu\n");
1991 ok (!strcmp(info.dwTypeData, "MenuItem"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1992
1993 memset( &info, 0, sizeof info );
1994 strback[0] = 0x00;
1995 info.cbSize = sizeof(MENUITEMINFOA);
1996 info.fMask = MIIM_STRING | MIIM_ID;
1997 info.dwTypeData = strback;
1998 info.cch = sizeof(strback);
1999
2000 rc = GetMenuItemInfoA(hmenu, (UINT_PTR)hmenuSub2, FALSE, &info);
2001 ok (rc, "Getting the menus info failed\n");
2002 ok (info.wID == (UINT_PTR)hmenuSub2, "IDs differ for popup menu\n");
2003 ok (!strcmp(info.dwTypeData, "Submenu2"), "Returned item has wrong label (%s)\n", info.dwTypeData);
2004
2005 DestroyMenu( hmenu );
2006 DestroyMenu( hmenuSub );
2007 DestroyMenu( hmenuSub2 );
2008
2009
2010 /*
2011 Case 5: Menu containing a popup menu which in turn
2012 contains an item with a different id than the popup menu.
2013 This tests the fallback to a popup menu ID.
2014 */
2015
2016 hmenu = CreateMenu();
2017 hmenuSub = CreateMenu();
2018
2019 rc = AppendMenuA(hmenu, MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
2020 ok (rc, "Appending the popup menu to the main menu failed\n");
2021
2022 rc = AppendMenuA(hmenuSub, MF_STRING, 102, "Item");
2023 ok (rc, "Appending the item to the popup menu failed\n");
2024
2025 /* Set the ID for hmenuSub */
2026 info.cbSize = sizeof(info);
2027 info.fMask = MIIM_ID;
2028 info.wID = 101;
2029
2030 rc = SetMenuItemInfoA(hmenu, 0, TRUE, &info);
2031 ok(rc, "Setting the ID for the popup menu failed\n");
2032
2033 /* Check if the ID has been set */
2034 info.wID = 0;
2035 rc = GetMenuItemInfoA(hmenu, 0, TRUE, &info);
2036 ok(rc, "Getting the ID for the popup menu failed\n");
2037 ok(info.wID == 101, "The ID for the popup menu has not been set\n");
2038
2039 /* Prove getting the item info via ID returns the popup menu */
2040 memset( &info, 0, sizeof(info));
2041 strback[0] = 0x00;
2042 info.cbSize = sizeof(MENUITEMINFOA);
2043 info.fMask = MIIM_STRING | MIIM_ID;
2044 info.dwTypeData = strback;
2045 info.cch = sizeof(strback);
2046
2047 rc = GetMenuItemInfoA(hmenu, 101, FALSE, &info);
2048 ok (rc, "Getting the menu info failed\n");
2049 ok (info.wID == 101, "IDs differ\n");
2050 ok (!strcmp(info.dwTypeData, "Submenu"), "Returned item has wrong label (%s)\n", info.dwTypeData);
2051
2052 /* Also look for the menu item */
2053 memset( &info, 0, sizeof(info));
2054 strback[0] = 0x00;
2055 info.cbSize = sizeof(MENUITEMINFOA);
2056 info.fMask = MIIM_STRING | MIIM_ID;
2057 info.dwTypeData = strback;
2058 info.cch = sizeof(strback);
2059
2060 rc = GetMenuItemInfoA(hmenu, 102, FALSE, &info);
2061 ok (rc, "Getting the menu info failed\n");
2062 ok (info.wID == 102, "IDs differ\n");
2063 ok (!strcmp(info.dwTypeData, "Item"), "Returned item has wrong label (%s)\n", info.dwTypeData);
2064
2065 DestroyMenu(hmenu);
2066 DestroyMenu(hmenuSub);
2067 }
2068
2069 struct menu_item_pair_s {
2070 UINT uMenu; /* 1 - top level menu, [0-Menu 1-Enabled 2-Disabled]
2071 * 2 - 2nd level menu, [0-Popup 1-Enabled 2-Disabled]
2072 * 3 - 3rd level menu, [0-Enabled 1-Disabled] */
2073 UINT uItem;
2074 };
2075
2076 static struct menu_mouse_tests_s {
2077 DWORD type;
2078 struct menu_item_pair_s menu_item_pairs[5]; /* for mousing */
2079 WORD wVk[5]; /* keys */
2080 BOOL bMenuVisible;
2081 BOOL _todo_wine;
2082 } menu_tests[] = {
2083 /* for each test, send keys or clicks and check for menu visibility */
2084 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE }, /* test 0 */
2085 { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, 0}, FALSE, FALSE },
2086 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE },
2087 { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
2088 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE },
2089 { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
2090 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
2091 { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, VK_ESCAPE, 0}, FALSE, FALSE },
2092 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', VK_ESCAPE, 0}, TRUE, FALSE },
2093 { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, 0}, FALSE, FALSE },
2094 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
2095 { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
2096 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
2097 { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
2098 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 'P', 0}, TRUE, FALSE },
2099 { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
2100 { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 'P', 0}, TRUE, FALSE },
2101 { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
2102 { INPUT_KEYBOARD, {{0}}, {VK_F10, 0}, TRUE, FALSE },
2103 { INPUT_KEYBOARD, {{0}}, {VK_F10, 0}, FALSE, FALSE },
2104
2105 { INPUT_MOUSE, {{1, 2}, {0}}, {0}, TRUE, TRUE }, /* test 20 */
2106 { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
2107 { INPUT_MOUSE, {{1, 0}, {0}}, {0}, TRUE, TRUE },
2108 { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
2109 { INPUT_MOUSE, {{1, 0}, {2, 2}, {0}}, {0}, TRUE, TRUE },
2110 { INPUT_MOUSE, {{2, 1}, {0}}, {0}, FALSE, FALSE },
2111 { INPUT_MOUSE, {{1, 0}, {2, 0}, {0}}, {0}, TRUE, TRUE },
2112 { INPUT_MOUSE, {{3, 0}, {0}}, {0}, FALSE, FALSE },
2113 { INPUT_MOUSE, {{1, 0}, {2, 0}, {0}}, {0}, TRUE, TRUE },
2114 { INPUT_MOUSE, {{3, 1}, {0}}, {0}, TRUE, TRUE },
2115 { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
2116 { -1 }
2117 };
2118
2119 static void send_key(WORD wVk)
2120 {
2121 TEST_INPUT i[2];
2122 memset(i, 0, sizeof(i));
2123 i[0].type = i[1].type = INPUT_KEYBOARD;
2124 i[0].u.ki.wVk = i[1].u.ki.wVk = wVk;
2125 i[1].u.ki.dwFlags = KEYEVENTF_KEYUP;
2126 pSendInput(2, (INPUT *) i, sizeof(INPUT));
2127 }
2128
2129 static BOOL click_menu(HANDLE hWnd, struct menu_item_pair_s *mi)
2130 {
2131 HMENU hMenu = hMenus[mi->uMenu];
2132 TEST_INPUT i[3];
2133 MSG msg;
2134 RECT r;
2135 int screen_w = GetSystemMetrics(SM_CXSCREEN);
2136 int screen_h = GetSystemMetrics(SM_CYSCREEN);
2137 BOOL ret = GetMenuItemRect(mi->uMenu > 2 ? NULL : hWnd, hMenu, mi->uItem, &r);
2138 if(!ret) return FALSE;
2139
2140 memset(i, 0, sizeof(i));
2141 i[0].type = i[1].type = i[2].type = INPUT_MOUSE;
2142 i[0].u.mi.dx = i[1].u.mi.dx = i[2].u.mi.dx
2143 = ((r.left + 5) * 65535) / screen_w;
2144 i[0].u.mi.dy = i[1].u.mi.dy = i[2].u.mi.dy
2145 = ((r.top + 5) * 65535) / screen_h;
2146 i[0].u.mi.dwFlags = i[1].u.mi.dwFlags = i[2].u.mi.dwFlags
2147 = MOUSEEVENTF_ABSOLUTE;
2148 i[0].u.mi.dwFlags |= MOUSEEVENTF_MOVE;
2149 i[1].u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
2150 i[2].u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
2151 ret = pSendInput(3, (INPUT *) i, sizeof(INPUT));
2152
2153 /* hack to prevent mouse message buildup in Wine */
2154 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
2155 return ret;
2156 }
2157
2158 static DWORD WINAPI test_menu_input_thread(LPVOID lpParameter)
2159 {
2160 int i, j;
2161 HANDLE hWnd = lpParameter;
2162
2163 Sleep(500);
2164 /* mixed keyboard/mouse test */
2165 for (i = 0; menu_tests[i].type != -1; i++)
2166 {
2167 BOOL ret = TRUE;
2168 int elapsed = 0;
2169
2170 got_input = i && menu_tests[i-1].bMenuVisible;
2171
2172 if (menu_tests[i].type == INPUT_KEYBOARD)
2173 for (j = 0; menu_tests[i].wVk[j] != 0; j++)
2174 send_key(menu_tests[i].wVk[j]);
2175 else
2176 for (j = 0; menu_tests[i].menu_item_pairs[j].uMenu != 0; j++)
2177 if (!(ret = click_menu(hWnd, &menu_tests[i].menu_item_pairs[j]))) break;
2178
2179 if (!ret)
2180 {
2181 skip( "test %u: failed to send input\n", i );
2182 PostMessageA( hWnd, WM_CANCELMODE, 0, 0 );
2183 return 0;
2184 }
2185 while (menu_tests[i].bMenuVisible != bMenuVisible)
2186 {
2187 if (elapsed > 200)
2188 break;
2189 elapsed += 20;
2190 Sleep(20);
2191 }
2192
2193 if (!got_input)
2194 {
2195 skip( "test %u: didn't receive input\n", i );
2196 PostMessageA( hWnd, WM_CANCELMODE, 0, 0 );
2197 return 0;
2198 }
2199
2200 if (menu_tests[i]._todo_wine)
2201 {
2202 todo_wine {
2203 ok(menu_tests[i].bMenuVisible == bMenuVisible, "test %d\n", i);
2204 }
2205 }
2206 else
2207 ok(menu_tests[i].bMenuVisible == bMenuVisible, "test %d\n", i);
2208 }
2209 return 0;
2210 }
2211
2212 static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam,
2213 LPARAM lParam)
2214 {
2215 switch (msg) {
2216 case WM_ENTERMENULOOP:
2217 bMenuVisible = TRUE;
2218 break;
2219 case WM_INITMENUPOPUP:
2220 case WM_UNINITMENUPOPUP:
2221 case WM_EXITMENULOOP:
2222 case WM_MENUSELECT:
2223 break;
2224
2225 case WM_KEYDOWN:
2226 case WM_SYSKEYDOWN:
2227 case WM_MOUSEMOVE:
2228 case WM_LBUTTONDOWN:
2229 case WM_LBUTTONUP:
2230 case WM_NCMOUSEMOVE:
2231 case WM_NCLBUTTONDOWN:
2232 case WM_NCLBUTTONUP:
2233 got_input = TRUE;
2234 /* fall through */
2235 default:
2236 return( DefWindowProcA( hWnd, msg, wParam, lParam ) );
2237 }
2238
2239 if(pGetMenuBarInfo)
2240 {
2241 MENUBARINFO mbi;
2242 HMENU hmenu;
2243 UINT state;
2244 BOOL br;
2245
2246 mbi.cbSize = sizeof(MENUBARINFO);
2247
2248 /* get info for the menu */
2249 br = pGetMenuBarInfo(hWnd, OBJID_MENU, 0, &mbi);
2250 ok(br, "msg %x: GetMenuBarInfo failed\n", msg);
2251 hmenu = GetMenu(hWnd);
2252 ok(!mbi.hwndMenu, "msg %x: GetMenuBarInfo.hwndMenu wrong: %p expected NULL\n",
2253 msg, mbi.hwndMenu);
2254 ok(mbi.hMenu == hmenu, "msg %x: GetMenuBarInfo got wrong menu: %p expected %p\n",
2255 msg, mbi.hMenu, hmenu);
2256 ok(!bMenuVisible == !mbi.fBarFocused, "msg %x: GetMenuBarInfo.fBarFocused (%d) is wrong\n",
2257 msg, mbi.fBarFocused != 0);
2258 ok(!bMenuVisible == !mbi.fFocused, "msg %x: GetMenuBarInfo.fFocused (%d) is wrong\n",
2259 msg, mbi.fFocused != 0);
2260
2261 /* get info for the menu's first item */
2262 br = pGetMenuBarInfo(hWnd, OBJID_MENU, 1, &mbi);
2263 ok(br, "msg %x: GetMenuBarInfo failed\n", msg);
2264 state = GetMenuState(hmenu, 0, MF_BYPOSITION);
2265 if (pGetMenuInfo) /* Skip on NT */
2266 {
2267 /* Native returns handle to destroyed window */
2268 if (msg==WM_UNINITMENUPOPUP && popmenu==1)
2269 todo_wine ok(!mbi.hwndMenu == !popmenu,
2270 "msg %x: GetMenuBarInfo.hwndMenu wrong: %p expected %sNULL\n",
2271 msg, mbi.hwndMenu, popmenu ? "not " : "");
2272 else
2273 ok(!mbi.hwndMenu == !popmenu,
2274 "msg %x: GetMenuBarInfo.hwndMenu wrong: %p expected %sNULL\n",
2275 msg, mbi.hwndMenu, popmenu ? "not " : "");
2276 }
2277 ok(mbi.hMenu == hmenu, "msg %x: GetMenuBarInfo got wrong menu: %p expected %p\n",
2278 msg, mbi.hMenu, hmenu);
2279 ok(!bMenuVisible == !mbi.fBarFocused, "nsg %x: GetMenuBarInfo.fBarFocused (%d) is wrong\n",
2280 msg, mbi.fBarFocused != 0);
2281 ok(!(bMenuVisible && (state & MF_HILITE)) == !mbi.fFocused,
2282 "msg %x: GetMenuBarInfo.fFocused (%d) is wrong\n", msg, mbi.fFocused != 0);
2283 }
2284
2285 if (msg == WM_EXITMENULOOP)
2286 bMenuVisible = FALSE;
2287 else if (msg == WM_INITMENUPOPUP)
2288 popmenu++;
2289 else if (msg == WM_UNINITMENUPOPUP)
2290 popmenu--;
2291 return 0;
2292 }
2293
2294 static void test_menu_input(void) {
2295 MSG msg;
2296 WNDCLASSA wclass;
2297 HINSTANCE hInstance = GetModuleHandleA( NULL );
2298 HANDLE hThread, hWnd;
2299 DWORD tid;
2300 ATOM aclass;
2301
2302 if (!pSendInput)
2303 {
2304 win_skip("SendInput is not available\n");
2305 return;
2306 }
2307
2308 wclass.lpszClassName = "MenuTestClass";
2309 wclass.style = CS_HREDRAW | CS_VREDRAW;
2310 wclass.lpfnWndProc = WndProc;
2311 wclass.hInstance = hInstance;
2312 wclass.hIcon = LoadIconA( 0, (LPCSTR)IDI_APPLICATION );
2313 wclass.hCursor = LoadCursorA( 0, (LPCSTR)IDC_ARROW );
2314 wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
2315 wclass.lpszMenuName = 0;
2316 wclass.cbClsExtra = 0;
2317 wclass.cbWndExtra = 0;
2318 aclass = RegisterClassA( &wclass );
2319 ok (aclass, "MenuTest class not created\n");
2320 if (!aclass) return;
2321 hWnd = CreateWindowA( wclass.lpszClassName, "MenuTest",
2322 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
2323 400, 200, NULL, NULL, hInstance, NULL);
2324 ok (hWnd != NULL, "MenuTest window not created\n");
2325 if (!hWnd) return;
2326 /* fixed menus */
2327 hMenus[3] = CreatePopupMenu();
2328 AppendMenuA(hMenus[3], MF_STRING, 0, "&Enabled");
2329 AppendMenuA(hMenus[3], MF_STRING|MF_DISABLED, 0, "&Disabled");
2330
2331 hMenus[2] = CreatePopupMenu();
2332 AppendMenuA(hMenus[2], MF_STRING|MF_POPUP, (UINT_PTR) hMenus[3], "&Popup");
2333 AppendMenuA(hMenus[2], MF_STRING, 0, "&Enabled");
2334 AppendMenuA(hMenus[2], MF_STRING|MF_DISABLED, 0, "&Disabled");
2335
2336 hMenus[1] = CreateMenu();
2337 AppendMenuA(hMenus[1], MF_STRING|MF_POPUP, (UINT_PTR) hMenus[2], "&Menu");
2338 AppendMenuA(hMenus[1], MF_STRING, 0, "&Enabled");
2339 AppendMenuA(hMenus[1], MF_STRING|MF_DISABLED, 0, "&Disabled");
2340
2341 SetMenu(hWnd, hMenus[1]);
2342 ShowWindow(hWnd, SW_SHOW);
2343 UpdateWindow(hWnd);
2344
2345 hThread = CreateThread(NULL, 0, test_menu_input_thread, hWnd, 0, &tid);
2346 while(1)
2347 {
2348 if (WAIT_TIMEOUT != WaitForSingleObject(hThread, 50))
2349 break;
2350 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
2351 }
2352 DestroyWindow(hWnd);
2353 }
2354
2355 static void test_menu_flags( void )
2356 {
2357 HMENU hMenu, hPopupMenu;
2358
2359 hMenu = CreateMenu();
2360 hPopupMenu = CreatePopupMenu();
2361
2362 AppendMenuA(hMenu, MF_POPUP | MF_STRING, (UINT_PTR)hPopupMenu, "Popup");
2363
2364 AppendMenuA(hPopupMenu, MF_STRING | MF_HILITE | MF_DEFAULT, 101, "Item 1");
2365 InsertMenuA(hPopupMenu, 1, MF_BYPOSITION | MF_STRING | MF_HILITE | MF_DEFAULT, 102, "Item 2");
2366 AppendMenuA(hPopupMenu, MF_STRING, 103, "Item 3");
2367 ModifyMenuA(hPopupMenu, 2, MF_BYPOSITION | MF_STRING | MF_HILITE | MF_DEFAULT, 103, "Item 3");
2368
2369 ok(GetMenuState(hPopupMenu, 0, MF_BYPOSITION) & MF_HILITE,
2370 "AppendMenu should accept MF_HILITE\n");
2371 ok(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE,
2372 "InsertMenu should accept MF_HILITE\n");
2373 ok(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE,
2374 "ModifyMenu should accept MF_HILITE\n");
2375
2376 ok(!(GetMenuState(hPopupMenu, 0, MF_BYPOSITION) & MF_DEFAULT),
2377 "AppendMenu must not accept MF_DEFAULT\n");
2378 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_DEFAULT),
2379 "InsertMenu must not accept MF_DEFAULT\n");
2380 ok(!(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_DEFAULT),
2381 "ModifyMenu must not accept MF_DEFAULT\n");
2382
2383 DestroyMenu(hMenu);
2384 }
2385
2386 static void test_menu_hilitemenuitem( void )
2387 {
2388 HMENU hMenu, hPopupMenu;
2389 WNDCLASSA wclass;
2390 HWND hWnd;
2391 ATOM aclass;
2392
2393 wclass.lpszClassName = "HiliteMenuTestClass";
2394 wclass.style = CS_HREDRAW | CS_VREDRAW;
2395 wclass.lpfnWndProc = WndProc;
2396 wclass.hInstance = GetModuleHandleA( NULL );
2397 wclass.hIcon = LoadIconA( 0, (LPCSTR)IDI_APPLICATION );
2398 wclass.hCursor = LoadCursorA( 0, (LPCSTR)IDC_ARROW );
2399 wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
2400 wclass.lpszMenuName = 0;
2401 wclass.cbClsExtra = 0;
2402 wclass.cbWndExtra = 0;
2403 aclass = RegisterClassA( &wclass );
2404 ok (aclass, "HiliteMenuTest class could not be created\n");
2405 if (!aclass) return;
2406 hWnd = CreateWindowA( wclass.lpszClassName, "HiliteMenuTest",
2407 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
2408 400, 200, NULL, NULL, wclass.hInstance, NULL);
2409 ok (hWnd != NULL, "HiliteMenuTest window could not be created\n");
2410 if (!hWnd) return;
2411
2412 hMenu = CreateMenu();
2413 hPopupMenu = CreatePopupMenu();
2414
2415 AppendMenuA(hMenu, MF_POPUP | MF_STRING, (UINT_PTR)hPopupMenu, "Popup");
2416
2417 AppendMenuA(hPopupMenu, MF_STRING, 101, "Item 1");
2418 AppendMenuA(hPopupMenu, MF_STRING, 102, "Item 2");
2419 AppendMenuA(hPopupMenu, MF_STRING, 103, "Item 3");
2420
2421 SetMenu(hWnd, hMenu);
2422
2423 /* test invalid arguments */
2424
2425 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2426 "HiliteMenuItem: Item 2 is hilited\n");
2427
2428 SetLastError(0xdeadbeef);
2429 todo_wine
2430 {
2431 ok(!HiliteMenuItem(NULL, hPopupMenu, 1, MF_HILITE | MF_BYPOSITION),
2432 "HiliteMenuItem: call should have failed.\n");
2433 }
2434 ok(GetLastError() == 0xdeadbeef || /* 9x */
2435 GetLastError() == ERROR_INVALID_WINDOW_HANDLE /* NT */,
2436 "HiliteMenuItem: expected error ERROR_INVALID_WINDOW_HANDLE, got: %d\n", GetLastError());
2437
2438 SetLastError(0xdeadbeef);
2439 ok(!HiliteMenuItem(hWnd, NULL, 1, MF_HILITE | MF_BYPOSITION),
2440 "HiliteMenuItem: call should have failed.\n");
2441 ok(GetLastError() == 0xdeadbeef || /* 9x */
2442 GetLastError() == ERROR_INVALID_MENU_HANDLE /* NT */,
2443 "HiliteMenuItem: expected error ERROR_INVALID_MENU_HANDLE, got: %d\n", GetLastError());
2444
2445 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2446 "HiliteMenuItem: Item 2 is hilited\n");
2447
2448 /* either MF_HILITE or MF_UNHILITE *and* MF_BYCOMMAND or MF_BYPOSITION need to be set */
2449
2450 SetLastError(0xdeadbeef);
2451 ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_BYPOSITION),
2452 "HiliteMenuItem: call should have succeeded.\n");
2453 ok(GetLastError() == 0xdeadbeef,
2454 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2455
2456 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2457 "HiliteMenuItem: Item 2 is hilited\n");
2458
2459 SetLastError(0xdeadbeef);
2460 todo_wine
2461 {
2462 ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_HILITE),
2463 "HiliteMenuItem: call should have succeeded.\n");
2464 }
2465 ok(GetLastError() == 0xdeadbeef,
2466 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2467
2468 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2469 "HiliteMenuItem: Item 2 is hilited\n");
2470
2471 /* hilite a menu item (by position) */
2472
2473 SetLastError(0xdeadbeef);
2474 ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_HILITE | MF_BYPOSITION),
2475 "HiliteMenuItem: call should not have failed.\n");
2476 ok(GetLastError() == 0xdeadbeef,
2477 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2478
2479 todo_wine
2480 {
2481 ok(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE,
2482 "HiliteMenuItem: Item 2 is not hilited\n");
2483 }
2484
2485 /* unhilite a menu item (by position) */
2486
2487 SetLastError(0xdeadbeef);
2488 ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_UNHILITE | MF_BYPOSITION),
2489 "HiliteMenuItem: call should not have failed.\n");
2490 ok(GetLastError() == 0xdeadbeef,
2491 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2492
2493 ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2494 "HiliteMenuItem: Item 2 is hilited\n");
2495
2496 /* hilite a menu item (by command) */
2497
2498 SetLastError(0xdeadbeef);
2499 ok(HiliteMenuItem(hWnd, hPopupMenu, 103, MF_HILITE | MF_BYCOMMAND),
2500 "HiliteMenuItem: call should not have failed.\n");
2501 ok(GetLastError() == 0xdeadbeef,
2502 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2503
2504 todo_wine
2505 {
2506 ok(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE,
2507 "HiliteMenuItem: Item 3 is not hilited\n");
2508 }
2509
2510 /* unhilite a menu item (by command) */
2511
2512 SetLastError(0xdeadbeef);
2513 ok(HiliteMenuItem(hWnd, hPopupMenu, 103, MF_UNHILITE | MF_BYCOMMAND),
2514 "HiliteMenuItem: call should not have failed.\n");
2515 ok(GetLastError() == 0xdeadbeef,
2516 "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2517
2518 ok(!(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE),
2519 "HiliteMenuItem: Item 3 is hilited\n");
2520
2521 DestroyWindow(hWnd);
2522 }
2523
2524 static void check_menu_items(HMENU hmenu, UINT checked_cmd, UINT checked_type,
2525 UINT checked_state)
2526 {
2527 INT i, count;
2528
2529 count = GetMenuItemCount(hmenu);
2530 ok (count != -1, "GetMenuItemCount returned -1\n");
2531
2532 for (i = 0; i < count; i++)
2533 {
2534 BOOL ret;
2535 MENUITEMINFOA mii;
2536
2537 memset(&mii, 0, sizeof(mii));
2538 mii.cbSize = sizeof(mii);
2539 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU;
2540 ret = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
2541 ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2542
2543 if (winetest_debug > 1)
2544 trace("item #%u: fType %04x, fState %04x, wID %u, hSubMenu %p\n",
2545 i, mii.fType, mii.fState, mii.wID, mii.hSubMenu);
2546
2547 if (mii.hSubMenu)
2548 {
2549 ok(mii.wID == (UINT_PTR)mii.hSubMenu, "id %u: wID should be equal to hSubMenu\n", checked_cmd);
2550 if (!GetMenuItemCount(mii.hSubMenu))
2551 {
2552 ok(mii.fType == checked_type, "id %u: expected fType %04x, got %04x\n", checked_cmd, checked_type, mii.fType);
2553 ok(mii.fState == checked_state, "id %u: expected fState %04x, got %04x\n", checked_cmd, checked_state, mii.fState);
2554 }
2555 check_menu_items(mii.hSubMenu, checked_cmd, checked_type, checked_state);
2556 }
2557 else
2558 {
2559 if (mii.wID == checked_cmd)
2560 {
2561 ok(mii.fType == checked_type, "id %u: expected fType %04x, got %04x\n", checked_cmd, checked_type, mii.fType);
2562 ok(mii.fState == checked_state, "id %u: expected fState %04x, got %04x\n", checked_cmd, checked_state, mii.fState);
2563 ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
2564 }
2565 else
2566 {
2567 ok(mii.fType != MFT_RADIOCHECK, "id %u: not expected fType MFT_RADIOCHECK on cmd %u\n", checked_cmd, mii.wID);
2568
2569 if (mii.fType == MFT_SEPARATOR)
2570 {
2571 ok(mii.fState == MFS_GRAYED, "id %u: expected fState MFS_GRAYED, got %04x\n", checked_cmd, mii.fState);
2572 ok(mii.wID == 0, "id %u: expected wID 0, got %u\n", checked_cmd, mii.wID);
2573 }
2574 else
2575 {
2576 ok(mii.fState == 0, "id %u: expected fState 0, got %04x\n", checked_cmd, mii.fState);
2577 ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
2578 }
2579 }
2580 }
2581 }
2582 }
2583
2584 static void clear_ftype_and_state(HMENU hmenu, UINT id, UINT flags)
2585 {
2586 BOOL ret;
2587 MENUITEMINFOA mii;
2588
2589 memset(&mii, 0, sizeof(mii));
2590 mii.cbSize = sizeof(mii);
2591 mii.fMask = MIIM_FTYPE | MIIM_STATE;
2592 ret = SetMenuItemInfoA(hmenu, id, (flags & MF_BYPOSITION) != 0, &mii);
2593 ok(ret, "SetMenuItemInfo(%u) failed\n", id);
2594 }
2595
2596 static void test_CheckMenuRadioItem(void)
2597 {
2598 BOOL ret;
2599 HMENU hmenu;
2600
2601 hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
2602 assert(hmenu != 0);
2603
2604 check_menu_items(hmenu, -1, 0, 0);
2605
2606 ret = CheckMenuRadioItem(hmenu, 100, 100, 100, MF_BYCOMMAND);
2607 ok(ret, "CheckMenuRadioItem failed\n");
2608 check_menu_items(hmenu, 100, MFT_RADIOCHECK, MFS_CHECKED);
2609
2610 /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
2611 ret = CheckMenuRadioItem(hmenu, 100, 100, -1, MF_BYCOMMAND);
2612 ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2613 check_menu_items(hmenu, 100, MFT_RADIOCHECK, 0);
2614
2615 /* clear check */
2616 clear_ftype_and_state(hmenu, 100, MF_BYCOMMAND);
2617 check_menu_items(hmenu, -1, 0, 0);
2618
2619 /* first and checked items are on different menus */
2620 ret = CheckMenuRadioItem(hmenu, 0, 300, 202, MF_BYCOMMAND);
2621 ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2622 check_menu_items(hmenu, -1, 0, 0);
2623
2624 ret = CheckMenuRadioItem(hmenu, 200, 300, 202, MF_BYCOMMAND);
2625 ok(ret, "CheckMenuRadioItem failed\n");
2626 check_menu_items(hmenu, 202, MFT_RADIOCHECK, MFS_CHECKED);
2627
2628 /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
2629 ret = CheckMenuRadioItem(hmenu, 202, 202, -1, MF_BYCOMMAND);
2630 ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2631 check_menu_items(hmenu, 202, MFT_RADIOCHECK, 0);
2632
2633 /* clear check */
2634 clear_ftype_and_state(hmenu, 202, MF_BYCOMMAND);
2635 check_menu_items(hmenu, -1, 0, 0);
2636
2637 /* just for fun, try to check separator */
2638 ret = CheckMenuRadioItem(hmenu, 0, 300, 0, MF_BYCOMMAND);
2639 ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2640 check_menu_items(hmenu, -1, 0, 0);
2641 }
2642
2643 static void test_menu_resource_layout(void)
2644 {
2645 static const struct
2646 {
2647 MENUITEMTEMPLATEHEADER mith;
2648 WORD data[14];
2649 } menu_template =
2650 {
2651 { 0, 0 }, /* versionNumber, offset */
2652 {
2653 /* mtOption, mtID, mtString[] '\0' terminated */
2654 MF_STRING, 1, 'F', 0,
2655 MF_STRING, 2, 0,
2656 MF_SEPARATOR, 3, 0,
2657 /* MF_SEPARATOR, 4, 'S', 0, FIXME: Wine ignores 'S' */
2658 MF_STRING|MF_GRAYED|MF_END, 5, 'E', 0
2659 }
2660 };
2661 static const struct
2662 {
2663 UINT type, state, id;
2664 const char *str;
2665 } menu_data[] =
2666 {
2667 { MF_STRING, MF_ENABLED, 1, "F" },
2668 { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 2, "" },
2669 { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 3, "" },
2670 /*{ MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 4, "S" }, FIXME: Wine ignores 'S'*/
2671 { MF_STRING, MF_GRAYED, 5, "E" },
2672 { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 6, "" },
2673 { MF_STRING, MF_ENABLED, 7, "" },
2674 { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 8, "" }
2675 };
2676 HMENU hmenu;
2677 INT count, i;
2678 BOOL ret;
2679
2680 hmenu = LoadMenuIndirectA(&menu_template);
2681 ok(hmenu != 0, "LoadMenuIndirect error %u\n", GetLastError());
2682
2683 ret = AppendMenuA(hmenu, MF_STRING, 6, NULL);
2684 ok(ret, "AppendMenu failed\n");
2685 ret = AppendMenuA(hmenu, MF_STRING, 7, "\0");
2686 ok(ret, "AppendMenu failed\n");
2687 ret = AppendMenuA(hmenu, MF_SEPARATOR, 8, "separator");
2688 ok(ret, "AppendMenu failed\n");
2689
2690 count = GetMenuItemCount(hmenu);
2691 ok(count == sizeof(menu_data)/sizeof(menu_data[0]),
2692 "expected %u menu items, got %u\n",
2693 (UINT)(sizeof(menu_data)/sizeof(menu_data[0])), count);
2694
2695 for (i = 0; i < count; i++)
2696 {
2697 char buf[20];
2698 MENUITEMINFOA mii;
2699
2700 memset(&mii, 0, sizeof(mii));
2701 mii.cbSize = sizeof(mii);
2702 mii.dwTypeData = buf;
2703 mii.cch = sizeof(buf);
2704 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_STRING;
2705 ret = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
2706 ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2707 if (winetest_debug > 1)
2708 trace("item #%u: fType %04x, fState %04x, wID %u, dwTypeData %s\n",
2709 i, mii.fType, mii.fState, mii.wID, (LPCSTR)mii.dwTypeData);
2710
2711 ok(mii.fType == menu_data[i].type,
2712 "%u: expected fType %04x, got %04x\n", i, menu_data[i].type, mii.fType);
2713 ok(mii.fState == menu_data[i].state,
2714 "%u: expected fState %04x, got %04x\n", i, menu_data[i].state, mii.fState);
2715 ok(mii.wID == menu_data[i].id,
2716 "%u: expected wID %04x, got %04x\n", i, menu_data[i].id, mii.wID);
2717 ok(mii.cch == strlen(menu_data[i].str),
2718 "%u: expected cch %u, got %u\n", i, (UINT)strlen(menu_data[i].str), mii.cch);
2719 ok(!strcmp(mii.dwTypeData, menu_data[i].str),
2720 "%u: expected dwTypeData %s, got %s\n", i, menu_data[i].str, (LPCSTR)mii.dwTypeData);
2721 }
2722
2723 DestroyMenu(hmenu);
2724 }
2725
2726 struct menu_data
2727 {
2728 UINT type, id;
2729 const char *str;
2730 };
2731
2732 static HMENU create_menu_from_data(const struct menu_data *item, INT item_count)
2733 {
2734 HMENU hmenu;
2735 INT i;
2736 BOOL ret;
2737
2738 hmenu = CreateMenu();
2739 assert(hmenu != 0);
2740
2741 for (i = 0; i < item_count; i++)
2742 {
2743 SetLastError(0xdeadbeef);
2744 ret = AppendMenuA(hmenu, item[i].type, item[i].id, item[i].str);
2745 ok(ret, "%d: AppendMenu(%04x, %04x, %p) error %u\n",
2746 i, item[i].type, item[i].id, item[i].str, GetLastError());
2747 }
2748 return hmenu;
2749 }
2750
2751 /* use InsertMenuItem: does not set the MFT_BITMAP flag,
2752 * and does not accept non-magic bitmaps with invalid
2753 * bitmap handles */
2754 static HMENU create_menuitem_from_data(const struct menu_data *item, INT item_count)
2755 {
2756 HMENU hmenu;
2757 INT i;
2758 BOOL ret;
2759 MENUITEMINFOA mii = { sizeof( MENUITEMINFOA) };
2760
2761 hmenu = CreateMenu();
2762 assert(hmenu != 0);
2763
2764 for (i = 0; i < item_count; i++)
2765 {
2766 SetLastError(0xdeadbeef);
2767
2768 mii.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STATE;
2769 mii.fType = 0;
2770 if( item[i].type & MFT_BITMAP)
2771 {
2772 mii.fMask |= MIIM_BITMAP;
2773 mii.hbmpItem = (HBITMAP)item[i].str;
2774 }
2775 else if( item[i].type & MFT_SEPARATOR)
2776 mii.fType = MFT_SEPARATOR;
2777 else
2778 {
2779 mii.fMask |= MIIM_STRING;
2780 mii.dwTypeData = (LPSTR)item[i].str;
2781 mii.cch = strlen( item[i].str);
2782 }
2783 mii.fState = 0;
2784 if( item[i].type & MF_HELP) mii.fType |= MF_HELP;
2785 mii.wID = item[i].id;
2786 ret = InsertMenuItemA( hmenu, -1, TRUE, &mii);
2787 ok(ret, "%d: InsertMenuItem(%04x, %04x, %p) error %u\n",
2788 i, item[i].type, item[i].id, item[i].str, GetLastError());
2789 }
2790 return hmenu;
2791 }
2792
2793 static void compare_menu_data(HMENU hmenu, const struct menu_data *item, INT item_count)
2794 {
2795 INT count, i;
2796 BOOL ret;
2797
2798 count = GetMenuItemCount(hmenu);
2799 ok(count == item_count, "expected %d, got %d menu items\n", count, item_count);
2800
2801 for (i = 0; i < count; i++)
2802 {
2803 char buf[20];
2804 MENUITEMINFOA mii;
2805
2806 memset(&mii, 0, sizeof(mii));
2807 mii.cbSize = sizeof(mii);
2808 mii.dwTypeData = buf;
2809 mii.cch = sizeof(buf);
2810 mii.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_BITMAP;
2811 ret = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
2812 ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2813
2814 if (winetest_debug > 1)
2815 trace("item #%u: fType %04x, fState %04x, wID %04x, hbmp %p\n",
2816 i, mii.fType, mii.fState, mii.wID, mii.hbmpItem);
2817
2818 ok(mii.fType == item[i].type,
2819 "%u: expected fType %04x, got %04x\n", i, item[i].type, mii.fType);
2820 ok(mii.wID == item[i].id,
2821 "%u: expected wID %04x, got %04x\n", i, item[i].id, mii.wID);
2822 if (mii.hbmpItem || !item[i].str)
2823 /* For some reason Windows sets high word to not 0 for
2824 * not "magic" ids.
2825 */
2826 ok(LOWORD(mii.hbmpItem) == LOWORD(item[i].str),
2827 "%u: expected hbmpItem %p, got %p\n", i, item[i].str, mii.hbmpItem);
2828 else
2829 {
2830 ok(mii.cch == strlen(item[i].str),
2831 "%u: expected cch %u, got %u\n", i, (UINT)strlen(item[i].str), mii.cch);
2832 ok(!strcmp(mii.dwTypeData, item[i].str),
2833 "%u: expected dwTypeData %s, got %s\n", i, item[i].str, (LPCSTR)mii.dwTypeData);
2834 }
2835 }
2836 }
2837
2838 static void test_InsertMenu(void)
2839 {
2840 HBITMAP hbm = CreateBitmap(1,1,1,1,NULL);
2841 /* Note: XP treats only bitmap handles 1 - 6 as "magic" ones
2842 * regardless of their id.
2843 */
2844 static const struct menu_data in1[] =
2845 {
2846 { MF_STRING, 1, "File" },
2847 { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) },
2848 { MF_STRING|MF_HELP, 2, "Help" }
2849 };
2850 static const struct menu_data out1[] =
2851 {
2852 { MF_STRING, 1, "File" },
2853 { MF_STRING|MF_HELP, 2, "Help" },
2854 { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) }
2855 };
2856 static const struct menu_data out1a[] =
2857 {
2858 { MF_STRING, 1, "File" },
2859 { MF_STRING|MF_HELP, 2, "Help" },
2860 { MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) }
2861 };
2862 const struct menu_data in2[] =
2863 {
2864 { MF_STRING, 1, "File" },
2865 { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
2866 { MF_STRING|MF_HELP, 2, "Help" }
2867 };
2868 const struct menu_data out2[] =
2869 {
2870 { MF_STRING, 1, "File" },
2871 { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
2872 { MF_STRING|MF_HELP, 2, "Help" }
2873 };
2874 const struct menu_data out2a[] =
2875 {
2876 { MF_STRING, 1, "File" },
2877 { MF_HELP, SC_CLOSE, (char*)hbm },
2878 { MF_STRING|MF_HELP, 2, "Help" }
2879 };
2880 static const struct menu_data in3[] =
2881 {
2882 { MF_STRING, 1, "File" },
2883 { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) },
2884 { MF_STRING|MF_HELP, 2, "Help" }
2885 };
2886 static const struct menu_data out3[] =
2887 {
2888 { MF_STRING, 1, "File" },
2889 { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(0) },
2890 { MF_STRING|MF_HELP, 2, "Help" },
2891 };
2892 static const struct menu_data in4[] =
2893 {
2894 { MF_STRING, 1, "File" },
2895 { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCEA(1) },
2896 { MF_STRING|MF_HELP, 2, "Help" }
2897 };
2898 static const struct menu_data out4[] =
2899 {
2900 { MF_STRING, 1, "File" },
2901 { MF_STRING|MF_HELP, 2, "Help" },
2902 { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCEA(1) }
2903 };
2904 static const struct menu_data out4a[] =
2905 {
2906 { MF_STRING, 1, "File" },
2907 { MF_STRING|MF_HELP, 2, "Help" },
2908 { MF_HELP, 1, MAKEINTRESOURCEA(1) }
2909 };
2910 HMENU hmenu;
2911
2912 #define create_menu(a) create_menu_from_data((a), sizeof(a)/sizeof((a)[0]))
2913 #define create_menuitem(a) create_menuitem_from_data((a), sizeof(a)/sizeof((a)[0]))
2914 #define compare_menu(h, a) compare_menu_data((h), (a), sizeof(a)/sizeof((a)[0]))
2915
2916 hmenu = create_menu(in1);
2917 compare_menu(hmenu, out1);
2918 DestroyMenu(hmenu);
2919
2920 hmenu = create_menu(in2);
2921 compare_menu(hmenu, out2);
2922 DestroyMenu(hmenu);
2923
2924 hmenu = create_menu(in3);
2925 compare_menu(hmenu, out3);
2926 DestroyMenu(hmenu);
2927
2928 hmenu = create_menu(in4);
2929 compare_menu(hmenu, out4);
2930 DestroyMenu(hmenu);
2931
2932 /* now using InsertMenuItemInfo */
2933 hmenu = create_menuitem(in1);
2934 compare_menu(hmenu, out1a);
2935 DestroyMenu(hmenu);
2936
2937 hmenu = create_menuitem(in2);
2938 compare_menu(hmenu, out2a);
2939 DestroyMenu(hmenu);
2940
2941 hmenu = create_menuitem(in3);
2942 compare_menu(hmenu, out3);
2943 DestroyMenu(hmenu);
2944
2945 hmenu = create_menuitem(in4);
2946 compare_menu(hmenu, out4a);
2947 DestroyMenu(hmenu);
2948
2949 #undef create_menu
2950 #undef create_menuitem
2951 #undef compare_menu
2952 }
2953
2954 static void test_menu_getmenuinfo(void)
2955 {
2956 HMENU hmenu;
2957 MENUINFO mi = {0};
2958 BOOL ret;
2959 DWORD gle;
2960
2961 if (!pGetMenuInfo)
2962 {
2963 win_skip("GetMenuInfo is not available\n");
2964 return;
2965 }
2966
2967 /* create a menu */
2968 hmenu = CreateMenu();
2969 assert( hmenu);
2970 /* test some parameter errors */
2971 SetLastError(0xdeadbeef);
2972 ret = pGetMenuInfo( hmenu, NULL);
2973 gle= GetLastError();
2974 ok( !ret, "GetMenuInfo() should have failed\n");
2975 ok( gle == ERROR_INVALID_PARAMETER ||
2976 broken(gle == 0xdeadbeef), /* Win98, WinME */
2977 "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2978 SetLastError(0xdeadbeef);
2979 mi.cbSize = 0;
2980 ret = pGetMenuInfo( hmenu, &mi);
2981 gle= GetLastError();
2982 ok( !ret, "GetMenuInfo() should have failed\n");
2983 ok( gle == ERROR_INVALID_PARAMETER ||
2984 broken(gle == 0xdeadbeef), /* Win98, WinME */
2985 "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2986 SetLastError(0xdeadbeef);
2987 mi.cbSize = sizeof( MENUINFO);
2988 ret = pGetMenuInfo( hmenu, &mi);
2989 gle= GetLastError();
2990 ok( ret, "GetMenuInfo() should have succeeded\n");
2991 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2992 SetLastError(0xdeadbeef);
2993 mi.cbSize = 0;
2994 ret = pGetMenuInfo( NULL, &mi);
2995 gle= GetLastError();
2996 ok( !ret, "GetMenuInfo() should have failed\n");
2997 ok( gle == ERROR_INVALID_PARAMETER ||
2998 broken(gle == 0xdeadbeef), /* Win98, WinME */
2999 "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
3000 /* clean up */
3001 DestroyMenu( hmenu);
3002 return;
3003 }
3004
3005 static void test_menu_setmenuinfo(void)
3006 {
3007 HMENU hmenu, hsubmenu;
3008 MENUINFO mi = {0};
3009 MENUITEMINFOA mii = { sizeof(MENUITEMINFOA) };
3010 BOOL ret;
3011 DWORD gle;
3012 HBRUSH brush;
3013
3014 if (!pGetMenuInfo || !pSetMenuInfo)
3015 {
3016 win_skip("Get/SetMenuInfo are not available\n");
3017 return;
3018 }
3019
3020 /* create a menu with a submenu */
3021 hmenu = CreateMenu();
3022 hsubmenu = CreateMenu();
3023 assert( hmenu && hsubmenu);
3024 mii.fMask = MIIM_SUBMENU;
3025 mii.hSubMenu = hsubmenu;
3026 ret = InsertMenuItemA( hmenu, 0, FALSE, &mii);
3027 ok( ret, "InsertMenuItem failed with error %d\n", GetLastError());
3028 /* test some parameter errors */
3029 SetLastError(0xdeadbeef);
3030 ret = pSetMenuInfo( hmenu, NULL);
3031 gle= GetLastError();
3032 ok( !ret, "SetMenuInfo() should have failed\n");
3033 ok( gle == ERROR_INVALID_PARAMETER ||
3034 broken(gle == 0xdeadbeef), /* Win98, WinME */
3035 "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
3036 SetLastError(0xdeadbeef);
3037 mi.cbSize = 0;
3038 ret = pSetMenuInfo( hmenu, &mi);
3039 gle= GetLastError();
3040 ok( !ret, "SetMenuInfo() should have failed\n");
3041 ok( gle == ERROR_INVALID_PARAMETER ||
3042 broken(gle == 0xdeadbeef), /* Win98, WinME */
3043 "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
3044 SetLastError(0xdeadbeef);
3045 mi.cbSize = sizeof( MENUINFO);
3046 ret = pSetMenuInfo( hmenu, &mi);
3047 gle= GetLastError();
3048 ok( ret, "SetMenuInfo() should have succeeded\n");
3049 ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
3050 SetLastError(0xdeadbeef);
3051 mi.cbSize = 0;
3052 ret = pSetMenuInfo( NULL, &mi);
3053 gle= GetLastError();
3054 ok( !ret, "SetMenuInfo() should have failed\n");
3055 ok( gle == ERROR_INVALID_PARAMETER ||
3056 broken(gle == 0xdeadbeef), /* Win98, WinME */
3057 "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
3058 /* functional tests */
3059 /* menu and submenu should have the CHECKORBMP style bit cleared */
3060 SetLastError(0xdeadbeef);
3061 mi.cbSize = sizeof( MENUINFO);
3062 mi.fMask = MIM_STYLE;
3063 ret = pGetMenuInfo( hmenu, &mi);
3064 gle= GetLastError();
3065 ok( ret, "GetMenuInfo() should have succeeded\n");
3066 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3067 ok( !(mi.dwStyle & MNS_CHECKORBMP), "menustyle was not expected to have the MNS_CHECKORBMP flag\n");
3068 SetLastError(0xdeadbeef);
3069 mi.cbSize = sizeof( MENUINFO);
3070 mi.fMask = MIM_STYLE;
3071 ret = pGetMenuInfo( hsubmenu, &mi);
3072 gle= GetLastError();
3073 ok( ret, "GetMenuInfo() should have succeeded\n");
3074 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3075 ok( !(mi.dwStyle & MNS_CHECKORBMP), "menustyle was not expected to have the MNS_CHECKORBMP flag\n");
3076 /* SetMenuInfo() */
3077 SetLastError(0xdeadbeef);
3078 mi.cbSize = sizeof( MENUINFO);
3079 mi.fMask = MIM_STYLE | MIM_APPLYTOSUBMENUS;
3080 mi.dwStyle = MNS_CHECKORBMP;
3081 ret = pSetMenuInfo( hmenu, &mi);
3082 gle= GetLastError();
3083 ok( ret, "SetMenuInfo() should have succeeded\n");
3084 ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
3085 /* Now both menus should have the MNS_CHECKORBMP style bit set */
3086 SetLastError(0xdeadbeef);
3087 mi.cbSize = sizeof( MENUINFO);
3088 mi.fMask = MIM_STYLE;
3089 ret = pGetMenuInfo( hmenu, &mi);
3090 gle= GetLastError();
3091 ok( ret, "GetMenuInfo() should have succeeded\n");
3092 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3093 ok( mi.dwStyle & MNS_CHECKORBMP, "menustyle was expected to have the MNS_CHECKORBMP flag\n");
3094 SetLastError(0xdeadbeef);
3095 mi.cbSize = sizeof( MENUINFO);
3096 mi.fMask = MIM_STYLE;
3097 ret = pGetMenuInfo( hsubmenu, &mi);
3098 gle= GetLastError();
3099 ok( ret, "GetMenuInfo() should have succeeded\n");
3100 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3101 ok( mi.dwStyle & MNS_CHECKORBMP, "menustyle was expected to have the MNS_CHECKORBMP flag\n");
3102 /* now repeat that without the APPLYTOSUBMENUS flag and another style bit */
3103 SetLastError(0xdeadbeef);
3104 mi.cbSize = sizeof( MENUINFO);
3105 mi.fMask = MIM_STYLE ;
3106 mi.dwStyle = MNS_NOCHECK;
3107 ret = pSetMenuInfo( hmenu, &mi);
3108 gle= GetLastError();
3109 ok( ret, "SetMenuInfo() should have succeeded\n");
3110 ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
3111 /* Now only the top menu should have the MNS_NOCHECK style bit set */
3112 SetLastError(0xdeadbeef);
3113 mi.cbSize = sizeof( MENUINFO);
3114 mi.fMask = MIM_STYLE;
3115 ret = pGetMenuInfo( hmenu, &mi);
3116 gle= GetLastError();
3117 ok( ret, "GetMenuInfo() should have succeeded\n");
3118 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3119 ok( mi.dwStyle & MNS_NOCHECK, "menustyle was expected to have the MNS_NOCHECK flag\n");
3120 SetLastError(0xdeadbeef);
3121 mi.cbSize = sizeof( MENUINFO);
3122 mi.fMask = MIM_STYLE;
3123 ret = pGetMenuInfo( hsubmenu, &mi);
3124 gle= GetLastError();
3125 ok( ret, "GetMenuInfo() should have succeeded\n");
3126 ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
3127 ok( !(mi.dwStyle & MNS_NOCHECK), "menustyle was not expected to have the MNS_NOCHECK flag\n");
3128
3129 /* test background brush */
3130 mi.cbSize = sizeof(mi);
3131 mi.fMask = MIM_BACKGROUND;
3132 ret = pGetMenuInfo( hmenu, &mi );
3133 ok( ret, "GetMenuInfo() should have succeeded\n" );
3134 ok( mi.hbrBack == NULL, "got %p\n", mi.hbrBack );
3135
3136 brush = CreateSolidBrush( RGB(0xff, 0, 0) );
3137 mi.hbrBack = brush;
3138 ret = pSetMenuInfo( hmenu, &mi );
3139 ok( ret, "SetMenuInfo() should have succeeded\n" );
3140 mi.hbrBack = NULL;
3141 ret = pGetMenuInfo( hmenu, &mi );
3142 ok( ret, "GetMenuInfo() should have succeeded\n" );
3143 ok( mi.hbrBack == brush, "got %p original %p\n", mi.hbrBack, brush );
3144
3145 mi.hbrBack = NULL;
3146 ret = pSetMenuInfo( hmenu, &mi );
3147 ok( ret, "SetMenuInfo() should have succeeded\n" );
3148 ret = pGetMenuInfo( hmenu, &mi );
3149 ok( ret, "GetMenuInfo() should have succeeded\n" );
3150 ok( mi.hbrBack == NULL, "got %p\n", mi.hbrBack );
3151 DeleteObject( brush );
3152
3153 /* clean up */
3154 DestroyMenu( hsubmenu);
3155 DestroyMenu( hmenu);
3156 return;
3157 }
3158
3159 /* little func to easy switch either TrackPopupMenu() or TrackPopupMenuEx() */
3160 static DWORD MyTrackPopupMenu( int ex, HMENU hmenu, UINT flags, INT x, INT y, HWND hwnd, LPTPMPARAMS ptpm)
3161 {
3162 return ex
3163 ? TrackPopupMenuEx( hmenu, flags, x, y, hwnd, ptpm)
3164 : TrackPopupMenu( hmenu, flags, x, y, 0, hwnd, NULL);
3165 }
3166
3167 /* some TrackPopupMenu and TrackPopupMenuEx tests */
3168 /* the LastError values differ between NO_ERROR and invalid handle */
3169 /* between all windows versions tested. The first value is that valid on XP */
3170 /* Vista was the only that made returned different error values */
3171 /* between the TrackPopupMenu and TrackPopupMenuEx functions */
3172 static void test_menu_trackpopupmenu(void)
3173 {
3174 BOOL ret;
3175 HMENU hmenu;
3176 DWORD gle;
3177 int Ex;
3178 HWND hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
3179 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3180 NULL, NULL, NULL, NULL);
3181 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
3182 if (!hwnd) return;
3183 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
3184 for( Ex = 0; Ex < 2; Ex++)
3185 {
3186 hmenu = CreatePopupMenu();
3187 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
3188 if (!hmenu)
3189 {
3190 DestroyWindow(hwnd);
3191 return;
3192 }
3193 /* display the menu */
3194 /* start with an invalid menu handle */
3195 SetLastError(0xdeadbeef);
3196
3197 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
3198 ret = MyTrackPopupMenu( Ex, NULL, TPM_RETURNCMD, 100,100, hwnd, NULL);
3199 gle = GetLastError();
3200 ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
3201 ok( gle == ERROR_INVALID_MENU_HANDLE
3202 || broken (gle == 0xdeadbeef) /* win95 */
3203 || broken (gle == NO_ERROR) /* win98/ME */
3204 ,"TrackPopupMenu%s error got %u expected %u\n",
3205 Ex ? "Ex" : "", gle, ERROR_INVALID_MENU_HANDLE);
3206 ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
3207 "got unexpected message(s)%s%s%s\n",
3208 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
3209 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
3210 gflag_initmenu ? "WM_INITMENU": "");
3211 /* another one but not NULL */
3212 SetLastError(0xdeadbeef);
3213 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
3214 ret = MyTrackPopupMenu( Ex, (HMENU)hwnd, TPM_RETURNCMD, 100,100, hwnd, NULL);
3215 gle = GetLastError();
3216 ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
3217 ok( gle == ERROR_INVALID_MENU_HANDLE
3218 || broken (gle == 0xdeadbeef) /* win95 */
3219 || broken (gle == NO_ERROR) /* win98/ME */
3220 ,"TrackPopupMenu%s error got %u expected %u\n",
3221 Ex ? "Ex" : "", gle, ERROR_INVALID_MENU_HANDLE);
3222 ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
3223 "got unexpected message(s)%s%s%s\n",
3224 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
3225 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
3226 gflag_initmenu ? "WM_INITMENU": "");
3227
3228 /* invalid window */
3229 SetLastError(0xdeadbeef);
3230 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
3231 ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, 0, NULL);
3232 gle = GetLastError();
3233 ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
3234 ok( gle == ERROR_INVALID_WINDOW_HANDLE, "TrackPopupMenu%s error got %u\n", Ex ? "Ex" : "", gle );
3235 ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
3236 "got unexpected message(s)%s%s%s\n",
3237 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
3238 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
3239 gflag_initmenu ? "WM_INITMENU": "");
3240
3241 /* now a somewhat successful call */
3242 SetLastError(0xdeadbeef);
3243 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
3244 ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, hwnd, NULL);
3245 gle = GetLastError();
3246 ok( ret == 0, "TrackPopupMenu%s returned %d expected zero\n", Ex ? "Ex" : "", ret);
3247 ok( gle == NO_ERROR
3248 || gle == ERROR_INVALID_MENU_HANDLE /* NT4, win2k */
3249 || broken (gle == 0xdeadbeef) /* win95 */
3250 ,"TrackPopupMenu%s error got %u expected %u or %u\n",
3251 Ex ? "Ex" : "", gle, NO_ERROR, ERROR_INVALID_MENU_HANDLE);
3252 ok( gflag_initmenupopup && gflag_entermenuloop && gflag_initmenu,
3253 "missed expected message(s)%s%s%s\n",
3254 !gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
3255 !gflag_entermenuloop ? "WM_INITMENULOOP ": "",
3256 !gflag_initmenu ? "WM_INITMENU": "");
3257 /* and another */
3258 ret = AppendMenuA( hmenu, MF_STRING, 1, "winetest");
3259 ok( ret, "AppendMenA has failed!\n");
3260 SetLastError(0xdeadbeef);
3261 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
3262 ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, hwnd, NULL);
3263 gle = GetLastError();
3264 ok( ret == 0, "TrackPopupMenu%s returned %d expected zero\n", Ex ? "Ex" : "", ret);
3265 ok( gle == NO_ERROR
3266 || gle == ERROR_INVALID_MENU_HANDLE /* NT4, win2k and Vista in the TrackPopupMenuEx case */
3267 || broken (gle == 0xdeadbeef) /* win95 */
3268 ,"TrackPopupMenu%s error got %u expected %u or %u\n",
3269 Ex ? "Ex" : "", gle, NO_ERROR, ERROR_INVALID_MENU_HANDLE);
3270 ok( gflag_initmenupopup && gflag_entermenuloop && gflag_initmenu,
3271 "missed expected message(s)%s%s%s\n",
3272 !gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
3273 !gflag_entermenuloop ? "WM_INITMENULOOP ": "",
3274 !gflag_initmenu ? "WM_INITMENU": "");
3275 DestroyMenu(hmenu);
3276 }
3277 /* clean up */
3278 DestroyWindow(hwnd);
3279 }
3280
3281 static HMENU g_hmenu;
3282
3283 static LRESULT WINAPI menu_track_again_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
3284 {
3285 switch (msg)
3286 {
3287 case WM_ENTERMENULOOP:
3288 {
3289 BOOL ret;
3290
3291 /* try a recursive call */
3292 SetLastError(0xdeadbeef);
3293 ret = TrackPopupMenu(g_hmenu, 0, 100, 100, 0, hwnd, NULL);
3294 ok(ret == FALSE, "got %d\n", ret);
3295 ok(GetLastError() == ERROR_POPUP_ALREADY_ACTIVE ||
3296 broken(GetLastError() == 0xdeadbeef) /* W9x */, "got %d\n", GetLastError());
3297
3298 /* exit menu modal loop
3299 * ( A SendMessage does not work on NT3.51 here ) */
3300 return PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
3301 }
3302 }
3303 return DefWindowProcA(hwnd, msg, wparam, lparam);
3304 }
3305
3306 static void test_menu_trackagain(void)
3307 {
3308 HWND hwnd;
3309 BOOL ret;
3310
3311 hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
3312 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3313 NULL, NULL, NULL, NULL);
3314 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
3315 if (!hwnd) return;
3316 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_track_again_wnd_proc);
3317
3318 g_hmenu = CreatePopupMenu();
3319 ok(g_hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
3320
3321 ret = AppendMenuA(g_hmenu, MF_STRING , 100, "item 1");
3322 ok(ret, "AppendMenu failed.\n");
3323 ret = AppendMenuA(g_hmenu, MF_STRING , 101, "item 2");
3324 ok(ret, "AppendMenu failed.\n");
3325
3326 ret = TrackPopupMenu( g_hmenu, 0, 100, 100, 0, hwnd, NULL);
3327 ok(ret == TRUE, "got %d\n", ret);
3328
3329 DestroyMenu(g_hmenu);
3330 DestroyWindow(hwnd);
3331 }
3332
3333 /* test handling of WM_CANCELMODE messages */
3334 static int g_got_enteridle;
3335 static HWND g_hwndtosend;
3336 static LRESULT WINAPI menu_cancelmode_wnd_proc(HWND hwnd, UINT msg,
3337 WPARAM wparam, LPARAM lparam)
3338 {
3339 switch (msg)
3340 {
3341 case WM_ENTERMENULOOP:
3342 g_got_enteridle = 0;
3343 return SendMessageA( g_hwndtosend, WM_CANCELMODE, 0, 0);
3344 case WM_ENTERIDLE:
3345 {
3346 if( g_got_enteridle++ == 0) {
3347 /* little hack to get another WM_ENTERIDLE message */
3348 PostMessageA( hwnd, WM_MOUSEMOVE, 0, 0);
3349 return SendMessageA( g_hwndtosend, WM_CANCELMODE, 0, 0);
3350 }
3351 pEndMenu();
3352 return TRUE;
3353 }
3354 }
3355 return DefWindowProcA( hwnd, msg, wparam, lparam);
3356 }
3357
3358 static void test_menu_cancelmode(void)
3359 {
3360 DWORD ret;
3361 HWND hwnd, hwndchild;
3362 HMENU menu, menubar;
3363 MSG msg;
3364 if( !pEndMenu) { /* win95 */
3365 win_skip( "EndMenu is not available\n");
3366 return;
3367 }
3368 hwnd = CreateWindowExA( 0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
3369 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3370 NULL, NULL, NULL, NULL);
3371 hwndchild = CreateWindowExA( 0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
3372 WS_VISIBLE | WS_CHILD, 10, 10, 20, 20,
3373 hwnd, NULL, NULL, NULL);
3374 ok( hwnd != NULL && hwndchild != NULL,
3375 "CreateWindowEx failed with error %d\n", GetLastError());
3376 g_hwndtosend = hwnd;
3377 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_cancelmode_wnd_proc);
3378 SetWindowLongPtrA( hwndchild, GWLP_WNDPROC, (LONG_PTR)menu_cancelmode_wnd_proc);
3379 menu = CreatePopupMenu();
3380 ok( menu != NULL, "CreatePopupMenu failed with error %d\n", GetLastError());
3381 ret = AppendMenuA( menu, MF_STRING, 1, "winetest");
3382 ok( ret, "Functie failed lasterror is %u\n", GetLastError());
3383 /* seems to be needed only on wine :( */
3384 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
3385 DispatchMessageA(&msg);
3386 /* test the effect of sending a WM_CANCELMODE message in the WM_INITMENULOOP
3387 * handler of the menu owner */
3388 /* test results is extracted from variable g_got_enteridle. Possible values:
3389 * 0 : complete conformance. Sending WM_CANCELMODE cancels a menu initializing tracking
3390 * 1 : Sending WM_CANCELMODE cancels a menu that is in tracking state
3391 * 2 : Sending WM_CANCELMODE does not work
3392 */
3393 /* menu owner is top level window */
3394 g_hwndtosend = hwnd;
3395 TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
3396 ok( g_got_enteridle == 0, "received %d WM_ENTERIDLE messages, none expected\n", g_got_enteridle);
3397 /* menu owner is child window */
3398 g_hwndtosend = hwndchild;
3399 TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwndchild, NULL);
3400 ok(g_got_enteridle == 0, "received %d WM_ENTERIDLE messages, none expected\n", g_got_enteridle);
3401 /* now send the WM_CANCELMODE messages to the WRONG window */
3402 /* those should fail ( to have any effect) */
3403 g_hwndtosend = hwnd;
3404 TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwndchild, NULL);
3405 ok( g_got_enteridle == 2, "received %d WM_ENTERIDLE messages, should be 2\n", g_got_enteridle);
3406
3407 /* test canceling tracking in a window's menu bar */
3408 menubar = CreateMenu();
3409 ok( menubar != NULL, "CreateMenu failed with error %d\n", GetLastError());
3410 ret = AppendMenuA( menubar, MF_POPUP|MF_STRING, (UINT_PTR)menu, "winetest");
3411 ok( ret, "AppendMenuA failed lasterror is %u\n", GetLastError());
3412 ret = SetMenu( hwnd, menubar );
3413 ok( ret, "SetMenu failed lasterror is %u\n", GetLastError());
3414 /* initiate tracking */
3415 g_hwndtosend = hwnd;
3416 ret = SendMessageA( hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0 );
3417 ok( ret == 0, "Sending WM_SYSCOMMAND/SC_KEYMENU failed lasterror is %u\n", GetLastError());
3418 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
3419 DispatchMessageA(&msg);
3420 ok(g_got_enteridle == 0, "received %d WM_ENTERIDLE messages, none expected\n", g_got_enteridle);
3421
3422 /* cleanup */
3423 DestroyMenu( menubar );
3424 DestroyMenu( menu);
3425 DestroyWindow( hwndchild);
3426 DestroyWindow( hwnd);
3427 }
3428
3429 /* show menu trees have a maximum depth */
3430 static void test_menu_maxdepth(void)
3431 {
3432 #define NR_MENUS 100
3433 HMENU hmenus[ NR_MENUS];
3434 int i;
3435 DWORD ret;
3436
3437 SetLastError(12345678);
3438 for( i = 0; i < NR_MENUS; i++) {
3439 hmenus[i] = CreatePopupMenu();
3440 if( !hmenus[i]) break;
3441 }
3442 ok( i == NR_MENUS, "could not create more than %d menu's\n", i);
3443 for( i = 1; i < NR_MENUS; i++) {
3444 ret = AppendMenuA( hmenus[i], MF_POPUP, (UINT_PTR)hmenus[i-1],"test");
3445 if( !ret) break;
3446 }
3447 trace("Maximum depth is %d\n", i);
3448 ok( GetLastError() == 12345678, "unexpected error %d\n", GetLastError());
3449 ok( i < NR_MENUS ||
3450 broken( i == NR_MENUS), /* win98, NT */
3451 "no ( or very large) limit on menu depth!\n");
3452
3453 for( i = 0; i < NR_MENUS; i++)
3454 DestroyMenu( hmenus[i]);
3455 }
3456
3457 /* bug #12171 */
3458 static void test_menu_circref(void)
3459 {
3460 HMENU menu1, menu2;
3461 DWORD ret;
3462
3463 menu1 = CreatePopupMenu();
3464 menu2 = CreatePopupMenu();
3465 ok( menu1 && menu2, "error creating menus.\n");
3466 ret = AppendMenuA( menu1, MF_POPUP, (UINT_PTR)menu2, "winetest");
3467 ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3468 ret = AppendMenuA( menu1, MF_STRING | MF_HILITE, 123, "winetest");
3469 ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3470 /* app chooses an id that happens to clash with its own hmenu */
3471 ret = AppendMenuA( menu2, MF_STRING, (UINT_PTR)menu2, "winetest");
3472 ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3473 /* now attempt to change the string of the first item of menu1 */
3474 ret = ModifyMenuA( menu1, (UINT_PTR)menu2, MF_POPUP, (UINT_PTR)menu2, "menu 2");
3475 ok( !ret ||
3476 broken( ret), /* win98, NT */
3477 "ModifyMenu should have failed.\n");
3478 if( !ret) { /* will probably stack fault if the ModifyMenu succeeded */
3479 ret = GetMenuState( menu1, 123, 0);
3480 ok( ret == MF_HILITE, "GetMenuState returned %x\n",ret);
3481 }
3482 DestroyMenu( menu2);
3483 DestroyMenu( menu1);
3484 }
3485
3486 /* test how the menu texts are aligned when the menu items have
3487 * different combinations of text and bitmaps (bug #13350) */
3488 static void test_menualign(void)
3489 {
3490 BYTE bmfill[300];
3491 HMENU menu;
3492 HBITMAP hbm1, hbm2, hbm3;
3493 MENUITEMINFOA mii = { sizeof(MENUITEMINFOA) };
3494 DWORD ret;
3495 HWND hwnd;
3496 MENUINFO mi = { sizeof( MENUINFO)};
3497
3498 if( !winetest_interactive) {
3499 skip( "interactive alignment tests.\n");
3500 return;
3501 }
3502 hwnd = CreateWindowExA(0,
3503 "STATIC",
3504 "Menu text alignment Test\nPlease make a selection.",
3505 WS_OVERLAPPEDWINDOW,
3506 100, 100,
3507 300, 300,
3508 NULL, NULL, 0, NULL);
3509 ShowWindow( hwnd, SW_SHOW);
3510 /* create bitmaps */
3511 memset( bmfill, 0xcc, sizeof( bmfill));
3512 hbm1 = CreateBitmap( 10,10,1,1,bmfill);
3513 hbm2 = CreateBitmap( 20,20,1,1,bmfill);
3514 hbm3 = CreateBitmap( 50,6,1,1,bmfill);
3515 ok( hbm1 && hbm2 && hbm3, "Creating bitmaps failed\n");
3516 menu = CreatePopupMenu();
3517 ok( menu != NULL, "CreatePopupMenu() failed\n");
3518 if( pGetMenuInfo) {
3519 mi.fMask = MIM_STYLE;
3520 ret = pGetMenuInfo( menu, &mi);
3521 ok( ret, "GetMenuInfo failed: %d\n", GetLastError());
3522 ok( menu != NULL, "GetMenuInfo() failed\n");
3523 ok( 0 == mi.dwStyle, "menuinfo style is %x\n", mi.dwStyle);
3524 }
3525 /* test 1 */
3526 mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3527 mii.wID = 1;
3528 mii.hbmpItem = hbm1;
3529 mii.dwTypeData = (LPSTR) " OK: menu texts are correctly left-aligned.";
3530 ret = InsertMenuItemA( menu, -1, TRUE, &mii);
3531 ok( ret, "InsertMenuItem() failed\n");
3532 mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID ;
3533 mii.wID = 2;
3534 mii.hbmpItem = hbm2;
3535 mii.dwTypeData = (LPSTR) " FAIL: menu texts are NOT left-aligned.";
3536 ret = InsertMenuItemA( menu, -1, TRUE, &mii);
3537 ok( ret, "InsertMenuItem() failed\n");
3538 ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3539 ok( ret != 2, "User indicated that menu text alignment test 1 failed %d\n", ret);
3540 /* test 2*/
3541 mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3542 mii.wID = 3;
3543 mii.hbmpItem = hbm3;
3544 mii.dwTypeData = NULL;
3545 ret = InsertMenuItemA( menu, 0, TRUE, &mii);
3546 ok( ret, "InsertMenuItem() failed\n");
3547 mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3548 mii.wID = 1;
3549 mii.hbmpItem = hbm1;
3550 /* make the text a bit longer, to keep it readable */
3551 /* this bug is on winXP and reproduced on wine */
3552 mii.dwTypeData = (LPSTR) " OK: menu texts are to the right of the bitmaps........";
3553 ret = SetMenuItemInfoA( menu, 1, TRUE, &mii);
3554 ok( ret, "SetMenuItemInfo() failed\n");
3555 mii.wID = 2;
3556 mii.hbmpItem = hbm2;
3557 mii.dwTypeData = (LPSTR) " FAIL: menu texts are below the first bitmap. ";
3558 ret = SetMenuItemInfoA( menu, 2, TRUE, &mii);
3559 ok( ret, "SetMenuItemInfo() failed\n");
3560 ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3561 ok( ret != 2, "User indicated that menu text alignment test 2 failed %d\n", ret);
3562 /* test 3 */
3563 mii.fMask = MIIM_TYPE | MIIM_ID;
3564 mii.wID = 3;
3565 mii.fType = MFT_BITMAP;
3566 mii.dwTypeData = (LPSTR) hbm3;
3567 ret = SetMenuItemInfoA( menu, 0, TRUE, &mii);
3568 ok( ret, "SetMenuItemInfo() failed\n");
3569 mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3570 mii.wID = 1;
3571 mii.hbmpItem = NULL;
3572 mii.dwTypeData = (LPSTR) " OK: menu texts are below the bitmap.";
3573 ret = SetMenuItemInfoA( menu, 1, TRUE, &mii);
3574 ok( ret, "SetMenuItemInfo() failed\n");
3575 mii.wID = 2;
3576 mii.hbmpItem = NULL;
3577 mii.dwTypeData = (LPSTR) " FAIL: menu texts are NOT below the bitmap.";
3578 ret = SetMenuItemInfoA( menu, 2, TRUE, &mii);
3579 ok( ret, "SetMenuItemInfo() failed\n");
3580 ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3581 ok( ret != 2, "User indicated that menu text alignment test 3 failed %d\n", ret);
3582 /* cleanup */
3583 DeleteObject( hbm1);
3584 DeleteObject( hbm2);
3585 DeleteObject( hbm3);
3586 DestroyMenu( menu);
3587 DestroyWindow( hwnd);
3588 }
3589
3590 static LRESULT WINAPI menu_fill_in_init(HWND hwnd, UINT msg,
3591 WPARAM wparam, LPARAM lparam)
3592 {
3593 HMENU hmenupopup;
3594 BOOL ret;
3595 switch (msg)
3596 {
3597 case WM_INITMENUPOPUP:
3598 gflag_initmenupopup++;
3599 hmenupopup = (HMENU) wparam;
3600 ret = AppendMenuA(hmenupopup, MF_STRING , 100, "item 1");
3601 ok(ret, "AppendMenu failed.\n");
3602 ret = AppendMenuA(hmenupopup, MF_STRING , 101, "item 2");
3603 ok(ret, "AppendMenu failed.\n");
3604 break;
3605 case WM_ENTERMENULOOP:
3606 gflag_entermenuloop++;
3607 break;
3608 case WM_INITMENU:
3609 gflag_initmenu++;
3610 break;
3611 case WM_ENTERIDLE:
3612 gflag_enteridle++;
3613 PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
3614 return TRUE;
3615 case WM_MENUSELECT:
3616 selectitem_wp = wparam;
3617 selectitem_lp = lparam;
3618 break;
3619 }
3620 return DefWindowProcA(hwnd, msg, wparam, lparam);
3621 }
3622
3623 static void test_emptypopup(void)
3624 {
3625 BOOL ret;
3626 HMENU hmenu;
3627
3628 HWND hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
3629 WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3630 NULL, NULL, NULL, NULL);
3631 ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
3632 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
3633
3634 hmenu = CreatePopupMenu();
3635 ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
3636
3637 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
3638 selectitem_wp = 0xdeadbeef;
3639 selectitem_lp = 0xdeadbeef;
3640
3641 ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
3642 ok(ret == 0, "got %i\n", ret);
3643
3644 ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
3645 ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
3646 ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
3647 todo_wine ok(gflag_enteridle == 0, "got %i\n", gflag_initmenu);
3648
3649 todo_wine ok(selectitem_wp == 0xdeadbeef, "got %lx\n", selectitem_wp);
3650 todo_wine ok(selectitem_lp == 0xdeadbeef, "got %lx\n", selectitem_lp);
3651
3652 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
3653 selectitem_wp = 0xdeadbeef;
3654 selectitem_lp = 0xdeadbeef;
3655
3656 ret = TrackPopupMenu( hmenu, 0, 100,100, 0, hwnd, NULL);
3657 todo_wine ok(ret == 0, "got %i\n", ret);
3658
3659 ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
3660 ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
3661 ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
3662 todo_wine ok(gflag_enteridle == 0, "got %i\n", gflag_initmenu);
3663
3664 todo_wine ok(selectitem_wp == 0xdeadbeef, "got %lx\n", selectitem_wp);
3665 todo_wine ok(selectitem_lp == 0xdeadbeef, "got %lx\n", selectitem_lp);
3666
3667 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_fill_in_init);
3668
3669 gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
3670 selectitem_wp = 0xdeadbeef;
3671 selectitem_lp = 0xdeadbeef;
3672
3673 ret = TrackPopupMenu( hmenu, 0, 100,100, 0, hwnd, NULL);
3674 ok(ret == 1, "got %i\n", ret);
3675
3676 ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
3677 ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
3678 ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
3679 ok(gflag_enteridle == 1, "got %i\n", gflag_initmenu);
3680
3681 ok(selectitem_wp == 0xffff0000, "got %lx\n", selectitem_wp);
3682 ok(selectitem_lp == 0, "got %lx\n", selectitem_lp);
3683
3684 DestroyWindow(hwnd);
3685
3686 ret = DestroyMenu(hmenu);
3687 ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
3688 }
3689
3690 static void test_AppendMenu(void)
3691 {
3692 static char string[] = "string";
3693 MENUITEMINFOA mii;
3694 HMENU hmenu, hsubmenu;
3695 HBITMAP hbmp;
3696 char buf[16];
3697 BOOL ret;
3698
3699 hmenu = CreateMenu();
3700 ok(hmenu != 0, "CreateMenu failed\n");
3701 ret = AppendMenuA(hmenu, MF_OWNERDRAW, 201, "item 1");
3702 ok(ret, "AppendMenu failed\n");
3703 check_menu_items(hmenu, 201, MF_OWNERDRAW, 0);
3704 DestroyMenu(hmenu);
3705
3706 hmenu = CreateMenu();
3707 ok(hmenu != 0, "CreateMenu failed\n");
3708 ret = AppendMenuA(hmenu, MF_POPUP, 202, "item 1");
3709 ok(ret, "AppendMenu failed\n");
3710 check_menu_items(hmenu, 202, MF_STRING, 0);
3711 DestroyMenu(hmenu);
3712
3713 hmenu = CreateMenu();
3714 ok(hmenu != 0, "CreateMenu failed\n");
3715 ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, 203, "item 1");
3716 ok(ret, "AppendMenu failed\n");
3717 check_menu_items(hmenu, 203, MF_OWNERDRAW, 0);
3718 DestroyMenu(hmenu);
3719
3720 hmenu = CreateMenu();
3721 ok(hmenu != 0, "CreateMenu failed\n");
3722 hsubmenu = CreateMenu();
3723 ok(hsubmenu != 0, "CreateMenu failed\n");
3724 ret = AppendMenuA(hmenu, MF_OWNERDRAW, (UINT_PTR)hsubmenu, "item 1");
3725 ok(ret, "AppendMenu failed\n");
3726 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
3727 DestroyMenu(hmenu);
3728 DestroyMenu(hsubmenu);
3729
3730 hmenu = CreateMenu();
3731 ok(hmenu != 0, "CreateMenu failed\n");
3732 hsubmenu = CreateMenu();
3733 ok(hsubmenu != 0, "CreateMenu failed\n");
3734 ret = AppendMenuA(hmenu, MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
3735 ok(ret, "AppendMenu failed\n");
3736 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
3737 DestroyMenu(hmenu);
3738 DestroyMenu(hsubmenu);
3739
3740 hmenu = CreateMenu();
3741 ok(hmenu != 0, "CreateMenu failed\n");
3742 hsubmenu = CreateMenu();
3743 ok(hsubmenu != 0, "CreateMenu failed\n");
3744 ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
3745 ok(ret, "AppendMenu failed\n");
3746 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
3747 DestroyMenu(hmenu);
3748 DestroyMenu(hsubmenu);
3749
3750 hmenu = CreateMenu();
3751 ok(hmenu != 0, "CreateMenu failed\n");
3752 hsubmenu = CreatePopupMenu();
3753 ok(hsubmenu != 0, "CreatePopupMenu failed\n");
3754 ret = AppendMenuA(hmenu, MF_OWNERDRAW, (UINT_PTR)hsubmenu, "item 1");
3755 ok(ret, "AppendMenu failed\n");
3756 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
3757 DestroyMenu(hmenu);
3758 DestroyMenu(hsubmenu);
3759
3760 hmenu = CreateMenu();
3761 ok(hmenu != 0, "CreateMenu failed\n");
3762 hsubmenu = CreatePopupMenu();
3763 ok(hsubmenu != 0, "CreatePopupMenu failed\n");
3764 ret = AppendMenuA(hmenu, MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
3765 ok(ret, "AppendMenu failed\n");
3766 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
3767 DestroyMenu(hmenu);
3768 DestroyMenu(hsubmenu);
3769
3770 hmenu = CreateMenu();
3771 ok(hmenu != 0, "CreateMenu failed\n");
3772 hsubmenu = CreatePopupMenu();
3773 ok(hsubmenu != 0, "CreatePopupMenu failed\n");
3774 ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
3775 ok(ret, "AppendMenu failed\n");
3776 check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
3777 DestroyMenu(hmenu);
3778 DestroyMenu(hsubmenu);
3779
3780 hmenu = CreateMenu();
3781 ok(hmenu != 0, "CreateMenu failed\n");
3782 ret = AppendMenuA(hmenu, MF_STRING, 204, "item 1");
3783 ok(ret, "AppendMenu failed\n");
3784 check_menu_items(hmenu, 204, MF_STRING, 0);
3785 ret = ModifyMenuA(hmenu, 0, MF_POPUP | MF_BYPOSITION, 205, "item 2");
3786 ok(ret, "ModifyMenu failed\n");
3787 check_menu_items(hmenu, 205, MF_STRING, 0);
3788 memset(&mii, 0, sizeof(mii));
3789 mii.cbSize = sizeof(mii);
3790 mii.fMask = MIIM_SUBMENU;
3791 mii.hSubMenu = (HMENU)204;
3792 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
3793 ok(!ret, "InsertMenuItem should fail\n");
3794 ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3795 ok(!ret, "SetMenuItemInfo should fail\n");
3796 mii.fMask = MIIM_ID;
3797 mii.wID = 206;
3798 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
3799 ok(ret, "InsertMenuItem failed\n");
3800 if (0) /* FIXME: uncomment once Wine is fixed */
3801 check_menu_items(hmenu, 206, MF_SEPARATOR, MFS_GRAYED);
3802 mii.wID = 207;
3803 ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3804 ok(ret, "SetMenuItemInfo failed\n");
3805 if (0) /* FIXME: uncomment once Wine is fixed */
3806 check_menu_items(hmenu, 207, MF_SEPARATOR, MFS_GRAYED);
3807 DestroyMenu(hmenu);
3808
3809 hbmp = CreateBitmap(1, 1, 1, 1, NULL);
3810 hmenu = CreateMenu();
3811 ok(hmenu != 0, "CreateMenu failed\n");
3812
3813 /* menu item with a string and a bitmap */
3814 memset(&mii, 0, sizeof(mii));
3815 mii.cbSize = sizeof(mii);
3816 mii.fMask = MIIM_STRING | MIIM_BITMAP;
3817 mii.dwTypeData = string;
3818 mii.cch = strlen(string);
3819 mii.hbmpItem = hbmp;
3820 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
3821 ok(ret, "InsertMenuItem failed\n");
3822 memset(&mii, 0x81, sizeof(mii));
3823 memset(buf, 0x81, sizeof(buf));
3824 mii.cbSize = sizeof(mii);
3825 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
3826 mii.dwTypeData = buf;
3827 mii.cch = sizeof(buf);
3828 mii.dwItemData = 0x81818181;
3829 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3830 ok(ret, "GetMenuItemInfo failed\n");
3831 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3832 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
3833 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
3834 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3835 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
3836 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3837 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3838 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3839 ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
3840
3841 memset(&mii, 0x81, sizeof(mii));
3842 mii.cbSize = sizeof(mii);
3843 mii.fMask = MIIM_TYPE;
3844 mii.dwItemData = 0x81818181;
3845 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3846 ok(ret, "GetMenuItemInfo failed\n");
3847 ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
3848 ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
3849 ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
3850 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3851 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
3852 ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
3853 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3854 ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
3855
3856 memset(&mii, 0x81, sizeof(mii));
3857 memset(buf, 0x81, sizeof(buf));
3858 mii.cbSize = sizeof(mii);
3859 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
3860 mii.dwTypeData = buf;
3861 mii.cch = sizeof(buf);
3862 mii.dwItemData = 0x81818181;
3863 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3864 ok(ret, "GetMenuItemInfo failed\n");
3865 ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
3866 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
3867 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
3868 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3869 ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
3870 ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
3871 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3872 ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
3873
3874 DestroyMenu(hmenu);
3875 DeleteObject(hbmp);
3876
3877 hmenu = CreateMenu();
3878 ok(hmenu != 0, "CreateMenu failed\n");
3879
3880 /* menu item with a string and a "magic" bitmap */
3881 memset(&mii, 0, sizeof(mii));
3882 mii.cbSize = sizeof(mii);
3883 mii.fMask = MIIM_STRING | MIIM_BITMAP;
3884 mii.dwTypeData = string;
3885 mii.cch = strlen(string);
3886 mii.hbmpItem = HBMMENU_POPUP_RESTORE;
3887 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
3888 ok(ret, "InsertMenuItem failed\n");
3889 memset(&mii, 0x81, sizeof(mii));
3890 memset(buf, 0x81, sizeof(buf));
3891 mii.cbSize = sizeof(mii);
3892 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
3893 mii.dwTypeData = buf;
3894 mii.cch = sizeof(buf);
3895 mii.dwItemData = 0x81818181;
3896 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3897 ok(ret, "GetMenuItemInfo failed\n");
3898 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3899 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
3900 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
3901 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3902 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
3903 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3904 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3905 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3906 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
3907
3908 memset(&mii, 0x81, sizeof(mii));
3909 mii.cbSize = sizeof(mii);
3910 mii.fMask = MIIM_TYPE;
3911 mii.dwTypeData = buf;
3912 mii.cch = sizeof(buf);
3913 mii.dwItemData = 0x81818181;
3914 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3915 ok(ret, "GetMenuItemInfo failed\n");
3916 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3917 ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
3918 ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
3919 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3920 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
3921 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3922 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3923 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3924 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
3925
3926 memset(&mii, 0x81, sizeof(mii));
3927 memset(buf, 0x81, sizeof(buf));
3928 mii.cbSize = sizeof(mii);
3929 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
3930 mii.dwTypeData = buf;
3931 mii.cch = sizeof(buf);
3932 mii.dwItemData = 0x81818181;
3933 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3934 ok(ret, "GetMenuItemInfo failed\n");
3935 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3936 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
3937 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
3938 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3939 ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
3940 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3941 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3942 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3943 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
3944
3945 DestroyMenu(hmenu);
3946
3947 hbmp = CreateBitmap(1, 1, 1, 1, NULL);
3948 hmenu = CreateMenu();
3949 ok(hmenu != 0, "CreateMenu failed\n");
3950
3951 /* menu item with a string */
3952 memset(&mii, 0, sizeof(mii));
3953 mii.cbSize = sizeof(mii);
3954 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
3955 mii.dwItemData = (ULONG_PTR)hbmp;
3956 mii.dwTypeData = string;
3957 mii.cch = strlen(string);
3958 mii.hbmpItem = hbmp;
3959 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
3960 ok(ret, "InsertMenuItem failed\n");
3961 memset(&mii, 0x81, sizeof(mii));
3962 memset(buf, 0x81, sizeof(buf));
3963 mii.cbSize = sizeof(mii);
3964 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
3965 mii.dwTypeData = buf;
3966 mii.cch = sizeof(buf);
3967 mii.dwItemData = 0x81818181;
3968 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3969 ok(ret, "GetMenuItemInfo failed\n");
3970 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3971 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
3972 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
3973 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3974 ok(mii.dwItemData == (ULONG_PTR)hbmp, "expected %p, got %#lx\n", hbmp, mii.dwItemData);
3975 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3976 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3977 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3978 ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
3979
3980 memset(&mii, 0x81, sizeof(mii));
3981 memset(buf, 0x81, sizeof(buf));
3982 mii.cbSize = sizeof(mii);
3983 mii.fMask = MIIM_TYPE;
3984 mii.dwTypeData = buf;
3985 mii.cch = sizeof(buf);
3986 mii.dwItemData = 0x81818181;
3987 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
3988 ok(ret, "GetMenuItemInfo failed\n");
3989 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
3990 ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
3991 ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
3992 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
3993 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
3994 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
3995 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
3996 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
3997 ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
3998
3999 DestroyMenu(hmenu);
4000 DeleteObject(hbmp);
4001
4002 /* menu item with a string */
4003 hbmp = CreateBitmap(1, 1, 1, 1, NULL);
4004 hmenu = CreateMenu();
4005 ok(hmenu != 0, "CreateMenu failed\n");
4006 memset(&mii, 0, sizeof(mii));
4007 mii.cbSize = sizeof(mii);
4008 mii.fMask = MIIM_STRING;
4009 mii.dwTypeData = string;
4010 mii.cch = strlen(string);
4011 ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
4012 ok(ret, "InsertMenuItem failed\n");
4013 memset(&mii, 0x81, sizeof(mii));
4014 memset(buf, 0x81, sizeof(buf));
4015 mii.cbSize = sizeof(mii);
4016 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
4017 mii.dwTypeData = buf;
4018 mii.cch = sizeof(buf);
4019 mii.dwItemData = 0x81818181;
4020 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4021 ok(ret, "GetMenuItemInfo failed\n");
4022 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
4023 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
4024 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
4025 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
4026 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
4027 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
4028 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
4029 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
4030 ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
4031
4032 /* add "magic" bitmap to a menu item */
4033 mii.fMask = MIIM_BITMAP;
4034 mii.hbmpItem = HBMMENU_POPUP_RESTORE;
4035 ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4036 ok(ret, "SetMenuItemInfo failed\n");
4037 memset(&mii, 0x81, sizeof(mii));
4038 memset(buf, 0x81, sizeof(buf));
4039 mii.cbSize = sizeof(mii);
4040 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
4041 mii.dwTypeData = buf;
4042 mii.cch = sizeof(buf);
4043 mii.dwItemData = 0x81818181;
4044 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4045 ok(ret, "GetMenuItemInfo failed\n");
4046 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
4047 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
4048 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
4049 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
4050 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
4051 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
4052 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
4053 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
4054 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
4055
4056 memset(&mii, 0x81, sizeof(mii));
4057 memset(buf, 0x81, sizeof(buf));
4058 mii.cbSize = sizeof(mii);
4059 mii.fMask = MIIM_TYPE;
4060 mii.dwTypeData = buf;
4061 mii.cch = sizeof(buf);
4062 mii.dwItemData = 0x81818181;
4063 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4064 ok(ret, "GetMenuItemInfo failed\n");
4065 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
4066 ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
4067 ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
4068 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
4069 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
4070 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
4071 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
4072 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
4073 ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
4074
4075 /* replace "magic" bitmap by a normal one */
4076 mii.fMask = MIIM_BITMAP;
4077 mii.hbmpItem = hbmp;
4078 ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4079 ok(ret, "SetMenuItemInfo failed\n");
4080 memset(&mii, 0x81, sizeof(mii));
4081 memset(buf, 0x81, sizeof(buf));
4082 mii.cbSize = sizeof(mii);
4083 mii.fMask = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
4084 mii.dwTypeData = buf;
4085 mii.cch = sizeof(buf);
4086 mii.dwItemData = 0x81818181;
4087 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4088 ok(ret, "GetMenuItemInfo failed\n");
4089 ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
4090 ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
4091 ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
4092 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
4093 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
4094 ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
4095 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
4096 ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
4097 ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
4098
4099 memset(&mii, 0x81, sizeof(mii));
4100 memset(buf, 0x81, sizeof(buf));
4101 mii.cbSize = sizeof(mii);
4102 mii.fMask = MIIM_TYPE;
4103 mii.dwTypeData = buf;
4104 mii.cch = sizeof(buf);
4105 mii.dwItemData = 0x81818181;
4106 ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
4107 ok(ret, "GetMenuItemInfo failed\n");
4108 ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
4109 ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
4110 ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
4111 ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
4112 ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
4113 ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
4114 ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
4115 ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
4116
4117 DestroyMenu(hmenu);
4118 DeleteObject(hbmp);
4119 }
4120
4121 START_TEST(menu)
4122 {
4123 init_function_pointers();
4124
4125 /* Wine defines MENUITEMINFO for W2K and above. NT4 and below can't
4126 * handle that.
4127 */
4128 if (correct_behavior())
4129 {
4130 test_menu_add_string();
4131 test_menu_iteminfo();
4132 test_menu_search_bycommand();
4133 test_CheckMenuRadioItem();
4134 test_menu_resource_layout();
4135 test_InsertMenu();
4136 test_menualign();
4137 }
4138
4139 register_menu_check_class();
4140
4141 test_menu_locked_by_window();
4142 test_subpopup_locked_by_menu();
4143 test_menu_ownerdraw();
4144 test_getmenubarinfo();
4145 test_menu_bmp_and_string();
4146 test_menu_getmenuinfo();
4147 test_menu_setmenuinfo();
4148 test_menu_input();
4149 test_menu_flags();
4150
4151 test_menu_hilitemenuitem();
4152 test_menu_trackpopupmenu();
4153 test_menu_trackagain();
4154 test_menu_cancelmode();
4155 test_menu_maxdepth();
4156 test_menu_circref();
4157 test_emptypopup();
4158 test_AppendMenu();
4159 }
Windows API implementation