Release 20040408.
[wine.git] / controls / menu.c
blob659b15b676ea01879db9a864e55b6187770ae8d1
1 /*
2 * Menu functions
4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994 Alexandre Julliard
6 * Copyright 1997 Morten Welinder
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.
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.
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
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.
29 #include "config.h"
30 #include "wine/port.h"
32 #include <stdarg.h>
33 #include <string.h>
35 #include "windef.h"
36 #include "winbase.h"
37 #include "wingdi.h"
38 #include "winnls.h"
39 #include "wine/winbase16.h"
40 #include "wine/winuser16.h"
41 #include "wownt32.h"
42 #include "wine/server.h"
43 #include "wine/unicode.h"
44 #include "win.h"
45 #include "controls.h"
46 #include "nonclient.h"
47 #include "user.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(menu);
51 WINE_DECLARE_DEBUG_CHANNEL(accel);
53 /* internal popup menu window messages */
55 #define MM_SETMENUHANDLE (WM_USER + 0)
56 #define MM_GETMENUHANDLE (WM_USER + 1)
58 /* Menu item structure */
59 typedef struct {
60 /* ----------- MENUITEMINFO Stuff ----------- */
61 UINT fType; /* Item type. */
62 UINT fState; /* Item state. */
63 UINT_PTR wID; /* Item id. */
64 HMENU hSubMenu; /* Pop-up menu. */
65 HBITMAP hCheckBit; /* Bitmap when checked. */
66 HBITMAP hUnCheckBit; /* Bitmap when unchecked. */
67 LPWSTR text; /* Item text or bitmap handle. */
68 DWORD dwItemData; /* Application defined. */
69 DWORD dwTypeData; /* depends on fMask */
70 HBITMAP hbmpItem; /* bitmap in win98 style menus */
71 /* ----------- Wine stuff ----------- */
72 RECT rect; /* Item area (relative to menu window) */
73 UINT xTab; /* X position of text after Tab */
74 } MENUITEM;
76 /* Popup menu structure */
77 typedef struct {
78 WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
79 WORD wMagic; /* Magic number */
80 WORD Width; /* Width of the whole menu */
81 WORD Height; /* Height of the whole menu */
82 UINT nItems; /* Number of items in the menu */
83 HWND hWnd; /* Window containing the menu */
84 MENUITEM *items; /* Array of menu items */
85 UINT FocusedItem; /* Currently focused item */
86 HWND hwndOwner; /* window receiving the messages for ownerdraw */
87 BOOL bTimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
88 /* ------------ MENUINFO members ------ */
89 DWORD dwStyle; /* Extended mennu style */
90 UINT cyMax; /* max hight of the whole menu, 0 is screen hight */
91 HBRUSH hbrBack; /* brush for menu background */
92 DWORD dwContextHelpID;
93 DWORD dwMenuData; /* application defined value */
94 HMENU hSysMenuOwner; /* Handle to the dummy sys menu holder */
95 } POPUPMENU, *LPPOPUPMENU;
97 /* internal flags for menu tracking */
99 #define TF_ENDMENU 0x0001
100 #define TF_SUSPENDPOPUP 0x0002
101 #define TF_SKIPREMOVE 0x0004
103 typedef struct
105 UINT trackFlags;
106 HMENU hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
107 HMENU hTopMenu; /* initial menu */
108 HWND hOwnerWnd; /* where notifications are sent */
109 POINT pt;
110 } MTRACKER;
112 #define MENU_MAGIC 0x554d /* 'MU' */
114 #define ITEM_PREV -1
115 #define ITEM_NEXT 1
117 /* Internal MENU_TrackMenu() flags */
118 #define TPM_INTERNAL 0xF0000000
119 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
120 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
121 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
123 /* popup menu shade thickness */
124 #define POPUP_XSHADE 4
125 #define POPUP_YSHADE 4
127 /* Space between 2 menu bar items */
128 #define MENU_BAR_ITEMS_SPACE 12
130 /* Minimum width of a tab character */
131 #define MENU_TAB_SPACE 8
133 /* Height of a separator item */
134 #define SEPARATOR_HEIGHT 5
136 /* (other menu->FocusedItem values give the position of the focused item) */
137 #define NO_SELECTED_ITEM 0xffff
139 #define MENU_ITEM_TYPE(flags) \
140 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
142 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
143 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
144 #define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
146 #define IS_SYSTEM_MENU(menu) \
147 (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
149 #define IS_SYSTEM_POPUP(menu) \
150 ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
152 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
153 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
154 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
155 MF_POPUP | MF_SYSMENU | MF_HELP)
156 #define STATE_MASK (~TYPE_MASK)
158 /* Dimension of the menu bitmaps */
159 static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
161 static HBITMAP hStdMnArrow = 0;
162 static HBITMAP hBmpSysMenu = 0;
164 static HBRUSH hShadeBrush = 0;
165 static HFONT hMenuFont = 0;
166 static HFONT hMenuFontBold = 0;
168 static HMENU MENU_DefSysPopup = 0; /* Default system menu popup */
170 /* Use global popup window because there's no way 2 menus can
171 * be tracked at the same time. */
172 static HWND top_popup;
174 /* Flag set by EndMenu() to force an exit from menu tracking */
175 static BOOL fEndMenu = FALSE;
177 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
179 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont);
181 /*********************************************************************
182 * menu class descriptor
184 const struct builtin_class_descr MENU_builtin_class =
186 POPUPMENU_CLASS_ATOMA, /* name */
187 CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS, /* style */
188 NULL, /* procA (winproc is Unicode only) */
189 PopupMenuWndProc, /* procW */
190 sizeof(HMENU), /* extra */
191 IDC_ARROW, /* cursor */
192 (HBRUSH)(COLOR_MENU+1) /* brush */
196 /***********************************************************************
197 * debug_print_menuitem
199 * Print a menuitem in readable form.
202 #define debug_print_menuitem(pre, mp, post) \
203 if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
205 #define MENUOUT(text) \
206 DPRINTF("%s%s", (count++ ? "," : ""), (text))
208 #define MENUFLAG(bit,text) \
209 do { \
210 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
211 } while (0)
213 static void do_debug_print_menuitem(const char *prefix, MENUITEM * mp,
214 const char *postfix)
216 TRACE("%s ", prefix);
217 if (mp) {
218 UINT flags = mp->fType;
219 int type = MENU_ITEM_TYPE(flags);
220 DPRINTF( "{ ID=0x%x", mp->wID);
221 if (flags & MF_POPUP)
222 DPRINTF( ", Sub=%p", mp->hSubMenu);
223 if (flags) {
224 int count = 0;
225 DPRINTF( ", Type=");
226 if (type == MFT_STRING)
227 /* Nothing */ ;
228 else if (type == MFT_SEPARATOR)
229 MENUOUT("sep");
230 else if (type == MFT_OWNERDRAW)
231 MENUOUT("own");
232 else if (type == MFT_BITMAP)
233 MENUOUT("bit");
234 else
235 MENUOUT("???");
236 flags -= type;
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 */
246 if (flags)
247 DPRINTF( "+0x%x", flags);
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);
263 if (mp->hCheckBit)
264 DPRINTF( ", Chk=%p", mp->hCheckBit);
265 if (mp->hUnCheckBit)
266 DPRINTF( ", Unc=%p", mp->hUnCheckBit);
268 if (type == 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");
284 DPRINTF(" %s\n", postfix);
287 #undef MENUOUT
288 #undef MENUFLAG
291 /***********************************************************************
292 * MENU_GetMenu
294 * Validate the given menu handle and returns the menu structure pointer.
296 static POPUPMENU *MENU_GetMenu(HMENU hMenu)
298 POPUPMENU *menu = USER_HEAP_LIN_ADDR(hMenu);
299 if (!menu || menu->wMagic != MENU_MAGIC)
301 WARN("invalid menu handle=%p, ptr=%p, magic=%x\n", hMenu, menu, menu? menu->wMagic:0);
302 menu = NULL;
304 return menu;
307 /***********************************************************************
308 * get_win_sys_menu
310 * Get the system menu of a window
312 static HMENU get_win_sys_menu( HWND hwnd )
314 HMENU ret = 0;
315 WND *win = WIN_FindWndPtr( hwnd );
316 if (win)
318 ret = win->hSysMenu;
319 WIN_ReleaseWndPtr( win );
321 return ret;
324 /***********************************************************************
325 * MENU_CopySysPopup
327 * Return the default system menu.
329 static HMENU MENU_CopySysPopup(void)
331 static const WCHAR sysmenuW[] = {'S','Y','S','M','E','N','U',0};
332 HMENU hMenu = LoadMenuW(user32_module, sysmenuW);
334 if( hMenu ) {
335 POPUPMENU* menu = MENU_GetMenu(hMenu);
336 menu->wFlags |= MF_SYSMENU | MF_POPUP;
337 SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
339 else
340 ERR("Unable to load default system menu\n" );
342 TRACE("returning %p.\n", hMenu );
344 return hMenu;
348 /**********************************************************************
349 * MENU_GetSysMenu
351 * Create a copy of the system menu. System menu in Windows is
352 * a special menu bar with the single entry - system menu popup.
353 * This popup is presented to the outside world as a "system menu".
354 * However, the real system menu handle is sometimes seen in the
355 * WM_MENUSELECT parameters (and Word 6 likes it this way).
357 HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
359 HMENU hMenu;
361 TRACE("loading system menu, hWnd %p, hPopupMenu %p\n", hWnd, hPopupMenu);
362 if ((hMenu = CreateMenu()))
364 POPUPMENU *menu = MENU_GetMenu(hMenu);
365 menu->wFlags = MF_SYSMENU;
366 menu->hWnd = WIN_GetFullHandle( hWnd );
367 TRACE("hWnd %p (hMenu %p)\n", menu->hWnd, hMenu);
369 if (hPopupMenu == (HMENU)(-1))
370 hPopupMenu = MENU_CopySysPopup();
371 else if( !hPopupMenu ) hPopupMenu = MENU_DefSysPopup;
373 if (hPopupMenu)
375 InsertMenuW( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION,
376 (UINT_PTR)hPopupMenu, NULL );
378 menu->items[0].fType = MF_SYSMENU | MF_POPUP;
379 menu->items[0].fState = 0;
380 if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags |= MF_SYSMENU;
382 TRACE("hMenu=%p (hPopup %p)\n", hMenu, hPopupMenu );
383 return hMenu;
385 DestroyMenu( hMenu );
387 ERR("failed to load system menu!\n");
388 return 0;
392 /***********************************************************************
393 * MENU_Init
395 * Menus initialisation.
397 BOOL MENU_Init(void)
399 HBITMAP hBitmap;
400 NONCLIENTMETRICSW ncm;
402 static unsigned char shade_bits[16] = { 0x55, 0, 0xAA, 0,
403 0x55, 0, 0xAA, 0,
404 0x55, 0, 0xAA, 0,
405 0x55, 0, 0xAA, 0 };
407 /* Load menu bitmaps */
408 hStdMnArrow = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW));
409 /* Load system buttons bitmaps */
410 hBmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
412 if (hStdMnArrow)
414 BITMAP bm;
415 GetObjectW( hStdMnArrow, sizeof(bm), &bm );
416 arrow_bitmap_width = bm.bmWidth;
417 arrow_bitmap_height = bm.bmHeight;
418 } else
419 return FALSE;
421 if (! (hBitmap = CreateBitmap( 8, 8, 1, 1, shade_bits)))
422 return FALSE;
424 if(!(hShadeBrush = CreatePatternBrush( hBitmap )))
425 return FALSE;
427 DeleteObject( hBitmap );
428 if (!(MENU_DefSysPopup = MENU_CopySysPopup()))
429 return FALSE;
431 ncm.cbSize = sizeof(NONCLIENTMETRICSW);
432 if (!(SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSW), &ncm, 0)))
433 return FALSE;
435 if (!(hMenuFont = CreateFontIndirectW( &ncm.lfMenuFont )))
436 return FALSE;
438 ncm.lfMenuFont.lfWeight += 300;
439 if ( ncm.lfMenuFont.lfWeight > 1000)
440 ncm.lfMenuFont.lfWeight = 1000;
442 if (!(hMenuFontBold = CreateFontIndirectW( &ncm.lfMenuFont )))
443 return FALSE;
445 return TRUE;
448 /***********************************************************************
449 * MENU_InitSysMenuPopup
451 * Grey the appropriate items in System menu.
453 static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
455 BOOL gray;
457 gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
458 EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
459 gray = ((style & WS_MAXIMIZE) != 0);
460 EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
461 gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
462 EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
463 gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
464 EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
465 gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
466 EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
467 gray = (clsStyle & CS_NOCLOSE) != 0;
469 /* The menu item must keep its state if it's disabled */
470 if(gray)
471 EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
475 /******************************************************************************
477 * UINT MENU_GetStartOfNextColumn(
478 * HMENU hMenu )
480 *****************************************************************************/
482 static UINT MENU_GetStartOfNextColumn(
483 HMENU hMenu )
485 POPUPMENU *menu = MENU_GetMenu(hMenu);
486 UINT i;
488 if(!menu)
489 return NO_SELECTED_ITEM;
491 i = menu->FocusedItem + 1;
492 if( i == NO_SELECTED_ITEM )
493 return i;
495 for( ; i < menu->nItems; ++i ) {
496 if (menu->items[i].fType & MF_MENUBARBREAK)
497 return i;
500 return NO_SELECTED_ITEM;
504 /******************************************************************************
506 * UINT MENU_GetStartOfPrevColumn(
507 * HMENU hMenu )
509 *****************************************************************************/
511 static UINT MENU_GetStartOfPrevColumn(
512 HMENU hMenu )
514 POPUPMENU *menu = MENU_GetMenu(hMenu);
515 UINT i;
517 if( !menu )
518 return NO_SELECTED_ITEM;
520 if( menu->FocusedItem == 0 || menu->FocusedItem == NO_SELECTED_ITEM )
521 return NO_SELECTED_ITEM;
523 /* Find the start of the column */
525 for(i = menu->FocusedItem; i != 0 &&
526 !(menu->items[i].fType & MF_MENUBARBREAK);
527 --i); /* empty */
529 if(i == 0)
530 return NO_SELECTED_ITEM;
532 for(--i; i != 0; --i) {
533 if (menu->items[i].fType & MF_MENUBARBREAK)
534 break;
537 TRACE("ret %d.\n", i );
539 return i;
544 /***********************************************************************
545 * MENU_FindItem
547 * Find a menu item. Return a pointer on the item, and modifies *hmenu
548 * in case the item was in a sub-menu.
550 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
552 POPUPMENU *menu;
553 UINT i;
555 if ((*hmenu == (HMENU)0xffff) || (!(menu = MENU_GetMenu(*hmenu)))) return NULL;
556 if (wFlags & MF_BYPOSITION)
558 if (*nPos >= menu->nItems) return NULL;
559 return &menu->items[*nPos];
561 else
563 MENUITEM *item = menu->items;
564 for (i = 0; i < menu->nItems; i++, item++)
566 if (item->wID == *nPos)
568 *nPos = i;
569 return item;
571 else if (item->fType & MF_POPUP)
573 HMENU hsubmenu = item->hSubMenu;
574 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
575 if (subitem)
577 *hmenu = hsubmenu;
578 return subitem;
583 return NULL;
586 /***********************************************************************
587 * MENU_FindSubMenu
589 * Find a Sub menu. Return the position of the submenu, and modifies
590 * *hmenu in case it is found in another sub-menu.
591 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
593 UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
595 POPUPMENU *menu;
596 UINT i;
597 MENUITEM *item;
598 if (((*hmenu)==(HMENU)0xffff) ||
599 (!(menu = MENU_GetMenu(*hmenu))))
600 return NO_SELECTED_ITEM;
601 item = menu->items;
602 for (i = 0; i < menu->nItems; i++, item++) {
603 if(!(item->fType & MF_POPUP)) continue;
604 if (item->hSubMenu == hSubTarget) {
605 return i;
607 else {
608 HMENU hsubmenu = item->hSubMenu;
609 UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
610 if (pos != NO_SELECTED_ITEM) {
611 *hmenu = hsubmenu;
612 return pos;
616 return NO_SELECTED_ITEM;
619 /***********************************************************************
620 * MENU_FreeItemData
622 static void MENU_FreeItemData( MENUITEM* item )
624 /* delete text */
625 if (IS_STRING_ITEM(item->fType) && item->text)
626 HeapFree( GetProcessHeap(), 0, item->text );
629 /***********************************************************************
630 * MENU_FindItemByCoords
632 * Find the item at the specified coordinates (screen coords). Does
633 * not work for child windows and therefore should not be called for
634 * an arbitrary system menu.
636 static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu,
637 POINT pt, UINT *pos )
639 MENUITEM *item;
640 UINT i;
641 RECT wrect;
643 if (!GetWindowRect(menu->hWnd,&wrect)) return NULL;
644 pt.x -= wrect.left;pt.y -= wrect.top;
645 item = menu->items;
646 for (i = 0; i < menu->nItems; i++, item++)
648 if ((pt.x >= item->rect.left) && (pt.x < item->rect.right) &&
649 (pt.y >= item->rect.top) && (pt.y < item->rect.bottom))
651 if (pos) *pos = i;
652 return item;
655 return NULL;
659 /***********************************************************************
660 * MENU_FindItemByKey
662 * Find the menu item selected by a key press.
663 * Return item id, -1 if none, -2 if we should close the menu.
665 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu,
666 WCHAR key, BOOL forceMenuChar )
668 TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)key, key, hmenu );
670 if (!IsMenu( hmenu )) hmenu = GetSubMenu( get_win_sys_menu(hwndOwner), 0);
672 if (hmenu)
674 POPUPMENU *menu = MENU_GetMenu( hmenu );
675 MENUITEM *item = menu->items;
676 LRESULT menuchar;
678 if( !forceMenuChar )
680 UINT i;
682 key = toupperW(key);
683 for (i = 0; i < menu->nItems; i++, item++)
685 if (IS_STRING_ITEM(item->fType) && item->text)
687 WCHAR *p = item->text - 2;
690 p = strchrW (p + 2, '&');
692 while (p != NULL && p [1] == '&');
693 if (p && (toupperW(p[1]) == key)) return i;
697 menuchar = SendMessageW( hwndOwner, WM_MENUCHAR,
698 MAKEWPARAM( key, menu->wFlags ), (LPARAM)hmenu );
699 if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
700 if (HIWORD(menuchar) == 1) return (UINT)(-2);
702 return (UINT)(-1);
706 /***********************************************************************
707 * MENU_GetBitmapItemSize
709 * Get the size of a bitmap item.
711 static void MENU_GetBitmapItemSize( UINT id, DWORD data, SIZE *size )
713 BITMAP bm;
714 HBITMAP bmp = (HBITMAP)id;
716 size->cx = size->cy = 0;
718 /* check if there is a magic menu item associated with this item */
719 if (id && IS_MAGIC_ITEM( id ))
721 switch(LOWORD(id))
723 case (INT_PTR)HBMMENU_SYSTEM:
724 if (data)
726 bmp = (HBITMAP)data;
727 break;
729 /* fall through */
730 case (INT_PTR)HBMMENU_MBAR_RESTORE:
731 case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
732 case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
733 case (INT_PTR)HBMMENU_MBAR_CLOSE:
734 case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
735 size->cx = GetSystemMetrics( SM_CXSIZE );
736 size->cy = GetSystemMetrics( SM_CYSIZE );
737 return;
738 case (INT_PTR)HBMMENU_CALLBACK:
739 case (INT_PTR)HBMMENU_POPUP_CLOSE:
740 case (INT_PTR)HBMMENU_POPUP_RESTORE:
741 case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
742 case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
743 default:
744 FIXME("Magic 0x%08x not implemented\n", id);
745 return;
748 if (GetObjectW(bmp, sizeof(bm), &bm ))
750 size->cx = bm.bmWidth;
751 size->cy = bm.bmHeight;
755 /***********************************************************************
756 * MENU_DrawBitmapItem
758 * Draw a bitmap item.
760 static void MENU_DrawBitmapItem( HDC hdc, MENUITEM *lpitem, const RECT *rect, BOOL menuBar )
762 BITMAP bm;
763 DWORD rop;
764 HDC hdcMem;
765 HBITMAP bmp = (HBITMAP)lpitem->text;
766 int w = rect->right - rect->left;
767 int h = rect->bottom - rect->top;
768 int bmp_xoffset = 0;
769 int left, top;
771 /* Check if there is a magic menu item associated with this item */
772 if (lpitem->text && IS_MAGIC_ITEM(lpitem->text))
774 UINT flags = 0;
775 RECT r;
777 switch(LOWORD(lpitem->text))
779 case (INT_PTR)HBMMENU_SYSTEM:
780 if (lpitem->dwItemData)
782 bmp = (HBITMAP)lpitem->dwItemData;
783 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
785 else
787 bmp = hBmpSysMenu;
788 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
789 /* only use right half of the bitmap */
790 bmp_xoffset = bm.bmWidth / 2;
791 bm.bmWidth -= bmp_xoffset;
793 goto got_bitmap;
794 case (INT_PTR)HBMMENU_MBAR_RESTORE:
795 flags = DFCS_CAPTIONRESTORE;
796 break;
797 case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
798 flags = DFCS_CAPTIONMIN;
799 break;
800 case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
801 flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
802 break;
803 case (INT_PTR)HBMMENU_MBAR_CLOSE:
804 flags = DFCS_CAPTIONCLOSE;
805 break;
806 case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
807 flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
808 break;
809 case (INT_PTR)HBMMENU_CALLBACK:
810 case (INT_PTR)HBMMENU_POPUP_CLOSE:
811 case (INT_PTR)HBMMENU_POPUP_RESTORE:
812 case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
813 case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
814 default:
815 FIXME("Magic 0x%08x not implemented\n", LOWORD(lpitem->text));
816 return;
818 r = *rect;
819 InflateRect( &r, -1, -1 );
820 if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
821 DrawFrameControl( hdc, &r, DFC_CAPTION, flags );
822 return;
825 if (!bmp || !GetObjectW( bmp, sizeof(bm), &bm )) return;
827 got_bitmap:
828 hdcMem = CreateCompatibleDC( hdc );
829 SelectObject( hdcMem, bmp );
831 /* handle fontsize > bitmap_height */
832 top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
833 left=rect->left;
834 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(lpitem->text)) ? NOTSRCCOPY : SRCCOPY;
835 if ((lpitem->fState & MF_HILITE) && IS_BITMAP_ITEM(lpitem->fType))
836 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
837 BitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop );
838 DeleteDC( hdcMem );
842 /***********************************************************************
843 * MENU_CalcItemSize
845 * Calculate the size of the menu item and store it in lpitem->rect.
847 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
848 INT orgX, INT orgY, BOOL menuBar )
850 WCHAR *p;
851 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
853 TRACE("dc=%p owner=%p (%d,%d)\n", hdc, hwndOwner, orgX, orgY);
854 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem,
855 (menuBar ? " (MenuBar)" : ""));
857 SetRect( &lpitem->rect, orgX, orgY, orgX, orgY );
859 if (lpitem->fType & MF_OWNERDRAW)
862 ** Experimentation under Windows reveals that an owner-drawn
863 ** menu is expected to return the size of the content part of
864 ** the menu item, not including the checkmark nor the submenu
865 ** arrow. Windows adds those values itself and returns the
866 ** enlarged rectangle on subsequent WM_DRAWITEM messages.
868 MEASUREITEMSTRUCT mis;
869 mis.CtlType = ODT_MENU;
870 mis.CtlID = 0;
871 mis.itemID = lpitem->wID;
872 mis.itemData = (DWORD)lpitem->dwItemData;
873 mis.itemHeight = 0;
874 mis.itemWidth = 0;
875 SendMessageW( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&mis );
876 lpitem->rect.right += mis.itemWidth;
878 if (menuBar)
880 lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
883 /* under at least win95 you seem to be given a standard
884 height for the menu and the height value is ignored */
885 lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU)-1;
887 else
888 lpitem->rect.bottom += mis.itemHeight;
890 TRACE("id=%04x size=%dx%d\n",
891 lpitem->wID, mis.itemWidth, mis.itemHeight);
892 /* Fall through to get check/arrow width calculation. */
895 if (lpitem->fType & MF_SEPARATOR)
897 lpitem->rect.bottom += SEPARATOR_HEIGHT;
898 return;
901 if (!menuBar)
903 lpitem->rect.right += 2 * check_bitmap_width;
904 if (lpitem->fType & MF_POPUP)
905 lpitem->rect.right += arrow_bitmap_width;
908 if (lpitem->fType & MF_OWNERDRAW)
909 return;
911 if (IS_BITMAP_ITEM(lpitem->fType))
913 SIZE size;
915 MENU_GetBitmapItemSize( (int)lpitem->text, lpitem->dwItemData, &size );
916 lpitem->rect.right += size.cx;
917 lpitem->rect.bottom += size.cy;
918 /* Leave space for the sunken border */
919 lpitem->rect.right += 2;
920 lpitem->rect.bottom += 2;
924 /* it must be a text item - unless it's the system menu */
925 if (!(lpitem->fType & MF_SYSMENU) && IS_STRING_ITEM( lpitem->fType ))
926 { SIZE size;
928 GetTextExtentPoint32W(hdc, lpitem->text, strlenW(lpitem->text), &size);
930 lpitem->rect.right += size.cx;
931 lpitem->rect.bottom += max(size.cy, GetSystemMetrics(SM_CYMENU)-1);
932 lpitem->xTab = 0;
934 if (menuBar)
936 lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
938 else if ((p = strchrW( lpitem->text, '\t' )) != NULL)
940 /* Item contains a tab (only meaningful in popup menus) */
941 GetTextExtentPoint32W(hdc, lpitem->text, (int)(p - lpitem->text) , &size);
942 lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE + size.cx;
943 lpitem->rect.right += MENU_TAB_SPACE;
945 else
947 if (strchrW( lpitem->text, '\b' ))
948 lpitem->rect.right += MENU_TAB_SPACE;
949 lpitem->xTab = lpitem->rect.right - check_bitmap_width
950 - arrow_bitmap_width;
953 TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem->rect.left, lpitem->rect.top, lpitem->rect.right, lpitem->rect.bottom);
957 /***********************************************************************
958 * MENU_PopupMenuCalcSize
960 * Calculate the size of a popup menu.
962 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
964 MENUITEM *lpitem;
965 HDC hdc;
966 int start, i;
967 int orgX, orgY, maxX, maxTab, maxTabWidth;
969 lppop->Width = lppop->Height = 0;
970 if (lppop->nItems == 0) return;
971 hdc = GetDC( 0 );
973 SelectObject( hdc, hMenuFont);
975 start = 0;
976 maxX = 2 + 1;
978 while (start < lppop->nItems)
980 lpitem = &lppop->items[start];
981 orgX = maxX;
982 orgY = 2;
984 maxTab = maxTabWidth = 0;
986 /* Parse items until column break or end of menu */
987 for (i = start; i < lppop->nItems; i++, lpitem++)
989 if ((i != start) &&
990 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
992 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE );
994 if (lpitem->fType & MF_MENUBARBREAK) orgX++;
995 maxX = max( maxX, lpitem->rect.right );
996 orgY = lpitem->rect.bottom;
997 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
999 maxTab = max( maxTab, lpitem->xTab );
1000 maxTabWidth = max(maxTabWidth,lpitem->rect.right-lpitem->xTab);
1004 /* Finish the column (set all items to the largest width found) */
1005 maxX = max( maxX, maxTab + maxTabWidth );
1006 for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
1008 lpitem->rect.right = maxX;
1009 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1010 lpitem->xTab = maxTab;
1013 lppop->Height = max( lppop->Height, orgY );
1016 lppop->Width = maxX;
1018 /* space for 3d border */
1019 lppop->Height += 2;
1020 lppop->Width += 2;
1022 ReleaseDC( 0, hdc );
1026 /***********************************************************************
1027 * MENU_MenuBarCalcSize
1029 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1030 * height is off by 1 pixel which causes lengthy window relocations when
1031 * active document window is maximized/restored.
1033 * Calculate the size of the menu bar.
1035 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect,
1036 LPPOPUPMENU lppop, HWND hwndOwner )
1038 MENUITEM *lpitem;
1039 int start, i, orgX, orgY, maxY, helpPos;
1041 if ((lprect == NULL) || (lppop == NULL)) return;
1042 if (lppop->nItems == 0) return;
1043 TRACE("left=%ld top=%ld right=%ld bottom=%ld\n",
1044 lprect->left, lprect->top, lprect->right, lprect->bottom);
1045 lppop->Width = lprect->right - lprect->left;
1046 lppop->Height = 0;
1047 maxY = lprect->top+1;
1048 start = 0;
1049 helpPos = -1;
1050 while (start < lppop->nItems)
1052 lpitem = &lppop->items[start];
1053 orgX = lprect->left;
1054 orgY = maxY;
1056 /* Parse items until line break or end of menu */
1057 for (i = start; i < lppop->nItems; i++, lpitem++)
1059 if ((helpPos == -1) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1060 if ((i != start) &&
1061 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1063 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1064 orgX, orgY );
1065 debug_print_menuitem (" item: ", lpitem, "");
1066 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE );
1068 if (lpitem->rect.right > lprect->right)
1070 if (i != start) break;
1071 else lpitem->rect.right = lprect->right;
1073 maxY = max( maxY, lpitem->rect.bottom );
1074 orgX = lpitem->rect.right;
1077 /* Finish the line (set all items to the largest height found) */
1078 while (start < i) lppop->items[start++].rect.bottom = maxY;
1081 lprect->bottom = maxY;
1082 lppop->Height = lprect->bottom - lprect->top;
1084 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1085 /* the last item (if several lines, only move the last line) */
1086 lpitem = &lppop->items[lppop->nItems-1];
1087 orgY = lpitem->rect.top;
1088 orgX = lprect->right;
1089 for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
1090 if ( (helpPos==-1) || (helpPos>i) )
1091 break; /* done */
1092 if (lpitem->rect.top != orgY) break; /* Other line */
1093 if (lpitem->rect.right >= orgX) break; /* Too far right already */
1094 lpitem->rect.left += orgX - lpitem->rect.right;
1095 lpitem->rect.right = orgX;
1096 orgX = lpitem->rect.left;
1100 /***********************************************************************
1101 * MENU_DrawMenuItem
1103 * Draw a single menu item.
1105 static void MENU_DrawMenuItem( HWND hwnd, HMENU hmenu, HWND hwndOwner, HDC hdc, MENUITEM *lpitem,
1106 UINT height, BOOL menuBar, UINT odaction )
1108 RECT rect;
1110 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem, "");
1112 if (lpitem->fType & MF_SYSMENU)
1114 if( !IsIconic(hwnd) )
1115 NC_DrawSysButton( hwnd, hdc, lpitem->fState & (MF_HILITE | MF_MOUSESELECT) );
1116 return;
1119 if (lpitem->fType & MF_OWNERDRAW)
1122 ** Experimentation under Windows reveals that an owner-drawn
1123 ** menu is given the rectangle which includes the space it requested
1124 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1125 ** and a popup-menu arrow. This is the value of lpitem->rect.
1126 ** Windows will leave all drawing to the application except for
1127 ** the popup-menu arrow. Windows always draws that itself, after
1128 ** the menu owner has finished drawing.
1130 DRAWITEMSTRUCT dis;
1132 dis.CtlType = ODT_MENU;
1133 dis.CtlID = 0;
1134 dis.itemID = lpitem->wID;
1135 dis.itemData = (DWORD)lpitem->dwItemData;
1136 dis.itemState = 0;
1137 if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
1138 if (lpitem->fState & MF_GRAYED) dis.itemState |= ODS_GRAYED|ODS_DISABLED;
1139 if (lpitem->fState & MF_HILITE) dis.itemState |= ODS_SELECTED;
1140 dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1141 dis.hwndItem = (HWND)hmenu;
1142 dis.hDC = hdc;
1143 dis.rcItem = lpitem->rect;
1144 TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
1145 "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", hwndOwner,
1146 dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
1147 dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
1148 dis.rcItem.bottom);
1149 SendMessageW( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&dis );
1150 /* Fall through to draw popup-menu arrow */
1153 TRACE("rect={%ld,%ld,%ld,%ld}\n", lpitem->rect.left, lpitem->rect.top,
1154 lpitem->rect.right,lpitem->rect.bottom);
1156 if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
1158 rect = lpitem->rect;
1160 if (!(lpitem->fType & MF_OWNERDRAW))
1162 if (lpitem->fState & MF_HILITE)
1164 if(menuBar)
1165 DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
1166 else
1167 FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1169 else
1170 FillRect( hdc, &rect, GetSysColorBrush(COLOR_MENU) );
1173 SetBkMode( hdc, TRANSPARENT );
1175 if (!(lpitem->fType & MF_OWNERDRAW))
1177 /* vertical separator */
1178 if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
1180 RECT rc = rect;
1181 rc.top = 3;
1182 rc.bottom = height - 3;
1183 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
1186 /* horizontal separator */
1187 if (lpitem->fType & MF_SEPARATOR)
1189 RECT rc = rect;
1190 rc.left++;
1191 rc.right--;
1192 rc.top += SEPARATOR_HEIGHT / 2;
1193 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
1194 return;
1198 /* Setup colors */
1200 if (lpitem->fState & MF_HILITE)
1202 if(menuBar) {
1203 SetTextColor(hdc, GetSysColor(COLOR_MENUTEXT));
1204 SetBkColor(hdc, GetSysColor(COLOR_MENU));
1205 } else {
1206 if(lpitem->fState & MF_GRAYED)
1207 SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1208 else
1209 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1210 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1213 else
1215 if (lpitem->fState & MF_GRAYED)
1216 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1217 else
1218 SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
1219 SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
1222 /* helper lines for debugging */
1223 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1224 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1225 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1226 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1229 if (!menuBar)
1231 INT y = rect.top + rect.bottom;
1232 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1233 UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1235 if (!(lpitem->fType & MF_OWNERDRAW))
1237 /* Draw the check mark
1239 * FIXME:
1240 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1242 HBITMAP bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit : lpitem->hUnCheckBit;
1243 if (bm) /* we have a custom bitmap */
1245 HDC hdcMem = CreateCompatibleDC( hdc );
1246 SelectObject( hdcMem, bm );
1247 BitBlt( hdc, rect.left, (y - check_bitmap_height) / 2,
1248 check_bitmap_width, check_bitmap_height,
1249 hdcMem, 0, 0, SRCCOPY );
1250 DeleteDC( hdcMem );
1252 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
1254 RECT r;
1255 HBITMAP bm = CreateBitmap( check_bitmap_width, check_bitmap_height, 1, 1, NULL );
1256 HDC hdcMem = CreateCompatibleDC( hdc );
1257 SelectObject( hdcMem, bm );
1258 SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height );
1259 DrawFrameControl( hdcMem, &r, DFC_MENU,
1260 (lpitem->fType & MFT_RADIOCHECK) ?
1261 DFCS_MENUBULLET : DFCS_MENUCHECK );
1262 BitBlt( hdc, rect.left, (y - r.bottom) / 2, r.right, r.bottom,
1263 hdcMem, 0, 0, SRCCOPY );
1264 DeleteDC( hdcMem );
1265 DeleteObject( bm );
1269 /* Draw the popup-menu arrow */
1270 if (lpitem->fType & MF_POPUP)
1272 HDC hdcMem = CreateCompatibleDC( hdc );
1273 HBITMAP hOrigBitmap;
1275 hOrigBitmap = SelectObject( hdcMem, hStdMnArrow );
1276 BitBlt( hdc, rect.right - arrow_bitmap_width - 1,
1277 (y - arrow_bitmap_height) / 2,
1278 arrow_bitmap_width, arrow_bitmap_height,
1279 hdcMem, 0, 0, SRCCOPY );
1280 SelectObject( hdcMem, hOrigBitmap );
1281 DeleteDC( hdcMem );
1284 rect.left += check_bitmap_width;
1285 rect.right -= arrow_bitmap_width;
1288 /* Done for owner-drawn */
1289 if (lpitem->fType & MF_OWNERDRAW)
1290 return;
1292 /* Draw the item text or bitmap */
1293 if (IS_BITMAP_ITEM(lpitem->fType))
1295 MENU_DrawBitmapItem( hdc, lpitem, &rect, menuBar );
1296 return;
1299 /* No bitmap - process text if present */
1300 else if (IS_STRING_ITEM(lpitem->fType))
1302 register int i;
1303 HFONT hfontOld = 0;
1305 UINT uFormat = (menuBar) ?
1306 DT_CENTER | DT_VCENTER | DT_SINGLELINE :
1307 DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1309 if ( lpitem->fState & MFS_DEFAULT )
1311 hfontOld = SelectObject( hdc, hMenuFontBold);
1314 if (menuBar)
1316 rect.left += MENU_BAR_ITEMS_SPACE / 2;
1317 rect.right -= MENU_BAR_ITEMS_SPACE / 2;
1320 for (i = 0; lpitem->text[i]; i++)
1321 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1322 break;
1324 if(lpitem->fState & MF_GRAYED)
1326 if (!(lpitem->fState & MF_HILITE) )
1328 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1329 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1330 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1331 --rect.left; --rect.top; --rect.right; --rect.bottom;
1333 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1336 DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1338 /* paint the shortcut text */
1339 if (!menuBar && lpitem->text[i]) /* There's a tab or flush-right char */
1341 if (lpitem->text[i] == '\t')
1343 rect.left = lpitem->xTab;
1344 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1346 else
1348 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1351 if(lpitem->fState & MF_GRAYED)
1353 if (!(lpitem->fState & MF_HILITE) )
1355 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1356 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1357 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1358 --rect.left; --rect.top; --rect.right; --rect.bottom;
1360 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1362 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1365 if (hfontOld)
1366 SelectObject (hdc, hfontOld);
1371 /***********************************************************************
1372 * MENU_DrawPopupMenu
1374 * Paint a popup menu.
1376 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1378 HBRUSH hPrevBrush = 0;
1379 RECT rect;
1381 TRACE("wnd=%p dc=%p menu=%p\n", hwnd, hdc, hmenu);
1383 GetClientRect( hwnd, &rect );
1385 if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1386 && (SelectObject( hdc, hMenuFont)))
1388 HPEN hPrevPen;
1390 Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1392 hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1393 if( hPrevPen )
1395 POPUPMENU *menu;
1397 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1399 /* draw menu items */
1401 menu = MENU_GetMenu( hmenu );
1402 if (menu && menu->nItems)
1404 MENUITEM *item;
1405 UINT u;
1407 for (u = menu->nItems, item = menu->items; u > 0; u--, item++)
1408 MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc, item,
1409 menu->Height, FALSE, ODA_DRAWENTIRE );
1412 } else
1414 SelectObject( hdc, hPrevBrush );
1419 /***********************************************************************
1420 * MENU_DrawMenuBar
1422 * Paint a menu bar. Returns the height of the menu bar.
1423 * called from [windows/nonclient.c]
1425 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1426 BOOL suppress_draw)
1428 LPPOPUPMENU lppop;
1429 HFONT hfontOld = 0;
1430 HMENU hMenu = GetMenu(hwnd);
1432 lppop = MENU_GetMenu( hMenu );
1433 if (lppop == NULL || lprect == NULL)
1435 return GetSystemMetrics(SM_CYMENU);
1438 if (suppress_draw)
1440 hfontOld = SelectObject( hDC, hMenuFont);
1442 if (lppop->Height == 0)
1443 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1445 lprect->bottom = lprect->top + lppop->Height;
1447 if (hfontOld) SelectObject( hDC, hfontOld);
1448 return lppop->Height;
1450 else
1451 return DrawMenuBarTemp(hwnd, hDC, lprect, hMenu, NULL);
1455 /***********************************************************************
1456 * MENU_ShowPopup
1458 * Display a popup menu.
1460 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id,
1461 INT x, INT y, INT xanchor, INT yanchor )
1463 POPUPMENU *menu;
1464 UINT width, height;
1466 TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1467 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1469 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1470 if (menu->FocusedItem != NO_SELECTED_ITEM)
1472 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1473 menu->FocusedItem = NO_SELECTED_ITEM;
1476 /* store the owner for DrawItem */
1477 menu->hwndOwner = hwndOwner;
1480 MENU_PopupMenuCalcSize( menu, hwndOwner );
1482 /* adjust popup menu pos so that it fits within the desktop */
1484 width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1485 height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1487 if( x + width > GetSystemMetrics(SM_CXSCREEN ))
1489 if( xanchor )
1490 x -= width - xanchor;
1491 if( x + width > GetSystemMetrics(SM_CXSCREEN))
1492 x = GetSystemMetrics(SM_CXSCREEN) - width;
1494 if( x < 0 ) x = 0;
1496 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1498 if( yanchor )
1499 y -= height + yanchor;
1500 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1501 y = GetSystemMetrics(SM_CYSCREEN) - height;
1503 if( y < 0 ) y = 0;
1505 /* NOTE: In Windows, top menu popup is not owned. */
1506 menu->hWnd = CreateWindowExW( 0, POPUPMENU_CLASS_ATOMW, NULL,
1507 WS_POPUP, x, y, width, height,
1508 hwndOwner, 0, (HINSTANCE)GetWindowLongW(hwndOwner, GWL_HINSTANCE),
1509 (LPVOID)hmenu );
1510 if( !menu->hWnd ) return FALSE;
1511 if (!top_popup) top_popup = menu->hWnd;
1513 /* Display the window */
1515 SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1516 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1517 UpdateWindow( menu->hWnd );
1518 return TRUE;
1522 /***********************************************************************
1523 * MENU_SelectItem
1525 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1526 BOOL sendMenuSelect, HMENU topmenu )
1528 LPPOPUPMENU lppop;
1529 HDC hdc;
1531 TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1533 lppop = MENU_GetMenu( hmenu );
1534 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1536 if (lppop->FocusedItem == wIndex) return;
1537 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1538 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1539 if (!top_popup) top_popup = lppop->hWnd;
1541 SelectObject( hdc, hMenuFont);
1543 /* Clear previous highlighted item */
1544 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1546 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1547 MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1548 lppop->Height, !(lppop->wFlags & MF_POPUP),
1549 ODA_SELECT );
1552 /* Highlight new item (if any) */
1553 lppop->FocusedItem = wIndex;
1554 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1556 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1557 lppop->items[wIndex].fState |= MF_HILITE;
1558 MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1559 &lppop->items[wIndex], lppop->Height,
1560 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1562 if (sendMenuSelect)
1564 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1565 SendMessageW( hwndOwner, WM_MENUSELECT,
1566 MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1567 ip->fType | ip->fState | MF_MOUSESELECT |
1568 (lppop->wFlags & MF_SYSMENU)), (LPARAM)hmenu);
1571 else if (sendMenuSelect) {
1572 if(topmenu){
1573 int pos;
1574 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1575 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1576 MENUITEM *ip = &ptm->items[pos];
1577 SendMessageW( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1578 ip->fType | ip->fState | MF_MOUSESELECT |
1579 (ptm->wFlags & MF_SYSMENU)), (LPARAM)topmenu);
1583 ReleaseDC( lppop->hWnd, hdc );
1587 /***********************************************************************
1588 * MENU_MoveSelection
1590 * Moves currently selected item according to the offset parameter.
1591 * If there is no selection then it should select the last item if
1592 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1594 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1596 INT i;
1597 POPUPMENU *menu;
1599 TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner, hmenu, offset);
1601 menu = MENU_GetMenu( hmenu );
1602 if ((!menu) || (!menu->items)) return;
1604 if ( menu->FocusedItem != NO_SELECTED_ITEM )
1606 if( menu->nItems == 1 ) return; else
1607 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1608 ; i += offset)
1609 if (!(menu->items[i].fType & MF_SEPARATOR))
1611 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1612 return;
1616 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1617 i >= 0 && i < menu->nItems ; i += offset)
1618 if (!(menu->items[i].fType & MF_SEPARATOR))
1620 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1621 return;
1626 /**********************************************************************
1627 * MENU_SetItemData
1629 * Set an item's flags, id and text ptr. Called by InsertMenu() and
1630 * ModifyMenu().
1632 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT_PTR id,
1633 LPCWSTR str )
1635 LPWSTR prevText = IS_STRING_ITEM(item->fType) ? item->text : NULL;
1637 debug_print_menuitem("MENU_SetItemData from: ", item, "");
1638 TRACE("flags=%x str=%p\n", flags, str);
1640 if (IS_STRING_ITEM(flags))
1642 if (!str)
1644 flags |= MF_SEPARATOR;
1645 item->text = NULL;
1647 else
1649 LPWSTR text;
1650 /* Item beginning with a backspace is a help item */
1651 if (*str == '\b')
1653 flags |= MF_HELP;
1654 str++;
1656 if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
1657 return FALSE;
1658 strcpyW( text, str );
1659 item->text = text;
1662 else if (IS_BITMAP_ITEM(flags))
1663 item->text = (LPWSTR)HBITMAP_32(LOWORD(str));
1664 else item->text = NULL;
1666 if (flags & MF_OWNERDRAW)
1667 item->dwItemData = (DWORD)str;
1668 else
1669 item->dwItemData = 0;
1671 if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != (HMENU)id) )
1672 DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
1674 if (flags & MF_POPUP)
1676 POPUPMENU *menu = MENU_GetMenu((HMENU)id);
1677 if (menu) menu->wFlags |= MF_POPUP;
1678 else
1680 item->wID = 0;
1681 item->hSubMenu = 0;
1682 item->fType = 0;
1683 item->fState = 0;
1684 return FALSE;
1688 item->wID = id;
1689 if (flags & MF_POPUP) item->hSubMenu = (HMENU)id;
1691 if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
1692 flags |= MF_POPUP; /* keep popup */
1694 item->fType = flags & TYPE_MASK;
1695 item->fState = (flags & STATE_MASK) &
1696 ~(MF_HILITE | MF_MOUSESELECT | MF_BYPOSITION);
1699 /* Don't call SetRectEmpty here! */
1702 if (prevText) HeapFree( GetProcessHeap(), 0, prevText );
1704 debug_print_menuitem("MENU_SetItemData to : ", item, "");
1705 return TRUE;
1709 /**********************************************************************
1710 * MENU_InsertItem
1712 * Insert (allocate) a new item into a menu.
1714 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1716 MENUITEM *newItems;
1717 POPUPMENU *menu;
1719 if (!(menu = MENU_GetMenu(hMenu)))
1720 return NULL;
1722 /* Find where to insert new item */
1724 if (flags & MF_BYPOSITION) {
1725 if (pos > menu->nItems)
1726 pos = menu->nItems;
1727 } else {
1728 if (!MENU_FindItem( &hMenu, &pos, flags ))
1729 pos = menu->nItems;
1730 else {
1731 if (!(menu = MENU_GetMenu( hMenu )))
1732 return NULL;
1736 /* Create new items array */
1738 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
1739 if (!newItems)
1741 WARN("allocation failed\n" );
1742 return NULL;
1744 if (menu->nItems > 0)
1746 /* Copy the old array into the new one */
1747 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1748 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1749 (menu->nItems-pos)*sizeof(MENUITEM) );
1750 HeapFree( GetProcessHeap(), 0, menu->items );
1752 menu->items = newItems;
1753 menu->nItems++;
1754 memset( &newItems[pos], 0, sizeof(*newItems) );
1755 menu->Height = 0; /* force size recalculate */
1756 return &newItems[pos];
1760 /**********************************************************************
1761 * MENU_ParseResource
1763 * Parse a standard menu resource and add items to the menu.
1764 * Return a pointer to the end of the resource.
1766 * NOTE: flags is equivalent to the mtOption field
1768 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1770 WORD flags, id = 0;
1771 LPCSTR str;
1775 flags = GET_WORD(res);
1776 res += sizeof(WORD);
1777 if (!(flags & MF_POPUP))
1779 id = GET_WORD(res);
1780 res += sizeof(WORD);
1782 str = res;
1783 if (!unicode) res += strlen(str) + 1;
1784 else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1785 if (flags & MF_POPUP)
1787 HMENU hSubMenu = CreatePopupMenu();
1788 if (!hSubMenu) return NULL;
1789 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1790 return NULL;
1791 if (!unicode) AppendMenuA( hMenu, flags, (UINT)hSubMenu, str );
1792 else AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1794 else /* Not a popup */
1796 if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1797 else AppendMenuW( hMenu, flags, id,
1798 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1800 } while (!(flags & MF_END));
1801 return res;
1805 /**********************************************************************
1806 * MENUEX_ParseResource
1808 * Parse an extended menu resource and add items to the menu.
1809 * Return a pointer to the end of the resource.
1811 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
1813 WORD resinfo;
1814 do {
1815 MENUITEMINFOW mii;
1817 mii.cbSize = sizeof(mii);
1818 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
1819 mii.fType = GET_DWORD(res);
1820 res += sizeof(DWORD);
1821 mii.fState = GET_DWORD(res);
1822 res += sizeof(DWORD);
1823 mii.wID = GET_DWORD(res);
1824 res += sizeof(DWORD);
1825 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
1826 res += sizeof(WORD);
1827 /* Align the text on a word boundary. */
1828 res += (~((int)res - 1)) & 1;
1829 mii.dwTypeData = (LPWSTR) res;
1830 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
1831 /* Align the following fields on a dword boundary. */
1832 res += (~((int)res - 1)) & 3;
1834 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1835 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
1837 if (resinfo & 1) { /* Pop-up? */
1838 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1839 res += sizeof(DWORD);
1840 mii.hSubMenu = CreatePopupMenu();
1841 if (!mii.hSubMenu)
1842 return NULL;
1843 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
1844 DestroyMenu(mii.hSubMenu);
1845 return NULL;
1847 mii.fMask |= MIIM_SUBMENU;
1848 mii.fType |= MF_POPUP;
1850 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
1852 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1853 mii.wID, mii.fType);
1854 mii.fType |= MF_SEPARATOR;
1856 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
1857 } while (!(resinfo & MF_END));
1858 return res;
1862 /***********************************************************************
1863 * MENU_GetSubPopup
1865 * Return the handle of the selected sub-popup menu (if any).
1867 static HMENU MENU_GetSubPopup( HMENU hmenu )
1869 POPUPMENU *menu;
1870 MENUITEM *item;
1872 menu = MENU_GetMenu( hmenu );
1874 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
1876 item = &menu->items[menu->FocusedItem];
1877 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
1878 return item->hSubMenu;
1879 return 0;
1883 /***********************************************************************
1884 * MENU_HideSubPopups
1886 * Hide the sub-popup menus of this menu.
1888 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
1889 BOOL sendMenuSelect )
1891 POPUPMENU *menu = MENU_GetMenu( hmenu );
1893 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
1895 if (menu && top_popup)
1897 HMENU hsubmenu;
1898 POPUPMENU *submenu;
1899 MENUITEM *item;
1901 if (menu->FocusedItem != NO_SELECTED_ITEM)
1903 item = &menu->items[menu->FocusedItem];
1904 if (!(item->fType & MF_POPUP) ||
1905 !(item->fState & MF_MOUSESELECT)) return;
1906 item->fState &= ~MF_MOUSESELECT;
1907 hsubmenu = item->hSubMenu;
1908 } else return;
1910 submenu = MENU_GetMenu( hsubmenu );
1911 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
1912 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
1913 DestroyWindow( submenu->hWnd );
1914 submenu->hWnd = 0;
1919 /***********************************************************************
1920 * MENU_ShowSubPopup
1922 * Display the sub-menu of the selected item of this menu.
1923 * Return the handle of the submenu, or hmenu if no submenu to display.
1925 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
1926 BOOL selectFirst, UINT wFlags )
1928 RECT rect;
1929 POPUPMENU *menu;
1930 MENUITEM *item;
1931 HDC hdc;
1933 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, selectFirst);
1935 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
1937 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
1939 item = &menu->items[menu->FocusedItem];
1940 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
1941 return hmenu;
1943 /* message must be sent before using item,
1944 because nearly everything may be changed by the application ! */
1946 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
1947 if (!(wFlags & TPM_NONOTIFY))
1948 SendMessageW( hwndOwner, WM_INITMENUPOPUP, (WPARAM)item->hSubMenu,
1949 MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
1951 item = &menu->items[menu->FocusedItem];
1952 rect = item->rect;
1954 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
1955 if (!(item->fState & MF_HILITE))
1957 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
1958 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1960 SelectObject( hdc, hMenuFont);
1962 item->fState |= MF_HILITE;
1963 MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
1964 ReleaseDC( menu->hWnd, hdc );
1966 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
1967 item->rect = rect;
1969 item->fState |= MF_MOUSESELECT;
1971 if (IS_SYSTEM_MENU(menu))
1973 MENU_InitSysMenuPopup(item->hSubMenu,
1974 GetWindowLongW( menu->hWnd, GWL_STYLE ),
1975 GetClassLongW( menu->hWnd, GCL_STYLE));
1977 NC_GetSysPopupPos( menu->hWnd, &rect );
1978 rect.top = rect.bottom;
1979 rect.right = GetSystemMetrics(SM_CXSIZE);
1980 rect.bottom = GetSystemMetrics(SM_CYSIZE);
1982 else
1984 GetWindowRect( menu->hWnd, &rect );
1985 if (menu->wFlags & MF_POPUP)
1987 rect.left += item->rect.right - GetSystemMetrics(SM_CXBORDER);
1988 rect.top += item->rect.top;
1989 rect.right = item->rect.left - item->rect.right + GetSystemMetrics(SM_CXBORDER);
1990 rect.bottom = item->rect.top - item->rect.bottom;
1992 else
1994 rect.left += item->rect.left;
1995 rect.top += item->rect.bottom;
1996 rect.right = item->rect.right - item->rect.left;
1997 rect.bottom = item->rect.bottom - item->rect.top;
2001 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2002 rect.left, rect.top, rect.right, rect.bottom );
2003 if (selectFirst)
2004 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2005 return item->hSubMenu;
2010 /**********************************************************************
2011 * MENU_IsMenuActive
2013 BOOL MENU_IsMenuActive(void)
2015 return (top_popup != 0);
2018 /***********************************************************************
2019 * MENU_PtMenu
2021 * Walks menu chain trying to find a menu pt maps to.
2023 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2025 POPUPMENU *menu = MENU_GetMenu( hMenu );
2026 UINT item = menu->FocusedItem;
2027 HMENU ret;
2029 /* try subpopup first (if any) */
2030 ret = (item != NO_SELECTED_ITEM &&
2031 (menu->items[item].fType & MF_POPUP) &&
2032 (menu->items[item].fState & MF_MOUSESELECT))
2033 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2035 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2037 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2038 if( menu->wFlags & MF_POPUP )
2040 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2042 else if (ht == HTSYSMENU)
2043 ret = get_win_sys_menu( menu->hWnd );
2044 else if (ht == HTMENU)
2045 ret = GetMenu( menu->hWnd );
2047 return ret;
2050 /***********************************************************************
2051 * MENU_ExecFocusedItem
2053 * Execute a menu item (for instance when user pressed Enter).
2054 * Return the wID of the executed item. Otherwise, -1 indicating
2055 * that no menu item was executed;
2056 * Have to receive the flags for the TrackPopupMenu options to avoid
2057 * sending unwanted message.
2060 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2062 MENUITEM *item;
2063 POPUPMENU *menu = MENU_GetMenu( hMenu );
2065 TRACE("%p hmenu=%p\n", pmt, hMenu);
2067 if (!menu || !menu->nItems ||
2068 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2070 item = &menu->items[menu->FocusedItem];
2072 TRACE("%p %08x %p\n", hMenu, item->wID, item->hSubMenu);
2074 if (!(item->fType & MF_POPUP))
2076 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2078 /* If TPM_RETURNCMD is set you return the id, but
2079 do not send a message to the owner */
2080 if(!(wFlags & TPM_RETURNCMD))
2082 if( menu->wFlags & MF_SYSMENU )
2083 PostMessageW( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2084 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2085 else
2086 PostMessageW( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2088 return item->wID;
2091 else
2092 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2094 return -1;
2097 /***********************************************************************
2098 * MENU_SwitchTracking
2100 * Helper function for menu navigation routines.
2102 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2104 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2105 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2107 TRACE("%p hmenu=%p 0x%04x\n", pmt, hPtMenu, id);
2109 if( pmt->hTopMenu != hPtMenu &&
2110 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2112 /* both are top level menus (system and menu-bar) */
2113 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2114 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2115 pmt->hTopMenu = hPtMenu;
2117 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2118 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2122 /***********************************************************************
2123 * MENU_ButtonDown
2125 * Return TRUE if we can go on with menu tracking.
2127 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2129 TRACE("%p hPtMenu=%p\n", pmt, hPtMenu);
2131 if (hPtMenu)
2133 UINT id = 0;
2134 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2135 MENUITEM *item;
2137 if( IS_SYSTEM_MENU(ptmenu) )
2138 item = ptmenu->items;
2139 else
2140 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2142 if( item )
2144 if( ptmenu->FocusedItem != id )
2145 MENU_SwitchTracking( pmt, hPtMenu, id );
2147 /* If the popup menu is not already "popped" */
2148 if(!(item->fState & MF_MOUSESELECT ))
2150 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2153 return TRUE;
2155 /* Else the click was on the menu bar, finish the tracking */
2157 return FALSE;
2160 /***********************************************************************
2161 * MENU_ButtonUp
2163 * Return the value of MENU_ExecFocusedItem if
2164 * the selected item was not a popup. Else open the popup.
2165 * A -1 return value indicates that we go on with menu tracking.
2168 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2170 TRACE("%p hmenu=%p\n", pmt, hPtMenu);
2172 if (hPtMenu)
2174 UINT id = 0;
2175 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2176 MENUITEM *item;
2178 if( IS_SYSTEM_MENU(ptmenu) )
2179 item = ptmenu->items;
2180 else
2181 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2183 if( item && (ptmenu->FocusedItem == id ))
2185 if( !(item->fType & MF_POPUP) )
2186 return MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2188 /* If we are dealing with the top-level menu */
2189 /* and this is a click on an already "popped" item: */
2190 /* Stop the menu tracking and close the opened submenus */
2191 if((pmt->hTopMenu == hPtMenu) && (ptmenu->bTimeToHide == TRUE))
2192 return 0;
2194 ptmenu->bTimeToHide = TRUE;
2196 return -1;
2200 /***********************************************************************
2201 * MENU_MouseMove
2203 * Return TRUE if we can go on with menu tracking.
2205 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2207 UINT id = NO_SELECTED_ITEM;
2208 POPUPMENU *ptmenu = NULL;
2210 if( hPtMenu )
2212 ptmenu = MENU_GetMenu( hPtMenu );
2213 if( IS_SYSTEM_MENU(ptmenu) )
2214 id = 0;
2215 else
2216 MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2219 if( id == NO_SELECTED_ITEM )
2221 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2222 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2225 else if( ptmenu->FocusedItem != id )
2227 MENU_SwitchTracking( pmt, hPtMenu, id );
2228 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2230 return TRUE;
2234 /***********************************************************************
2235 * MENU_SetCapture
2237 static void MENU_SetCapture( HWND hwnd )
2239 HWND previous = 0;
2241 SERVER_START_REQ( set_capture_window )
2243 req->handle = hwnd;
2244 req->flags = CAPTURE_MENU;
2245 if (!wine_server_call_err( req ))
2247 previous = reply->previous;
2248 hwnd = reply->full_handle;
2251 SERVER_END_REQ;
2253 if (previous && previous != hwnd)
2254 SendMessageW( previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd );
2258 /***********************************************************************
2259 * MENU_DoNextMenu
2261 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2263 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2265 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2267 if( (vk == VK_LEFT && menu->FocusedItem == 0 ) ||
2268 (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2270 MDINEXTMENU next_menu;
2271 HMENU hNewMenu;
2272 HWND hNewWnd;
2273 UINT id = 0;
2275 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2276 next_menu.hmenuNext = 0;
2277 next_menu.hwndNext = 0;
2278 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2280 TRACE("%p [%p] -> %p [%p]\n",
2281 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2283 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2285 DWORD style = GetWindowLongW( pmt->hOwnerWnd, GWL_STYLE );
2286 hNewWnd = pmt->hOwnerWnd;
2287 if( IS_SYSTEM_MENU(menu) )
2289 /* switch to the menu bar */
2291 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2293 if( vk == VK_LEFT )
2295 menu = MENU_GetMenu( hNewMenu );
2296 id = menu->nItems - 1;
2299 else if (style & WS_SYSMENU )
2301 /* switch to the system menu */
2302 hNewMenu = get_win_sys_menu( hNewWnd );
2304 else return FALSE;
2306 else /* application returned a new menu to switch to */
2308 hNewMenu = next_menu.hmenuNext;
2309 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2311 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2313 DWORD style = GetWindowLongW( hNewWnd, GWL_STYLE );
2315 if (style & WS_SYSMENU &&
2316 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2318 /* get the real system menu */
2319 hNewMenu = get_win_sys_menu(hNewWnd);
2321 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2323 /* FIXME: Not sure what to do here;
2324 * perhaps try to track hNewMenu as a popup? */
2326 TRACE(" -- got confused.\n");
2327 return FALSE;
2330 else return FALSE;
2333 if( hNewMenu != pmt->hTopMenu )
2335 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2336 FALSE, 0 );
2337 if( pmt->hCurrentMenu != pmt->hTopMenu )
2338 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2341 if( hNewWnd != pmt->hOwnerWnd )
2343 pmt->hOwnerWnd = hNewWnd;
2344 MENU_SetCapture( pmt->hOwnerWnd );
2347 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2348 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2350 return TRUE;
2352 return FALSE;
2355 /***********************************************************************
2356 * MENU_SuspendPopup
2358 * The idea is not to show the popup if the next input message is
2359 * going to hide it anyway.
2361 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2363 MSG msg;
2365 msg.hwnd = pmt->hOwnerWnd;
2367 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2368 pmt->trackFlags |= TF_SKIPREMOVE;
2370 switch( uMsg )
2372 case WM_KEYDOWN:
2373 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2374 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2376 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2377 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2378 if( msg.message == WM_KEYDOWN &&
2379 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2381 pmt->trackFlags |= TF_SUSPENDPOPUP;
2382 return TRUE;
2385 break;
2388 /* failures go through this */
2389 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2390 return FALSE;
2393 /***********************************************************************
2394 * MENU_KeyEscape
2396 * Handle a VK_ESCAPE key event in a menu.
2398 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2400 BOOL bEndMenu = TRUE;
2402 if (pmt->hCurrentMenu != pmt->hTopMenu)
2404 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2406 if (menu->wFlags & MF_POPUP)
2408 HMENU hmenutmp, hmenuprev;
2410 hmenuprev = hmenutmp = pmt->hTopMenu;
2412 /* close topmost popup */
2413 while (hmenutmp != pmt->hCurrentMenu)
2415 hmenuprev = hmenutmp;
2416 hmenutmp = MENU_GetSubPopup( hmenuprev );
2419 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2420 pmt->hCurrentMenu = hmenuprev;
2421 bEndMenu = FALSE;
2425 return bEndMenu;
2428 /***********************************************************************
2429 * MENU_KeyLeft
2431 * Handle a VK_LEFT key event in a menu.
2433 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2435 POPUPMENU *menu;
2436 HMENU hmenutmp, hmenuprev;
2437 UINT prevcol;
2439 hmenuprev = hmenutmp = pmt->hTopMenu;
2440 menu = MENU_GetMenu( hmenutmp );
2442 /* Try to move 1 column left (if possible) */
2443 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2444 NO_SELECTED_ITEM ) {
2446 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2447 prevcol, TRUE, 0 );
2448 return;
2451 /* close topmost popup */
2452 while (hmenutmp != pmt->hCurrentMenu)
2454 hmenuprev = hmenutmp;
2455 hmenutmp = MENU_GetSubPopup( hmenuprev );
2458 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2459 pmt->hCurrentMenu = hmenuprev;
2461 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2463 /* move menu bar selection if no more popups are left */
2465 if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2466 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2468 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2470 /* A sublevel menu was displayed - display the next one
2471 * unless there is another displacement coming up */
2473 if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2474 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2475 pmt->hTopMenu, TRUE, wFlags);
2481 /***********************************************************************
2482 * MENU_KeyRight
2484 * Handle a VK_RIGHT key event in a menu.
2486 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2488 HMENU hmenutmp;
2489 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2490 UINT nextcol;
2492 TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2493 pmt->hCurrentMenu,
2494 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->items[0].text),
2495 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2497 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2499 /* If already displaying a popup, try to display sub-popup */
2501 hmenutmp = pmt->hCurrentMenu;
2502 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2504 /* if subpopup was displayed then we are done */
2505 if (hmenutmp != pmt->hCurrentMenu) return;
2508 /* Check to see if there's another column */
2509 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2510 NO_SELECTED_ITEM ) {
2511 TRACE("Going to %d.\n", nextcol );
2512 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2513 nextcol, TRUE, 0 );
2514 return;
2517 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2519 if( pmt->hCurrentMenu != pmt->hTopMenu )
2521 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2522 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2523 } else hmenutmp = 0;
2525 /* try to move to the next item */
2526 if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2527 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2529 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2530 if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2531 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2532 pmt->hTopMenu, TRUE, wFlags);
2536 /***********************************************************************
2537 * MENU_TrackMenu
2539 * Menu tracking code.
2541 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2542 HWND hwnd, const RECT *lprect )
2544 MSG msg;
2545 POPUPMENU *menu;
2546 BOOL fRemove;
2547 INT executedMenuId = -1;
2548 MTRACKER mt;
2549 BOOL enterIdleSent = FALSE;
2551 mt.trackFlags = 0;
2552 mt.hCurrentMenu = hmenu;
2553 mt.hTopMenu = hmenu;
2554 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2555 mt.pt.x = x;
2556 mt.pt.y = y;
2558 TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p (%ld,%ld)-(%ld,%ld)\n",
2559 hmenu, wFlags, x, y, hwnd, (lprect) ? lprect->left : 0, (lprect) ? lprect->top : 0,
2560 (lprect) ? lprect->right : 0, (lprect) ? lprect->bottom : 0);
2562 fEndMenu = FALSE;
2563 if (!(menu = MENU_GetMenu( hmenu )))
2565 SetLastError(ERROR_INVALID_MENU_HANDLE);
2566 return FALSE;
2569 if (wFlags & TPM_BUTTONDOWN)
2571 /* Get the result in order to start the tracking or not */
2572 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2573 fEndMenu = !fRemove;
2576 MENU_SetCapture( mt.hOwnerWnd );
2578 while (!fEndMenu)
2580 menu = MENU_GetMenu( mt.hCurrentMenu );
2581 if (!menu) /* sometimes happens if I do a window manager close */
2582 break;
2584 /* we have to keep the message in the queue until it's
2585 * clear that menu loop is not over yet. */
2587 for (;;)
2589 if (PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ))
2591 if (!CallMsgFilterW( &msg, MSGF_MENU )) break;
2592 /* remove the message from the queue */
2593 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2595 else
2597 if (!enterIdleSent)
2599 HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2600 enterIdleSent = TRUE;
2601 SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2603 WaitMessage();
2607 /* check if EndMenu() tried to cancel us, by posting this message */
2608 if(msg.message == WM_CANCELMODE)
2610 /* we are now out of the loop */
2611 fEndMenu = TRUE;
2613 /* remove the message from the queue */
2614 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2616 /* break out of internal loop, ala ESCAPE */
2617 break;
2620 TranslateMessage( &msg );
2621 mt.pt = msg.pt;
2623 if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
2624 enterIdleSent=FALSE;
2626 fRemove = FALSE;
2627 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
2630 * Use the mouse coordinates in lParam instead of those in the MSG
2631 * struct to properly handle synthetic messages. They are already
2632 * in screen coordinates.
2634 mt.pt.x = (short)LOWORD(msg.lParam);
2635 mt.pt.y = (short)HIWORD(msg.lParam);
2637 /* Find a menu for this mouse event */
2638 hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
2640 switch(msg.message)
2642 /* no WM_NC... messages in captured state */
2644 case WM_RBUTTONDBLCLK:
2645 case WM_RBUTTONDOWN:
2646 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2647 /* fall through */
2648 case WM_LBUTTONDBLCLK:
2649 case WM_LBUTTONDOWN:
2650 /* If the message belongs to the menu, removes it from the queue */
2651 /* Else, end menu tracking */
2652 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2653 fEndMenu = !fRemove;
2654 break;
2656 case WM_RBUTTONUP:
2657 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2658 /* fall through */
2659 case WM_LBUTTONUP:
2660 /* Check if a menu was selected by the mouse */
2661 if (hmenu)
2663 executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
2665 /* End the loop if executedMenuId is an item ID */
2666 /* or if the job was done (executedMenuId = 0). */
2667 fEndMenu = fRemove = (executedMenuId != -1);
2669 /* No menu was selected by the mouse */
2670 /* if the function was called by TrackPopupMenu, continue
2671 with the menu tracking. If not, stop it */
2672 else
2673 fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
2675 break;
2677 case WM_MOUSEMOVE:
2678 /* the selected menu item must be changed every time */
2679 /* the mouse moves. */
2681 if (hmenu)
2682 fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
2684 } /* switch(msg.message) - mouse */
2686 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
2688 fRemove = TRUE; /* Keyboard messages are always removed */
2689 switch(msg.message)
2691 case WM_KEYDOWN:
2692 switch(msg.wParam)
2694 case VK_HOME:
2695 case VK_END:
2696 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
2697 NO_SELECTED_ITEM, FALSE, 0 );
2698 /* fall through */
2699 case VK_UP:
2700 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
2701 (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
2702 break;
2704 case VK_DOWN: /* If on menu bar, pull-down the menu */
2706 menu = MENU_GetMenu( mt.hCurrentMenu );
2707 if (!(menu->wFlags & MF_POPUP))
2708 mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
2709 else /* otherwise try to move selection */
2710 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT );
2711 break;
2713 case VK_LEFT:
2714 MENU_KeyLeft( &mt, wFlags );
2715 break;
2717 case VK_RIGHT:
2718 MENU_KeyRight( &mt, wFlags );
2719 break;
2721 case VK_ESCAPE:
2722 fEndMenu = MENU_KeyEscape(&mt, wFlags);
2723 break;
2725 case VK_F1:
2727 HELPINFO hi;
2728 hi.cbSize = sizeof(HELPINFO);
2729 hi.iContextType = HELPINFO_MENUITEM;
2730 if (menu->FocusedItem == NO_SELECTED_ITEM)
2731 hi.iCtrlId = 0;
2732 else
2733 hi.iCtrlId = menu->items[menu->FocusedItem].wID;
2734 hi.hItemHandle = hmenu;
2735 hi.dwContextId = menu->dwContextHelpID;
2736 hi.MousePos = msg.pt;
2737 SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
2738 break;
2741 default:
2742 break;
2744 break; /* WM_KEYDOWN */
2746 case WM_SYSKEYDOWN:
2747 switch(msg.wParam)
2749 case VK_MENU:
2750 fEndMenu = TRUE;
2751 break;
2754 break; /* WM_SYSKEYDOWN */
2756 case WM_CHAR:
2758 UINT pos;
2760 if (msg.wParam == '\r' || msg.wParam == ' ')
2762 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2763 fEndMenu = (executedMenuId != -1);
2765 break;
2768 /* Hack to avoid control chars. */
2769 /* We will find a better way real soon... */
2770 if (msg.wParam < 32) break;
2772 pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
2773 LOWORD(msg.wParam), FALSE );
2774 if (pos == (UINT)-2) fEndMenu = TRUE;
2775 else if (pos == (UINT)-1) MessageBeep(0);
2776 else
2778 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
2779 TRUE, 0 );
2780 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2781 fEndMenu = (executedMenuId != -1);
2784 break;
2785 } /* switch(msg.message) - kbd */
2787 else
2789 DispatchMessageW( &msg );
2792 if (!fEndMenu) fRemove = TRUE;
2794 /* finally remove message from the queue */
2796 if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
2797 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2798 else mt.trackFlags &= ~TF_SKIPREMOVE;
2801 MENU_SetCapture(0); /* release the capture */
2803 /* If dropdown is still painted and the close box is clicked on
2804 then the menu will be destroyed as part of the DispatchMessage above.
2805 This will then invalidate the menu handle in mt.hTopMenu. We should
2806 check for this first. */
2807 if( IsMenu( mt.hTopMenu ) )
2809 menu = MENU_GetMenu( mt.hTopMenu );
2811 if( IsWindow( mt.hOwnerWnd ) )
2813 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
2815 if (menu && menu->wFlags & MF_POPUP)
2817 DestroyWindow( menu->hWnd );
2818 menu->hWnd = 0;
2820 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2821 SendMessageW( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
2824 /* Reset the variable for hiding menu */
2825 if( menu ) menu->bTimeToHide = FALSE;
2828 /* The return value is only used by TrackPopupMenu */
2829 if (!(wFlags & TPM_RETURNCMD)) return TRUE;
2830 if (executedMenuId == -1) executedMenuId = 0;
2831 return executedMenuId;
2834 /***********************************************************************
2835 * MENU_InitTracking
2837 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
2839 TRACE("hwnd=%p hmenu=%p\n", hWnd, hMenu);
2841 HideCaret(0);
2843 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2844 if (!(wFlags & TPM_NONOTIFY))
2845 SendMessageW( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
2847 SendMessageW( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
2849 if (!(wFlags & TPM_NONOTIFY))
2851 POPUPMENU *menu;
2852 SendMessageW( hWnd, WM_INITMENU, (WPARAM)hMenu, 0 );
2853 if ((menu = MENU_GetMenu( hMenu )) && (!menu->Height))
2854 { /* app changed/recreated menu bar entries in WM_INITMENU
2855 Recalculate menu sizes else clicks will not work */
2856 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2857 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2861 return TRUE;
2863 /***********************************************************************
2864 * MENU_ExitTracking
2866 static BOOL MENU_ExitTracking(HWND hWnd)
2868 TRACE("hwnd=%p\n", hWnd);
2870 SendMessageW( hWnd, WM_EXITMENULOOP, 0, 0 );
2871 ShowCaret(0);
2872 return TRUE;
2875 /***********************************************************************
2876 * MENU_TrackMouseMenuBar
2878 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2880 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
2882 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
2883 UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2885 TRACE("wnd=%p ht=0x%04x (%ld,%ld)\n", hWnd, ht, pt.x, pt.y);
2887 if (IsMenu(hMenu))
2889 /* map point to parent client coordinates */
2890 HWND parent = GetAncestor( hWnd, GA_PARENT );
2891 if (parent != GetDesktopWindow()) ScreenToClient( parent, &pt );
2893 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
2894 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
2895 MENU_ExitTracking(hWnd);
2900 /***********************************************************************
2901 * MENU_TrackKbdMenuBar
2903 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
2905 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, WCHAR wChar)
2907 UINT uItem = NO_SELECTED_ITEM;
2908 HMENU hTrackMenu;
2909 UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2911 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd, wParam, wChar);
2913 /* find window that has a menu */
2915 while (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)
2916 if (!(hwnd = GetParent( hwnd ))) return;
2918 /* check if we have to track a system menu */
2920 hTrackMenu = GetMenu( hwnd );
2921 if (!hTrackMenu || IsIconic(hwnd) || wChar == ' ' )
2923 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
2924 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MANAGED) return;
2925 hTrackMenu = get_win_sys_menu( hwnd );
2926 uItem = 0;
2927 wParam |= HTSYSMENU; /* prevent item lookup */
2930 if (!IsMenu( hTrackMenu )) return;
2932 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
2934 if( wChar && wChar != ' ' )
2936 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, wChar, (wParam & HTSYSMENU) );
2937 if( uItem >= (UINT)(-2) )
2939 if( uItem == (UINT)(-1) ) MessageBeep(0);
2940 hTrackMenu = 0;
2944 if( hTrackMenu )
2946 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
2948 if( uItem == NO_SELECTED_ITEM )
2949 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
2950 else if( wChar )
2951 PostMessageW( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
2953 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
2955 MENU_ExitTracking( hwnd );
2959 /**********************************************************************
2960 * TrackPopupMenu (USER32.@)
2962 * Like the win32 API, the function return the command ID only if the
2963 * flag TPM_RETURNCMD is on.
2966 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
2967 INT nReserved, HWND hWnd, const RECT *lpRect )
2969 BOOL ret = FALSE;
2971 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
2973 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2974 if (!(wFlags & TPM_NONOTIFY))
2975 SendMessageW( hWnd, WM_INITMENUPOPUP, (WPARAM)hMenu, 0);
2977 if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
2978 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
2979 MENU_ExitTracking(hWnd);
2981 return ret;
2984 /**********************************************************************
2985 * TrackPopupMenuEx (USER32.@)
2987 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
2988 HWND hWnd, LPTPMPARAMS lpTpm )
2990 FIXME("not fully implemented\n" );
2991 return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
2992 lpTpm ? &lpTpm->rcExclude : NULL );
2995 /***********************************************************************
2996 * PopupMenuWndProc
2998 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3000 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3002 TRACE("hwnd=%p msg=0x%04x wp=0x%04x lp=0x%08lx\n", hwnd, message, wParam, lParam);
3004 switch(message)
3006 case WM_CREATE:
3008 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3009 SetWindowLongW( hwnd, 0, (LONG)cs->lpCreateParams );
3010 return 0;
3013 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3014 return MA_NOACTIVATE;
3016 case WM_PAINT:
3018 PAINTSTRUCT ps;
3019 BeginPaint( hwnd, &ps );
3020 MENU_DrawPopupMenu( hwnd, ps.hdc,
3021 (HMENU)GetWindowLongW( hwnd, 0 ) );
3022 EndPaint( hwnd, &ps );
3023 return 0;
3025 case WM_ERASEBKGND:
3026 return 1;
3028 case WM_DESTROY:
3029 /* zero out global pointer in case resident popup window was destroyed. */
3030 if (hwnd == top_popup) top_popup = 0;
3031 break;
3033 case WM_SHOWWINDOW:
3035 if( wParam )
3037 if (!GetWindowLongW( hwnd, 0 )) ERR("no menu to display\n");
3039 else
3040 SetWindowLongW( hwnd, 0, 0 );
3041 break;
3043 case MM_SETMENUHANDLE:
3044 SetWindowLongW( hwnd, 0, wParam );
3045 break;
3047 case MM_GETMENUHANDLE:
3048 return GetWindowLongW( hwnd, 0 );
3050 default:
3051 return DefWindowProcW( hwnd, message, wParam, lParam );
3053 return 0;
3057 /***********************************************************************
3058 * MENU_GetMenuBarHeight
3060 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3062 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3063 INT orgX, INT orgY )
3065 HDC hdc;
3066 RECT rectBar;
3067 LPPOPUPMENU lppop;
3069 TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd, menubarWidth, orgX, orgY );
3071 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3073 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3074 SelectObject( hdc, hMenuFont);
3075 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3076 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3077 ReleaseDC( hwnd, hdc );
3078 return lppop->Height;
3082 /*******************************************************************
3083 * ChangeMenuA (USER32.@)
3085 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3086 UINT id, UINT flags )
3088 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3089 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3090 id, data );
3091 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3092 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3093 id, data );
3094 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3095 flags & MF_BYPOSITION ? pos : id,
3096 flags & ~MF_REMOVE );
3097 /* Default: MF_INSERT */
3098 return InsertMenuA( hMenu, pos, flags, id, data );
3102 /*******************************************************************
3103 * ChangeMenuW (USER32.@)
3105 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3106 UINT id, UINT flags )
3108 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3109 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3110 id, data );
3111 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3112 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3113 id, data );
3114 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3115 flags & MF_BYPOSITION ? pos : id,
3116 flags & ~MF_REMOVE );
3117 /* Default: MF_INSERT */
3118 return InsertMenuW( hMenu, pos, flags, id, data );
3122 /*******************************************************************
3123 * CheckMenuItem (USER32.@)
3125 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3127 MENUITEM *item;
3128 DWORD ret;
3130 TRACE("menu=%p id=%04x flags=%04x\n", hMenu, id, flags );
3131 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3132 ret = item->fState & MF_CHECKED;
3133 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3134 else item->fState &= ~MF_CHECKED;
3135 return ret;
3139 /**********************************************************************
3140 * EnableMenuItem (USER32.@)
3142 UINT WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3144 UINT oldflags;
3145 MENUITEM *item;
3146 POPUPMENU *menu;
3148 TRACE("(%p, %04x, %04x) !\n", hMenu, wItemID, wFlags);
3150 /* Get the Popupmenu to access the owner menu */
3151 if (!(menu = MENU_GetMenu(hMenu)))
3152 return (UINT)-1;
3154 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3155 return (UINT)-1;
3157 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3158 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3160 /* If the close item in the system menu change update the close button */
3161 if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3163 if (menu->hSysMenuOwner != 0)
3165 POPUPMENU* parentMenu;
3167 /* Get the parent menu to access*/
3168 if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3169 return (UINT)-1;
3171 /* Refresh the frame to reflect the change*/
3172 SetWindowPos(parentMenu->hWnd, 0, 0, 0, 0, 0,
3173 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
3177 return oldflags;
3181 /*******************************************************************
3182 * GetMenuStringA (USER32.@)
3184 INT WINAPI GetMenuStringA(
3185 HMENU hMenu, /* [in] menuhandle */
3186 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3187 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3188 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3189 UINT wFlags /* [in] MF_ flags */
3191 MENUITEM *item;
3193 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3194 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3195 if (!IS_STRING_ITEM(item->fType)) return 0;
3196 if (!str || !nMaxSiz) return strlenW(item->text);
3197 str[0] = '\0';
3198 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3199 str[nMaxSiz-1] = 0;
3200 TRACE("returning '%s'\n", str );
3201 return strlen(str);
3205 /*******************************************************************
3206 * GetMenuStringW (USER32.@)
3208 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3209 LPWSTR str, INT nMaxSiz, UINT wFlags )
3211 MENUITEM *item;
3213 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3214 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3215 if (!IS_STRING_ITEM(item->fType)) return 0;
3216 if (!str || !nMaxSiz) return strlenW(item->text);
3217 str[0] = '\0';
3218 lstrcpynW( str, item->text, nMaxSiz );
3219 return strlenW(str);
3223 /**********************************************************************
3224 * HiliteMenuItem (USER32.@)
3226 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3227 UINT wHilite )
3229 LPPOPUPMENU menu;
3230 TRACE("(%p, %p, %04x, %04x);\n", hWnd, hMenu, wItemID, wHilite);
3231 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3232 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3233 if (menu->FocusedItem == wItemID) return TRUE;
3234 MENU_HideSubPopups( hWnd, hMenu, FALSE );
3235 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3236 return TRUE;
3240 /**********************************************************************
3241 * GetMenuState (USER32.@)
3243 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3245 MENUITEM *item;
3246 TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, wItemID, wFlags);
3247 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3248 debug_print_menuitem (" item: ", item, "");
3249 if (item->fType & MF_POPUP)
3251 POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3252 if (!menu) return -1;
3253 else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3255 else
3257 /* We used to (from way back then) mask the result to 0xff. */
3258 /* I don't know why and it seems wrong as the documented */
3259 /* return flag MF_SEPARATOR is outside that mask. */
3260 return (item->fType | item->fState);
3265 /**********************************************************************
3266 * GetMenuItemCount (USER32.@)
3268 INT WINAPI GetMenuItemCount( HMENU hMenu )
3270 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3271 if (!menu) return -1;
3272 TRACE("(%p) returning %d\n", hMenu, menu->nItems );
3273 return menu->nItems;
3277 /**********************************************************************
3278 * GetMenuItemID (USER32.@)
3280 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3282 MENUITEM * lpmi;
3284 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return -1;
3285 if (lpmi->fType & MF_POPUP) return -1;
3286 return lpmi->wID;
3291 /*******************************************************************
3292 * InsertMenuW (USER32.@)
3294 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3295 UINT_PTR id, LPCWSTR str )
3297 MENUITEM *item;
3299 if (IS_STRING_ITEM(flags) && str)
3300 TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %s\n",
3301 hMenu, pos, flags, id, debugstr_w(str) );
3302 else TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %08lx (not a string)\n",
3303 hMenu, pos, flags, id, (DWORD)str );
3305 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3307 if (!(MENU_SetItemData( item, flags, id, str )))
3309 RemoveMenu( hMenu, pos, flags );
3310 return FALSE;
3313 if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
3314 (MENU_GetMenu((HMENU)id))->wFlags |= MF_POPUP;
3316 item->hCheckBit = item->hUnCheckBit = 0;
3317 return TRUE;
3321 /*******************************************************************
3322 * InsertMenuA (USER32.@)
3324 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3325 UINT_PTR id, LPCSTR str )
3327 BOOL ret = FALSE;
3329 if (IS_STRING_ITEM(flags) && str)
3331 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3332 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3333 if (newstr)
3335 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3336 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3337 HeapFree( GetProcessHeap(), 0, newstr );
3339 return ret;
3341 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3345 /*******************************************************************
3346 * AppendMenuA (USER32.@)
3348 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3349 UINT_PTR id, LPCSTR data )
3351 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3355 /*******************************************************************
3356 * AppendMenuW (USER32.@)
3358 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3359 UINT_PTR id, LPCWSTR data )
3361 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3365 /**********************************************************************
3366 * RemoveMenu (USER32.@)
3368 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3370 LPPOPUPMENU menu;
3371 MENUITEM *item;
3373 TRACE("(menu=%p pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3374 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3375 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3377 /* Remove item */
3379 MENU_FreeItemData( item );
3381 if (--menu->nItems == 0)
3383 HeapFree( GetProcessHeap(), 0, menu->items );
3384 menu->items = NULL;
3386 else
3388 while(nPos < menu->nItems)
3390 *item = *(item+1);
3391 item++;
3392 nPos++;
3394 menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3395 menu->nItems * sizeof(MENUITEM) );
3397 return TRUE;
3401 /**********************************************************************
3402 * DeleteMenu (USER32.@)
3404 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3406 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3407 if (!item) return FALSE;
3408 if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3409 /* nPos is now the position of the item */
3410 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3411 return TRUE;
3415 /*******************************************************************
3416 * ModifyMenuW (USER32.@)
3418 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3419 UINT_PTR id, LPCWSTR str )
3421 MENUITEM *item;
3423 if (IS_STRING_ITEM(flags))
3425 TRACE("%p %d %04x %04x %s\n", hMenu, pos, flags, id, debugstr_w(str) );
3427 else
3429 TRACE("%p %d %04x %04x %08lx\n", hMenu, pos, flags, id, (DWORD)str );
3432 if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3433 return MENU_SetItemData( item, flags, id, str );
3437 /*******************************************************************
3438 * ModifyMenuA (USER32.@)
3440 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3441 UINT_PTR id, LPCSTR str )
3443 BOOL ret = FALSE;
3445 if (IS_STRING_ITEM(flags) && str)
3447 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3448 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3449 if (newstr)
3451 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3452 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3453 HeapFree( GetProcessHeap(), 0, newstr );
3455 return ret;
3457 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3461 /**********************************************************************
3462 * CreatePopupMenu (USER32.@)
3464 HMENU WINAPI CreatePopupMenu(void)
3466 HMENU hmenu;
3467 POPUPMENU *menu;
3469 if (!(hmenu = CreateMenu())) return 0;
3470 menu = MENU_GetMenu( hmenu );
3471 menu->wFlags |= MF_POPUP;
3472 menu->bTimeToHide = FALSE;
3473 return hmenu;
3477 /**********************************************************************
3478 * GetMenuCheckMarkDimensions (USER.417)
3479 * GetMenuCheckMarkDimensions (USER32.@)
3481 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3483 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3487 /**********************************************************************
3488 * SetMenuItemBitmaps (USER32.@)
3490 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3491 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3493 MENUITEM *item;
3494 TRACE("(%p, %04x, %04x, %p, %p)\n",
3495 hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3496 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3498 if (!hNewCheck && !hNewUnCheck)
3500 item->fState &= ~MF_USECHECKBITMAPS;
3502 else /* Install new bitmaps */
3504 item->hCheckBit = hNewCheck;
3505 item->hUnCheckBit = hNewUnCheck;
3506 item->fState |= MF_USECHECKBITMAPS;
3508 return TRUE;
3512 /**********************************************************************
3513 * CreateMenu (USER32.@)
3515 HMENU WINAPI CreateMenu(void)
3517 HMENU hMenu;
3518 LPPOPUPMENU menu;
3519 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3520 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3522 ZeroMemory(menu, sizeof(POPUPMENU));
3523 menu->wMagic = MENU_MAGIC;
3524 menu->FocusedItem = NO_SELECTED_ITEM;
3525 menu->bTimeToHide = FALSE;
3527 TRACE("return %p\n", hMenu );
3529 return hMenu;
3533 /**********************************************************************
3534 * DestroyMenu (USER32.@)
3536 BOOL WINAPI DestroyMenu( HMENU hMenu )
3538 TRACE("(%p)\n", hMenu);
3540 /* Silently ignore attempts to destroy default system popup */
3542 if (hMenu && hMenu != MENU_DefSysPopup)
3544 LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3546 if (!lppop) return FALSE;
3548 lppop->wMagic = 0; /* Mark it as destroyed */
3550 if ((lppop->wFlags & MF_POPUP) && lppop->hWnd)
3552 DestroyWindow( lppop->hWnd );
3553 lppop->hWnd = 0;
3556 if (lppop->items) /* recursively destroy submenus */
3558 int i;
3559 MENUITEM *item = lppop->items;
3560 for (i = lppop->nItems; i > 0; i--, item++)
3562 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3563 MENU_FreeItemData( item );
3565 HeapFree( GetProcessHeap(), 0, lppop->items );
3567 USER_HEAP_FREE( hMenu );
3569 return (hMenu != MENU_DefSysPopup);
3573 /**********************************************************************
3574 * GetSystemMenu (USER32.@)
3576 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3578 WND *wndPtr = WIN_FindWndPtr( hWnd );
3579 HMENU retvalue = 0;
3581 if (wndPtr)
3583 if( wndPtr->hSysMenu )
3585 if( bRevert )
3587 DestroyMenu(wndPtr->hSysMenu);
3588 wndPtr->hSysMenu = 0;
3590 else
3592 POPUPMENU *menu = MENU_GetMenu( wndPtr->hSysMenu );
3593 if( menu )
3595 if( menu->nItems > 0 && menu->items[0].hSubMenu == MENU_DefSysPopup )
3596 menu->items[0].hSubMenu = MENU_CopySysPopup();
3598 else
3600 WARN("Current sys-menu (%p) of wnd %p is broken\n",
3601 wndPtr->hSysMenu, hWnd);
3602 wndPtr->hSysMenu = 0;
3607 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
3608 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU)(-1) );
3610 if( wndPtr->hSysMenu )
3612 POPUPMENU *menu;
3613 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
3615 /* Store the dummy sysmenu handle to facilitate the refresh */
3616 /* of the close button if the SC_CLOSE item change */
3617 menu = MENU_GetMenu(retvalue);
3618 if ( menu )
3619 menu->hSysMenuOwner = wndPtr->hSysMenu;
3621 WIN_ReleaseWndPtr(wndPtr);
3623 return bRevert ? 0 : retvalue;
3627 /*******************************************************************
3628 * SetSystemMenu (USER32.@)
3630 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
3632 WND *wndPtr = WIN_FindWndPtr(hwnd);
3634 if (wndPtr)
3636 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
3637 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
3638 WIN_ReleaseWndPtr(wndPtr);
3639 return TRUE;
3641 return FALSE;
3645 /**********************************************************************
3646 * GetMenu (USER32.@)
3648 HMENU WINAPI GetMenu( HWND hWnd )
3650 HMENU retvalue = (HMENU)GetWindowLongW( hWnd, GWL_ID );
3651 TRACE("for %p returning %p\n", hWnd, retvalue);
3652 return retvalue;
3656 /**********************************************************************
3657 * MENU_SetMenu
3659 * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
3660 * SetWindowPos call that would result if SetMenu were called directly.
3662 BOOL MENU_SetMenu( HWND hWnd, HMENU hMenu )
3664 TRACE("(%p, %p);\n", hWnd, hMenu);
3666 if (hMenu && !IsMenu(hMenu))
3668 WARN("hMenu %p is not a menu handle\n", hMenu);
3669 return FALSE;
3671 if (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
3673 hWnd = WIN_GetFullHandle( hWnd );
3674 if (GetCapture() == hWnd) MENU_SetCapture(0); /* release the capture */
3676 if (hMenu != 0)
3678 LPPOPUPMENU lpmenu;
3680 if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
3682 lpmenu->hWnd = hWnd;
3683 lpmenu->Height = 0; /* Make sure we recalculate the size */
3685 SetWindowLongW( hWnd, GWL_ID, (LONG_PTR)hMenu );
3686 return TRUE;
3690 /**********************************************************************
3691 * SetMenu (USER32.@)
3693 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
3695 if(!MENU_SetMenu(hWnd, hMenu))
3696 return FALSE;
3698 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3699 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3700 return TRUE;
3704 /**********************************************************************
3705 * GetSubMenu (USER32.@)
3707 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
3709 MENUITEM * lpmi;
3711 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return 0;
3712 if (!(lpmi->fType & MF_POPUP)) return 0;
3713 return lpmi->hSubMenu;
3717 /**********************************************************************
3718 * DrawMenuBar (USER32.@)
3720 BOOL WINAPI DrawMenuBar( HWND hWnd )
3722 LPPOPUPMENU lppop;
3723 HMENU hMenu = GetMenu(hWnd);
3725 if (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
3726 if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
3728 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
3729 lppop->hwndOwner = hWnd;
3730 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3731 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3732 return TRUE;
3735 /***********************************************************************
3736 * DrawMenuBarTemp (USER32.@)
3738 * UNDOCUMENTED !!
3740 * called by W98SE desk.cpl Control Panel Applet
3742 * Not 100% sure about the param names, but close.
3744 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont)
3746 LPPOPUPMENU lppop;
3747 UINT i,retvalue;
3748 HFONT hfontOld = 0;
3750 if (!hMenu)
3751 hMenu = GetMenu(hwnd);
3753 if (!hFont)
3754 hFont = hMenuFont;
3756 lppop = MENU_GetMenu( hMenu );
3757 if (lppop == NULL || lprect == NULL)
3759 retvalue = GetSystemMetrics(SM_CYMENU);
3760 goto END;
3763 TRACE("(%p, %p, %p, %p, %p)\n", hwnd, hDC, lprect, hMenu, hFont);
3765 hfontOld = SelectObject( hDC, hFont);
3767 if (lppop->Height == 0)
3768 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
3770 lprect->bottom = lprect->top + lppop->Height;
3772 FillRect(hDC, lprect, GetSysColorBrush(COLOR_MENU) );
3774 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
3775 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
3776 LineTo( hDC, lprect->right, lprect->bottom );
3778 if (lppop->nItems == 0)
3780 retvalue = GetSystemMetrics(SM_CYMENU);
3781 goto END;
3784 for (i = 0; i < lppop->nItems; i++)
3786 MENU_DrawMenuItem( hwnd, hMenu, hwnd,
3787 hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
3789 retvalue = lppop->Height;
3791 END:
3792 if (hfontOld) SelectObject (hDC, hfontOld);
3793 return retvalue;
3796 /***********************************************************************
3797 * EndMenu (USER.187)
3798 * EndMenu (USER32.@)
3800 void WINAPI EndMenu(void)
3802 /* if we are in the menu code, and it is active */
3803 if (!fEndMenu && top_popup)
3805 /* terminate the menu handling code */
3806 fEndMenu = TRUE;
3808 /* needs to be posted to wakeup the internal menu handler */
3809 /* which will now terminate the menu, in the event that */
3810 /* the main window was minimized, or lost focus, so we */
3811 /* don't end up with an orphaned menu */
3812 PostMessageW( top_popup, WM_CANCELMODE, 0, 0);
3817 /***********************************************************************
3818 * LookupMenuHandle (USER.217)
3820 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
3822 HMENU hmenu32 = HMENU_32(hmenu);
3823 UINT id32 = id;
3824 if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
3825 else return HMENU_16(hmenu32);
3829 /**********************************************************************
3830 * LoadMenu (USER.150)
3832 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
3834 HRSRC16 hRsrc;
3835 HGLOBAL16 handle;
3836 HMENU16 hMenu;
3838 if (HIWORD(name) && name[0] == '#') name = (LPCSTR)atoi( name + 1 );
3839 if (!name) return 0;
3841 instance = GetExePtr( instance );
3842 if (!(hRsrc = FindResource16( instance, name, (LPSTR)RT_MENU ))) return 0;
3843 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
3844 hMenu = LoadMenuIndirect16(LockResource16(handle));
3845 FreeResource16( handle );
3846 return hMenu;
3850 /*****************************************************************
3851 * LoadMenuA (USER32.@)
3853 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
3855 HRSRC hrsrc = FindResourceA( instance, name, (LPSTR)RT_MENU );
3856 if (!hrsrc) return 0;
3857 return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
3861 /*****************************************************************
3862 * LoadMenuW (USER32.@)
3864 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
3866 HRSRC hrsrc = FindResourceW( instance, name, (LPWSTR)RT_MENU );
3867 if (!hrsrc) return 0;
3868 return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
3872 /**********************************************************************
3873 * LoadMenuIndirect (USER.220)
3875 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
3877 HMENU hMenu;
3878 WORD version, offset;
3879 LPCSTR p = (LPCSTR)template;
3881 TRACE("(%p)\n", template );
3882 version = GET_WORD(p);
3883 p += sizeof(WORD);
3884 if (version)
3886 WARN("version must be 0 for Win16\n" );
3887 return 0;
3889 offset = GET_WORD(p);
3890 p += sizeof(WORD) + offset;
3891 if (!(hMenu = CreateMenu())) return 0;
3892 if (!MENU_ParseResource( p, hMenu, FALSE ))
3894 DestroyMenu( hMenu );
3895 return 0;
3897 return HMENU_16(hMenu);
3901 /**********************************************************************
3902 * LoadMenuIndirectW (USER32.@)
3904 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
3906 HMENU hMenu;
3907 WORD version, offset;
3908 LPCSTR p = (LPCSTR)template;
3910 version = GET_WORD(p);
3911 p += sizeof(WORD);
3912 TRACE("%p, ver %d\n", template, version );
3913 switch (version)
3915 case 0: /* standard format is version of 0 */
3916 offset = GET_WORD(p);
3917 p += sizeof(WORD) + offset;
3918 if (!(hMenu = CreateMenu())) return 0;
3919 if (!MENU_ParseResource( p, hMenu, TRUE ))
3921 DestroyMenu( hMenu );
3922 return 0;
3924 return hMenu;
3925 case 1: /* extended format is version of 1 */
3926 offset = GET_WORD(p);
3927 p += sizeof(WORD) + offset;
3928 if (!(hMenu = CreateMenu())) return 0;
3929 if (!MENUEX_ParseResource( p, hMenu))
3931 DestroyMenu( hMenu );
3932 return 0;
3934 return hMenu;
3935 default:
3936 ERR("version %d not supported.\n", version);
3937 return 0;
3942 /**********************************************************************
3943 * LoadMenuIndirectA (USER32.@)
3945 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
3947 return LoadMenuIndirectW( template );
3951 /**********************************************************************
3952 * IsMenu (USER32.@)
3954 BOOL WINAPI IsMenu(HMENU hmenu)
3956 LPPOPUPMENU menu = MENU_GetMenu(hmenu);
3957 return menu != NULL;
3960 /**********************************************************************
3961 * GetMenuItemInfo_common
3964 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
3965 LPMENUITEMINFOW lpmii, BOOL unicode)
3967 MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos? MF_BYPOSITION : 0);
3969 debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
3971 if (!menu)
3972 return FALSE;
3974 if (lpmii->fMask & MIIM_TYPE) {
3975 lpmii->fType = menu->fType;
3976 switch (MENU_ITEM_TYPE(menu->fType)) {
3977 case MF_STRING:
3978 break; /* will be done below */
3979 case MF_OWNERDRAW:
3980 case MF_BITMAP:
3981 lpmii->dwTypeData = menu->text;
3982 /* fall through */
3983 default:
3984 lpmii->cch = 0;
3988 /* copy the text string */
3989 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING)) &&
3990 (MENU_ITEM_TYPE(menu->fType) == MF_STRING) && menu->text)
3992 int len;
3993 if (unicode)
3995 len = strlenW(menu->text);
3996 if(lpmii->dwTypeData && lpmii->cch)
3997 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
3999 else
4001 len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL, 0, NULL, NULL );
4002 if(lpmii->dwTypeData && lpmii->cch)
4003 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4004 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4005 ((LPSTR)lpmii->dwTypeData)[lpmii->cch-1] = 0;
4007 /* if we've copied a substring we return its length */
4008 if(lpmii->dwTypeData && lpmii->cch)
4010 if (lpmii->cch <= len) lpmii->cch--;
4012 else /* return length of string */
4013 lpmii->cch = len;
4016 if (lpmii->fMask & MIIM_FTYPE)
4017 lpmii->fType = menu->fType;
4019 if (lpmii->fMask & MIIM_BITMAP)
4020 lpmii->hbmpItem = menu->hbmpItem;
4022 if (lpmii->fMask & MIIM_STATE)
4023 lpmii->fState = menu->fState;
4025 if (lpmii->fMask & MIIM_ID)
4026 lpmii->wID = menu->wID;
4028 if (lpmii->fMask & MIIM_SUBMENU)
4029 lpmii->hSubMenu = menu->hSubMenu;
4031 if (lpmii->fMask & MIIM_CHECKMARKS) {
4032 lpmii->hbmpChecked = menu->hCheckBit;
4033 lpmii->hbmpUnchecked = menu->hUnCheckBit;
4035 if (lpmii->fMask & MIIM_DATA)
4036 lpmii->dwItemData = menu->dwItemData;
4038 return TRUE;
4041 /**********************************************************************
4042 * GetMenuItemInfoA (USER32.@)
4044 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4045 LPMENUITEMINFOA lpmii)
4047 return GetMenuItemInfo_common (hmenu, item, bypos,
4048 (LPMENUITEMINFOW)lpmii, FALSE);
4051 /**********************************************************************
4052 * GetMenuItemInfoW (USER32.@)
4054 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4055 LPMENUITEMINFOW lpmii)
4057 return GetMenuItemInfo_common (hmenu, item, bypos,
4058 lpmii, TRUE);
4062 /* set a menu item text from a ASCII or Unicode string */
4063 inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4065 if (!text)
4067 menu->text = NULL;
4068 menu->fType |= MF_SEPARATOR;
4070 else if (unicode)
4072 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4073 strcpyW( menu->text, text );
4075 else
4077 LPCSTR str = (LPCSTR)text;
4078 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4079 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4080 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4085 /**********************************************************************
4086 * SetMenuItemInfo_common
4089 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4090 const MENUITEMINFOW *lpmii,
4091 BOOL unicode)
4093 if (!menu) return FALSE;
4095 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu, "");
4097 if (lpmii->fMask & MIIM_TYPE ) {
4098 /* Get rid of old string. */
4099 if (IS_STRING_ITEM(menu->fType) && menu->text) {
4100 HeapFree(GetProcessHeap(), 0, menu->text);
4101 menu->text = NULL;
4104 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4105 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4106 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4108 menu->text = lpmii->dwTypeData;
4110 if (IS_STRING_ITEM(menu->fType))
4111 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4114 if (lpmii->fMask & MIIM_FTYPE ) {
4115 /* free the string when the type is changing */
4116 if ( (!IS_STRING_ITEM(lpmii->fType)) && IS_STRING_ITEM(menu->fType) && menu->text) {
4117 HeapFree(GetProcessHeap(), 0, menu->text);
4118 menu->text = NULL;
4120 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4121 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4122 if ( IS_STRING_ITEM(menu->fType) && !menu->text )
4123 menu->fType |= MF_SEPARATOR;
4126 if (lpmii->fMask & MIIM_STRING ) {
4127 if (IS_STRING_ITEM(menu->fType)) {
4128 /* free the string when used */
4129 if(menu->text)
4130 HeapFree(GetProcessHeap(), 0, menu->text);
4131 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4135 if (lpmii->fMask & MIIM_STATE)
4137 /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4138 menu->fState = lpmii->fState;
4141 if (lpmii->fMask & MIIM_ID)
4142 menu->wID = lpmii->wID;
4144 if (lpmii->fMask & MIIM_SUBMENU) {
4145 menu->hSubMenu = lpmii->hSubMenu;
4146 if (menu->hSubMenu) {
4147 POPUPMENU *subMenu = MENU_GetMenu(menu->hSubMenu);
4148 if (subMenu) {
4149 subMenu->wFlags |= MF_POPUP;
4150 menu->fType |= MF_POPUP;
4152 else
4153 /* FIXME: Return an error ? */
4154 menu->fType &= ~MF_POPUP;
4156 else
4157 menu->fType &= ~MF_POPUP;
4160 if (lpmii->fMask & MIIM_CHECKMARKS)
4162 if (lpmii->fType & MFT_RADIOCHECK)
4163 menu->fType |= MFT_RADIOCHECK;
4165 menu->hCheckBit = lpmii->hbmpChecked;
4166 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4168 if (lpmii->fMask & MIIM_DATA)
4169 menu->dwItemData = lpmii->dwItemData;
4171 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4172 return TRUE;
4175 /**********************************************************************
4176 * SetMenuItemInfoA (USER32.@)
4178 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4179 const MENUITEMINFOA *lpmii)
4181 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4182 (const MENUITEMINFOW *)lpmii, FALSE);
4185 /**********************************************************************
4186 * SetMenuItemInfoW (USER32.@)
4188 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4189 const MENUITEMINFOW *lpmii)
4191 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4192 lpmii, TRUE);
4195 /**********************************************************************
4196 * SetMenuDefaultItem (USER32.@)
4199 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4201 UINT i;
4202 POPUPMENU *menu;
4203 MENUITEM *item;
4205 TRACE("(%p,%d,%d)\n", hmenu, uItem, bypos);
4207 if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4209 /* reset all default-item flags */
4210 item = menu->items;
4211 for (i = 0; i < menu->nItems; i++, item++)
4213 item->fState &= ~MFS_DEFAULT;
4216 /* no default item */
4217 if ( -1 == uItem)
4219 return TRUE;
4222 item = menu->items;
4223 if ( bypos )
4225 if ( uItem >= menu->nItems ) return FALSE;
4226 item[uItem].fState |= MFS_DEFAULT;
4227 return TRUE;
4229 else
4231 for (i = 0; i < menu->nItems; i++, item++)
4233 if (item->wID == uItem)
4235 item->fState |= MFS_DEFAULT;
4236 return TRUE;
4241 return FALSE;
4244 /**********************************************************************
4245 * GetMenuDefaultItem (USER32.@)
4247 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4249 POPUPMENU *menu;
4250 MENUITEM * item;
4251 UINT i = 0;
4253 TRACE("(%p,%d,%d)\n", hmenu, bypos, flags);
4255 if (!(menu = MENU_GetMenu(hmenu))) return -1;
4257 /* find default item */
4258 item = menu->items;
4260 /* empty menu */
4261 if (! item) return -1;
4263 while ( !( item->fState & MFS_DEFAULT ) )
4265 i++; item++;
4266 if (i >= menu->nItems ) return -1;
4269 /* default: don't return disabled items */
4270 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4272 /* search rekursiv when needed */
4273 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4275 UINT ret;
4276 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4277 if ( -1 != ret ) return ret;
4279 /* when item not found in submenu, return the popup item */
4281 return ( bypos ) ? i : item->wID;
4286 /**********************************************************************
4287 * InsertMenuItemA (USER32.@)
4289 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4290 const MENUITEMINFOA *lpmii)
4292 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4293 return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)lpmii, FALSE);
4297 /**********************************************************************
4298 * InsertMenuItemW (USER32.@)
4300 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4301 const MENUITEMINFOW *lpmii)
4303 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4304 return SetMenuItemInfo_common(item, lpmii, TRUE);
4307 /**********************************************************************
4308 * CheckMenuRadioItem (USER32.@)
4311 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4312 UINT first, UINT last, UINT check,
4313 UINT bypos)
4315 MENUITEM *mifirst, *milast, *micheck;
4316 HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4318 TRACE("%p: %d-%d, check %d, bypos=%d\n", hMenu, first, last, check, bypos);
4320 mifirst = MENU_FindItem (&mfirst, &first, bypos);
4321 milast = MENU_FindItem (&mlast, &last, bypos);
4322 micheck = MENU_FindItem (&mcheck, &check, bypos);
4324 if (mifirst == NULL || milast == NULL || micheck == NULL ||
4325 mifirst > milast || mfirst != mlast || mfirst != mcheck ||
4326 micheck > milast || micheck < mifirst)
4327 return FALSE;
4329 while (mifirst <= milast)
4331 if (mifirst == micheck)
4333 mifirst->fType |= MFT_RADIOCHECK;
4334 mifirst->fState |= MFS_CHECKED;
4335 } else {
4336 mifirst->fType &= ~MFT_RADIOCHECK;
4337 mifirst->fState &= ~MFS_CHECKED;
4339 mifirst++;
4342 return TRUE;
4346 /**********************************************************************
4347 * GetMenuItemRect (USER32.@)
4349 * ATTENTION: Here, the returned values in rect are the screen
4350 * coordinates of the item just like if the menu was
4351 * always on the upper left side of the application.
4354 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4355 LPRECT rect)
4357 POPUPMENU *itemMenu;
4358 MENUITEM *item;
4359 HWND referenceHwnd;
4361 TRACE("(%p,%p,%d,%p)\n", hwnd, hMenu, uItem, rect);
4363 item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4364 referenceHwnd = hwnd;
4366 if(!hwnd)
4368 itemMenu = MENU_GetMenu(hMenu);
4369 if (itemMenu == NULL)
4370 return FALSE;
4372 if(itemMenu->hWnd == 0)
4373 return FALSE;
4374 referenceHwnd = itemMenu->hWnd;
4377 if ((rect == NULL) || (item == NULL))
4378 return FALSE;
4380 *rect = item->rect;
4382 MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4384 return TRUE;
4388 /**********************************************************************
4389 * SetMenuInfo (USER32.@)
4391 * FIXME
4392 * MIM_APPLYTOSUBMENUS
4393 * actually use the items to draw the menu
4395 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4397 POPUPMENU *menu;
4399 TRACE("(%p %p)\n", hMenu, lpmi);
4401 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4404 if (lpmi->fMask & MIM_BACKGROUND)
4405 menu->hbrBack = lpmi->hbrBack;
4407 if (lpmi->fMask & MIM_HELPID)
4408 menu->dwContextHelpID = lpmi->dwContextHelpID;
4410 if (lpmi->fMask & MIM_MAXHEIGHT)
4411 menu->cyMax = lpmi->cyMax;
4413 if (lpmi->fMask & MIM_MENUDATA)
4414 menu->dwMenuData = lpmi->dwMenuData;
4416 if (lpmi->fMask & MIM_STYLE)
4417 menu->dwStyle = lpmi->dwStyle;
4419 return TRUE;
4421 return FALSE;
4424 /**********************************************************************
4425 * GetMenuInfo (USER32.@)
4427 * NOTES
4428 * win98/NT5.0
4431 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4432 { POPUPMENU *menu;
4434 TRACE("(%p %p)\n", hMenu, lpmi);
4436 if (lpmi && (menu = MENU_GetMenu(hMenu)))
4439 if (lpmi->fMask & MIM_BACKGROUND)
4440 lpmi->hbrBack = menu->hbrBack;
4442 if (lpmi->fMask & MIM_HELPID)
4443 lpmi->dwContextHelpID = menu->dwContextHelpID;
4445 if (lpmi->fMask & MIM_MAXHEIGHT)
4446 lpmi->cyMax = menu->cyMax;
4448 if (lpmi->fMask & MIM_MENUDATA)
4449 lpmi->dwMenuData = menu->dwMenuData;
4451 if (lpmi->fMask & MIM_STYLE)
4452 lpmi->dwStyle = menu->dwStyle;
4454 return TRUE;
4456 return FALSE;
4460 /**********************************************************************
4461 * SetMenuContextHelpId (USER32.@)
4463 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4465 LPPOPUPMENU menu;
4467 TRACE("(%p 0x%08lx)\n", hMenu, dwContextHelpID);
4469 if ((menu = MENU_GetMenu(hMenu)))
4471 menu->dwContextHelpID = dwContextHelpID;
4472 return TRUE;
4474 return FALSE;
4478 /**********************************************************************
4479 * GetMenuContextHelpId (USER32.@)
4481 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4483 LPPOPUPMENU menu;
4485 TRACE("(%p)\n", hMenu);
4487 if ((menu = MENU_GetMenu(hMenu)))
4489 return menu->dwContextHelpID;
4491 return 0;
4494 /**********************************************************************
4495 * MenuItemFromPoint (USER32.@)
4497 UINT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
4499 POPUPMENU *menu = MENU_GetMenu(hMenu);
4500 UINT pos;
4501 MENUITEM *item;
4503 /*FIXME: Do we have to handle hWnd here? */
4504 item = MENU_FindItemByCoords(menu, ptScreen, &pos);
4506 return pos;
4510 /**********************************************************************
4511 * translate_accelerator
4513 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
4514 BYTE fVirt, WORD key, WORD cmd )
4516 UINT mesg = 0;
4518 if (wParam != key) return FALSE;
4520 if (message == WM_CHAR)
4522 if ( !(fVirt & FALT) && !(fVirt & FVIRTKEY) )
4524 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
4525 goto found;
4528 else
4530 if(fVirt & FVIRTKEY)
4532 INT mask = 0;
4533 TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
4534 wParam, 0xff & HIWORD(lParam));
4535 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
4536 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
4537 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
4538 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
4539 TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
4541 else
4543 if (!(lParam & 0x01000000)) /* no special_key */
4545 if ((fVirt & FALT) && (lParam & 0x20000000))
4546 { /* ^^ ALT pressed */
4547 TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
4548 goto found;
4553 return FALSE;
4555 found:
4556 if (message == WM_KEYUP || message == WM_SYSKEYUP)
4557 mesg = 1;
4558 else
4560 HMENU hMenu, hSubMenu, hSysMenu;
4561 UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
4563 hMenu = (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
4564 hSysMenu = get_win_sys_menu( hWnd );
4566 /* find menu item and ask application to initialize it */
4567 /* 1. in the system menu */
4568 hSubMenu = hSysMenu;
4569 nPos = cmd;
4570 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4572 if (GetCapture())
4573 mesg = 2;
4574 if (!IsWindowEnabled(hWnd))
4575 mesg = 3;
4576 else
4578 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
4579 if(hSubMenu != hSysMenu)
4581 nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
4582 TRACE_(accel)("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hSysMenu, hSubMenu, nPos);
4583 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
4585 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
4588 else /* 2. in the window's menu */
4590 hSubMenu = hMenu;
4591 nPos = cmd;
4592 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4594 if (GetCapture())
4595 mesg = 2;
4596 if (!IsWindowEnabled(hWnd))
4597 mesg = 3;
4598 else
4600 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
4601 if(hSubMenu != hMenu)
4603 nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
4604 TRACE_(accel)("hMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
4605 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
4607 uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
4612 if (mesg == 0)
4614 if (uSysStat != (UINT)-1)
4616 if (uSysStat & (MF_DISABLED|MF_GRAYED))
4617 mesg=4;
4618 else
4619 mesg=WM_SYSCOMMAND;
4621 else
4623 if (uStat != (UINT)-1)
4625 if (IsIconic(hWnd))
4626 mesg=5;
4627 else
4629 if (uStat & (MF_DISABLED|MF_GRAYED))
4630 mesg=6;
4631 else
4632 mesg=WM_COMMAND;
4635 else
4636 mesg=WM_COMMAND;
4641 if( mesg==WM_COMMAND )
4643 TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
4644 SendMessageW(hWnd, mesg, 0x10000 | cmd, 0L);
4646 else if( mesg==WM_SYSCOMMAND )
4648 TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
4649 SendMessageW(hWnd, mesg, cmd, 0x00010000L);
4651 else
4653 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4654 * #0: unknown (please report!)
4655 * #1: for WM_KEYUP,WM_SYSKEYUP
4656 * #2: mouse is captured
4657 * #3: window is disabled
4658 * #4: it's a disabled system menu option
4659 * #5: it's a menu option, but window is iconic
4660 * #6: it's a menu option, but disabled
4662 TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
4663 if(mesg==0)
4664 ERR_(accel)(" unknown reason - please report!\n");
4666 return TRUE;
4669 /**********************************************************************
4670 * TranslateAccelerator (USER32.@)
4671 * TranslateAcceleratorA (USER32.@)
4672 * TranslateAcceleratorW (USER32.@)
4674 INT WINAPI TranslateAcceleratorW( HWND hWnd, HACCEL hAccel, LPMSG msg )
4676 /* YES, Accel16! */
4677 LPACCEL16 lpAccelTbl;
4678 int i;
4680 if (msg == NULL)
4682 WARN_(accel)("msg null; should hang here to be win compatible\n");
4683 return 0;
4685 if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
4687 WARN_(accel)("invalid accel handle=%p\n", hAccel);
4688 return 0;
4690 if ((msg->message != WM_KEYDOWN &&
4691 msg->message != WM_KEYUP &&
4692 msg->message != WM_SYSKEYDOWN &&
4693 msg->message != WM_SYSKEYUP &&
4694 msg->message != WM_CHAR)) return 0;
4696 TRACE_(accel)("TranslateAccelerators hAccel=%p, hWnd=%p,"
4697 "msg->hwnd=%p, msg->message=%04x, wParam=%08x, lParam=%lx\n",
4698 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
4700 i = 0;
4703 if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
4704 lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
4705 return 1;
4706 } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
4707 WARN_(accel)("couldn't translate accelerator key\n");
4708 return 0;