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.
30 #include "wine/port.h"
40 #include "wine/winbase16.h"
41 #include "wine/winuser16.h"
42 #include "wine/unicode.h"
45 #include "nonclient.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(menu);
52 WINE_DECLARE_DEBUG_CHANNEL(accel);
54 /* internal popup menu window messages */
56 #define MM_SETMENUHANDLE (WM_USER + 0)
57 #define MM_GETMENUHANDLE (WM_USER + 1)
59 /* Menu item structure */
61 /* ----------- MENUITEMINFO Stuff ----------- */
62 UINT fType; /* Item type. */
63 UINT fState; /* Item state. */
64 UINT wID; /* Item id. */
65 HMENU hSubMenu; /* Pop-up menu. */
66 HBITMAP hCheckBit; /* Bitmap when checked. */
67 HBITMAP hUnCheckBit; /* Bitmap when unchecked. */
68 LPWSTR text; /* Item text or bitmap handle. */
69 DWORD dwItemData; /* Application defined. */
70 DWORD dwTypeData; /* depends on fMask */
71 HBITMAP hbmpItem; /* bitmap in win98 style menus */
72 /* ----------- Wine stuff ----------- */
73 RECT rect; /* Item area (relative to menu window) */
74 UINT xTab; /* X position of text after Tab */
77 /* Popup menu structure */
79 WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
80 WORD wMagic; /* Magic number */
81 WORD Width; /* Width of the whole menu */
82 WORD Height; /* Height of the whole menu */
83 UINT nItems; /* Number of items in the menu */
84 HWND hWnd; /* Window containing the menu */
85 MENUITEM *items; /* Array of menu items */
86 UINT FocusedItem; /* Currently focused item */
87 HWND hwndOwner; /* window receiving the messages for ownerdraw */
88 BOOL bTimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
89 /* ------------ MENUINFO members ------ */
90 DWORD dwStyle; /* Extended mennu style */
91 UINT cyMax; /* max hight of the whole menu, 0 is screen hight */
92 HBRUSH hbrBack; /* brush for menu background */
93 DWORD dwContextHelpID;
94 DWORD dwMenuData; /* application defined value */
95 HMENU hSysMenuOwner; /* Handle to the dummy sys menu holder */
96 } POPUPMENU, *LPPOPUPMENU;
98 /* internal flags for menu tracking */
100 #define TF_ENDMENU 0x0001
101 #define TF_SUSPENDPOPUP 0x0002
102 #define TF_SKIPREMOVE 0x0004
107 HMENU hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
108 HMENU hTopMenu; /* initial menu */
109 HWND hOwnerWnd; /* where notifications are sent */
113 #define MENU_MAGIC 0x554d /* 'MU' */
118 /* Internal MENU_TrackMenu() flags */
119 #define TPM_INTERNAL 0xF0000000
120 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
121 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
122 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
124 /* popup menu shade thickness */
125 #define POPUP_XSHADE 4
126 #define POPUP_YSHADE 4
128 /* Space between 2 menu bar items */
129 #define MENU_BAR_ITEMS_SPACE 12
131 /* Minimum width of a tab character */
132 #define MENU_TAB_SPACE 8
134 /* Height of a separator item */
135 #define SEPARATOR_HEIGHT 5
137 /* (other menu->FocusedItem values give the position of the focused item) */
138 #define NO_SELECTED_ITEM 0xffff
140 #define MENU_ITEM_TYPE(flags) \
141 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
143 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
144 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
145 #define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
147 #define IS_SYSTEM_MENU(menu) \
148 (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
150 #define IS_SYSTEM_POPUP(menu) \
151 ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
153 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
154 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
155 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
156 MF_POPUP | MF_SYSMENU | MF_HELP)
157 #define STATE_MASK (~TYPE_MASK)
159 /* Dimension of the menu bitmaps */
160 static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
162 static HBITMAP hStdMnArrow = 0;
163 static HBITMAP hBmpSysMenu = 0;
165 static HBRUSH hShadeBrush = 0;
166 static HFONT hMenuFont = 0;
167 static HFONT hMenuFontBold = 0;
169 static HMENU MENU_DefSysPopup = 0; /* Default system menu popup */
171 /* Use global popup window because there's no way 2 menus can
172 * be tracked at the same time. */
173 static HWND top_popup;
175 /* Flag set by EndMenu() to force an exit from menu tracking */
176 static BOOL fEndMenu = FALSE;
178 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
181 /*********************************************************************
182 * menu class descriptor
184 const struct builtin_class_descr MENU_builtin_class =
186 POPUPMENU_CLASS_ATOM, /* name */
187 CS_GLOBALCLASS | CS_SAVEBITS, /* style */
188 NULL, /* procA (winproc is Unicode only) */
189 PopupMenuWndProc, /* procW */
190 sizeof(HMENU), /* extra */
191 IDC_ARROWA, /* cursor */
192 COLOR_MENU+1 /* brush */
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) \
210 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
213 static void do_debug_print_menuitem(const char *prefix, MENUITEM * mp,
216 TRACE("%s ", prefix);
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=0x%x", mp->hSubMenu);
226 if (type == MFT_STRING)
228 else if (type == MFT_SEPARATOR)
230 else if (type == MFT_OWNERDRAW)
232 else if (type == MFT_BITMAP)
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 */
247 DPRINTF( "+0x%x", flags);
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");
261 DPRINTF( "+0x%x", flags);
264 DPRINTF( ", Chk=0x%x", mp->hCheckBit);
266 DPRINTF( ", Unc=0x%x", mp->hUnCheckBit);
268 if (type == MFT_STRING) {
270 DPRINTF( ", Text=%s", debugstr_w(mp->text));
272 DPRINTF( ", Text=Null");
273 } else if (mp->text == NULL)
276 DPRINTF( ", Text=%p", mp->text);
278 DPRINTF( ", ItemData=0x%08lx", mp->dwItemData);
284 DPRINTF(" %s\n", postfix);
291 /***********************************************************************
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=%x, ptr=%p, magic=%x\n", hMenu, menu, menu? menu->wMagic:0);
307 /***********************************************************************
310 * Get the system menu of a window
312 static HMENU get_win_sys_menu( HWND hwnd )
315 WND *win = WIN_FindWndPtr( hwnd );
319 WIN_ReleaseWndPtr( win );
324 /***********************************************************************
327 * Return the default system menu.
329 static HMENU MENU_CopySysPopup(void)
331 HMENU hMenu = LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU");
334 POPUPMENU* menu = MENU_GetMenu(hMenu);
335 menu->wFlags |= MF_SYSMENU | MF_POPUP;
336 SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
339 ERR("Unable to load default system menu\n" );
341 TRACE("returning %x.\n", hMenu );
347 /**********************************************************************
350 * Create a copy of the system menu. System menu in Windows is
351 * a special menu bar with the single entry - system menu popup.
352 * This popup is presented to the outside world as a "system menu".
353 * However, the real system menu handle is sometimes seen in the
354 * WM_MENUSELECT parameters (and Word 6 likes it this way).
356 HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
360 TRACE("loading system menu, hWnd %04x, hPopupMenu %04x\n", hWnd, hPopupMenu);
361 if ((hMenu = CreateMenu()))
363 POPUPMENU *menu = MENU_GetMenu(hMenu);
364 menu->wFlags = MF_SYSMENU;
365 menu->hWnd = WIN_GetFullHandle( hWnd );
366 TRACE("hWnd %04x (hMenu %04x)\n", menu->hWnd, hMenu);
368 if (hPopupMenu == (HMENU)(-1))
369 hPopupMenu = MENU_CopySysPopup();
370 else if( !hPopupMenu ) hPopupMenu = MENU_DefSysPopup;
374 InsertMenuA( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION, hPopupMenu, NULL );
376 menu->items[0].fType = MF_SYSMENU | MF_POPUP;
377 menu->items[0].fState = 0;
378 if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags |= MF_SYSMENU;
380 TRACE("hMenu=%04x (hPopup %04x)\n", hMenu, hPopupMenu );
383 DestroyMenu( hMenu );
385 ERR("failed to load system menu!\n");
390 /***********************************************************************
393 * Menus initialisation.
398 NONCLIENTMETRICSA ncm;
400 static unsigned char shade_bits[16] = { 0x55, 0, 0xAA, 0,
405 /* Load menu bitmaps */
406 hStdMnArrow = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_MNARROW));
407 /* Load system buttons bitmaps */
408 hBmpSysMenu = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_CLOSE));
413 GetObjectA( hStdMnArrow, sizeof(bm), &bm );
414 arrow_bitmap_width = bm.bmWidth;
415 arrow_bitmap_height = bm.bmHeight;
419 if (! (hBitmap = CreateBitmap( 8, 8, 1, 1, shade_bits)))
422 if(!(hShadeBrush = CreatePatternBrush( hBitmap )))
425 DeleteObject( hBitmap );
426 if (!(MENU_DefSysPopup = MENU_CopySysPopup()))
429 ncm.cbSize = sizeof (NONCLIENTMETRICSA);
430 if (!(SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &ncm, 0)))
433 if (!(hMenuFont = CreateFontIndirectA( &ncm.lfMenuFont )))
436 ncm.lfMenuFont.lfWeight += 300;
437 if ( ncm.lfMenuFont.lfWeight > 1000)
438 ncm.lfMenuFont.lfWeight = 1000;
440 if (!(hMenuFontBold = CreateFontIndirectA( &ncm.lfMenuFont )))
446 /***********************************************************************
447 * MENU_InitSysMenuPopup
449 * Grey the appropriate items in System menu.
451 static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
455 gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
456 EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
457 gray = ((style & WS_MAXIMIZE) != 0);
458 EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
459 gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
460 EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
461 gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
462 EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
463 gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
464 EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
465 gray = (clsStyle & CS_NOCLOSE) != 0;
467 /* The menu item must keep its state if it's disabled */
469 EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
473 /******************************************************************************
475 * UINT MENU_GetStartOfNextColumn(
478 *****************************************************************************/
480 static UINT MENU_GetStartOfNextColumn(
483 POPUPMENU *menu = MENU_GetMenu(hMenu);
487 return NO_SELECTED_ITEM;
489 i = menu->FocusedItem + 1;
490 if( i == NO_SELECTED_ITEM )
493 for( ; i < menu->nItems; ++i ) {
494 if (menu->items[i].fType & MF_MENUBARBREAK)
498 return NO_SELECTED_ITEM;
502 /******************************************************************************
504 * UINT MENU_GetStartOfPrevColumn(
507 *****************************************************************************/
509 static UINT MENU_GetStartOfPrevColumn(
512 POPUPMENU *menu = MENU_GetMenu(hMenu);
516 return NO_SELECTED_ITEM;
518 if( menu->FocusedItem == 0 || menu->FocusedItem == NO_SELECTED_ITEM )
519 return NO_SELECTED_ITEM;
521 /* Find the start of the column */
523 for(i = menu->FocusedItem; i != 0 &&
524 !(menu->items[i].fType & MF_MENUBARBREAK);
528 return NO_SELECTED_ITEM;
530 for(--i; i != 0; --i) {
531 if (menu->items[i].fType & MF_MENUBARBREAK)
535 TRACE("ret %d.\n", i );
542 /***********************************************************************
545 * Find a menu item. Return a pointer on the item, and modifies *hmenu
546 * in case the item was in a sub-menu.
548 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
553 if (((*hmenu)==0xffff) || (!(menu = MENU_GetMenu(*hmenu)))) return NULL;
554 if (wFlags & MF_BYPOSITION)
556 if (*nPos >= menu->nItems) return NULL;
557 return &menu->items[*nPos];
561 MENUITEM *item = menu->items;
562 for (i = 0; i < menu->nItems; i++, item++)
564 if (item->wID == *nPos)
569 else if (item->fType & MF_POPUP)
571 HMENU hsubmenu = item->hSubMenu;
572 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
584 /***********************************************************************
587 * Find a Sub menu. Return the position of the submenu, and modifies
588 * *hmenu in case it is found in another sub-menu.
589 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
591 UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
596 if (((*hmenu)==0xffff) ||
597 (!(menu = MENU_GetMenu(*hmenu))))
598 return NO_SELECTED_ITEM;
600 for (i = 0; i < menu->nItems; i++, item++) {
601 if(!(item->fType & MF_POPUP)) continue;
602 if (item->hSubMenu == hSubTarget) {
606 HMENU hsubmenu = item->hSubMenu;
607 UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
608 if (pos != NO_SELECTED_ITEM) {
614 return NO_SELECTED_ITEM;
617 /***********************************************************************
620 static void MENU_FreeItemData( MENUITEM* item )
623 if (IS_STRING_ITEM(item->fType) && item->text)
624 HeapFree( GetProcessHeap(), 0, item->text );
627 /***********************************************************************
628 * MENU_FindItemByCoords
630 * Find the item at the specified coordinates (screen coords). Does
631 * not work for child windows and therefore should not be called for
632 * an arbitrary system menu.
634 static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu,
635 POINT pt, UINT *pos )
641 if (!GetWindowRect(menu->hWnd,&wrect)) return NULL;
642 pt.x -= wrect.left;pt.y -= wrect.top;
644 for (i = 0; i < menu->nItems; i++, item++)
646 if ((pt.x >= item->rect.left) && (pt.x < item->rect.right) &&
647 (pt.y >= item->rect.top) && (pt.y < item->rect.bottom))
657 /***********************************************************************
660 * Find the menu item selected by a key press.
661 * Return item id, -1 if none, -2 if we should close the menu.
663 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu,
664 UINT key, BOOL forceMenuChar )
666 TRACE("\tlooking for '%c' in [%04x]\n", (char)key, (UINT16)hmenu );
668 if (!IsMenu( hmenu )) hmenu = GetSubMenu( get_win_sys_menu(hwndOwner), 0);
672 POPUPMENU *menu = MENU_GetMenu( hmenu );
673 MENUITEM *item = menu->items;
681 for (i = 0; i < menu->nItems; i++, item++)
683 if (IS_STRING_ITEM(item->fType) && item->text)
685 WCHAR *p = item->text - 2;
688 p = strchrW (p + 2, '&');
690 while (p != NULL && p [1] == '&');
691 if (p && (toupper(p[1]) == key)) return i;
695 menuchar = SendMessageA( hwndOwner, WM_MENUCHAR,
696 MAKEWPARAM( key, menu->wFlags ), hmenu );
697 if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
698 if (HIWORD(menuchar) == 1) return (UINT)(-2);
704 /***********************************************************************
705 * MENU_GetBitmapItemSize
707 * Get the size of a bitmap item.
709 static void MENU_GetBitmapItemSize( UINT id, DWORD data, SIZE *size )
712 HBITMAP bmp = (HBITMAP)id;
714 size->cx = size->cy = 0;
716 /* check if there is a magic menu item associated with this item */
717 if (id && IS_MAGIC_ITEM( id ))
728 case HBMMENU_MBAR_RESTORE:
729 case HBMMENU_MBAR_MINIMIZE:
730 case HBMMENU_MBAR_MINIMIZE_D:
731 case HBMMENU_MBAR_CLOSE:
732 case HBMMENU_MBAR_CLOSE_D:
733 size->cx = GetSystemMetrics( SM_CXSIZE );
734 size->cy = GetSystemMetrics( SM_CYSIZE );
736 case HBMMENU_CALLBACK:
737 case HBMMENU_POPUP_CLOSE:
738 case HBMMENU_POPUP_RESTORE:
739 case HBMMENU_POPUP_MAXIMIZE:
740 case HBMMENU_POPUP_MINIMIZE:
742 FIXME("Magic 0x%08x not implemented\n", id);
746 if (GetObjectA(bmp, sizeof(bm), &bm ))
748 size->cx = bm.bmWidth;
749 size->cy = bm.bmHeight;
753 /***********************************************************************
754 * MENU_DrawBitmapItem
756 * Draw a bitmap item.
758 static void MENU_DrawBitmapItem( HDC hdc, MENUITEM *lpitem, const RECT *rect, BOOL menuBar )
763 HBITMAP bmp = (HBITMAP)lpitem->text;
764 int w = rect->right - rect->left;
765 int h = rect->bottom - rect->top;
769 /* Check if there is a magic menu item associated with this item */
770 if (lpitem->text && IS_MAGIC_ITEM(lpitem->text))
775 switch(LOWORD(lpitem->text))
778 if (lpitem->dwItemData)
780 bmp = (HBITMAP)lpitem->dwItemData;
781 if (!GetObjectA( bmp, sizeof(bm), &bm )) return;
786 if (!GetObjectA( bmp, sizeof(bm), &bm )) return;
787 /* only use right half of the bitmap */
788 bmp_xoffset = bm.bmWidth / 2;
789 bm.bmWidth -= bmp_xoffset;
792 case HBMMENU_MBAR_RESTORE:
793 flags = DFCS_CAPTIONRESTORE;
795 case HBMMENU_MBAR_MINIMIZE:
796 flags = DFCS_CAPTIONMIN;
798 case HBMMENU_MBAR_MINIMIZE_D:
799 flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
801 case HBMMENU_MBAR_CLOSE:
802 flags = DFCS_CAPTIONCLOSE;
804 case HBMMENU_MBAR_CLOSE_D:
805 flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
807 case HBMMENU_CALLBACK:
808 case HBMMENU_POPUP_CLOSE:
809 case HBMMENU_POPUP_RESTORE:
810 case HBMMENU_POPUP_MAXIMIZE:
811 case HBMMENU_POPUP_MINIMIZE:
813 FIXME("Magic 0x%08x not implemented\n", LOWORD(lpitem->text));
817 InflateRect( &r, -1, -1 );
818 if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
819 DrawFrameControl( hdc, &r, DFC_CAPTION, flags );
823 if (!bmp || !GetObjectA( bmp, sizeof(bm), &bm )) return;
826 hdcMem = CreateCompatibleDC( hdc );
827 SelectObject( hdcMem, bmp );
829 /* handle fontsize > bitmap_height */
830 top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
832 if (TWEAK_WineLook == WIN95_LOOK) {
833 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(lpitem->text)) ? NOTSRCCOPY : SRCCOPY;
834 if ((lpitem->fState & MF_HILITE) && IS_BITMAP_ITEM(lpitem->fType))
835 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
839 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_ITEM(lpitem->text) && (!menuBar)) ? MERGEPAINT : SRCCOPY;
841 BitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop );
846 /***********************************************************************
849 * Calculate the size of the menu item and store it in lpitem->rect.
851 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
852 INT orgX, INT orgY, BOOL menuBar )
855 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
857 TRACE("dc=0x%04x owner=0x%04x (%d,%d)\n", hdc, hwndOwner, orgX, orgY);
858 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem,
859 (menuBar ? " (MenuBar)" : ""));
861 SetRect( &lpitem->rect, orgX, orgY, orgX, orgY );
863 if (lpitem->fType & MF_OWNERDRAW)
866 ** Experimentation under Windows reveals that an owner-drawn
867 ** menu is expected to return the size of the content part of
868 ** the menu item, not including the checkmark nor the submenu
869 ** arrow. Windows adds those values itself and returns the
870 ** enlarged rectangle on subsequent WM_DRAWITEM messages.
872 MEASUREITEMSTRUCT mis;
873 mis.CtlType = ODT_MENU;
875 mis.itemID = lpitem->wID;
876 mis.itemData = (DWORD)lpitem->dwItemData;
879 SendMessageA( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&mis );
880 lpitem->rect.right += mis.itemWidth;
884 lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
887 /* under at least win95 you seem to be given a standard
888 height for the menu and the height value is ignored */
890 if (TWEAK_WineLook == WIN31_LOOK)
891 lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU);
893 lpitem->rect.bottom += GetSystemMetrics(SM_CYMENU)-1;
896 lpitem->rect.bottom += mis.itemHeight;
898 TRACE("id=%04x size=%dx%d\n",
899 lpitem->wID, mis.itemWidth, mis.itemHeight);
900 /* Fall through to get check/arrow width calculation. */
903 if (lpitem->fType & MF_SEPARATOR)
905 lpitem->rect.bottom += SEPARATOR_HEIGHT;
911 lpitem->rect.right += 2 * check_bitmap_width;
912 if (lpitem->fType & MF_POPUP)
913 lpitem->rect.right += arrow_bitmap_width;
916 if (lpitem->fType & MF_OWNERDRAW)
919 if (IS_BITMAP_ITEM(lpitem->fType))
923 MENU_GetBitmapItemSize( (int)lpitem->text, lpitem->dwItemData, &size );
924 lpitem->rect.right += size.cx;
925 lpitem->rect.bottom += size.cy;
926 if (TWEAK_WineLook == WIN98_LOOK)
928 /* Leave space for the sunken border */
929 lpitem->rect.right += 2;
930 lpitem->rect.bottom += 2;
935 /* it must be a text item - unless it's the system menu */
936 if (!(lpitem->fType & MF_SYSMENU) && IS_STRING_ITEM( lpitem->fType ))
939 GetTextExtentPoint32W(hdc, lpitem->text, strlenW(lpitem->text), &size);
941 lpitem->rect.right += size.cx;
942 if (TWEAK_WineLook == WIN31_LOOK)
943 lpitem->rect.bottom += max( size.cy, GetSystemMetrics(SM_CYMENU) );
945 lpitem->rect.bottom += max(size.cy, GetSystemMetrics(SM_CYMENU)-1);
950 lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
952 else if ((p = strchrW( lpitem->text, '\t' )) != NULL)
954 /* Item contains a tab (only meaningful in popup menus) */
955 GetTextExtentPoint32W(hdc, lpitem->text, (int)(p - lpitem->text) , &size);
956 lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE + size.cx;
957 lpitem->rect.right += MENU_TAB_SPACE;
961 if (strchrW( lpitem->text, '\b' ))
962 lpitem->rect.right += MENU_TAB_SPACE;
963 lpitem->xTab = lpitem->rect.right - check_bitmap_width
964 - arrow_bitmap_width;
967 TRACE("(%d,%d)-(%d,%d)\n", lpitem->rect.left, lpitem->rect.top, lpitem->rect.right, lpitem->rect.bottom);
971 /***********************************************************************
972 * MENU_PopupMenuCalcSize
974 * Calculate the size of a popup menu.
976 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
981 int orgX, orgY, maxX, maxTab, maxTabWidth;
983 lppop->Width = lppop->Height = 0;
984 if (lppop->nItems == 0) return;
987 SelectObject( hdc, hMenuFont);
990 maxX = (TWEAK_WineLook == WIN31_LOOK) ? GetSystemMetrics(SM_CXBORDER) : 2+1 ;
992 while (start < lppop->nItems)
994 lpitem = &lppop->items[start];
996 orgY = (TWEAK_WineLook == WIN31_LOOK) ? GetSystemMetrics(SM_CYBORDER) : 2;
998 maxTab = maxTabWidth = 0;
1000 /* Parse items until column break or end of menu */
1001 for (i = start; i < lppop->nItems; i++, lpitem++)
1004 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1006 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE );
1008 if (lpitem->fType & MF_MENUBARBREAK) orgX++;
1009 maxX = max( maxX, lpitem->rect.right );
1010 orgY = lpitem->rect.bottom;
1011 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1013 maxTab = max( maxTab, lpitem->xTab );
1014 maxTabWidth = max(maxTabWidth,lpitem->rect.right-lpitem->xTab);
1018 /* Finish the column (set all items to the largest width found) */
1019 maxX = max( maxX, maxTab + maxTabWidth );
1020 for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
1022 lpitem->rect.right = maxX;
1023 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1024 lpitem->xTab = maxTab;
1027 lppop->Height = max( lppop->Height, orgY );
1030 lppop->Width = maxX;
1032 /* space for 3d border */
1033 if(TWEAK_WineLook > WIN31_LOOK)
1039 ReleaseDC( 0, hdc );
1043 /***********************************************************************
1044 * MENU_MenuBarCalcSize
1046 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1047 * height is off by 1 pixel which causes lengthy window relocations when
1048 * active document window is maximized/restored.
1050 * Calculate the size of the menu bar.
1052 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect,
1053 LPPOPUPMENU lppop, HWND hwndOwner )
1056 int start, i, orgX, orgY, maxY, helpPos;
1058 if ((lprect == NULL) || (lppop == NULL)) return;
1059 if (lppop->nItems == 0) return;
1060 TRACE("left=%d top=%d right=%d bottom=%d\n",
1061 lprect->left, lprect->top, lprect->right, lprect->bottom);
1062 lppop->Width = lprect->right - lprect->left;
1064 maxY = lprect->top+1;
1067 while (start < lppop->nItems)
1069 lpitem = &lppop->items[start];
1070 orgX = lprect->left;
1073 /* Parse items until line break or end of menu */
1074 for (i = start; i < lppop->nItems; i++, lpitem++)
1076 if ((helpPos == -1) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1078 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1080 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1082 debug_print_menuitem (" item: ", lpitem, "");
1083 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE );
1085 if (lpitem->rect.right > lprect->right)
1087 if (i != start) break;
1088 else lpitem->rect.right = lprect->right;
1090 maxY = max( maxY, lpitem->rect.bottom );
1091 orgX = lpitem->rect.right;
1094 /* Finish the line (set all items to the largest height found) */
1095 while (start < i) lppop->items[start++].rect.bottom = maxY;
1098 lprect->bottom = maxY;
1099 lppop->Height = lprect->bottom - lprect->top;
1101 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1102 /* the last item (if several lines, only move the last line) */
1103 lpitem = &lppop->items[lppop->nItems-1];
1104 orgY = lpitem->rect.top;
1105 orgX = lprect->right;
1106 for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
1107 if ( (helpPos==-1) || (helpPos>i) )
1109 if (lpitem->rect.top != orgY) break; /* Other line */
1110 if (lpitem->rect.right >= orgX) break; /* Too far right already */
1111 lpitem->rect.left += orgX - lpitem->rect.right;
1112 lpitem->rect.right = orgX;
1113 orgX = lpitem->rect.left;
1117 /***********************************************************************
1120 * Draw a single menu item.
1122 static void MENU_DrawMenuItem( HWND hwnd, HMENU hmenu, HWND hwndOwner, HDC hdc, MENUITEM *lpitem,
1123 UINT height, BOOL menuBar, UINT odaction )
1127 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem, "");
1129 if (lpitem->fType & MF_SYSMENU)
1131 if( !IsIconic(hwnd) ) {
1132 if (TWEAK_WineLook > WIN31_LOOK)
1133 NC_DrawSysButton95( hwnd, hdc,
1135 (MF_HILITE | MF_MOUSESELECT) );
1137 NC_DrawSysButton( hwnd, hdc,
1139 (MF_HILITE | MF_MOUSESELECT) );
1145 if (lpitem->fType & MF_OWNERDRAW)
1148 ** Experimentation under Windows reveals that an owner-drawn
1149 ** menu is given the rectangle which includes the space it requested
1150 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1151 ** and a popup-menu arrow. This is the value of lpitem->rect.
1152 ** Windows will leave all drawing to the application except for
1153 ** the popup-menu arrow. Windows always draws that itself, after
1154 ** the menu owner has finished drawing.
1158 dis.CtlType = ODT_MENU;
1160 dis.itemID = lpitem->wID;
1161 dis.itemData = (DWORD)lpitem->dwItemData;
1163 if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
1164 if (lpitem->fState & MF_GRAYED) dis.itemState |= ODS_GRAYED;
1165 if (lpitem->fState & MF_HILITE) dis.itemState |= ODS_SELECTED;
1166 dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1167 dis.hwndItem = (HWND)hmenu;
1169 dis.rcItem = lpitem->rect;
1170 TRACE("Ownerdraw: owner=%04x itemID=%d, itemState=%d, itemAction=%d, "
1171 "hwndItem=%04x, hdc=%04x, rcItem={%d,%d,%d,%d}\n", hwndOwner,
1172 dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
1173 dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
1175 SendMessageA( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&dis );
1176 /* Fall through to draw popup-menu arrow */
1179 TRACE("rect={%d,%d,%d,%d}\n", lpitem->rect.left, lpitem->rect.top,
1180 lpitem->rect.right,lpitem->rect.bottom);
1182 if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
1184 rect = lpitem->rect;
1186 if (!(lpitem->fType & MF_OWNERDRAW))
1188 if (lpitem->fState & MF_HILITE)
1190 if(TWEAK_WineLook == WIN98_LOOK)
1193 DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
1195 FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1197 else /* Not Win98 Look */
1199 if(!IS_BITMAP_ITEM(lpitem->fType))
1200 FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1204 FillRect( hdc, &rect, GetSysColorBrush(COLOR_MENU) );
1207 SetBkMode( hdc, TRANSPARENT );
1209 if (!(lpitem->fType & MF_OWNERDRAW))
1211 /* vertical separator */
1212 if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
1214 if (TWEAK_WineLook > WIN31_LOOK)
1218 rc.bottom = height - 3;
1219 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
1223 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1224 MoveToEx( hdc, rect.left, 0, NULL );
1225 LineTo( hdc, rect.left, height );
1229 /* horizontal separator */
1230 if (lpitem->fType & MF_SEPARATOR)
1232 if (TWEAK_WineLook > WIN31_LOOK)
1237 rc.top += SEPARATOR_HEIGHT / 2;
1238 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
1242 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1243 MoveToEx( hdc, rect.left, rect.top + SEPARATOR_HEIGHT/2, NULL );
1244 LineTo( hdc, rect.right, rect.top + SEPARATOR_HEIGHT/2 );
1252 if (lpitem->fState & MF_HILITE)
1254 if(TWEAK_WineLook == WIN98_LOOK)
1257 SetTextColor(hdc, GetSysColor(COLOR_MENUTEXT));
1258 SetBkColor(hdc, GetSysColor(COLOR_MENU));
1260 if(lpitem->fState & MF_GRAYED)
1261 SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1263 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1264 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1267 else /* Not Win98 Look */
1269 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1270 if(!IS_BITMAP_ITEM(lpitem->fType))
1271 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1276 if (lpitem->fState & MF_GRAYED)
1277 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1279 SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
1280 SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
1283 /* helper lines for debugging */
1284 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1285 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1286 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1287 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1292 INT y = rect.top + rect.bottom;
1293 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1294 UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1296 if (!(lpitem->fType & MF_OWNERDRAW))
1298 /* Draw the check mark
1301 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1303 HBITMAP bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit : lpitem->hUnCheckBit;
1304 if (bm) /* we have a custom bitmap */
1306 HDC hdcMem = CreateCompatibleDC( hdc );
1307 SelectObject( hdcMem, bm );
1308 BitBlt( hdc, rect.left, (y - check_bitmap_height) / 2,
1309 check_bitmap_width, check_bitmap_height,
1310 hdcMem, 0, 0, SRCCOPY );
1313 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
1316 HBITMAP bm = CreateBitmap( check_bitmap_width, check_bitmap_height, 1, 1, NULL );
1317 HDC hdcMem = CreateCompatibleDC( hdc );
1318 SelectObject( hdcMem, bm );
1319 SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height );
1320 DrawFrameControl( hdcMem, &r, DFC_MENU,
1321 (lpitem->fType & MFT_RADIOCHECK) ?
1322 DFCS_MENUBULLET : DFCS_MENUCHECK );
1323 BitBlt( hdc, rect.left, (y - r.bottom) / 2, r.right, r.bottom,
1324 hdcMem, 0, 0, SRCCOPY );
1330 /* Draw the popup-menu arrow */
1331 if (lpitem->fType & MF_POPUP)
1333 HDC hdcMem = CreateCompatibleDC( hdc );
1334 HBITMAP hOrigBitmap;
1336 hOrigBitmap = SelectObject( hdcMem, hStdMnArrow );
1337 BitBlt( hdc, rect.right - arrow_bitmap_width - 1,
1338 (y - arrow_bitmap_height) / 2,
1339 arrow_bitmap_width, arrow_bitmap_height,
1340 hdcMem, 0, 0, SRCCOPY );
1341 SelectObject( hdcMem, hOrigBitmap );
1345 rect.left += check_bitmap_width;
1346 rect.right -= arrow_bitmap_width;
1349 /* Done for owner-drawn */
1350 if (lpitem->fType & MF_OWNERDRAW)
1353 /* Draw the item text or bitmap */
1354 if (IS_BITMAP_ITEM(lpitem->fType))
1356 MENU_DrawBitmapItem( hdc, lpitem, &rect, menuBar );
1360 /* No bitmap - process text if present */
1361 else if (IS_STRING_ITEM(lpitem->fType))
1366 UINT uFormat = (menuBar) ?
1367 DT_CENTER | DT_VCENTER | DT_SINGLELINE :
1368 DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1370 if ( lpitem->fState & MFS_DEFAULT )
1372 hfontOld = SelectObject( hdc, hMenuFontBold);
1377 rect.left += MENU_BAR_ITEMS_SPACE / 2;
1378 rect.right -= MENU_BAR_ITEMS_SPACE / 2;
1381 for (i = 0; lpitem->text[i]; i++)
1382 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1385 if( (TWEAK_WineLook != WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1387 if (!(lpitem->fState & MF_HILITE) )
1389 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1390 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1391 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1392 --rect.left; --rect.top; --rect.right; --rect.bottom;
1394 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1397 DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1399 /* paint the shortcut text */
1400 if (!menuBar && lpitem->text[i]) /* There's a tab or flush-right char */
1402 if (lpitem->text[i] == '\t')
1404 rect.left = lpitem->xTab;
1405 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1409 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1412 if( (TWEAK_WineLook != WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1414 if (!(lpitem->fState & MF_HILITE) )
1416 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1417 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1418 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1419 --rect.left; --rect.top; --rect.right; --rect.bottom;
1421 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1423 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1427 SelectObject (hdc, hfontOld);
1432 /***********************************************************************
1433 * MENU_DrawPopupMenu
1435 * Paint a popup menu.
1437 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1439 HBRUSH hPrevBrush = 0;
1442 TRACE("wnd=0x%04x dc=0x%04x menu=0x%04x\n", hwnd, hdc, hmenu);
1444 GetClientRect( hwnd, &rect );
1446 if(TWEAK_WineLook == WIN31_LOOK)
1448 rect.bottom -= POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1449 rect.right -= POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER);
1452 if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1453 && (SelectObject( hdc, hMenuFont)))
1457 Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1459 hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1465 /* draw 3-d shade */
1466 if(TWEAK_WineLook == WIN31_LOOK) {
1467 SelectObject( hdc, hShadeBrush );
1468 SetBkMode( hdc, TRANSPARENT );
1469 ropPrev = SetROP2( hdc, R2_MASKPEN );
1471 i = rect.right; /* why SetBrushOrg() doesn't? */
1472 PatBlt( hdc, i & 0xfffffffe,
1473 rect.top + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER),
1474 i%2 + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1475 rect.bottom - rect.top, 0x00a000c9 );
1477 PatBlt( hdc, rect.left + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1478 i & 0xfffffffe,rect.right - rect.left,
1479 i%2 + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER), 0x00a000c9 );
1480 SelectObject( hdc, hPrevPen );
1481 SelectObject( hdc, hPrevBrush );
1482 SetROP2( hdc, ropPrev );
1485 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1487 /* draw menu items */
1489 menu = MENU_GetMenu( hmenu );
1490 if (menu && menu->nItems)
1495 for (u = menu->nItems, item = menu->items; u > 0; u--, item++)
1496 MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc, item,
1497 menu->Height, FALSE, ODA_DRAWENTIRE );
1502 SelectObject( hdc, hPrevBrush );
1507 /***********************************************************************
1510 * Paint a menu bar. Returns the height of the menu bar.
1511 * called from [windows/nonclient.c]
1513 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1519 HMENU hMenu = GetMenu(hwnd);
1521 lppop = MENU_GetMenu( hMenu );
1522 if (lppop == NULL || lprect == NULL)
1524 retvalue = GetSystemMetrics(SM_CYMENU);
1528 TRACE("(%04x, %p, %p)\n", hDC, lprect, lppop);
1530 hfontOld = SelectObject( hDC, hMenuFont);
1532 if (lppop->Height == 0)
1533 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1535 lprect->bottom = lprect->top + lppop->Height;
1539 retvalue = lppop->Height;
1543 FillRect(hDC, lprect, GetSysColorBrush(COLOR_MENU) );
1545 if (TWEAK_WineLook == WIN31_LOOK)
1547 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1548 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1549 LineTo( hDC, lprect->right, lprect->bottom );
1553 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
1554 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1555 LineTo( hDC, lprect->right, lprect->bottom );
1558 if (lppop->nItems == 0)
1560 retvalue = GetSystemMetrics(SM_CYMENU);
1564 for (i = 0; i < lppop->nItems; i++)
1566 MENU_DrawMenuItem( hwnd, hMenu, hwnd,
1567 hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
1569 retvalue = lppop->Height;
1572 if (hfontOld) SelectObject (hDC, hfontOld);
1577 /***********************************************************************
1580 * Display a popup menu.
1582 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id,
1583 INT x, INT y, INT xanchor, INT yanchor )
1588 TRACE("owner=0x%04x hmenu=0x%04x id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1589 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1591 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1592 if (menu->FocusedItem != NO_SELECTED_ITEM)
1594 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1595 menu->FocusedItem = NO_SELECTED_ITEM;
1598 /* store the owner for DrawItem */
1599 menu->hwndOwner = hwndOwner;
1602 MENU_PopupMenuCalcSize( menu, hwndOwner );
1604 /* adjust popup menu pos so that it fits within the desktop */
1606 width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1607 height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1609 if( x + width > GetSystemMetrics(SM_CXSCREEN ))
1612 x -= width - xanchor;
1613 if( x + width > GetSystemMetrics(SM_CXSCREEN))
1614 x = GetSystemMetrics(SM_CXSCREEN) - width;
1618 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1621 y -= height + yanchor;
1622 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1623 y = GetSystemMetrics(SM_CYSCREEN) - height;
1627 if( TWEAK_WineLook == WIN31_LOOK )
1629 width += POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER); /* add space for shading */
1630 height += POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1633 /* NOTE: In Windows, top menu popup is not owned. */
1634 menu->hWnd = CreateWindowA( POPUPMENU_CLASS_ATOM, NULL,
1635 WS_POPUP, x, y, width, height,
1636 hwndOwner, 0, GetWindowLongA(hwndOwner,GWL_HINSTANCE),
1638 if( !menu->hWnd ) return FALSE;
1639 if (!top_popup) top_popup = menu->hWnd;
1641 /* Display the window */
1643 SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1644 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1645 UpdateWindow( menu->hWnd );
1650 /***********************************************************************
1653 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1654 BOOL sendMenuSelect, HMENU topmenu )
1659 TRACE("owner=0x%04x menu=0x%04x index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1661 lppop = MENU_GetMenu( hmenu );
1662 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1664 if (lppop->FocusedItem == wIndex) return;
1665 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1666 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1667 if (!top_popup) top_popup = lppop->hWnd;
1669 SelectObject( hdc, hMenuFont);
1671 /* Clear previous highlighted item */
1672 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1674 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1675 MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1676 lppop->Height, !(lppop->wFlags & MF_POPUP),
1680 /* Highlight new item (if any) */
1681 lppop->FocusedItem = wIndex;
1682 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1684 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1685 lppop->items[wIndex].fState |= MF_HILITE;
1686 MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1687 &lppop->items[wIndex], lppop->Height,
1688 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1692 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1693 SendMessageA( hwndOwner, WM_MENUSELECT,
1694 MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1695 ip->fType | ip->fState | MF_MOUSESELECT |
1696 (lppop->wFlags & MF_SYSMENU)), hmenu);
1699 else if (sendMenuSelect) {
1702 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1703 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1704 MENUITEM *ip = &ptm->items[pos];
1705 SendMessageA( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1706 ip->fType | ip->fState | MF_MOUSESELECT |
1707 (ptm->wFlags & MF_SYSMENU)), topmenu);
1711 ReleaseDC( lppop->hWnd, hdc );
1715 /***********************************************************************
1716 * MENU_MoveSelection
1718 * Moves currently selected item according to the offset parameter.
1719 * If there is no selection then it should select the last item if
1720 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1722 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1727 TRACE("hwnd=0x%04x hmenu=0x%04x off=0x%04x\n", hwndOwner, hmenu, offset);
1729 menu = MENU_GetMenu( hmenu );
1730 if ((!menu) || (!menu->items)) return;
1732 if ( menu->FocusedItem != NO_SELECTED_ITEM )
1734 if( menu->nItems == 1 ) return; else
1735 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1737 if (!(menu->items[i].fType & MF_SEPARATOR))
1739 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1744 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1745 i >= 0 && i < menu->nItems ; i += offset)
1746 if (!(menu->items[i].fType & MF_SEPARATOR))
1748 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1754 /**********************************************************************
1757 * Set an item's flags, id and text ptr. Called by InsertMenu() and
1760 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT id,
1763 LPWSTR prevText = IS_STRING_ITEM(item->fType) ? item->text : NULL;
1765 debug_print_menuitem("MENU_SetItemData from: ", item, "");
1766 TRACE("flags=%x str=%p\n", flags, str);
1768 if (IS_STRING_ITEM(flags))
1772 flags |= MF_SEPARATOR;
1778 /* Item beginning with a backspace is a help item */
1784 if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
1786 strcpyW( text, str );
1790 else if (IS_BITMAP_ITEM(flags))
1791 item->text = (LPWSTR)(HBITMAP)LOWORD(str);
1792 else item->text = NULL;
1794 if (flags & MF_OWNERDRAW)
1795 item->dwItemData = (DWORD)str;
1797 item->dwItemData = 0;
1799 if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != id) )
1800 DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
1802 if (flags & MF_POPUP)
1804 POPUPMENU *menu = MENU_GetMenu((UINT16)id);
1805 if (menu) menu->wFlags |= MF_POPUP;
1817 if (flags & MF_POPUP)
1818 item->hSubMenu = id;
1820 if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
1821 flags |= MF_POPUP; /* keep popup */
1823 item->fType = flags & TYPE_MASK;
1824 item->fState = (flags & STATE_MASK) &
1825 ~(MF_HILITE | MF_MOUSESELECT | MF_BYPOSITION);
1828 /* Don't call SetRectEmpty here! */
1831 if (prevText) HeapFree( GetProcessHeap(), 0, prevText );
1833 debug_print_menuitem("MENU_SetItemData to : ", item, "");
1838 /**********************************************************************
1841 * Insert (allocate) a new item into a menu.
1843 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1848 if (!(menu = MENU_GetMenu(hMenu)))
1851 /* Find where to insert new item */
1853 if (flags & MF_BYPOSITION) {
1854 if (pos > menu->nItems)
1857 if (!MENU_FindItem( &hMenu, &pos, flags ))
1860 if (!(menu = MENU_GetMenu( hMenu )))
1865 /* Create new items array */
1867 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
1870 WARN("allocation failed\n" );
1873 if (menu->nItems > 0)
1875 /* Copy the old array into the new one */
1876 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1877 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1878 (menu->nItems-pos)*sizeof(MENUITEM) );
1879 HeapFree( GetProcessHeap(), 0, menu->items );
1881 menu->items = newItems;
1883 memset( &newItems[pos], 0, sizeof(*newItems) );
1884 menu->Height = 0; /* force size recalculate */
1885 return &newItems[pos];
1889 /**********************************************************************
1890 * MENU_ParseResource
1892 * Parse a standard menu resource and add items to the menu.
1893 * Return a pointer to the end of the resource.
1895 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1902 flags = GET_WORD(res);
1903 res += sizeof(WORD);
1904 if (!(flags & MF_POPUP))
1907 res += sizeof(WORD);
1909 if (!IS_STRING_ITEM(flags))
1910 ERR("not a string item %04x\n", flags );
1912 if (!unicode) res += strlen(str) + 1;
1913 else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1914 if (flags & MF_POPUP)
1916 HMENU hSubMenu = CreatePopupMenu();
1917 if (!hSubMenu) return NULL;
1918 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1920 if (!unicode) AppendMenuA( hMenu, flags, (UINT)hSubMenu, str );
1921 else AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1923 else /* Not a popup */
1925 if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1926 else AppendMenuW( hMenu, flags, id,
1927 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1929 } while (!(flags & MF_END));
1934 /**********************************************************************
1935 * MENUEX_ParseResource
1937 * Parse an extended menu resource and add items to the menu.
1938 * Return a pointer to the end of the resource.
1940 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
1946 mii.cbSize = sizeof(mii);
1947 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
1948 mii.fType = GET_DWORD(res);
1949 res += sizeof(DWORD);
1950 mii.fState = GET_DWORD(res);
1951 res += sizeof(DWORD);
1952 mii.wID = GET_DWORD(res);
1953 res += sizeof(DWORD);
1954 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
1955 res += sizeof(WORD);
1956 /* Align the text on a word boundary. */
1957 res += (~((int)res - 1)) & 1;
1958 mii.dwTypeData = (LPWSTR) res;
1959 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
1960 /* Align the following fields on a dword boundary. */
1961 res += (~((int)res - 1)) & 3;
1963 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1964 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
1966 if (resinfo & 1) { /* Pop-up? */
1967 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1968 res += sizeof(DWORD);
1969 mii.hSubMenu = CreatePopupMenu();
1972 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
1973 DestroyMenu(mii.hSubMenu);
1976 mii.fMask |= MIIM_SUBMENU;
1977 mii.fType |= MF_POPUP;
1979 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
1981 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1982 mii.wID, mii.fType);
1983 mii.fType |= MF_SEPARATOR;
1985 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
1986 } while (!(resinfo & MF_END));
1991 /***********************************************************************
1994 * Return the handle of the selected sub-popup menu (if any).
1996 static HMENU MENU_GetSubPopup( HMENU hmenu )
2001 menu = MENU_GetMenu( hmenu );
2003 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2005 item = &menu->items[menu->FocusedItem];
2006 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2007 return item->hSubMenu;
2012 /***********************************************************************
2013 * MENU_HideSubPopups
2015 * Hide the sub-popup menus of this menu.
2017 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2018 BOOL sendMenuSelect )
2020 POPUPMENU *menu = MENU_GetMenu( hmenu );
2022 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2024 if (menu && top_popup)
2030 if (menu->FocusedItem != NO_SELECTED_ITEM)
2032 item = &menu->items[menu->FocusedItem];
2033 if (!(item->fType & MF_POPUP) ||
2034 !(item->fState & MF_MOUSESELECT)) return;
2035 item->fState &= ~MF_MOUSESELECT;
2036 hsubmenu = item->hSubMenu;
2039 submenu = MENU_GetMenu( hsubmenu );
2040 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
2041 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2042 DestroyWindow( submenu->hWnd );
2048 /***********************************************************************
2051 * Display the sub-menu of the selected item of this menu.
2052 * Return the handle of the submenu, or hmenu if no submenu to display.
2054 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2055 BOOL selectFirst, UINT wFlags )
2062 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, selectFirst);
2064 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2066 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2068 item = &menu->items[menu->FocusedItem];
2069 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2072 /* message must be sent before using item,
2073 because nearly everything may be changed by the application ! */
2075 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2076 if (!(wFlags & TPM_NONOTIFY))
2077 SendMessageA( hwndOwner, WM_INITMENUPOPUP, item->hSubMenu,
2078 MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2080 item = &menu->items[menu->FocusedItem];
2083 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2084 if (!(item->fState & MF_HILITE))
2086 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2087 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2089 SelectObject( hdc, hMenuFont);
2091 item->fState |= MF_HILITE;
2092 MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2093 ReleaseDC( menu->hWnd, hdc );
2095 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2098 item->fState |= MF_MOUSESELECT;
2100 if (IS_SYSTEM_MENU(menu))
2102 MENU_InitSysMenuPopup(item->hSubMenu,
2103 GetWindowLongA( menu->hWnd, GWL_STYLE ),
2104 GetClassLongA( menu->hWnd, GCL_STYLE));
2106 NC_GetSysPopupPos( menu->hWnd, &rect );
2107 rect.top = rect.bottom;
2108 rect.right = GetSystemMetrics(SM_CXSIZE);
2109 rect.bottom = GetSystemMetrics(SM_CYSIZE);
2113 GetWindowRect( menu->hWnd, &rect );
2114 if (menu->wFlags & MF_POPUP)
2116 rect.left += item->rect.right - GetSystemMetrics(SM_CXBORDER);
2117 rect.top += item->rect.top;
2118 rect.right = item->rect.left - item->rect.right + GetSystemMetrics(SM_CXBORDER);
2119 rect.bottom = item->rect.top - item->rect.bottom;
2123 rect.left += item->rect.left;
2124 rect.top += item->rect.bottom;
2125 rect.right = item->rect.right - item->rect.left;
2126 rect.bottom = item->rect.bottom - item->rect.top;
2130 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2131 rect.left, rect.top, rect.right, rect.bottom );
2133 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2134 return item->hSubMenu;
2139 /**********************************************************************
2142 BOOL MENU_IsMenuActive(void)
2144 return (top_popup != 0);
2147 /***********************************************************************
2150 * Walks menu chain trying to find a menu pt maps to.
2152 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2154 POPUPMENU *menu = MENU_GetMenu( hMenu );
2155 UINT item = menu->FocusedItem;
2158 /* try subpopup first (if any) */
2159 ret = (item != NO_SELECTED_ITEM &&
2160 (menu->items[item].fType & MF_POPUP) &&
2161 (menu->items[item].fState & MF_MOUSESELECT))
2162 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2164 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2166 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2167 if( menu->wFlags & MF_POPUP )
2169 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2171 else if (ht == HTSYSMENU)
2172 ret = get_win_sys_menu( menu->hWnd );
2173 else if (ht == HTMENU)
2174 ret = GetMenu( menu->hWnd );
2179 /***********************************************************************
2180 * MENU_ExecFocusedItem
2182 * Execute a menu item (for instance when user pressed Enter).
2183 * Return the wID of the executed item. Otherwise, -1 indicating
2184 * that no menu item was executed;
2185 * Have to receive the flags for the TrackPopupMenu options to avoid
2186 * sending unwanted message.
2189 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2192 POPUPMENU *menu = MENU_GetMenu( hMenu );
2194 TRACE("%p hmenu=0x%04x\n", pmt, hMenu);
2196 if (!menu || !menu->nItems ||
2197 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2199 item = &menu->items[menu->FocusedItem];
2201 TRACE("%08x %08x %08x\n",
2202 hMenu, item->wID, item->hSubMenu);
2204 if (!(item->fType & MF_POPUP))
2206 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2208 /* If TPM_RETURNCMD is set you return the id, but
2209 do not send a message to the owner */
2210 if(!(wFlags & TPM_RETURNCMD))
2212 if( menu->wFlags & MF_SYSMENU )
2213 PostMessageA( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2214 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2216 PostMessageA( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2222 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2227 /***********************************************************************
2228 * MENU_SwitchTracking
2230 * Helper function for menu navigation routines.
2232 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2234 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2235 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2237 TRACE("%p hmenu=0x%04x 0x%04x\n", pmt, hPtMenu, id);
2239 if( pmt->hTopMenu != hPtMenu &&
2240 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2242 /* both are top level menus (system and menu-bar) */
2243 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2244 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2245 pmt->hTopMenu = hPtMenu;
2247 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2248 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2252 /***********************************************************************
2255 * Return TRUE if we can go on with menu tracking.
2257 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2259 TRACE("%p hPtMenu=0x%04x\n", pmt, hPtMenu);
2264 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2267 if( IS_SYSTEM_MENU(ptmenu) )
2268 item = ptmenu->items;
2270 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2274 if( ptmenu->FocusedItem != id )
2275 MENU_SwitchTracking( pmt, hPtMenu, id );
2277 /* If the popup menu is not already "popped" */
2278 if(!(item->fState & MF_MOUSESELECT ))
2280 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2282 /* In win31, a newly popped menu always remains opened for the next buttonup */
2283 if(TWEAK_WineLook == WIN31_LOOK)
2284 ptmenu->bTimeToHide = FALSE;
2289 /* Else the click was on the menu bar, finish the tracking */
2294 /***********************************************************************
2297 * Return the value of MENU_ExecFocusedItem if
2298 * the selected item was not a popup. Else open the popup.
2299 * A -1 return value indicates that we go on with menu tracking.
2302 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2304 TRACE("%p hmenu=0x%04x\n", pmt, hPtMenu);
2309 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2312 if( IS_SYSTEM_MENU(ptmenu) )
2313 item = ptmenu->items;
2315 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2317 if( item && (ptmenu->FocusedItem == id ))
2319 if( !(item->fType & MF_POPUP) )
2320 return MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2322 /* If we are dealing with the top-level menu */
2323 /* and this is a click on an already "popped" item: */
2324 /* Stop the menu tracking and close the opened submenus */
2325 if((pmt->hTopMenu == hPtMenu) && (ptmenu->bTimeToHide == TRUE))
2328 ptmenu->bTimeToHide = TRUE;
2334 /***********************************************************************
2337 * Return TRUE if we can go on with menu tracking.
2339 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2341 UINT id = NO_SELECTED_ITEM;
2342 POPUPMENU *ptmenu = NULL;
2346 ptmenu = MENU_GetMenu( hPtMenu );
2347 if( IS_SYSTEM_MENU(ptmenu) )
2350 MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2353 if( id == NO_SELECTED_ITEM )
2355 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2356 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2359 else if( ptmenu->FocusedItem != id )
2361 MENU_SwitchTracking( pmt, hPtMenu, id );
2362 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2368 /***********************************************************************
2371 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2373 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2375 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2377 if( (vk == VK_LEFT && menu->FocusedItem == 0 ) ||
2378 (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2380 MDINEXTMENU next_menu;
2385 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2386 next_menu.hmenuNext = 0;
2387 next_menu.hwndNext = 0;
2388 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2390 TRACE("%04x [%04x] -> %04x [%04x]\n",
2391 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2393 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2395 DWORD style = GetWindowLongA( pmt->hOwnerWnd, GWL_STYLE );
2396 hNewWnd = pmt->hOwnerWnd;
2397 if( IS_SYSTEM_MENU(menu) )
2399 /* switch to the menu bar */
2401 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2405 menu = MENU_GetMenu( hNewMenu );
2406 id = menu->nItems - 1;
2409 else if (style & WS_SYSMENU )
2411 /* switch to the system menu */
2412 hNewMenu = get_win_sys_menu( hNewWnd );
2416 else /* application returned a new menu to switch to */
2418 hNewMenu = next_menu.hmenuNext;
2419 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2421 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2423 DWORD style = GetWindowLongA( hNewWnd, GWL_STYLE );
2425 if (style & WS_SYSMENU &&
2426 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2428 /* get the real system menu */
2429 hNewMenu = get_win_sys_menu(hNewWnd);
2431 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2433 /* FIXME: Not sure what to do here;
2434 * perhaps try to track hNewMenu as a popup? */
2436 TRACE(" -- got confused.\n");
2443 if( hNewMenu != pmt->hTopMenu )
2445 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2447 if( pmt->hCurrentMenu != pmt->hTopMenu )
2448 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2451 if( hNewWnd != pmt->hOwnerWnd )
2454 pmt->hOwnerWnd = hNewWnd;
2455 EVENT_Capture( pmt->hOwnerWnd, HTMENU );
2458 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2459 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2466 /***********************************************************************
2469 * The idea is not to show the popup if the next input message is
2470 * going to hide it anyway.
2472 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2476 msg.hwnd = pmt->hOwnerWnd;
2478 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2479 pmt->trackFlags |= TF_SKIPREMOVE;
2484 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2485 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2487 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2488 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2489 if( msg.message == WM_KEYDOWN &&
2490 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2492 pmt->trackFlags |= TF_SUSPENDPOPUP;
2499 /* failures go through this */
2500 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2504 /***********************************************************************
2507 * Handle a VK_ESCAPE key event in a menu.
2509 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2511 BOOL bEndMenu = TRUE;
2513 if (pmt->hCurrentMenu != pmt->hTopMenu)
2515 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2517 if (menu->wFlags & MF_POPUP)
2519 HMENU hmenutmp, hmenuprev;
2521 hmenuprev = hmenutmp = pmt->hTopMenu;
2523 /* close topmost popup */
2524 while (hmenutmp != pmt->hCurrentMenu)
2526 hmenuprev = hmenutmp;
2527 hmenutmp = MENU_GetSubPopup( hmenuprev );
2530 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2531 pmt->hCurrentMenu = hmenuprev;
2539 /***********************************************************************
2542 * Handle a VK_LEFT key event in a menu.
2544 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2547 HMENU hmenutmp, hmenuprev;
2550 hmenuprev = hmenutmp = pmt->hTopMenu;
2551 menu = MENU_GetMenu( hmenutmp );
2553 /* Try to move 1 column left (if possible) */
2554 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2555 NO_SELECTED_ITEM ) {
2557 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2562 /* close topmost popup */
2563 while (hmenutmp != pmt->hCurrentMenu)
2565 hmenuprev = hmenutmp;
2566 hmenutmp = MENU_GetSubPopup( hmenuprev );
2569 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2570 pmt->hCurrentMenu = hmenuprev;
2572 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2574 /* move menu bar selection if no more popups are left */
2576 if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2577 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2579 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2581 /* A sublevel menu was displayed - display the next one
2582 * unless there is another displacement coming up */
2584 if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2585 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2586 pmt->hTopMenu, TRUE, wFlags);
2592 /***********************************************************************
2595 * Handle a VK_RIGHT key event in a menu.
2597 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2600 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2603 TRACE("MENU_KeyRight called, cur %x (%s), top %x (%s).\n",
2605 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->
2607 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2609 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2611 /* If already displaying a popup, try to display sub-popup */
2613 hmenutmp = pmt->hCurrentMenu;
2614 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2616 /* if subpopup was displayed then we are done */
2617 if (hmenutmp != pmt->hCurrentMenu) return;
2620 /* Check to see if there's another column */
2621 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2622 NO_SELECTED_ITEM ) {
2623 TRACE("Going to %d.\n", nextcol );
2624 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2629 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2631 if( pmt->hCurrentMenu != pmt->hTopMenu )
2633 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2634 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2635 } else hmenutmp = 0;
2637 /* try to move to the next item */
2638 if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2639 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2641 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2642 if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2643 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2644 pmt->hTopMenu, TRUE, wFlags);
2648 /***********************************************************************
2651 * Menu tracking code.
2653 static INT MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2654 HWND hwnd, const RECT *lprect )
2659 INT executedMenuId = -1;
2661 BOOL enterIdleSent = FALSE;
2664 mt.hCurrentMenu = hmenu;
2665 mt.hTopMenu = hmenu;
2666 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2670 TRACE("hmenu=0x%04x flags=0x%08x (%d,%d) hwnd=0x%04x (%d,%d)-(%d,%d)\n",
2671 hmenu, wFlags, x, y, hwnd, (lprect) ? lprect->left : 0, (lprect) ? lprect->top : 0,
2672 (lprect) ? lprect->right : 0, (lprect) ? lprect->bottom : 0);
2675 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
2677 if (wFlags & TPM_BUTTONDOWN)
2679 /* Get the result in order to start the tracking or not */
2680 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2681 fEndMenu = !fRemove;
2684 EVENT_Capture( mt.hOwnerWnd, HTMENU );
2688 menu = MENU_GetMenu( mt.hCurrentMenu );
2689 if (!menu) /* sometimes happens if I do a window manager close */
2692 /* we have to keep the message in the queue until it's
2693 * clear that menu loop is not over yet. */
2697 if (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
2699 if (!CallMsgFilterA( &msg, MSGF_MENU )) break;
2700 /* remove the message from the queue */
2701 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2707 HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2708 enterIdleSent = TRUE;
2709 SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2715 /* check if EndMenu() tried to cancel us, by posting this message */
2716 if(msg.message == WM_CANCELMODE)
2718 /* we are now out of the loop */
2721 /* remove the message from the queue */
2722 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2724 /* break out of internal loop, ala ESCAPE */
2728 TranslateMessage( &msg );
2731 if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
2732 enterIdleSent=FALSE;
2735 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
2738 * use the mouse coordinates in lParam instead of those in the MSG
2739 * struct to properly handle synthetic messages. lParam coords are
2740 * relative to client area, so they must be converted; since they can
2741 * be negative, we must use SLOWORD/SHIWORD instead of LOWORD/HIWORD.
2743 mt.pt.x = SLOWORD(msg.lParam);
2744 mt.pt.y = SHIWORD(msg.lParam);
2745 ClientToScreen(msg.hwnd,&mt.pt);
2747 /* Find a menu for this mouse event */
2748 hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
2752 /* no WM_NC... messages in captured state */
2754 case WM_RBUTTONDBLCLK:
2755 case WM_RBUTTONDOWN:
2756 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2758 case WM_LBUTTONDBLCLK:
2759 case WM_LBUTTONDOWN:
2760 /* If the message belongs to the menu, removes it from the queue */
2761 /* Else, end menu tracking */
2762 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2763 fEndMenu = !fRemove;
2767 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2770 /* Check if a menu was selected by the mouse */
2773 executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
2775 /* End the loop if executedMenuId is an item ID */
2776 /* or if the job was done (executedMenuId = 0). */
2777 fEndMenu = fRemove = (executedMenuId != -1);
2779 /* No menu was selected by the mouse */
2780 /* if the function was called by TrackPopupMenu, continue
2781 with the menu tracking. If not, stop it */
2783 fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
2788 /* In win95 winelook, the selected menu item must be changed every time the
2789 mouse moves. In Win31 winelook, the mouse button has to be held down */
2791 if ( hmenu && ((TWEAK_WineLook > WIN31_LOOK) ||
2792 ( (msg.wParam & MK_LBUTTON) ||
2793 ((wFlags & TPM_RIGHTBUTTON) && (msg.wParam & MK_RBUTTON)))) )
2795 fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
2797 } /* switch(msg.message) - mouse */
2799 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
2801 fRemove = TRUE; /* Keyboard messages are always removed */
2809 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
2810 NO_SELECTED_ITEM, FALSE, 0 );
2813 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
2814 (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
2817 case VK_DOWN: /* If on menu bar, pull-down the menu */
2819 menu = MENU_GetMenu( mt.hCurrentMenu );
2820 if (!(menu->wFlags & MF_POPUP))
2821 mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
2822 else /* otherwise try to move selection */
2823 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT );
2827 MENU_KeyLeft( &mt, wFlags );
2831 MENU_KeyRight( &mt, wFlags );
2835 fEndMenu = MENU_KeyEscape(&mt, wFlags);
2841 hi.cbSize = sizeof(HELPINFO);
2842 hi.iContextType = HELPINFO_MENUITEM;
2843 if (menu->FocusedItem == NO_SELECTED_ITEM)
2846 hi.iCtrlId = menu->items[menu->FocusedItem].wID;
2847 hi.hItemHandle = hmenu;
2848 hi.dwContextId = menu->dwContextHelpID;
2849 hi.MousePos = msg.pt;
2850 SendMessageA(hwnd, WM_HELP, 0, (LPARAM)&hi);
2857 break; /* WM_KEYDOWN */
2867 break; /* WM_SYSKEYDOWN */
2873 if (msg.wParam == '\r' || msg.wParam == ' ')
2875 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2876 fEndMenu = (executedMenuId != -1);
2881 /* Hack to avoid control chars. */
2882 /* We will find a better way real soon... */
2883 if ((msg.wParam <= 32) || (msg.wParam >= 127)) break;
2885 pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
2886 LOWORD(msg.wParam), FALSE );
2887 if (pos == (UINT)-2) fEndMenu = TRUE;
2888 else if (pos == (UINT)-1) MessageBeep(0);
2891 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
2893 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2894 fEndMenu = (executedMenuId != -1);
2898 } /* switch(msg.message) - kbd */
2902 DispatchMessageA( &msg );
2905 if (!fEndMenu) fRemove = TRUE;
2907 /* finally remove message from the queue */
2909 if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
2910 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2911 else mt.trackFlags &= ~TF_SKIPREMOVE;
2916 /* If dropdown is still painted and the close box is clicked on
2917 then the menu will be destroyed as part of the DispatchMessage above.
2918 This will then invalidate the menu handle in mt.hTopMenu. We should
2919 check for this first. */
2920 if( IsMenu( mt.hTopMenu ) )
2922 menu = MENU_GetMenu( mt.hTopMenu );
2924 if( IsWindow( mt.hOwnerWnd ) )
2926 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
2928 if (menu && menu->wFlags & MF_POPUP)
2930 DestroyWindow( menu->hWnd );
2933 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2934 SendMessageA( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
2937 /* Reset the variable for hiding menu */
2938 if( menu ) menu->bTimeToHide = FALSE;
2941 /* The return value is only used by TrackPopupMenu */
2942 return ((executedMenuId != -1) ? executedMenuId : 0);
2945 /***********************************************************************
2948 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
2950 TRACE("hwnd=0x%04x hmenu=0x%04x\n", hWnd, hMenu);
2954 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2955 if (!(wFlags & TPM_NONOTIFY))
2956 SendMessageA( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
2958 SendMessageA( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
2960 if (!(wFlags & TPM_NONOTIFY))
2963 SendMessageA( hWnd, WM_INITMENU, hMenu, 0 );
2964 if ((menu = MENU_GetMenu( hMenu )) && (!menu->Height))
2965 { /* app changed/recreated menu bar entries in WM_INITMENU
2966 Recalculate menu sizes else clicks will not work */
2967 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2968 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2974 /***********************************************************************
2977 static BOOL MENU_ExitTracking(HWND hWnd)
2979 TRACE("hwnd=0x%04x\n", hWnd);
2981 SendMessageA( hWnd, WM_EXITMENULOOP, 0, 0 );
2986 /***********************************************************************
2987 * MENU_TrackMouseMenuBar
2989 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2991 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
2993 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
2994 UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2996 TRACE("wnd=%x ht=0x%04x (%ld,%ld)\n", hWnd, ht, pt.x, pt.y);
3000 /* map point to parent client coordinates */
3001 HWND parent = GetAncestor( hWnd, GA_PARENT );
3002 if (parent != GetDesktopWindow()) ScreenToClient( parent, &pt );
3004 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3005 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3006 MENU_ExitTracking(hWnd);
3011 /***********************************************************************
3012 * MENU_TrackKbdMenuBar
3014 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3016 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, INT vkey)
3018 UINT uItem = NO_SELECTED_ITEM;
3020 UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3022 /* find window that has a menu */
3024 while (GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)
3025 if (!(hwnd = GetParent( hwnd ))) return;
3027 /* check if we have to track a system menu */
3029 hTrackMenu = GetMenu( hwnd );
3030 if (!hTrackMenu || IsIconic(hwnd) || vkey == VK_SPACE )
3032 if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3033 hTrackMenu = get_win_sys_menu( hwnd );
3035 wParam |= HTSYSMENU; /* prevent item lookup */
3038 if (!IsMenu( hTrackMenu )) return;
3040 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3042 if( vkey && vkey != VK_SPACE )
3044 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, vkey, (wParam & HTSYSMENU) );
3045 if( uItem >= (UINT)(-2) )
3047 if( uItem == (UINT)(-1) ) MessageBeep(0);
3054 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3056 if( uItem == NO_SELECTED_ITEM )
3057 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3059 PostMessageA( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3061 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3063 MENU_ExitTracking( hwnd );
3067 /**********************************************************************
3068 * TrackPopupMenu (USER32.@)
3070 * Like the win32 API, the function return the command ID only if the
3071 * flag TPM_RETURNCMD is on.
3074 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3075 INT nReserved, HWND hWnd, const RECT *lpRect )
3079 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3081 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3082 if (!(wFlags & TPM_NONOTIFY))
3083 SendMessageA( hWnd, WM_INITMENUPOPUP, hMenu, 0);
3085 if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
3086 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3087 MENU_ExitTracking(hWnd);
3089 if( (!(wFlags & TPM_RETURNCMD)) && (ret != FALSE) )
3095 /**********************************************************************
3096 * TrackPopupMenuEx (USER32.@)
3098 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3099 HWND hWnd, LPTPMPARAMS lpTpm )
3101 FIXME("not fully implemented\n" );
3102 return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3103 lpTpm ? &lpTpm->rcExclude : NULL );
3106 /***********************************************************************
3109 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3111 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3113 TRACE("hwnd=0x%04x msg=0x%04x wp=0x%04x lp=0x%08lx\n",
3114 hwnd, message, wParam, lParam);
3120 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3121 SetWindowLongW( hwnd, 0, (LONG)cs->lpCreateParams );
3125 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3126 return MA_NOACTIVATE;
3131 BeginPaint( hwnd, &ps );
3132 MENU_DrawPopupMenu( hwnd, ps.hdc,
3133 (HMENU)GetWindowLongA( hwnd, 0 ) );
3134 EndPaint( hwnd, &ps );
3141 /* zero out global pointer in case resident popup window was destroyed. */
3142 if (hwnd == top_popup) top_popup = 0;
3149 if (!GetWindowLongW( hwnd, 0 )) ERR("no menu to display\n");
3152 SetWindowLongW( hwnd, 0, 0 );
3155 case MM_SETMENUHANDLE:
3156 SetWindowLongW( hwnd, 0, wParam );
3159 case MM_GETMENUHANDLE:
3160 return GetWindowLongW( hwnd, 0 );
3163 return DefWindowProcW( hwnd, message, wParam, lParam );
3169 /***********************************************************************
3170 * MENU_GetMenuBarHeight
3172 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3174 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3175 INT orgX, INT orgY )
3181 TRACE("HWND 0x%x, width %d, at (%d, %d).\n",
3182 hwnd, menubarWidth, orgX, orgY );
3184 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3186 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3187 SelectObject( hdc, hMenuFont);
3188 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3189 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3190 ReleaseDC( hwnd, hdc );
3191 return lppop->Height;
3195 /*******************************************************************
3196 * ChangeMenu (USER.153)
3198 BOOL16 WINAPI ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
3199 UINT16 id, UINT16 flags )
3201 TRACE("menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
3202 hMenu, pos, (DWORD)data, id, flags );
3203 if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND,
3206 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
3207 /* for MF_DELETE. We should check the parameters for all others */
3208 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
3210 if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE);
3211 if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE,
3213 if (flags & MF_REMOVE) return RemoveMenu16(hMenu,
3214 flags & MF_BYPOSITION ? pos : id,
3215 flags & ~MF_REMOVE );
3216 /* Default: MF_INSERT */
3217 return InsertMenu16( hMenu, pos, flags, id, data );
3221 /*******************************************************************
3222 * ChangeMenuA (USER32.@)
3224 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3225 UINT id, UINT flags )
3227 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3228 hMenu, pos, (DWORD)data, id, flags );
3229 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3231 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3232 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3234 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3235 flags & MF_BYPOSITION ? pos : id,
3236 flags & ~MF_REMOVE );
3237 /* Default: MF_INSERT */
3238 return InsertMenuA( hMenu, pos, flags, id, data );
3242 /*******************************************************************
3243 * ChangeMenuW (USER32.@)
3245 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3246 UINT id, UINT flags )
3248 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3249 hMenu, pos, (DWORD)data, id, flags );
3250 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3252 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3253 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3255 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3256 flags & MF_BYPOSITION ? pos : id,
3257 flags & ~MF_REMOVE );
3258 /* Default: MF_INSERT */
3259 return InsertMenuW( hMenu, pos, flags, id, data );
3263 /*******************************************************************
3264 * CheckMenuItem (USER.154)
3266 BOOL16 WINAPI CheckMenuItem16( HMENU16 hMenu, UINT16 id, UINT16 flags )
3268 return (BOOL16)CheckMenuItem( hMenu, id, flags );
3272 /*******************************************************************
3273 * CheckMenuItem (USER32.@)
3275 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3280 TRACE("menu=%04x id=%04x flags=%04x\n", hMenu, id, flags );
3281 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3282 ret = item->fState & MF_CHECKED;
3283 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3284 else item->fState &= ~MF_CHECKED;
3289 /**********************************************************************
3290 * EnableMenuItem (USER.155)
3292 UINT16 WINAPI EnableMenuItem16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3294 return EnableMenuItem( hMenu, wItemID, wFlags );
3298 /**********************************************************************
3299 * EnableMenuItem (USER32.@)
3301 UINT WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3307 TRACE("(%04x, %04X, %04X) !\n",
3308 hMenu, wItemID, wFlags);
3310 /* Get the Popupmenu to access the owner menu */
3311 if (!(menu = MENU_GetMenu(hMenu)))
3314 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3317 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3318 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3320 /* In win95 if the close item in the system menu change update the close button */
3321 if (TWEAK_WineLook == WIN95_LOOK)
3322 if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3324 if (menu->hSysMenuOwner != 0)
3326 POPUPMENU* parentMenu;
3328 /* Get the parent menu to access*/
3329 if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3332 /* Refresh the frame to reflect the change*/
3333 SetWindowPos(parentMenu->hWnd, 0, 0, 0, 0, 0,
3334 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
3342 /*******************************************************************
3343 * GetMenuString (USER.161)
3345 INT16 WINAPI GetMenuString16( HMENU16 hMenu, UINT16 wItemID,
3346 LPSTR str, INT16 nMaxSiz, UINT16 wFlags )
3348 return GetMenuStringA( hMenu, wItemID, str, nMaxSiz, wFlags );
3352 /*******************************************************************
3353 * GetMenuStringA (USER32.@)
3355 INT WINAPI GetMenuStringA(
3356 HMENU hMenu, /* [in] menuhandle */
3357 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3358 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3359 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3360 UINT wFlags /* [in] MF_ flags */
3364 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3365 hMenu, wItemID, str, nMaxSiz, wFlags );
3366 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3367 if (!IS_STRING_ITEM(item->fType)) return 0;
3368 if (!str || !nMaxSiz) return strlenW(item->text);
3370 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3372 TRACE("returning '%s'\n", str );
3377 /*******************************************************************
3378 * GetMenuStringW (USER32.@)
3380 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3381 LPWSTR str, INT nMaxSiz, UINT wFlags )
3385 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3386 hMenu, wItemID, str, nMaxSiz, wFlags );
3387 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3388 if (!IS_STRING_ITEM(item->fType)) return 0;
3389 if (!str || !nMaxSiz) return strlenW(item->text);
3391 lstrcpynW( str, item->text, nMaxSiz );
3392 return strlenW(str);
3396 /**********************************************************************
3397 * HiliteMenuItem (USER32.@)
3399 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3403 TRACE("(%04x, %04x, %04x, %04x);\n",
3404 hWnd, hMenu, wItemID, wHilite);
3405 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3406 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3407 if (menu->FocusedItem == wItemID) return TRUE;
3408 MENU_HideSubPopups( hWnd, hMenu, FALSE );
3409 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3414 /**********************************************************************
3415 * GetMenuState (USER.250)
3417 UINT16 WINAPI GetMenuState16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3419 return GetMenuState( hMenu, wItemID, wFlags );
3423 /**********************************************************************
3424 * GetMenuState (USER32.@)
3426 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3429 TRACE("(menu=%04x, id=%04x, flags=%04x);\n",
3430 hMenu, wItemID, wFlags);
3431 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3432 debug_print_menuitem (" item: ", item, "");
3433 if (item->fType & MF_POPUP)
3435 POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3436 if (!menu) return -1;
3437 else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3441 /* We used to (from way back then) mask the result to 0xff. */
3442 /* I don't know why and it seems wrong as the documented */
3443 /* return flag MF_SEPARATOR is outside that mask. */
3444 return (item->fType | item->fState);
3449 /**********************************************************************
3450 * GetMenuItemCount (USER.263)
3452 INT16 WINAPI GetMenuItemCount16( HMENU16 hMenu )
3454 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3455 if (!menu) return -1;
3456 TRACE("(%04x) returning %d\n",
3457 hMenu, menu->nItems );
3458 return menu->nItems;
3462 /**********************************************************************
3463 * GetMenuItemCount (USER32.@)
3465 INT WINAPI GetMenuItemCount( HMENU hMenu )
3467 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3468 if (!menu) return -1;
3469 TRACE("(%04x) returning %d\n",
3470 hMenu, menu->nItems );
3471 return menu->nItems;
3474 /**********************************************************************
3475 * GetMenuItemID (USER.264)
3477 UINT16 WINAPI GetMenuItemID16( HMENU16 hMenu, INT16 nPos )
3479 return (UINT16) GetMenuItemID (hMenu, nPos);
3482 /**********************************************************************
3483 * GetMenuItemID (USER32.@)
3485 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3489 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return -1;
3490 if (lpmi->fType & MF_POPUP) return -1;
3495 /*******************************************************************
3496 * InsertMenu (USER.410)
3498 BOOL16 WINAPI InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3499 UINT16 id, SEGPTR data )
3501 UINT pos32 = (UINT)pos;
3502 if ((pos == (UINT16)-1) && (flags & MF_BYPOSITION)) pos32 = (UINT)-1;
3503 if (IS_STRING_ITEM(flags) && data)
3504 return InsertMenuA( hMenu, pos32, flags, id, MapSL(data) );
3505 return InsertMenuA( hMenu, pos32, flags, id, (LPSTR)data );
3509 /*******************************************************************
3510 * InsertMenuW (USER32.@)
3512 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3513 UINT id, LPCWSTR str )
3517 if (IS_STRING_ITEM(flags) && str)
3518 TRACE("hMenu %04x, pos %d, flags %08x, "
3519 "id %04x, str %s\n",
3520 hMenu, pos, flags, id, debugstr_w(str) );
3521 else TRACE("hMenu %04x, pos %d, flags %08x, "
3522 "id %04x, str %08lx (not a string)\n",
3523 hMenu, pos, flags, id, (DWORD)str );
3525 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3527 if (!(MENU_SetItemData( item, flags, id, str )))
3529 RemoveMenu( hMenu, pos, flags );
3533 if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
3534 (MENU_GetMenu((HMENU16)id))->wFlags |= MF_POPUP;
3536 item->hCheckBit = item->hUnCheckBit = 0;
3541 /*******************************************************************
3542 * InsertMenuA (USER32.@)
3544 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3545 UINT id, LPCSTR str )
3549 if (IS_STRING_ITEM(flags) && str)
3551 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3552 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3555 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3556 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3557 HeapFree( GetProcessHeap(), 0, newstr );
3561 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3565 /*******************************************************************
3566 * AppendMenu (USER.411)
3568 BOOL16 WINAPI AppendMenu16(HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data)
3570 return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
3574 /*******************************************************************
3575 * AppendMenuA (USER32.@)
3577 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3578 UINT id, LPCSTR data )
3580 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3584 /*******************************************************************
3585 * AppendMenuW (USER32.@)
3587 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3588 UINT id, LPCWSTR data )
3590 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3594 /**********************************************************************
3595 * RemoveMenu (USER.412)
3597 BOOL16 WINAPI RemoveMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3599 return RemoveMenu( hMenu, nPos, wFlags );
3603 /**********************************************************************
3604 * RemoveMenu (USER32.@)
3606 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3611 TRACE("(menu=%04x pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3612 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3613 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3617 MENU_FreeItemData( item );
3619 if (--menu->nItems == 0)
3621 HeapFree( GetProcessHeap(), 0, menu->items );
3626 while(nPos < menu->nItems)
3632 menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3633 menu->nItems * sizeof(MENUITEM) );
3639 /**********************************************************************
3640 * DeleteMenu (USER.413)
3642 BOOL16 WINAPI DeleteMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3644 return DeleteMenu( hMenu, nPos, wFlags );
3648 /**********************************************************************
3649 * DeleteMenu (USER32.@)
3651 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3653 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3654 if (!item) return FALSE;
3655 if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3656 /* nPos is now the position of the item */
3657 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3662 /*******************************************************************
3663 * ModifyMenu (USER.414)
3665 BOOL16 WINAPI ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3666 UINT16 id, SEGPTR data )
3668 if (IS_STRING_ITEM(flags))
3669 return ModifyMenuA( hMenu, pos, flags, id, MapSL(data) );
3670 return ModifyMenuA( hMenu, pos, flags, id, (LPSTR)data );
3674 /*******************************************************************
3675 * ModifyMenuW (USER32.@)
3677 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3678 UINT id, LPCWSTR str )
3682 if (IS_STRING_ITEM(flags))
3684 TRACE("%04x %d %04x %04x %s\n",
3685 hMenu, pos, flags, id, debugstr_w(str) );
3686 if (!str) return FALSE;
3690 TRACE("%04x %d %04x %04x %08lx\n",
3691 hMenu, pos, flags, id, (DWORD)str );
3694 if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3695 return MENU_SetItemData( item, flags, id, str );
3699 /*******************************************************************
3700 * ModifyMenuA (USER32.@)
3702 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3703 UINT id, LPCSTR str )
3707 if (IS_STRING_ITEM(flags) && str)
3709 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3710 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3713 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3714 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3715 HeapFree( GetProcessHeap(), 0, newstr );
3719 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3723 /**********************************************************************
3724 * CreatePopupMenu (USER.415)
3726 HMENU16 WINAPI CreatePopupMenu16(void)
3728 return CreatePopupMenu();
3732 /**********************************************************************
3733 * CreatePopupMenu (USER32.@)
3735 HMENU WINAPI CreatePopupMenu(void)
3740 if (!(hmenu = CreateMenu())) return 0;
3741 menu = MENU_GetMenu( hmenu );
3742 menu->wFlags |= MF_POPUP;
3743 menu->bTimeToHide = FALSE;
3748 /**********************************************************************
3749 * GetMenuCheckMarkDimensions (USER.417)
3750 * GetMenuCheckMarkDimensions (USER32.@)
3752 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3754 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3758 /**********************************************************************
3759 * SetMenuItemBitmaps (USER.418)
3761 BOOL16 WINAPI SetMenuItemBitmaps16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags,
3762 HBITMAP16 hNewUnCheck, HBITMAP16 hNewCheck)
3764 return SetMenuItemBitmaps( hMenu, nPos, wFlags, hNewUnCheck, hNewCheck );
3768 /**********************************************************************
3769 * SetMenuItemBitmaps (USER32.@)
3771 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3772 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3775 TRACE("(%04x, %04x, %04x, %04x, %04x)\n",
3776 hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3777 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3779 if (!hNewCheck && !hNewUnCheck)
3781 item->fState &= ~MF_USECHECKBITMAPS;
3783 else /* Install new bitmaps */
3785 item->hCheckBit = hNewCheck;
3786 item->hUnCheckBit = hNewUnCheck;
3787 item->fState |= MF_USECHECKBITMAPS;
3793 /**********************************************************************
3794 * CreateMenu (USER.151)
3796 HMENU16 WINAPI CreateMenu16(void)
3798 return CreateMenu();
3802 /**********************************************************************
3803 * CreateMenu (USER32.@)
3805 HMENU WINAPI CreateMenu(void)
3809 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3810 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3812 ZeroMemory(menu, sizeof(POPUPMENU));
3813 menu->wMagic = MENU_MAGIC;
3814 menu->FocusedItem = NO_SELECTED_ITEM;
3815 menu->bTimeToHide = FALSE;
3817 TRACE("return %04x\n", hMenu );
3823 /**********************************************************************
3824 * DestroyMenu (USER.152)
3826 BOOL16 WINAPI DestroyMenu16( HMENU16 hMenu )
3828 return DestroyMenu( hMenu );
3832 /**********************************************************************
3833 * DestroyMenu (USER32.@)
3835 BOOL WINAPI DestroyMenu( HMENU hMenu )
3837 TRACE("(%04x)\n", hMenu);
3839 /* Silently ignore attempts to destroy default system popup */
3841 if (hMenu && hMenu != MENU_DefSysPopup)
3843 LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3845 if (!lppop) return FALSE;
3847 lppop->wMagic = 0; /* Mark it as destroyed */
3849 if ((lppop->wFlags & MF_POPUP) && lppop->hWnd)
3851 DestroyWindow( lppop->hWnd );
3855 if (lppop->items) /* recursively destroy submenus */
3858 MENUITEM *item = lppop->items;
3859 for (i = lppop->nItems; i > 0; i--, item++)
3861 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3862 MENU_FreeItemData( item );
3864 HeapFree( GetProcessHeap(), 0, lppop->items );
3866 USER_HEAP_FREE( hMenu );
3868 return (hMenu != MENU_DefSysPopup);
3872 /**********************************************************************
3873 * GetSystemMenu (USER32.@)
3875 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3877 WND *wndPtr = WIN_FindWndPtr( hWnd );
3882 if( wndPtr->hSysMenu )
3886 DestroyMenu(wndPtr->hSysMenu);
3887 wndPtr->hSysMenu = 0;
3891 POPUPMENU *menu = MENU_GetMenu( wndPtr->hSysMenu );
3894 if( menu->nItems > 0 && menu->items[0].hSubMenu == MENU_DefSysPopup )
3895 menu->items[0].hSubMenu = MENU_CopySysPopup();
3899 WARN("Current sys-menu (%04x) of wnd %04x is broken\n",
3900 wndPtr->hSysMenu, hWnd);
3901 wndPtr->hSysMenu = 0;
3906 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
3907 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU)(-1) );
3909 if( wndPtr->hSysMenu )
3912 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
3914 /* Store the dummy sysmenu handle to facilitate the refresh */
3915 /* of the close button if the SC_CLOSE item change */
3916 menu = MENU_GetMenu(retvalue);
3918 menu->hSysMenuOwner = wndPtr->hSysMenu;
3920 WIN_ReleaseWndPtr(wndPtr);
3922 return bRevert ? 0 : retvalue;
3926 /*******************************************************************
3927 * SetSystemMenu (USER32.@)
3929 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
3931 WND *wndPtr = WIN_FindWndPtr(hwnd);
3935 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
3936 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
3937 WIN_ReleaseWndPtr(wndPtr);
3944 /**********************************************************************
3945 * GetMenu (USER32.@)
3947 HMENU WINAPI GetMenu( HWND hWnd )
3949 HMENU retvalue = (HMENU)GetWindowLongA( hWnd, GWL_ID );
3950 TRACE("for %04x returning %04x\n", hWnd, retvalue);
3955 /**********************************************************************
3956 * SetMenu (USER32.@)
3958 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
3960 TRACE("(%04x, %04x);\n", hWnd, hMenu);
3962 if (hMenu && !IsMenu(hMenu))
3964 WARN("hMenu %x is not a menu handle\n", hMenu);
3967 if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
3969 hWnd = WIN_GetFullHandle( hWnd );
3970 if (GetCapture() == hWnd) ReleaseCapture();
3976 if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
3978 lpmenu->hWnd = hWnd;
3979 lpmenu->Height = 0; /* Make sure we recalculate the size */
3981 SetWindowLongA( hWnd, GWL_ID, hMenu );
3983 if (IsWindowVisible(hWnd))
3984 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3985 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3991 /**********************************************************************
3992 * GetSubMenu (USER.159)
3994 HMENU16 WINAPI GetSubMenu16( HMENU16 hMenu, INT16 nPos )
3996 return GetSubMenu( hMenu, nPos );
4000 /**********************************************************************
4001 * GetSubMenu (USER32.@)
4003 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4007 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return 0;
4008 if (!(lpmi->fType & MF_POPUP)) return 0;
4009 return lpmi->hSubMenu;
4013 /**********************************************************************
4014 * DrawMenuBar (USER32.@)
4016 BOOL WINAPI DrawMenuBar( HWND hWnd )
4019 HMENU hMenu = GetMenu(hWnd);
4021 if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
4022 if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
4024 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4025 lppop->hwndOwner = hWnd;
4026 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4027 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4031 /***********************************************************************
4032 * DrawMenuBarTemp (USER32.@)
4036 * called by W98SE desk.cpl Control Panel Applet
4038 * Not 100% sure about the param names, but close.
4040 DWORD WINAPI DrawMenuBarTemp(HWND someHWND, HDC someHDC, LPRECT someRECT, HMENU someHMENU, HFONT someFONT)
4042 FIXME("(0x%08x, 0x%08x, %p, 0x%08x, 0x%08x): stub\n", someHWND, someHDC, someRECT, someHMENU, someFONT);
4046 /***********************************************************************
4047 * EndMenu (USER.187)
4048 * EndMenu (USER32.@)
4050 void WINAPI EndMenu(void)
4052 /* if we are in the menu code, and it is active */
4053 if (!fEndMenu && top_popup)
4055 /* terminate the menu handling code */
4058 /* needs to be posted to wakeup the internal menu handler */
4059 /* which will now terminate the menu, in the event that */
4060 /* the main window was minimized, or lost focus, so we */
4061 /* don't end up with an orphaned menu */
4062 PostMessageA( top_popup, WM_CANCELMODE, 0, 0);
4067 /***********************************************************************
4068 * LookupMenuHandle (USER.217)
4070 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
4072 HMENU hmenu32 = hmenu;
4074 if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
4075 else return hmenu32;
4079 /**********************************************************************
4080 * LoadMenu (USER.150)
4082 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
4088 TRACE("(%04x,%s)\n", instance, debugstr_a(name) );
4092 if (name[0] == '#') name = (LPCSTR)atoi( name + 1 );
4095 if (!name) return 0;
4097 /* check for Win32 module */
4098 if (HIWORD(instance)) return LoadMenuA( instance, name );
4099 instance = GetExePtr( instance );
4101 if (!(hRsrc = FindResource16( instance, name, RT_MENUA ))) return 0;
4102 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
4103 hMenu = LoadMenuIndirect16(LockResource16(handle));
4104 FreeResource16( handle );
4109 /*****************************************************************
4110 * LoadMenuA (USER32.@)
4112 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4114 HRSRC hrsrc = FindResourceA( instance, name, RT_MENUA );
4115 if (!hrsrc) return 0;
4116 return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
4120 /*****************************************************************
4121 * LoadMenuW (USER32.@)
4123 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4125 HRSRC hrsrc = FindResourceW( instance, name, RT_MENUW );
4126 if (!hrsrc) return 0;
4127 return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
4131 /**********************************************************************
4132 * LoadMenuIndirect (USER.220)
4134 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
4137 WORD version, offset;
4138 LPCSTR p = (LPCSTR)template;
4140 TRACE("(%p)\n", template );
4141 version = GET_WORD(p);
4145 WARN("version must be 0 for Win16\n" );
4148 offset = GET_WORD(p);
4149 p += sizeof(WORD) + offset;
4150 if (!(hMenu = CreateMenu())) return 0;
4151 if (!MENU_ParseResource( p, hMenu, FALSE ))
4153 DestroyMenu( hMenu );
4160 /**********************************************************************
4161 * LoadMenuIndirectA (USER32.@)
4163 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4166 WORD version, offset;
4167 LPCSTR p = (LPCSTR)template;
4169 version = GET_WORD(p);
4171 TRACE("%p, ver %d\n", template, version );
4175 offset = GET_WORD(p);
4176 p += sizeof(WORD) + offset;
4177 if (!(hMenu = CreateMenu())) return 0;
4178 if (!MENU_ParseResource( p, hMenu, TRUE ))
4180 DestroyMenu( hMenu );
4185 offset = GET_WORD(p);
4186 p += sizeof(WORD) + offset;
4187 if (!(hMenu = CreateMenu())) return 0;
4188 if (!MENUEX_ParseResource( p, hMenu))
4190 DestroyMenu( hMenu );
4195 ERR("version %d not supported.\n", version);
4201 /**********************************************************************
4202 * LoadMenuIndirectW (USER32.@)
4204 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4206 /* FIXME: is there anything different between A and W? */
4207 return LoadMenuIndirectA( template );
4211 /**********************************************************************
4214 BOOL16 WINAPI IsMenu16( HMENU16 hmenu )
4216 return IsMenu( hmenu );
4220 /**********************************************************************
4223 BOOL WINAPI IsMenu(HMENU hmenu)
4225 LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4226 return menu != NULL;
4229 /**********************************************************************
4230 * GetMenuItemInfo_common
4233 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4234 LPMENUITEMINFOW lpmii, BOOL unicode)
4236 MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos? MF_BYPOSITION : 0);
4238 debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4243 if (lpmii->fMask & MIIM_TYPE) {
4244 lpmii->fType = menu->fType;
4245 switch (MENU_ITEM_TYPE(menu->fType)) {
4247 break; /* will be done below */
4250 lpmii->dwTypeData = menu->text;
4257 /* copy the text string */
4258 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING)) &&
4259 (MENU_ITEM_TYPE(menu->fType) == MF_STRING) && menu->text)
4264 len = strlenW(menu->text);
4265 if(lpmii->dwTypeData && lpmii->cch)
4266 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4270 len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL, 0, NULL, NULL );
4271 if(lpmii->dwTypeData && lpmii->cch)
4272 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4273 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4274 ((LPSTR)lpmii->dwTypeData)[lpmii->cch-1] = 0;
4276 /* if we've copied a substring we return its length */
4277 if(lpmii->dwTypeData && lpmii->cch)
4279 if (lpmii->cch <= len) lpmii->cch--;
4281 else /* return length of string */
4285 if (lpmii->fMask & MIIM_FTYPE)
4286 lpmii->fType = menu->fType;
4288 if (lpmii->fMask & MIIM_BITMAP)
4289 lpmii->hbmpItem = menu->hbmpItem;
4291 if (lpmii->fMask & MIIM_STATE)
4292 lpmii->fState = menu->fState;
4294 if (lpmii->fMask & MIIM_ID)
4295 lpmii->wID = menu->wID;
4297 if (lpmii->fMask & MIIM_SUBMENU)
4298 lpmii->hSubMenu = menu->hSubMenu;
4300 if (lpmii->fMask & MIIM_CHECKMARKS) {
4301 lpmii->hbmpChecked = menu->hCheckBit;
4302 lpmii->hbmpUnchecked = menu->hUnCheckBit;
4304 if (lpmii->fMask & MIIM_DATA)
4305 lpmii->dwItemData = menu->dwItemData;
4310 /**********************************************************************
4311 * GetMenuItemInfoA (USER32.@)
4313 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4314 LPMENUITEMINFOA lpmii)
4316 return GetMenuItemInfo_common (hmenu, item, bypos,
4317 (LPMENUITEMINFOW)lpmii, FALSE);
4320 /**********************************************************************
4321 * GetMenuItemInfoW (USER32.@)
4323 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4324 LPMENUITEMINFOW lpmii)
4326 return GetMenuItemInfo_common (hmenu, item, bypos,
4331 /* set a menu item text from a ASCII or Unicode string */
4332 inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4337 menu->fType |= MF_SEPARATOR;
4341 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4342 strcpyW( menu->text, text );
4346 LPCSTR str = (LPCSTR)text;
4347 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4348 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4349 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4354 /**********************************************************************
4355 * SetMenuItemInfo_common
4358 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4359 const MENUITEMINFOW *lpmii,
4362 if (!menu) return FALSE;
4364 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu, "");
4366 if (lpmii->fMask & MIIM_TYPE ) {
4367 /* Get rid of old string. */
4368 if (IS_STRING_ITEM(menu->fType) && menu->text) {
4369 HeapFree(GetProcessHeap(), 0, menu->text);
4373 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4374 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4375 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4377 menu->text = lpmii->dwTypeData;
4379 if (IS_STRING_ITEM(menu->fType))
4380 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4383 if (lpmii->fMask & MIIM_FTYPE ) {
4384 /* free the string when the type is changing */
4385 if ( (!IS_STRING_ITEM(lpmii->fType)) && IS_STRING_ITEM(menu->fType) && menu->text) {
4386 HeapFree(GetProcessHeap(), 0, menu->text);
4389 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4390 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4391 if ( IS_STRING_ITEM(menu->fType) && !menu->text )
4392 menu->fType |= MF_SEPARATOR;
4395 if (lpmii->fMask & MIIM_STRING ) {
4396 /* free the string when used */
4397 if (IS_STRING_ITEM(menu->fType) && menu->text) {
4398 HeapFree(GetProcessHeap(), 0, menu->text);
4399 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4403 if (lpmii->fMask & MIIM_STATE)
4405 /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4406 menu->fState = lpmii->fState;
4409 if (lpmii->fMask & MIIM_ID)
4410 menu->wID = lpmii->wID;
4412 if (lpmii->fMask & MIIM_SUBMENU) {
4413 menu->hSubMenu = lpmii->hSubMenu;
4414 if (menu->hSubMenu) {
4415 POPUPMENU *subMenu = MENU_GetMenu((UINT16)menu->hSubMenu);
4417 subMenu->wFlags |= MF_POPUP;
4418 menu->fType |= MF_POPUP;
4421 /* FIXME: Return an error ? */
4422 menu->fType &= ~MF_POPUP;
4425 menu->fType &= ~MF_POPUP;
4428 if (lpmii->fMask & MIIM_CHECKMARKS)
4430 if (lpmii->fType & MFT_RADIOCHECK)
4431 menu->fType |= MFT_RADIOCHECK;
4433 menu->hCheckBit = lpmii->hbmpChecked;
4434 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4436 if (lpmii->fMask & MIIM_DATA)
4437 menu->dwItemData = lpmii->dwItemData;
4439 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4443 /**********************************************************************
4444 * SetMenuItemInfoA (USER32.@)
4446 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4447 const MENUITEMINFOA *lpmii)
4449 if ((lpmii->fType & (MF_HILITE|MF_POPUP)) || (lpmii->fState)) {
4450 /* QuickTime does pass invalid data into SetMenuItemInfo.
4451 * do some of the checks Windows does.
4453 WARN("Bad masks for type (0x%08x) or state (0x%08x)\n",
4454 lpmii->fType,lpmii->fState );
4458 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4459 (const MENUITEMINFOW *)lpmii, FALSE);
4462 /**********************************************************************
4463 * SetMenuItemInfoW (USER32.@)
4465 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4466 const MENUITEMINFOW *lpmii)
4468 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4472 /**********************************************************************
4473 * SetMenuDefaultItem (USER32.@)
4476 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4482 TRACE("(0x%x,%d,%d)\n", hmenu, uItem, bypos);
4484 if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4486 /* reset all default-item flags */
4488 for (i = 0; i < menu->nItems; i++, item++)
4490 item->fState &= ~MFS_DEFAULT;
4493 /* no default item */
4502 if ( uItem >= menu->nItems ) return FALSE;
4503 item[uItem].fState |= MFS_DEFAULT;
4508 for (i = 0; i < menu->nItems; i++, item++)
4510 if (item->wID == uItem)
4512 item->fState |= MFS_DEFAULT;
4521 /**********************************************************************
4522 * GetMenuDefaultItem (USER32.@)
4524 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4530 TRACE("(0x%x,%d,%d)\n", hmenu, bypos, flags);
4532 if (!(menu = MENU_GetMenu(hmenu))) return -1;
4534 /* find default item */
4538 if (! item) return -1;
4540 while ( !( item->fState & MFS_DEFAULT ) )
4543 if (i >= menu->nItems ) return -1;
4546 /* default: don't return disabled items */
4547 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4549 /* search rekursiv when needed */
4550 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4553 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4554 if ( -1 != ret ) return ret;
4556 /* when item not found in submenu, return the popup item */
4558 return ( bypos ) ? i : item->wID;
4562 /*******************************************************************
4563 * InsertMenuItem (USER.441)
4567 BOOL16 WINAPI InsertMenuItem16( HMENU16 hmenu, UINT16 pos, BOOL16 byposition,
4568 const MENUITEMINFO16 *mii )
4572 miia.cbSize = sizeof(miia);
4573 miia.fMask = mii->fMask;
4574 miia.dwTypeData = (LPSTR)mii->dwTypeData;
4575 miia.fType = mii->fType;
4576 miia.fState = mii->fState;
4577 miia.wID = mii->wID;
4578 miia.hSubMenu = mii->hSubMenu;
4579 miia.hbmpChecked = mii->hbmpChecked;
4580 miia.hbmpUnchecked = mii->hbmpUnchecked;
4581 miia.dwItemData = mii->dwItemData;
4582 miia.cch = mii->cch;
4583 if (IS_STRING_ITEM(miia.fType))
4584 miia.dwTypeData = MapSL(mii->dwTypeData);
4585 return InsertMenuItemA( hmenu, pos, byposition, &miia );
4589 /**********************************************************************
4590 * InsertMenuItemA (USER32.@)
4592 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4593 const MENUITEMINFOA *lpmii)
4595 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4596 return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)lpmii, FALSE);
4600 /**********************************************************************
4601 * InsertMenuItemW (USER32.@)
4603 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4604 const MENUITEMINFOW *lpmii)
4606 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4607 return SetMenuItemInfo_common(item, lpmii, TRUE);
4610 /**********************************************************************
4611 * CheckMenuRadioItem (USER32.@)
4614 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4615 UINT first, UINT last, UINT check,
4618 MENUITEM *mifirst, *milast, *micheck;
4619 HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4621 TRACE("ox%x: %d-%d, check %d, bypos=%d\n",
4622 hMenu, first, last, check, bypos);
4624 mifirst = MENU_FindItem (&mfirst, &first, bypos);
4625 milast = MENU_FindItem (&mlast, &last, bypos);
4626 micheck = MENU_FindItem (&mcheck, &check, bypos);
4628 if (mifirst == NULL || milast == NULL || micheck == NULL ||
4629 mifirst > milast || mfirst != mlast || mfirst != mcheck ||
4630 micheck > milast || micheck < mifirst)
4633 while (mifirst <= milast)
4635 if (mifirst == micheck)
4637 mifirst->fType |= MFT_RADIOCHECK;
4638 mifirst->fState |= MFS_CHECKED;
4640 mifirst->fType &= ~MFT_RADIOCHECK;
4641 mifirst->fState &= ~MFS_CHECKED;
4649 /**********************************************************************
4650 * CheckMenuRadioItem (USER.666)
4652 BOOL16 WINAPI CheckMenuRadioItem16(HMENU16 hMenu,
4653 UINT16 first, UINT16 last, UINT16 check,
4656 return CheckMenuRadioItem (hMenu, first, last, check, bypos);
4659 /**********************************************************************
4660 * GetMenuItemRect (USER32.@)
4662 * ATTENTION: Here, the returned values in rect are the screen
4663 * coordinates of the item just like if the menu was
4664 * always on the upper left side of the application.
4667 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4670 POPUPMENU *itemMenu;
4674 TRACE("(0x%x,0x%x,%d,%p)\n", hwnd, hMenu, uItem, rect);
4676 item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4677 referenceHwnd = hwnd;
4681 itemMenu = MENU_GetMenu(hMenu);
4682 if (itemMenu == NULL)
4685 if(itemMenu->hWnd == 0)
4687 referenceHwnd = itemMenu->hWnd;
4690 if ((rect == NULL) || (item == NULL))
4695 MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4701 /**********************************************************************
4702 * SetMenuInfo (USER32.@)
4705 * MIM_APPLYTOSUBMENUS
4706 * actually use the items to draw the menu
4708 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4712 TRACE("(0x%04x %p)\n", hMenu, lpmi);
4714 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4717 if (lpmi->fMask & MIM_BACKGROUND)
4718 menu->hbrBack = lpmi->hbrBack;
4720 if (lpmi->fMask & MIM_HELPID)
4721 menu->dwContextHelpID = lpmi->dwContextHelpID;
4723 if (lpmi->fMask & MIM_MAXHEIGHT)
4724 menu->cyMax = lpmi->cyMax;
4726 if (lpmi->fMask & MIM_MENUDATA)
4727 menu->dwMenuData = lpmi->dwMenuData;
4729 if (lpmi->fMask & MIM_STYLE)
4730 menu->dwStyle = lpmi->dwStyle;
4737 /**********************************************************************
4738 * GetMenuInfo (USER32.@)
4744 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4747 TRACE("(0x%04x %p)\n", hMenu, lpmi);
4749 if (lpmi && (menu = MENU_GetMenu(hMenu)))
4752 if (lpmi->fMask & MIM_BACKGROUND)
4753 lpmi->hbrBack = menu->hbrBack;
4755 if (lpmi->fMask & MIM_HELPID)
4756 lpmi->dwContextHelpID = menu->dwContextHelpID;
4758 if (lpmi->fMask & MIM_MAXHEIGHT)
4759 lpmi->cyMax = menu->cyMax;
4761 if (lpmi->fMask & MIM_MENUDATA)
4762 lpmi->dwMenuData = menu->dwMenuData;
4764 if (lpmi->fMask & MIM_STYLE)
4765 lpmi->dwStyle = menu->dwStyle;
4772 /**********************************************************************
4773 * SetMenuContextHelpId (USER.384)
4775 BOOL16 WINAPI SetMenuContextHelpId16( HMENU16 hMenu, DWORD dwContextHelpID)
4777 return SetMenuContextHelpId( hMenu, dwContextHelpID );
4781 /**********************************************************************
4782 * SetMenuContextHelpId (USER32.@)
4784 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4788 TRACE("(0x%04x 0x%08lx)\n", hMenu, dwContextHelpID);
4790 if ((menu = MENU_GetMenu(hMenu)))
4792 menu->dwContextHelpID = dwContextHelpID;
4798 /**********************************************************************
4799 * GetMenuContextHelpId (USER.385)
4801 DWORD WINAPI GetMenuContextHelpId16( HMENU16 hMenu )
4803 return GetMenuContextHelpId( hMenu );
4806 /**********************************************************************
4807 * GetMenuContextHelpId (USER32.@)
4809 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4813 TRACE("(0x%04x)\n", hMenu);
4815 if ((menu = MENU_GetMenu(hMenu)))
4817 return menu->dwContextHelpID;
4822 /**********************************************************************
4823 * MenuItemFromPoint (USER32.@)
4825 UINT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
4827 POPUPMENU *menu = MENU_GetMenu(hMenu);
4831 /*FIXME: Do we have to handle hWnd here? */
4832 item = MENU_FindItemByCoords(menu, ptScreen, &pos);
4838 /**********************************************************************
4839 * translate_accelerator
4841 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
4842 BYTE fVirt, WORD key, WORD cmd )
4846 if (wParam != key) return FALSE;
4848 if (message == WM_CHAR)
4850 if ( !(fVirt & FALT) && !(fVirt & FVIRTKEY) )
4852 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
4858 if(fVirt & FVIRTKEY)
4861 TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
4862 wParam, 0xff & HIWORD(lParam));
4863 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
4864 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
4865 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
4866 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
4867 TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
4871 if (!(lParam & 0x01000000)) /* no special_key */
4873 if ((fVirt & FALT) && (lParam & 0x20000000))
4874 { /* ^^ ALT pressed */
4875 TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
4884 if (message == WM_KEYUP || message == WM_SYSKEYUP)
4886 else if (GetCapture())
4888 else if (!IsWindowEnabled(hWnd))
4892 HMENU hMenu, hSubMenu, hSysMenu;
4893 UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
4895 hMenu = (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
4896 hSysMenu = get_win_sys_menu( hWnd );
4898 /* find menu item and ask application to initialize it */
4899 /* 1. in the system menu */
4900 hSubMenu = hSysMenu;
4902 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4904 SendMessageA(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
4905 if(hSubMenu != hSysMenu)
4907 nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
4908 TRACE_(accel)("hSysMenu = %04x, hSubMenu = %04x, nPos = %d\n", hSysMenu, hSubMenu, nPos);
4909 SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
4911 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
4913 else /* 2. in the window's menu */
4917 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4919 SendMessageA(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
4920 if(hSubMenu != hMenu)
4922 nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
4923 TRACE_(accel)("hMenu = %04x, hSubMenu = %04x, nPos = %d\n", hMenu, hSubMenu, nPos);
4924 SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
4926 uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
4930 if (uSysStat != (UINT)-1)
4932 if (uSysStat & (MF_DISABLED|MF_GRAYED))
4939 if (uStat != (UINT)-1)
4945 if (uStat & (MF_DISABLED|MF_GRAYED))
4956 if( mesg==WM_COMMAND )
4958 TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
4959 SendMessageA(hWnd, mesg, 0x10000 | cmd, 0L);
4961 else if( mesg==WM_SYSCOMMAND )
4963 TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
4964 SendMessageA(hWnd, mesg, cmd, 0x00010000L);
4968 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4969 * #0: unknown (please report!)
4970 * #1: for WM_KEYUP,WM_SYSKEYUP
4971 * #2: mouse is captured
4972 * #3: window is disabled
4973 * #4: it's a disabled system menu option
4974 * #5: it's a menu option, but window is iconic
4975 * #6: it's a menu option, but disabled
4977 TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
4979 ERR_(accel)(" unknown reason - please report!");
4984 /**********************************************************************
4985 * TranslateAccelerator (USER32.@)
4986 * TranslateAcceleratorA (USER32.@)
4987 * TranslateAcceleratorW (USER32.@)
4989 INT WINAPI TranslateAccelerator( HWND hWnd, HACCEL hAccel, LPMSG msg )
4992 LPACCEL16 lpAccelTbl;
4997 WARN_(accel)("msg null; should hang here to be win compatible\n");
5000 if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
5002 WARN_(accel)("invalid accel handle=%x\n", hAccel);
5005 if ((msg->message != WM_KEYDOWN &&
5006 msg->message != WM_KEYUP &&
5007 msg->message != WM_SYSKEYDOWN &&
5008 msg->message != WM_SYSKEYUP &&
5009 msg->message != WM_CHAR)) return 0;
5011 TRACE_(accel)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5012 "msg->hwnd=%04x, msg->message=%04x, wParam=%08x, lParam=%lx\n",
5013 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5018 if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
5019 lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
5021 } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
5022 WARN_(accel)("couldn't translate accelerator key\n");