Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/src/user32/controls/menu.c@ 8543

Visit:

Last change on this file since 8543 was 8543, checked in by sandervl, 23 years ago
seperate odin control dll with latest wine controls added (not activate & not finished)
File size: 142.7 KB

Line
1	/*
2	* Menu functions
3	*
4	* Copyright 1993 Martin Ayotte
5	* Copyright 1994 Alexandre Julliard
6	* Copyright 1997 Morten Welinder
7	*
8	* This library is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU Lesser General Public
10	* License as published by the Free Software Foundation; either
11	* version 2.1 of the License, or (at your option) any later version.
12	*
13	* This library is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* Lesser General Public License for more details.
17	*
18	* You should have received a copy of the GNU Lesser General Public
19	* License along with this library; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21	*/
22
23	/*
24	* Note: the style MF_MOUSESELECT is used to mark popup items that
25	* have been selected, i.e. their popup menu is currently displayed.
26	* This is probably not the meaning this style has in MS-Windows.
27	*/
28
29	#include "config.h"
30	#include "wine/port.h"
31
32	#include <assert.h>
33	#include <ctype.h>
34	#include <stdlib.h>
35	#include <string.h>
36
37	#include "windef.h"
38	#include "winnls.h"
39	#include "wingdi.h"
40	#include "wine/winbase16.h"
41	#include "wine/winuser16.h"
42	#include "wine/unicode.h"
43	#include "win.h"
44	#include "controls.h"
45	#include "nonclient.h"
46	#include "user.h"
47	#include "message.h"
48
49	#include "wine/debug.h"
50
51	WINE_DEFAULT_DEBUG_CHANNEL(menu);
52	WINE_DECLARE_DEBUG_CHANNEL(accel);
53
54	/* internal popup menu window messages */
55
56	#define MM_SETMENUHANDLE (WM_USER + 0)
57	#define MM_GETMENUHANDLE (WM_USER + 1)
58
59	/* Menu item structure */
60	typedef struct {
61	/* ----------- MENUITEMINFO Stuff ----------- */
62	UINT fType; /* Item type. */
63	UINT fState; /* Item state. */
64	UINT wID; /* Item id. */
65	HMENU hSubMenu; /* Pop-up menu. */
66	HBITMAP hCheckBit; /* Bitmap when checked. */
67	HBITMAP hUnCheckBit; /* Bitmap when unchecked. */
68	LPWSTR text; /* Item text or bitmap handle. */
69	DWORD dwItemData; /* Application defined. */
70	DWORD dwTypeData; /* depends on fMask */
71	HBITMAP hbmpItem; /* bitmap in win98 style menus */
72	/* ----------- Wine stuff ----------- */
73	RECT rect; /* Item area (relative to menu window) */
74	UINT xTab; /* X position of text after Tab */
75	} MENUITEM;
76
77	/* Popup menu structure */
78	typedef struct {
79	WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
80	WORD wMagic; /* Magic number */
81	WORD Width; /* Width of the whole menu */
82	WORD Height; /* Height of the whole menu */
83	UINT nItems; /* Number of items in the menu */
84	HWND hWnd; /* Window containing the menu */
85	MENUITEM items; / Array of menu items */
86	UINT FocusedItem; /* Currently focused item */
87	HWND hwndOwner; /* window receiving the messages for ownerdraw */
88	BOOL bTimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
89	/* ------------ MENUINFO members ------ */
90	DWORD dwStyle; /* Extended mennu style */
91	UINT cyMax; /* max hight of the whole menu, 0 is screen hight */
92	HBRUSH hbrBack; /* brush for menu background */
93	DWORD dwContextHelpID;
94	DWORD dwMenuData; /* application defined value */
95	HMENU hSysMenuOwner; /* Handle to the dummy sys menu holder */
96	} POPUPMENU, *LPPOPUPMENU;
97
98	/* internal flags for menu tracking */
99
100	#define TF_ENDMENU 0x0001
101	#define TF_SUSPENDPOPUP 0x0002
102	#define TF_SKIPREMOVE 0x0004
103
104	typedef struct
105	{
106	UINT trackFlags;
107	HMENU hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
108	HMENU hTopMenu; /* initial menu */
109	HWND hOwnerWnd; /* where notifications are sent */
110	POINT pt;
111	} MTRACKER;
112
113	#define MENU_MAGIC 0x554d /* 'MU' */
114
115	#define ITEM_PREV -1
116	#define ITEM_NEXT 1
117
118	/* Internal MENU_TrackMenu() flags */
119	#define TPM_INTERNAL 0xF0000000
120	#define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
121	#define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
122	#define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
123
124	/* popup menu shade thickness */
125	#define POPUP_XSHADE 4
126	#define POPUP_YSHADE 4
127
128	/* Space between 2 menu bar items */
129	#define MENU_BAR_ITEMS_SPACE 12
130
131	/* Minimum width of a tab character */
132	#define MENU_TAB_SPACE 8
133
134	/* Height of a separator item */
135	#define SEPARATOR_HEIGHT 5
136
137	/* (other menu->FocusedItem values give the position of the focused item) */
138	#define NO_SELECTED_ITEM 0xffff
139
140	#define MENU_ITEM_TYPE(flags) \
141	((flags) & (MF_STRING \| MF_BITMAP \| MF_OWNERDRAW \| MF_SEPARATOR))
142
143	#define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
144	#define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
145	#define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
146
147	#define IS_SYSTEM_MENU(menu) \
148	(!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
149
150	#define IS_SYSTEM_POPUP(menu) \
151	((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
152
153	#define TYPE_MASK (MFT_STRING \| MFT_BITMAP \| MFT_OWNERDRAW \| MFT_SEPARATOR \| \
154	MFT_MENUBARBREAK \| MFT_MENUBREAK \| MFT_RADIOCHECK \| \
155	MFT_RIGHTORDER \| MFT_RIGHTJUSTIFY \| \
156	MF_POPUP \| MF_SYSMENU \| MF_HELP)
157	#define STATE_MASK (~TYPE_MASK)
158
159	/* Dimension of the menu bitmaps */
160	static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
161
162	static HBITMAP hStdMnArrow = 0;
163	static HBITMAP hBmpSysMenu = 0;
164
165	static HBRUSH hShadeBrush = 0;
166	static HFONT hMenuFont = 0;
167	static HFONT hMenuFontBold = 0;
168
169	static HMENU MENU_DefSysPopup = 0; /* Default system menu popup */
170
171	/* Use global popup window because there's no way 2 menus can
172	* be tracked at the same time. */
173	static HWND top_popup;
174
175	/* Flag set by EndMenu() to force an exit from menu tracking */
176	static BOOL fEndMenu = FALSE;
177
178	static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
179
180
181	/*********************************************************************
182	* menu class descriptor
183	*/
184	const struct builtin_class_descr MENU_builtin_class =
185	{
186	POPUPMENU_CLASS_ATOM, /* name */
187	CS_GLOBALCLASS \| CS_SAVEBITS, /* style */
188	NULL, /* procA (winproc is Unicode only) */
189	PopupMenuWndProc, /* procW */
190	sizeof(HMENU), /* extra */
191	IDC_ARROWA, /* cursor */
192	COLOR_MENU+1 /* brush */
193	};
194
195
196	/***********************************************************************
197	* debug_print_menuitem
198	*
199	* Print a menuitem in readable form.
200	*/
201
202	#define debug_print_menuitem(pre, mp, post) \
203	if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
204
205	#define MENUOUT(text) \
206	DPRINTF("%s%s", (count++ ? "," : ""), (text))
207
208	#define MENUFLAG(bit,text) \
209	do { \
210	if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
211	} while (0)
212
213	static void do_debug_print_menuitem(const char prefix, MENUITEM mp,
214	const char *postfix)
215	{
216	TRACE("%s ", prefix);
217	if (mp) {
218	UINT flags = mp->fType;
219	int typ = MENU_ITEM_TYPE(flags);
220	DPRINTF( "{ ID=0x%x", mp->wID);
221	if (flags & MF_POPUP)
222	DPRINTF( ", Sub=0x%x", mp->hSubMenu);
223	if (flags) {
224	int count = 0;
225	DPRINTF( ", Typ=");
226	if (typ == MFT_STRING)
227	/* Nothing */ ;
228	else if (typ == MFT_SEPARATOR)
229	MENUOUT("sep");
230	else if (typ == MFT_OWNERDRAW)
231	MENUOUT("own");
232	else if (typ == MFT_BITMAP)
233	MENUOUT("bit");
234	else
235	MENUOUT("???");
236	flags -= typ;
237
238	MENUFLAG(MF_POPUP, "pop");
239	MENUFLAG(MFT_MENUBARBREAK, "barbrk");
240	MENUFLAG(MFT_MENUBREAK, "brk");
241	MENUFLAG(MFT_RADIOCHECK, "radio");
242	MENUFLAG(MFT_RIGHTORDER, "rorder");
243	MENUFLAG(MF_SYSMENU, "sys");
244	MENUFLAG(MFT_RIGHTJUSTIFY, "right"); /* same as MF_HELP */
245
246	if (flags)
247	DPRINTF( "+0x%x", flags);
248	}
249	flags = mp->fState;
250	if (flags) {
251	int count = 0;
252	DPRINTF( ", State=");
253	MENUFLAG(MFS_GRAYED, "grey");
254	MENUFLAG(MFS_DEFAULT, "default");
255	MENUFLAG(MFS_DISABLED, "dis");
256	MENUFLAG(MFS_CHECKED, "check");
257	MENUFLAG(MFS_HILITE, "hi");
258	MENUFLAG(MF_USECHECKBITMAPS, "usebit");
259	MENUFLAG(MF_MOUSESELECT, "mouse");
260	if (flags)
261	DPRINTF( "+0x%x", flags);
262	}
263	if (mp->hCheckBit)
264	DPRINTF( ", Chk=0x%x", mp->hCheckBit);
265	if (mp->hUnCheckBit)
266	DPRINTF( ", Unc=0x%x", mp->hUnCheckBit);
267
268	if (typ == MFT_STRING) {
269	if (mp->text)
270	DPRINTF( ", Text=%s", debugstr_w(mp->text));
271	else
272	DPRINTF( ", Text=Null");
273	} else if (mp->text == NULL)
274	/* Nothing */ ;
275	else
276	DPRINTF( ", Text=%p", mp->text);
277	if (mp->dwItemData)
278	DPRINTF( ", ItemData=0x%08lx", mp->dwItemData);
279	DPRINTF( " }");
280	} else {
281	DPRINTF( "NULL");
282	}
283
284	DPRINTF(" %s\n", postfix);
285	}
286
287	#undef MENUOUT
288	#undef MENUFLAG
289
290
291	/***********************************************************************
292	* MENU_GetMenu
293	*
294	* Validate the given menu handle and returns the menu structure pointer.
295	*/
296	static POPUPMENU *MENU_GetMenu(HMENU hMenu)
297	{
298	POPUPMENU *menu = USER_HEAP_LIN_ADDR(hMenu);
299	if (!menu \|\| menu->wMagic != MENU_MAGIC)
300	{
301	WARN("invalid menu handle=%x, ptr=%p, magic=%x\n", hMenu, menu, menu? menu->wMagic:0);
302	menu = NULL;
303	}
304	return menu;
305	}
306
307	/***********************************************************************
308	* get_win_sys_menu
309	*
310	* Get the system menu of a window
311	*/
312	static HMENU get_win_sys_menu( HWND hwnd )
313	{
314	HMENU ret = 0;
315	WND *win = WIN_FindWndPtr( hwnd );
316	if (win)
317	{
318	ret = win->hSysMenu;
319	WIN_ReleaseWndPtr( win );
320	}
321	return ret;
322	}
323
324	/***********************************************************************
325	* MENU_CopySysPopup
326	*
327	* Return the default system menu.
328	*/
329	static HMENU MENU_CopySysPopup(void)
330	{
331	HMENU hMenu = LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU");
332
333	if( hMenu ) {
334	POPUPMENU* menu = MENU_GetMenu(hMenu);
335	menu->wFlags \|= MF_SYSMENU \| MF_POPUP;
336	SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
337	}
338	else
339	ERR("Unable to load default system menu\n" );
340
341	TRACE("returning %x.\n", hMenu );
342
343	return hMenu;
344	}
345
346
347	/**********************************************************************
348	* MENU_GetSysMenu
349	*
350	* Create a copy of the system menu. System menu in Windows is
351	* a special menu bar with the single entry - system menu popup.
352	* This popup is presented to the outside world as a "system menu".
353	* However, the real system menu handle is sometimes seen in the
354	* WM_MENUSELECT parameters (and Word 6 likes it this way).
355	*/
356	HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
357	{
358	HMENU hMenu;
359
360	if ((hMenu = CreateMenu()))
361	{
362	POPUPMENU *menu = MENU_GetMenu(hMenu);
363	menu->wFlags = MF_SYSMENU;
364	menu->hWnd = WIN_GetFullHandle( hWnd );
365
366	if (hPopupMenu == (HMENU)(-1))
367	hPopupMenu = MENU_CopySysPopup();
368	else if( !hPopupMenu ) hPopupMenu = MENU_DefSysPopup;
369
370	if (hPopupMenu)
371	{
372	InsertMenuA( hMenu, -1, MF_SYSMENU \| MF_POPUP \| MF_BYPOSITION, hPopupMenu, NULL );
373
374	menu->items[0].fType = MF_SYSMENU \| MF_POPUP;
375	menu->items[0].fState = 0;
376	if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags \|= MF_SYSMENU;
377
378	TRACE("GetSysMenu hMenu=%04x (%04x)\n", hMenu, hPopupMenu );
379	return hMenu;
380	}
381	DestroyMenu( hMenu );
382	}
383	ERR("failed to load system menu!\n");
384	return 0;
385	}
386
387
388	/***********************************************************************
389	* MENU_Init
390	*
391	* Menus initialisation.
392	*/
393	BOOL MENU_Init()
394	{
395	HBITMAP hBitmap;
396	NONCLIENTMETRICSA ncm;
397
398	static unsigned char shade_bits[16] = { 0x55, 0, 0xAA, 0,
399	0x55, 0, 0xAA, 0,
400	0x55, 0, 0xAA, 0,
401	0x55, 0, 0xAA, 0 };
402
403	/* Load menu bitmaps */
404	hStdMnArrow = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_MNARROW));
405	/* Load system buttons bitmaps */
406	hBmpSysMenu = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_CLOSE));
407
408	if (hStdMnArrow)
409	{
410	BITMAP bm;
411	GetObjectA( hStdMnArrow, sizeof(bm), &bm );
412	arrow_bitmap_width = bm.bmWidth;
413	arrow_bitmap_height = bm.bmHeight;
414	} else
415	return FALSE;
416
417	if (! (hBitmap = CreateBitmap( 8, 8, 1, 1, shade_bits)))
418	return FALSE;
419
420	if(!(hShadeBrush = CreatePatternBrush( hBitmap )))
421	return FALSE;
422
423	DeleteObject( hBitmap );
424	if (!(MENU_DefSysPopup = MENU_CopySysPopup()))
425	return FALSE;
426
427	ncm.cbSize = sizeof (NONCLIENTMETRICSA);
428	if (!(SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &ncm, 0)))
429	return FALSE;
430
431	if (!(hMenuFont = CreateFontIndirectA( &ncm.lfMenuFont )))
432	return FALSE;
433
434	ncm.lfMenuFont.lfWeight += 300;
435	if ( ncm.lfMenuFont.lfWeight > 1000)
436	ncm.lfMenuFont.lfWeight = 1000;
437
438	if (!(hMenuFontBold = CreateFontIndirectA( &ncm.lfMenuFont )))
439	return FALSE;
440
441	return TRUE;
442	}
443
444	/***********************************************************************
445	* MENU_InitSysMenuPopup
446	*
447	* Grey the appropriate items in System menu.
448	*/
449	static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
450	{
451	BOOL gray;
452
453	gray = !(style & WS_THICKFRAME) \|\| (style & (WS_MAXIMIZE \| WS_MINIMIZE));
454	EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
455	gray = ((style & WS_MAXIMIZE) != 0);
456	EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
457	gray = !(style & WS_MINIMIZEBOX) \|\| (style & WS_MINIMIZE);
458	EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
459	gray = !(style & WS_MAXIMIZEBOX) \|\| (style & WS_MAXIMIZE);
460	EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
461	gray = !(style & (WS_MAXIMIZE \| WS_MINIMIZE));
462	EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
463	gray = (clsStyle & CS_NOCLOSE) != 0;
464
465	/* The menu item must keep its state if it's disabled */
466	if(gray)
467	EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
468	}
469
470
471	/******************************************************************************
472	*
473	* UINT MENU_GetStartOfNextColumn(
474	* HMENU hMenu )
475	*
476	*****************************************************************************/
477
478	static UINT MENU_GetStartOfNextColumn(
479	HMENU hMenu )
480	{
481	POPUPMENU *menu = MENU_GetMenu(hMenu);
482	UINT i;
483
484	if(!menu)
485	return NO_SELECTED_ITEM;
486
487	i = menu->FocusedItem + 1;
488	if( i == NO_SELECTED_ITEM )
489	return i;
490
491	for( ; i < menu->nItems; ++i ) {
492	if (menu->items[i].fType & MF_MENUBARBREAK)
493	return i;
494	}
495
496	return NO_SELECTED_ITEM;
497	}
498
499
500	/******************************************************************************
501	*
502	* UINT MENU_GetStartOfPrevColumn(
503	* HMENU hMenu )
504	*
505	*****************************************************************************/
506
507	static UINT MENU_GetStartOfPrevColumn(
508	HMENU hMenu )
509	{
510	POPUPMENU *menu = MENU_GetMenu(hMenu);
511	UINT i;
512
513	if( !menu )
514	return NO_SELECTED_ITEM;
515
516	if( menu->FocusedItem == 0 \|\| menu->FocusedItem == NO_SELECTED_ITEM )
517	return NO_SELECTED_ITEM;
518
519	/* Find the start of the column */
520
521	for(i = menu->FocusedItem; i != 0 &&
522	!(menu->items[i].fType & MF_MENUBARBREAK);
523	--i); /* empty */
524
525	if(i == 0)
526	return NO_SELECTED_ITEM;
527
528	for(--i; i != 0; --i) {
529	if (menu->items[i].fType & MF_MENUBARBREAK)
530	break;
531	}
532
533	TRACE("ret %d.\n", i );
534
535	return i;
536	}
537
538
539
540	/***********************************************************************
541	* MENU_FindItem
542	*
543	* Find a menu item. Return a pointer on the item, and modifies *hmenu
544	* in case the item was in a sub-menu.
545	*/
546	static MENUITEM MENU_FindItem( HMENU hmenu, UINT *nPos, UINT wFlags )
547	{
548	POPUPMENU *menu;
549	UINT i;
550
551	if (((hmenu)==0xffff) \|\| (!(menu = MENU_GetMenu(hmenu)))) return NULL;
552	if (wFlags & MF_BYPOSITION)
553	{
554	if (*nPos >= menu->nItems) return NULL;
555	return &menu->items[*nPos];
556	}
557	else
558	{
559	MENUITEM *item = menu->items;
560	for (i = 0; i < menu->nItems; i++, item++)
561	{
562	if (item->wID == *nPos)
563	{
564	*nPos = i;
565	return item;
566	}
567	else if (item->fType & MF_POPUP)
568	{
569	HMENU hsubmenu = item->hSubMenu;
570	MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
571	if (subitem)
572	{
573	*hmenu = hsubmenu;
574	return subitem;
575	}
576	}
577	}
578	}
579	return NULL;
580	}
581
582	/***********************************************************************
583	* MENU_FindSubMenu
584	*
585	* Find a Sub menu. Return the position of the submenu, and modifies
586	* *hmenu in case it is found in another sub-menu.
587	* If the submenu cannot be found, NO_SELECTED_ITEM is returned.
588	*/
589	UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
590	{
591	POPUPMENU *menu;
592	UINT i;
593	MENUITEM *item;
594	if (((*hmenu)==0xffff) \|\|
595	(!(menu = MENU_GetMenu(*hmenu))))
596	return NO_SELECTED_ITEM;
597	item = menu->items;
598	for (i = 0; i < menu->nItems; i++, item++) {
599	if(!(item->fType & MF_POPUP)) continue;
600	if (item->hSubMenu == hSubTarget) {
601	return i;
602	}
603	else {
604	HMENU hsubmenu = item->hSubMenu;
605	UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
606	if (pos != NO_SELECTED_ITEM) {
607	*hmenu = hsubmenu;
608	return pos;
609	}
610	}
611	}
612	return NO_SELECTED_ITEM;
613	}
614
615	/***********************************************************************
616	* MENU_FreeItemData
617	*/
618	static void MENU_FreeItemData( MENUITEM* item )
619	{
620	/* delete text */
621	if (IS_STRING_ITEM(item->fType) && item->text)
622	HeapFree( GetProcessHeap(), 0, item->text );
623	}
624
625	/***********************************************************************
626	* MENU_FindItemByCoords
627	*
628	* Find the item at the specified coordinates (screen coords). Does
629	* not work for child windows and therefore should not be called for
630	* an arbitrary system menu.
631	*/
632	static MENUITEM MENU_FindItemByCoords( POPUPMENU menu,
633	POINT pt, UINT *pos )
634	{
635	MENUITEM *item;
636	UINT i;
637	RECT wrect;
638
639	if (!GetWindowRect(menu->hWnd,&wrect)) return NULL;
640	pt.x -= wrect.left;pt.y -= wrect.top;
641	item = menu->items;
642	for (i = 0; i < menu->nItems; i++, item++)
643	{
644	if ((pt.x >= item->rect.left) && (pt.x < item->rect.right) &&
645	(pt.y >= item->rect.top) && (pt.y < item->rect.bottom))
646	{
647	if (pos) *pos = i;
648	return item;
649	}
650	}
651	return NULL;
652	}
653
654
655	/***********************************************************************
656	* MENU_FindItemByKey
657	*
658	* Find the menu item selected by a key press.
659	* Return item id, -1 if none, -2 if we should close the menu.
660	*/
661	static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu,
662	UINT key, BOOL forceMenuChar )
663	{
664	TRACE("\tlooking for '%c' in [%04x]\n", (char)key, (UINT16)hmenu );
665
666	if (!IsMenu( hmenu )) hmenu = GetSubMenu( get_win_sys_menu(hwndOwner), 0);
667
668	if (hmenu)
669	{
670	POPUPMENU *menu = MENU_GetMenu( hmenu );
671	MENUITEM *item = menu->items;
672	LONG menuchar;
673
674	if( !forceMenuChar )
675	{
676	UINT i;
677
678	key = toupper(key);
679	for (i = 0; i < menu->nItems; i++, item++)
680	{
681	if (item->text && (IS_STRING_ITEM(item->fType)))
682	{
683	WCHAR *p = item->text - 2;
684	do
685	{
686	p = strchrW (p + 2, '&');
687	}
688	while (p != NULL && p [1] == '&');
689	if (p && (toupper(p[1]) == key)) return i;
690	}
691	}
692	}
693	menuchar = SendMessageA( hwndOwner, WM_MENUCHAR,
694	MAKEWPARAM( key, menu->wFlags ), hmenu );
695	if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
696	if (HIWORD(menuchar) == 1) return (UINT)(-2);
697	}
698	return (UINT)(-1);
699	}
700
701
702	/***********************************************************************
703	* MENU_GetBitmapItemSize
704	*
705	* Get the size of a bitmap item.
706	*/
707	static void MENU_GetBitmapItemSize( UINT id, DWORD data, SIZE *size )
708	{
709	BITMAP bm;
710	HBITMAP bmp = (HBITMAP)id;
711
712	size->cx = size->cy = 0;
713
714	/* check if there is a magic menu item associated with this item */
715	if (id && IS_MAGIC_ITEM( id ))
716	{
717	switch(LOWORD(id))
718	{
719	case HBMMENU_SYSTEM:
720	if (data)
721	{
722	bmp = (HBITMAP)data;
723	break;
724	}
725	/* fall through */
726	case HBMMENU_MBAR_RESTORE:
727	case HBMMENU_MBAR_MINIMIZE:
728	case HBMMENU_MBAR_MINIMIZE_D:
729	case HBMMENU_MBAR_CLOSE:
730	case HBMMENU_MBAR_CLOSE_D:
731	size->cx = GetSystemMetrics( SM_CXSIZE );
732	size->cy = GetSystemMetrics( SM_CYSIZE );
733	return;
734	case HBMMENU_CALLBACK:
735	case HBMMENU_POPUP_CLOSE:
736	case HBMMENU_POPUP_RESTORE:
737	case HBMMENU_POPUP_MAXIMIZE:
738	case HBMMENU_POPUP_MINIMIZE:
739	default:
740	FIXME("Magic 0x%08x not implemented\n", id);
741	return;
742	}
743	}
744	if (GetObjectA(bmp, sizeof(bm), &bm ))
745	{
746	size->cx = bm.bmWidth;
747	size->cy = bm.bmHeight;
748	}
749	}
750
751	/***********************************************************************
752	* MENU_DrawBitmapItem
753	*
754	* Draw a bitmap item.
755	*/
756	static void MENU_DrawBitmapItem( HDC hdc, MENUITEM lpitem, const RECT rect, BOOL menuBar )
757	{
758	BITMAP bm;
759	DWORD rop;
760	HDC hdcMem;
761	HBITMAP bmp = (HBITMAP)lpitem->text;
762	int w = rect->right - rect->left;
763	int h = rect->bottom - rect->top;
764	int bmp_xoffset = 0;
765	int left, top;
766
767	/* Check if there is a magic menu item associated with this item */
768	if (lpitem->text && IS_MAGIC_ITEM(lpitem->text))
769	{
770	UINT flags = 0;
771	RECT r;
772
773	switch(LOWORD(lpitem->text))
774	{
775	case HBMMENU_SYSTEM:
776	if (lpitem->dwItemData)
777	{
778	bmp = (HBITMAP)lpitem->dwItemData;
779	if (!GetObjectA( bmp, sizeof(bm), &bm )) return;
780	}
781	else
782	{
783	bmp = hBmpSysMenu;
784	if (!GetObjectA( bmp, sizeof(bm), &bm )) return;
785	/* only use right half of the bitmap */
786	bmp_xoffset = bm.bmWidth / 2;
787	bm.bmWidth -= bmp_xoffset;
788	}
789	goto got_bitmap;
790	case HBMMENU_MBAR_RESTORE:
791	flags = DFCS_CAPTIONRESTORE;
792	break;
793	case HBMMENU_MBAR_MINIMIZE:
794	flags = DFCS_CAPTIONMIN;
795	break;
796	case HBMMENU_MBAR_MINIMIZE_D:
797	flags = DFCS_CAPTIONMIN \| DFCS_INACTIVE;
798	break;
799	case HBMMENU_MBAR_CLOSE:
800	flags = DFCS_CAPTIONCLOSE;
801	break;
802	case HBMMENU_MBAR_CLOSE_D:
803	flags = DFCS_CAPTIONCLOSE \| DFCS_INACTIVE;
804	break;
805	case HBMMENU_CALLBACK:
806	case HBMMENU_POPUP_CLOSE:
807	case HBMMENU_POPUP_RESTORE:
808	case HBMMENU_POPUP_MAXIMIZE:
809	case HBMMENU_POPUP_MINIMIZE:
810	default:
811	FIXME("Magic 0x%08x not implemented\n", LOWORD(lpitem->text));
812	return;
813	}
814	r = *rect;
815	InflateRect( &r, -1, -1 );
816	if (lpitem->fState & MF_HILITE) flags \|= DFCS_PUSHED;
817	DrawFrameControl( hdc, &r, DFC_CAPTION, flags );
818	return;
819	}
820
821	if (!bmp \|\| !GetObjectA( bmp, sizeof(bm), &bm )) return;
822
823	got_bitmap:
824	hdcMem = CreateCompatibleDC( hdc );
825	SelectObject( hdcMem, bmp );
826
827	/* handle fontsize > bitmap_height */
828	top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
829	left=rect->left;
830	if (TWEAK_WineLook == WIN95_LOOK) {
831	rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(lpitem->text)) ? NOTSRCCOPY : SRCCOPY;
832	if ((lpitem->fState & MF_HILITE) && IS_BITMAP_ITEM(lpitem->fType))
833	SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
834	} else {
835	left++;
836	w-=2;
837	rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(lpitem->text) && (!menuBar)) ? MERGEPAINT : SRCCOPY;
838	}
839	BitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop );
840	DeleteDC( hdcMem );
841	}
842
843
844	/***********************************************************************
845	* MENU_CalcItemSize
846	*
847	* Calculate the size of the menu item and store it in lpitem->rect.
848	*/
849	static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
850	INT orgX, INT orgY, BOOL menuBar )
851	{
852	WCHAR *p;
853	UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
854
855	TRACE("dc=0x%04x owner=0x%04x (%d,%d)\n", hdc, hwndOwner, orgX, orgY);
856	debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem,
857	(menuBar ? " (MenuBar)" : ""));
858
859	SetRect( &lpitem->rect, orgX, orgY, orgX, orgY );
860
861	if (lpitem->fType & MF_OWNERDRAW)
862	{
863	/*
864	** Experimentation under Windows reveals that an owner-drawn
865	** menu is expected to return the size of the content part of
866	** the menu item, not including the checkmark nor the submenu
867	** arrow. Windows adds those values itself and returns the
868	** enlarged rectangle on subsequent WM_DRAWITEM messages.
869	*/
870	MEASUREITEMSTRUCT mis;
871	mis.CtlType = ODT_MENU;
872	mis.CtlID = 0;
873	mis.itemID = lpitem->wID;
874	mis.itemData = (DWORD)lpitem->dwItemData;
875	mis.itemHeight = 0;
876	mis.itemWidth = 0;
877	SendMessageA( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&mis );
878	lpitem->rect.right += mis.itemWidth;
879
880	if (menuBar)
881	{
882	lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
883
884
885	/* under at least win95 you seem to be given a standard
886	height for the menu and the height value is ignored */
887
888	if (TWEAK_WineLook == WIN31_LOOK)
889	lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU);
890	else
891	lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU)-1;
892	}
893	else
894	lpitem->rect.bottom += mis.itemHeight;
895
896	TRACE("id=%04x size=%dx%d\n",
897	lpitem->wID, mis.itemWidth, mis.itemHeight);
898	/* Fall through to get check/arrow width calculation. */
899	}
900
901	if (lpitem->fType & MF_SEPARATOR)
902	{
903	lpitem->rect.bottom += SEPARATOR_HEIGHT;
904	return;
905	}
906
907	if (!menuBar)
908	{
909	lpitem->rect.right += 2 * check_bitmap_width;
910	if (lpitem->fType & MF_POPUP)
911	lpitem->rect.right += arrow_bitmap_width;
912	}
913
914	if (lpitem->fType & MF_OWNERDRAW)
915	return;
916
917	if (IS_BITMAP_ITEM(lpitem->fType))
918	{
919	SIZE size;
920
921	MENU_GetBitmapItemSize( (int)lpitem->text, lpitem->dwItemData, &size );
922	lpitem->rect.right += size.cx;
923	lpitem->rect.bottom += size.cy;
924	if (TWEAK_WineLook == WIN98_LOOK)
925	{
926	/* Leave space for the sunken border */
927	lpitem->rect.right += 2;
928	lpitem->rect.bottom += 2;
929	}
930	}
931
932
933	/* it must be a text item - unless it's the system menu */
934	if (!(lpitem->fType & MF_SYSMENU) && IS_STRING_ITEM( lpitem->fType ))
935	{ SIZE size;
936
937	GetTextExtentPoint32W(hdc, lpitem->text, strlenW(lpitem->text), &size);
938
939	lpitem->rect.right += size.cx;
940	if (TWEAK_WineLook == WIN31_LOOK)
941	lpitem->rect.bottom += max( size.cy, GetSystemMetrics(SM_CYMENU) );
942	else
943	lpitem->rect.bottom += max(size.cy, GetSystemMetrics(SM_CYMENU)-1);
944	lpitem->xTab = 0;
945
946	if (menuBar)
947	{
948	lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
949	}
950	else if ((p = strchrW( lpitem->text, '\t' )) != NULL)
951	{
952	/* Item contains a tab (only meaningful in popup menus) */
953	GetTextExtentPoint32W(hdc, lpitem->text, (int)(p - lpitem->text) , &size);
954	lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE + size.cx;
955	lpitem->rect.right += MENU_TAB_SPACE;
956	}
957	else
958	{
959	if (strchrW( lpitem->text, '\b' ))
960	lpitem->rect.right += MENU_TAB_SPACE;
961	lpitem->xTab = lpitem->rect.right - check_bitmap_width
962	- arrow_bitmap_width;
963	}
964	}
965	TRACE("(%d,%d)-(%d,%d)\n", lpitem->rect.left, lpitem->rect.top, lpitem->rect.right, lpitem->rect.bottom);
966	}
967
968
969	/***********************************************************************
970	* MENU_PopupMenuCalcSize
971	*
972	* Calculate the size of a popup menu.
973	*/
974	static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
975	{
976	MENUITEM *lpitem;
977	HDC hdc;
978	int start, i;
979	int orgX, orgY, maxX, maxTab, maxTabWidth;
980
981	lppop->Width = lppop->Height = 0;
982	if (lppop->nItems == 0) return;
983	hdc = GetDC( 0 );
984
985	SelectObject( hdc, hMenuFont);
986
987	start = 0;
988	maxX = (TWEAK_WineLook == WIN31_LOOK) ? GetSystemMetrics(SM_CXBORDER) : 2+1 ;
989
990	while (start < lppop->nItems)
991	{
992	lpitem = &lppop->items[start];
993	orgX = maxX;
994	orgY = (TWEAK_WineLook == WIN31_LOOK) ? GetSystemMetrics(SM_CYBORDER) : 2;
995
996	maxTab = maxTabWidth = 0;
997
998	/* Parse items until column break or end of menu */
999	for (i = start; i < lppop->nItems; i++, lpitem++)
1000	{
1001	if ((i != start) &&
1002	(lpitem->fType & (MF_MENUBREAK \| MF_MENUBARBREAK))) break;
1003
1004	MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE );
1005
1006	if (lpitem->fType & MF_MENUBARBREAK) orgX++;
1007	maxX = max( maxX, lpitem->rect.right );
1008	orgY = lpitem->rect.bottom;
1009	if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1010	{
1011	maxTab = max( maxTab, lpitem->xTab );
1012	maxTabWidth = max(maxTabWidth,lpitem->rect.right-lpitem->xTab);
1013	}
1014	}
1015
1016	/* Finish the column (set all items to the largest width found) */
1017	maxX = max( maxX, maxTab + maxTabWidth );
1018	for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
1019	{
1020	lpitem->rect.right = maxX;
1021	if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1022	lpitem->xTab = maxTab;
1023
1024	}
1025	lppop->Height = max( lppop->Height, orgY );
1026	}
1027
1028	lppop->Width = maxX;
1029
1030	/* space for 3d border */
1031	if(TWEAK_WineLook > WIN31_LOOK)
1032	{
1033	lppop->Height += 2;
1034	lppop->Width += 2;
1035	}
1036
1037	ReleaseDC( 0, hdc );
1038	}
1039
1040
1041	/***********************************************************************
1042	* MENU_MenuBarCalcSize
1043	*
1044	* FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1045	* height is off by 1 pixel which causes lengthy window relocations when
1046	* active document window is maximized/restored.
1047	*
1048	* Calculate the size of the menu bar.
1049	*/
1050	static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect,
1051	LPPOPUPMENU lppop, HWND hwndOwner )
1052	{
1053	MENUITEM *lpitem;
1054	int start, i, orgX, orgY, maxY, helpPos;
1055
1056	if ((lprect == NULL) \|\| (lppop == NULL)) return;
1057	if (lppop->nItems == 0) return;
1058	TRACE("left=%d top=%d right=%d bottom=%d\n",
1059	lprect->left, lprect->top, lprect->right, lprect->bottom);
1060	lppop->Width = lprect->right - lprect->left;
1061	lppop->Height = 0;
1062	maxY = lprect->top+1;
1063	start = 0;
1064	helpPos = -1;
1065	while (start < lppop->nItems)
1066	{
1067	lpitem = &lppop->items[start];
1068	orgX = lprect->left;
1069	orgY = maxY;
1070
1071	/* Parse items until line break or end of menu */
1072	for (i = start; i < lppop->nItems; i++, lpitem++)
1073	{
1074	if ((helpPos == -1) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1075	if ((i != start) &&
1076	(lpitem->fType & (MF_MENUBREAK \| MF_MENUBARBREAK))) break;
1077
1078	TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1079	orgX, orgY );
1080	debug_print_menuitem (" item: ", lpitem, "");
1081	MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE );
1082
1083	if (lpitem->rect.right > lprect->right)
1084	{
1085	if (i != start) break;
1086	else lpitem->rect.right = lprect->right;
1087	}
1088	maxY = max( maxY, lpitem->rect.bottom );
1089	orgX = lpitem->rect.right;
1090	}
1091
1092	/* Finish the line (set all items to the largest height found) */
1093	while (start < i) lppop->items[start++].rect.bottom = maxY;
1094	}
1095
1096	lprect->bottom = maxY;
1097	lppop->Height = lprect->bottom - lprect->top;
1098
1099	/* Flush right all items between the MF_RIGHTJUSTIFY and */
1100	/* the last item (if several lines, only move the last line) */
1101	lpitem = &lppop->items[lppop->nItems-1];
1102	orgY = lpitem->rect.top;
1103	orgX = lprect->right;
1104	for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
1105	if ( (helpPos==-1) \|\| (helpPos>i) )
1106	break; /* done */
1107	if (lpitem->rect.top != orgY) break; /* Other line */
1108	if (lpitem->rect.right >= orgX) break; /* Too far right already */
1109	lpitem->rect.left += orgX - lpitem->rect.right;
1110	lpitem->rect.right = orgX;
1111	orgX = lpitem->rect.left;
1112	}
1113	}
1114
1115	/***********************************************************************
1116	* MENU_DrawMenuItem
1117	*
1118	* Draw a single menu item.
1119	*/
1120	static void MENU_DrawMenuItem( HWND hwnd, HMENU hmenu, HWND hwndOwner, HDC hdc, MENUITEM *lpitem,
1121	UINT height, BOOL menuBar, UINT odaction )
1122	{
1123	RECT rect;
1124
1125	debug_print_menuitem("MENU_DrawMenuItem: ", lpitem, "");
1126
1127	if (lpitem->fType & MF_SYSMENU)
1128	{
1129	if( !IsIconic(hwnd) ) {
1130	if (TWEAK_WineLook > WIN31_LOOK)
1131	NC_DrawSysButton95( hwnd, hdc,
1132	lpitem->fState &
1133	(MF_HILITE \| MF_MOUSESELECT) );
1134	else
1135	NC_DrawSysButton( hwnd, hdc,
1136	lpitem->fState &
1137	(MF_HILITE \| MF_MOUSESELECT) );
1138	}
1139
1140	return;
1141	}
1142
1143	if (lpitem->fType & MF_OWNERDRAW)
1144	{
1145	/*
1146	** Experimentation under Windows reveals that an owner-drawn
1147	** menu is given the rectangle which includes the space it requested
1148	** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1149	** and a popup-menu arrow. This is the value of lpitem->rect.
1150	** Windows will leave all drawing to the application except for
1151	** the popup-menu arrow. Windows always draws that itself, after
1152	** the menu owner has finished drawing.
1153	*/
1154	DRAWITEMSTRUCT dis;
1155
1156	dis.CtlType = ODT_MENU;
1157	dis.CtlID = 0;
1158	dis.itemID = lpitem->wID;
1159	dis.itemData = (DWORD)lpitem->dwItemData;
1160	dis.itemState = 0;
1161	if (lpitem->fState & MF_CHECKED) dis.itemState \|= ODS_CHECKED;
1162	if (lpitem->fState & MF_GRAYED) dis.itemState \|= ODS_GRAYED;
1163	if (lpitem->fState & MF_HILITE) dis.itemState \|= ODS_SELECTED;
1164	dis.itemAction = odaction; /* ODA_DRAWENTIRE \| ODA_SELECT \| ODA_FOCUS; */
1165	dis.hwndItem = (HWND)hmenu;
1166	dis.hDC = hdc;
1167	dis.rcItem = lpitem->rect;
1168	TRACE("Ownerdraw: owner=%04x itemID=%d, itemState=%d, itemAction=%d, "
1169	"hwndItem=%04x, hdc=%04x, rcItem={%d,%d,%d,%d}\n", hwndOwner,
1170	dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
1171	dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
1172	dis.rcItem.bottom);
1173	SendMessageA( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&dis );
1174	/* Fall through to draw popup-menu arrow */
1175	}
1176
1177	TRACE("rect={%d,%d,%d,%d}\n", lpitem->rect.left, lpitem->rect.top,
1178	lpitem->rect.right,lpitem->rect.bottom);
1179
1180	if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
1181
1182	rect = lpitem->rect;
1183
1184	if (!(lpitem->fType & MF_OWNERDRAW))
1185	{
1186	if (lpitem->fState & MF_HILITE)
1187	{
1188	if(TWEAK_WineLook == WIN98_LOOK)
1189	{
1190	if(menuBar)
1191	DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
1192	else
1193	FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1194	}
1195	else /* Not Win98 Look */
1196	{
1197	if(!IS_BITMAP_ITEM(lpitem->fType))
1198	FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1199	}
1200	}
1201	else
1202	FillRect( hdc, &rect, GetSysColorBrush(COLOR_MENU) );
1203	}
1204
1205	SetBkMode( hdc, TRANSPARENT );
1206
1207	if (!(lpitem->fType & MF_OWNERDRAW))
1208	{
1209	/* vertical separator */
1210	if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
1211	{
1212	if (TWEAK_WineLook > WIN31_LOOK)
1213	{
1214	RECT rc = rect;
1215	rc.top = 3;
1216	rc.bottom = height - 3;
1217	DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
1218	}
1219	else
1220	{
1221	SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1222	MoveToEx( hdc, rect.left, 0, NULL );
1223	LineTo( hdc, rect.left, height );
1224	}
1225	}
1226
1227	/* horizontal separator */
1228	if (lpitem->fType & MF_SEPARATOR)
1229	{
1230	if (TWEAK_WineLook > WIN31_LOOK)
1231	{
1232	RECT rc = rect;
1233	rc.left++;
1234	rc.right--;
1235	rc.top += SEPARATOR_HEIGHT / 2;
1236	DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
1237	}
1238	else
1239	{
1240	SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1241	MoveToEx( hdc, rect.left, rect.top + SEPARATOR_HEIGHT/2, NULL );
1242	LineTo( hdc, rect.right, rect.top + SEPARATOR_HEIGHT/2 );
1243	}
1244	return;
1245	}
1246	}
1247
1248	/* Setup colors */
1249
1250	if (lpitem->fState & MF_HILITE)
1251	{
1252	if(TWEAK_WineLook == WIN98_LOOK)
1253	{
1254	if(menuBar) {
1255	SetTextColor(hdc, GetSysColor(COLOR_MENUTEXT));
1256	SetBkColor(hdc, GetSysColor(COLOR_MENU));
1257	} else {
1258	if(lpitem->fState & MF_GRAYED)
1259	SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1260	else
1261	SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1262	SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1263	}
1264	}
1265	else /* Not Win98 Look */
1266	{
1267	SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1268	if(!IS_BITMAP_ITEM(lpitem->fType))
1269	SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1270	}
1271	}
1272	else
1273	{
1274	if (lpitem->fState & MF_GRAYED)
1275	SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1276	else
1277	SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
1278	SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
1279	}
1280
1281	/* helper lines for debugging */
1282	/* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1283	SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1284	MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1285	LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1286	*/
1287
1288	if (!menuBar)
1289	{
1290	INT y = rect.top + rect.bottom;
1291	UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1292	UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1293
1294	if (!(lpitem->fType & MF_OWNERDRAW))
1295	{
1296	/* Draw the check mark
1297	*
1298	* FIXME:
1299	* Custom checkmark bitmaps are monochrome but not always 1bpp.
1300	*/
1301	HBITMAP bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit : lpitem->hUnCheckBit;
1302	if (bm) /* we have a custom bitmap */
1303	{
1304	HDC hdcMem = CreateCompatibleDC( hdc );
1305	SelectObject( hdcMem, bm );
1306	BitBlt( hdc, rect.left, (y - check_bitmap_height) / 2,
1307	check_bitmap_width, check_bitmap_height,
1308	hdcMem, 0, 0, SRCCOPY );
1309	DeleteDC( hdcMem );
1310	}
1311	else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
1312	{
1313	RECT r;
1314	HBITMAP bm = CreateBitmap( check_bitmap_width, check_bitmap_height, 1, 1, NULL );
1315	HDC hdcMem = CreateCompatibleDC( hdc );
1316	SelectObject( hdcMem, bm );
1317	SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height );
1318	DrawFrameControl( hdcMem, &r, DFC_MENU,
1319	(lpitem->fType & MFT_RADIOCHECK) ?
1320	DFCS_MENUBULLET : DFCS_MENUCHECK );
1321	BitBlt( hdc, rect.left, (y - r.bottom) / 2, r.right, r.bottom,
1322	hdcMem, 0, 0, SRCCOPY );
1323	DeleteDC( hdcMem );
1324	DeleteObject( bm );
1325	}
1326	}
1327
1328	/* Draw the popup-menu arrow */
1329	if (lpitem->fType & MF_POPUP)
1330	{
1331	HDC hdcMem = CreateCompatibleDC( hdc );
1332	HBITMAP hOrigBitmap;
1333
1334	hOrigBitmap = SelectObject( hdcMem, hStdMnArrow );
1335	BitBlt( hdc, rect.right - arrow_bitmap_width - 1,
1336	(y - arrow_bitmap_height) / 2,
1337	arrow_bitmap_width, arrow_bitmap_height,
1338	hdcMem, 0, 0, SRCCOPY );
1339	SelectObject( hdcMem, hOrigBitmap );
1340	DeleteDC( hdcMem );
1341	}
1342
1343	rect.left += check_bitmap_width;
1344	rect.right -= arrow_bitmap_width;
1345	}
1346
1347	/* Done for owner-drawn */
1348	if (lpitem->fType & MF_OWNERDRAW)
1349	return;
1350
1351	/* Draw the item text or bitmap */
1352	if (IS_BITMAP_ITEM(lpitem->fType))
1353	{
1354	MENU_DrawBitmapItem( hdc, lpitem, &rect, menuBar );
1355	return;
1356
1357	}
1358	/* No bitmap - process text if present */
1359	else if (IS_STRING_ITEM(lpitem->fType))
1360	{
1361	register int i;
1362	HFONT hfontOld = 0;
1363
1364	UINT uFormat = (menuBar) ?
1365	DT_CENTER \| DT_VCENTER \| DT_SINGLELINE :
1366	DT_LEFT \| DT_VCENTER \| DT_SINGLELINE;
1367
1368	if ( lpitem->fState & MFS_DEFAULT )
1369	{
1370	hfontOld = SelectObject( hdc, hMenuFontBold);
1371	}
1372
1373	if (menuBar)
1374	{
1375	rect.left += MENU_BAR_ITEMS_SPACE / 2;
1376	rect.right -= MENU_BAR_ITEMS_SPACE / 2;
1377	i = strlenW( lpitem->text );
1378	}
1379	else
1380	{
1381	for (i = 0; lpitem->text[i]; i++)
1382	if ((lpitem->text[i] == '\t') \|\| (lpitem->text[i] == '\b'))
1383	break;
1384	}
1385
1386	if( !(TWEAK_WineLook == WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1387	{
1388	if (!(lpitem->fState & MF_HILITE) )
1389	{
1390	++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1391	SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1392	DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1393	--rect.left; --rect.top; --rect.right; --rect.bottom;
1394	}
1395	SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1396	}
1397
1398	DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1399
1400	/* paint the shortcut text */
1401	if (lpitem->text[i]) /* There's a tab or flush-right char */
1402	{
1403	if (lpitem->text[i] == '\t')
1404	{
1405	rect.left = lpitem->xTab;
1406	uFormat = DT_LEFT \| DT_VCENTER \| DT_SINGLELINE;
1407	}
1408	else
1409	{
1410	uFormat = DT_RIGHT \| DT_VCENTER \| DT_SINGLELINE;
1411	}
1412
1413	if( !(TWEAK_WineLook == WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1414	{
1415	if (!(lpitem->fState & MF_HILITE) )
1416	{
1417	++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1418	SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1419	DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1420	--rect.left; --rect.top; --rect.right; --rect.bottom;
1421	}
1422	SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1423	}
1424	DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1425	}
1426
1427	if (hfontOld)
1428	SelectObject (hdc, hfontOld);
1429	}
1430	}
1431
1432
1433	/***********************************************************************
1434	* MENU_DrawPopupMenu
1435	*
1436	* Paint a popup menu.
1437	*/
1438	static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1439	{
1440	HBRUSH hPrevBrush = 0;
1441	RECT rect;
1442
1443	TRACE("wnd=0x%04x dc=0x%04x menu=0x%04x\n", hwnd, hdc, hmenu);
1444
1445	GetClientRect( hwnd, &rect );
1446
1447	if(TWEAK_WineLook == WIN31_LOOK)
1448	{
1449	rect.bottom -= POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1450	rect.right -= POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER);
1451	}
1452
1453	if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1454	&& (SelectObject( hdc, hMenuFont)))
1455	{
1456	HPEN hPrevPen;
1457
1458	Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1459
1460	hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1461	if( hPrevPen )
1462	{
1463	INT ropPrev, i;
1464	POPUPMENU *menu;
1465
1466	/* draw 3-d shade */
1467	if(TWEAK_WineLook == WIN31_LOOK) {
1468	SelectObject( hdc, hShadeBrush );
1469	SetBkMode( hdc, TRANSPARENT );
1470	ropPrev = SetROP2( hdc, R2_MASKPEN );
1471
1472	i = rect.right; /* why SetBrushOrg() doesn't? */
1473	PatBlt( hdc, i & 0xfffffffe,
1474	rect.top + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER),
1475	i%2 + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1476	rect.bottom - rect.top, 0x00a000c9 );
1477	i = rect.bottom;
1478	PatBlt( hdc, rect.left + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1479	i & 0xfffffffe,rect.right - rect.left,
1480	i%2 + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER), 0x00a000c9 );
1481	SelectObject( hdc, hPrevPen );
1482	SelectObject( hdc, hPrevBrush );
1483	SetROP2( hdc, ropPrev );
1484	}
1485	else
1486	DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1487
1488	/* draw menu items */
1489
1490	menu = MENU_GetMenu( hmenu );
1491	if (menu && menu->nItems)
1492	{
1493	MENUITEM *item;
1494	UINT u;
1495
1496	for (u = menu->nItems, item = menu->items; u > 0; u--, item++)
1497	MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc, item,
1498	menu->Height, FALSE, ODA_DRAWENTIRE );
1499
1500	}
1501	} else
1502	{
1503	SelectObject( hdc, hPrevBrush );
1504	}
1505	}
1506	}
1507
1508	/***********************************************************************
1509	* MENU_DrawMenuBar
1510	*
1511	* Paint a menu bar. Returns the height of the menu bar.
1512	* called from [windows/nonclient.c]
1513	*/
1514	UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1515	BOOL suppress_draw)
1516	{
1517	LPPOPUPMENU lppop;
1518	UINT i,retvalue;
1519	HFONT hfontOld = 0;
1520	HMENU hMenu = GetMenu(hwnd);
1521
1522	lppop = MENU_GetMenu( hMenu );
1523	if (lppop == NULL \|\| lprect == NULL)
1524	{
1525	retvalue = GetSystemMetrics(SM_CYMENU);
1526	goto END;
1527	}
1528
1529	TRACE("(%04x, %p, %p)\n", hDC, lprect, lppop);
1530
1531	hfontOld = SelectObject( hDC, hMenuFont);
1532
1533	if (lppop->Height == 0)
1534	MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1535
1536	lprect->bottom = lprect->top + lppop->Height;
1537
1538	if (suppress_draw)
1539	{
1540	retvalue = lppop->Height;
1541	goto END;
1542	}
1543
1544	FillRect(hDC, lprect, GetSysColorBrush(COLOR_MENU) );
1545
1546	if (TWEAK_WineLook == WIN31_LOOK)
1547	{
1548	SelectObject( hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1549	MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1550	LineTo( hDC, lprect->right, lprect->bottom );
1551	}
1552	else
1553	{
1554	SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
1555	MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1556	LineTo( hDC, lprect->right, lprect->bottom );
1557	}
1558
1559	if (lppop->nItems == 0)
1560	{
1561	retvalue = GetSystemMetrics(SM_CYMENU);
1562	goto END;
1563	}
1564
1565	for (i = 0; i < lppop->nItems; i++)
1566	{
1567	MENU_DrawMenuItem( hwnd, hMenu, hwnd,
1568	hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
1569	}
1570	retvalue = lppop->Height;
1571
1572	END:
1573	if (hfontOld) SelectObject (hDC, hfontOld);
1574	return retvalue;
1575	}
1576
1577
1578	/***********************************************************************
1579	* MENU_ShowPopup
1580	*
1581	* Display a popup menu.
1582	*/
1583	static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id,
1584	INT x, INT y, INT xanchor, INT yanchor )
1585	{
1586	POPUPMENU *menu;
1587	UINT width, height;
1588
1589	TRACE("owner=0x%04x hmenu=0x%04x id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1590	hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1591
1592	if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1593	if (menu->FocusedItem != NO_SELECTED_ITEM)
1594	{
1595	menu->items[menu->FocusedItem].fState &= ~(MF_HILITE\|MF_MOUSESELECT);
1596	menu->FocusedItem = NO_SELECTED_ITEM;
1597	}
1598
1599	/* store the owner for DrawItem */
1600	menu->hwndOwner = hwndOwner;
1601
1602
1603	MENU_PopupMenuCalcSize( menu, hwndOwner );
1604
1605	/* adjust popup menu pos so that it fits within the desktop */
1606
1607	width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1608	height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1609
1610	if( x + width > GetSystemMetrics(SM_CXSCREEN ))
1611	{
1612	if( xanchor )
1613	x -= width - xanchor;
1614	if( x + width > GetSystemMetrics(SM_CXSCREEN))
1615	x = GetSystemMetrics(SM_CXSCREEN) - width;
1616	}
1617	if( x < 0 ) x = 0;
1618
1619	if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1620	{
1621	if( yanchor )
1622	y -= height + yanchor;
1623	if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1624	y = GetSystemMetrics(SM_CYSCREEN) - height;
1625	}
1626	if( y < 0 ) y = 0;
1627
1628	if( TWEAK_WineLook == WIN31_LOOK )
1629	{
1630	width += POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER); /* add space for shading */
1631	height += POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1632	}
1633
1634	/* NOTE: In Windows, top menu popup is not owned. */
1635	menu->hWnd = CreateWindowA( POPUPMENU_CLASS_ATOM, NULL,
1636	WS_POPUP, x, y, width, height,
1637	hwndOwner, 0, GetWindowLongA(hwndOwner,GWL_HINSTANCE),
1638	(LPVOID)hmenu );
1639	if( !menu->hWnd ) return FALSE;
1640	if (!top_popup) top_popup = menu->hWnd;
1641
1642	/* Display the window */
1643
1644	SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1645	SWP_SHOWWINDOW \| SWP_NOSIZE \| SWP_NOMOVE \| SWP_NOACTIVATE );
1646	UpdateWindow( menu->hWnd );
1647	return TRUE;
1648	}
1649
1650
1651	/***********************************************************************
1652	* MENU_SelectItem
1653	*/
1654	static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1655	BOOL sendMenuSelect, HMENU topmenu )
1656	{
1657	LPPOPUPMENU lppop;
1658	HDC hdc;
1659
1660	TRACE("owner=0x%04x menu=0x%04x index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1661
1662	lppop = MENU_GetMenu( hmenu );
1663	if ((!lppop) \|\| (!lppop->nItems) \|\| (!lppop->hWnd)) return;
1664
1665	if (lppop->FocusedItem == wIndex) return;
1666	if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1667	else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE \| DCX_WINDOW);
1668	if (!top_popup) top_popup = lppop->hWnd;
1669
1670	SelectObject( hdc, hMenuFont);
1671
1672	/* Clear previous highlighted item */
1673	if (lppop->FocusedItem != NO_SELECTED_ITEM)
1674	{
1675	lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE\|MF_MOUSESELECT);
1676	MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1677	lppop->Height, !(lppop->wFlags & MF_POPUP),
1678	ODA_SELECT );
1679	}
1680
1681	/* Highlight new item (if any) */
1682	lppop->FocusedItem = wIndex;
1683	if (lppop->FocusedItem != NO_SELECTED_ITEM)
1684	{
1685	if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1686	lppop->items[wIndex].fState \|= MF_HILITE;
1687	MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1688	&lppop->items[wIndex], lppop->Height,
1689	!(lppop->wFlags & MF_POPUP), ODA_SELECT );
1690	}
1691	if (sendMenuSelect)
1692	{
1693	MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1694	SendMessageA( hwndOwner, WM_MENUSELECT,
1695	MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1696	ip->fType \| ip->fState \| MF_MOUSESELECT \|
1697	(lppop->wFlags & MF_SYSMENU)), hmenu);
1698	}
1699	}
1700	else if (sendMenuSelect) {
1701	if(topmenu){
1702	int pos;
1703	if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1704	POPUPMENU *ptm = MENU_GetMenu( topmenu );
1705	MENUITEM *ip = &ptm->items[pos];
1706	SendMessageA( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1707	ip->fType \| ip->fState \| MF_MOUSESELECT \|
1708	(ptm->wFlags & MF_SYSMENU)), topmenu);
1709	}
1710	}
1711	}
1712	ReleaseDC( lppop->hWnd, hdc );
1713	}
1714
1715
1716	/***********************************************************************
1717	* MENU_MoveSelection
1718	*
1719	* Moves currently selected item according to the offset parameter.
1720	* If there is no selection then it should select the last item if
1721	* offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1722	*/
1723	static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1724	{
1725	INT i;
1726	POPUPMENU *menu;
1727
1728	TRACE("hwnd=0x%04x hmenu=0x%04x off=0x%04x\n", hwndOwner, hmenu, offset);
1729
1730	menu = MENU_GetMenu( hmenu );
1731	if ((!menu) \|\| (!menu->items)) return;
1732
1733	if ( menu->FocusedItem != NO_SELECTED_ITEM )
1734	{
1735	if( menu->nItems == 1 ) return; else
1736	for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1737	; i += offset)
1738	if (!(menu->items[i].fType & MF_SEPARATOR))
1739	{
1740	MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1741	return;
1742	}
1743	}
1744
1745	for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1746	i >= 0 && i < menu->nItems ; i += offset)
1747	if (!(menu->items[i].fType & MF_SEPARATOR))
1748	{
1749	MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1750	return;
1751	}
1752	}
1753
1754
1755	/**********************************************************************
1756	* MENU_SetItemData
1757	*
1758	* Set an item flags, id and text ptr. Called by InsertMenu() and
1759	* ModifyMenu().
1760	*/
1761	static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT id,
1762	LPCWSTR str )
1763	{
1764	LPWSTR prevText = IS_STRING_ITEM(item->fType) ? item->text : NULL;
1765
1766	debug_print_menuitem("MENU_SetItemData from: ", item, "");
1767	TRACE("flags=%x str=%p\n", flags, str);
1768
1769	if (IS_STRING_ITEM(flags))
1770	{
1771	if (!str)
1772	{
1773	flags \|= MF_SEPARATOR;
1774	item->text = NULL;
1775	}
1776	else
1777	{
1778	LPWSTR text;
1779	/* Item beginning with a backspace is a help item */
1780	if (*str == '\b')
1781	{
1782	flags \|= MF_HELP;
1783	str++;
1784	}
1785	if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
1786	return FALSE;
1787	strcpyW( text, str );
1788	item->text = text;
1789	}
1790	}
1791	else if (IS_BITMAP_ITEM(flags))
1792	item->text = (LPWSTR)(HBITMAP)LOWORD(str);
1793	else item->text = NULL;
1794
1795	if (flags & MF_OWNERDRAW)
1796	item->dwItemData = (DWORD)str;
1797	else
1798	item->dwItemData = 0;
1799
1800	if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != id) )
1801	DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
1802
1803	if (flags & MF_POPUP)
1804	{
1805	POPUPMENU *menu = MENU_GetMenu((UINT16)id);
1806	if (menu) menu->wFlags \|= MF_POPUP;
1807	else
1808	{
1809	item->wID = 0;
1810	item->hSubMenu = 0;
1811	item->fType = 0;
1812	item->fState = 0;
1813	return FALSE;
1814	}
1815	}
1816
1817	item->wID = id;
1818	if (flags & MF_POPUP)
1819	item->hSubMenu = id;
1820
1821	if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
1822	flags \|= MF_POPUP; /* keep popup */
1823
1824	item->fType = flags & TYPE_MASK;
1825	item->fState = (flags & STATE_MASK) &
1826	~(MF_HILITE \| MF_MOUSESELECT \| MF_BYPOSITION);
1827
1828
1829	/* Don't call SetRectEmpty here! */
1830
1831
1832	if (prevText) HeapFree( GetProcessHeap(), 0, prevText );
1833
1834	debug_print_menuitem("MENU_SetItemData to : ", item, "");
1835	return TRUE;
1836	}
1837
1838
1839	/**********************************************************************
1840	* MENU_InsertItem
1841	*
1842	* Insert a new item into a menu.
1843	*/
1844	static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1845	{
1846	MENUITEM *newItems;
1847	POPUPMENU *menu;
1848
1849	if (!(menu = MENU_GetMenu(hMenu)))
1850	return NULL;
1851
1852	/* Find where to insert new item */
1853
1854	if (flags & MF_BYPOSITION) {
1855	if (pos > menu->nItems)
1856	pos = menu->nItems;
1857	} else {
1858	if (!MENU_FindItem( &hMenu, &pos, flags ))
1859	pos = menu->nItems;
1860	else {
1861	if (!(menu = MENU_GetMenu( hMenu )))
1862	return NULL;
1863	}
1864	}
1865
1866	/* Create new items array */
1867
1868	newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
1869	if (!newItems)
1870	{
1871	WARN("allocation failed\n" );
1872	return NULL;
1873	}
1874	if (menu->nItems > 0)
1875	{
1876	/* Copy the old array into the new one */
1877	if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1878	if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1879	(menu->nItems-pos)*sizeof(MENUITEM) );
1880	HeapFree( GetProcessHeap(), 0, menu->items );
1881	}
1882	menu->items = newItems;
1883	menu->nItems++;
1884	memset( &newItems[pos], 0, sizeof(*newItems) );
1885	menu->Height = 0; /* force size recalculate */
1886	return &newItems[pos];
1887	}
1888
1889
1890	/**********************************************************************
1891	* MENU_ParseResource
1892	*
1893	* Parse a standard menu resource and add items to the menu.
1894	* Return a pointer to the end of the resource.
1895	*/
1896	static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1897	{
1898	WORD flags, id = 0;
1899	LPCSTR str;
1900
1901	do
1902	{
1903	flags = GET_WORD(res);
1904	res += sizeof(WORD);
1905	if (!(flags & MF_POPUP))
1906	{
1907	id = GET_WORD(res);
1908	res += sizeof(WORD);
1909	}
1910	if (!IS_STRING_ITEM(flags))
1911	ERR("not a string item %04x\n", flags );
1912	str = res;
1913	if (!unicode) res += strlen(str) + 1;
1914	else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1915	if (flags & MF_POPUP)
1916	{
1917	HMENU hSubMenu = CreatePopupMenu();
1918	if (!hSubMenu) return NULL;
1919	if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1920	return NULL;
1921	if (!unicode) AppendMenuA( hMenu, flags, (UINT)hSubMenu, str );
1922	else AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1923	}
1924	else /* Not a popup */
1925	{
1926	if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1927	else AppendMenuW( hMenu, flags, id,
1928	*(LPCWSTR)str ? (LPCWSTR)str : NULL );
1929	}
1930	} while (!(flags & MF_END));
1931	return res;
1932	}
1933
1934
1935	/**********************************************************************
1936	* MENUEX_ParseResource
1937	*
1938	* Parse an extended menu resource and add items to the menu.
1939	* Return a pointer to the end of the resource.
1940	*/
1941	static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
1942	{
1943	WORD resinfo;
1944	do {
1945	MENUITEMINFOW mii;
1946
1947	mii.cbSize = sizeof(mii);
1948	mii.fMask = MIIM_STATE \| MIIM_ID \| MIIM_TYPE;
1949	mii.fType = GET_DWORD(res);
1950	res += sizeof(DWORD);
1951	mii.fState = GET_DWORD(res);
1952	res += sizeof(DWORD);
1953	mii.wID = GET_DWORD(res);
1954	res += sizeof(DWORD);
1955	resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
1956	res += sizeof(WORD);
1957	/* Align the text on a word boundary. */
1958	res += (~((int)res - 1)) & 1;
1959	mii.dwTypeData = (LPWSTR) res;
1960	res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
1961	/* Align the following fields on a dword boundary. */
1962	res += (~((int)res - 1)) & 3;
1963
1964	TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1965	mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
1966
1967	if (resinfo & 1) { /* Pop-up? */
1968	/* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1969	res += sizeof(DWORD);
1970	mii.hSubMenu = CreatePopupMenu();
1971	if (!mii.hSubMenu)
1972	return NULL;
1973	if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
1974	DestroyMenu(mii.hSubMenu);
1975	return NULL;
1976	}
1977	mii.fMask \|= MIIM_SUBMENU;
1978	mii.fType \|= MF_POPUP;
1979	}
1980	else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
1981	{
1982	WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1983	mii.wID, mii.fType);
1984	mii.fType \|= MF_SEPARATOR;
1985	}
1986	InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
1987	} while (!(resinfo & MF_END));
1988	return res;
1989	}
1990
1991
1992	/***********************************************************************
1993	* MENU_GetSubPopup
1994	*
1995	* Return the handle of the selected sub-popup menu (if any).
1996	*/
1997	static HMENU MENU_GetSubPopup( HMENU hmenu )
1998	{
1999	POPUPMENU *menu;
2000	MENUITEM *item;
2001
2002	menu = MENU_GetMenu( hmenu );
2003
2004	if ((!menu) \|\| (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2005
2006	item = &menu->items[menu->FocusedItem];
2007	if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2008	return item->hSubMenu;
2009	return 0;
2010	}
2011
2012
2013	/***********************************************************************
2014	* MENU_HideSubPopups
2015	*
2016	* Hide the sub-popup menus of this menu.
2017	*/
2018	static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2019	BOOL sendMenuSelect )
2020	{
2021	POPUPMENU *menu = MENU_GetMenu( hmenu );
2022
2023	TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2024
2025	if (menu && top_popup)
2026	{
2027	HMENU hsubmenu;
2028	POPUPMENU *submenu;
2029	MENUITEM *item;
2030
2031	if (menu->FocusedItem != NO_SELECTED_ITEM)
2032	{
2033	item = &menu->items[menu->FocusedItem];
2034	if (!(item->fType & MF_POPUP) \|\|
2035	!(item->fState & MF_MOUSESELECT)) return;
2036	item->fState &= ~MF_MOUSESELECT;
2037	hsubmenu = item->hSubMenu;
2038	} else return;
2039
2040	submenu = MENU_GetMenu( hsubmenu );
2041	MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
2042	MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2043	DestroyWindow( submenu->hWnd );
2044	submenu->hWnd = 0;
2045	}
2046	}
2047
2048
2049	/***********************************************************************
2050	* MENU_ShowSubPopup
2051	*
2052	* Display the sub-menu of the selected item of this menu.
2053	* Return the handle of the submenu, or hmenu if no submenu to display.
2054	*/
2055	static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2056	BOOL selectFirst, UINT wFlags )
2057	{
2058	RECT rect;
2059	POPUPMENU *menu;
2060	MENUITEM *item;
2061	HDC hdc;
2062
2063	TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, selectFirst);
2064
2065	if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2066
2067	if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2068
2069	item = &menu->items[menu->FocusedItem];
2070	if (!(item->fType & MF_POPUP) \|\| (item->fState & (MF_GRAYED \| MF_DISABLED)))
2071	return hmenu;
2072
2073	/* message must be sent before using item,
2074	because nearly everything may be changed by the application ! */
2075
2076	/* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2077	if (!(wFlags & TPM_NONOTIFY))
2078	SendMessageA( hwndOwner, WM_INITMENUPOPUP, item->hSubMenu,
2079	MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2080
2081	item = &menu->items[menu->FocusedItem];
2082	rect = item->rect;
2083
2084	/* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2085	if (!(item->fState & MF_HILITE))
2086	{
2087	if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2088	else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE \| DCX_WINDOW);
2089
2090	SelectObject( hdc, hMenuFont);
2091
2092	item->fState \|= MF_HILITE;
2093	MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2094	ReleaseDC( menu->hWnd, hdc );
2095	}
2096	if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2097	item->rect = rect;
2098
2099	item->fState \|= MF_MOUSESELECT;
2100
2101	if (IS_SYSTEM_MENU(menu))
2102	{
2103	MENU_InitSysMenuPopup(item->hSubMenu,
2104	GetWindowLongA( menu->hWnd, GWL_STYLE ),
2105	GetClassLongA( menu->hWnd, GCL_STYLE));
2106
2107	NC_GetSysPopupPos( menu->hWnd, &rect );
2108	rect.top = rect.bottom;
2109	rect.right = GetSystemMetrics(SM_CXSIZE);
2110	rect.bottom = GetSystemMetrics(SM_CYSIZE);
2111	}
2112	else
2113	{
2114	GetWindowRect( menu->hWnd, &rect );
2115	if (menu->wFlags & MF_POPUP)
2116	{
2117	rect.left += item->rect.right - GetSystemMetrics(SM_CXBORDER);
2118	rect.top += item->rect.top;
2119	rect.right = item->rect.left - item->rect.right + GetSystemMetrics(SM_CXBORDER);
2120	rect.bottom = item->rect.top - item->rect.bottom;
2121	}
2122	else
2123	{
2124	rect.left += item->rect.left;
2125	rect.top += item->rect.bottom;
2126	rect.right = item->rect.right - item->rect.left;
2127	rect.bottom = item->rect.bottom - item->rect.top;
2128	}
2129	}
2130
2131	MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2132	rect.left, rect.top, rect.right, rect.bottom );
2133	if (selectFirst)
2134	MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2135	return item->hSubMenu;
2136	}
2137
2138
2139
2140	/**********************************************************************
2141	* MENU_IsMenuActive
2142	*/
2143	BOOL MENU_IsMenuActive(void)
2144	{
2145	return (top_popup != 0);
2146	}
2147
2148	/***********************************************************************
2149	* MENU_PtMenu
2150	*
2151	* Walks menu chain trying to find a menu pt maps to.
2152	*/
2153	static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2154	{
2155	POPUPMENU *menu = MENU_GetMenu( hMenu );
2156	UINT item = menu->FocusedItem;
2157	HMENU ret;
2158
2159	/* try subpopup first (if any) */
2160	ret = (item != NO_SELECTED_ITEM &&
2161	(menu->items[item].fType & MF_POPUP) &&
2162	(menu->items[item].fState & MF_MOUSESELECT))
2163	? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2164
2165	if (!ret) /* check the current window (avoiding WM_HITTEST) */
2166	{
2167	INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2168	if( menu->wFlags & MF_POPUP )
2169	{
2170	if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2171	}
2172	else if (ht == HTSYSMENU)
2173	ret = get_win_sys_menu( menu->hWnd );
2174	else if (ht == HTMENU)
2175	ret = GetMenu( menu->hWnd );
2176	}
2177	return ret;
2178	}
2179
2180	/***********************************************************************
2181	* MENU_ExecFocusedItem
2182	*
2183	* Execute a menu item (for instance when user pressed Enter).
2184	* Return the wID of the executed item. Otherwise, -1 indicating
2185	* that no menu item was executed;
2186	* Have to receive the flags for the TrackPopupMenu options to avoid
2187	* sending unwanted message.
2188	*
2189	*/
2190	static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2191	{
2192	MENUITEM *item;
2193	POPUPMENU *menu = MENU_GetMenu( hMenu );
2194
2195	TRACE("%p hmenu=0x%04x\n", pmt, hMenu);
2196
2197	if (!menu \|\| !menu->nItems \|\|
2198	(menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2199
2200	item = &menu->items[menu->FocusedItem];
2201
2202	TRACE("%08x %08x %08x\n",
2203	hMenu, item->wID, item->hSubMenu);
2204
2205	if (!(item->fType & MF_POPUP))
2206	{
2207	if (!(item->fState & (MF_GRAYED \| MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2208	{
2209	/* If TPM_RETURNCMD is set you return the id, but
2210	do not send a message to the owner */
2211	if(!(wFlags & TPM_RETURNCMD))
2212	{
2213	if( menu->wFlags & MF_SYSMENU )
2214	PostMessageA( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2215	MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2216	else
2217	PostMessageA( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2218	}
2219	return item->wID;
2220	}
2221	}
2222	else
2223	pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2224
2225	return -1;
2226	}
2227
2228	/***********************************************************************
2229	* MENU_SwitchTracking
2230	*
2231	* Helper function for menu navigation routines.
2232	*/
2233	static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2234	{
2235	POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2236	POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2237
2238	TRACE("%p hmenu=0x%04x 0x%04x\n", pmt, hPtMenu, id);
2239
2240	if( pmt->hTopMenu != hPtMenu &&
2241	!((ptmenu->wFlags \| topmenu->wFlags) & MF_POPUP) )
2242	{
2243	/* both are top level menus (system and menu-bar) */
2244	MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2245	MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2246	pmt->hTopMenu = hPtMenu;
2247	}
2248	else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2249	MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2250	}
2251
2252
2253	/***********************************************************************
2254	* MENU_ButtonDown
2255	*
2256	* Return TRUE if we can go on with menu tracking.
2257	*/
2258	static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2259	{
2260	TRACE("%p hmenu=0x%04x\n", pmt, hPtMenu);
2261
2262	if (hPtMenu)
2263	{
2264	UINT id = 0;
2265	POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2266	MENUITEM *item;
2267
2268	if( IS_SYSTEM_MENU(ptmenu) )
2269	item = ptmenu->items;
2270	else
2271	item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2272
2273	if( item )
2274	{
2275	if( ptmenu->FocusedItem != id )
2276	MENU_SwitchTracking( pmt, hPtMenu, id );
2277
2278	/* If the popup menu is not already "popped" */
2279	if(!(item->fState & MF_MOUSESELECT ))
2280	{
2281	pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2282
2283	/* In win31, a newly popped menu always remains opened for the next buttonup */
2284	if(TWEAK_WineLook == WIN31_LOOK)
2285	ptmenu->bTimeToHide = FALSE;
2286	}
2287
2288	return TRUE;
2289	}
2290	/* Else the click was on the menu bar, finish the tracking */
2291	}
2292	return FALSE;
2293	}
2294
2295	/***********************************************************************
2296	* MENU_ButtonUp
2297	*
2298	* Return the value of MENU_ExecFocusedItem if
2299	* the selected item was not a popup. Else open the popup.
2300	* A -1 return value indicates that we go on with menu tracking.
2301	*
2302	*/
2303	static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2304	{
2305	TRACE("%p hmenu=0x%04x\n", pmt, hPtMenu);
2306
2307	if (hPtMenu)
2308	{
2309	UINT id = 0;
2310	POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2311	MENUITEM *item;
2312
2313	if( IS_SYSTEM_MENU(ptmenu) )
2314	item = ptmenu->items;
2315	else
2316	item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2317
2318	if( item && (ptmenu->FocusedItem == id ))
2319	{
2320	if( !(item->fType & MF_POPUP) )
2321	return MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2322
2323	/* If we are dealing with the top-level menu */
2324	/* and this is a click on an already "popped" item: */
2325	/* Stop the menu tracking and close the opened submenus */
2326	if((pmt->hTopMenu == hPtMenu) && (ptmenu->bTimeToHide == TRUE))
2327	return 0;
2328	}
2329	ptmenu->bTimeToHide = TRUE;
2330	}
2331	return -1;
2332	}
2333
2334
2335	/***********************************************************************
2336	* MENU_MouseMove
2337	*
2338	* Return TRUE if we can go on with menu tracking.
2339	*/
2340	static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2341	{
2342	UINT id = NO_SELECTED_ITEM;
2343	POPUPMENU *ptmenu = NULL;
2344
2345	if( hPtMenu )
2346	{
2347	ptmenu = MENU_GetMenu( hPtMenu );
2348	if( IS_SYSTEM_MENU(ptmenu) )
2349	id = 0;
2350	else
2351	MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2352	}
2353
2354	if( id == NO_SELECTED_ITEM )
2355	{
2356	MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2357	NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2358
2359	}
2360	else if( ptmenu->FocusedItem != id )
2361	{
2362	MENU_SwitchTracking( pmt, hPtMenu, id );
2363	pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2364	}
2365	return TRUE;
2366	}
2367
2368
2369	/***********************************************************************
2370	* MENU_DoNextMenu
2371	*
2372	* NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2373	*/
2374	static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2375	{
2376	POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2377
2378	if( (vk == VK_LEFT && menu->FocusedItem == 0 ) \|\|
2379	(vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2380	{
2381	MDINEXTMENU next_menu;
2382	HMENU hNewMenu;
2383	HWND hNewWnd;
2384	UINT id = 0;
2385
2386	next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2387	next_menu.hmenuNext = 0;
2388	next_menu.hwndNext = 0;
2389	SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2390
2391	TRACE("%04x [%04x] -> %04x [%04x]\n",
2392	pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2393
2394	if (!next_menu.hmenuNext \|\| !next_menu.hwndNext)
2395	{
2396	DWORD style = GetWindowLongA( pmt->hOwnerWnd, GWL_STYLE );
2397	hNewWnd = pmt->hOwnerWnd;
2398	if( IS_SYSTEM_MENU(menu) )
2399	{
2400	/* switch to the menu bar */
2401
2402	if(style & WS_CHILD \|\| !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2403
2404	if( vk == VK_LEFT )
2405	{
2406	menu = MENU_GetMenu( hNewMenu );
2407	id = menu->nItems - 1;
2408	}
2409	}
2410	else if (style & WS_SYSMENU )
2411	{
2412	/* switch to the system menu */
2413	hNewMenu = get_win_sys_menu( hNewWnd );
2414	}
2415	else return FALSE;
2416	}
2417	else /* application returned a new menu to switch to */
2418	{
2419	hNewMenu = next_menu.hmenuNext;
2420	hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2421
2422	if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2423	{
2424	DWORD style = GetWindowLongA( hNewWnd, GWL_STYLE );
2425
2426	if (style & WS_SYSMENU &&
2427	GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2428	{
2429	/* get the real system menu */
2430	hNewMenu = get_win_sys_menu(hNewWnd);
2431	}
2432	else if (style & WS_CHILD \|\| GetMenu(hNewWnd) != hNewMenu )
2433	{
2434	/* FIXME: Not sure what to do here;
2435	* perhaps try to track hNewMenu as a popup? */
2436
2437	TRACE(" -- got confused.\n");
2438	return FALSE;
2439	}
2440	}
2441	else return FALSE;
2442	}
2443
2444	if( hNewMenu != pmt->hTopMenu )
2445	{
2446	MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2447	FALSE, 0 );
2448	if( pmt->hCurrentMenu != pmt->hTopMenu )
2449	MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2450	}
2451
2452	if( hNewWnd != pmt->hOwnerWnd )
2453	{
2454	ReleaseCapture();
2455	pmt->hOwnerWnd = hNewWnd;
2456	EVENT_Capture( pmt->hOwnerWnd, HTMENU );
2457	}
2458
2459	pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2460	MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2461
2462	return TRUE;
2463	}
2464	return FALSE;
2465	}
2466
2467	/***********************************************************************
2468	* MENU_SuspendPopup
2469	*
2470	* The idea is not to show the popup if the next input message is
2471	* going to hide it anyway.
2472	*/
2473	static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2474	{
2475	MSG msg;
2476
2477	msg.hwnd = pmt->hOwnerWnd;
2478
2479	PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD \| PM_REMOVE);
2480	pmt->trackFlags \|= TF_SKIPREMOVE;
2481
2482	switch( uMsg )
2483	{
2484	case WM_KEYDOWN:
2485	PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD \| PM_NOREMOVE);
2486	if( msg.message == WM_KEYUP \|\| msg.message == WM_PAINT )
2487	{
2488	PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD \| PM_REMOVE);
2489	PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD \| PM_NOREMOVE);
2490	if( msg.message == WM_KEYDOWN &&
2491	(msg.wParam == VK_LEFT \|\| msg.wParam == VK_RIGHT))
2492	{
2493	pmt->trackFlags \|= TF_SUSPENDPOPUP;
2494	return TRUE;
2495	}
2496	}
2497	break;
2498	}
2499
2500	/* failures go through this */
2501	pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2502	return FALSE;
2503	}
2504
2505	/***********************************************************************
2506	* MENU_KeyEscape
2507	*
2508	* Handle a VK_ESCAPE key event in a menu.
2509	*/
2510	static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2511	{
2512	BOOL bEndMenu = TRUE;
2513
2514	if (pmt->hCurrentMenu != pmt->hTopMenu)
2515	{
2516	POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2517
2518	if (menu->wFlags & MF_POPUP)
2519	{
2520	HMENU hmenutmp, hmenuprev;
2521
2522	hmenuprev = hmenutmp = pmt->hTopMenu;
2523
2524	/* close topmost popup */
2525	while (hmenutmp != pmt->hCurrentMenu)
2526	{
2527	hmenuprev = hmenutmp;
2528	hmenutmp = MENU_GetSubPopup( hmenuprev );
2529	}
2530
2531	MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2532	pmt->hCurrentMenu = hmenuprev;
2533	bEndMenu = FALSE;
2534	}
2535	}
2536
2537	return bEndMenu;
2538	}
2539
2540	/***********************************************************************
2541	* MENU_KeyLeft
2542	*
2543	* Handle a VK_LEFT key event in a menu.
2544	*/
2545	static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2546	{
2547	POPUPMENU *menu;
2548	HMENU hmenutmp, hmenuprev;
2549	UINT prevcol;
2550
2551	hmenuprev = hmenutmp = pmt->hTopMenu;
2552	menu = MENU_GetMenu( hmenutmp );
2553
2554	/* Try to move 1 column left (if possible) */
2555	if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2556	NO_SELECTED_ITEM ) {
2557
2558	MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2559	prevcol, TRUE, 0 );
2560	return;
2561	}
2562
2563	/* close topmost popup */
2564	while (hmenutmp != pmt->hCurrentMenu)
2565	{
2566	hmenuprev = hmenutmp;
2567	hmenutmp = MENU_GetSubPopup( hmenuprev );
2568	}
2569
2570	MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2571	pmt->hCurrentMenu = hmenuprev;
2572
2573	if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2574	{
2575	/* move menu bar selection if no more popups are left */
2576
2577	if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2578	MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2579
2580	if ( hmenuprev != hmenutmp \|\| pmt->trackFlags & TF_SUSPENDPOPUP )
2581	{
2582	/* A sublevel menu was displayed - display the next one
2583	* unless there is another displacement coming up */
2584
2585	if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2586	pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2587	pmt->hTopMenu, TRUE, wFlags);
2588	}
2589	}
2590	}
2591
2592
2593	/***********************************************************************
2594	* MENU_KeyRight
2595	*
2596	* Handle a VK_RIGHT key event in a menu.
2597	*/
2598	static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2599	{
2600	HMENU hmenutmp;
2601	POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2602	UINT nextcol;
2603
2604	TRACE("MENU_KeyRight called, cur %x (%s), top %x (%s).\n",
2605	pmt->hCurrentMenu,
2606	debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->
2607	items[0].text),
2608	pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2609
2610	if ( (menu->wFlags & MF_POPUP) \|\| (pmt->hCurrentMenu != pmt->hTopMenu))
2611	{
2612	/* If already displaying a popup, try to display sub-popup */
2613
2614	hmenutmp = pmt->hCurrentMenu;
2615	pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2616
2617	/* if subpopup was displayed then we are done */
2618	if (hmenutmp != pmt->hCurrentMenu) return;
2619	}
2620
2621	/* Check to see if there's another column */
2622	if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2623	NO_SELECTED_ITEM ) {
2624	TRACE("Going to %d.\n", nextcol );
2625	MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2626	nextcol, TRUE, 0 );
2627	return;
2628	}
2629
2630	if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2631	{
2632	if( pmt->hCurrentMenu != pmt->hTopMenu )
2633	{
2634	MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2635	hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2636	} else hmenutmp = 0;
2637
2638	/* try to move to the next item */
2639	if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2640	MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2641
2642	if( hmenutmp \|\| pmt->trackFlags & TF_SUSPENDPOPUP )
2643	if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2644	pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2645	pmt->hTopMenu, TRUE, wFlags);
2646	}
2647	}
2648
2649	/***********************************************************************
2650	* MENU_TrackMenu
2651	*
2652	* Menu tracking code.
2653	*/
2654	static INT MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2655	HWND hwnd, const RECT *lprect )
2656	{
2657	MSG msg;
2658	POPUPMENU *menu;
2659	BOOL fRemove;
2660	INT executedMenuId = -1;
2661	MTRACKER mt;
2662	BOOL enterIdleSent = FALSE;
2663
2664	mt.trackFlags = 0;
2665	mt.hCurrentMenu = hmenu;
2666	mt.hTopMenu = hmenu;
2667	mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2668	mt.pt.x = x;
2669	mt.pt.y = y;
2670
2671	TRACE("hmenu=0x%04x flags=0x%08x (%d,%d) hwnd=0x%04x (%d,%d)-(%d,%d)\n",
2672	hmenu, wFlags, x, y, hwnd, (lprect) ? lprect->left : 0, (lprect) ? lprect->top : 0,
2673	(lprect) ? lprect->right : 0, (lprect) ? lprect->bottom : 0);
2674
2675	fEndMenu = FALSE;
2676	if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
2677
2678	if (wFlags & TPM_BUTTONDOWN)
2679	{
2680	/* Get the result in order to start the tracking or not */
2681	fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2682	fEndMenu = !fRemove;
2683	}
2684
2685	EVENT_Capture( mt.hOwnerWnd, HTMENU );
2686
2687	while (!fEndMenu)
2688	{
2689	menu = MENU_GetMenu( mt.hCurrentMenu );
2690	if (!menu) /* sometimes happens if I do a window manager close */
2691	break;
2692
2693	/* we have to keep the message in the queue until it's
2694	* clear that menu loop is not over yet. */
2695
2696	for (;;)
2697	{
2698	if (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
2699	{
2700	if (!CallMsgFilterA( &msg, MSGF_MENU )) break;
2701	/* remove the message from the queue */
2702	PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2703	}
2704	else
2705	{
2706	if (!enterIdleSent)
2707	{
2708	HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2709	enterIdleSent = TRUE;
2710	SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2711	}
2712	WaitMessage();
2713	}
2714	}
2715
2716	/* check if EndMenu() tried to cancel us, by posting this message */
2717	if(msg.message == WM_CANCELMODE)
2718	{
2719	/* we are now out of the loop */
2720	fEndMenu = TRUE;
2721
2722	/* remove the message from the queue */
2723	PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2724
2725	/* break out of internal loop, ala ESCAPE */
2726	break;
2727	}
2728
2729	TranslateMessage( &msg );
2730	mt.pt = msg.pt;
2731
2732	if ( (msg.hwnd==menu->hWnd) \|\| (msg.message!=WM_TIMER) )
2733	enterIdleSent=FALSE;
2734
2735	fRemove = FALSE;
2736	if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
2737	{
2738	/*
2739	* use the mouse coordinates in lParam instead of those in the MSG
2740	* struct to properly handle synthetic messages. lParam coords are
2741	* relative to client area, so they must be converted; since they can
2742	* be negative, we must use SLOWORD/SHIWORD instead of LOWORD/HIWORD.
2743	*/
2744	mt.pt.x = SLOWORD(msg.lParam);
2745	mt.pt.y = SHIWORD(msg.lParam);
2746	ClientToScreen(msg.hwnd,&mt.pt);
2747
2748	/* Find a menu for this mouse event */
2749	hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
2750
2751	switch(msg.message)
2752	{
2753	/* no WM_NC... messages in captured state */
2754
2755	case WM_RBUTTONDBLCLK:
2756	case WM_RBUTTONDOWN:
2757	if (!(wFlags & TPM_RIGHTBUTTON)) break;
2758	/* fall through */
2759	case WM_LBUTTONDBLCLK:
2760	case WM_LBUTTONDOWN:
2761	/* If the message belongs to the menu, removes it from the queue */
2762	/* Else, end menu tracking */
2763	fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2764	fEndMenu = !fRemove;
2765	break;
2766
2767	case WM_RBUTTONUP:
2768	if (!(wFlags & TPM_RIGHTBUTTON)) break;
2769	/* fall through */
2770	case WM_LBUTTONUP:
2771	/* Check if a menu was selected by the mouse */
2772	if (hmenu)
2773	{
2774	executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
2775
2776	/* End the loop if executedMenuId is an item ID */
2777	/* or if the job was done (executedMenuId = 0). */
2778	fEndMenu = fRemove = (executedMenuId != -1);
2779	}
2780	/* No menu was selected by the mouse */
2781	/* if the function was called by TrackPopupMenu, continue
2782	with the menu tracking. If not, stop it */
2783	else
2784	fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
2785
2786	break;
2787
2788	case WM_MOUSEMOVE:
2789	/* In win95 winelook, the selected menu item must be changed every time the
2790	mouse moves. In Win31 winelook, the mouse button has to be held down */
2791
2792	if ( hmenu && ((TWEAK_WineLook > WIN31_LOOK) \|\|
2793	( (msg.wParam & MK_LBUTTON) \|\|
2794	((wFlags & TPM_RIGHTBUTTON) && (msg.wParam & MK_RBUTTON)))) )
2795
2796	fEndMenu \|= !MENU_MouseMove( &mt, hmenu, wFlags );
2797
2798	} /* switch(msg.message) - mouse */
2799	}
2800	else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
2801	{
2802	fRemove = TRUE; /* Keyboard messages are always removed */
2803	switch(msg.message)
2804	{
2805	case WM_KEYDOWN:
2806	switch(msg.wParam)
2807	{
2808	case VK_HOME:
2809	case VK_END:
2810	MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
2811	NO_SELECTED_ITEM, FALSE, 0 );
2812	/* fall through */
2813	case VK_UP:
2814	MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
2815	(msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
2816	break;
2817
2818	case VK_DOWN: /* If on menu bar, pull-down the menu */
2819
2820	menu = MENU_GetMenu( mt.hCurrentMenu );
2821	if (!(menu->wFlags & MF_POPUP))
2822	mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
2823	else /* otherwise try to move selection */
2824	MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT );
2825	break;
2826
2827	case VK_LEFT:
2828	MENU_KeyLeft( &mt, wFlags );
2829	break;
2830
2831	case VK_RIGHT:
2832	MENU_KeyRight( &mt, wFlags );
2833	break;
2834
2835	case VK_ESCAPE:
2836	fEndMenu = MENU_KeyEscape(&mt, wFlags);
2837	break;
2838
2839	case VK_F1:
2840	{
2841	HELPINFO hi;
2842	hi.cbSize = sizeof(HELPINFO);
2843	hi.iContextType = HELPINFO_MENUITEM;
2844	if (menu->FocusedItem == NO_SELECTED_ITEM)
2845	hi.iCtrlId = 0;
2846	else
2847	hi.iCtrlId = menu->items[menu->FocusedItem].wID;
2848	hi.hItemHandle = hmenu;
2849	hi.dwContextId = menu->dwContextHelpID;
2850	hi.MousePos = msg.pt;
2851	SendMessageA(hwnd, WM_HELP, 0, (LPARAM)&hi);
2852	break;
2853	}
2854
2855	default:
2856	break;
2857	}
2858	break; /* WM_KEYDOWN */
2859
2860	case WM_SYSKEYDOWN:
2861	switch(msg.wParam)
2862	{
2863	case VK_MENU:
2864	fEndMenu = TRUE;
2865	break;
2866
2867	}
2868	break; /* WM_SYSKEYDOWN */
2869
2870	case WM_CHAR:
2871	{
2872	UINT pos;
2873
2874	if (msg.wParam == '\r' \|\| msg.wParam == ' ')
2875	{
2876	executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2877	fEndMenu = (executedMenuId != -1);
2878
2879	break;
2880	}
2881
2882	/* Hack to avoid control chars. */
2883	/* We will find a better way real soon... */
2884	if ((msg.wParam <= 32) \|\| (msg.wParam >= 127)) break;
2885
2886	pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
2887	LOWORD(msg.wParam), FALSE );
2888	if (pos == (UINT)-2) fEndMenu = TRUE;
2889	else if (pos == (UINT)-1) MessageBeep(0);
2890	else
2891	{
2892	MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
2893	TRUE, 0 );
2894	executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2895	fEndMenu = (executedMenuId != -1);
2896	}
2897	}
2898	break;
2899	} /* switch(msg.message) - kbd */
2900	}
2901	else
2902	{
2903	DispatchMessageA( &msg );
2904	}
2905
2906	if (!fEndMenu) fRemove = TRUE;
2907
2908	/* finally remove message from the queue */
2909
2910	if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
2911	PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2912	else mt.trackFlags &= ~TF_SKIPREMOVE;
2913	}
2914
2915	ReleaseCapture();
2916
2917	/* If dropdown is still painted and the close box is clicked on
2918	then the menu will be destroyed as part of the DispatchMessage above.
2919	This will then invalidate the menu handle in mt.hTopMenu. We should
2920	check for this first. */
2921	if( IsMenu( mt.hTopMenu ) )
2922	{
2923	menu = MENU_GetMenu( mt.hTopMenu );
2924
2925	if( IsWindow( mt.hOwnerWnd ) )
2926	{
2927	MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
2928
2929	if (menu && menu->wFlags & MF_POPUP)
2930	{
2931	DestroyWindow( menu->hWnd );
2932	menu->hWnd = 0;
2933	}
2934	MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2935	SendMessageA( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
2936	}
2937
2938	/* Reset the variable for hiding menu */
2939	if( menu ) menu->bTimeToHide = FALSE;
2940	}
2941
2942	/* The return value is only used by TrackPopupMenu */
2943	return ((executedMenuId != -1) ? executedMenuId : 0);
2944	}
2945
2946	/***********************************************************************
2947	* MENU_InitTracking
2948	*/
2949	static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
2950	{
2951	TRACE("hwnd=0x%04x hmenu=0x%04x\n", hWnd, hMenu);
2952
2953	HideCaret(0);
2954
2955	/* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2956	if (!(wFlags & TPM_NONOTIFY))
2957	SendMessageA( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
2958
2959	SendMessageA( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
2960
2961	if (!(wFlags & TPM_NONOTIFY))
2962	{
2963	POPUPMENU *menu;
2964	SendMessageA( hWnd, WM_INITMENU, hMenu, 0 );
2965	if ((menu = MENU_GetMenu( hMenu )) && (!menu->Height))
2966	{ /* app changed/recreated menu bar entries in WM_INITMENU
2967	Recalculate menu sizes else clicks will not work */
2968	SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE \| SWP_NOMOVE \|
2969	SWP_NOACTIVATE \| SWP_NOZORDER \| SWP_FRAMECHANGED );
2970
2971	}
2972	}
2973	return TRUE;
2974	}
2975	/***********************************************************************
2976	* MENU_ExitTracking
2977	*/
2978	static BOOL MENU_ExitTracking(HWND hWnd)
2979	{
2980	TRACE("hwnd=0x%04x\n", hWnd);
2981
2982	SendMessageA( hWnd, WM_EXITMENULOOP, 0, 0 );
2983	ShowCaret(0);
2984	return TRUE;
2985	}
2986
2987	/***********************************************************************
2988	* MENU_TrackMouseMenuBar
2989	*
2990	* Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2991	*/
2992	void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
2993	{
2994	HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
2995	UINT wFlags = TPM_ENTERIDLEEX \| TPM_BUTTONDOWN \| TPM_LEFTALIGN \| TPM_LEFTBUTTON;
2996
2997	TRACE("wnd=%x ht=0x%04x (%ld,%ld)\n", hWnd, ht, pt.x, pt.y);
2998
2999	if (IsMenu(hMenu))
3000	{
3001	/* map point to parent client coordinates */
3002	HWND parent = GetAncestor( hWnd, GA_PARENT );
3003	if (parent != GetDesktopWindow()) ScreenToClient( parent, &pt );
3004
3005	MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3006	MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3007	MENU_ExitTracking(hWnd);
3008	}
3009	}
3010
3011
3012	/***********************************************************************
3013	* MENU_TrackKbdMenuBar
3014	*
3015	* Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3016	*/
3017	void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, INT vkey)
3018	{
3019	UINT uItem = NO_SELECTED_ITEM;
3020	HMENU hTrackMenu;
3021	UINT wFlags = TPM_ENTERIDLEEX \| TPM_LEFTALIGN \| TPM_LEFTBUTTON;
3022
3023	/* find window that has a menu */
3024
3025	while (GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)
3026	if (!(hwnd = GetParent( hwnd ))) return;
3027
3028	/* check if we have to track a system menu */
3029
3030	hTrackMenu = GetMenu( hwnd );
3031	if (!hTrackMenu \|\| IsIconic(hwnd) \|\| vkey == VK_SPACE )
3032	{
3033	if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3034	hTrackMenu = get_win_sys_menu( hwnd );
3035	uItem = 0;
3036	wParam \|= HTSYSMENU; /* prevent item lookup */
3037	}
3038
3039	if (!IsMenu( hTrackMenu )) return;
3040
3041	MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3042
3043	if( vkey && vkey != VK_SPACE )
3044	{
3045	uItem = MENU_FindItemByKey( hwnd, hTrackMenu, vkey, (wParam & HTSYSMENU) );
3046	if( uItem >= (UINT)(-2) )
3047	{
3048	if( uItem == (UINT)(-1) ) MessageBeep(0);
3049	hTrackMenu = 0;
3050	}
3051	}
3052
3053	if( hTrackMenu )
3054	{
3055	MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3056
3057	if( uItem == NO_SELECTED_ITEM )
3058	MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3059	else if( vkey )
3060	PostMessageA( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3061
3062	MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3063	}
3064	MENU_ExitTracking( hwnd );
3065	}
3066
3067
3068	/**********************************************************************
3069	* TrackPopupMenu (USER32.@)
3070	*
3071	* Like the win32 API, the function return the command ID only if the
3072	* flag TPM_RETURNCMD is on.
3073	*
3074	*/
3075	BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3076	INT nReserved, HWND hWnd, const RECT *lpRect )
3077	{
3078	BOOL ret = FALSE;
3079
3080	MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3081
3082	/* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3083	if (!(wFlags & TPM_NONOTIFY))
3084	SendMessageA( hWnd, WM_INITMENUPOPUP, hMenu, 0);
3085
3086	if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
3087	ret = MENU_TrackMenu( hMenu, wFlags \| TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3088	MENU_ExitTracking(hWnd);
3089
3090	if( (!(wFlags & TPM_RETURNCMD)) && (ret != FALSE) )
3091	ret = 1;
3092
3093	return ret;
3094	}
3095
3096	/**********************************************************************
3097	* TrackPopupMenuEx (USER32.@)
3098	*/
3099	BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3100	HWND hWnd, LPTPMPARAMS lpTpm )
3101	{
3102	FIXME("not fully implemented\n" );
3103	return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3104	lpTpm ? &lpTpm->rcExclude : NULL );
3105	}
3106
3107	/***********************************************************************
3108	* PopupMenuWndProc
3109	*
3110	* NOTE: Windows has totally different (and undocumented) popup wndproc.
3111	*/
3112	static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3113	{
3114	TRACE("hwnd=0x%04x msg=0x%04x wp=0x%04x lp=0x%08lx\n",
3115	hwnd, message, wParam, lParam);
3116
3117	switch(message)
3118	{
3119	case WM_CREATE:
3120	{
3121	CREATESTRUCTW cs = (CREATESTRUCTW)lParam;
3122	SetWindowLongW( hwnd, 0, (LONG)cs->lpCreateParams );
3123	return 0;
3124	}
3125
3126	case WM_MOUSEACTIVATE: /* We don't want to be activated */
3127	return MA_NOACTIVATE;
3128
3129	case WM_PAINT:
3130	{
3131	PAINTSTRUCT ps;
3132	BeginPaint( hwnd, &ps );
3133	MENU_DrawPopupMenu( hwnd, ps.hdc,
3134	(HMENU)GetWindowLongA( hwnd, 0 ) );
3135	EndPaint( hwnd, &ps );
3136	return 0;
3137	}
3138	case WM_ERASEBKGND:
3139	return 1;
3140
3141	case WM_DESTROY:
3142	/* zero out global pointer in case resident popup window was destroyed. */
3143	if (hwnd == top_popup) top_popup = 0;
3144	break;
3145
3146	case WM_SHOWWINDOW:
3147
3148	if( wParam )
3149	{
3150	if (!GetWindowLongW( hwnd, 0 )) ERR("no menu to display\n");
3151	}
3152	else
3153	SetWindowLongW( hwnd, 0, 0 );
3154	break;
3155
3156	case MM_SETMENUHANDLE:
3157	SetWindowLongW( hwnd, 0, wParam );
3158	break;
3159
3160	case MM_GETMENUHANDLE:
3161	return GetWindowLongW( hwnd, 0 );
3162
3163	default:
3164	return DefWindowProcW( hwnd, message, wParam, lParam );
3165	}
3166	return 0;
3167	}
3168
3169
3170	/***********************************************************************
3171	* MENU_GetMenuBarHeight
3172	*
3173	* Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3174	*/
3175	UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3176	INT orgX, INT orgY )
3177	{
3178	HDC hdc;
3179	RECT rectBar;
3180	LPPOPUPMENU lppop;
3181
3182	TRACE("HWND 0x%x, width %d, at (%d, %d).\n",
3183	hwnd, menubarWidth, orgX, orgY );
3184
3185	if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3186
3187	hdc = GetDCEx( hwnd, 0, DCX_CACHE \| DCX_WINDOW );
3188	SelectObject( hdc, hMenuFont);
3189	SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3190	MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3191	ReleaseDC( hwnd, hdc );
3192	return lppop->Height;
3193	}
3194
3195
3196	/*******************************************************************
3197	* ChangeMenu (USER.153)
3198	*/
3199	BOOL16 WINAPI ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
3200	UINT16 id, UINT16 flags )
3201	{
3202	TRACE("menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
3203	hMenu, pos, (DWORD)data, id, flags );
3204	if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND,
3205	id, data );
3206
3207	/* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
3208	/* for MF_DELETE. We should check the parameters for all others */
3209	/* MF_* actions also (anybody got a doc on ChangeMenu?). */
3210
3211	if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE);
3212	if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE,
3213	id, data );
3214	if (flags & MF_REMOVE) return RemoveMenu16(hMenu,
3215	flags & MF_BYPOSITION ? pos : id,
3216	flags & ~MF_REMOVE );
3217	/* Default: MF_INSERT */
3218	return InsertMenu16( hMenu, pos, flags, id, data );
3219	}
3220
3221
3222	/*******************************************************************
3223	* ChangeMenuA (USER32.@)
3224	*/
3225	BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3226	UINT id, UINT flags )
3227	{
3228	TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3229	hMenu, pos, (DWORD)data, id, flags );
3230	if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3231	id, data );
3232	if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3233	if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3234	id, data );
3235	if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3236	flags & MF_BYPOSITION ? pos : id,
3237	flags & ~MF_REMOVE );
3238	/* Default: MF_INSERT */
3239	return InsertMenuA( hMenu, pos, flags, id, data );
3240	}
3241
3242
3243	/*******************************************************************
3244	* ChangeMenuW (USER32.@)
3245	*/
3246	BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3247	UINT id, UINT flags )
3248	{
3249	TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3250	hMenu, pos, (DWORD)data, id, flags );
3251	if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3252	id, data );
3253	if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3254	if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3255	id, data );
3256	if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3257	flags & MF_BYPOSITION ? pos : id,
3258	flags & ~MF_REMOVE );
3259	/* Default: MF_INSERT */
3260	return InsertMenuW( hMenu, pos, flags, id, data );
3261	}
3262
3263
3264	/*******************************************************************
3265	* CheckMenuItem (USER.154)
3266	*/
3267	BOOL16 WINAPI CheckMenuItem16( HMENU16 hMenu, UINT16 id, UINT16 flags )
3268	{
3269	return (BOOL16)CheckMenuItem( hMenu, id, flags );
3270	}
3271
3272
3273	/*******************************************************************
3274	* CheckMenuItem (USER32.@)
3275	*/
3276	DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3277	{
3278	MENUITEM *item;
3279	DWORD ret;
3280
3281	TRACE("menu=%04x id=%04x flags=%04x\n", hMenu, id, flags );
3282	if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3283	ret = item->fState & MF_CHECKED;
3284	if (flags & MF_CHECKED) item->fState \|= MF_CHECKED;
3285	else item->fState &= ~MF_CHECKED;
3286	return ret;
3287	}
3288
3289
3290	/**********************************************************************
3291	* EnableMenuItem (USER.155)
3292	*/
3293	UINT16 WINAPI EnableMenuItem16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3294	{
3295	return EnableMenuItem( hMenu, wItemID, wFlags );
3296	}
3297
3298
3299	/**********************************************************************
3300	* EnableMenuItem (USER32.@)
3301	*/
3302	UINT WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3303	{
3304	UINT oldflags;
3305	MENUITEM *item;
3306	POPUPMENU *menu;
3307
3308	TRACE("(%04x, %04X, %04X) !\n",
3309	hMenu, wItemID, wFlags);
3310
3311	/* Get the Popupmenu to access the owner menu */
3312	if (!(menu = MENU_GetMenu(hMenu)))
3313	return (UINT)-1;
3314
3315	if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3316	return (UINT)-1;
3317
3318	oldflags = item->fState & (MF_GRAYED \| MF_DISABLED);
3319	item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED \| MF_DISABLED);
3320
3321	/* In win95 if the close item in the system menu change update the close button */
3322	if (TWEAK_WineLook == WIN95_LOOK)
3323	if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3324	{
3325	if (menu->hSysMenuOwner != 0)
3326	{
3327	POPUPMENU* parentMenu;
3328
3329	/* Get the parent menu to access*/
3330	if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3331	return (UINT)-1;
3332
3333	/* Refresh the frame to reflect the change*/
3334	SetWindowPos(parentMenu->hWnd, 0, 0, 0, 0, 0,
3335	SWP_NOACTIVATE \| SWP_NOMOVE \| SWP_NOSIZE \| SWP_NOZORDER);
3336	}
3337	}
3338
3339	return oldflags;
3340	}
3341
3342
3343	/*******************************************************************
3344	* GetMenuString (USER.161)
3345	*/
3346	INT16 WINAPI GetMenuString16( HMENU16 hMenu, UINT16 wItemID,
3347	LPSTR str, INT16 nMaxSiz, UINT16 wFlags )
3348	{
3349	return GetMenuStringA( hMenu, wItemID, str, nMaxSiz, wFlags );
3350	}
3351
3352
3353	/*******************************************************************
3354	* GetMenuStringA (USER32.@)
3355	*/
3356	INT WINAPI GetMenuStringA(
3357	HMENU hMenu, /* [in] menuhandle */
3358	UINT wItemID, /* [in] menu item (dep. on wFlags) */
3359	LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3360	INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3361	UINT wFlags /* [in] MF_ flags */
3362	) {
3363	MENUITEM *item;
3364
3365	TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3366	hMenu, wItemID, str, nMaxSiz, wFlags );
3367	if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3368	if (!IS_STRING_ITEM(item->fType)) return 0;
3369	if (!str \|\| !nMaxSiz) return strlenW(item->text);
3370	str[0] = '\0';
3371	if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3372	str[nMaxSiz-1] = 0;
3373	TRACE("returning '%s'\n", str );
3374	return strlen(str);
3375	}
3376
3377
3378	/*******************************************************************
3379	* GetMenuStringW (USER32.@)
3380	*/
3381	INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3382	LPWSTR str, INT nMaxSiz, UINT wFlags )
3383	{
3384	MENUITEM *item;
3385
3386	TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3387	hMenu, wItemID, str, nMaxSiz, wFlags );
3388	if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3389	if (!IS_STRING_ITEM(item->fType)) return 0;
3390	if (!str \|\| !nMaxSiz) return strlenW(item->text);
3391	str[0] = '\0';
3392	lstrcpynW( str, item->text, nMaxSiz );
3393	return strlenW(str);
3394	}
3395
3396
3397	/**********************************************************************
3398	* HiliteMenuItem (USER32.@)
3399	*/
3400	BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3401	UINT wHilite )
3402	{
3403	LPPOPUPMENU menu;
3404	TRACE("(%04x, %04x, %04x, %04x);\n",
3405	hWnd, hMenu, wItemID, wHilite);
3406	if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3407	if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3408	if (menu->FocusedItem == wItemID) return TRUE;
3409	MENU_HideSubPopups( hWnd, hMenu, FALSE );
3410	MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3411	return TRUE;
3412	}
3413
3414
3415	/**********************************************************************
3416	* GetMenuState (USER.250)
3417	*/
3418	UINT16 WINAPI GetMenuState16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3419	{
3420	return GetMenuState( hMenu, wItemID, wFlags );
3421	}
3422
3423
3424	/**********************************************************************
3425	* GetMenuState (USER32.@)
3426	*/
3427	UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3428	{
3429	MENUITEM *item;
3430	TRACE("(menu=%04x, id=%04x, flags=%04x);\n",
3431	hMenu, wItemID, wFlags);
3432	if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3433	debug_print_menuitem (" item: ", item, "");
3434	if (item->fType & MF_POPUP)
3435	{
3436	POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3437	if (!menu) return -1;
3438	else return (menu->nItems << 8) \| ((item->fState\|item->fType) & 0xff);
3439	}
3440	else
3441	{
3442	/* We used to (from way back then) mask the result to 0xff. */
3443	/* I don't know why and it seems wrong as the documented */
3444	/* return flag MF_SEPARATOR is outside that mask. */
3445	return (item->fType \| item->fState);
3446	}
3447	}
3448
3449
3450	/**********************************************************************
3451	* GetMenuItemCount (USER.263)
3452	*/
3453	INT16 WINAPI GetMenuItemCount16( HMENU16 hMenu )
3454	{
3455	LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3456	if (!menu) return -1;
3457	TRACE("(%04x) returning %d\n",
3458	hMenu, menu->nItems );
3459	return menu->nItems;
3460	}
3461
3462
3463	/**********************************************************************
3464	* GetMenuItemCount (USER32.@)
3465	*/
3466	INT WINAPI GetMenuItemCount( HMENU hMenu )
3467	{
3468	LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3469	if (!menu) return -1;
3470	TRACE("(%04x) returning %d\n",
3471	hMenu, menu->nItems );
3472	return menu->nItems;
3473	}
3474
3475	/**********************************************************************
3476	* GetMenuItemID (USER.264)
3477	*/
3478	UINT16 WINAPI GetMenuItemID16( HMENU16 hMenu, INT16 nPos )
3479	{
3480	return (UINT16) GetMenuItemID (hMenu, nPos);
3481	}
3482
3483	/**********************************************************************
3484	* GetMenuItemID (USER32.@)
3485	*/
3486	UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3487	{
3488	MENUITEM * lpmi;
3489
3490	if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return -1;
3491	if (lpmi->fType & MF_POPUP) return -1;
3492	return lpmi->wID;
3493
3494	}
3495
3496	/*******************************************************************
3497	* InsertMenu (USER.410)
3498	*/
3499	BOOL16 WINAPI InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3500	UINT16 id, SEGPTR data )
3501	{
3502	UINT pos32 = (UINT)pos;
3503	if ((pos == (UINT16)-1) && (flags & MF_BYPOSITION)) pos32 = (UINT)-1;
3504	if (IS_STRING_ITEM(flags) && data)
3505	return InsertMenuA( hMenu, pos32, flags, id, MapSL(data) );
3506	return InsertMenuA( hMenu, pos32, flags, id, (LPSTR)data );
3507	}
3508
3509
3510	/*******************************************************************
3511	* InsertMenuW (USER32.@)
3512	*/
3513	BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3514	UINT id, LPCWSTR str )
3515	{
3516	MENUITEM *item;
3517
3518	if (IS_STRING_ITEM(flags) && str)
3519	TRACE("hMenu %04x, pos %d, flags %08x, "
3520	"id %04x, str %s\n",
3521	hMenu, pos, flags, id, debugstr_w(str) );
3522	else TRACE("hMenu %04x, pos %d, flags %08x, "
3523	"id %04x, str %08lx (not a string)\n",
3524	hMenu, pos, flags, id, (DWORD)str );
3525
3526	if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3527
3528	if (!(MENU_SetItemData( item, flags, id, str )))
3529	{
3530	RemoveMenu( hMenu, pos, flags );
3531	return FALSE;
3532	}
3533
3534	if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
3535	(MENU_GetMenu((HMENU16)id))->wFlags \|= MF_POPUP;
3536
3537	item->hCheckBit = item->hUnCheckBit = 0;
3538	return TRUE;
3539	}
3540
3541
3542	/*******************************************************************
3543	* InsertMenuA (USER32.@)
3544	*/
3545	BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3546	UINT id, LPCSTR str )
3547	{
3548	BOOL ret = FALSE;
3549
3550	if (IS_STRING_ITEM(flags) && str)
3551	{
3552	INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3553	LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3554	if (newstr)
3555	{
3556	MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3557	ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3558	HeapFree( GetProcessHeap(), 0, newstr );
3559	}
3560	return ret;
3561	}
3562	else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3563	}
3564
3565
3566	/*******************************************************************
3567	* AppendMenu (USER.411)
3568	*/
3569	BOOL16 WINAPI AppendMenu16(HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data)
3570	{
3571	return InsertMenu16( hMenu, -1, flags \| MF_BYPOSITION, id, data );
3572	}
3573
3574
3575	/*******************************************************************
3576	* AppendMenuA (USER32.@)
3577	*/
3578	BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3579	UINT id, LPCSTR data )
3580	{
3581	return InsertMenuA( hMenu, -1, flags \| MF_BYPOSITION, id, data );
3582	}
3583
3584
3585	/*******************************************************************
3586	* AppendMenuW (USER32.@)
3587	*/
3588	BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3589	UINT id, LPCWSTR data )
3590	{
3591	return InsertMenuW( hMenu, -1, flags \| MF_BYPOSITION, id, data );
3592	}
3593
3594
3595	/**********************************************************************
3596	* RemoveMenu (USER.412)
3597	*/
3598	BOOL16 WINAPI RemoveMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3599	{
3600	return RemoveMenu( hMenu, nPos, wFlags );
3601	}
3602
3603
3604	/**********************************************************************
3605	* RemoveMenu (USER32.@)
3606	*/
3607	BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3608	{
3609	LPPOPUPMENU menu;
3610	MENUITEM *item;
3611
3612	TRACE("(menu=%04x pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3613	if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3614	if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3615
3616	/* Remove item */
3617
3618	MENU_FreeItemData( item );
3619
3620	if (--menu->nItems == 0)
3621	{
3622	HeapFree( GetProcessHeap(), 0, menu->items );
3623	menu->items = NULL;
3624	}
3625	else
3626	{
3627	while(nPos < menu->nItems)
3628	{
3629	item = (item+1);
3630	item++;
3631	nPos++;
3632	}
3633	menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3634	menu->nItems * sizeof(MENUITEM) );
3635	}
3636	return TRUE;
3637	}
3638
3639
3640	/**********************************************************************
3641	* DeleteMenu (USER.413)
3642	*/
3643	BOOL16 WINAPI DeleteMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3644	{
3645	return DeleteMenu( hMenu, nPos, wFlags );
3646	}
3647
3648
3649	/**********************************************************************
3650	* DeleteMenu (USER32.@)
3651	*/
3652	BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3653	{
3654	MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3655	if (!item) return FALSE;
3656	if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3657	/* nPos is now the position of the item */
3658	RemoveMenu( hMenu, nPos, wFlags \| MF_BYPOSITION );
3659	return TRUE;
3660	}
3661
3662
3663	/*******************************************************************
3664	* ModifyMenu (USER.414)
3665	*/
3666	BOOL16 WINAPI ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3667	UINT16 id, SEGPTR data )
3668	{
3669	if (IS_STRING_ITEM(flags))
3670	return ModifyMenuA( hMenu, pos, flags, id, MapSL(data) );
3671	return ModifyMenuA( hMenu, pos, flags, id, (LPSTR)data );
3672	}
3673
3674
3675	/*******************************************************************
3676	* ModifyMenuW (USER32.@)
3677	*/
3678	BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3679	UINT id, LPCWSTR str )
3680	{
3681	MENUITEM *item;
3682
3683	if (IS_STRING_ITEM(flags))
3684	{
3685	TRACE("%04x %d %04x %04x %s\n",
3686	hMenu, pos, flags, id, debugstr_w(str) );
3687	if (!str) return FALSE;
3688	}
3689	else
3690	{
3691	TRACE("%04x %d %04x %04x %08lx\n",
3692	hMenu, pos, flags, id, (DWORD)str );
3693	}
3694
3695	if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3696	return MENU_SetItemData( item, flags, id, str );
3697	}
3698
3699
3700	/*******************************************************************
3701	* ModifyMenuA (USER32.@)
3702	*/
3703	BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3704	UINT id, LPCSTR str )
3705	{
3706	BOOL ret = FALSE;
3707
3708	if (IS_STRING_ITEM(flags) && str)
3709	{
3710	INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3711	LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3712	if (newstr)
3713	{
3714	MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3715	ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3716	HeapFree( GetProcessHeap(), 0, newstr );
3717	}
3718	return ret;
3719	}
3720	else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3721	}
3722
3723
3724	/**********************************************************************
3725	* CreatePopupMenu (USER.415)
3726	*/
3727	HMENU16 WINAPI CreatePopupMenu16(void)
3728	{
3729	return CreatePopupMenu();
3730	}
3731
3732
3733	/**********************************************************************
3734	* CreatePopupMenu (USER32.@)
3735	*/
3736	HMENU WINAPI CreatePopupMenu(void)
3737	{
3738	HMENU hmenu;
3739	POPUPMENU *menu;
3740
3741	if (!(hmenu = CreateMenu())) return 0;
3742	menu = MENU_GetMenu( hmenu );
3743	menu->wFlags \|= MF_POPUP;
3744	menu->bTimeToHide = FALSE;
3745	return hmenu;
3746	}
3747
3748
3749	/**********************************************************************
3750	* GetMenuCheckMarkDimensions (USER.417)
3751	* GetMenuCheckMarkDimensions (USER32.@)
3752	*/
3753	DWORD WINAPI GetMenuCheckMarkDimensions(void)
3754	{
3755	return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3756	}
3757
3758
3759	/**********************************************************************
3760	* SetMenuItemBitmaps (USER.418)
3761	*/
3762	BOOL16 WINAPI SetMenuItemBitmaps16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags,
3763	HBITMAP16 hNewUnCheck, HBITMAP16 hNewCheck)
3764	{
3765	return SetMenuItemBitmaps( hMenu, nPos, wFlags, hNewUnCheck, hNewCheck );
3766	}
3767
3768
3769	/**********************************************************************
3770	* SetMenuItemBitmaps (USER32.@)
3771	*/
3772	BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3773	HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3774	{
3775	MENUITEM *item;
3776	TRACE("(%04x, %04x, %04x, %04x, %04x)\n",
3777	hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3778	if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3779
3780	if (!hNewCheck && !hNewUnCheck)
3781	{
3782	item->fState &= ~MF_USECHECKBITMAPS;
3783	}
3784	else /* Install new bitmaps */
3785	{
3786	item->hCheckBit = hNewCheck;
3787	item->hUnCheckBit = hNewUnCheck;
3788	item->fState \|= MF_USECHECKBITMAPS;
3789	}
3790	return TRUE;
3791	}
3792
3793
3794	/**********************************************************************
3795	* CreateMenu (USER.151)
3796	*/
3797	HMENU16 WINAPI CreateMenu16(void)
3798	{
3799	return CreateMenu();
3800	}
3801
3802
3803	/**********************************************************************
3804	* CreateMenu (USER32.@)
3805	*/
3806	HMENU WINAPI CreateMenu(void)
3807	{
3808	HMENU hMenu;
3809	LPPOPUPMENU menu;
3810	if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3811	menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3812
3813	ZeroMemory(menu, sizeof(POPUPMENU));
3814	menu->wMagic = MENU_MAGIC;
3815	menu->FocusedItem = NO_SELECTED_ITEM;
3816	menu->bTimeToHide = FALSE;
3817
3818	TRACE("return %04x\n", hMenu );
3819
3820	return hMenu;
3821	}
3822
3823
3824	/**********************************************************************
3825	* DestroyMenu (USER.152)
3826	*/
3827	BOOL16 WINAPI DestroyMenu16( HMENU16 hMenu )
3828	{
3829	return DestroyMenu( hMenu );
3830	}
3831
3832
3833	/**********************************************************************
3834	* DestroyMenu (USER32.@)
3835	*/
3836	BOOL WINAPI DestroyMenu( HMENU hMenu )
3837	{
3838	TRACE("(%04x)\n", hMenu);
3839
3840	/* Silently ignore attempts to destroy default system popup */
3841
3842	if (hMenu && hMenu != MENU_DefSysPopup)
3843	{
3844	LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3845
3846	if (!lppop) return FALSE;
3847
3848	lppop->wMagic = 0; /* Mark it as destroyed */
3849
3850	if ((lppop->wFlags & MF_POPUP) && lppop->hWnd)
3851	{
3852	DestroyWindow( lppop->hWnd );
3853	lppop->hWnd = 0;
3854	}
3855
3856	if (lppop->items) /* recursively destroy submenus */
3857	{
3858	int i;
3859	MENUITEM *item = lppop->items;
3860	for (i = lppop->nItems; i > 0; i--, item++)
3861	{
3862	if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3863	MENU_FreeItemData( item );
3864	}
3865	HeapFree( GetProcessHeap(), 0, lppop->items );
3866	}
3867	USER_HEAP_FREE( hMenu );
3868	}
3869	return (hMenu != MENU_DefSysPopup);
3870	}
3871
3872
3873	/**********************************************************************
3874	* GetSystemMenu (USER32.@)
3875	*/
3876	HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3877	{
3878	WND *wndPtr = WIN_FindWndPtr( hWnd );
3879	HMENU retvalue = 0;
3880
3881	if (wndPtr)
3882	{
3883	if( wndPtr->hSysMenu )
3884	{
3885	if( bRevert )
3886	{
3887	DestroyMenu(wndPtr->hSysMenu);
3888	wndPtr->hSysMenu = 0;
3889	}
3890	else
3891	{
3892	POPUPMENU *menu = MENU_GetMenu( wndPtr->hSysMenu );
3893	if( menu )
3894	{
3895	if( menu->nItems > 0 && menu->items[0].hSubMenu == MENU_DefSysPopup )
3896	menu->items[0].hSubMenu = MENU_CopySysPopup();
3897	}
3898	else
3899	{
3900	WARN("Current sys-menu (%04x) of wnd %04x is broken\n",
3901	wndPtr->hSysMenu, hWnd);
3902	wndPtr->hSysMenu = 0;
3903	}
3904	}
3905	}
3906
3907	if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
3908	wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU)(-1) );
3909
3910	if( wndPtr->hSysMenu )
3911	{
3912	POPUPMENU *menu;
3913	retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
3914
3915	/* Store the dummy sysmenu handle to facilitate the refresh */
3916	/* of the close button if the SC_CLOSE item change */
3917	menu = MENU_GetMenu(retvalue);
3918	if ( menu )
3919	menu->hSysMenuOwner = wndPtr->hSysMenu;
3920	}
3921	WIN_ReleaseWndPtr(wndPtr);
3922	}
3923	return bRevert ? 0 : retvalue;
3924	}
3925
3926
3927	/*******************************************************************
3928	* SetSystemMenu (USER32.@)
3929	*/
3930	BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
3931	{
3932	WND *wndPtr = WIN_FindWndPtr(hwnd);
3933
3934	if (wndPtr)
3935	{
3936	if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
3937	wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
3938	WIN_ReleaseWndPtr(wndPtr);
3939	return TRUE;
3940	}
3941	return FALSE;
3942	}
3943
3944
3945	/**********************************************************************
3946	* GetMenu (USER32.@)
3947	*/
3948	HMENU WINAPI GetMenu( HWND hWnd )
3949	{
3950	HMENU retvalue = (HMENU)GetWindowLongA( hWnd, GWL_ID );
3951	TRACE("for %04x returning %04x\n", hWnd, retvalue);
3952	return retvalue;
3953	}
3954
3955
3956	/**********************************************************************
3957	* SetMenu (USER32.@)
3958	*/
3959	BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
3960	{
3961	TRACE("(%04x, %04x);\n", hWnd, hMenu);
3962
3963	if (hMenu && !IsMenu(hMenu))
3964	{
3965	WARN("hMenu %x is not a menu handle\n", hMenu);
3966	return FALSE;
3967	}
3968	if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
3969
3970	hWnd = WIN_GetFullHandle( hWnd );
3971	if (GetCapture() == hWnd) ReleaseCapture();
3972
3973	if (hMenu != 0)
3974	{
3975	LPPOPUPMENU lpmenu;
3976
3977	if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
3978
3979	lpmenu->hWnd = hWnd;
3980	lpmenu->Height = 0; /* Make sure we recalculate the size */
3981	}
3982	SetWindowLongA( hWnd, GWL_ID, hMenu );
3983
3984	if (IsWindowVisible(hWnd))
3985	SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE \| SWP_NOMOVE \|
3986	SWP_NOACTIVATE \| SWP_NOZORDER \| SWP_FRAMECHANGED );
3987	return TRUE;
3988	}
3989
3990
3991
3992	/**********************************************************************
3993	* GetSubMenu (USER.159)
3994	*/
3995	HMENU16 WINAPI GetSubMenu16( HMENU16 hMenu, INT16 nPos )
3996	{
3997	return GetSubMenu( hMenu, nPos );
3998	}
3999
4000
4001	/**********************************************************************
4002	* GetSubMenu (USER32.@)
4003	*/
4004	HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4005	{
4006	MENUITEM * lpmi;
4007
4008	if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return 0;
4009	if (!(lpmi->fType & MF_POPUP)) return 0;
4010	return lpmi->hSubMenu;
4011	}
4012
4013
4014	/**********************************************************************
4015	* DrawMenuBar (USER32.@)
4016	*/
4017	BOOL WINAPI DrawMenuBar( HWND hWnd )
4018	{
4019	LPPOPUPMENU lppop;
4020	HMENU hMenu = GetMenu(hWnd);
4021
4022	if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
4023	if (!hMenu \|\| !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
4024
4025	lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4026	lppop->hwndOwner = hWnd;
4027	SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE \| SWP_NOMOVE \|
4028	SWP_NOACTIVATE \| SWP_NOZORDER \| SWP_FRAMECHANGED );
4029	return TRUE;
4030	}
4031
4032	/***********************************************************************
4033	* DrawMenuBarTemp (USER32.@)
4034	*
4035	* UNDOCUMENTED !!
4036	*
4037	* called by W98SE desk.cpl Control Panel Applet
4038	*
4039	* Not 100% sure about the param names, but close.
4040	*/
4041	DWORD WINAPI DrawMenuBarTemp(HWND someHWND, HDC someHDC, LPRECT someRECT, HMENU someHMENU, HFONT someFONT)
4042	{
4043	FIXME("(0x%08x, 0x%08x, %p, 0x%08x, 0x%08x): stub\n", someHWND, someHDC, someRECT, someHMENU, someFONT);
4044	return 0;
4045	}
4046
4047	/***********************************************************************
4048	* EndMenu (USER.187)
4049	* EndMenu (USER32.@)
4050	*/
4051	void WINAPI EndMenu(void)
4052	{
4053	/* if we are in the menu code, and it is active */
4054	if (!fEndMenu && top_popup)
4055	{
4056	/* terminate the menu handling code */
4057	fEndMenu = TRUE;
4058
4059	/* needs to be posted to wakeup the internal menu handler */
4060	/* which will now terminate the menu, in the event that */
4061	/* the main window was minimized, or lost focus, so we */
4062	/* don't end up with an orphaned menu */
4063	PostMessageA( top_popup, WM_CANCELMODE, 0, 0);
4064	}
4065	}
4066
4067
4068	/***********************************************************************
4069	* LookupMenuHandle (USER.217)
4070	*/
4071	HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
4072	{
4073	HMENU hmenu32 = hmenu;
4074	UINT id32 = id;
4075	if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
4076	else return hmenu32;
4077	}
4078
4079
4080	/**********************************************************************
4081	* LoadMenu (USER.150)
4082	*/
4083	HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
4084	{
4085	HRSRC16 hRsrc;
4086	HGLOBAL16 handle;
4087	HMENU16 hMenu;
4088
4089	TRACE("(%04x,%s)\n", instance, debugstr_a(name) );
4090
4091	if (HIWORD(name))
4092	{
4093	if (name[0] == '#') name = (LPCSTR)atoi( name + 1 );
4094	}
4095
4096	if (!name) return 0;
4097
4098	/* check for Win32 module */
4099	if (HIWORD(instance)) return LoadMenuA( instance, name );
4100	instance = GetExePtr( instance );
4101
4102	if (!(hRsrc = FindResource16( instance, name, RT_MENUA ))) return 0;
4103	if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
4104	hMenu = LoadMenuIndirect16(LockResource16(handle));
4105	FreeResource16( handle );
4106	return hMenu;
4107	}
4108
4109
4110	/*****************************************************************
4111	* LoadMenuA (USER32.@)
4112	*/
4113	HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4114	{
4115	HRSRC hrsrc = FindResourceA( instance, name, RT_MENUA );
4116	if (!hrsrc) return 0;
4117	return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
4118	}
4119
4120
4121	/*****************************************************************
4122	* LoadMenuW (USER32.@)
4123	*/
4124	HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4125	{
4126	HRSRC hrsrc = FindResourceW( instance, name, RT_MENUW );
4127	if (!hrsrc) return 0;
4128	return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
4129	}
4130
4131
4132	/**********************************************************************
4133	* LoadMenuIndirect (USER.220)
4134	*/
4135	HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
4136	{
4137	HMENU16 hMenu;
4138	WORD version, offset;
4139	LPCSTR p = (LPCSTR)template;
4140
4141	TRACE("(%p)\n", template );
4142	version = GET_WORD(p);
4143	p += sizeof(WORD);
4144	if (version)
4145	{
4146	WARN("version must be 0 for Win16\n" );
4147	return 0;
4148	}
4149	offset = GET_WORD(p);
4150	p += sizeof(WORD) + offset;
4151	if (!(hMenu = CreateMenu())) return 0;
4152	if (!MENU_ParseResource( p, hMenu, FALSE ))
4153	{
4154	DestroyMenu( hMenu );
4155	return 0;
4156	}
4157	return hMenu;
4158	}
4159
4160
4161	/**********************************************************************
4162	* LoadMenuIndirectA (USER32.@)
4163	*/
4164	HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4165	{
4166	HMENU16 hMenu;
4167	WORD version, offset;
4168	LPCSTR p = (LPCSTR)template;
4169
4170	TRACE("%p\n", template );
4171	version = GET_WORD(p);
4172	p += sizeof(WORD);
4173	switch (version)
4174	{
4175	case 0:
4176	offset = GET_WORD(p);
4177	p += sizeof(WORD) + offset;
4178	if (!(hMenu = CreateMenu())) return 0;
4179	if (!MENU_ParseResource( p, hMenu, TRUE ))
4180	{
4181	DestroyMenu( hMenu );
4182	return 0;
4183	}
4184	return hMenu;
4185	case 1:
4186	offset = GET_WORD(p);
4187	p += sizeof(WORD) + offset;
4188	if (!(hMenu = CreateMenu())) return 0;
4189	if (!MENUEX_ParseResource( p, hMenu))
4190	{
4191	DestroyMenu( hMenu );
4192	return 0;
4193	}
4194	return hMenu;
4195	default:
4196	ERR("version %d not supported.\n", version);
4197	return 0;
4198	}
4199	}
4200
4201
4202	/**********************************************************************
4203	* LoadMenuIndirectW (USER32.@)
4204	*/
4205	HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4206	{
4207	/* FIXME: is there anything different between A and W? */
4208	return LoadMenuIndirectA( template );
4209	}
4210
4211
4212	/**********************************************************************
4213	* IsMenu (USER.358)
4214	*/
4215	BOOL16 WINAPI IsMenu16( HMENU16 hmenu )
4216	{
4217	return IsMenu( hmenu );
4218	}
4219
4220
4221	/**********************************************************************
4222	* IsMenu (USER32.@)
4223	*/
4224	BOOL WINAPI IsMenu(HMENU hmenu)
4225	{
4226	LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4227	return menu != NULL;
4228	}
4229
4230	/**********************************************************************
4231	* GetMenuItemInfo_common
4232	*/
4233
4234	static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4235	LPMENUITEMINFOW lpmii, BOOL unicode)
4236	{
4237	MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos? MF_BYPOSITION : 0);
4238
4239	debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4240
4241	if (!menu)
4242	return FALSE;
4243
4244	if (lpmii->fMask & MIIM_TYPE) {
4245	lpmii->fType = menu->fType;
4246	switch (MENU_ITEM_TYPE(menu->fType)) {
4247	case MF_STRING:
4248	break; /* will be done below */
4249	case MF_OWNERDRAW:
4250	case MF_BITMAP:
4251	lpmii->dwTypeData = menu->text;
4252	/* fall through */
4253	default:
4254	lpmii->cch = 0;
4255	}
4256	}
4257
4258	/* copy the text string */
4259	if ((lpmii->fMask & (MIIM_TYPE\|MIIM_STRING)) &&
4260	(MENU_ITEM_TYPE(menu->fType) == MF_STRING) && menu->text)
4261	{
4262	int len;
4263	if (unicode)
4264	{
4265	len = strlenW(menu->text);
4266	if(lpmii->dwTypeData && lpmii->cch)
4267	lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4268	}
4269	else
4270	{
4271	len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL, 0, NULL, NULL );
4272	if(lpmii->dwTypeData && lpmii->cch)
4273	if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4274	(LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4275	((LPSTR)lpmii->dwTypeData)[lpmii->cch-1] = 0;
4276	}
4277	/* if we've copied a substring we return its length */
4278	if(lpmii->dwTypeData && lpmii->cch)
4279	{
4280	if (lpmii->cch <= len) lpmii->cch--;
4281	}
4282	else /* return length of string */
4283	lpmii->cch = len;
4284	}
4285
4286	if (lpmii->fMask & MIIM_FTYPE)
4287	lpmii->fType = menu->fType;
4288
4289	if (lpmii->fMask & MIIM_BITMAP)
4290	lpmii->hbmpItem = menu->hbmpItem;
4291
4292	if (lpmii->fMask & MIIM_STATE)
4293	lpmii->fState = menu->fState;
4294
4295	if (lpmii->fMask & MIIM_ID)
4296	lpmii->wID = menu->wID;
4297
4298	if (lpmii->fMask & MIIM_SUBMENU)
4299	lpmii->hSubMenu = menu->hSubMenu;
4300
4301	if (lpmii->fMask & MIIM_CHECKMARKS) {
4302	lpmii->hbmpChecked = menu->hCheckBit;
4303	lpmii->hbmpUnchecked = menu->hUnCheckBit;
4304	}
4305	if (lpmii->fMask & MIIM_DATA)
4306	lpmii->dwItemData = menu->dwItemData;
4307
4308	return TRUE;
4309	}
4310
4311	/**********************************************************************
4312	* GetMenuItemInfoA (USER32.@)
4313	*/
4314	BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4315	LPMENUITEMINFOA lpmii)
4316	{
4317	return GetMenuItemInfo_common (hmenu, item, bypos,
4318	(LPMENUITEMINFOW)lpmii, FALSE);
4319	}
4320
4321	/**********************************************************************
4322	* GetMenuItemInfoW (USER32.@)
4323	*/
4324	BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4325	LPMENUITEMINFOW lpmii)
4326	{
4327	return GetMenuItemInfo_common (hmenu, item, bypos,
4328	lpmii, TRUE);
4329	}
4330
4331
4332	/* set a menu item text from a ASCII or Unicode string */
4333	inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4334	{
4335	if (!text)
4336	{
4337	menu->text = NULL;
4338	menu->fType \|= MF_SEPARATOR;
4339	}
4340	else if (unicode)
4341	{
4342	if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4343	strcpyW( menu->text, text );
4344	}
4345	else
4346	{
4347	LPCSTR str = (LPCSTR)text;
4348	int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4349	if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4350	MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4351	}
4352	}
4353
4354
4355	/**********************************************************************
4356	* SetMenuItemInfo_common
4357	*/
4358
4359	static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4360	const MENUITEMINFOW *lpmii,
4361	BOOL unicode)
4362	{
4363	if (!menu) return FALSE;
4364
4365	debug_print_menuitem("MENU_SetItemInfo_common from: ", menu, "");
4366
4367	if (lpmii->fMask & MIIM_TYPE ) {
4368	/* Get rid of old string. */
4369	if ( IS_STRING_ITEM(menu->fType) && menu->text) {
4370	HeapFree(GetProcessHeap(), 0, menu->text);
4371	menu->text = NULL;
4372	}
4373
4374	/* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4375	menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4376	menu->fType \|= MENU_ITEM_TYPE(lpmii->fType);
4377
4378	menu->text = lpmii->dwTypeData;
4379
4380	if (IS_STRING_ITEM(menu->fType))
4381	set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4382	}
4383
4384	if (lpmii->fMask & MIIM_FTYPE ) {
4385	/* free the string when the type is changing */
4386	if ( (!IS_STRING_ITEM(lpmii->fType)) && IS_STRING_ITEM(menu->fType) && menu->text) {
4387	HeapFree(GetProcessHeap(), 0, menu->text);
4388	menu->text = NULL;
4389	}
4390	menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4391	menu->fType \|= MENU_ITEM_TYPE(lpmii->fType);
4392	if ( IS_STRING_ITEM(menu->fType) && !menu->text )
4393	menu->fType \|= MF_SEPARATOR;
4394	}
4395
4396	if (lpmii->fMask & MIIM_STRING ) {
4397	/* free the string when used */
4398	if ( IS_STRING_ITEM(menu->fType) && menu->text) {
4399	HeapFree(GetProcessHeap(), 0, menu->text);
4400	set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4401	}
4402	}
4403
4404	if (lpmii->fMask & MIIM_STATE)
4405	{
4406	/* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4407	menu->fState = lpmii->fState;
4408	}
4409
4410	if (lpmii->fMask & MIIM_ID)
4411	menu->wID = lpmii->wID;
4412
4413	if (lpmii->fMask & MIIM_SUBMENU) {
4414	menu->hSubMenu = lpmii->hSubMenu;
4415	if (menu->hSubMenu) {
4416	POPUPMENU *subMenu = MENU_GetMenu((UINT16)menu->hSubMenu);
4417	if (subMenu) {
4418	subMenu->wFlags \|= MF_POPUP;
4419	menu->fType \|= MF_POPUP;
4420	}
4421	else
4422	/* FIXME: Return an error ? */
4423	menu->fType &= ~MF_POPUP;
4424	}
4425	else
4426	menu->fType &= ~MF_POPUP;
4427	}
4428
4429	if (lpmii->fMask & MIIM_CHECKMARKS)
4430	{
4431	if (lpmii->fType & MFT_RADIOCHECK)
4432	menu->fType \|= MFT_RADIOCHECK;
4433
4434	menu->hCheckBit = lpmii->hbmpChecked;
4435	menu->hUnCheckBit = lpmii->hbmpUnchecked;
4436	}
4437	if (lpmii->fMask & MIIM_DATA)
4438	menu->dwItemData = lpmii->dwItemData;
4439
4440	debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4441	return TRUE;
4442	}
4443
4444	/**********************************************************************
4445	* SetMenuItemInfoA (USER32.@)
4446	*/
4447	BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4448	const MENUITEMINFOA *lpmii)
4449	{
4450	if ((lpmii->fType & (MF_HILITE\|MF_POPUP)) \|\| (lpmii->fState)) {
4451	/* QuickTime does pass invalid data into SetMenuItemInfo.
4452	* do some of the checks Windows does.
4453	*/
4454	WARN("Bad masks for type (0x%08x) or state (0x%08x)\n",
4455	lpmii->fType,lpmii->fState );
4456	return FALSE;
4457	}
4458
4459	return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4460	(const MENUITEMINFOW *)lpmii, FALSE);
4461	}
4462
4463	/**********************************************************************
4464	* SetMenuItemInfoW (USER32.@)
4465	*/
4466	BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4467	const MENUITEMINFOW *lpmii)
4468	{
4469	return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4470	lpmii, TRUE);
4471	}
4472
4473	/**********************************************************************
4474	* SetMenuDefaultItem (USER32.@)
4475	*
4476	*/
4477	BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4478	{
4479	UINT i;
4480	POPUPMENU *menu;
4481	MENUITEM *item;
4482
4483	TRACE("(0x%x,%d,%d)\n", hmenu, uItem, bypos);
4484
4485	if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4486
4487	/* reset all default-item flags */
4488	item = menu->items;
4489	for (i = 0; i < menu->nItems; i++, item++)
4490	{
4491	item->fState &= ~MFS_DEFAULT;
4492	}
4493
4494	/* no default item */
4495	if ( -1 == uItem)
4496	{
4497	return TRUE;
4498	}
4499
4500	item = menu->items;
4501	if ( bypos )
4502	{
4503	if ( uItem >= menu->nItems ) return FALSE;
4504	item[uItem].fState \|= MFS_DEFAULT;
4505	return TRUE;
4506	}
4507	else
4508	{
4509	for (i = 0; i < menu->nItems; i++, item++)
4510	{
4511	if (item->wID == uItem)
4512	{
4513	item->fState \|= MFS_DEFAULT;
4514	return TRUE;
4515	}
4516	}
4517
4518	}
4519	return FALSE;
4520	}
4521
4522	/**********************************************************************
4523	* GetMenuDefaultItem (USER32.@)
4524	*/
4525	UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4526	{
4527	POPUPMENU *menu;
4528	MENUITEM * item;
4529	UINT i = 0;
4530
4531	TRACE("(0x%x,%d,%d)\n", hmenu, bypos, flags);
4532
4533	if (!(menu = MENU_GetMenu(hmenu))) return -1;
4534
4535	/* find default item */
4536	item = menu->items;
4537
4538	/* empty menu */
4539	if (! item) return -1;
4540
4541	while ( !( item->fState & MFS_DEFAULT ) )
4542	{
4543	i++; item++;
4544	if (i >= menu->nItems ) return -1;
4545	}
4546
4547	/* default: don't return disabled items */
4548	if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4549
4550	/* search rekursiv when needed */
4551	if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4552	{
4553	UINT ret;
4554	ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4555	if ( -1 != ret ) return ret;
4556
4557	/* when item not found in submenu, return the popup item */
4558	}
4559	return ( bypos ) ? i : item->wID;
4560
4561	}
4562
4563	/*******************************************************************
4564	* InsertMenuItem (USER.441)
4565	*
4566	* FIXME: untested
4567	*/
4568	BOOL16 WINAPI InsertMenuItem16( HMENU16 hmenu, UINT16 pos, BOOL16 byposition,
4569	const MENUITEMINFO16 *mii )
4570	{
4571	MENUITEMINFOA miia;
4572
4573	miia.cbSize = sizeof(miia);
4574	miia.fMask = mii->fMask;
4575	miia.dwTypeData = (LPSTR)mii->dwTypeData;
4576	miia.fType = mii->fType;
4577	miia.fState = mii->fState;
4578	miia.wID = mii->wID;
4579	miia.hSubMenu = mii->hSubMenu;
4580	miia.hbmpChecked = mii->hbmpChecked;
4581	miia.hbmpUnchecked = mii->hbmpUnchecked;
4582	miia.dwItemData = mii->dwItemData;
4583	miia.cch = mii->cch;
4584	if (IS_STRING_ITEM(miia.fType))
4585	miia.dwTypeData = MapSL(mii->dwTypeData);
4586	return InsertMenuItemA( hmenu, pos, byposition, &miia );
4587	}
4588
4589
4590	/**********************************************************************
4591	* InsertMenuItemA (USER32.@)
4592	*/
4593	BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4594	const MENUITEMINFOA *lpmii)
4595	{
4596	MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4597	return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)lpmii, FALSE);
4598	}
4599
4600
4601	/**********************************************************************
4602	* InsertMenuItemW (USER32.@)
4603	*/
4604	BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4605	const MENUITEMINFOW *lpmii)
4606	{
4607	MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4608	return SetMenuItemInfo_common(item, lpmii, TRUE);
4609	}
4610
4611	/**********************************************************************
4612	* CheckMenuRadioItem (USER32.@)
4613	*/
4614
4615	BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4616	UINT first, UINT last, UINT check,
4617	UINT bypos)
4618	{
4619	MENUITEM mifirst, milast, *micheck;
4620	HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4621
4622	TRACE("ox%x: %d-%d, check %d, bypos=%d\n",
4623	hMenu, first, last, check, bypos);
4624
4625	mifirst = MENU_FindItem (&mfirst, &first, bypos);
4626	milast = MENU_FindItem (&mlast, &last, bypos);
4627	micheck = MENU_FindItem (&mcheck, &check, bypos);
4628
4629	if (mifirst == NULL \|\| milast == NULL \|\| micheck == NULL \|\|
4630	mifirst > milast \|\| mfirst != mlast \|\| mfirst != mcheck \|\|
4631	micheck > milast \|\| micheck < mifirst)
4632	return FALSE;
4633
4634	while (mifirst <= milast)
4635	{
4636	if (mifirst == micheck)
4637	{
4638	mifirst->fType \|= MFT_RADIOCHECK;
4639	mifirst->fState \|= MFS_CHECKED;
4640	} else {
4641	mifirst->fType &= ~MFT_RADIOCHECK;
4642	mifirst->fState &= ~MFS_CHECKED;
4643	}
4644	mifirst++;
4645	}
4646
4647	return TRUE;
4648	}
4649
4650	/**********************************************************************
4651	* CheckMenuRadioItem (USER.666)
4652	*/
4653	BOOL16 WINAPI CheckMenuRadioItem16(HMENU16 hMenu,
4654	UINT16 first, UINT16 last, UINT16 check,
4655	BOOL16 bypos)
4656	{
4657	return CheckMenuRadioItem (hMenu, first, last, check, bypos);
4658	}
4659
4660	/**********************************************************************
4661	* GetMenuItemRect (USER32.@)
4662	*
4663	* ATTENTION: Here, the returned values in rect are the screen
4664	* coordinates of the item just like if the menu was
4665	* always on the upper left side of the application.
4666	*
4667	*/
4668	BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4669	LPRECT rect)
4670	{
4671	POPUPMENU *itemMenu;
4672	MENUITEM *item;
4673	HWND referenceHwnd;
4674
4675	TRACE("(0x%x,0x%x,%d,%p)\n", hwnd, hMenu, uItem, rect);
4676
4677	item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4678	referenceHwnd = hwnd;
4679
4680	if(!hwnd)
4681	{
4682	itemMenu = MENU_GetMenu(hMenu);
4683	if (itemMenu == NULL)
4684	return FALSE;
4685
4686	if(itemMenu->hWnd == 0)
4687	return FALSE;
4688	referenceHwnd = itemMenu->hWnd;
4689	}
4690
4691	if ((rect == NULL) \|\| (item == NULL))
4692	return FALSE;
4693
4694	*rect = item->rect;
4695
4696	MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4697
4698	return TRUE;
4699	}
4700
4701
4702	/**********************************************************************
4703	* SetMenuInfo (USER32.@)
4704	*
4705	* FIXME
4706	* MIM_APPLYTOSUBMENUS
4707	* actually use the items to draw the menu
4708	*/
4709	BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4710	{
4711	POPUPMENU *menu;
4712
4713	TRACE("(0x%04x %p)\n", hMenu, lpmi);
4714
4715	if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4716	{
4717
4718	if (lpmi->fMask & MIM_BACKGROUND)
4719	menu->hbrBack = lpmi->hbrBack;
4720
4721	if (lpmi->fMask & MIM_HELPID)
4722	menu->dwContextHelpID = lpmi->dwContextHelpID;
4723
4724	if (lpmi->fMask & MIM_MAXHEIGHT)
4725	menu->cyMax = lpmi->cyMax;
4726
4727	if (lpmi->fMask & MIM_MENUDATA)
4728	menu->dwMenuData = lpmi->dwMenuData;
4729
4730	if (lpmi->fMask & MIM_STYLE)
4731	menu->dwStyle = lpmi->dwStyle;
4732
4733	return TRUE;
4734	}
4735	return FALSE;
4736	}
4737
4738	/**********************************************************************
4739	* GetMenuInfo (USER32.@)
4740	*
4741	* NOTES
4742	* win98/NT5.0
4743	*
4744	*/
4745	BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4746	{ POPUPMENU *menu;
4747
4748	TRACE("(0x%04x %p)\n", hMenu, lpmi);
4749
4750	if (lpmi && (menu = MENU_GetMenu(hMenu)))
4751	{
4752
4753	if (lpmi->fMask & MIM_BACKGROUND)
4754	lpmi->hbrBack = menu->hbrBack;
4755
4756	if (lpmi->fMask & MIM_HELPID)
4757	lpmi->dwContextHelpID = menu->dwContextHelpID;
4758
4759	if (lpmi->fMask & MIM_MAXHEIGHT)
4760	lpmi->cyMax = menu->cyMax;
4761
4762	if (lpmi->fMask & MIM_MENUDATA)
4763	lpmi->dwMenuData = menu->dwMenuData;
4764
4765	if (lpmi->fMask & MIM_STYLE)
4766	lpmi->dwStyle = menu->dwStyle;
4767
4768	return TRUE;
4769	}
4770	return FALSE;
4771	}
4772
4773	/**********************************************************************
4774	* SetMenuContextHelpId (USER.384)
4775	*/
4776	BOOL16 WINAPI SetMenuContextHelpId16( HMENU16 hMenu, DWORD dwContextHelpID)
4777	{
4778	return SetMenuContextHelpId( hMenu, dwContextHelpID );
4779	}
4780
4781
4782	/**********************************************************************
4783	* SetMenuContextHelpId (USER32.@)
4784	*/
4785	BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4786	{
4787	LPPOPUPMENU menu;
4788
4789	TRACE("(0x%04x 0x%08lx)\n", hMenu, dwContextHelpID);
4790
4791	if ((menu = MENU_GetMenu(hMenu)))
4792	{
4793	menu->dwContextHelpID = dwContextHelpID;
4794	return TRUE;
4795	}
4796	return FALSE;
4797	}
4798
4799	/**********************************************************************
4800	* GetMenuContextHelpId (USER.385)
4801	*/
4802	DWORD WINAPI GetMenuContextHelpId16( HMENU16 hMenu )
4803	{
4804	return GetMenuContextHelpId( hMenu );
4805	}
4806
4807	/**********************************************************************
4808	* GetMenuContextHelpId (USER32.@)
4809	*/
4810	DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4811	{
4812	LPPOPUPMENU menu;
4813
4814	TRACE("(0x%04x)\n", hMenu);
4815
4816	if ((menu = MENU_GetMenu(hMenu)))
4817	{
4818	return menu->dwContextHelpID;
4819	}
4820	return 0;
4821	}
4822
4823	/**********************************************************************
4824	* MenuItemFromPoint (USER32.@)
4825	*/
4826	UINT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
4827	{
4828	POPUPMENU *menu = MENU_GetMenu(hMenu);
4829	UINT pos;
4830	MENUITEM *item;
4831
4832	/FIXME: Do we have to handle hWnd here? /
4833	item = MENU_FindItemByCoords(menu, ptScreen, &pos);
4834
4835	return pos;
4836	}
4837
4838
4839	/**********************************************************************
4840	* translate_accelerator
4841	*/
4842	static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
4843	BYTE fVirt, WORD key, WORD cmd )
4844	{
4845	UINT mesg = 0;
4846
4847	if (wParam != key) return FALSE;
4848
4849	if (message == WM_CHAR)
4850	{
4851	if ( !(fVirt & FALT) && !(fVirt & FVIRTKEY) )
4852	{
4853	TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
4854	goto found;
4855	}
4856	}
4857	else
4858	{
4859	if(fVirt & FVIRTKEY)
4860	{
4861	INT mask = 0;
4862	TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
4863	wParam, 0xff & HIWORD(lParam));
4864	if(GetKeyState(VK_SHIFT) & 0x8000) mask \|= FSHIFT;
4865	if(GetKeyState(VK_CONTROL) & 0x8000) mask \|= FCONTROL;
4866	if(GetKeyState(VK_MENU) & 0x8000) mask \|= FALT;
4867	if(mask == (fVirt & (FSHIFT \| FCONTROL \| FALT))) goto found;
4868	TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
4869	}
4870	else
4871	{
4872	if (!(lParam & 0x01000000)) /* no special_key */
4873	{
4874	if ((fVirt & FALT) && (lParam & 0x20000000))
4875	{ /* ^^ ALT pressed */
4876	TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
4877	goto found;
4878	}
4879	}
4880	}
4881	}
4882	return FALSE;
4883
4884	found:
4885	if (message == WM_KEYUP \|\| message == WM_SYSKEYUP)
4886	mesg = 1;
4887	else if (GetCapture())
4888	mesg = 2;
4889	else if (!IsWindowEnabled(hWnd))
4890	mesg = 3;
4891	else
4892	{
4893	HMENU hMenu, hSubMenu, hSysMenu;
4894	UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
4895
4896	hMenu = (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
4897	hSysMenu = get_win_sys_menu( hWnd );
4898
4899	/* find menu item and ask application to initialize it */
4900	/* 1. in the system menu */
4901	hSubMenu = hSysMenu;
4902	nPos = cmd;
4903	if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4904	{
4905	SendMessageA(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
4906	if(hSubMenu != hSysMenu)
4907	{
4908	nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
4909	TRACE_(accel)("hSysMenu = %04x, hSubMenu = %04x, nPos = %d\n", hSysMenu, hSubMenu, nPos);
4910	SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
4911	}
4912	uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
4913	}
4914	else /* 2. in the window's menu */
4915	{
4916	hSubMenu = hMenu;
4917	nPos = cmd;
4918	if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4919	{
4920	SendMessageA(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
4921	if(hSubMenu != hMenu)
4922	{
4923	nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
4924	TRACE_(accel)("hMenu = %04x, hSubMenu = %04x, nPos = %d\n", hMenu, hSubMenu, nPos);
4925	SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
4926	}
4927	uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
4928	}
4929	}
4930
4931	if (uSysStat != (UINT)-1)
4932	{
4933	if (uSysStat & (MF_DISABLED\|MF_GRAYED))
4934	mesg=4;
4935	else
4936	mesg=WM_SYSCOMMAND;
4937	}
4938	else
4939	{
4940	if (uStat != (UINT)-1)
4941	{
4942	if (IsIconic(hWnd))
4943	mesg=5;
4944	else
4945	{
4946	if (uStat & (MF_DISABLED\|MF_GRAYED))
4947	mesg=6;
4948	else
4949	mesg=WM_COMMAND;
4950	}
4951	}
4952	else
4953	mesg=WM_COMMAND;
4954	}
4955	}
4956
4957	if( mesg==WM_COMMAND )
4958	{
4959	TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 \| cmd);
4960	SendMessageA(hWnd, mesg, 0x10000 \| cmd, 0L);
4961	}
4962	else if( mesg==WM_SYSCOMMAND )
4963	{
4964	TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
4965	SendMessageA(hWnd, mesg, cmd, 0x00010000L);
4966	}
4967	else
4968	{
4969	/* some reasons for NOT sending the WM_{SYS}COMMAND message:
4970	* #0: unknown (please report!)
4971	* #1: for WM_KEYUP,WM_SYSKEYUP
4972	* #2: mouse is captured
4973	* #3: window is disabled
4974	* #4: it's a disabled system menu option
4975	* #5: it's a menu option, but window is iconic
4976	* #6: it's a menu option, but disabled
4977	*/
4978	TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
4979	if(mesg==0)
4980	ERR_(accel)(" unknown reason - please report!");
4981	}
4982	return TRUE;
4983	}
4984
4985	/**********************************************************************
4986	* TranslateAccelerator (USER32.@)
4987	* TranslateAcceleratorA (USER32.@)
4988	* TranslateAcceleratorW (USER32.@)
4989	*/
4990	INT WINAPI TranslateAccelerator( HWND hWnd, HACCEL hAccel, LPMSG msg )
4991	{
4992	/* YES, Accel16! */
4993	LPACCEL16 lpAccelTbl;
4994	int i;
4995
4996	if (msg == NULL)
4997	{
4998	WARN_(accel)("msg null; should hang here to be win compatible\n");
4999	return 0;
5000	}
5001	if (!hAccel \|\| !(lpAccelTbl = (LPACCEL16) LockResource16(hAccel)))
5002	{
5003	WARN_(accel)("invalid accel handle=%x\n", hAccel);
5004	return 0;
5005	}
5006	if ((msg->message != WM_KEYDOWN &&
5007	msg->message != WM_KEYUP &&
5008	msg->message != WM_SYSKEYDOWN &&
5009	msg->message != WM_SYSKEYUP &&
5010	msg->message != WM_CHAR)) return 0;
5011
5012	TRACE_(accel)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5013	"msg->hwnd=%04x, msg->message=%04x, wParam=%08x, lParam=%lx\n",
5014	hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5015
5016	i = 0;
5017	do
5018	{
5019	if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
5020	lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
5021	return 1;
5022	} while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
5023	WARN_(accel)("couldn't translate accelerator key\n");
5024	return 0;
5025	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: