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"
39 #include "wine/winbase16.h"
40 #include "wine/winuser16.h"
42 #include "wine/server.h"
43 #include "wine/unicode.h"
46 #include "nonclient.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(menu
);
51 WINE_DECLARE_DEBUG_CHANNEL(accel
);
53 /* internal popup menu window messages */
55 #define MM_SETMENUHANDLE (WM_USER + 0)
56 #define MM_GETMENUHANDLE (WM_USER + 1)
58 /* Menu item structure */
60 /* ----------- MENUITEMINFO Stuff ----------- */
61 UINT fType
; /* Item type. */
62 UINT fState
; /* Item state. */
63 UINT_PTR wID
; /* Item id. */
64 HMENU hSubMenu
; /* Pop-up menu. */
65 HBITMAP hCheckBit
; /* Bitmap when checked. */
66 HBITMAP hUnCheckBit
; /* Bitmap when unchecked. */
67 LPWSTR text
; /* Item text or bitmap handle. */
68 DWORD dwItemData
; /* Application defined. */
69 DWORD dwTypeData
; /* depends on fMask */
70 HBITMAP hbmpItem
; /* bitmap in win98 style menus */
71 /* ----------- Wine stuff ----------- */
72 RECT rect
; /* Item area (relative to menu window) */
73 UINT xTab
; /* X position of text after Tab */
76 /* Popup menu structure */
78 WORD wFlags
; /* Menu flags (MF_POPUP, MF_SYSMENU) */
79 WORD wMagic
; /* Magic number */
80 WORD Width
; /* Width of the whole menu */
81 WORD Height
; /* Height of the whole menu */
82 UINT nItems
; /* Number of items in the menu */
83 HWND hWnd
; /* Window containing the menu */
84 MENUITEM
*items
; /* Array of menu items */
85 UINT FocusedItem
; /* Currently focused item */
86 HWND hwndOwner
; /* window receiving the messages for ownerdraw */
87 BOOL bTimeToHide
; /* Request hiding when receiving a second click in the top-level menu item */
88 /* ------------ MENUINFO members ------ */
89 DWORD dwStyle
; /* Extended mennu style */
90 UINT cyMax
; /* max hight of the whole menu, 0 is screen hight */
91 HBRUSH hbrBack
; /* brush for menu background */
92 DWORD dwContextHelpID
;
93 DWORD dwMenuData
; /* application defined value */
94 HMENU hSysMenuOwner
; /* Handle to the dummy sys menu holder */
95 } POPUPMENU
, *LPPOPUPMENU
;
97 /* internal flags for menu tracking */
99 #define TF_ENDMENU 0x0001
100 #define TF_SUSPENDPOPUP 0x0002
101 #define TF_SKIPREMOVE 0x0004
106 HMENU hCurrentMenu
; /* current submenu (can be equal to hTopMenu)*/
107 HMENU hTopMenu
; /* initial menu */
108 HWND hOwnerWnd
; /* where notifications are sent */
112 #define MENU_MAGIC 0x554d /* 'MU' */
117 /* Internal MENU_TrackMenu() flags */
118 #define TPM_INTERNAL 0xF0000000
119 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
120 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
121 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
123 /* popup menu shade thickness */
124 #define POPUP_XSHADE 4
125 #define POPUP_YSHADE 4
127 /* Space between 2 menu bar items */
128 #define MENU_BAR_ITEMS_SPACE 12
130 /* Minimum width of a tab character */
131 #define MENU_TAB_SPACE 8
133 /* Height of a separator item */
134 #define SEPARATOR_HEIGHT 5
136 /* (other menu->FocusedItem values give the position of the focused item) */
137 #define NO_SELECTED_ITEM 0xffff
139 #define MENU_ITEM_TYPE(flags) \
140 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
142 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
143 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
144 #define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
146 #define IS_SYSTEM_MENU(menu) \
147 (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
149 #define IS_SYSTEM_POPUP(menu) \
150 ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
152 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
153 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
154 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
155 MF_POPUP | MF_SYSMENU | MF_HELP)
156 #define STATE_MASK (~TYPE_MASK)
158 /* Dimension of the menu bitmaps */
159 static WORD arrow_bitmap_width
= 0, arrow_bitmap_height
= 0;
161 static HBITMAP hStdMnArrow
= 0;
162 static HBITMAP hBmpSysMenu
= 0;
164 static HBRUSH hShadeBrush
= 0;
165 static HFONT hMenuFont
= 0;
166 static HFONT hMenuFontBold
= 0;
168 static HMENU MENU_DefSysPopup
= 0; /* Default system menu popup */
170 /* Use global popup window because there's no way 2 menus can
171 * be tracked at the same time. */
172 static HWND top_popup
;
174 /* Flag set by EndMenu() to force an exit from menu tracking */
175 static BOOL fEndMenu
= FALSE
;
177 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
179 DWORD WINAPI
DrawMenuBarTemp(HWND hwnd
, HDC hDC
, LPRECT lprect
, HMENU hMenu
, HFONT hFont
);
181 /*********************************************************************
182 * menu class descriptor
184 const struct builtin_class_descr MENU_builtin_class
=
186 POPUPMENU_CLASS_ATOMA
, /* name */
187 CS_DROPSHADOW
| CS_SAVEBITS
| CS_DBLCLKS
, /* style */
188 NULL
, /* procA (winproc is Unicode only) */
189 PopupMenuWndProc
, /* procW */
190 sizeof(HMENU
), /* extra */
191 IDC_ARROW
, /* cursor */
192 (HBRUSH
)(COLOR_MENU
+1) /* brush */
196 /***********************************************************************
197 * debug_print_menuitem
199 * Print a menuitem in readable form.
202 #define debug_print_menuitem(pre, mp, post) \
203 if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
205 #define MENUOUT(text) \
206 DPRINTF("%s%s", (count++ ? "," : ""), (text))
208 #define MENUFLAG(bit,text) \
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=%p", 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=%p", mp
->hCheckBit
);
266 DPRINTF( ", Unc=%p", 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=%p, 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 static const WCHAR sysmenuW
[] = {'S','Y','S','M','E','N','U',0};
332 HMENU hMenu
= LoadMenuW(user32_module
, sysmenuW
);
335 POPUPMENU
* menu
= MENU_GetMenu(hMenu
);
336 menu
->wFlags
|= MF_SYSMENU
| MF_POPUP
;
337 SetMenuDefaultItem(hMenu
, SC_CLOSE
, FALSE
);
340 ERR("Unable to load default system menu\n" );
342 TRACE("returning %p.\n", hMenu
);
348 /**********************************************************************
351 * Create a copy of the system menu. System menu in Windows is
352 * a special menu bar with the single entry - system menu popup.
353 * This popup is presented to the outside world as a "system menu".
354 * However, the real system menu handle is sometimes seen in the
355 * WM_MENUSELECT parameters (and Word 6 likes it this way).
357 HMENU
MENU_GetSysMenu( HWND hWnd
, HMENU hPopupMenu
)
361 TRACE("loading system menu, hWnd %p, hPopupMenu %p\n", hWnd
, hPopupMenu
);
362 if ((hMenu
= CreateMenu()))
364 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
365 menu
->wFlags
= MF_SYSMENU
;
366 menu
->hWnd
= WIN_GetFullHandle( hWnd
);
367 TRACE("hWnd %p (hMenu %p)\n", menu
->hWnd
, hMenu
);
369 if (hPopupMenu
== (HMENU
)(-1))
370 hPopupMenu
= MENU_CopySysPopup();
371 else if( !hPopupMenu
) hPopupMenu
= MENU_DefSysPopup
;
375 InsertMenuW( hMenu
, -1, MF_SYSMENU
| MF_POPUP
| MF_BYPOSITION
,
376 (UINT_PTR
)hPopupMenu
, NULL
);
378 menu
->items
[0].fType
= MF_SYSMENU
| MF_POPUP
;
379 menu
->items
[0].fState
= 0;
380 if ((menu
= MENU_GetMenu(hPopupMenu
))) menu
->wFlags
|= MF_SYSMENU
;
382 TRACE("hMenu=%p (hPopup %p)\n", hMenu
, hPopupMenu
);
385 DestroyMenu( hMenu
);
387 ERR("failed to load system menu!\n");
392 /***********************************************************************
395 * Menus initialisation.
400 NONCLIENTMETRICSW ncm
;
402 static unsigned char shade_bits
[16] = { 0x55, 0, 0xAA, 0,
407 /* Load menu bitmaps */
408 hStdMnArrow
= LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW
));
409 /* Load system buttons bitmaps */
410 hBmpSysMenu
= LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE
));
415 GetObjectW( hStdMnArrow
, sizeof(bm
), &bm
);
416 arrow_bitmap_width
= bm
.bmWidth
;
417 arrow_bitmap_height
= bm
.bmHeight
;
421 if (! (hBitmap
= CreateBitmap( 8, 8, 1, 1, shade_bits
)))
424 if(!(hShadeBrush
= CreatePatternBrush( hBitmap
)))
427 DeleteObject( hBitmap
);
428 if (!(MENU_DefSysPopup
= MENU_CopySysPopup()))
431 ncm
.cbSize
= sizeof(NONCLIENTMETRICSW
);
432 if (!(SystemParametersInfoW(SPI_GETNONCLIENTMETRICS
, sizeof(NONCLIENTMETRICSW
), &ncm
, 0)))
435 if (!(hMenuFont
= CreateFontIndirectW( &ncm
.lfMenuFont
)))
438 ncm
.lfMenuFont
.lfWeight
+= 300;
439 if ( ncm
.lfMenuFont
.lfWeight
> 1000)
440 ncm
.lfMenuFont
.lfWeight
= 1000;
442 if (!(hMenuFontBold
= CreateFontIndirectW( &ncm
.lfMenuFont
)))
448 /***********************************************************************
449 * MENU_InitSysMenuPopup
451 * Grey the appropriate items in System menu.
453 static void MENU_InitSysMenuPopup( HMENU hmenu
, DWORD style
, DWORD clsStyle
)
457 gray
= !(style
& WS_THICKFRAME
) || (style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
458 EnableMenuItem( hmenu
, SC_SIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
459 gray
= ((style
& WS_MAXIMIZE
) != 0);
460 EnableMenuItem( hmenu
, SC_MOVE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
461 gray
= !(style
& WS_MINIMIZEBOX
) || (style
& WS_MINIMIZE
);
462 EnableMenuItem( hmenu
, SC_MINIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
463 gray
= !(style
& WS_MAXIMIZEBOX
) || (style
& WS_MAXIMIZE
);
464 EnableMenuItem( hmenu
, SC_MAXIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
465 gray
= !(style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
466 EnableMenuItem( hmenu
, SC_RESTORE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
467 gray
= (clsStyle
& CS_NOCLOSE
) != 0;
469 /* The menu item must keep its state if it's disabled */
471 EnableMenuItem( hmenu
, SC_CLOSE
, MF_GRAYED
);
475 /******************************************************************************
477 * UINT MENU_GetStartOfNextColumn(
480 *****************************************************************************/
482 static UINT
MENU_GetStartOfNextColumn(
485 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
489 return NO_SELECTED_ITEM
;
491 i
= menu
->FocusedItem
+ 1;
492 if( i
== NO_SELECTED_ITEM
)
495 for( ; i
< menu
->nItems
; ++i
) {
496 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
500 return NO_SELECTED_ITEM
;
504 /******************************************************************************
506 * UINT MENU_GetStartOfPrevColumn(
509 *****************************************************************************/
511 static UINT
MENU_GetStartOfPrevColumn(
514 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
518 return NO_SELECTED_ITEM
;
520 if( menu
->FocusedItem
== 0 || menu
->FocusedItem
== NO_SELECTED_ITEM
)
521 return NO_SELECTED_ITEM
;
523 /* Find the start of the column */
525 for(i
= menu
->FocusedItem
; i
!= 0 &&
526 !(menu
->items
[i
].fType
& MF_MENUBARBREAK
);
530 return NO_SELECTED_ITEM
;
532 for(--i
; i
!= 0; --i
) {
533 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
537 TRACE("ret %d.\n", i
);
544 /***********************************************************************
547 * Find a menu item. Return a pointer on the item, and modifies *hmenu
548 * in case the item was in a sub-menu.
550 static MENUITEM
*MENU_FindItem( HMENU
*hmenu
, UINT
*nPos
, UINT wFlags
)
555 if ((*hmenu
== (HMENU
)0xffff) || (!(menu
= MENU_GetMenu(*hmenu
)))) return NULL
;
556 if (wFlags
& MF_BYPOSITION
)
558 if (*nPos
>= menu
->nItems
) return NULL
;
559 return &menu
->items
[*nPos
];
563 MENUITEM
*item
= menu
->items
;
564 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
566 if (item
->wID
== *nPos
)
571 else if (item
->fType
& MF_POPUP
)
573 HMENU hsubmenu
= item
->hSubMenu
;
574 MENUITEM
*subitem
= MENU_FindItem( &hsubmenu
, nPos
, wFlags
);
586 /***********************************************************************
589 * Find a Sub menu. Return the position of the submenu, and modifies
590 * *hmenu in case it is found in another sub-menu.
591 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
593 UINT
MENU_FindSubMenu( HMENU
*hmenu
, HMENU hSubTarget
)
598 if (((*hmenu
)==(HMENU
)0xffff) ||
599 (!(menu
= MENU_GetMenu(*hmenu
))))
600 return NO_SELECTED_ITEM
;
602 for (i
= 0; i
< menu
->nItems
; i
++, item
++) {
603 if(!(item
->fType
& MF_POPUP
)) continue;
604 if (item
->hSubMenu
== hSubTarget
) {
608 HMENU hsubmenu
= item
->hSubMenu
;
609 UINT pos
= MENU_FindSubMenu( &hsubmenu
, hSubTarget
);
610 if (pos
!= NO_SELECTED_ITEM
) {
616 return NO_SELECTED_ITEM
;
619 /***********************************************************************
622 static void MENU_FreeItemData( MENUITEM
* item
)
625 if (IS_STRING_ITEM(item
->fType
) && item
->text
)
626 HeapFree( GetProcessHeap(), 0, item
->text
);
629 /***********************************************************************
630 * MENU_FindItemByCoords
632 * Find the item at the specified coordinates (screen coords). Does
633 * not work for child windows and therefore should not be called for
634 * an arbitrary system menu.
636 static MENUITEM
*MENU_FindItemByCoords( POPUPMENU
*menu
,
637 POINT pt
, UINT
*pos
)
643 if (!GetWindowRect(menu
->hWnd
,&wrect
)) return NULL
;
644 pt
.x
-= wrect
.left
;pt
.y
-= wrect
.top
;
646 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
648 if ((pt
.x
>= item
->rect
.left
) && (pt
.x
< item
->rect
.right
) &&
649 (pt
.y
>= item
->rect
.top
) && (pt
.y
< item
->rect
.bottom
))
659 /***********************************************************************
662 * Find the menu item selected by a key press.
663 * Return item id, -1 if none, -2 if we should close the menu.
665 static UINT
MENU_FindItemByKey( HWND hwndOwner
, HMENU hmenu
,
666 WCHAR key
, BOOL forceMenuChar
)
668 TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)key
, key
, hmenu
);
670 if (!IsMenu( hmenu
)) hmenu
= GetSubMenu( get_win_sys_menu(hwndOwner
), 0);
674 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
675 MENUITEM
*item
= menu
->items
;
683 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
685 if (IS_STRING_ITEM(item
->fType
) && item
->text
)
687 WCHAR
*p
= item
->text
- 2;
690 p
= strchrW (p
+ 2, '&');
692 while (p
!= NULL
&& p
[1] == '&');
693 if (p
&& (toupperW(p
[1]) == key
)) return i
;
697 menuchar
= SendMessageW( hwndOwner
, WM_MENUCHAR
,
698 MAKEWPARAM( key
, menu
->wFlags
), (LPARAM
)hmenu
);
699 if (HIWORD(menuchar
) == 2) return LOWORD(menuchar
);
700 if (HIWORD(menuchar
) == 1) return (UINT
)(-2);
706 /***********************************************************************
707 * MENU_GetBitmapItemSize
709 * Get the size of a bitmap item.
711 static void MENU_GetBitmapItemSize( UINT id
, DWORD data
, SIZE
*size
)
714 HBITMAP bmp
= (HBITMAP
)id
;
716 size
->cx
= size
->cy
= 0;
718 /* check if there is a magic menu item associated with this item */
719 if (id
&& IS_MAGIC_ITEM( id
))
723 case (INT_PTR
)HBMMENU_SYSTEM
:
730 case (INT_PTR
)HBMMENU_MBAR_RESTORE
:
731 case (INT_PTR
)HBMMENU_MBAR_MINIMIZE
:
732 case (INT_PTR
)HBMMENU_MBAR_MINIMIZE_D
:
733 case (INT_PTR
)HBMMENU_MBAR_CLOSE
:
734 case (INT_PTR
)HBMMENU_MBAR_CLOSE_D
:
735 size
->cx
= GetSystemMetrics( SM_CYMENU
) - 4;
738 case (INT_PTR
)HBMMENU_CALLBACK
:
739 case (INT_PTR
)HBMMENU_POPUP_CLOSE
:
740 case (INT_PTR
)HBMMENU_POPUP_RESTORE
:
741 case (INT_PTR
)HBMMENU_POPUP_MAXIMIZE
:
742 case (INT_PTR
)HBMMENU_POPUP_MINIMIZE
:
744 FIXME("Magic 0x%08x not implemented\n", id
);
748 if (GetObjectW(bmp
, sizeof(bm
), &bm
))
750 size
->cx
= bm
.bmWidth
;
751 size
->cy
= bm
.bmHeight
;
755 /***********************************************************************
756 * MENU_DrawBitmapItem
758 * Draw a bitmap item.
760 static void MENU_DrawBitmapItem( HDC hdc
, MENUITEM
*lpitem
, const RECT
*rect
, BOOL menuBar
)
765 HBITMAP bmp
= (HBITMAP
)lpitem
->text
;
766 int w
= rect
->right
- rect
->left
;
767 int h
= rect
->bottom
- rect
->top
;
771 /* Check if there is a magic menu item associated with this item */
772 if (lpitem
->text
&& IS_MAGIC_ITEM(lpitem
->text
))
777 switch(LOWORD(lpitem
->text
))
779 case (INT_PTR
)HBMMENU_SYSTEM
:
780 if (lpitem
->dwItemData
)
782 bmp
= (HBITMAP
)lpitem
->dwItemData
;
783 if (!GetObjectW( bmp
, sizeof(bm
), &bm
)) return;
788 if (!GetObjectW( bmp
, sizeof(bm
), &bm
)) return;
789 /* only use right half of the bitmap */
790 bmp_xoffset
= bm
.bmWidth
/ 2;
791 bm
.bmWidth
-= bmp_xoffset
;
794 case (INT_PTR
)HBMMENU_MBAR_RESTORE
:
795 flags
= DFCS_CAPTIONRESTORE
;
797 case (INT_PTR
)HBMMENU_MBAR_MINIMIZE
:
798 flags
= DFCS_CAPTIONMIN
;
800 case (INT_PTR
)HBMMENU_MBAR_MINIMIZE_D
:
801 flags
= DFCS_CAPTIONMIN
| DFCS_INACTIVE
;
803 case (INT_PTR
)HBMMENU_MBAR_CLOSE
:
804 flags
= DFCS_CAPTIONCLOSE
;
806 case (INT_PTR
)HBMMENU_MBAR_CLOSE_D
:
807 flags
= DFCS_CAPTIONCLOSE
| DFCS_INACTIVE
;
809 case (INT_PTR
)HBMMENU_CALLBACK
:
810 case (INT_PTR
)HBMMENU_POPUP_CLOSE
:
811 case (INT_PTR
)HBMMENU_POPUP_RESTORE
:
812 case (INT_PTR
)HBMMENU_POPUP_MAXIMIZE
:
813 case (INT_PTR
)HBMMENU_POPUP_MINIMIZE
:
815 FIXME("Magic 0x%08x not implemented\n", LOWORD(lpitem
->text
));
819 InflateRect( &r
, -1, -1 );
820 if (lpitem
->fState
& MF_HILITE
) flags
|= DFCS_PUSHED
;
821 DrawFrameControl( hdc
, &r
, DFC_CAPTION
, flags
);
825 if (!bmp
|| !GetObjectW( bmp
, sizeof(bm
), &bm
)) return;
828 hdcMem
= CreateCompatibleDC( hdc
);
829 SelectObject( hdcMem
, bmp
);
831 /* handle fontsize > bitmap_height */
832 top
= (h
>bm
.bmHeight
) ? rect
->top
+(h
-bm
.bmHeight
)/2 : rect
->top
;
834 rop
=((lpitem
->fState
& MF_HILITE
) && !IS_MAGIC_ITEM(lpitem
->text
)) ? NOTSRCCOPY
: SRCCOPY
;
835 if ((lpitem
->fState
& MF_HILITE
) && IS_BITMAP_ITEM(lpitem
->fType
))
836 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
837 BitBlt( hdc
, left
, top
, w
, h
, hdcMem
, bmp_xoffset
, 0, rop
);
842 /***********************************************************************
845 * Calculate the size of the menu item and store it in lpitem->rect.
847 static void MENU_CalcItemSize( HDC hdc
, MENUITEM
*lpitem
, HWND hwndOwner
,
848 INT orgX
, INT orgY
, BOOL menuBar
)
851 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
853 TRACE("dc=%p owner=%p (%d,%d)\n", hdc
, hwndOwner
, orgX
, orgY
);
854 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem
,
855 (menuBar
? " (MenuBar)" : ""));
857 SetRect( &lpitem
->rect
, orgX
, orgY
, orgX
, orgY
);
859 if (lpitem
->fType
& MF_OWNERDRAW
)
862 ** Experimentation under Windows reveals that an owner-drawn
863 ** menu is expected to return the size of the content part of
864 ** the menu item, not including the checkmark nor the submenu
865 ** arrow. Windows adds those values itself and returns the
866 ** enlarged rectangle on subsequent WM_DRAWITEM messages.
868 MEASUREITEMSTRUCT mis
;
869 mis
.CtlType
= ODT_MENU
;
871 mis
.itemID
= lpitem
->wID
;
872 mis
.itemData
= (DWORD
)lpitem
->dwItemData
;
875 SendMessageW( hwndOwner
, WM_MEASUREITEM
, 0, (LPARAM
)&mis
);
876 lpitem
->rect
.right
+= mis
.itemWidth
;
880 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
883 /* under at least win95 you seem to be given a standard
884 height for the menu and the height value is ignored */
885 lpitem
->rect
.bottom
+= GetSystemMetrics(SM_CYMENU
)-1;
888 lpitem
->rect
.bottom
+= mis
.itemHeight
;
890 TRACE("id=%04x size=%dx%d\n",
891 lpitem
->wID
, mis
.itemWidth
, mis
.itemHeight
);
892 /* Fall through to get check/arrow width calculation. */
895 if (lpitem
->fType
& MF_SEPARATOR
)
897 lpitem
->rect
.bottom
+= SEPARATOR_HEIGHT
;
903 lpitem
->rect
.right
+= 2 * check_bitmap_width
;
904 if (lpitem
->fType
& MF_POPUP
)
905 lpitem
->rect
.right
+= arrow_bitmap_width
;
908 if (lpitem
->fType
& MF_OWNERDRAW
)
911 if (IS_BITMAP_ITEM(lpitem
->fType
))
915 MENU_GetBitmapItemSize( (int)lpitem
->text
, lpitem
->dwItemData
, &size
);
916 lpitem
->rect
.right
+= size
.cx
;
917 lpitem
->rect
.bottom
+= size
.cy
;
918 /* Leave space for the sunken border */
919 lpitem
->rect
.right
+= 2;
920 lpitem
->rect
.bottom
+= 2;
924 /* it must be a text item - unless it's the system menu */
925 if (!(lpitem
->fType
& MF_SYSMENU
) && IS_STRING_ITEM( lpitem
->fType
))
928 GetTextExtentPoint32W(hdc
, lpitem
->text
, strlenW(lpitem
->text
), &size
);
930 lpitem
->rect
.right
+= size
.cx
;
931 lpitem
->rect
.bottom
+= max(size
.cy
, GetSystemMetrics(SM_CYMENU
)-1);
936 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
938 else if ((p
= strchrW( lpitem
->text
, '\t' )) != NULL
)
940 /* Item contains a tab (only meaningful in popup menus) */
941 GetTextExtentPoint32W(hdc
, lpitem
->text
, (int)(p
- lpitem
->text
) , &size
);
942 lpitem
->xTab
= check_bitmap_width
+ MENU_TAB_SPACE
+ size
.cx
;
943 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
947 if (strchrW( lpitem
->text
, '\b' ))
948 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
949 lpitem
->xTab
= lpitem
->rect
.right
- check_bitmap_width
950 - arrow_bitmap_width
;
953 TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem
->rect
.left
, lpitem
->rect
.top
, lpitem
->rect
.right
, lpitem
->rect
.bottom
);
957 /***********************************************************************
958 * MENU_PopupMenuCalcSize
960 * Calculate the size of a popup menu.
962 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop
, HWND hwndOwner
)
967 int orgX
, orgY
, maxX
, maxTab
, maxTabWidth
;
969 lppop
->Width
= lppop
->Height
= 0;
970 if (lppop
->nItems
== 0) return;
973 SelectObject( hdc
, hMenuFont
);
978 while (start
< lppop
->nItems
)
980 lpitem
= &lppop
->items
[start
];
984 maxTab
= maxTabWidth
= 0;
986 /* Parse items until column break or end of menu */
987 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
990 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
992 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, FALSE
);
994 if (lpitem
->fType
& MF_MENUBARBREAK
) orgX
++;
995 maxX
= max( maxX
, lpitem
->rect
.right
);
996 orgY
= lpitem
->rect
.bottom
;
997 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
999 maxTab
= max( maxTab
, lpitem
->xTab
);
1000 maxTabWidth
= max(maxTabWidth
,lpitem
->rect
.right
-lpitem
->xTab
);
1004 /* Finish the column (set all items to the largest width found) */
1005 maxX
= max( maxX
, maxTab
+ maxTabWidth
);
1006 for (lpitem
= &lppop
->items
[start
]; start
< i
; start
++, lpitem
++)
1008 lpitem
->rect
.right
= maxX
;
1009 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
1010 lpitem
->xTab
= maxTab
;
1013 lppop
->Height
= max( lppop
->Height
, orgY
);
1016 lppop
->Width
= maxX
;
1018 /* space for 3d border */
1022 ReleaseDC( 0, hdc
);
1026 /***********************************************************************
1027 * MENU_MenuBarCalcSize
1029 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1030 * height is off by 1 pixel which causes lengthy window relocations when
1031 * active document window is maximized/restored.
1033 * Calculate the size of the menu bar.
1035 static void MENU_MenuBarCalcSize( HDC hdc
, LPRECT lprect
,
1036 LPPOPUPMENU lppop
, HWND hwndOwner
)
1039 int start
, i
, orgX
, orgY
, maxY
, helpPos
;
1041 if ((lprect
== NULL
) || (lppop
== NULL
)) return;
1042 if (lppop
->nItems
== 0) return;
1043 TRACE("left=%ld top=%ld right=%ld bottom=%ld\n",
1044 lprect
->left
, lprect
->top
, lprect
->right
, lprect
->bottom
);
1045 lppop
->Width
= lprect
->right
- lprect
->left
;
1047 maxY
= lprect
->top
+1;
1050 while (start
< lppop
->nItems
)
1052 lpitem
= &lppop
->items
[start
];
1053 orgX
= lprect
->left
;
1056 /* Parse items until line break or end of menu */
1057 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
1059 if ((helpPos
== -1) && (lpitem
->fType
& MF_RIGHTJUSTIFY
)) helpPos
= i
;
1061 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
1063 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1065 debug_print_menuitem (" item: ", lpitem
, "");
1066 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, TRUE
);
1068 if (lpitem
->rect
.right
> lprect
->right
)
1070 if (i
!= start
) break;
1071 else lpitem
->rect
.right
= lprect
->right
;
1073 maxY
= max( maxY
, lpitem
->rect
.bottom
);
1074 orgX
= lpitem
->rect
.right
;
1077 /* Finish the line (set all items to the largest height found) */
1078 while (start
< i
) lppop
->items
[start
++].rect
.bottom
= maxY
;
1081 lprect
->bottom
= maxY
;
1082 lppop
->Height
= lprect
->bottom
- lprect
->top
;
1084 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1085 /* the last item (if several lines, only move the last line) */
1086 lpitem
= &lppop
->items
[lppop
->nItems
-1];
1087 orgY
= lpitem
->rect
.top
;
1088 orgX
= lprect
->right
;
1089 for (i
= lppop
->nItems
- 1; i
>= helpPos
; i
--, lpitem
--) {
1090 if ( (helpPos
==-1) || (helpPos
>i
) )
1092 if (lpitem
->rect
.top
!= orgY
) break; /* Other line */
1093 if (lpitem
->rect
.right
>= orgX
) break; /* Too far right already */
1094 lpitem
->rect
.left
+= orgX
- lpitem
->rect
.right
;
1095 lpitem
->rect
.right
= orgX
;
1096 orgX
= lpitem
->rect
.left
;
1100 /***********************************************************************
1103 * Draw a single menu item.
1105 static void MENU_DrawMenuItem( HWND hwnd
, HMENU hmenu
, HWND hwndOwner
, HDC hdc
, MENUITEM
*lpitem
,
1106 UINT height
, BOOL menuBar
, UINT odaction
)
1110 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem
, "");
1112 if (lpitem
->fType
& MF_SYSMENU
)
1114 if( !IsIconic(hwnd
) )
1115 NC_DrawSysButton( hwnd
, hdc
, lpitem
->fState
& (MF_HILITE
| MF_MOUSESELECT
) );
1121 if (lpitem
->fState
& MF_HILITE
)
1124 SetTextColor(hdc
, GetSysColor(COLOR_MENUTEXT
));
1125 SetBkColor(hdc
, GetSysColor(COLOR_MENU
));
1127 if(lpitem
->fState
& MF_GRAYED
)
1128 SetTextColor(hdc
, GetSysColor(COLOR_GRAYTEXT
));
1130 SetTextColor(hdc
, GetSysColor(COLOR_HIGHLIGHTTEXT
));
1131 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1136 if (lpitem
->fState
& MF_GRAYED
)
1137 SetTextColor( hdc
, GetSysColor( COLOR_GRAYTEXT
) );
1139 SetTextColor( hdc
, GetSysColor( COLOR_MENUTEXT
) );
1140 SetBkColor( hdc
, GetSysColor( COLOR_MENU
) );
1143 if (lpitem
->fType
& MF_OWNERDRAW
)
1146 ** Experimentation under Windows reveals that an owner-drawn
1147 ** menu is given the rectangle which includes the space it requested
1148 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1149 ** and a popup-menu arrow. This is the value of lpitem->rect.
1150 ** Windows will leave all drawing to the application except for
1151 ** the popup-menu arrow. Windows always draws that itself, after
1152 ** the menu owner has finished drawing.
1156 dis
.CtlType
= ODT_MENU
;
1158 dis
.itemID
= lpitem
->wID
;
1159 dis
.itemData
= (DWORD
)lpitem
->dwItemData
;
1161 if (lpitem
->fState
& MF_CHECKED
) dis
.itemState
|= ODS_CHECKED
;
1162 if (lpitem
->fState
& MF_GRAYED
) dis
.itemState
|= ODS_GRAYED
|ODS_DISABLED
;
1163 if (lpitem
->fState
& MF_HILITE
) dis
.itemState
|= ODS_SELECTED
;
1164 dis
.itemAction
= odaction
; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1165 dis
.hwndItem
= (HWND
)hmenu
;
1167 dis
.rcItem
= lpitem
->rect
;
1168 TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
1169 "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", hwndOwner
,
1170 dis
.itemID
, dis
.itemState
, dis
.itemAction
, dis
.hwndItem
,
1171 dis
.hDC
, dis
.rcItem
.left
, dis
.rcItem
.top
, dis
.rcItem
.right
,
1173 SendMessageW( hwndOwner
, WM_DRAWITEM
, 0, (LPARAM
)&dis
);
1174 /* Fall through to draw popup-menu arrow */
1177 TRACE("rect={%ld,%ld,%ld,%ld}\n", lpitem
->rect
.left
, lpitem
->rect
.top
,
1178 lpitem
->rect
.right
,lpitem
->rect
.bottom
);
1180 if (menuBar
&& (lpitem
->fType
& MF_SEPARATOR
)) return;
1182 rect
= lpitem
->rect
;
1184 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1186 if (lpitem
->fState
& MF_HILITE
)
1189 DrawEdge(hdc
, &rect
, BDR_SUNKENOUTER
, BF_RECT
);
1191 FillRect(hdc
, &rect
, GetSysColorBrush(COLOR_HIGHLIGHT
));
1194 FillRect( hdc
, &rect
, GetSysColorBrush(COLOR_MENU
) );
1197 SetBkMode( hdc
, TRANSPARENT
);
1199 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1201 /* vertical separator */
1202 if (!menuBar
&& (lpitem
->fType
& MF_MENUBARBREAK
))
1206 rc
.bottom
= height
- 3;
1207 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_LEFT
);
1210 /* horizontal separator */
1211 if (lpitem
->fType
& MF_SEPARATOR
)
1216 rc
.top
+= SEPARATOR_HEIGHT
/ 2;
1217 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_TOP
);
1222 /* helper lines for debugging */
1223 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1224 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1225 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1226 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1231 INT y
= rect
.top
+ rect
.bottom
;
1232 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
1233 UINT check_bitmap_height
= GetSystemMetrics( SM_CYMENUCHECK
);
1235 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1237 /* Draw the check mark
1240 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1242 HBITMAP bm
= (lpitem
->fState
& MF_CHECKED
) ? lpitem
->hCheckBit
: lpitem
->hUnCheckBit
;
1243 if (bm
) /* we have a custom bitmap */
1245 HDC hdcMem
= CreateCompatibleDC( hdc
);
1246 SelectObject( hdcMem
, bm
);
1247 BitBlt( hdc
, rect
.left
, (y
- check_bitmap_height
) / 2,
1248 check_bitmap_width
, check_bitmap_height
,
1249 hdcMem
, 0, 0, SRCCOPY
);
1252 else if (lpitem
->fState
& MF_CHECKED
) /* standard bitmaps */
1255 HBITMAP bm
= CreateBitmap( check_bitmap_width
, check_bitmap_height
, 1, 1, NULL
);
1256 HDC hdcMem
= CreateCompatibleDC( hdc
);
1257 SelectObject( hdcMem
, bm
);
1258 SetRect( &r
, 0, 0, check_bitmap_width
, check_bitmap_height
);
1259 DrawFrameControl( hdcMem
, &r
, DFC_MENU
,
1260 (lpitem
->fType
& MFT_RADIOCHECK
) ?
1261 DFCS_MENUBULLET
: DFCS_MENUCHECK
);
1262 BitBlt( hdc
, rect
.left
, (y
- r
.bottom
) / 2, r
.right
, r
.bottom
,
1263 hdcMem
, 0, 0, SRCCOPY
);
1269 /* Draw the popup-menu arrow */
1270 if (lpitem
->fType
& MF_POPUP
)
1272 HDC hdcMem
= CreateCompatibleDC( hdc
);
1273 HBITMAP hOrigBitmap
;
1275 hOrigBitmap
= SelectObject( hdcMem
, hStdMnArrow
);
1276 BitBlt( hdc
, rect
.right
- arrow_bitmap_width
- 1,
1277 (y
- arrow_bitmap_height
) / 2,
1278 arrow_bitmap_width
, arrow_bitmap_height
,
1279 hdcMem
, 0, 0, SRCCOPY
);
1280 SelectObject( hdcMem
, hOrigBitmap
);
1284 rect
.left
+= check_bitmap_width
;
1285 rect
.right
-= arrow_bitmap_width
;
1288 /* Done for owner-drawn */
1289 if (lpitem
->fType
& MF_OWNERDRAW
)
1292 /* Draw the item text or bitmap */
1293 if (IS_BITMAP_ITEM(lpitem
->fType
))
1295 MENU_DrawBitmapItem( hdc
, lpitem
, &rect
, menuBar
);
1299 /* No bitmap - process text if present */
1300 else if (IS_STRING_ITEM(lpitem
->fType
))
1305 UINT uFormat
= (menuBar
) ?
1306 DT_CENTER
| DT_VCENTER
| DT_SINGLELINE
:
1307 DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1309 if ( lpitem
->fState
& MFS_DEFAULT
)
1311 hfontOld
= SelectObject( hdc
, hMenuFontBold
);
1316 rect
.left
+= MENU_BAR_ITEMS_SPACE
/ 2;
1317 rect
.right
-= MENU_BAR_ITEMS_SPACE
/ 2;
1320 for (i
= 0; lpitem
->text
[i
]; i
++)
1321 if ((lpitem
->text
[i
] == '\t') || (lpitem
->text
[i
] == '\b'))
1324 if(lpitem
->fState
& MF_GRAYED
)
1326 if (!(lpitem
->fState
& MF_HILITE
) )
1328 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1329 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1330 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1331 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1333 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1336 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1338 /* paint the shortcut text */
1339 if (!menuBar
&& lpitem
->text
[i
]) /* There's a tab or flush-right char */
1341 if (lpitem
->text
[i
] == '\t')
1343 rect
.left
= lpitem
->xTab
;
1344 uFormat
= DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1348 uFormat
= DT_RIGHT
| DT_VCENTER
| DT_SINGLELINE
;
1351 if(lpitem
->fState
& MF_GRAYED
)
1353 if (!(lpitem
->fState
& MF_HILITE
) )
1355 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1356 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1357 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1358 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1360 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1362 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1366 SelectObject (hdc
, hfontOld
);
1371 /***********************************************************************
1372 * MENU_DrawPopupMenu
1374 * Paint a popup menu.
1376 static void MENU_DrawPopupMenu( HWND hwnd
, HDC hdc
, HMENU hmenu
)
1378 HBRUSH hPrevBrush
= 0;
1381 TRACE("wnd=%p dc=%p menu=%p\n", hwnd
, hdc
, hmenu
);
1383 GetClientRect( hwnd
, &rect
);
1385 if((hPrevBrush
= SelectObject( hdc
, GetSysColorBrush(COLOR_MENU
) ))
1386 && (SelectObject( hdc
, hMenuFont
)))
1390 Rectangle( hdc
, rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
1392 hPrevPen
= SelectObject( hdc
, GetStockObject( NULL_PEN
) );
1397 DrawEdge (hdc
, &rect
, EDGE_RAISED
, BF_RECT
);
1399 /* draw menu items */
1401 menu
= MENU_GetMenu( hmenu
);
1402 if (menu
&& menu
->nItems
)
1407 for (u
= menu
->nItems
, item
= menu
->items
; u
> 0; u
--, item
++)
1408 MENU_DrawMenuItem( hwnd
, hmenu
, menu
->hwndOwner
, hdc
, item
,
1409 menu
->Height
, FALSE
, ODA_DRAWENTIRE
);
1414 SelectObject( hdc
, hPrevBrush
);
1419 /***********************************************************************
1422 * Paint a menu bar. Returns the height of the menu bar.
1423 * called from [windows/nonclient.c]
1425 UINT
MENU_DrawMenuBar( HDC hDC
, LPRECT lprect
, HWND hwnd
,
1430 HMENU hMenu
= GetMenu(hwnd
);
1432 lppop
= MENU_GetMenu( hMenu
);
1433 if (lppop
== NULL
|| lprect
== NULL
)
1435 return GetSystemMetrics(SM_CYMENU
);
1440 hfontOld
= SelectObject( hDC
, hMenuFont
);
1442 if (lppop
->Height
== 0)
1443 MENU_MenuBarCalcSize(hDC
, lprect
, lppop
, hwnd
);
1445 lprect
->bottom
= lprect
->top
+ lppop
->Height
;
1447 if (hfontOld
) SelectObject( hDC
, hfontOld
);
1448 return lppop
->Height
;
1451 return DrawMenuBarTemp(hwnd
, hDC
, lprect
, hMenu
, NULL
);
1455 /***********************************************************************
1458 * Display a popup menu.
1460 static BOOL
MENU_ShowPopup( HWND hwndOwner
, HMENU hmenu
, UINT id
,
1461 INT x
, INT y
, INT xanchor
, INT yanchor
)
1466 TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1467 hwndOwner
, hmenu
, id
, x
, y
, xanchor
, yanchor
);
1469 if (!(menu
= MENU_GetMenu( hmenu
))) return FALSE
;
1470 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1472 menu
->items
[menu
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1473 menu
->FocusedItem
= NO_SELECTED_ITEM
;
1476 /* store the owner for DrawItem */
1477 menu
->hwndOwner
= hwndOwner
;
1480 MENU_PopupMenuCalcSize( menu
, hwndOwner
);
1482 /* adjust popup menu pos so that it fits within the desktop */
1484 width
= menu
->Width
+ GetSystemMetrics(SM_CXBORDER
);
1485 height
= menu
->Height
+ GetSystemMetrics(SM_CYBORDER
);
1487 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1490 x
-= width
- xanchor
;
1491 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1492 x
= GetSystemMetrics(SM_CXSCREEN
) - width
;
1496 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1499 y
-= height
+ yanchor
;
1500 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1501 y
= GetSystemMetrics(SM_CYSCREEN
) - height
;
1505 /* NOTE: In Windows, top menu popup is not owned. */
1506 menu
->hWnd
= CreateWindowExW( 0, POPUPMENU_CLASS_ATOMW
, NULL
,
1507 WS_POPUP
, x
, y
, width
, height
,
1508 hwndOwner
, 0, (HINSTANCE
)GetWindowLongPtrW(hwndOwner
, GWLP_HINSTANCE
),
1510 if( !menu
->hWnd
) return FALSE
;
1511 if (!top_popup
) top_popup
= menu
->hWnd
;
1513 /* Display the window */
1515 SetWindowPos( menu
->hWnd
, HWND_TOP
, 0, 0, 0, 0,
1516 SWP_SHOWWINDOW
| SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
1517 UpdateWindow( menu
->hWnd
);
1522 /***********************************************************************
1525 static void MENU_SelectItem( HWND hwndOwner
, HMENU hmenu
, UINT wIndex
,
1526 BOOL sendMenuSelect
, HMENU topmenu
)
1531 TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner
, hmenu
, wIndex
, sendMenuSelect
);
1533 lppop
= MENU_GetMenu( hmenu
);
1534 if ((!lppop
) || (!lppop
->nItems
) || (!lppop
->hWnd
)) return;
1536 if (lppop
->FocusedItem
== wIndex
) return;
1537 if (lppop
->wFlags
& MF_POPUP
) hdc
= GetDC( lppop
->hWnd
);
1538 else hdc
= GetDCEx( lppop
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1539 if (!top_popup
) top_popup
= lppop
->hWnd
;
1541 SelectObject( hdc
, hMenuFont
);
1543 /* Clear previous highlighted item */
1544 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1546 lppop
->items
[lppop
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1547 MENU_DrawMenuItem(lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,&lppop
->items
[lppop
->FocusedItem
],
1548 lppop
->Height
, !(lppop
->wFlags
& MF_POPUP
),
1552 /* Highlight new item (if any) */
1553 lppop
->FocusedItem
= wIndex
;
1554 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1556 if(!(lppop
->items
[wIndex
].fType
& MF_SEPARATOR
)) {
1557 lppop
->items
[wIndex
].fState
|= MF_HILITE
;
1558 MENU_DrawMenuItem( lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,
1559 &lppop
->items
[wIndex
], lppop
->Height
,
1560 !(lppop
->wFlags
& MF_POPUP
), ODA_SELECT
);
1564 MENUITEM
*ip
= &lppop
->items
[lppop
->FocusedItem
];
1565 SendMessageW( hwndOwner
, WM_MENUSELECT
,
1566 MAKELONG(ip
->fType
& MF_POPUP
? wIndex
: ip
->wID
,
1567 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1568 (lppop
->wFlags
& MF_SYSMENU
)), (LPARAM
)hmenu
);
1571 else if (sendMenuSelect
) {
1574 if((pos
=MENU_FindSubMenu(&topmenu
, hmenu
))!=NO_SELECTED_ITEM
){
1575 POPUPMENU
*ptm
= MENU_GetMenu( topmenu
);
1576 MENUITEM
*ip
= &ptm
->items
[pos
];
1577 SendMessageW( hwndOwner
, WM_MENUSELECT
, MAKELONG(pos
,
1578 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1579 (ptm
->wFlags
& MF_SYSMENU
)), (LPARAM
)topmenu
);
1583 ReleaseDC( lppop
->hWnd
, hdc
);
1587 /***********************************************************************
1588 * MENU_MoveSelection
1590 * Moves currently selected item according to the offset parameter.
1591 * If there is no selection then it should select the last item if
1592 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1594 static void MENU_MoveSelection( HWND hwndOwner
, HMENU hmenu
, INT offset
)
1599 TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner
, hmenu
, offset
);
1601 menu
= MENU_GetMenu( hmenu
);
1602 if ((!menu
) || (!menu
->items
)) return;
1604 if ( menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1606 if( menu
->nItems
== 1 ) return; else
1607 for (i
= menu
->FocusedItem
+ offset
; i
>= 0 && i
< menu
->nItems
1609 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1611 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1616 for ( i
= (offset
> 0) ? 0 : menu
->nItems
- 1;
1617 i
>= 0 && i
< menu
->nItems
; i
+= offset
)
1618 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1620 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1626 /**********************************************************************
1629 * Set an item's flags, id and text ptr. Called by InsertMenu() and
1632 static BOOL
MENU_SetItemData( MENUITEM
*item
, UINT flags
, UINT_PTR id
,
1635 LPWSTR prevText
= IS_STRING_ITEM(item
->fType
) ? item
->text
: NULL
;
1637 debug_print_menuitem("MENU_SetItemData from: ", item
, "");
1638 TRACE("flags=%x str=%p\n", flags
, str
);
1640 if (IS_STRING_ITEM(flags
))
1644 flags
|= MF_SEPARATOR
;
1650 /* Item beginning with a backspace is a help item */
1656 if (!(text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(str
)+1) * sizeof(WCHAR
) )))
1658 strcpyW( text
, str
);
1662 else if (IS_BITMAP_ITEM(flags
))
1663 item
->text
= (LPWSTR
)HBITMAP_32(LOWORD(str
));
1664 else item
->text
= NULL
;
1666 if (flags
& MF_OWNERDRAW
)
1667 item
->dwItemData
= (DWORD
)str
;
1669 item
->dwItemData
= 0;
1671 if ((item
->fType
& MF_POPUP
) && (flags
& MF_POPUP
) && (item
->hSubMenu
!= (HMENU
)id
) )
1672 DestroyMenu( item
->hSubMenu
); /* ModifyMenu() spec */
1674 if (flags
& MF_POPUP
)
1676 POPUPMENU
*menu
= MENU_GetMenu((HMENU
)id
);
1677 if (menu
) menu
->wFlags
|= MF_POPUP
;
1689 if (flags
& MF_POPUP
) item
->hSubMenu
= (HMENU
)id
;
1691 if ((item
->fType
& MF_POPUP
) && !(flags
& MF_POPUP
) )
1692 flags
|= MF_POPUP
; /* keep popup */
1694 item
->fType
= flags
& TYPE_MASK
;
1695 item
->fState
= (flags
& STATE_MASK
) &
1696 ~(MF_HILITE
| MF_MOUSESELECT
| MF_BYPOSITION
);
1699 /* Don't call SetRectEmpty here! */
1702 if (prevText
) HeapFree( GetProcessHeap(), 0, prevText
);
1704 debug_print_menuitem("MENU_SetItemData to : ", item
, "");
1709 /**********************************************************************
1712 * Insert (allocate) a new item into a menu.
1714 static MENUITEM
*MENU_InsertItem( HMENU hMenu
, UINT pos
, UINT flags
)
1719 if (!(menu
= MENU_GetMenu(hMenu
)))
1722 /* Find where to insert new item */
1724 if (flags
& MF_BYPOSITION
) {
1725 if (pos
> menu
->nItems
)
1728 if (!MENU_FindItem( &hMenu
, &pos
, flags
))
1731 if (!(menu
= MENU_GetMenu( hMenu
)))
1736 /* Create new items array */
1738 newItems
= HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM
) * (menu
->nItems
+1) );
1741 WARN("allocation failed\n" );
1744 if (menu
->nItems
> 0)
1746 /* Copy the old array into the new one */
1747 if (pos
> 0) memcpy( newItems
, menu
->items
, pos
* sizeof(MENUITEM
) );
1748 if (pos
< menu
->nItems
) memcpy( &newItems
[pos
+1], &menu
->items
[pos
],
1749 (menu
->nItems
-pos
)*sizeof(MENUITEM
) );
1750 HeapFree( GetProcessHeap(), 0, menu
->items
);
1752 menu
->items
= newItems
;
1754 memset( &newItems
[pos
], 0, sizeof(*newItems
) );
1755 menu
->Height
= 0; /* force size recalculate */
1756 return &newItems
[pos
];
1760 /**********************************************************************
1761 * MENU_ParseResource
1763 * Parse a standard menu resource and add items to the menu.
1764 * Return a pointer to the end of the resource.
1766 * NOTE: flags is equivalent to the mtOption field
1768 static LPCSTR
MENU_ParseResource( LPCSTR res
, HMENU hMenu
, BOOL unicode
)
1775 flags
= GET_WORD(res
);
1776 res
+= sizeof(WORD
);
1777 if (!(flags
& MF_POPUP
))
1780 res
+= sizeof(WORD
);
1783 if (!unicode
) res
+= strlen(str
) + 1;
1784 else res
+= (strlenW((LPCWSTR
)str
) + 1) * sizeof(WCHAR
);
1785 if (flags
& MF_POPUP
)
1787 HMENU hSubMenu
= CreatePopupMenu();
1788 if (!hSubMenu
) return NULL
;
1789 if (!(res
= MENU_ParseResource( res
, hSubMenu
, unicode
)))
1791 if (!unicode
) AppendMenuA( hMenu
, flags
, (UINT
)hSubMenu
, str
);
1792 else AppendMenuW( hMenu
, flags
, (UINT
)hSubMenu
, (LPCWSTR
)str
);
1794 else /* Not a popup */
1796 if (!unicode
) AppendMenuA( hMenu
, flags
, id
, *str
? str
: NULL
);
1797 else AppendMenuW( hMenu
, flags
, id
,
1798 *(LPCWSTR
)str
? (LPCWSTR
)str
: NULL
);
1800 } while (!(flags
& MF_END
));
1805 /**********************************************************************
1806 * MENUEX_ParseResource
1808 * Parse an extended menu resource and add items to the menu.
1809 * Return a pointer to the end of the resource.
1811 static LPCSTR
MENUEX_ParseResource( LPCSTR res
, HMENU hMenu
)
1817 mii
.cbSize
= sizeof(mii
);
1818 mii
.fMask
= MIIM_STATE
| MIIM_ID
| MIIM_TYPE
;
1819 mii
.fType
= GET_DWORD(res
);
1820 res
+= sizeof(DWORD
);
1821 mii
.fState
= GET_DWORD(res
);
1822 res
+= sizeof(DWORD
);
1823 mii
.wID
= GET_DWORD(res
);
1824 res
+= sizeof(DWORD
);
1825 resinfo
= GET_WORD(res
); /* FIXME: for 16-bit apps this is a byte. */
1826 res
+= sizeof(WORD
);
1827 /* Align the text on a word boundary. */
1828 res
+= (~((int)res
- 1)) & 1;
1829 mii
.dwTypeData
= (LPWSTR
) res
;
1830 res
+= (1 + strlenW(mii
.dwTypeData
)) * sizeof(WCHAR
);
1831 /* Align the following fields on a dword boundary. */
1832 res
+= (~((int)res
- 1)) & 3;
1834 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1835 mii
.fType
, mii
.fState
, mii
.wID
, resinfo
, debugstr_w(mii
.dwTypeData
));
1837 if (resinfo
& 1) { /* Pop-up? */
1838 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1839 res
+= sizeof(DWORD
);
1840 mii
.hSubMenu
= CreatePopupMenu();
1843 if (!(res
= MENUEX_ParseResource(res
, mii
.hSubMenu
))) {
1844 DestroyMenu(mii
.hSubMenu
);
1847 mii
.fMask
|= MIIM_SUBMENU
;
1848 mii
.fType
|= MF_POPUP
;
1850 else if(!*mii
.dwTypeData
&& !(mii
.fType
& MF_SEPARATOR
))
1852 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1853 mii
.wID
, mii
.fType
);
1854 mii
.fType
|= MF_SEPARATOR
;
1856 InsertMenuItemW(hMenu
, -1, MF_BYPOSITION
, &mii
);
1857 } while (!(resinfo
& MF_END
));
1862 /***********************************************************************
1865 * Return the handle of the selected sub-popup menu (if any).
1867 static HMENU
MENU_GetSubPopup( HMENU hmenu
)
1872 menu
= MENU_GetMenu( hmenu
);
1874 if ((!menu
) || (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return 0;
1876 item
= &menu
->items
[menu
->FocusedItem
];
1877 if ((item
->fType
& MF_POPUP
) && (item
->fState
& MF_MOUSESELECT
))
1878 return item
->hSubMenu
;
1883 /***********************************************************************
1884 * MENU_HideSubPopups
1886 * Hide the sub-popup menus of this menu.
1888 static void MENU_HideSubPopups( HWND hwndOwner
, HMENU hmenu
,
1889 BOOL sendMenuSelect
)
1891 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
1893 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner
, hmenu
, sendMenuSelect
);
1895 if (menu
&& top_popup
)
1901 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1903 item
= &menu
->items
[menu
->FocusedItem
];
1904 if (!(item
->fType
& MF_POPUP
) ||
1905 !(item
->fState
& MF_MOUSESELECT
)) return;
1906 item
->fState
&= ~MF_MOUSESELECT
;
1907 hsubmenu
= item
->hSubMenu
;
1910 submenu
= MENU_GetMenu( hsubmenu
);
1911 MENU_HideSubPopups( hwndOwner
, hsubmenu
, FALSE
);
1912 MENU_SelectItem( hwndOwner
, hsubmenu
, NO_SELECTED_ITEM
, sendMenuSelect
, 0 );
1913 DestroyWindow( submenu
->hWnd
);
1919 /***********************************************************************
1922 * Display the sub-menu of the selected item of this menu.
1923 * Return the handle of the submenu, or hmenu if no submenu to display.
1925 static HMENU
MENU_ShowSubPopup( HWND hwndOwner
, HMENU hmenu
,
1926 BOOL selectFirst
, UINT wFlags
)
1933 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner
, hmenu
, selectFirst
);
1935 if (!(menu
= MENU_GetMenu( hmenu
))) return hmenu
;
1937 if (menu
->FocusedItem
== NO_SELECTED_ITEM
) return hmenu
;
1939 item
= &menu
->items
[menu
->FocusedItem
];
1940 if (!(item
->fType
& MF_POPUP
) || (item
->fState
& (MF_GRAYED
| MF_DISABLED
)))
1943 /* message must be sent before using item,
1944 because nearly everything may be changed by the application ! */
1946 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
1947 if (!(wFlags
& TPM_NONOTIFY
))
1948 SendMessageW( hwndOwner
, WM_INITMENUPOPUP
, (WPARAM
)item
->hSubMenu
,
1949 MAKELONG( menu
->FocusedItem
, IS_SYSTEM_MENU(menu
) ));
1951 item
= &menu
->items
[menu
->FocusedItem
];
1954 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
1955 if (!(item
->fState
& MF_HILITE
))
1957 if (menu
->wFlags
& MF_POPUP
) hdc
= GetDC( menu
->hWnd
);
1958 else hdc
= GetDCEx( menu
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1960 SelectObject( hdc
, hMenuFont
);
1962 item
->fState
|= MF_HILITE
;
1963 MENU_DrawMenuItem( menu
->hWnd
, hmenu
, hwndOwner
, hdc
, item
, menu
->Height
, !(menu
->wFlags
& MF_POPUP
), ODA_DRAWENTIRE
);
1964 ReleaseDC( menu
->hWnd
, hdc
);
1966 if (!item
->rect
.top
&& !item
->rect
.left
&& !item
->rect
.bottom
&& !item
->rect
.right
)
1969 item
->fState
|= MF_MOUSESELECT
;
1971 if (IS_SYSTEM_MENU(menu
))
1973 MENU_InitSysMenuPopup(item
->hSubMenu
,
1974 GetWindowLongW( menu
->hWnd
, GWL_STYLE
),
1975 GetClassLongW( menu
->hWnd
, GCL_STYLE
));
1977 NC_GetSysPopupPos( menu
->hWnd
, &rect
);
1978 rect
.top
= rect
.bottom
;
1979 rect
.right
= GetSystemMetrics(SM_CXSIZE
);
1980 rect
.bottom
= GetSystemMetrics(SM_CYSIZE
);
1984 GetWindowRect( menu
->hWnd
, &rect
);
1985 if (menu
->wFlags
& MF_POPUP
)
1987 rect
.left
+= item
->rect
.right
- GetSystemMetrics(SM_CXBORDER
);
1988 rect
.top
+= item
->rect
.top
;
1989 rect
.right
= item
->rect
.left
- item
->rect
.right
+ GetSystemMetrics(SM_CXBORDER
);
1990 rect
.bottom
= item
->rect
.top
- item
->rect
.bottom
;
1994 rect
.left
+= item
->rect
.left
;
1995 rect
.top
+= item
->rect
.bottom
;
1996 rect
.right
= item
->rect
.right
- item
->rect
.left
;
1997 rect
.bottom
= item
->rect
.bottom
- item
->rect
.top
;
2001 MENU_ShowPopup( hwndOwner
, item
->hSubMenu
, menu
->FocusedItem
,
2002 rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
2004 MENU_MoveSelection( hwndOwner
, item
->hSubMenu
, ITEM_NEXT
);
2005 return item
->hSubMenu
;
2010 /**********************************************************************
2013 BOOL
MENU_IsMenuActive(void)
2015 return (top_popup
!= 0);
2018 /***********************************************************************
2021 * Walks menu chain trying to find a menu pt maps to.
2023 static HMENU
MENU_PtMenu( HMENU hMenu
, POINT pt
)
2025 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2026 UINT item
= menu
->FocusedItem
;
2029 /* try subpopup first (if any) */
2030 ret
= (item
!= NO_SELECTED_ITEM
&&
2031 (menu
->items
[item
].fType
& MF_POPUP
) &&
2032 (menu
->items
[item
].fState
& MF_MOUSESELECT
))
2033 ? MENU_PtMenu(menu
->items
[item
].hSubMenu
, pt
) : 0;
2035 if (!ret
) /* check the current window (avoiding WM_HITTEST) */
2037 INT ht
= NC_HandleNCHitTest( menu
->hWnd
, pt
);
2038 if( menu
->wFlags
& MF_POPUP
)
2040 if (ht
!= HTNOWHERE
&& ht
!= HTERROR
) ret
= hMenu
;
2042 else if (ht
== HTSYSMENU
)
2043 ret
= get_win_sys_menu( menu
->hWnd
);
2044 else if (ht
== HTMENU
)
2045 ret
= GetMenu( menu
->hWnd
);
2050 /***********************************************************************
2051 * MENU_ExecFocusedItem
2053 * Execute a menu item (for instance when user pressed Enter).
2054 * Return the wID of the executed item. Otherwise, -1 indicating
2055 * that no menu item was executed;
2056 * Have to receive the flags for the TrackPopupMenu options to avoid
2057 * sending unwanted message.
2060 static INT
MENU_ExecFocusedItem( MTRACKER
* pmt
, HMENU hMenu
, UINT wFlags
)
2063 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2065 TRACE("%p hmenu=%p\n", pmt
, hMenu
);
2067 if (!menu
|| !menu
->nItems
||
2068 (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return -1;
2070 item
= &menu
->items
[menu
->FocusedItem
];
2072 TRACE("%p %08x %p\n", hMenu
, item
->wID
, item
->hSubMenu
);
2074 if (!(item
->fType
& MF_POPUP
))
2076 if (!(item
->fState
& (MF_GRAYED
| MF_DISABLED
)) && !(item
->fType
& MF_SEPARATOR
))
2078 /* If TPM_RETURNCMD is set you return the id, but
2079 do not send a message to the owner */
2080 if(!(wFlags
& TPM_RETURNCMD
))
2082 if( menu
->wFlags
& MF_SYSMENU
)
2083 PostMessageW( pmt
->hOwnerWnd
, WM_SYSCOMMAND
, item
->wID
,
2084 MAKELPARAM((INT16
)pmt
->pt
.x
, (INT16
)pmt
->pt
.y
) );
2086 PostMessageW( pmt
->hOwnerWnd
, WM_COMMAND
, item
->wID
, 0 );
2092 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hMenu
, TRUE
, wFlags
);
2097 /***********************************************************************
2098 * MENU_SwitchTracking
2100 * Helper function for menu navigation routines.
2102 static void MENU_SwitchTracking( MTRACKER
* pmt
, HMENU hPtMenu
, UINT id
)
2104 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2105 POPUPMENU
*topmenu
= MENU_GetMenu( pmt
->hTopMenu
);
2107 TRACE("%p hmenu=%p 0x%04x\n", pmt
, hPtMenu
, id
);
2109 if( pmt
->hTopMenu
!= hPtMenu
&&
2110 !((ptmenu
->wFlags
| topmenu
->wFlags
) & MF_POPUP
) )
2112 /* both are top level menus (system and menu-bar) */
2113 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2114 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2115 pmt
->hTopMenu
= hPtMenu
;
2117 else MENU_HideSubPopups( pmt
->hOwnerWnd
, hPtMenu
, FALSE
);
2118 MENU_SelectItem( pmt
->hOwnerWnd
, hPtMenu
, id
, TRUE
, 0 );
2122 /***********************************************************************
2125 * Return TRUE if we can go on with menu tracking.
2127 static BOOL
MENU_ButtonDown( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2129 TRACE("%p hPtMenu=%p\n", pmt
, hPtMenu
);
2134 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2137 if( IS_SYSTEM_MENU(ptmenu
) )
2138 item
= ptmenu
->items
;
2140 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2144 if( ptmenu
->FocusedItem
!= id
)
2145 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2147 /* If the popup menu is not already "popped" */
2148 if(!(item
->fState
& MF_MOUSESELECT
))
2150 pmt
->hCurrentMenu
= MENU_ShowSubPopup( pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2155 /* Else the click was on the menu bar, finish the tracking */
2160 /***********************************************************************
2163 * Return the value of MENU_ExecFocusedItem if
2164 * the selected item was not a popup. Else open the popup.
2165 * A -1 return value indicates that we go on with menu tracking.
2168 static INT
MENU_ButtonUp( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2170 TRACE("%p hmenu=%p\n", pmt
, hPtMenu
);
2175 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2178 if( IS_SYSTEM_MENU(ptmenu
) )
2179 item
= ptmenu
->items
;
2181 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2183 if( item
&& (ptmenu
->FocusedItem
== id
))
2185 if( !(item
->fType
& MF_POPUP
) )
2186 return MENU_ExecFocusedItem( pmt
, hPtMenu
, wFlags
);
2188 /* If we are dealing with the top-level menu */
2189 /* and this is a click on an already "popped" item: */
2190 /* Stop the menu tracking and close the opened submenus */
2191 if((pmt
->hTopMenu
== hPtMenu
) && (ptmenu
->bTimeToHide
== TRUE
))
2194 ptmenu
->bTimeToHide
= TRUE
;
2200 /***********************************************************************
2203 * Return TRUE if we can go on with menu tracking.
2205 static BOOL
MENU_MouseMove( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2207 UINT id
= NO_SELECTED_ITEM
;
2208 POPUPMENU
*ptmenu
= NULL
;
2212 ptmenu
= MENU_GetMenu( hPtMenu
);
2213 if( IS_SYSTEM_MENU(ptmenu
) )
2216 MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2219 if( id
== NO_SELECTED_ITEM
)
2221 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2222 NO_SELECTED_ITEM
, TRUE
, pmt
->hTopMenu
);
2225 else if( ptmenu
->FocusedItem
!= id
)
2227 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2228 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2234 /***********************************************************************
2237 static void MENU_SetCapture( HWND hwnd
)
2241 SERVER_START_REQ( set_capture_window
)
2244 req
->flags
= CAPTURE_MENU
;
2245 if (!wine_server_call_err( req
))
2247 previous
= reply
->previous
;
2248 hwnd
= reply
->full_handle
;
2253 if (previous
&& previous
!= hwnd
)
2254 SendMessageW( previous
, WM_CAPTURECHANGED
, 0, (LPARAM
)hwnd
);
2258 /***********************************************************************
2261 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2263 static LRESULT
MENU_DoNextMenu( MTRACKER
* pmt
, UINT vk
)
2265 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2267 if( (vk
== VK_LEFT
&& menu
->FocusedItem
== 0 ) ||
2268 (vk
== VK_RIGHT
&& menu
->FocusedItem
== menu
->nItems
- 1))
2270 MDINEXTMENU next_menu
;
2275 next_menu
.hmenuIn
= (IS_SYSTEM_MENU(menu
)) ? GetSubMenu(pmt
->hTopMenu
,0) : pmt
->hTopMenu
;
2276 next_menu
.hmenuNext
= 0;
2277 next_menu
.hwndNext
= 0;
2278 SendMessageW( pmt
->hOwnerWnd
, WM_NEXTMENU
, vk
, (LPARAM
)&next_menu
);
2280 TRACE("%p [%p] -> %p [%p]\n",
2281 pmt
->hCurrentMenu
, pmt
->hOwnerWnd
, next_menu
.hmenuNext
, next_menu
.hwndNext
);
2283 if (!next_menu
.hmenuNext
|| !next_menu
.hwndNext
)
2285 DWORD style
= GetWindowLongW( pmt
->hOwnerWnd
, GWL_STYLE
);
2286 hNewWnd
= pmt
->hOwnerWnd
;
2287 if( IS_SYSTEM_MENU(menu
) )
2289 /* switch to the menu bar */
2291 if(style
& WS_CHILD
|| !(hNewMenu
= GetMenu(hNewWnd
))) return FALSE
;
2295 menu
= MENU_GetMenu( hNewMenu
);
2296 id
= menu
->nItems
- 1;
2299 else if (style
& WS_SYSMENU
)
2301 /* switch to the system menu */
2302 hNewMenu
= get_win_sys_menu( hNewWnd
);
2306 else /* application returned a new menu to switch to */
2308 hNewMenu
= next_menu
.hmenuNext
;
2309 hNewWnd
= WIN_GetFullHandle( next_menu
.hwndNext
);
2311 if( IsMenu(hNewMenu
) && IsWindow(hNewWnd
) )
2313 DWORD style
= GetWindowLongW( hNewWnd
, GWL_STYLE
);
2315 if (style
& WS_SYSMENU
&&
2316 GetSubMenu(get_win_sys_menu(hNewWnd
), 0) == hNewMenu
)
2318 /* get the real system menu */
2319 hNewMenu
= get_win_sys_menu(hNewWnd
);
2321 else if (style
& WS_CHILD
|| GetMenu(hNewWnd
) != hNewMenu
)
2323 /* FIXME: Not sure what to do here;
2324 * perhaps try to track hNewMenu as a popup? */
2326 TRACE(" -- got confused.\n");
2333 if( hNewMenu
!= pmt
->hTopMenu
)
2335 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
,
2337 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2338 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2341 if( hNewWnd
!= pmt
->hOwnerWnd
)
2343 pmt
->hOwnerWnd
= hNewWnd
;
2344 MENU_SetCapture( pmt
->hOwnerWnd
);
2347 pmt
->hTopMenu
= pmt
->hCurrentMenu
= hNewMenu
; /* all subpopups are hidden */
2348 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, id
, TRUE
, 0 );
2355 /***********************************************************************
2358 * The idea is not to show the popup if the next input message is
2359 * going to hide it anyway.
2361 static BOOL
MENU_SuspendPopup( MTRACKER
* pmt
, UINT16 uMsg
)
2365 msg
.hwnd
= pmt
->hOwnerWnd
;
2367 PeekMessageW( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2368 pmt
->trackFlags
|= TF_SKIPREMOVE
;
2373 PeekMessageW( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2374 if( msg
.message
== WM_KEYUP
|| msg
.message
== WM_PAINT
)
2376 PeekMessageW( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2377 PeekMessageW( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2378 if( msg
.message
== WM_KEYDOWN
&&
2379 (msg
.wParam
== VK_LEFT
|| msg
.wParam
== VK_RIGHT
))
2381 pmt
->trackFlags
|= TF_SUSPENDPOPUP
;
2388 /* failures go through this */
2389 pmt
->trackFlags
&= ~TF_SUSPENDPOPUP
;
2393 /***********************************************************************
2396 * Handle a VK_ESCAPE key event in a menu.
2398 static BOOL
MENU_KeyEscape(MTRACKER
* pmt
, UINT wFlags
)
2400 BOOL bEndMenu
= TRUE
;
2402 if (pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2404 POPUPMENU
*menu
= MENU_GetMenu(pmt
->hCurrentMenu
);
2406 if (menu
->wFlags
& MF_POPUP
)
2408 HMENU hmenutmp
, hmenuprev
;
2410 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2412 /* close topmost popup */
2413 while (hmenutmp
!= pmt
->hCurrentMenu
)
2415 hmenuprev
= hmenutmp
;
2416 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2419 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2420 pmt
->hCurrentMenu
= hmenuprev
;
2428 /***********************************************************************
2431 * Handle a VK_LEFT key event in a menu.
2433 static void MENU_KeyLeft( MTRACKER
* pmt
, UINT wFlags
)
2436 HMENU hmenutmp
, hmenuprev
;
2439 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2440 menu
= MENU_GetMenu( hmenutmp
);
2442 /* Try to move 1 column left (if possible) */
2443 if( (prevcol
= MENU_GetStartOfPrevColumn( pmt
->hCurrentMenu
)) !=
2444 NO_SELECTED_ITEM
) {
2446 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2451 /* close topmost popup */
2452 while (hmenutmp
!= pmt
->hCurrentMenu
)
2454 hmenuprev
= hmenutmp
;
2455 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2458 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2459 pmt
->hCurrentMenu
= hmenuprev
;
2461 if ( (hmenuprev
== pmt
->hTopMenu
) && !(menu
->wFlags
& MF_POPUP
) )
2463 /* move menu bar selection if no more popups are left */
2465 if( !MENU_DoNextMenu( pmt
, VK_LEFT
) )
2466 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_PREV
);
2468 if ( hmenuprev
!= hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2470 /* A sublevel menu was displayed - display the next one
2471 * unless there is another displacement coming up */
2473 if( !MENU_SuspendPopup( pmt
, WM_KEYDOWN
) )
2474 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2475 pmt
->hTopMenu
, TRUE
, wFlags
);
2481 /***********************************************************************
2484 * Handle a VK_RIGHT key event in a menu.
2486 static void MENU_KeyRight( MTRACKER
* pmt
, UINT wFlags
)
2489 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2492 TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2494 debugstr_w((MENU_GetMenu(pmt
->hCurrentMenu
))->items
[0].text
),
2495 pmt
->hTopMenu
, debugstr_w(menu
->items
[0].text
) );
2497 if ( (menu
->wFlags
& MF_POPUP
) || (pmt
->hCurrentMenu
!= pmt
->hTopMenu
))
2499 /* If already displaying a popup, try to display sub-popup */
2501 hmenutmp
= pmt
->hCurrentMenu
;
2502 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hmenutmp
, TRUE
, wFlags
);
2504 /* if subpopup was displayed then we are done */
2505 if (hmenutmp
!= pmt
->hCurrentMenu
) return;
2508 /* Check to see if there's another column */
2509 if( (nextcol
= MENU_GetStartOfNextColumn( pmt
->hCurrentMenu
)) !=
2510 NO_SELECTED_ITEM
) {
2511 TRACE("Going to %d.\n", nextcol
);
2512 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2517 if (!(menu
->wFlags
& MF_POPUP
)) /* menu bar tracking */
2519 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2521 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2522 hmenutmp
= pmt
->hCurrentMenu
= pmt
->hTopMenu
;
2523 } else hmenutmp
= 0;
2525 /* try to move to the next item */
2526 if( !MENU_DoNextMenu( pmt
, VK_RIGHT
) )
2527 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_NEXT
);
2529 if( hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2530 if( !MENU_SuspendPopup(pmt
, WM_KEYDOWN
) )
2531 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2532 pmt
->hTopMenu
, TRUE
, wFlags
);
2536 /***********************************************************************
2539 * Menu tracking code.
2541 static BOOL
MENU_TrackMenu( HMENU hmenu
, UINT wFlags
, INT x
, INT y
,
2542 HWND hwnd
, const RECT
*lprect
)
2547 INT executedMenuId
= -1;
2549 BOOL enterIdleSent
= FALSE
;
2552 mt
.hCurrentMenu
= hmenu
;
2553 mt
.hTopMenu
= hmenu
;
2554 mt
.hOwnerWnd
= WIN_GetFullHandle( hwnd
);
2558 TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p (%ld,%ld)-(%ld,%ld)\n",
2559 hmenu
, wFlags
, x
, y
, hwnd
, (lprect
) ? lprect
->left
: 0, (lprect
) ? lprect
->top
: 0,
2560 (lprect
) ? lprect
->right
: 0, (lprect
) ? lprect
->bottom
: 0);
2563 if (!(menu
= MENU_GetMenu( hmenu
)))
2565 WARN("Invalid menu handle %p\n", hmenu
);
2566 SetLastError(ERROR_INVALID_MENU_HANDLE
);
2570 if (wFlags
& TPM_BUTTONDOWN
)
2572 /* Get the result in order to start the tracking or not */
2573 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2574 fEndMenu
= !fRemove
;
2577 MENU_SetCapture( mt
.hOwnerWnd
);
2581 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2582 if (!menu
) /* sometimes happens if I do a window manager close */
2585 /* we have to keep the message in the queue until it's
2586 * clear that menu loop is not over yet. */
2590 if (PeekMessageW( &msg
, 0, 0, 0, PM_NOREMOVE
))
2592 if (!CallMsgFilterW( &msg
, MSGF_MENU
)) break;
2593 /* remove the message from the queue */
2594 PeekMessageW( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2600 HWND win
= (wFlags
& TPM_ENTERIDLEEX
&& menu
->wFlags
& MF_POPUP
) ? menu
->hWnd
: 0;
2601 enterIdleSent
= TRUE
;
2602 SendMessageW( mt
.hOwnerWnd
, WM_ENTERIDLE
, MSGF_MENU
, (LPARAM
)win
);
2608 /* check if EndMenu() tried to cancel us, by posting this message */
2609 if(msg
.message
== WM_CANCELMODE
)
2611 /* we are now out of the loop */
2614 /* remove the message from the queue */
2615 PeekMessageW( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2617 /* break out of internal loop, ala ESCAPE */
2621 TranslateMessage( &msg
);
2624 if ( (msg
.hwnd
==menu
->hWnd
) || (msg
.message
!=WM_TIMER
) )
2625 enterIdleSent
=FALSE
;
2628 if ((msg
.message
>= WM_MOUSEFIRST
) && (msg
.message
<= WM_MOUSELAST
))
2631 * Use the mouse coordinates in lParam instead of those in the MSG
2632 * struct to properly handle synthetic messages. They are already
2633 * in screen coordinates.
2635 mt
.pt
.x
= (short)LOWORD(msg
.lParam
);
2636 mt
.pt
.y
= (short)HIWORD(msg
.lParam
);
2638 /* Find a menu for this mouse event */
2639 hmenu
= MENU_PtMenu( mt
.hTopMenu
, mt
.pt
);
2643 /* no WM_NC... messages in captured state */
2645 case WM_RBUTTONDBLCLK
:
2646 case WM_RBUTTONDOWN
:
2647 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2649 case WM_LBUTTONDBLCLK
:
2650 case WM_LBUTTONDOWN
:
2651 /* If the message belongs to the menu, removes it from the queue */
2652 /* Else, end menu tracking */
2653 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2654 fEndMenu
= !fRemove
;
2658 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2661 /* Check if a menu was selected by the mouse */
2664 executedMenuId
= MENU_ButtonUp( &mt
, hmenu
, wFlags
);
2666 /* End the loop if executedMenuId is an item ID */
2667 /* or if the job was done (executedMenuId = 0). */
2668 fEndMenu
= fRemove
= (executedMenuId
!= -1);
2670 /* No menu was selected by the mouse */
2671 /* if the function was called by TrackPopupMenu, continue
2672 with the menu tracking. If not, stop it */
2674 fEndMenu
= ((wFlags
& TPM_POPUPMENU
) ? FALSE
: TRUE
);
2679 /* the selected menu item must be changed every time */
2680 /* the mouse moves. */
2683 fEndMenu
|= !MENU_MouseMove( &mt
, hmenu
, wFlags
);
2685 } /* switch(msg.message) - mouse */
2687 else if ((msg
.message
>= WM_KEYFIRST
) && (msg
.message
<= WM_KEYLAST
))
2689 fRemove
= TRUE
; /* Keyboard messages are always removed */
2697 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2698 NO_SELECTED_ITEM
, FALSE
, 0 );
2701 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2702 (msg
.wParam
== VK_HOME
)? ITEM_NEXT
: ITEM_PREV
);
2705 case VK_DOWN
: /* If on menu bar, pull-down the menu */
2707 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2708 if (!(menu
->wFlags
& MF_POPUP
))
2709 mt
.hCurrentMenu
= MENU_ShowSubPopup(mt
.hOwnerWnd
, mt
.hTopMenu
, TRUE
, wFlags
);
2710 else /* otherwise try to move selection */
2711 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
, ITEM_NEXT
);
2715 MENU_KeyLeft( &mt
, wFlags
);
2719 MENU_KeyRight( &mt
, wFlags
);
2723 fEndMenu
= MENU_KeyEscape(&mt
, wFlags
);
2729 hi
.cbSize
= sizeof(HELPINFO
);
2730 hi
.iContextType
= HELPINFO_MENUITEM
;
2731 if (menu
->FocusedItem
== NO_SELECTED_ITEM
)
2734 hi
.iCtrlId
= menu
->items
[menu
->FocusedItem
].wID
;
2735 hi
.hItemHandle
= hmenu
;
2736 hi
.dwContextId
= menu
->dwContextHelpID
;
2737 hi
.MousePos
= msg
.pt
;
2738 SendMessageW(hwnd
, WM_HELP
, 0, (LPARAM
)&hi
);
2745 break; /* WM_KEYDOWN */
2755 break; /* WM_SYSKEYDOWN */
2761 if (msg
.wParam
== '\r' || msg
.wParam
== ' ')
2763 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2764 fEndMenu
= (executedMenuId
!= -1);
2769 /* Hack to avoid control chars. */
2770 /* We will find a better way real soon... */
2771 if (msg
.wParam
< 32) break;
2773 pos
= MENU_FindItemByKey( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2774 LOWORD(msg
.wParam
), FALSE
);
2775 if (pos
== (UINT
)-2) fEndMenu
= TRUE
;
2776 else if (pos
== (UINT
)-1) MessageBeep(0);
2779 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
, pos
,
2781 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2782 fEndMenu
= (executedMenuId
!= -1);
2786 } /* switch(msg.message) - kbd */
2790 DispatchMessageW( &msg
);
2793 if (!fEndMenu
) fRemove
= TRUE
;
2795 /* finally remove message from the queue */
2797 if (fRemove
&& !(mt
.trackFlags
& TF_SKIPREMOVE
) )
2798 PeekMessageW( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2799 else mt
.trackFlags
&= ~TF_SKIPREMOVE
;
2802 MENU_SetCapture(0); /* release the capture */
2804 /* If dropdown is still painted and the close box is clicked on
2805 then the menu will be destroyed as part of the DispatchMessage above.
2806 This will then invalidate the menu handle in mt.hTopMenu. We should
2807 check for this first. */
2808 if( IsMenu( mt
.hTopMenu
) )
2810 menu
= MENU_GetMenu( mt
.hTopMenu
);
2812 if( IsWindow( mt
.hOwnerWnd
) )
2814 MENU_HideSubPopups( mt
.hOwnerWnd
, mt
.hTopMenu
, FALSE
);
2816 if (menu
&& menu
->wFlags
& MF_POPUP
)
2818 DestroyWindow( menu
->hWnd
);
2821 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2822 SendMessageW( mt
.hOwnerWnd
, WM_MENUSELECT
, MAKELONG(0,0xffff), 0 );
2825 /* Reset the variable for hiding menu */
2826 if( menu
) menu
->bTimeToHide
= FALSE
;
2829 /* The return value is only used by TrackPopupMenu */
2830 if (!(wFlags
& TPM_RETURNCMD
)) return TRUE
;
2831 if (executedMenuId
== -1) executedMenuId
= 0;
2832 return executedMenuId
;
2835 /***********************************************************************
2838 static BOOL
MENU_InitTracking(HWND hWnd
, HMENU hMenu
, BOOL bPopup
, UINT wFlags
)
2842 TRACE("hwnd=%p hmenu=%p\n", hWnd
, hMenu
);
2846 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2847 if (!(wFlags
& TPM_NONOTIFY
))
2848 SendMessageW( hWnd
, WM_ENTERMENULOOP
, bPopup
, 0 );
2850 SendMessageW( hWnd
, WM_SETCURSOR
, (WPARAM
)hWnd
, HTCAPTION
);
2852 if (!(wFlags
& TPM_NONOTIFY
))
2854 SendMessageW( hWnd
, WM_INITMENU
, (WPARAM
)hMenu
, 0 );
2855 if ((menu
= MENU_GetMenu( hMenu
)) && (!menu
->Height
))
2856 { /* app changed/recreated menu bar entries in WM_INITMENU
2857 Recalculate menu sizes else clicks will not work */
2858 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
2859 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
2864 /* This makes the menus of applications built with Delphi work.
2865 * It also enables menus to be displayed in more than one window,
2866 * but there are some bugs left that need to be fixed in this case.
2868 if ((menu
= MENU_GetMenu( hMenu
))) menu
->hWnd
= hWnd
;
2872 /***********************************************************************
2875 static BOOL
MENU_ExitTracking(HWND hWnd
)
2877 TRACE("hwnd=%p\n", hWnd
);
2879 SendMessageW( hWnd
, WM_EXITMENULOOP
, 0, 0 );
2885 /***********************************************************************
2886 * MENU_TrackMouseMenuBar
2888 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2890 void MENU_TrackMouseMenuBar( HWND hWnd
, INT ht
, POINT pt
)
2892 HMENU hMenu
= (ht
== HTSYSMENU
) ? get_win_sys_menu( hWnd
) : GetMenu( hWnd
);
2893 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_BUTTONDOWN
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
2895 TRACE("wnd=%p ht=0x%04x (%ld,%ld)\n", hWnd
, ht
, pt
.x
, pt
.y
);
2899 /* map point to parent client coordinates */
2900 HWND parent
= GetAncestor( hWnd
, GA_PARENT
);
2901 if (parent
!= GetDesktopWindow()) ScreenToClient( parent
, &pt
);
2903 MENU_InitTracking( hWnd
, hMenu
, FALSE
, wFlags
);
2904 MENU_TrackMenu( hMenu
, wFlags
, pt
.x
, pt
.y
, hWnd
, NULL
);
2905 MENU_ExitTracking(hWnd
);
2910 /***********************************************************************
2911 * MENU_TrackKbdMenuBar
2913 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
2915 void MENU_TrackKbdMenuBar( HWND hwnd
, UINT wParam
, WCHAR wChar
)
2917 UINT uItem
= NO_SELECTED_ITEM
;
2919 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
2921 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd
, wParam
, wChar
);
2923 /* find window that has a menu */
2925 while (GetWindowLongW( hwnd
, GWL_STYLE
) & WS_CHILD
)
2926 if (!(hwnd
= GetParent( hwnd
))) return;
2928 /* check if we have to track a system menu */
2930 hTrackMenu
= GetMenu( hwnd
);
2931 if (!hTrackMenu
|| IsIconic(hwnd
) || wChar
== ' ' )
2933 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_SYSMENU
)) return;
2934 if (GetWindowLongW( hwnd
, GWL_EXSTYLE
) & WS_EX_MANAGED
) return;
2935 hTrackMenu
= get_win_sys_menu( hwnd
);
2937 wParam
|= HTSYSMENU
; /* prevent item lookup */
2940 if (!IsMenu( hTrackMenu
)) return;
2942 MENU_InitTracking( hwnd
, hTrackMenu
, FALSE
, wFlags
);
2944 if( wChar
&& wChar
!= ' ' )
2946 uItem
= MENU_FindItemByKey( hwnd
, hTrackMenu
, wChar
, (wParam
& HTSYSMENU
) );
2947 if( uItem
>= (UINT
)(-2) )
2949 if( uItem
== (UINT
)(-1) ) MessageBeep(0);
2956 MENU_SelectItem( hwnd
, hTrackMenu
, uItem
, TRUE
, 0 );
2958 if( uItem
== NO_SELECTED_ITEM
)
2959 MENU_MoveSelection( hwnd
, hTrackMenu
, ITEM_NEXT
);
2961 PostMessageW( hwnd
, WM_KEYDOWN
, VK_DOWN
, 0L );
2963 MENU_TrackMenu( hTrackMenu
, wFlags
, 0, 0, hwnd
, NULL
);
2965 MENU_ExitTracking( hwnd
);
2969 /**********************************************************************
2970 * TrackPopupMenu (USER32.@)
2972 * Like the win32 API, the function return the command ID only if the
2973 * flag TPM_RETURNCMD is on.
2976 BOOL WINAPI
TrackPopupMenu( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
2977 INT nReserved
, HWND hWnd
, const RECT
*lpRect
)
2981 MENU_InitTracking(hWnd
, hMenu
, TRUE
, wFlags
);
2983 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2984 if (!(wFlags
& TPM_NONOTIFY
))
2985 SendMessageW( hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hMenu
, 0);
2987 if (MENU_ShowPopup( hWnd
, hMenu
, 0, x
, y
, 0, 0 ))
2988 ret
= MENU_TrackMenu( hMenu
, wFlags
| TPM_POPUPMENU
, 0, 0, hWnd
, lpRect
);
2989 MENU_ExitTracking(hWnd
);
2994 /**********************************************************************
2995 * TrackPopupMenuEx (USER32.@)
2997 BOOL WINAPI
TrackPopupMenuEx( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
2998 HWND hWnd
, LPTPMPARAMS lpTpm
)
3000 FIXME("not fully implemented\n" );
3001 return TrackPopupMenu( hMenu
, wFlags
, x
, y
, 0, hWnd
,
3002 lpTpm
? &lpTpm
->rcExclude
: NULL
);
3005 /***********************************************************************
3008 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3010 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
3012 TRACE("hwnd=%p msg=0x%04x wp=0x%04x lp=0x%08lx\n", hwnd
, message
, wParam
, lParam
);
3018 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lParam
;
3019 SetWindowLongW( hwnd
, 0, (LONG
)cs
->lpCreateParams
);
3023 case WM_MOUSEACTIVATE
: /* We don't want to be activated */
3024 return MA_NOACTIVATE
;
3029 BeginPaint( hwnd
, &ps
);
3030 MENU_DrawPopupMenu( hwnd
, ps
.hdc
,
3031 (HMENU
)GetWindowLongW( hwnd
, 0 ) );
3032 EndPaint( hwnd
, &ps
);
3039 /* zero out global pointer in case resident popup window was destroyed. */
3040 if (hwnd
== top_popup
) top_popup
= 0;
3047 if (!GetWindowLongW( hwnd
, 0 )) ERR("no menu to display\n");
3050 SetWindowLongW( hwnd
, 0, 0 );
3053 case MM_SETMENUHANDLE
:
3054 SetWindowLongW( hwnd
, 0, wParam
);
3057 case MM_GETMENUHANDLE
:
3058 return GetWindowLongW( hwnd
, 0 );
3061 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
3067 /***********************************************************************
3068 * MENU_GetMenuBarHeight
3070 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3072 UINT
MENU_GetMenuBarHeight( HWND hwnd
, UINT menubarWidth
,
3073 INT orgX
, INT orgY
)
3079 TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd
, menubarWidth
, orgX
, orgY
);
3081 if (!(lppop
= MENU_GetMenu( GetMenu(hwnd
) ))) return 0;
3083 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| DCX_WINDOW
);
3084 SelectObject( hdc
, hMenuFont
);
3085 SetRect(&rectBar
, orgX
, orgY
, orgX
+menubarWidth
, orgY
+GetSystemMetrics(SM_CYMENU
));
3086 MENU_MenuBarCalcSize( hdc
, &rectBar
, lppop
, hwnd
);
3087 ReleaseDC( hwnd
, hdc
);
3088 return lppop
->Height
;
3092 /*******************************************************************
3093 * ChangeMenuA (USER32.@)
3095 BOOL WINAPI
ChangeMenuA( HMENU hMenu
, UINT pos
, LPCSTR data
,
3096 UINT id
, UINT flags
)
3098 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu
, pos
, data
, id
, flags
);
3099 if (flags
& MF_APPEND
) return AppendMenuA( hMenu
, flags
& ~MF_APPEND
,
3101 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3102 if (flags
& MF_CHANGE
) return ModifyMenuA(hMenu
, pos
, flags
& ~MF_CHANGE
,
3104 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3105 flags
& MF_BYPOSITION
? pos
: id
,
3106 flags
& ~MF_REMOVE
);
3107 /* Default: MF_INSERT */
3108 return InsertMenuA( hMenu
, pos
, flags
, id
, data
);
3112 /*******************************************************************
3113 * ChangeMenuW (USER32.@)
3115 BOOL WINAPI
ChangeMenuW( HMENU hMenu
, UINT pos
, LPCWSTR data
,
3116 UINT id
, UINT flags
)
3118 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu
, pos
, data
, id
, flags
);
3119 if (flags
& MF_APPEND
) return AppendMenuW( hMenu
, flags
& ~MF_APPEND
,
3121 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3122 if (flags
& MF_CHANGE
) return ModifyMenuW(hMenu
, pos
, flags
& ~MF_CHANGE
,
3124 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3125 flags
& MF_BYPOSITION
? pos
: id
,
3126 flags
& ~MF_REMOVE
);
3127 /* Default: MF_INSERT */
3128 return InsertMenuW( hMenu
, pos
, flags
, id
, data
);
3132 /*******************************************************************
3133 * CheckMenuItem (USER32.@)
3135 DWORD WINAPI
CheckMenuItem( HMENU hMenu
, UINT id
, UINT flags
)
3140 TRACE("menu=%p id=%04x flags=%04x\n", hMenu
, id
, flags
);
3141 if (!(item
= MENU_FindItem( &hMenu
, &id
, flags
))) return -1;
3142 ret
= item
->fState
& MF_CHECKED
;
3143 if (flags
& MF_CHECKED
) item
->fState
|= MF_CHECKED
;
3144 else item
->fState
&= ~MF_CHECKED
;
3149 /**********************************************************************
3150 * EnableMenuItem (USER32.@)
3152 UINT WINAPI
EnableMenuItem( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3158 TRACE("(%p, %04x, %04x) !\n", hMenu
, wItemID
, wFlags
);
3160 /* Get the Popupmenu to access the owner menu */
3161 if (!(menu
= MENU_GetMenu(hMenu
)))
3164 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
)))
3167 oldflags
= item
->fState
& (MF_GRAYED
| MF_DISABLED
);
3168 item
->fState
^= (oldflags
^ wFlags
) & (MF_GRAYED
| MF_DISABLED
);
3170 /* If the close item in the system menu change update the close button */
3171 if((item
->wID
== SC_CLOSE
) && (oldflags
!= wFlags
))
3173 if (menu
->hSysMenuOwner
!= 0)
3175 POPUPMENU
* parentMenu
;
3177 /* Get the parent menu to access*/
3178 if (!(parentMenu
= MENU_GetMenu(menu
->hSysMenuOwner
)))
3181 /* Refresh the frame to reflect the change*/
3182 SetWindowPos(parentMenu
->hWnd
, 0, 0, 0, 0, 0,
3183 SWP_NOACTIVATE
| SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
);
3191 /*******************************************************************
3192 * GetMenuStringA (USER32.@)
3194 INT WINAPI
GetMenuStringA(
3195 HMENU hMenu
, /* [in] menuhandle */
3196 UINT wItemID
, /* [in] menu item (dep. on wFlags) */
3197 LPSTR str
, /* [out] outbuffer. If NULL, func returns entry length*/
3198 INT nMaxSiz
, /* [in] length of buffer. if 0, func returns entry len*/
3199 UINT wFlags
/* [in] MF_ flags */
3203 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3204 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3205 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3206 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3208 if (!WideCharToMultiByte( CP_ACP
, 0, item
->text
, -1, str
, nMaxSiz
, NULL
, NULL
))
3210 TRACE("returning '%s'\n", str
);
3215 /*******************************************************************
3216 * GetMenuStringW (USER32.@)
3218 INT WINAPI
GetMenuStringW( HMENU hMenu
, UINT wItemID
,
3219 LPWSTR str
, INT nMaxSiz
, UINT wFlags
)
3223 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3224 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3225 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3226 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3228 lstrcpynW( str
, item
->text
, nMaxSiz
);
3229 return strlenW(str
);
3233 /**********************************************************************
3234 * HiliteMenuItem (USER32.@)
3236 BOOL WINAPI
HiliteMenuItem( HWND hWnd
, HMENU hMenu
, UINT wItemID
,
3240 TRACE("(%p, %p, %04x, %04x);\n", hWnd
, hMenu
, wItemID
, wHilite
);
3241 if (!MENU_FindItem( &hMenu
, &wItemID
, wHilite
)) return FALSE
;
3242 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3243 if (menu
->FocusedItem
== wItemID
) return TRUE
;
3244 MENU_HideSubPopups( hWnd
, hMenu
, FALSE
);
3245 MENU_SelectItem( hWnd
, hMenu
, wItemID
, TRUE
, 0 );
3250 /**********************************************************************
3251 * GetMenuState (USER32.@)
3253 UINT WINAPI
GetMenuState( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3256 TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu
, wItemID
, wFlags
);
3257 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return -1;
3258 debug_print_menuitem (" item: ", item
, "");
3259 if (item
->fType
& MF_POPUP
)
3261 POPUPMENU
*menu
= MENU_GetMenu( item
->hSubMenu
);
3262 if (!menu
) return -1;
3263 else return (menu
->nItems
<< 8) | ((item
->fState
|item
->fType
) & 0xff);
3267 /* We used to (from way back then) mask the result to 0xff. */
3268 /* I don't know why and it seems wrong as the documented */
3269 /* return flag MF_SEPARATOR is outside that mask. */
3270 return (item
->fType
| item
->fState
);
3275 /**********************************************************************
3276 * GetMenuItemCount (USER32.@)
3278 INT WINAPI
GetMenuItemCount( HMENU hMenu
)
3280 LPPOPUPMENU menu
= MENU_GetMenu(hMenu
);
3281 if (!menu
) return -1;
3282 TRACE("(%p) returning %d\n", hMenu
, menu
->nItems
);
3283 return menu
->nItems
;
3287 /**********************************************************************
3288 * GetMenuItemID (USER32.@)
3290 UINT WINAPI
GetMenuItemID( HMENU hMenu
, INT nPos
)
3294 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return -1;
3295 if (lpmi
->fType
& MF_POPUP
) return -1;
3301 /*******************************************************************
3302 * InsertMenuW (USER32.@)
3304 BOOL WINAPI
InsertMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3305 UINT_PTR id
, LPCWSTR str
)
3309 if (IS_STRING_ITEM(flags
) && str
)
3310 TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %s\n",
3311 hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3312 else TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %08lx (not a string)\n",
3313 hMenu
, pos
, flags
, id
, (DWORD
)str
);
3315 if (!(item
= MENU_InsertItem( hMenu
, pos
, flags
))) return FALSE
;
3317 if (!(MENU_SetItemData( item
, flags
, id
, str
)))
3319 RemoveMenu( hMenu
, pos
, flags
);
3323 if (flags
& MF_POPUP
) /* Set the MF_POPUP flag on the popup-menu */
3324 (MENU_GetMenu((HMENU
)id
))->wFlags
|= MF_POPUP
;
3326 item
->hCheckBit
= item
->hUnCheckBit
= 0;
3331 /*******************************************************************
3332 * InsertMenuA (USER32.@)
3334 BOOL WINAPI
InsertMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3335 UINT_PTR id
, LPCSTR str
)
3339 if (IS_STRING_ITEM(flags
) && str
)
3341 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3342 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3345 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3346 ret
= InsertMenuW( hMenu
, pos
, flags
, id
, newstr
);
3347 HeapFree( GetProcessHeap(), 0, newstr
);
3351 else return InsertMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3355 /*******************************************************************
3356 * AppendMenuA (USER32.@)
3358 BOOL WINAPI
AppendMenuA( HMENU hMenu
, UINT flags
,
3359 UINT_PTR id
, LPCSTR data
)
3361 return InsertMenuA( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3365 /*******************************************************************
3366 * AppendMenuW (USER32.@)
3368 BOOL WINAPI
AppendMenuW( HMENU hMenu
, UINT flags
,
3369 UINT_PTR id
, LPCWSTR data
)
3371 return InsertMenuW( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3375 /**********************************************************************
3376 * RemoveMenu (USER32.@)
3378 BOOL WINAPI
RemoveMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3383 TRACE("(menu=%p pos=%04x flags=%04x)\n",hMenu
, nPos
, wFlags
);
3384 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3385 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3389 MENU_FreeItemData( item
);
3391 if (--menu
->nItems
== 0)
3393 HeapFree( GetProcessHeap(), 0, menu
->items
);
3398 while(nPos
< menu
->nItems
)
3404 menu
->items
= HeapReAlloc( GetProcessHeap(), 0, menu
->items
,
3405 menu
->nItems
* sizeof(MENUITEM
) );
3411 /**********************************************************************
3412 * DeleteMenu (USER32.@)
3414 BOOL WINAPI
DeleteMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3416 MENUITEM
*item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
);
3417 if (!item
) return FALSE
;
3418 if (item
->fType
& MF_POPUP
) DestroyMenu( item
->hSubMenu
);
3419 /* nPos is now the position of the item */
3420 RemoveMenu( hMenu
, nPos
, wFlags
| MF_BYPOSITION
);
3425 /*******************************************************************
3426 * ModifyMenuW (USER32.@)
3428 BOOL WINAPI
ModifyMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3429 UINT_PTR id
, LPCWSTR str
)
3433 if (IS_STRING_ITEM(flags
))
3435 TRACE("%p %d %04x %04x %s\n", hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3439 TRACE("%p %d %04x %04x %08lx\n", hMenu
, pos
, flags
, id
, (DWORD
)str
);
3442 if (!(item
= MENU_FindItem( &hMenu
, &pos
, flags
))) return FALSE
;
3443 return MENU_SetItemData( item
, flags
, id
, str
);
3447 /*******************************************************************
3448 * ModifyMenuA (USER32.@)
3450 BOOL WINAPI
ModifyMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3451 UINT_PTR id
, LPCSTR str
)
3455 if (IS_STRING_ITEM(flags
) && str
)
3457 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3458 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3461 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3462 ret
= ModifyMenuW( hMenu
, pos
, flags
, id
, newstr
);
3463 HeapFree( GetProcessHeap(), 0, newstr
);
3467 else return ModifyMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3471 /**********************************************************************
3472 * CreatePopupMenu (USER32.@)
3474 HMENU WINAPI
CreatePopupMenu(void)
3479 if (!(hmenu
= CreateMenu())) return 0;
3480 menu
= MENU_GetMenu( hmenu
);
3481 menu
->wFlags
|= MF_POPUP
;
3482 menu
->bTimeToHide
= FALSE
;
3487 /**********************************************************************
3488 * GetMenuCheckMarkDimensions (USER.417)
3489 * GetMenuCheckMarkDimensions (USER32.@)
3491 DWORD WINAPI
GetMenuCheckMarkDimensions(void)
3493 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK
), GetSystemMetrics(SM_CYMENUCHECK
) );
3497 /**********************************************************************
3498 * SetMenuItemBitmaps (USER32.@)
3500 BOOL WINAPI
SetMenuItemBitmaps( HMENU hMenu
, UINT nPos
, UINT wFlags
,
3501 HBITMAP hNewUnCheck
, HBITMAP hNewCheck
)
3504 TRACE("(%p, %04x, %04x, %p, %p)\n",
3505 hMenu
, nPos
, wFlags
, hNewCheck
, hNewUnCheck
);
3506 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3508 if (!hNewCheck
&& !hNewUnCheck
)
3510 item
->fState
&= ~MF_USECHECKBITMAPS
;
3512 else /* Install new bitmaps */
3514 item
->hCheckBit
= hNewCheck
;
3515 item
->hUnCheckBit
= hNewUnCheck
;
3516 item
->fState
|= MF_USECHECKBITMAPS
;
3522 /**********************************************************************
3523 * CreateMenu (USER32.@)
3525 HMENU WINAPI
CreateMenu(void)
3529 if (!(hMenu
= USER_HEAP_ALLOC( sizeof(POPUPMENU
) ))) return 0;
3530 menu
= (LPPOPUPMENU
) USER_HEAP_LIN_ADDR(hMenu
);
3532 ZeroMemory(menu
, sizeof(POPUPMENU
));
3533 menu
->wMagic
= MENU_MAGIC
;
3534 menu
->FocusedItem
= NO_SELECTED_ITEM
;
3535 menu
->bTimeToHide
= FALSE
;
3537 TRACE("return %p\n", hMenu
);
3543 /**********************************************************************
3544 * DestroyMenu (USER32.@)
3546 BOOL WINAPI
DestroyMenu( HMENU hMenu
)
3548 TRACE("(%p)\n", hMenu
);
3550 /* Silently ignore attempts to destroy default system popup */
3552 if (hMenu
&& hMenu
!= MENU_DefSysPopup
)
3554 LPPOPUPMENU lppop
= MENU_GetMenu(hMenu
);
3556 if (!lppop
) return FALSE
;
3558 lppop
->wMagic
= 0; /* Mark it as destroyed */
3560 if ((lppop
->wFlags
& MF_POPUP
) && lppop
->hWnd
)
3562 DestroyWindow( lppop
->hWnd
);
3566 if (lppop
->items
) /* recursively destroy submenus */
3569 MENUITEM
*item
= lppop
->items
;
3570 for (i
= lppop
->nItems
; i
> 0; i
--, item
++)
3572 if (item
->fType
& MF_POPUP
) DestroyMenu(item
->hSubMenu
);
3573 MENU_FreeItemData( item
);
3575 HeapFree( GetProcessHeap(), 0, lppop
->items
);
3577 USER_HEAP_FREE( hMenu
);
3579 return (hMenu
!= MENU_DefSysPopup
);
3583 /**********************************************************************
3584 * GetSystemMenu (USER32.@)
3586 HMENU WINAPI
GetSystemMenu( HWND hWnd
, BOOL bRevert
)
3588 WND
*wndPtr
= WIN_FindWndPtr( hWnd
);
3593 if( wndPtr
->hSysMenu
)
3597 DestroyMenu(wndPtr
->hSysMenu
);
3598 wndPtr
->hSysMenu
= 0;
3602 POPUPMENU
*menu
= MENU_GetMenu( wndPtr
->hSysMenu
);
3605 if( menu
->nItems
> 0 && menu
->items
[0].hSubMenu
== MENU_DefSysPopup
)
3606 menu
->items
[0].hSubMenu
= MENU_CopySysPopup();
3610 WARN("Current sys-menu (%p) of wnd %p is broken\n",
3611 wndPtr
->hSysMenu
, hWnd
);
3612 wndPtr
->hSysMenu
= 0;
3617 if(!wndPtr
->hSysMenu
&& (wndPtr
->dwStyle
& WS_SYSMENU
) )
3618 wndPtr
->hSysMenu
= MENU_GetSysMenu( hWnd
, (HMENU
)(-1) );
3620 if( wndPtr
->hSysMenu
)
3623 retvalue
= GetSubMenu(wndPtr
->hSysMenu
, 0);
3625 /* Store the dummy sysmenu handle to facilitate the refresh */
3626 /* of the close button if the SC_CLOSE item change */
3627 menu
= MENU_GetMenu(retvalue
);
3629 menu
->hSysMenuOwner
= wndPtr
->hSysMenu
;
3631 WIN_ReleaseWndPtr(wndPtr
);
3633 return bRevert
? 0 : retvalue
;
3637 /*******************************************************************
3638 * SetSystemMenu (USER32.@)
3640 BOOL WINAPI
SetSystemMenu( HWND hwnd
, HMENU hMenu
)
3642 WND
*wndPtr
= WIN_FindWndPtr(hwnd
);
3646 if (wndPtr
->hSysMenu
) DestroyMenu( wndPtr
->hSysMenu
);
3647 wndPtr
->hSysMenu
= MENU_GetSysMenu( hwnd
, hMenu
);
3648 WIN_ReleaseWndPtr(wndPtr
);
3655 /**********************************************************************
3656 * GetMenu (USER32.@)
3658 HMENU WINAPI
GetMenu( HWND hWnd
)
3660 HMENU retvalue
= (HMENU
)GetWindowLongPtrW( hWnd
, GWLP_ID
);
3661 TRACE("for %p returning %p\n", hWnd
, retvalue
);
3666 /**********************************************************************
3669 * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
3670 * SetWindowPos call that would result if SetMenu were called directly.
3672 BOOL
MENU_SetMenu( HWND hWnd
, HMENU hMenu
)
3674 TRACE("(%p, %p);\n", hWnd
, hMenu
);
3676 if (hMenu
&& !IsMenu(hMenu
))
3678 WARN("hMenu %p is not a menu handle\n", hMenu
);
3681 if (GetWindowLongW( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
3683 hWnd
= WIN_GetFullHandle( hWnd
);
3684 if (GetCapture() == hWnd
) MENU_SetCapture(0); /* release the capture */
3690 if (!(lpmenu
= MENU_GetMenu(hMenu
))) return FALSE
;
3692 lpmenu
->hWnd
= hWnd
;
3693 lpmenu
->Height
= 0; /* Make sure we recalculate the size */
3695 SetWindowLongPtrW( hWnd
, GWLP_ID
, (LONG_PTR
)hMenu
);
3700 /**********************************************************************
3701 * SetMenu (USER32.@)
3703 BOOL WINAPI
SetMenu( HWND hWnd
, HMENU hMenu
)
3705 if(!MENU_SetMenu(hWnd
, hMenu
))
3708 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
3709 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
3714 /**********************************************************************
3715 * GetSubMenu (USER32.@)
3717 HMENU WINAPI
GetSubMenu( HMENU hMenu
, INT nPos
)
3721 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return 0;
3722 if (!(lpmi
->fType
& MF_POPUP
)) return 0;
3723 return lpmi
->hSubMenu
;
3727 /**********************************************************************
3728 * DrawMenuBar (USER32.@)
3730 BOOL WINAPI
DrawMenuBar( HWND hWnd
)
3733 HMENU hMenu
= GetMenu(hWnd
);
3735 if (GetWindowLongW( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
3736 if (!hMenu
|| !(lppop
= MENU_GetMenu( hMenu
))) return FALSE
;
3738 lppop
->Height
= 0; /* Make sure we call MENU_MenuBarCalcSize */
3739 lppop
->hwndOwner
= hWnd
;
3740 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
3741 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
3745 /***********************************************************************
3746 * DrawMenuBarTemp (USER32.@)
3750 * called by W98SE desk.cpl Control Panel Applet
3752 * Not 100% sure about the param names, but close.
3754 DWORD WINAPI
DrawMenuBarTemp(HWND hwnd
, HDC hDC
, LPRECT lprect
, HMENU hMenu
, HFONT hFont
)
3761 hMenu
= GetMenu(hwnd
);
3766 lppop
= MENU_GetMenu( hMenu
);
3767 if (lppop
== NULL
|| lprect
== NULL
)
3769 retvalue
= GetSystemMetrics(SM_CYMENU
);
3773 TRACE("(%p, %p, %p, %p, %p)\n", hwnd
, hDC
, lprect
, hMenu
, hFont
);
3775 hfontOld
= SelectObject( hDC
, hFont
);
3777 if (lppop
->Height
== 0)
3778 MENU_MenuBarCalcSize(hDC
, lprect
, lppop
, hwnd
);
3780 lprect
->bottom
= lprect
->top
+ lppop
->Height
;
3782 FillRect(hDC
, lprect
, GetSysColorBrush(COLOR_MENU
) );
3784 SelectObject( hDC
, SYSCOLOR_GetPen(COLOR_3DFACE
));
3785 MoveToEx( hDC
, lprect
->left
, lprect
->bottom
, NULL
);
3786 LineTo( hDC
, lprect
->right
, lprect
->bottom
);
3788 if (lppop
->nItems
== 0)
3790 retvalue
= GetSystemMetrics(SM_CYMENU
);
3794 for (i
= 0; i
< lppop
->nItems
; i
++)
3796 MENU_DrawMenuItem( hwnd
, hMenu
, hwnd
,
3797 hDC
, &lppop
->items
[i
], lppop
->Height
, TRUE
, ODA_DRAWENTIRE
);
3799 retvalue
= lppop
->Height
;
3802 if (hfontOld
) SelectObject (hDC
, hfontOld
);
3806 /***********************************************************************
3807 * EndMenu (USER.187)
3808 * EndMenu (USER32.@)
3810 void WINAPI
EndMenu(void)
3812 /* if we are in the menu code, and it is active */
3813 if (!fEndMenu
&& top_popup
)
3815 /* terminate the menu handling code */
3818 /* needs to be posted to wakeup the internal menu handler */
3819 /* which will now terminate the menu, in the event that */
3820 /* the main window was minimized, or lost focus, so we */
3821 /* don't end up with an orphaned menu */
3822 PostMessageW( top_popup
, WM_CANCELMODE
, 0, 0);
3827 /***********************************************************************
3828 * LookupMenuHandle (USER.217)
3830 HMENU16 WINAPI
LookupMenuHandle16( HMENU16 hmenu
, INT16 id
)
3832 HMENU hmenu32
= HMENU_32(hmenu
);
3834 if (!MENU_FindItem( &hmenu32
, &id32
, MF_BYCOMMAND
)) return 0;
3835 else return HMENU_16(hmenu32
);
3839 /**********************************************************************
3840 * LoadMenu (USER.150)
3842 HMENU16 WINAPI
LoadMenu16( HINSTANCE16 instance
, LPCSTR name
)
3848 if (HIWORD(name
) && name
[0] == '#') name
= (LPCSTR
)atoi( name
+ 1 );
3849 if (!name
) return 0;
3851 instance
= GetExePtr( instance
);
3852 if (!(hRsrc
= FindResource16( instance
, name
, (LPSTR
)RT_MENU
))) return 0;
3853 if (!(handle
= LoadResource16( instance
, hRsrc
))) return 0;
3854 hMenu
= LoadMenuIndirect16(LockResource16(handle
));
3855 FreeResource16( handle
);
3860 /*****************************************************************
3861 * LoadMenuA (USER32.@)
3863 HMENU WINAPI
LoadMenuA( HINSTANCE instance
, LPCSTR name
)
3865 HRSRC hrsrc
= FindResourceA( instance
, name
, (LPSTR
)RT_MENU
);
3866 if (!hrsrc
) return 0;
3867 return LoadMenuIndirectA( (LPCVOID
)LoadResource( instance
, hrsrc
));
3871 /*****************************************************************
3872 * LoadMenuW (USER32.@)
3874 HMENU WINAPI
LoadMenuW( HINSTANCE instance
, LPCWSTR name
)
3876 HRSRC hrsrc
= FindResourceW( instance
, name
, (LPWSTR
)RT_MENU
);
3877 if (!hrsrc
) return 0;
3878 return LoadMenuIndirectW( (LPCVOID
)LoadResource( instance
, hrsrc
));
3882 /**********************************************************************
3883 * LoadMenuIndirect (USER.220)
3885 HMENU16 WINAPI
LoadMenuIndirect16( LPCVOID
template )
3888 WORD version
, offset
;
3889 LPCSTR p
= (LPCSTR
)template;
3891 TRACE("(%p)\n", template );
3892 version
= GET_WORD(p
);
3896 WARN("version must be 0 for Win16\n" );
3899 offset
= GET_WORD(p
);
3900 p
+= sizeof(WORD
) + offset
;
3901 if (!(hMenu
= CreateMenu())) return 0;
3902 if (!MENU_ParseResource( p
, hMenu
, FALSE
))
3904 DestroyMenu( hMenu
);
3907 return HMENU_16(hMenu
);
3911 /**********************************************************************
3912 * LoadMenuIndirectW (USER32.@)
3914 HMENU WINAPI
LoadMenuIndirectW( LPCVOID
template )
3917 WORD version
, offset
;
3918 LPCSTR p
= (LPCSTR
)template;
3920 version
= GET_WORD(p
);
3922 TRACE("%p, ver %d\n", template, version
);
3925 case 0: /* standard format is version of 0 */
3926 offset
= GET_WORD(p
);
3927 p
+= sizeof(WORD
) + offset
;
3928 if (!(hMenu
= CreateMenu())) return 0;
3929 if (!MENU_ParseResource( p
, hMenu
, TRUE
))
3931 DestroyMenu( hMenu
);
3935 case 1: /* extended format is version of 1 */
3936 offset
= GET_WORD(p
);
3937 p
+= sizeof(WORD
) + offset
;
3938 if (!(hMenu
= CreateMenu())) return 0;
3939 if (!MENUEX_ParseResource( p
, hMenu
))
3941 DestroyMenu( hMenu
);
3946 ERR("version %d not supported.\n", version
);
3952 /**********************************************************************
3953 * LoadMenuIndirectA (USER32.@)
3955 HMENU WINAPI
LoadMenuIndirectA( LPCVOID
template )
3957 return LoadMenuIndirectW( template );
3961 /**********************************************************************
3964 BOOL WINAPI
IsMenu(HMENU hmenu
)
3966 LPPOPUPMENU menu
= MENU_GetMenu(hmenu
);
3967 return menu
!= NULL
;
3970 /**********************************************************************
3971 * GetMenuItemInfo_common
3974 static BOOL
GetMenuItemInfo_common ( HMENU hmenu
, UINT item
, BOOL bypos
,
3975 LPMENUITEMINFOW lpmii
, BOOL unicode
)
3977 MENUITEM
*menu
= MENU_FindItem (&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0);
3979 debug_print_menuitem("GetMenuItemInfo_common: ", menu
, "");
3984 if (lpmii
->fMask
& MIIM_TYPE
) {
3985 lpmii
->fType
= menu
->fType
;
3986 switch (MENU_ITEM_TYPE(menu
->fType
)) {
3988 break; /* will be done below */
3991 lpmii
->dwTypeData
= menu
->text
;
3998 /* copy the text string */
3999 if ((lpmii
->fMask
& (MIIM_TYPE
|MIIM_STRING
)) &&
4000 (MENU_ITEM_TYPE(menu
->fType
) == MF_STRING
) && menu
->text
)
4005 len
= strlenW(menu
->text
);
4006 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4007 lstrcpynW(lpmii
->dwTypeData
, menu
->text
, lpmii
->cch
);
4011 len
= WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1, NULL
, 0, NULL
, NULL
);
4012 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4013 if (!WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1,
4014 (LPSTR
)lpmii
->dwTypeData
, lpmii
->cch
, NULL
, NULL
))
4015 ((LPSTR
)lpmii
->dwTypeData
)[lpmii
->cch
-1] = 0;
4017 /* if we've copied a substring we return its length */
4018 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4020 if (lpmii
->cch
<= len
) lpmii
->cch
--;
4022 else /* return length of string */
4026 if (lpmii
->fMask
& MIIM_FTYPE
)
4027 lpmii
->fType
= menu
->fType
;
4029 if (lpmii
->fMask
& MIIM_BITMAP
)
4030 lpmii
->hbmpItem
= menu
->hbmpItem
;
4032 if (lpmii
->fMask
& MIIM_STATE
)
4033 lpmii
->fState
= menu
->fState
;
4035 if (lpmii
->fMask
& MIIM_ID
)
4036 lpmii
->wID
= menu
->wID
;
4038 if (lpmii
->fMask
& MIIM_SUBMENU
)
4039 lpmii
->hSubMenu
= menu
->hSubMenu
;
4041 if (lpmii
->fMask
& MIIM_CHECKMARKS
) {
4042 lpmii
->hbmpChecked
= menu
->hCheckBit
;
4043 lpmii
->hbmpUnchecked
= menu
->hUnCheckBit
;
4045 if (lpmii
->fMask
& MIIM_DATA
)
4046 lpmii
->dwItemData
= menu
->dwItemData
;
4051 /**********************************************************************
4052 * GetMenuItemInfoA (USER32.@)
4054 BOOL WINAPI
GetMenuItemInfoA( HMENU hmenu
, UINT item
, BOOL bypos
,
4055 LPMENUITEMINFOA lpmii
)
4057 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4058 (LPMENUITEMINFOW
)lpmii
, FALSE
);
4061 /**********************************************************************
4062 * GetMenuItemInfoW (USER32.@)
4064 BOOL WINAPI
GetMenuItemInfoW( HMENU hmenu
, UINT item
, BOOL bypos
,
4065 LPMENUITEMINFOW lpmii
)
4067 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4072 /* set a menu item text from a ASCII or Unicode string */
4073 inline static void set_menu_item_text( MENUITEM
*menu
, LPCWSTR text
, BOOL unicode
)
4078 menu
->fType
|= MF_SEPARATOR
;
4082 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(text
)+1) * sizeof(WCHAR
) )))
4083 strcpyW( menu
->text
, text
);
4087 LPCSTR str
= (LPCSTR
)text
;
4088 int len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
4089 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
4090 MultiByteToWideChar( CP_ACP
, 0, str
, -1, menu
->text
, len
);
4095 /**********************************************************************
4096 * SetMenuItemInfo_common
4099 static BOOL
SetMenuItemInfo_common(MENUITEM
* menu
,
4100 const MENUITEMINFOW
*lpmii
,
4103 if (!menu
) return FALSE
;
4105 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu
, "");
4107 if (lpmii
->fMask
& MIIM_TYPE
) {
4108 /* Get rid of old string. */
4109 if (IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4110 HeapFree(GetProcessHeap(), 0, menu
->text
);
4114 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4115 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4116 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4118 menu
->text
= lpmii
->dwTypeData
;
4120 if (IS_STRING_ITEM(menu
->fType
))
4121 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4124 if (lpmii
->fMask
& MIIM_FTYPE
) {
4125 /* free the string when the type is changing */
4126 if ( (!IS_STRING_ITEM(lpmii
->fType
)) && IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4127 HeapFree(GetProcessHeap(), 0, menu
->text
);
4130 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4131 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4132 if ( IS_STRING_ITEM(menu
->fType
) && !menu
->text
)
4133 menu
->fType
|= MF_SEPARATOR
;
4136 if (lpmii
->fMask
& MIIM_STRING
) {
4137 if (IS_STRING_ITEM(menu
->fType
)) {
4138 /* free the string when used */
4140 HeapFree(GetProcessHeap(), 0, menu
->text
);
4141 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4145 if (lpmii
->fMask
& MIIM_STATE
)
4147 /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4148 menu
->fState
= lpmii
->fState
;
4151 if (lpmii
->fMask
& MIIM_ID
)
4152 menu
->wID
= lpmii
->wID
;
4154 if (lpmii
->fMask
& MIIM_SUBMENU
) {
4155 menu
->hSubMenu
= lpmii
->hSubMenu
;
4156 if (menu
->hSubMenu
) {
4157 POPUPMENU
*subMenu
= MENU_GetMenu(menu
->hSubMenu
);
4159 subMenu
->wFlags
|= MF_POPUP
;
4160 menu
->fType
|= MF_POPUP
;
4163 /* FIXME: Return an error ? */
4164 menu
->fType
&= ~MF_POPUP
;
4167 menu
->fType
&= ~MF_POPUP
;
4170 if (lpmii
->fMask
& MIIM_CHECKMARKS
)
4172 if (lpmii
->fType
& MFT_RADIOCHECK
)
4173 menu
->fType
|= MFT_RADIOCHECK
;
4175 menu
->hCheckBit
= lpmii
->hbmpChecked
;
4176 menu
->hUnCheckBit
= lpmii
->hbmpUnchecked
;
4178 if (lpmii
->fMask
& MIIM_DATA
)
4179 menu
->dwItemData
= lpmii
->dwItemData
;
4181 debug_print_menuitem("SetMenuItemInfo_common to : ", menu
, "");
4185 /**********************************************************************
4186 * SetMenuItemInfoA (USER32.@)
4188 BOOL WINAPI
SetMenuItemInfoA(HMENU hmenu
, UINT item
, BOOL bypos
,
4189 const MENUITEMINFOA
*lpmii
)
4191 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4192 (const MENUITEMINFOW
*)lpmii
, FALSE
);
4195 /**********************************************************************
4196 * SetMenuItemInfoW (USER32.@)
4198 BOOL WINAPI
SetMenuItemInfoW(HMENU hmenu
, UINT item
, BOOL bypos
,
4199 const MENUITEMINFOW
*lpmii
)
4201 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4205 /**********************************************************************
4206 * SetMenuDefaultItem (USER32.@)
4209 BOOL WINAPI
SetMenuDefaultItem(HMENU hmenu
, UINT uItem
, UINT bypos
)
4215 TRACE("(%p,%d,%d)\n", hmenu
, uItem
, bypos
);
4217 if (!(menu
= MENU_GetMenu(hmenu
))) return FALSE
;
4219 /* reset all default-item flags */
4221 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4223 item
->fState
&= ~MFS_DEFAULT
;
4226 /* no default item */
4235 if ( uItem
>= menu
->nItems
) return FALSE
;
4236 item
[uItem
].fState
|= MFS_DEFAULT
;
4241 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4243 if (item
->wID
== uItem
)
4245 item
->fState
|= MFS_DEFAULT
;
4254 /**********************************************************************
4255 * GetMenuDefaultItem (USER32.@)
4257 UINT WINAPI
GetMenuDefaultItem(HMENU hmenu
, UINT bypos
, UINT flags
)
4263 TRACE("(%p,%d,%d)\n", hmenu
, bypos
, flags
);
4265 if (!(menu
= MENU_GetMenu(hmenu
))) return -1;
4267 /* find default item */
4271 if (! item
) return -1;
4273 while ( !( item
->fState
& MFS_DEFAULT
) )
4276 if (i
>= menu
->nItems
) return -1;
4279 /* default: don't return disabled items */
4280 if ( (!(GMDI_USEDISABLED
& flags
)) && (item
->fState
& MFS_DISABLED
)) return -1;
4282 /* search rekursiv when needed */
4283 if ( (item
->fType
& MF_POPUP
) && (flags
& GMDI_GOINTOPOPUPS
) )
4286 ret
= GetMenuDefaultItem( item
->hSubMenu
, bypos
, flags
);
4287 if ( -1 != ret
) return ret
;
4289 /* when item not found in submenu, return the popup item */
4291 return ( bypos
) ? i
: item
->wID
;
4296 /**********************************************************************
4297 * InsertMenuItemA (USER32.@)
4299 BOOL WINAPI
InsertMenuItemA(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4300 const MENUITEMINFOA
*lpmii
)
4302 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4303 return SetMenuItemInfo_common(item
, (const MENUITEMINFOW
*)lpmii
, FALSE
);
4307 /**********************************************************************
4308 * InsertMenuItemW (USER32.@)
4310 BOOL WINAPI
InsertMenuItemW(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4311 const MENUITEMINFOW
*lpmii
)
4313 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4314 return SetMenuItemInfo_common(item
, lpmii
, TRUE
);
4317 /**********************************************************************
4318 * CheckMenuRadioItem (USER32.@)
4321 BOOL WINAPI
CheckMenuRadioItem(HMENU hMenu
,
4322 UINT first
, UINT last
, UINT check
,
4325 MENUITEM
*mifirst
, *milast
, *micheck
;
4326 HMENU mfirst
= hMenu
, mlast
= hMenu
, mcheck
= hMenu
;
4328 TRACE("%p: %d-%d, check %d, bypos=%d\n", hMenu
, first
, last
, check
, bypos
);
4330 mifirst
= MENU_FindItem (&mfirst
, &first
, bypos
);
4331 milast
= MENU_FindItem (&mlast
, &last
, bypos
);
4332 micheck
= MENU_FindItem (&mcheck
, &check
, bypos
);
4334 if (mifirst
== NULL
|| milast
== NULL
|| micheck
== NULL
||
4335 mifirst
> milast
|| mfirst
!= mlast
|| mfirst
!= mcheck
||
4336 micheck
> milast
|| micheck
< mifirst
)
4339 while (mifirst
<= milast
)
4341 if (mifirst
== micheck
)
4343 mifirst
->fType
|= MFT_RADIOCHECK
;
4344 mifirst
->fState
|= MFS_CHECKED
;
4346 mifirst
->fType
&= ~MFT_RADIOCHECK
;
4347 mifirst
->fState
&= ~MFS_CHECKED
;
4356 /**********************************************************************
4357 * GetMenuItemRect (USER32.@)
4359 * ATTENTION: Here, the returned values in rect are the screen
4360 * coordinates of the item just like if the menu was
4361 * always on the upper left side of the application.
4364 BOOL WINAPI
GetMenuItemRect (HWND hwnd
, HMENU hMenu
, UINT uItem
,
4367 POPUPMENU
*itemMenu
;
4371 TRACE("(%p,%p,%d,%p)\n", hwnd
, hMenu
, uItem
, rect
);
4373 item
= MENU_FindItem (&hMenu
, &uItem
, MF_BYPOSITION
);
4374 referenceHwnd
= hwnd
;
4378 itemMenu
= MENU_GetMenu(hMenu
);
4379 if (itemMenu
== NULL
)
4382 if(itemMenu
->hWnd
== 0)
4384 referenceHwnd
= itemMenu
->hWnd
;
4387 if ((rect
== NULL
) || (item
== NULL
))
4392 MapWindowPoints(referenceHwnd
, 0, (LPPOINT
)rect
, 2);
4398 /**********************************************************************
4399 * SetMenuInfo (USER32.@)
4402 * MIM_APPLYTOSUBMENUS
4403 * actually use the items to draw the menu
4405 BOOL WINAPI
SetMenuInfo (HMENU hMenu
, LPCMENUINFO lpmi
)
4409 TRACE("(%p %p)\n", hMenu
, lpmi
);
4411 if (lpmi
&& (lpmi
->cbSize
==sizeof(MENUINFO
)) && (menu
= MENU_GetMenu(hMenu
)))
4414 if (lpmi
->fMask
& MIM_BACKGROUND
)
4415 menu
->hbrBack
= lpmi
->hbrBack
;
4417 if (lpmi
->fMask
& MIM_HELPID
)
4418 menu
->dwContextHelpID
= lpmi
->dwContextHelpID
;
4420 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4421 menu
->cyMax
= lpmi
->cyMax
;
4423 if (lpmi
->fMask
& MIM_MENUDATA
)
4424 menu
->dwMenuData
= lpmi
->dwMenuData
;
4426 if (lpmi
->fMask
& MIM_STYLE
)
4427 menu
->dwStyle
= lpmi
->dwStyle
;
4434 /**********************************************************************
4435 * GetMenuInfo (USER32.@)
4441 BOOL WINAPI
GetMenuInfo (HMENU hMenu
, LPMENUINFO lpmi
)
4444 TRACE("(%p %p)\n", hMenu
, lpmi
);
4446 if (lpmi
&& (menu
= MENU_GetMenu(hMenu
)))
4449 if (lpmi
->fMask
& MIM_BACKGROUND
)
4450 lpmi
->hbrBack
= menu
->hbrBack
;
4452 if (lpmi
->fMask
& MIM_HELPID
)
4453 lpmi
->dwContextHelpID
= menu
->dwContextHelpID
;
4455 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4456 lpmi
->cyMax
= menu
->cyMax
;
4458 if (lpmi
->fMask
& MIM_MENUDATA
)
4459 lpmi
->dwMenuData
= menu
->dwMenuData
;
4461 if (lpmi
->fMask
& MIM_STYLE
)
4462 lpmi
->dwStyle
= menu
->dwStyle
;
4470 /**********************************************************************
4471 * SetMenuContextHelpId (USER32.@)
4473 BOOL WINAPI
SetMenuContextHelpId( HMENU hMenu
, DWORD dwContextHelpID
)
4477 TRACE("(%p 0x%08lx)\n", hMenu
, dwContextHelpID
);
4479 if ((menu
= MENU_GetMenu(hMenu
)))
4481 menu
->dwContextHelpID
= dwContextHelpID
;
4488 /**********************************************************************
4489 * GetMenuContextHelpId (USER32.@)
4491 DWORD WINAPI
GetMenuContextHelpId( HMENU hMenu
)
4495 TRACE("(%p)\n", hMenu
);
4497 if ((menu
= MENU_GetMenu(hMenu
)))
4499 return menu
->dwContextHelpID
;
4504 /**********************************************************************
4505 * MenuItemFromPoint (USER32.@)
4507 UINT WINAPI
MenuItemFromPoint(HWND hWnd
, HMENU hMenu
, POINT ptScreen
)
4509 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
4513 /*FIXME: Do we have to handle hWnd here? */
4514 item
= MENU_FindItemByCoords(menu
, ptScreen
, &pos
);
4520 /**********************************************************************
4521 * translate_accelerator
4523 static BOOL
translate_accelerator( HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
,
4524 BYTE fVirt
, WORD key
, WORD cmd
)
4528 if (wParam
!= key
) return FALSE
;
4530 if (message
== WM_CHAR
)
4532 if ( !(fVirt
& FALT
) && !(fVirt
& FVIRTKEY
) )
4534 TRACE_(accel
)("found accel for WM_CHAR: ('%c')\n", wParam
& 0xff);
4540 if(fVirt
& FVIRTKEY
)
4543 TRACE_(accel
)("found accel for virt_key %04x (scan %04x)\n",
4544 wParam
, 0xff & HIWORD(lParam
));
4545 if(GetKeyState(VK_SHIFT
) & 0x8000) mask
|= FSHIFT
;
4546 if(GetKeyState(VK_CONTROL
) & 0x8000) mask
|= FCONTROL
;
4547 if(GetKeyState(VK_MENU
) & 0x8000) mask
|= FALT
;
4548 if(mask
== (fVirt
& (FSHIFT
| FCONTROL
| FALT
))) goto found
;
4549 TRACE_(accel
)(", but incorrect SHIFT/CTRL/ALT-state\n");
4553 if (!(lParam
& 0x01000000)) /* no special_key */
4555 if ((fVirt
& FALT
) && (lParam
& 0x20000000))
4556 { /* ^^ ALT pressed */
4557 TRACE_(accel
)("found accel for Alt-%c\n", wParam
& 0xff);
4566 if (message
== WM_KEYUP
|| message
== WM_SYSKEYUP
)
4570 HMENU hMenu
, hSubMenu
, hSysMenu
;
4571 UINT uSysStat
= (UINT
)-1, uStat
= (UINT
)-1, nPos
;
4573 hMenu
= (GetWindowLongW( hWnd
, GWL_STYLE
) & WS_CHILD
) ? 0 : GetMenu(hWnd
);
4574 hSysMenu
= get_win_sys_menu( hWnd
);
4576 /* find menu item and ask application to initialize it */
4577 /* 1. in the system menu */
4578 hSubMenu
= hSysMenu
;
4580 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4584 if (!IsWindowEnabled(hWnd
))
4588 SendMessageW(hWnd
, WM_INITMENU
, (WPARAM
)hSysMenu
, 0L);
4589 if(hSubMenu
!= hSysMenu
)
4591 nPos
= MENU_FindSubMenu(&hSysMenu
, hSubMenu
);
4592 TRACE_(accel
)("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hSysMenu
, hSubMenu
, nPos
);
4593 SendMessageW(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, TRUE
));
4595 uSysStat
= GetMenuState(GetSubMenu(hSysMenu
, 0), cmd
, MF_BYCOMMAND
);
4598 else /* 2. in the window's menu */
4602 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4606 if (!IsWindowEnabled(hWnd
))
4610 SendMessageW(hWnd
, WM_INITMENU
, (WPARAM
)hMenu
, 0L);
4611 if(hSubMenu
!= hMenu
)
4613 nPos
= MENU_FindSubMenu(&hMenu
, hSubMenu
);
4614 TRACE_(accel
)("hMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu
, hSubMenu
, nPos
);
4615 SendMessageW(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, FALSE
));
4617 uStat
= GetMenuState(hMenu
, cmd
, MF_BYCOMMAND
);
4624 if (uSysStat
!= (UINT
)-1)
4626 if (uSysStat
& (MF_DISABLED
|MF_GRAYED
))
4633 if (uStat
!= (UINT
)-1)
4639 if (uStat
& (MF_DISABLED
|MF_GRAYED
))
4651 if( mesg
==WM_COMMAND
)
4653 TRACE_(accel
)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd
);
4654 SendMessageW(hWnd
, mesg
, 0x10000 | cmd
, 0L);
4656 else if( mesg
==WM_SYSCOMMAND
)
4658 TRACE_(accel
)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd
);
4659 SendMessageW(hWnd
, mesg
, cmd
, 0x00010000L
);
4663 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4664 * #0: unknown (please report!)
4665 * #1: for WM_KEYUP,WM_SYSKEYUP
4666 * #2: mouse is captured
4667 * #3: window is disabled
4668 * #4: it's a disabled system menu option
4669 * #5: it's a menu option, but window is iconic
4670 * #6: it's a menu option, but disabled
4672 TRACE_(accel
)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg
);
4674 ERR_(accel
)(" unknown reason - please report!\n");
4679 /**********************************************************************
4680 * TranslateAccelerator (USER32.@)
4681 * TranslateAcceleratorA (USER32.@)
4682 * TranslateAcceleratorW (USER32.@)
4684 INT WINAPI
TranslateAcceleratorW( HWND hWnd
, HACCEL hAccel
, LPMSG msg
)
4687 LPACCEL16 lpAccelTbl
;
4692 WARN_(accel
)("msg null; should hang here to be win compatible\n");
4695 if (!hAccel
|| !(lpAccelTbl
= (LPACCEL16
) LockResource16(HACCEL_16(hAccel
))))
4697 WARN_(accel
)("invalid accel handle=%p\n", hAccel
);
4700 if ((msg
->message
!= WM_KEYDOWN
&&
4701 msg
->message
!= WM_KEYUP
&&
4702 msg
->message
!= WM_SYSKEYDOWN
&&
4703 msg
->message
!= WM_SYSKEYUP
&&
4704 msg
->message
!= WM_CHAR
)) return 0;
4706 TRACE_(accel
)("TranslateAccelerators hAccel=%p, hWnd=%p,"
4707 "msg->hwnd=%p, msg->message=%04x, wParam=%08x, lParam=%lx\n",
4708 hAccel
,hWnd
,msg
->hwnd
,msg
->message
,msg
->wParam
,msg
->lParam
);
4713 if (translate_accelerator( hWnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
4714 lpAccelTbl
[i
].fVirt
, lpAccelTbl
[i
].key
, lpAccelTbl
[i
].cmd
))
4716 } while ((lpAccelTbl
[i
++].fVirt
& 0x80) == 0);
4717 WARN_(accel
)("couldn't translate accelerator key\n");