4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994 Alexandre Julliard
6 * Copyright 1997 Morten Welinder
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Note: the style MF_MOUSESELECT is used to mark popup items that
25 * have been selected, i.e. their popup menu is currently displayed.
26 * This is probably not the meaning this style has in MS-Windows.
30 #include "wine/port.h"
40 #include "wine/winbase16.h"
41 #include "wine/winuser16.h"
43 #include "wine/server.h"
44 #include "wine/unicode.h"
47 #include "nonclient.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(menu
);
52 WINE_DECLARE_DEBUG_CHANNEL(accel
);
54 /* internal popup menu window messages */
56 #define MM_SETMENUHANDLE (WM_USER + 0)
57 #define MM_GETMENUHANDLE (WM_USER + 1)
59 /* Menu item structure */
61 /* ----------- MENUITEMINFO Stuff ----------- */
62 UINT fType
; /* Item type. */
63 UINT fState
; /* Item state. */
64 UINT_PTR wID
; /* Item id. */
65 HMENU hSubMenu
; /* Pop-up menu. */
66 HBITMAP hCheckBit
; /* Bitmap when checked. */
67 HBITMAP hUnCheckBit
; /* Bitmap when unchecked. */
68 LPWSTR text
; /* Item text or bitmap handle. */
69 DWORD dwItemData
; /* Application defined. */
70 DWORD dwTypeData
; /* depends on fMask */
71 HBITMAP hbmpItem
; /* bitmap in win98 style menus */
72 /* ----------- Wine stuff ----------- */
73 RECT rect
; /* Item area (relative to menu window) */
74 UINT xTab
; /* X position of text after Tab */
77 /* Popup menu structure */
79 WORD wFlags
; /* Menu flags (MF_POPUP, MF_SYSMENU) */
80 WORD wMagic
; /* Magic number */
81 WORD Width
; /* Width of the whole menu */
82 WORD Height
; /* Height of the whole menu */
83 UINT nItems
; /* Number of items in the menu */
84 HWND hWnd
; /* Window containing the menu */
85 MENUITEM
*items
; /* Array of menu items */
86 UINT FocusedItem
; /* Currently focused item */
87 HWND hwndOwner
; /* window receiving the messages for ownerdraw */
88 BOOL bTimeToHide
; /* Request hiding when receiving a second click in the top-level menu item */
89 /* ------------ MENUINFO members ------ */
90 DWORD dwStyle
; /* Extended mennu style */
91 UINT cyMax
; /* max hight of the whole menu, 0 is screen hight */
92 HBRUSH hbrBack
; /* brush for menu background */
93 DWORD dwContextHelpID
;
94 DWORD dwMenuData
; /* application defined value */
95 HMENU hSysMenuOwner
; /* Handle to the dummy sys menu holder */
96 } POPUPMENU
, *LPPOPUPMENU
;
98 /* internal flags for menu tracking */
100 #define TF_ENDMENU 0x0001
101 #define TF_SUSPENDPOPUP 0x0002
102 #define TF_SKIPREMOVE 0x0004
107 HMENU hCurrentMenu
; /* current submenu (can be equal to hTopMenu)*/
108 HMENU hTopMenu
; /* initial menu */
109 HWND hOwnerWnd
; /* where notifications are sent */
113 #define MENU_MAGIC 0x554d /* 'MU' */
118 /* Internal MENU_TrackMenu() flags */
119 #define TPM_INTERNAL 0xF0000000
120 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
121 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
122 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
124 /* popup menu shade thickness */
125 #define POPUP_XSHADE 4
126 #define POPUP_YSHADE 4
128 /* Space between 2 menu bar items */
129 #define MENU_BAR_ITEMS_SPACE 12
131 /* Minimum width of a tab character */
132 #define MENU_TAB_SPACE 8
134 /* Height of a separator item */
135 #define SEPARATOR_HEIGHT 5
137 /* (other menu->FocusedItem values give the position of the focused item) */
138 #define NO_SELECTED_ITEM 0xffff
140 #define MENU_ITEM_TYPE(flags) \
141 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
143 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
144 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
145 #define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
147 #define IS_SYSTEM_MENU(menu) \
148 (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
150 #define IS_SYSTEM_POPUP(menu) \
151 ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
153 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
154 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
155 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
156 MF_POPUP | MF_SYSMENU | MF_HELP)
157 #define STATE_MASK (~TYPE_MASK)
159 /* Dimension of the menu bitmaps */
160 static WORD arrow_bitmap_width
= 0, arrow_bitmap_height
= 0;
162 static HBITMAP hStdMnArrow
= 0;
163 static HBITMAP hBmpSysMenu
= 0;
165 static HBRUSH hShadeBrush
= 0;
166 static HFONT hMenuFont
= 0;
167 static HFONT hMenuFontBold
= 0;
169 static HMENU MENU_DefSysPopup
= 0; /* Default system menu popup */
171 /* Use global popup window because there's no way 2 menus can
172 * be tracked at the same time. */
173 static HWND top_popup
;
175 /* Flag set by EndMenu() to force an exit from menu tracking */
176 static BOOL fEndMenu
= FALSE
;
178 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
181 /*********************************************************************
182 * menu class descriptor
184 const struct builtin_class_descr MENU_builtin_class
=
186 POPUPMENU_CLASS_ATOM
, /* name */
187 CS_GLOBALCLASS
| CS_SAVEBITS
, /* style */
188 NULL
, /* procA (winproc is Unicode only) */
189 PopupMenuWndProc
, /* procW */
190 sizeof(HMENU
), /* extra */
191 IDC_ARROWA
, /* cursor */
192 COLOR_MENU
+1 /* brush */
196 /***********************************************************************
197 * debug_print_menuitem
199 * Print a menuitem in readable form.
202 #define debug_print_menuitem(pre, mp, post) \
203 if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
205 #define MENUOUT(text) \
206 DPRINTF("%s%s", (count++ ? "," : ""), (text))
208 #define MENUFLAG(bit,text) \
210 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
213 static void do_debug_print_menuitem(const char *prefix
, MENUITEM
* mp
,
216 TRACE("%s ", prefix
);
218 UINT flags
= mp
->fType
;
219 int type
= MENU_ITEM_TYPE(flags
);
220 DPRINTF( "{ ID=0x%x", mp
->wID
);
221 if (flags
& MF_POPUP
)
222 DPRINTF( ", Sub=0x%x", mp
->hSubMenu
);
226 if (type
== MFT_STRING
)
228 else if (type
== MFT_SEPARATOR
)
230 else if (type
== MFT_OWNERDRAW
)
232 else if (type
== MFT_BITMAP
)
238 MENUFLAG(MF_POPUP
, "pop");
239 MENUFLAG(MFT_MENUBARBREAK
, "barbrk");
240 MENUFLAG(MFT_MENUBREAK
, "brk");
241 MENUFLAG(MFT_RADIOCHECK
, "radio");
242 MENUFLAG(MFT_RIGHTORDER
, "rorder");
243 MENUFLAG(MF_SYSMENU
, "sys");
244 MENUFLAG(MFT_RIGHTJUSTIFY
, "right"); /* same as MF_HELP */
247 DPRINTF( "+0x%x", flags
);
252 DPRINTF( ", State=");
253 MENUFLAG(MFS_GRAYED
, "grey");
254 MENUFLAG(MFS_DEFAULT
, "default");
255 MENUFLAG(MFS_DISABLED
, "dis");
256 MENUFLAG(MFS_CHECKED
, "check");
257 MENUFLAG(MFS_HILITE
, "hi");
258 MENUFLAG(MF_USECHECKBITMAPS
, "usebit");
259 MENUFLAG(MF_MOUSESELECT
, "mouse");
261 DPRINTF( "+0x%x", flags
);
264 DPRINTF( ", Chk=0x%x", mp
->hCheckBit
);
266 DPRINTF( ", Unc=0x%x", mp
->hUnCheckBit
);
268 if (type
== MFT_STRING
) {
270 DPRINTF( ", Text=%s", debugstr_w(mp
->text
));
272 DPRINTF( ", Text=Null");
273 } else if (mp
->text
== NULL
)
276 DPRINTF( ", Text=%p", mp
->text
);
278 DPRINTF( ", ItemData=0x%08lx", mp
->dwItemData
);
284 DPRINTF(" %s\n", postfix
);
291 /***********************************************************************
294 * Validate the given menu handle and returns the menu structure pointer.
296 static POPUPMENU
*MENU_GetMenu(HMENU hMenu
)
298 POPUPMENU
*menu
= USER_HEAP_LIN_ADDR(hMenu
);
299 if (!menu
|| menu
->wMagic
!= MENU_MAGIC
)
301 WARN("invalid menu handle=%x, ptr=%p, magic=%x\n", hMenu
, menu
, menu
? menu
->wMagic
:0);
307 /***********************************************************************
310 * Get the system menu of a window
312 static HMENU
get_win_sys_menu( HWND hwnd
)
315 WND
*win
= WIN_FindWndPtr( hwnd
);
319 WIN_ReleaseWndPtr( win
);
324 /***********************************************************************
327 * Return the default system menu.
329 static HMENU
MENU_CopySysPopup(void)
331 HMENU hMenu
= LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU");
334 POPUPMENU
* menu
= MENU_GetMenu(hMenu
);
335 menu
->wFlags
|= MF_SYSMENU
| MF_POPUP
;
336 SetMenuDefaultItem(hMenu
, SC_CLOSE
, FALSE
);
339 ERR("Unable to load default system menu\n" );
341 TRACE("returning %x.\n", hMenu
);
347 /**********************************************************************
350 * Create a copy of the system menu. System menu in Windows is
351 * a special menu bar with the single entry - system menu popup.
352 * This popup is presented to the outside world as a "system menu".
353 * However, the real system menu handle is sometimes seen in the
354 * WM_MENUSELECT parameters (and Word 6 likes it this way).
356 HMENU
MENU_GetSysMenu( HWND hWnd
, HMENU hPopupMenu
)
360 TRACE("loading system menu, hWnd %04x, hPopupMenu %04x\n", hWnd
, hPopupMenu
);
361 if ((hMenu
= CreateMenu()))
363 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
364 menu
->wFlags
= MF_SYSMENU
;
365 menu
->hWnd
= WIN_GetFullHandle( hWnd
);
366 TRACE("hWnd %04x (hMenu %04x)\n", menu
->hWnd
, hMenu
);
368 if (hPopupMenu
== (HMENU
)(-1))
369 hPopupMenu
= MENU_CopySysPopup();
370 else if( !hPopupMenu
) hPopupMenu
= MENU_DefSysPopup
;
374 InsertMenuA( hMenu
, -1, MF_SYSMENU
| MF_POPUP
| MF_BYPOSITION
, hPopupMenu
, NULL
);
376 menu
->items
[0].fType
= MF_SYSMENU
| MF_POPUP
;
377 menu
->items
[0].fState
= 0;
378 if ((menu
= MENU_GetMenu(hPopupMenu
))) menu
->wFlags
|= MF_SYSMENU
;
380 TRACE("hMenu=%04x (hPopup %04x)\n", hMenu
, hPopupMenu
);
383 DestroyMenu( hMenu
);
385 ERR("failed to load system menu!\n");
390 /***********************************************************************
393 * Menus initialisation.
398 NONCLIENTMETRICSA ncm
;
400 static unsigned char shade_bits
[16] = { 0x55, 0, 0xAA, 0,
405 /* Load menu bitmaps */
406 hStdMnArrow
= LoadBitmapA(0, MAKEINTRESOURCEA(OBM_MNARROW
));
407 /* Load system buttons bitmaps */
408 hBmpSysMenu
= LoadBitmapA(0, MAKEINTRESOURCEA(OBM_CLOSE
));
413 GetObjectA( hStdMnArrow
, sizeof(bm
), &bm
);
414 arrow_bitmap_width
= bm
.bmWidth
;
415 arrow_bitmap_height
= bm
.bmHeight
;
419 if (! (hBitmap
= CreateBitmap( 8, 8, 1, 1, shade_bits
)))
422 if(!(hShadeBrush
= CreatePatternBrush( hBitmap
)))
425 DeleteObject( hBitmap
);
426 if (!(MENU_DefSysPopup
= MENU_CopySysPopup()))
429 ncm
.cbSize
= sizeof (NONCLIENTMETRICSA
);
430 if (!(SystemParametersInfoA(SPI_GETNONCLIENTMETRICS
, sizeof(NONCLIENTMETRICSA
), &ncm
, 0)))
433 if (!(hMenuFont
= CreateFontIndirectA( &ncm
.lfMenuFont
)))
436 ncm
.lfMenuFont
.lfWeight
+= 300;
437 if ( ncm
.lfMenuFont
.lfWeight
> 1000)
438 ncm
.lfMenuFont
.lfWeight
= 1000;
440 if (!(hMenuFontBold
= CreateFontIndirectA( &ncm
.lfMenuFont
)))
446 /***********************************************************************
447 * MENU_InitSysMenuPopup
449 * Grey the appropriate items in System menu.
451 static void MENU_InitSysMenuPopup( HMENU hmenu
, DWORD style
, DWORD clsStyle
)
455 gray
= !(style
& WS_THICKFRAME
) || (style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
456 EnableMenuItem( hmenu
, SC_SIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
457 gray
= ((style
& WS_MAXIMIZE
) != 0);
458 EnableMenuItem( hmenu
, SC_MOVE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
459 gray
= !(style
& WS_MINIMIZEBOX
) || (style
& WS_MINIMIZE
);
460 EnableMenuItem( hmenu
, SC_MINIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
461 gray
= !(style
& WS_MAXIMIZEBOX
) || (style
& WS_MAXIMIZE
);
462 EnableMenuItem( hmenu
, SC_MAXIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
463 gray
= !(style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
464 EnableMenuItem( hmenu
, SC_RESTORE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
465 gray
= (clsStyle
& CS_NOCLOSE
) != 0;
467 /* The menu item must keep its state if it's disabled */
469 EnableMenuItem( hmenu
, SC_CLOSE
, MF_GRAYED
);
473 /******************************************************************************
475 * UINT MENU_GetStartOfNextColumn(
478 *****************************************************************************/
480 static UINT
MENU_GetStartOfNextColumn(
483 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
487 return NO_SELECTED_ITEM
;
489 i
= menu
->FocusedItem
+ 1;
490 if( i
== NO_SELECTED_ITEM
)
493 for( ; i
< menu
->nItems
; ++i
) {
494 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
498 return NO_SELECTED_ITEM
;
502 /******************************************************************************
504 * UINT MENU_GetStartOfPrevColumn(
507 *****************************************************************************/
509 static UINT
MENU_GetStartOfPrevColumn(
512 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
516 return NO_SELECTED_ITEM
;
518 if( menu
->FocusedItem
== 0 || menu
->FocusedItem
== NO_SELECTED_ITEM
)
519 return NO_SELECTED_ITEM
;
521 /* Find the start of the column */
523 for(i
= menu
->FocusedItem
; i
!= 0 &&
524 !(menu
->items
[i
].fType
& MF_MENUBARBREAK
);
528 return NO_SELECTED_ITEM
;
530 for(--i
; i
!= 0; --i
) {
531 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
535 TRACE("ret %d.\n", i
);
542 /***********************************************************************
545 * Find a menu item. Return a pointer on the item, and modifies *hmenu
546 * in case the item was in a sub-menu.
548 static MENUITEM
*MENU_FindItem( HMENU
*hmenu
, UINT
*nPos
, UINT wFlags
)
553 if (((*hmenu
)==0xffff) || (!(menu
= MENU_GetMenu(*hmenu
)))) return NULL
;
554 if (wFlags
& MF_BYPOSITION
)
556 if (*nPos
>= menu
->nItems
) return NULL
;
557 return &menu
->items
[*nPos
];
561 MENUITEM
*item
= menu
->items
;
562 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
564 if (item
->wID
== *nPos
)
569 else if (item
->fType
& MF_POPUP
)
571 HMENU hsubmenu
= item
->hSubMenu
;
572 MENUITEM
*subitem
= MENU_FindItem( &hsubmenu
, nPos
, wFlags
);
584 /***********************************************************************
587 * Find a Sub menu. Return the position of the submenu, and modifies
588 * *hmenu in case it is found in another sub-menu.
589 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
591 UINT
MENU_FindSubMenu( HMENU
*hmenu
, HMENU hSubTarget
)
596 if (((*hmenu
)==0xffff) ||
597 (!(menu
= MENU_GetMenu(*hmenu
))))
598 return NO_SELECTED_ITEM
;
600 for (i
= 0; i
< menu
->nItems
; i
++, item
++) {
601 if(!(item
->fType
& MF_POPUP
)) continue;
602 if (item
->hSubMenu
== hSubTarget
) {
606 HMENU hsubmenu
= item
->hSubMenu
;
607 UINT pos
= MENU_FindSubMenu( &hsubmenu
, hSubTarget
);
608 if (pos
!= NO_SELECTED_ITEM
) {
614 return NO_SELECTED_ITEM
;
617 /***********************************************************************
620 static void MENU_FreeItemData( MENUITEM
* item
)
623 if (IS_STRING_ITEM(item
->fType
) && item
->text
)
624 HeapFree( GetProcessHeap(), 0, item
->text
);
627 /***********************************************************************
628 * MENU_FindItemByCoords
630 * Find the item at the specified coordinates (screen coords). Does
631 * not work for child windows and therefore should not be called for
632 * an arbitrary system menu.
634 static MENUITEM
*MENU_FindItemByCoords( POPUPMENU
*menu
,
635 POINT pt
, UINT
*pos
)
641 if (!GetWindowRect(menu
->hWnd
,&wrect
)) return NULL
;
642 pt
.x
-= wrect
.left
;pt
.y
-= wrect
.top
;
644 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
646 if ((pt
.x
>= item
->rect
.left
) && (pt
.x
< item
->rect
.right
) &&
647 (pt
.y
>= item
->rect
.top
) && (pt
.y
< item
->rect
.bottom
))
657 /***********************************************************************
660 * Find the menu item selected by a key press.
661 * Return item id, -1 if none, -2 if we should close the menu.
663 static UINT
MENU_FindItemByKey( HWND hwndOwner
, HMENU hmenu
,
664 UINT key
, BOOL forceMenuChar
)
666 TRACE("\tlooking for '%c' in [%04x]\n", (char)key
, (UINT16
)hmenu
);
668 if (!IsMenu( hmenu
)) hmenu
= GetSubMenu( get_win_sys_menu(hwndOwner
), 0);
672 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
673 MENUITEM
*item
= menu
->items
;
681 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
683 if (IS_STRING_ITEM(item
->fType
) && item
->text
)
685 WCHAR
*p
= item
->text
- 2;
688 p
= strchrW (p
+ 2, '&');
690 while (p
!= NULL
&& p
[1] == '&');
691 if (p
&& (toupper(p
[1]) == key
)) return i
;
695 menuchar
= SendMessageA( hwndOwner
, WM_MENUCHAR
,
696 MAKEWPARAM( key
, menu
->wFlags
), hmenu
);
697 if (HIWORD(menuchar
) == 2) return LOWORD(menuchar
);
698 if (HIWORD(menuchar
) == 1) return (UINT
)(-2);
704 /***********************************************************************
705 * MENU_GetBitmapItemSize
707 * Get the size of a bitmap item.
709 static void MENU_GetBitmapItemSize( UINT id
, DWORD data
, SIZE
*size
)
712 HBITMAP bmp
= (HBITMAP
)id
;
714 size
->cx
= size
->cy
= 0;
716 /* check if there is a magic menu item associated with this item */
717 if (id
&& IS_MAGIC_ITEM( id
))
728 case HBMMENU_MBAR_RESTORE
:
729 case HBMMENU_MBAR_MINIMIZE
:
730 case HBMMENU_MBAR_MINIMIZE_D
:
731 case HBMMENU_MBAR_CLOSE
:
732 case HBMMENU_MBAR_CLOSE_D
:
733 size
->cx
= GetSystemMetrics( SM_CXSIZE
);
734 size
->cy
= GetSystemMetrics( SM_CYSIZE
);
736 case HBMMENU_CALLBACK
:
737 case HBMMENU_POPUP_CLOSE
:
738 case HBMMENU_POPUP_RESTORE
:
739 case HBMMENU_POPUP_MAXIMIZE
:
740 case HBMMENU_POPUP_MINIMIZE
:
742 FIXME("Magic 0x%08x not implemented\n", id
);
746 if (GetObjectA(bmp
, sizeof(bm
), &bm
))
748 size
->cx
= bm
.bmWidth
;
749 size
->cy
= bm
.bmHeight
;
753 /***********************************************************************
754 * MENU_DrawBitmapItem
756 * Draw a bitmap item.
758 static void MENU_DrawBitmapItem( HDC hdc
, MENUITEM
*lpitem
, const RECT
*rect
, BOOL menuBar
)
763 HBITMAP bmp
= (HBITMAP
)lpitem
->text
;
764 int w
= rect
->right
- rect
->left
;
765 int h
= rect
->bottom
- rect
->top
;
769 /* Check if there is a magic menu item associated with this item */
770 if (lpitem
->text
&& IS_MAGIC_ITEM(lpitem
->text
))
775 switch(LOWORD(lpitem
->text
))
778 if (lpitem
->dwItemData
)
780 bmp
= (HBITMAP
)lpitem
->dwItemData
;
781 if (!GetObjectA( bmp
, sizeof(bm
), &bm
)) return;
786 if (!GetObjectA( bmp
, sizeof(bm
), &bm
)) return;
787 /* only use right half of the bitmap */
788 bmp_xoffset
= bm
.bmWidth
/ 2;
789 bm
.bmWidth
-= bmp_xoffset
;
792 case HBMMENU_MBAR_RESTORE
:
793 flags
= DFCS_CAPTIONRESTORE
;
795 case HBMMENU_MBAR_MINIMIZE
:
796 flags
= DFCS_CAPTIONMIN
;
798 case HBMMENU_MBAR_MINIMIZE_D
:
799 flags
= DFCS_CAPTIONMIN
| DFCS_INACTIVE
;
801 case HBMMENU_MBAR_CLOSE
:
802 flags
= DFCS_CAPTIONCLOSE
;
804 case HBMMENU_MBAR_CLOSE_D
:
805 flags
= DFCS_CAPTIONCLOSE
| DFCS_INACTIVE
;
807 case HBMMENU_CALLBACK
:
808 case HBMMENU_POPUP_CLOSE
:
809 case HBMMENU_POPUP_RESTORE
:
810 case HBMMENU_POPUP_MAXIMIZE
:
811 case HBMMENU_POPUP_MINIMIZE
:
813 FIXME("Magic 0x%08x not implemented\n", LOWORD(lpitem
->text
));
817 InflateRect( &r
, -1, -1 );
818 if (lpitem
->fState
& MF_HILITE
) flags
|= DFCS_PUSHED
;
819 DrawFrameControl( hdc
, &r
, DFC_CAPTION
, flags
);
823 if (!bmp
|| !GetObjectA( bmp
, sizeof(bm
), &bm
)) return;
826 hdcMem
= CreateCompatibleDC( hdc
);
827 SelectObject( hdcMem
, bmp
);
829 /* handle fontsize > bitmap_height */
830 top
= (h
>bm
.bmHeight
) ? rect
->top
+(h
-bm
.bmHeight
)/2 : rect
->top
;
832 if (TWEAK_WineLook
== WIN95_LOOK
) {
833 rop
=((lpitem
->fState
& MF_HILITE
) && !IS_MAGIC_ITEM(lpitem
->text
)) ? NOTSRCCOPY
: SRCCOPY
;
834 if ((lpitem
->fState
& MF_HILITE
) && IS_BITMAP_ITEM(lpitem
->fType
))
835 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
839 rop
=((lpitem
->fState
& MF_HILITE
) && !IS_MAGIC_ITEM(lpitem
->text
) && (!menuBar
)) ? MERGEPAINT
: SRCCOPY
;
841 BitBlt( hdc
, left
, top
, w
, h
, hdcMem
, bmp_xoffset
, 0, rop
);
846 /***********************************************************************
849 * Calculate the size of the menu item and store it in lpitem->rect.
851 static void MENU_CalcItemSize( HDC hdc
, MENUITEM
*lpitem
, HWND hwndOwner
,
852 INT orgX
, INT orgY
, BOOL menuBar
)
855 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
857 TRACE("dc=0x%04x owner=0x%04x (%d,%d)\n", hdc
, hwndOwner
, orgX
, orgY
);
858 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem
,
859 (menuBar
? " (MenuBar)" : ""));
861 SetRect( &lpitem
->rect
, orgX
, orgY
, orgX
, orgY
);
863 if (lpitem
->fType
& MF_OWNERDRAW
)
866 ** Experimentation under Windows reveals that an owner-drawn
867 ** menu is expected to return the size of the content part of
868 ** the menu item, not including the checkmark nor the submenu
869 ** arrow. Windows adds those values itself and returns the
870 ** enlarged rectangle on subsequent WM_DRAWITEM messages.
872 MEASUREITEMSTRUCT mis
;
873 mis
.CtlType
= ODT_MENU
;
875 mis
.itemID
= lpitem
->wID
;
876 mis
.itemData
= (DWORD
)lpitem
->dwItemData
;
879 SendMessageA( hwndOwner
, WM_MEASUREITEM
, 0, (LPARAM
)&mis
);
880 lpitem
->rect
.right
+= mis
.itemWidth
;
884 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
887 /* under at least win95 you seem to be given a standard
888 height for the menu and the height value is ignored */
890 if (TWEAK_WineLook
== WIN31_LOOK
)
891 lpitem
->rect
.bottom
+= GetSystemMetrics(SM_CYMENU
);
893 lpitem
->rect
.bottom
+= GetSystemMetrics(SM_CYMENU
)-1;
896 lpitem
->rect
.bottom
+= mis
.itemHeight
;
898 TRACE("id=%04x size=%dx%d\n",
899 lpitem
->wID
, mis
.itemWidth
, mis
.itemHeight
);
900 /* Fall through to get check/arrow width calculation. */
903 if (lpitem
->fType
& MF_SEPARATOR
)
905 lpitem
->rect
.bottom
+= SEPARATOR_HEIGHT
;
911 lpitem
->rect
.right
+= 2 * check_bitmap_width
;
912 if (lpitem
->fType
& MF_POPUP
)
913 lpitem
->rect
.right
+= arrow_bitmap_width
;
916 if (lpitem
->fType
& MF_OWNERDRAW
)
919 if (IS_BITMAP_ITEM(lpitem
->fType
))
923 MENU_GetBitmapItemSize( (int)lpitem
->text
, lpitem
->dwItemData
, &size
);
924 lpitem
->rect
.right
+= size
.cx
;
925 lpitem
->rect
.bottom
+= size
.cy
;
926 if (TWEAK_WineLook
== WIN98_LOOK
)
928 /* Leave space for the sunken border */
929 lpitem
->rect
.right
+= 2;
930 lpitem
->rect
.bottom
+= 2;
935 /* it must be a text item - unless it's the system menu */
936 if (!(lpitem
->fType
& MF_SYSMENU
) && IS_STRING_ITEM( lpitem
->fType
))
939 GetTextExtentPoint32W(hdc
, lpitem
->text
, strlenW(lpitem
->text
), &size
);
941 lpitem
->rect
.right
+= size
.cx
;
942 if (TWEAK_WineLook
== WIN31_LOOK
)
943 lpitem
->rect
.bottom
+= max( size
.cy
, GetSystemMetrics(SM_CYMENU
) );
945 lpitem
->rect
.bottom
+= max(size
.cy
, GetSystemMetrics(SM_CYMENU
)-1);
950 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
952 else if ((p
= strchrW( lpitem
->text
, '\t' )) != NULL
)
954 /* Item contains a tab (only meaningful in popup menus) */
955 GetTextExtentPoint32W(hdc
, lpitem
->text
, (int)(p
- lpitem
->text
) , &size
);
956 lpitem
->xTab
= check_bitmap_width
+ MENU_TAB_SPACE
+ size
.cx
;
957 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
961 if (strchrW( lpitem
->text
, '\b' ))
962 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
963 lpitem
->xTab
= lpitem
->rect
.right
- check_bitmap_width
964 - arrow_bitmap_width
;
967 TRACE("(%d,%d)-(%d,%d)\n", lpitem
->rect
.left
, lpitem
->rect
.top
, lpitem
->rect
.right
, lpitem
->rect
.bottom
);
971 /***********************************************************************
972 * MENU_PopupMenuCalcSize
974 * Calculate the size of a popup menu.
976 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop
, HWND hwndOwner
)
981 int orgX
, orgY
, maxX
, maxTab
, maxTabWidth
;
983 lppop
->Width
= lppop
->Height
= 0;
984 if (lppop
->nItems
== 0) return;
987 SelectObject( hdc
, hMenuFont
);
990 maxX
= (TWEAK_WineLook
== WIN31_LOOK
) ? GetSystemMetrics(SM_CXBORDER
) : 2+1 ;
992 while (start
< lppop
->nItems
)
994 lpitem
= &lppop
->items
[start
];
996 orgY
= (TWEAK_WineLook
== WIN31_LOOK
) ? GetSystemMetrics(SM_CYBORDER
) : 2;
998 maxTab
= maxTabWidth
= 0;
1000 /* Parse items until column break or end of menu */
1001 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
1004 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
1006 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, FALSE
);
1008 if (lpitem
->fType
& MF_MENUBARBREAK
) orgX
++;
1009 maxX
= max( maxX
, lpitem
->rect
.right
);
1010 orgY
= lpitem
->rect
.bottom
;
1011 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
1013 maxTab
= max( maxTab
, lpitem
->xTab
);
1014 maxTabWidth
= max(maxTabWidth
,lpitem
->rect
.right
-lpitem
->xTab
);
1018 /* Finish the column (set all items to the largest width found) */
1019 maxX
= max( maxX
, maxTab
+ maxTabWidth
);
1020 for (lpitem
= &lppop
->items
[start
]; start
< i
; start
++, lpitem
++)
1022 lpitem
->rect
.right
= maxX
;
1023 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
1024 lpitem
->xTab
= maxTab
;
1027 lppop
->Height
= max( lppop
->Height
, orgY
);
1030 lppop
->Width
= maxX
;
1032 /* space for 3d border */
1033 if(TWEAK_WineLook
> WIN31_LOOK
)
1039 ReleaseDC( 0, hdc
);
1043 /***********************************************************************
1044 * MENU_MenuBarCalcSize
1046 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1047 * height is off by 1 pixel which causes lengthy window relocations when
1048 * active document window is maximized/restored.
1050 * Calculate the size of the menu bar.
1052 static void MENU_MenuBarCalcSize( HDC hdc
, LPRECT lprect
,
1053 LPPOPUPMENU lppop
, HWND hwndOwner
)
1056 int start
, i
, orgX
, orgY
, maxY
, helpPos
;
1058 if ((lprect
== NULL
) || (lppop
== NULL
)) return;
1059 if (lppop
->nItems
== 0) return;
1060 TRACE("left=%d top=%d right=%d bottom=%d\n",
1061 lprect
->left
, lprect
->top
, lprect
->right
, lprect
->bottom
);
1062 lppop
->Width
= lprect
->right
- lprect
->left
;
1064 maxY
= lprect
->top
+1;
1067 while (start
< lppop
->nItems
)
1069 lpitem
= &lppop
->items
[start
];
1070 orgX
= lprect
->left
;
1073 /* Parse items until line break or end of menu */
1074 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
1076 if ((helpPos
== -1) && (lpitem
->fType
& MF_RIGHTJUSTIFY
)) helpPos
= i
;
1078 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
1080 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
1082 debug_print_menuitem (" item: ", lpitem
, "");
1083 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, TRUE
);
1085 if (lpitem
->rect
.right
> lprect
->right
)
1087 if (i
!= start
) break;
1088 else lpitem
->rect
.right
= lprect
->right
;
1090 maxY
= max( maxY
, lpitem
->rect
.bottom
);
1091 orgX
= lpitem
->rect
.right
;
1094 /* Finish the line (set all items to the largest height found) */
1095 while (start
< i
) lppop
->items
[start
++].rect
.bottom
= maxY
;
1098 lprect
->bottom
= maxY
;
1099 lppop
->Height
= lprect
->bottom
- lprect
->top
;
1101 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1102 /* the last item (if several lines, only move the last line) */
1103 lpitem
= &lppop
->items
[lppop
->nItems
-1];
1104 orgY
= lpitem
->rect
.top
;
1105 orgX
= lprect
->right
;
1106 for (i
= lppop
->nItems
- 1; i
>= helpPos
; i
--, lpitem
--) {
1107 if ( (helpPos
==-1) || (helpPos
>i
) )
1109 if (lpitem
->rect
.top
!= orgY
) break; /* Other line */
1110 if (lpitem
->rect
.right
>= orgX
) break; /* Too far right already */
1111 lpitem
->rect
.left
+= orgX
- lpitem
->rect
.right
;
1112 lpitem
->rect
.right
= orgX
;
1113 orgX
= lpitem
->rect
.left
;
1117 /***********************************************************************
1120 * Draw a single menu item.
1122 static void MENU_DrawMenuItem( HWND hwnd
, HMENU hmenu
, HWND hwndOwner
, HDC hdc
, MENUITEM
*lpitem
,
1123 UINT height
, BOOL menuBar
, UINT odaction
)
1127 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem
, "");
1129 if (lpitem
->fType
& MF_SYSMENU
)
1131 if( !IsIconic(hwnd
) ) {
1132 if (TWEAK_WineLook
> WIN31_LOOK
)
1133 NC_DrawSysButton95( hwnd
, hdc
,
1135 (MF_HILITE
| MF_MOUSESELECT
) );
1137 NC_DrawSysButton( hwnd
, hdc
,
1139 (MF_HILITE
| MF_MOUSESELECT
) );
1145 if (lpitem
->fType
& MF_OWNERDRAW
)
1148 ** Experimentation under Windows reveals that an owner-drawn
1149 ** menu is given the rectangle which includes the space it requested
1150 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1151 ** and a popup-menu arrow. This is the value of lpitem->rect.
1152 ** Windows will leave all drawing to the application except for
1153 ** the popup-menu arrow. Windows always draws that itself, after
1154 ** the menu owner has finished drawing.
1158 dis
.CtlType
= ODT_MENU
;
1160 dis
.itemID
= lpitem
->wID
;
1161 dis
.itemData
= (DWORD
)lpitem
->dwItemData
;
1163 if (lpitem
->fState
& MF_CHECKED
) dis
.itemState
|= ODS_CHECKED
;
1164 if (lpitem
->fState
& MF_GRAYED
) dis
.itemState
|= ODS_GRAYED
;
1165 if (lpitem
->fState
& MF_HILITE
) dis
.itemState
|= ODS_SELECTED
;
1166 dis
.itemAction
= odaction
; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1167 dis
.hwndItem
= (HWND
)hmenu
;
1169 dis
.rcItem
= lpitem
->rect
;
1170 TRACE("Ownerdraw: owner=%04x itemID=%d, itemState=%d, itemAction=%d, "
1171 "hwndItem=%04x, hdc=%04x, rcItem={%d,%d,%d,%d}\n", hwndOwner
,
1172 dis
.itemID
, dis
.itemState
, dis
.itemAction
, dis
.hwndItem
,
1173 dis
.hDC
, dis
.rcItem
.left
, dis
.rcItem
.top
, dis
.rcItem
.right
,
1175 SendMessageA( hwndOwner
, WM_DRAWITEM
, 0, (LPARAM
)&dis
);
1176 /* Fall through to draw popup-menu arrow */
1179 TRACE("rect={%d,%d,%d,%d}\n", lpitem
->rect
.left
, lpitem
->rect
.top
,
1180 lpitem
->rect
.right
,lpitem
->rect
.bottom
);
1182 if (menuBar
&& (lpitem
->fType
& MF_SEPARATOR
)) return;
1184 rect
= lpitem
->rect
;
1186 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1188 if (lpitem
->fState
& MF_HILITE
)
1190 if(TWEAK_WineLook
== WIN98_LOOK
)
1193 DrawEdge(hdc
, &rect
, BDR_SUNKENOUTER
, BF_RECT
);
1195 FillRect(hdc
, &rect
, GetSysColorBrush(COLOR_HIGHLIGHT
));
1197 else /* Not Win98 Look */
1199 if(!IS_BITMAP_ITEM(lpitem
->fType
))
1200 FillRect(hdc
, &rect
, GetSysColorBrush(COLOR_HIGHLIGHT
));
1204 FillRect( hdc
, &rect
, GetSysColorBrush(COLOR_MENU
) );
1207 SetBkMode( hdc
, TRANSPARENT
);
1209 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1211 /* vertical separator */
1212 if (!menuBar
&& (lpitem
->fType
& MF_MENUBARBREAK
))
1214 if (TWEAK_WineLook
> WIN31_LOOK
)
1218 rc
.bottom
= height
- 3;
1219 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_LEFT
);
1223 SelectObject( hdc
, SYSCOLOR_GetPen(COLOR_WINDOWFRAME
) );
1224 MoveToEx( hdc
, rect
.left
, 0, NULL
);
1225 LineTo( hdc
, rect
.left
, height
);
1229 /* horizontal separator */
1230 if (lpitem
->fType
& MF_SEPARATOR
)
1232 if (TWEAK_WineLook
> WIN31_LOOK
)
1237 rc
.top
+= SEPARATOR_HEIGHT
/ 2;
1238 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_TOP
);
1242 SelectObject( hdc
, SYSCOLOR_GetPen(COLOR_WINDOWFRAME
) );
1243 MoveToEx( hdc
, rect
.left
, rect
.top
+ SEPARATOR_HEIGHT
/2, NULL
);
1244 LineTo( hdc
, rect
.right
, rect
.top
+ SEPARATOR_HEIGHT
/2 );
1252 if (lpitem
->fState
& MF_HILITE
)
1254 if(TWEAK_WineLook
== WIN98_LOOK
)
1257 SetTextColor(hdc
, GetSysColor(COLOR_MENUTEXT
));
1258 SetBkColor(hdc
, GetSysColor(COLOR_MENU
));
1260 if(lpitem
->fState
& MF_GRAYED
)
1261 SetTextColor(hdc
, GetSysColor(COLOR_GRAYTEXT
));
1263 SetTextColor(hdc
, GetSysColor(COLOR_HIGHLIGHTTEXT
));
1264 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1267 else /* Not Win98 Look */
1269 SetTextColor(hdc
, GetSysColor(COLOR_HIGHLIGHTTEXT
));
1270 if(!IS_BITMAP_ITEM(lpitem
->fType
))
1271 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1276 if (lpitem
->fState
& MF_GRAYED
)
1277 SetTextColor( hdc
, GetSysColor( COLOR_GRAYTEXT
) );
1279 SetTextColor( hdc
, GetSysColor( COLOR_MENUTEXT
) );
1280 SetBkColor( hdc
, GetSysColor( COLOR_MENU
) );
1283 /* helper lines for debugging */
1284 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1285 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1286 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1287 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1292 INT y
= rect
.top
+ rect
.bottom
;
1293 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
1294 UINT check_bitmap_height
= GetSystemMetrics( SM_CYMENUCHECK
);
1296 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1298 /* Draw the check mark
1301 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1303 HBITMAP bm
= (lpitem
->fState
& MF_CHECKED
) ? lpitem
->hCheckBit
: lpitem
->hUnCheckBit
;
1304 if (bm
) /* we have a custom bitmap */
1306 HDC hdcMem
= CreateCompatibleDC( hdc
);
1307 SelectObject( hdcMem
, bm
);
1308 BitBlt( hdc
, rect
.left
, (y
- check_bitmap_height
) / 2,
1309 check_bitmap_width
, check_bitmap_height
,
1310 hdcMem
, 0, 0, SRCCOPY
);
1313 else if (lpitem
->fState
& MF_CHECKED
) /* standard bitmaps */
1316 HBITMAP bm
= CreateBitmap( check_bitmap_width
, check_bitmap_height
, 1, 1, NULL
);
1317 HDC hdcMem
= CreateCompatibleDC( hdc
);
1318 SelectObject( hdcMem
, bm
);
1319 SetRect( &r
, 0, 0, check_bitmap_width
, check_bitmap_height
);
1320 DrawFrameControl( hdcMem
, &r
, DFC_MENU
,
1321 (lpitem
->fType
& MFT_RADIOCHECK
) ?
1322 DFCS_MENUBULLET
: DFCS_MENUCHECK
);
1323 BitBlt( hdc
, rect
.left
, (y
- r
.bottom
) / 2, r
.right
, r
.bottom
,
1324 hdcMem
, 0, 0, SRCCOPY
);
1330 /* Draw the popup-menu arrow */
1331 if (lpitem
->fType
& MF_POPUP
)
1333 HDC hdcMem
= CreateCompatibleDC( hdc
);
1334 HBITMAP hOrigBitmap
;
1336 hOrigBitmap
= SelectObject( hdcMem
, hStdMnArrow
);
1337 BitBlt( hdc
, rect
.right
- arrow_bitmap_width
- 1,
1338 (y
- arrow_bitmap_height
) / 2,
1339 arrow_bitmap_width
, arrow_bitmap_height
,
1340 hdcMem
, 0, 0, SRCCOPY
);
1341 SelectObject( hdcMem
, hOrigBitmap
);
1345 rect
.left
+= check_bitmap_width
;
1346 rect
.right
-= arrow_bitmap_width
;
1349 /* Done for owner-drawn */
1350 if (lpitem
->fType
& MF_OWNERDRAW
)
1353 /* Draw the item text or bitmap */
1354 if (IS_BITMAP_ITEM(lpitem
->fType
))
1356 MENU_DrawBitmapItem( hdc
, lpitem
, &rect
, menuBar
);
1360 /* No bitmap - process text if present */
1361 else if (IS_STRING_ITEM(lpitem
->fType
))
1366 UINT uFormat
= (menuBar
) ?
1367 DT_CENTER
| DT_VCENTER
| DT_SINGLELINE
:
1368 DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1370 if ( lpitem
->fState
& MFS_DEFAULT
)
1372 hfontOld
= SelectObject( hdc
, hMenuFontBold
);
1377 rect
.left
+= MENU_BAR_ITEMS_SPACE
/ 2;
1378 rect
.right
-= MENU_BAR_ITEMS_SPACE
/ 2;
1381 for (i
= 0; lpitem
->text
[i
]; i
++)
1382 if ((lpitem
->text
[i
] == '\t') || (lpitem
->text
[i
] == '\b'))
1385 if( (TWEAK_WineLook
!= WIN31_LOOK
) && (lpitem
->fState
& MF_GRAYED
))
1387 if (!(lpitem
->fState
& MF_HILITE
) )
1389 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1390 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1391 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1392 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1394 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1397 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1399 /* paint the shortcut text */
1400 if (!menuBar
&& lpitem
->text
[i
]) /* There's a tab or flush-right char */
1402 if (lpitem
->text
[i
] == '\t')
1404 rect
.left
= lpitem
->xTab
;
1405 uFormat
= DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1409 uFormat
= DT_RIGHT
| DT_VCENTER
| DT_SINGLELINE
;
1412 if( (TWEAK_WineLook
!= WIN31_LOOK
) && (lpitem
->fState
& MF_GRAYED
))
1414 if (!(lpitem
->fState
& MF_HILITE
) )
1416 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1417 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1418 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1419 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1421 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1423 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1427 SelectObject (hdc
, hfontOld
);
1432 /***********************************************************************
1433 * MENU_DrawPopupMenu
1435 * Paint a popup menu.
1437 static void MENU_DrawPopupMenu( HWND hwnd
, HDC hdc
, HMENU hmenu
)
1439 HBRUSH hPrevBrush
= 0;
1442 TRACE("wnd=0x%04x dc=0x%04x menu=0x%04x\n", hwnd
, hdc
, hmenu
);
1444 GetClientRect( hwnd
, &rect
);
1446 if(TWEAK_WineLook
== WIN31_LOOK
)
1448 rect
.bottom
-= POPUP_YSHADE
* GetSystemMetrics(SM_CYBORDER
);
1449 rect
.right
-= POPUP_XSHADE
* GetSystemMetrics(SM_CXBORDER
);
1452 if((hPrevBrush
= SelectObject( hdc
, GetSysColorBrush(COLOR_MENU
) ))
1453 && (SelectObject( hdc
, hMenuFont
)))
1457 Rectangle( hdc
, rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
1459 hPrevPen
= SelectObject( hdc
, GetStockObject( NULL_PEN
) );
1465 /* draw 3-d shade */
1466 if(TWEAK_WineLook
== WIN31_LOOK
) {
1467 SelectObject( hdc
, hShadeBrush
);
1468 SetBkMode( hdc
, TRANSPARENT
);
1469 ropPrev
= SetROP2( hdc
, R2_MASKPEN
);
1471 i
= rect
.right
; /* why SetBrushOrg() doesn't? */
1472 PatBlt( hdc
, i
& 0xfffffffe,
1473 rect
.top
+ POPUP_YSHADE
*GetSystemMetrics(SM_CYBORDER
),
1474 i
%2 + POPUP_XSHADE
*GetSystemMetrics(SM_CXBORDER
),
1475 rect
.bottom
- rect
.top
, 0x00a000c9 );
1477 PatBlt( hdc
, rect
.left
+ POPUP_XSHADE
*GetSystemMetrics(SM_CXBORDER
),
1478 i
& 0xfffffffe,rect
.right
- rect
.left
,
1479 i
%2 + POPUP_YSHADE
*GetSystemMetrics(SM_CYBORDER
), 0x00a000c9 );
1480 SelectObject( hdc
, hPrevPen
);
1481 SelectObject( hdc
, hPrevBrush
);
1482 SetROP2( hdc
, ropPrev
);
1485 DrawEdge (hdc
, &rect
, EDGE_RAISED
, BF_RECT
);
1487 /* draw menu items */
1489 menu
= MENU_GetMenu( hmenu
);
1490 if (menu
&& menu
->nItems
)
1495 for (u
= menu
->nItems
, item
= menu
->items
; u
> 0; u
--, item
++)
1496 MENU_DrawMenuItem( hwnd
, hmenu
, menu
->hwndOwner
, hdc
, item
,
1497 menu
->Height
, FALSE
, ODA_DRAWENTIRE
);
1502 SelectObject( hdc
, hPrevBrush
);
1507 /***********************************************************************
1510 * Paint a menu bar. Returns the height of the menu bar.
1511 * called from [windows/nonclient.c]
1513 UINT
MENU_DrawMenuBar( HDC hDC
, LPRECT lprect
, HWND hwnd
,
1519 HMENU hMenu
= GetMenu(hwnd
);
1521 lppop
= MENU_GetMenu( hMenu
);
1522 if (lppop
== NULL
|| lprect
== NULL
)
1524 retvalue
= GetSystemMetrics(SM_CYMENU
);
1528 TRACE("(%04x, %p, %p)\n", hDC
, lprect
, lppop
);
1530 hfontOld
= SelectObject( hDC
, hMenuFont
);
1532 if (lppop
->Height
== 0)
1533 MENU_MenuBarCalcSize(hDC
, lprect
, lppop
, hwnd
);
1535 lprect
->bottom
= lprect
->top
+ lppop
->Height
;
1539 retvalue
= lppop
->Height
;
1543 FillRect(hDC
, lprect
, GetSysColorBrush(COLOR_MENU
) );
1545 if (TWEAK_WineLook
== WIN31_LOOK
)
1547 SelectObject( hDC
, SYSCOLOR_GetPen(COLOR_WINDOWFRAME
) );
1548 MoveToEx( hDC
, lprect
->left
, lprect
->bottom
, NULL
);
1549 LineTo( hDC
, lprect
->right
, lprect
->bottom
);
1553 SelectObject( hDC
, SYSCOLOR_GetPen(COLOR_3DFACE
));
1554 MoveToEx( hDC
, lprect
->left
, lprect
->bottom
, NULL
);
1555 LineTo( hDC
, lprect
->right
, lprect
->bottom
);
1558 if (lppop
->nItems
== 0)
1560 retvalue
= GetSystemMetrics(SM_CYMENU
);
1564 for (i
= 0; i
< lppop
->nItems
; i
++)
1566 MENU_DrawMenuItem( hwnd
, hMenu
, hwnd
,
1567 hDC
, &lppop
->items
[i
], lppop
->Height
, TRUE
, ODA_DRAWENTIRE
);
1569 retvalue
= lppop
->Height
;
1572 if (hfontOld
) SelectObject (hDC
, hfontOld
);
1577 /***********************************************************************
1580 * Display a popup menu.
1582 static BOOL
MENU_ShowPopup( HWND hwndOwner
, HMENU hmenu
, UINT id
,
1583 INT x
, INT y
, INT xanchor
, INT yanchor
)
1588 TRACE("owner=0x%04x hmenu=0x%04x id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1589 hwndOwner
, hmenu
, id
, x
, y
, xanchor
, yanchor
);
1591 if (!(menu
= MENU_GetMenu( hmenu
))) return FALSE
;
1592 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1594 menu
->items
[menu
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1595 menu
->FocusedItem
= NO_SELECTED_ITEM
;
1598 /* store the owner for DrawItem */
1599 menu
->hwndOwner
= hwndOwner
;
1602 MENU_PopupMenuCalcSize( menu
, hwndOwner
);
1604 /* adjust popup menu pos so that it fits within the desktop */
1606 width
= menu
->Width
+ GetSystemMetrics(SM_CXBORDER
);
1607 height
= menu
->Height
+ GetSystemMetrics(SM_CYBORDER
);
1609 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1612 x
-= width
- xanchor
;
1613 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1614 x
= GetSystemMetrics(SM_CXSCREEN
) - width
;
1618 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1621 y
-= height
+ yanchor
;
1622 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1623 y
= GetSystemMetrics(SM_CYSCREEN
) - height
;
1627 if( TWEAK_WineLook
== WIN31_LOOK
)
1629 width
+= POPUP_XSHADE
* GetSystemMetrics(SM_CXBORDER
); /* add space for shading */
1630 height
+= POPUP_YSHADE
* GetSystemMetrics(SM_CYBORDER
);
1633 /* NOTE: In Windows, top menu popup is not owned. */
1634 menu
->hWnd
= CreateWindowA( POPUPMENU_CLASS_ATOM
, NULL
,
1635 WS_POPUP
, x
, y
, width
, height
,
1636 hwndOwner
, 0, GetWindowLongA(hwndOwner
,GWL_HINSTANCE
),
1638 if( !menu
->hWnd
) return FALSE
;
1639 if (!top_popup
) top_popup
= menu
->hWnd
;
1641 /* Display the window */
1643 SetWindowPos( menu
->hWnd
, HWND_TOP
, 0, 0, 0, 0,
1644 SWP_SHOWWINDOW
| SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
1645 UpdateWindow( menu
->hWnd
);
1650 /***********************************************************************
1653 static void MENU_SelectItem( HWND hwndOwner
, HMENU hmenu
, UINT wIndex
,
1654 BOOL sendMenuSelect
, HMENU topmenu
)
1659 TRACE("owner=0x%04x menu=0x%04x index=0x%04x select=0x%04x\n", hwndOwner
, hmenu
, wIndex
, sendMenuSelect
);
1661 lppop
= MENU_GetMenu( hmenu
);
1662 if ((!lppop
) || (!lppop
->nItems
) || (!lppop
->hWnd
)) return;
1664 if (lppop
->FocusedItem
== wIndex
) return;
1665 if (lppop
->wFlags
& MF_POPUP
) hdc
= GetDC( lppop
->hWnd
);
1666 else hdc
= GetDCEx( lppop
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1667 if (!top_popup
) top_popup
= lppop
->hWnd
;
1669 SelectObject( hdc
, hMenuFont
);
1671 /* Clear previous highlighted item */
1672 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1674 lppop
->items
[lppop
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1675 MENU_DrawMenuItem(lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,&lppop
->items
[lppop
->FocusedItem
],
1676 lppop
->Height
, !(lppop
->wFlags
& MF_POPUP
),
1680 /* Highlight new item (if any) */
1681 lppop
->FocusedItem
= wIndex
;
1682 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1684 if(!(lppop
->items
[wIndex
].fType
& MF_SEPARATOR
)) {
1685 lppop
->items
[wIndex
].fState
|= MF_HILITE
;
1686 MENU_DrawMenuItem( lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,
1687 &lppop
->items
[wIndex
], lppop
->Height
,
1688 !(lppop
->wFlags
& MF_POPUP
), ODA_SELECT
);
1692 MENUITEM
*ip
= &lppop
->items
[lppop
->FocusedItem
];
1693 SendMessageA( hwndOwner
, WM_MENUSELECT
,
1694 MAKELONG(ip
->fType
& MF_POPUP
? wIndex
: ip
->wID
,
1695 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1696 (lppop
->wFlags
& MF_SYSMENU
)), hmenu
);
1699 else if (sendMenuSelect
) {
1702 if((pos
=MENU_FindSubMenu(&topmenu
, hmenu
))!=NO_SELECTED_ITEM
){
1703 POPUPMENU
*ptm
= MENU_GetMenu( topmenu
);
1704 MENUITEM
*ip
= &ptm
->items
[pos
];
1705 SendMessageA( hwndOwner
, WM_MENUSELECT
, MAKELONG(pos
,
1706 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1707 (ptm
->wFlags
& MF_SYSMENU
)), topmenu
);
1711 ReleaseDC( lppop
->hWnd
, hdc
);
1715 /***********************************************************************
1716 * MENU_MoveSelection
1718 * Moves currently selected item according to the offset parameter.
1719 * If there is no selection then it should select the last item if
1720 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1722 static void MENU_MoveSelection( HWND hwndOwner
, HMENU hmenu
, INT offset
)
1727 TRACE("hwnd=0x%04x hmenu=0x%04x off=0x%04x\n", hwndOwner
, hmenu
, offset
);
1729 menu
= MENU_GetMenu( hmenu
);
1730 if ((!menu
) || (!menu
->items
)) return;
1732 if ( menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1734 if( menu
->nItems
== 1 ) return; else
1735 for (i
= menu
->FocusedItem
+ offset
; i
>= 0 && i
< menu
->nItems
1737 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1739 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1744 for ( i
= (offset
> 0) ? 0 : menu
->nItems
- 1;
1745 i
>= 0 && i
< menu
->nItems
; i
+= offset
)
1746 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1748 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1754 /**********************************************************************
1757 * Set an item's flags, id and text ptr. Called by InsertMenu() and
1760 static BOOL
MENU_SetItemData( MENUITEM
*item
, UINT flags
, UINT_PTR id
,
1763 LPWSTR prevText
= IS_STRING_ITEM(item
->fType
) ? item
->text
: NULL
;
1765 debug_print_menuitem("MENU_SetItemData from: ", item
, "");
1766 TRACE("flags=%x str=%p\n", flags
, str
);
1768 if (IS_STRING_ITEM(flags
))
1772 flags
|= MF_SEPARATOR
;
1778 /* Item beginning with a backspace is a help item */
1784 if (!(text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(str
)+1) * sizeof(WCHAR
) )))
1786 strcpyW( text
, str
);
1790 else if (IS_BITMAP_ITEM(flags
))
1791 item
->text
= (LPWSTR
)(HBITMAP
)LOWORD(str
);
1792 else item
->text
= NULL
;
1794 if (flags
& MF_OWNERDRAW
)
1795 item
->dwItemData
= (DWORD
)str
;
1797 item
->dwItemData
= 0;
1799 if ((item
->fType
& MF_POPUP
) && (flags
& MF_POPUP
) && (item
->hSubMenu
!= id
) )
1800 DestroyMenu( item
->hSubMenu
); /* ModifyMenu() spec */
1802 if (flags
& MF_POPUP
)
1804 POPUPMENU
*menu
= MENU_GetMenu((UINT16
)id
);
1805 if (menu
) menu
->wFlags
|= MF_POPUP
;
1817 if (flags
& MF_POPUP
)
1818 item
->hSubMenu
= id
;
1820 if ((item
->fType
& MF_POPUP
) && !(flags
& MF_POPUP
) )
1821 flags
|= MF_POPUP
; /* keep popup */
1823 item
->fType
= flags
& TYPE_MASK
;
1824 item
->fState
= (flags
& STATE_MASK
) &
1825 ~(MF_HILITE
| MF_MOUSESELECT
| MF_BYPOSITION
);
1828 /* Don't call SetRectEmpty here! */
1831 if (prevText
) HeapFree( GetProcessHeap(), 0, prevText
);
1833 debug_print_menuitem("MENU_SetItemData to : ", item
, "");
1838 /**********************************************************************
1841 * Insert (allocate) a new item into a menu.
1843 static MENUITEM
*MENU_InsertItem( HMENU hMenu
, UINT pos
, UINT flags
)
1848 if (!(menu
= MENU_GetMenu(hMenu
)))
1851 /* Find where to insert new item */
1853 if (flags
& MF_BYPOSITION
) {
1854 if (pos
> menu
->nItems
)
1857 if (!MENU_FindItem( &hMenu
, &pos
, flags
))
1860 if (!(menu
= MENU_GetMenu( hMenu
)))
1865 /* Create new items array */
1867 newItems
= HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM
) * (menu
->nItems
+1) );
1870 WARN("allocation failed\n" );
1873 if (menu
->nItems
> 0)
1875 /* Copy the old array into the new one */
1876 if (pos
> 0) memcpy( newItems
, menu
->items
, pos
* sizeof(MENUITEM
) );
1877 if (pos
< menu
->nItems
) memcpy( &newItems
[pos
+1], &menu
->items
[pos
],
1878 (menu
->nItems
-pos
)*sizeof(MENUITEM
) );
1879 HeapFree( GetProcessHeap(), 0, menu
->items
);
1881 menu
->items
= newItems
;
1883 memset( &newItems
[pos
], 0, sizeof(*newItems
) );
1884 menu
->Height
= 0; /* force size recalculate */
1885 return &newItems
[pos
];
1889 /**********************************************************************
1890 * MENU_ParseResource
1892 * Parse a standard menu resource and add items to the menu.
1893 * Return a pointer to the end of the resource.
1895 * NOTE: flags is equivalent to the mtOption field
1897 static LPCSTR
MENU_ParseResource( LPCSTR res
, HMENU hMenu
, BOOL unicode
)
1904 flags
= GET_WORD(res
);
1905 res
+= sizeof(WORD
);
1906 if (!(flags
& MF_POPUP
))
1909 res
+= sizeof(WORD
);
1912 if (!unicode
) res
+= strlen(str
) + 1;
1913 else res
+= (strlenW((LPCWSTR
)str
) + 1) * sizeof(WCHAR
);
1914 if (flags
& MF_POPUP
)
1916 HMENU hSubMenu
= CreatePopupMenu();
1917 if (!hSubMenu
) return NULL
;
1918 if (!(res
= MENU_ParseResource( res
, hSubMenu
, unicode
)))
1920 if (!unicode
) AppendMenuA( hMenu
, flags
, (UINT
)hSubMenu
, str
);
1921 else AppendMenuW( hMenu
, flags
, (UINT
)hSubMenu
, (LPCWSTR
)str
);
1923 else /* Not a popup */
1925 if (!unicode
) AppendMenuA( hMenu
, flags
, id
, *str
? str
: NULL
);
1926 else AppendMenuW( hMenu
, flags
, id
,
1927 *(LPCWSTR
)str
? (LPCWSTR
)str
: NULL
);
1929 } while (!(flags
& MF_END
));
1934 /**********************************************************************
1935 * MENUEX_ParseResource
1937 * Parse an extended menu resource and add items to the menu.
1938 * Return a pointer to the end of the resource.
1940 static LPCSTR
MENUEX_ParseResource( LPCSTR res
, HMENU hMenu
)
1946 mii
.cbSize
= sizeof(mii
);
1947 mii
.fMask
= MIIM_STATE
| MIIM_ID
| MIIM_TYPE
;
1948 mii
.fType
= GET_DWORD(res
);
1949 res
+= sizeof(DWORD
);
1950 mii
.fState
= GET_DWORD(res
);
1951 res
+= sizeof(DWORD
);
1952 mii
.wID
= GET_DWORD(res
);
1953 res
+= sizeof(DWORD
);
1954 resinfo
= GET_WORD(res
); /* FIXME: for 16-bit apps this is a byte. */
1955 res
+= sizeof(WORD
);
1956 /* Align the text on a word boundary. */
1957 res
+= (~((int)res
- 1)) & 1;
1958 mii
.dwTypeData
= (LPWSTR
) res
;
1959 res
+= (1 + strlenW(mii
.dwTypeData
)) * sizeof(WCHAR
);
1960 /* Align the following fields on a dword boundary. */
1961 res
+= (~((int)res
- 1)) & 3;
1963 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1964 mii
.fType
, mii
.fState
, mii
.wID
, resinfo
, debugstr_w(mii
.dwTypeData
));
1966 if (resinfo
& 1) { /* Pop-up? */
1967 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1968 res
+= sizeof(DWORD
);
1969 mii
.hSubMenu
= CreatePopupMenu();
1972 if (!(res
= MENUEX_ParseResource(res
, mii
.hSubMenu
))) {
1973 DestroyMenu(mii
.hSubMenu
);
1976 mii
.fMask
|= MIIM_SUBMENU
;
1977 mii
.fType
|= MF_POPUP
;
1979 else if(!*mii
.dwTypeData
&& !(mii
.fType
& MF_SEPARATOR
))
1981 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1982 mii
.wID
, mii
.fType
);
1983 mii
.fType
|= MF_SEPARATOR
;
1985 InsertMenuItemW(hMenu
, -1, MF_BYPOSITION
, &mii
);
1986 } while (!(resinfo
& MF_END
));
1991 /***********************************************************************
1994 * Return the handle of the selected sub-popup menu (if any).
1996 static HMENU
MENU_GetSubPopup( HMENU hmenu
)
2001 menu
= MENU_GetMenu( hmenu
);
2003 if ((!menu
) || (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return 0;
2005 item
= &menu
->items
[menu
->FocusedItem
];
2006 if ((item
->fType
& MF_POPUP
) && (item
->fState
& MF_MOUSESELECT
))
2007 return item
->hSubMenu
;
2012 /***********************************************************************
2013 * MENU_HideSubPopups
2015 * Hide the sub-popup menus of this menu.
2017 static void MENU_HideSubPopups( HWND hwndOwner
, HMENU hmenu
,
2018 BOOL sendMenuSelect
)
2020 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
2022 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner
, hmenu
, sendMenuSelect
);
2024 if (menu
&& top_popup
)
2030 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
2032 item
= &menu
->items
[menu
->FocusedItem
];
2033 if (!(item
->fType
& MF_POPUP
) ||
2034 !(item
->fState
& MF_MOUSESELECT
)) return;
2035 item
->fState
&= ~MF_MOUSESELECT
;
2036 hsubmenu
= item
->hSubMenu
;
2039 submenu
= MENU_GetMenu( hsubmenu
);
2040 MENU_HideSubPopups( hwndOwner
, hsubmenu
, FALSE
);
2041 MENU_SelectItem( hwndOwner
, hsubmenu
, NO_SELECTED_ITEM
, sendMenuSelect
, 0 );
2042 DestroyWindow( submenu
->hWnd
);
2048 /***********************************************************************
2051 * Display the sub-menu of the selected item of this menu.
2052 * Return the handle of the submenu, or hmenu if no submenu to display.
2054 static HMENU
MENU_ShowSubPopup( HWND hwndOwner
, HMENU hmenu
,
2055 BOOL selectFirst
, UINT wFlags
)
2062 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner
, hmenu
, selectFirst
);
2064 if (!(menu
= MENU_GetMenu( hmenu
))) return hmenu
;
2066 if (menu
->FocusedItem
== NO_SELECTED_ITEM
) return hmenu
;
2068 item
= &menu
->items
[menu
->FocusedItem
];
2069 if (!(item
->fType
& MF_POPUP
) || (item
->fState
& (MF_GRAYED
| MF_DISABLED
)))
2072 /* message must be sent before using item,
2073 because nearly everything may be changed by the application ! */
2075 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2076 if (!(wFlags
& TPM_NONOTIFY
))
2077 SendMessageA( hwndOwner
, WM_INITMENUPOPUP
, item
->hSubMenu
,
2078 MAKELONG( menu
->FocusedItem
, IS_SYSTEM_MENU(menu
) ));
2080 item
= &menu
->items
[menu
->FocusedItem
];
2083 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2084 if (!(item
->fState
& MF_HILITE
))
2086 if (menu
->wFlags
& MF_POPUP
) hdc
= GetDC( menu
->hWnd
);
2087 else hdc
= GetDCEx( menu
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
2089 SelectObject( hdc
, hMenuFont
);
2091 item
->fState
|= MF_HILITE
;
2092 MENU_DrawMenuItem( menu
->hWnd
, hmenu
, hwndOwner
, hdc
, item
, menu
->Height
, !(menu
->wFlags
& MF_POPUP
), ODA_DRAWENTIRE
);
2093 ReleaseDC( menu
->hWnd
, hdc
);
2095 if (!item
->rect
.top
&& !item
->rect
.left
&& !item
->rect
.bottom
&& !item
->rect
.right
)
2098 item
->fState
|= MF_MOUSESELECT
;
2100 if (IS_SYSTEM_MENU(menu
))
2102 MENU_InitSysMenuPopup(item
->hSubMenu
,
2103 GetWindowLongA( menu
->hWnd
, GWL_STYLE
),
2104 GetClassLongA( menu
->hWnd
, GCL_STYLE
));
2106 NC_GetSysPopupPos( menu
->hWnd
, &rect
);
2107 rect
.top
= rect
.bottom
;
2108 rect
.right
= GetSystemMetrics(SM_CXSIZE
);
2109 rect
.bottom
= GetSystemMetrics(SM_CYSIZE
);
2113 GetWindowRect( menu
->hWnd
, &rect
);
2114 if (menu
->wFlags
& MF_POPUP
)
2116 rect
.left
+= item
->rect
.right
- GetSystemMetrics(SM_CXBORDER
);
2117 rect
.top
+= item
->rect
.top
;
2118 rect
.right
= item
->rect
.left
- item
->rect
.right
+ GetSystemMetrics(SM_CXBORDER
);
2119 rect
.bottom
= item
->rect
.top
- item
->rect
.bottom
;
2123 rect
.left
+= item
->rect
.left
;
2124 rect
.top
+= item
->rect
.bottom
;
2125 rect
.right
= item
->rect
.right
- item
->rect
.left
;
2126 rect
.bottom
= item
->rect
.bottom
- item
->rect
.top
;
2130 MENU_ShowPopup( hwndOwner
, item
->hSubMenu
, menu
->FocusedItem
,
2131 rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
2133 MENU_MoveSelection( hwndOwner
, item
->hSubMenu
, ITEM_NEXT
);
2134 return item
->hSubMenu
;
2139 /**********************************************************************
2142 BOOL
MENU_IsMenuActive(void)
2144 return (top_popup
!= 0);
2147 /***********************************************************************
2150 * Walks menu chain trying to find a menu pt maps to.
2152 static HMENU
MENU_PtMenu( HMENU hMenu
, POINT pt
)
2154 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2155 UINT item
= menu
->FocusedItem
;
2158 /* try subpopup first (if any) */
2159 ret
= (item
!= NO_SELECTED_ITEM
&&
2160 (menu
->items
[item
].fType
& MF_POPUP
) &&
2161 (menu
->items
[item
].fState
& MF_MOUSESELECT
))
2162 ? MENU_PtMenu(menu
->items
[item
].hSubMenu
, pt
) : 0;
2164 if (!ret
) /* check the current window (avoiding WM_HITTEST) */
2166 INT ht
= NC_HandleNCHitTest( menu
->hWnd
, pt
);
2167 if( menu
->wFlags
& MF_POPUP
)
2169 if (ht
!= HTNOWHERE
&& ht
!= HTERROR
) ret
= hMenu
;
2171 else if (ht
== HTSYSMENU
)
2172 ret
= get_win_sys_menu( menu
->hWnd
);
2173 else if (ht
== HTMENU
)
2174 ret
= GetMenu( menu
->hWnd
);
2179 /***********************************************************************
2180 * MENU_ExecFocusedItem
2182 * Execute a menu item (for instance when user pressed Enter).
2183 * Return the wID of the executed item. Otherwise, -1 indicating
2184 * that no menu item was executed;
2185 * Have to receive the flags for the TrackPopupMenu options to avoid
2186 * sending unwanted message.
2189 static INT
MENU_ExecFocusedItem( MTRACKER
* pmt
, HMENU hMenu
, UINT wFlags
)
2192 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2194 TRACE("%p hmenu=0x%04x\n", pmt
, hMenu
);
2196 if (!menu
|| !menu
->nItems
||
2197 (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return -1;
2199 item
= &menu
->items
[menu
->FocusedItem
];
2201 TRACE("%08x %08x %08x\n",
2202 hMenu
, item
->wID
, item
->hSubMenu
);
2204 if (!(item
->fType
& MF_POPUP
))
2206 if (!(item
->fState
& (MF_GRAYED
| MF_DISABLED
)) && !(item
->fType
& MF_SEPARATOR
))
2208 /* If TPM_RETURNCMD is set you return the id, but
2209 do not send a message to the owner */
2210 if(!(wFlags
& TPM_RETURNCMD
))
2212 if( menu
->wFlags
& MF_SYSMENU
)
2213 PostMessageA( pmt
->hOwnerWnd
, WM_SYSCOMMAND
, item
->wID
,
2214 MAKELPARAM((INT16
)pmt
->pt
.x
, (INT16
)pmt
->pt
.y
) );
2216 PostMessageA( pmt
->hOwnerWnd
, WM_COMMAND
, item
->wID
, 0 );
2222 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hMenu
, TRUE
, wFlags
);
2227 /***********************************************************************
2228 * MENU_SwitchTracking
2230 * Helper function for menu navigation routines.
2232 static void MENU_SwitchTracking( MTRACKER
* pmt
, HMENU hPtMenu
, UINT id
)
2234 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2235 POPUPMENU
*topmenu
= MENU_GetMenu( pmt
->hTopMenu
);
2237 TRACE("%p hmenu=0x%04x 0x%04x\n", pmt
, hPtMenu
, id
);
2239 if( pmt
->hTopMenu
!= hPtMenu
&&
2240 !((ptmenu
->wFlags
| topmenu
->wFlags
) & MF_POPUP
) )
2242 /* both are top level menus (system and menu-bar) */
2243 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2244 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2245 pmt
->hTopMenu
= hPtMenu
;
2247 else MENU_HideSubPopups( pmt
->hOwnerWnd
, hPtMenu
, FALSE
);
2248 MENU_SelectItem( pmt
->hOwnerWnd
, hPtMenu
, id
, TRUE
, 0 );
2252 /***********************************************************************
2255 * Return TRUE if we can go on with menu tracking.
2257 static BOOL
MENU_ButtonDown( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2259 TRACE("%p hPtMenu=0x%04x\n", pmt
, hPtMenu
);
2264 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2267 if( IS_SYSTEM_MENU(ptmenu
) )
2268 item
= ptmenu
->items
;
2270 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2274 if( ptmenu
->FocusedItem
!= id
)
2275 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2277 /* If the popup menu is not already "popped" */
2278 if(!(item
->fState
& MF_MOUSESELECT
))
2280 pmt
->hCurrentMenu
= MENU_ShowSubPopup( pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2282 /* In win31, a newly popped menu always remains opened for the next buttonup */
2283 if(TWEAK_WineLook
== WIN31_LOOK
)
2284 ptmenu
->bTimeToHide
= FALSE
;
2289 /* Else the click was on the menu bar, finish the tracking */
2294 /***********************************************************************
2297 * Return the value of MENU_ExecFocusedItem if
2298 * the selected item was not a popup. Else open the popup.
2299 * A -1 return value indicates that we go on with menu tracking.
2302 static INT
MENU_ButtonUp( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2304 TRACE("%p hmenu=0x%04x\n", pmt
, hPtMenu
);
2309 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2312 if( IS_SYSTEM_MENU(ptmenu
) )
2313 item
= ptmenu
->items
;
2315 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2317 if( item
&& (ptmenu
->FocusedItem
== id
))
2319 if( !(item
->fType
& MF_POPUP
) )
2320 return MENU_ExecFocusedItem( pmt
, hPtMenu
, wFlags
);
2322 /* If we are dealing with the top-level menu */
2323 /* and this is a click on an already "popped" item: */
2324 /* Stop the menu tracking and close the opened submenus */
2325 if((pmt
->hTopMenu
== hPtMenu
) && (ptmenu
->bTimeToHide
== TRUE
))
2328 ptmenu
->bTimeToHide
= TRUE
;
2334 /***********************************************************************
2337 * Return TRUE if we can go on with menu tracking.
2339 static BOOL
MENU_MouseMove( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2341 UINT id
= NO_SELECTED_ITEM
;
2342 POPUPMENU
*ptmenu
= NULL
;
2346 ptmenu
= MENU_GetMenu( hPtMenu
);
2347 if( IS_SYSTEM_MENU(ptmenu
) )
2350 MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2353 if( id
== NO_SELECTED_ITEM
)
2355 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2356 NO_SELECTED_ITEM
, TRUE
, pmt
->hTopMenu
);
2359 else if( ptmenu
->FocusedItem
!= id
)
2361 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2362 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2368 /***********************************************************************
2371 static void MENU_SetCapture( HWND hwnd
)
2375 SERVER_START_REQ( set_capture_window
)
2378 req
->flags
= CAPTURE_MENU
;
2379 if (!wine_server_call_err( req
))
2381 previous
= reply
->previous
;
2382 hwnd
= reply
->full_handle
;
2387 if (previous
&& previous
!= hwnd
)
2388 SendMessageW( previous
, WM_CAPTURECHANGED
, 0, (LPARAM
)hwnd
);
2392 /***********************************************************************
2395 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2397 static LRESULT
MENU_DoNextMenu( MTRACKER
* pmt
, UINT vk
)
2399 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2401 if( (vk
== VK_LEFT
&& menu
->FocusedItem
== 0 ) ||
2402 (vk
== VK_RIGHT
&& menu
->FocusedItem
== menu
->nItems
- 1))
2404 MDINEXTMENU next_menu
;
2409 next_menu
.hmenuIn
= (IS_SYSTEM_MENU(menu
)) ? GetSubMenu(pmt
->hTopMenu
,0) : pmt
->hTopMenu
;
2410 next_menu
.hmenuNext
= 0;
2411 next_menu
.hwndNext
= 0;
2412 SendMessageW( pmt
->hOwnerWnd
, WM_NEXTMENU
, vk
, (LPARAM
)&next_menu
);
2414 TRACE("%04x [%04x] -> %04x [%04x]\n",
2415 pmt
->hCurrentMenu
, pmt
->hOwnerWnd
, next_menu
.hmenuNext
, next_menu
.hwndNext
);
2417 if (!next_menu
.hmenuNext
|| !next_menu
.hwndNext
)
2419 DWORD style
= GetWindowLongA( pmt
->hOwnerWnd
, GWL_STYLE
);
2420 hNewWnd
= pmt
->hOwnerWnd
;
2421 if( IS_SYSTEM_MENU(menu
) )
2423 /* switch to the menu bar */
2425 if(style
& WS_CHILD
|| !(hNewMenu
= GetMenu(hNewWnd
))) return FALSE
;
2429 menu
= MENU_GetMenu( hNewMenu
);
2430 id
= menu
->nItems
- 1;
2433 else if (style
& WS_SYSMENU
)
2435 /* switch to the system menu */
2436 hNewMenu
= get_win_sys_menu( hNewWnd
);
2440 else /* application returned a new menu to switch to */
2442 hNewMenu
= next_menu
.hmenuNext
;
2443 hNewWnd
= WIN_GetFullHandle( next_menu
.hwndNext
);
2445 if( IsMenu(hNewMenu
) && IsWindow(hNewWnd
) )
2447 DWORD style
= GetWindowLongA( hNewWnd
, GWL_STYLE
);
2449 if (style
& WS_SYSMENU
&&
2450 GetSubMenu(get_win_sys_menu(hNewWnd
), 0) == hNewMenu
)
2452 /* get the real system menu */
2453 hNewMenu
= get_win_sys_menu(hNewWnd
);
2455 else if (style
& WS_CHILD
|| GetMenu(hNewWnd
) != hNewMenu
)
2457 /* FIXME: Not sure what to do here;
2458 * perhaps try to track hNewMenu as a popup? */
2460 TRACE(" -- got confused.\n");
2467 if( hNewMenu
!= pmt
->hTopMenu
)
2469 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
,
2471 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2472 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2475 if( hNewWnd
!= pmt
->hOwnerWnd
)
2477 pmt
->hOwnerWnd
= hNewWnd
;
2478 MENU_SetCapture( pmt
->hOwnerWnd
);
2481 pmt
->hTopMenu
= pmt
->hCurrentMenu
= hNewMenu
; /* all subpopups are hidden */
2482 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, id
, TRUE
, 0 );
2489 /***********************************************************************
2492 * The idea is not to show the popup if the next input message is
2493 * going to hide it anyway.
2495 static BOOL
MENU_SuspendPopup( MTRACKER
* pmt
, UINT16 uMsg
)
2499 msg
.hwnd
= pmt
->hOwnerWnd
;
2501 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2502 pmt
->trackFlags
|= TF_SKIPREMOVE
;
2507 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2508 if( msg
.message
== WM_KEYUP
|| msg
.message
== WM_PAINT
)
2510 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2511 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2512 if( msg
.message
== WM_KEYDOWN
&&
2513 (msg
.wParam
== VK_LEFT
|| msg
.wParam
== VK_RIGHT
))
2515 pmt
->trackFlags
|= TF_SUSPENDPOPUP
;
2522 /* failures go through this */
2523 pmt
->trackFlags
&= ~TF_SUSPENDPOPUP
;
2527 /***********************************************************************
2530 * Handle a VK_ESCAPE key event in a menu.
2532 static BOOL
MENU_KeyEscape(MTRACKER
* pmt
, UINT wFlags
)
2534 BOOL bEndMenu
= TRUE
;
2536 if (pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2538 POPUPMENU
*menu
= MENU_GetMenu(pmt
->hCurrentMenu
);
2540 if (menu
->wFlags
& MF_POPUP
)
2542 HMENU hmenutmp
, hmenuprev
;
2544 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2546 /* close topmost popup */
2547 while (hmenutmp
!= pmt
->hCurrentMenu
)
2549 hmenuprev
= hmenutmp
;
2550 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2553 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2554 pmt
->hCurrentMenu
= hmenuprev
;
2562 /***********************************************************************
2565 * Handle a VK_LEFT key event in a menu.
2567 static void MENU_KeyLeft( MTRACKER
* pmt
, UINT wFlags
)
2570 HMENU hmenutmp
, hmenuprev
;
2573 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2574 menu
= MENU_GetMenu( hmenutmp
);
2576 /* Try to move 1 column left (if possible) */
2577 if( (prevcol
= MENU_GetStartOfPrevColumn( pmt
->hCurrentMenu
)) !=
2578 NO_SELECTED_ITEM
) {
2580 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2585 /* close topmost popup */
2586 while (hmenutmp
!= pmt
->hCurrentMenu
)
2588 hmenuprev
= hmenutmp
;
2589 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2592 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2593 pmt
->hCurrentMenu
= hmenuprev
;
2595 if ( (hmenuprev
== pmt
->hTopMenu
) && !(menu
->wFlags
& MF_POPUP
) )
2597 /* move menu bar selection if no more popups are left */
2599 if( !MENU_DoNextMenu( pmt
, VK_LEFT
) )
2600 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_PREV
);
2602 if ( hmenuprev
!= hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2604 /* A sublevel menu was displayed - display the next one
2605 * unless there is another displacement coming up */
2607 if( !MENU_SuspendPopup( pmt
, WM_KEYDOWN
) )
2608 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2609 pmt
->hTopMenu
, TRUE
, wFlags
);
2615 /***********************************************************************
2618 * Handle a VK_RIGHT key event in a menu.
2620 static void MENU_KeyRight( MTRACKER
* pmt
, UINT wFlags
)
2623 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2626 TRACE("MENU_KeyRight called, cur %x (%s), top %x (%s).\n",
2628 debugstr_w((MENU_GetMenu(pmt
->hCurrentMenu
))->
2630 pmt
->hTopMenu
, debugstr_w(menu
->items
[0].text
) );
2632 if ( (menu
->wFlags
& MF_POPUP
) || (pmt
->hCurrentMenu
!= pmt
->hTopMenu
))
2634 /* If already displaying a popup, try to display sub-popup */
2636 hmenutmp
= pmt
->hCurrentMenu
;
2637 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hmenutmp
, TRUE
, wFlags
);
2639 /* if subpopup was displayed then we are done */
2640 if (hmenutmp
!= pmt
->hCurrentMenu
) return;
2643 /* Check to see if there's another column */
2644 if( (nextcol
= MENU_GetStartOfNextColumn( pmt
->hCurrentMenu
)) !=
2645 NO_SELECTED_ITEM
) {
2646 TRACE("Going to %d.\n", nextcol
);
2647 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2652 if (!(menu
->wFlags
& MF_POPUP
)) /* menu bar tracking */
2654 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2656 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2657 hmenutmp
= pmt
->hCurrentMenu
= pmt
->hTopMenu
;
2658 } else hmenutmp
= 0;
2660 /* try to move to the next item */
2661 if( !MENU_DoNextMenu( pmt
, VK_RIGHT
) )
2662 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_NEXT
);
2664 if( hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2665 if( !MENU_SuspendPopup(pmt
, WM_KEYDOWN
) )
2666 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2667 pmt
->hTopMenu
, TRUE
, wFlags
);
2671 /***********************************************************************
2674 * Menu tracking code.
2676 static INT
MENU_TrackMenu( HMENU hmenu
, UINT wFlags
, INT x
, INT y
,
2677 HWND hwnd
, const RECT
*lprect
)
2682 INT executedMenuId
= -1;
2684 BOOL enterIdleSent
= FALSE
;
2687 mt
.hCurrentMenu
= hmenu
;
2688 mt
.hTopMenu
= hmenu
;
2689 mt
.hOwnerWnd
= WIN_GetFullHandle( hwnd
);
2693 TRACE("hmenu=0x%04x flags=0x%08x (%d,%d) hwnd=0x%04x (%d,%d)-(%d,%d)\n",
2694 hmenu
, wFlags
, x
, y
, hwnd
, (lprect
) ? lprect
->left
: 0, (lprect
) ? lprect
->top
: 0,
2695 (lprect
) ? lprect
->right
: 0, (lprect
) ? lprect
->bottom
: 0);
2698 if (!(menu
= MENU_GetMenu( hmenu
))) return FALSE
;
2700 if (wFlags
& TPM_BUTTONDOWN
)
2702 /* Get the result in order to start the tracking or not */
2703 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2704 fEndMenu
= !fRemove
;
2707 MENU_SetCapture( mt
.hOwnerWnd
);
2711 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2712 if (!menu
) /* sometimes happens if I do a window manager close */
2715 /* we have to keep the message in the queue until it's
2716 * clear that menu loop is not over yet. */
2720 if (PeekMessageA( &msg
, 0, 0, 0, PM_NOREMOVE
))
2722 if (!CallMsgFilterA( &msg
, MSGF_MENU
)) break;
2723 /* remove the message from the queue */
2724 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2730 HWND win
= (wFlags
& TPM_ENTERIDLEEX
&& menu
->wFlags
& MF_POPUP
) ? menu
->hWnd
: 0;
2731 enterIdleSent
= TRUE
;
2732 SendMessageW( mt
.hOwnerWnd
, WM_ENTERIDLE
, MSGF_MENU
, (LPARAM
)win
);
2738 /* check if EndMenu() tried to cancel us, by posting this message */
2739 if(msg
.message
== WM_CANCELMODE
)
2741 /* we are now out of the loop */
2744 /* remove the message from the queue */
2745 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2747 /* break out of internal loop, ala ESCAPE */
2751 TranslateMessage( &msg
);
2754 if ( (msg
.hwnd
==menu
->hWnd
) || (msg
.message
!=WM_TIMER
) )
2755 enterIdleSent
=FALSE
;
2758 if ((msg
.message
>= WM_MOUSEFIRST
) && (msg
.message
<= WM_MOUSELAST
))
2761 * Use the mouse coordinates in lParam instead of those in the MSG
2762 * struct to properly handle synthetic messages. They are already
2763 * in screen coordinates.
2765 mt
.pt
.x
= SLOWORD(msg
.lParam
);
2766 mt
.pt
.y
= SHIWORD(msg
.lParam
);
2768 /* Find a menu for this mouse event */
2769 hmenu
= MENU_PtMenu( mt
.hTopMenu
, mt
.pt
);
2773 /* no WM_NC... messages in captured state */
2775 case WM_RBUTTONDBLCLK
:
2776 case WM_RBUTTONDOWN
:
2777 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2779 case WM_LBUTTONDBLCLK
:
2780 case WM_LBUTTONDOWN
:
2781 /* If the message belongs to the menu, removes it from the queue */
2782 /* Else, end menu tracking */
2783 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2784 fEndMenu
= !fRemove
;
2788 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2791 /* Check if a menu was selected by the mouse */
2794 executedMenuId
= MENU_ButtonUp( &mt
, hmenu
, wFlags
);
2796 /* End the loop if executedMenuId is an item ID */
2797 /* or if the job was done (executedMenuId = 0). */
2798 fEndMenu
= fRemove
= (executedMenuId
!= -1);
2800 /* No menu was selected by the mouse */
2801 /* if the function was called by TrackPopupMenu, continue
2802 with the menu tracking. If not, stop it */
2804 fEndMenu
= ((wFlags
& TPM_POPUPMENU
) ? FALSE
: TRUE
);
2809 /* In win95 winelook, the selected menu item must be changed every time the
2810 mouse moves. In Win31 winelook, the mouse button has to be held down */
2812 if ( hmenu
&& ((TWEAK_WineLook
> WIN31_LOOK
) ||
2813 ( (msg
.wParam
& MK_LBUTTON
) ||
2814 ((wFlags
& TPM_RIGHTBUTTON
) && (msg
.wParam
& MK_RBUTTON
)))) )
2816 fEndMenu
|= !MENU_MouseMove( &mt
, hmenu
, wFlags
);
2818 } /* switch(msg.message) - mouse */
2820 else if ((msg
.message
>= WM_KEYFIRST
) && (msg
.message
<= WM_KEYLAST
))
2822 fRemove
= TRUE
; /* Keyboard messages are always removed */
2830 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2831 NO_SELECTED_ITEM
, FALSE
, 0 );
2834 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2835 (msg
.wParam
== VK_HOME
)? ITEM_NEXT
: ITEM_PREV
);
2838 case VK_DOWN
: /* If on menu bar, pull-down the menu */
2840 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2841 if (!(menu
->wFlags
& MF_POPUP
))
2842 mt
.hCurrentMenu
= MENU_ShowSubPopup(mt
.hOwnerWnd
, mt
.hTopMenu
, TRUE
, wFlags
);
2843 else /* otherwise try to move selection */
2844 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
, ITEM_NEXT
);
2848 MENU_KeyLeft( &mt
, wFlags
);
2852 MENU_KeyRight( &mt
, wFlags
);
2856 fEndMenu
= MENU_KeyEscape(&mt
, wFlags
);
2862 hi
.cbSize
= sizeof(HELPINFO
);
2863 hi
.iContextType
= HELPINFO_MENUITEM
;
2864 if (menu
->FocusedItem
== NO_SELECTED_ITEM
)
2867 hi
.iCtrlId
= menu
->items
[menu
->FocusedItem
].wID
;
2868 hi
.hItemHandle
= hmenu
;
2869 hi
.dwContextId
= menu
->dwContextHelpID
;
2870 hi
.MousePos
= msg
.pt
;
2871 SendMessageA(hwnd
, WM_HELP
, 0, (LPARAM
)&hi
);
2878 break; /* WM_KEYDOWN */
2888 break; /* WM_SYSKEYDOWN */
2894 if (msg
.wParam
== '\r' || msg
.wParam
== ' ')
2896 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2897 fEndMenu
= (executedMenuId
!= -1);
2902 /* Hack to avoid control chars. */
2903 /* We will find a better way real soon... */
2904 if ((msg
.wParam
<= 32) || (msg
.wParam
>= 127)) break;
2906 pos
= MENU_FindItemByKey( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2907 LOWORD(msg
.wParam
), FALSE
);
2908 if (pos
== (UINT
)-2) fEndMenu
= TRUE
;
2909 else if (pos
== (UINT
)-1) MessageBeep(0);
2912 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
, pos
,
2914 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2915 fEndMenu
= (executedMenuId
!= -1);
2919 } /* switch(msg.message) - kbd */
2923 DispatchMessageA( &msg
);
2926 if (!fEndMenu
) fRemove
= TRUE
;
2928 /* finally remove message from the queue */
2930 if (fRemove
&& !(mt
.trackFlags
& TF_SKIPREMOVE
) )
2931 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2932 else mt
.trackFlags
&= ~TF_SKIPREMOVE
;
2935 MENU_SetCapture(0); /* release the capture */
2937 /* If dropdown is still painted and the close box is clicked on
2938 then the menu will be destroyed as part of the DispatchMessage above.
2939 This will then invalidate the menu handle in mt.hTopMenu. We should
2940 check for this first. */
2941 if( IsMenu( mt
.hTopMenu
) )
2943 menu
= MENU_GetMenu( mt
.hTopMenu
);
2945 if( IsWindow( mt
.hOwnerWnd
) )
2947 MENU_HideSubPopups( mt
.hOwnerWnd
, mt
.hTopMenu
, FALSE
);
2949 if (menu
&& menu
->wFlags
& MF_POPUP
)
2951 DestroyWindow( menu
->hWnd
);
2954 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2955 SendMessageA( mt
.hOwnerWnd
, WM_MENUSELECT
, MAKELONG(0,0xffff), 0 );
2958 /* Reset the variable for hiding menu */
2959 if( menu
) menu
->bTimeToHide
= FALSE
;
2962 /* The return value is only used by TrackPopupMenu */
2963 return ((executedMenuId
!= -1) ? executedMenuId
: 0);
2966 /***********************************************************************
2969 static BOOL
MENU_InitTracking(HWND hWnd
, HMENU hMenu
, BOOL bPopup
, UINT wFlags
)
2971 TRACE("hwnd=0x%04x hmenu=0x%04x\n", hWnd
, hMenu
);
2975 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2976 if (!(wFlags
& TPM_NONOTIFY
))
2977 SendMessageA( hWnd
, WM_ENTERMENULOOP
, bPopup
, 0 );
2979 SendMessageA( hWnd
, WM_SETCURSOR
, (WPARAM
)hWnd
, HTCAPTION
);
2981 if (!(wFlags
& TPM_NONOTIFY
))
2984 SendMessageA( hWnd
, WM_INITMENU
, hMenu
, 0 );
2985 if ((menu
= MENU_GetMenu( hMenu
)) && (!menu
->Height
))
2986 { /* app changed/recreated menu bar entries in WM_INITMENU
2987 Recalculate menu sizes else clicks will not work */
2988 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
2989 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
2995 /***********************************************************************
2998 static BOOL
MENU_ExitTracking(HWND hWnd
)
3000 TRACE("hwnd=0x%04x\n", hWnd
);
3002 SendMessageA( hWnd
, WM_EXITMENULOOP
, 0, 0 );
3007 /***********************************************************************
3008 * MENU_TrackMouseMenuBar
3010 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
3012 void MENU_TrackMouseMenuBar( HWND hWnd
, INT ht
, POINT pt
)
3014 HMENU hMenu
= (ht
== HTSYSMENU
) ? get_win_sys_menu( hWnd
) : GetMenu( hWnd
);
3015 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_BUTTONDOWN
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
3017 TRACE("wnd=%x ht=0x%04x (%ld,%ld)\n", hWnd
, ht
, pt
.x
, pt
.y
);
3021 /* map point to parent client coordinates */
3022 HWND parent
= GetAncestor( hWnd
, GA_PARENT
);
3023 if (parent
!= GetDesktopWindow()) ScreenToClient( parent
, &pt
);
3025 MENU_InitTracking( hWnd
, hMenu
, FALSE
, wFlags
);
3026 MENU_TrackMenu( hMenu
, wFlags
, pt
.x
, pt
.y
, hWnd
, NULL
);
3027 MENU_ExitTracking(hWnd
);
3032 /***********************************************************************
3033 * MENU_TrackKbdMenuBar
3035 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3037 void MENU_TrackKbdMenuBar( HWND hwnd
, UINT wParam
, INT vkey
)
3039 UINT uItem
= NO_SELECTED_ITEM
;
3041 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
3043 /* find window that has a menu */
3045 while (GetWindowLongA( hwnd
, GWL_STYLE
) & WS_CHILD
)
3046 if (!(hwnd
= GetParent( hwnd
))) return;
3048 /* check if we have to track a system menu */
3050 hTrackMenu
= GetMenu( hwnd
);
3051 if (!hTrackMenu
|| IsIconic(hwnd
) || vkey
== VK_SPACE
)
3053 if (!(GetWindowLongA( hwnd
, GWL_STYLE
) & WS_SYSMENU
)) return;
3054 hTrackMenu
= get_win_sys_menu( hwnd
);
3056 wParam
|= HTSYSMENU
; /* prevent item lookup */
3059 if (!IsMenu( hTrackMenu
)) return;
3061 MENU_InitTracking( hwnd
, hTrackMenu
, FALSE
, wFlags
);
3063 if( vkey
&& vkey
!= VK_SPACE
)
3065 uItem
= MENU_FindItemByKey( hwnd
, hTrackMenu
, vkey
, (wParam
& HTSYSMENU
) );
3066 if( uItem
>= (UINT
)(-2) )
3068 if( uItem
== (UINT
)(-1) ) MessageBeep(0);
3075 MENU_SelectItem( hwnd
, hTrackMenu
, uItem
, TRUE
, 0 );
3077 if( uItem
== NO_SELECTED_ITEM
)
3078 MENU_MoveSelection( hwnd
, hTrackMenu
, ITEM_NEXT
);
3080 PostMessageA( hwnd
, WM_KEYDOWN
, VK_DOWN
, 0L );
3082 MENU_TrackMenu( hTrackMenu
, wFlags
, 0, 0, hwnd
, NULL
);
3084 MENU_ExitTracking( hwnd
);
3088 /**********************************************************************
3089 * TrackPopupMenu (USER32.@)
3091 * Like the win32 API, the function return the command ID only if the
3092 * flag TPM_RETURNCMD is on.
3095 BOOL WINAPI
TrackPopupMenu( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
3096 INT nReserved
, HWND hWnd
, const RECT
*lpRect
)
3100 MENU_InitTracking(hWnd
, hMenu
, TRUE
, wFlags
);
3102 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3103 if (!(wFlags
& TPM_NONOTIFY
))
3104 SendMessageA( hWnd
, WM_INITMENUPOPUP
, hMenu
, 0);
3106 if (MENU_ShowPopup( hWnd
, hMenu
, 0, x
, y
, 0, 0 ))
3107 ret
= MENU_TrackMenu( hMenu
, wFlags
| TPM_POPUPMENU
, 0, 0, hWnd
, lpRect
);
3108 MENU_ExitTracking(hWnd
);
3110 if( (!(wFlags
& TPM_RETURNCMD
)) && (ret
!= FALSE
) )
3116 /**********************************************************************
3117 * TrackPopupMenuEx (USER32.@)
3119 BOOL WINAPI
TrackPopupMenuEx( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
3120 HWND hWnd
, LPTPMPARAMS lpTpm
)
3122 FIXME("not fully implemented\n" );
3123 return TrackPopupMenu( hMenu
, wFlags
, x
, y
, 0, hWnd
,
3124 lpTpm
? &lpTpm
->rcExclude
: NULL
);
3127 /***********************************************************************
3130 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3132 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
3134 TRACE("hwnd=0x%04x msg=0x%04x wp=0x%04x lp=0x%08lx\n",
3135 hwnd
, message
, wParam
, lParam
);
3141 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lParam
;
3142 SetWindowLongW( hwnd
, 0, (LONG
)cs
->lpCreateParams
);
3146 case WM_MOUSEACTIVATE
: /* We don't want to be activated */
3147 return MA_NOACTIVATE
;
3152 BeginPaint( hwnd
, &ps
);
3153 MENU_DrawPopupMenu( hwnd
, ps
.hdc
,
3154 (HMENU
)GetWindowLongA( hwnd
, 0 ) );
3155 EndPaint( hwnd
, &ps
);
3162 /* zero out global pointer in case resident popup window was destroyed. */
3163 if (hwnd
== top_popup
) top_popup
= 0;
3170 if (!GetWindowLongW( hwnd
, 0 )) ERR("no menu to display\n");
3173 SetWindowLongW( hwnd
, 0, 0 );
3176 case MM_SETMENUHANDLE
:
3177 SetWindowLongW( hwnd
, 0, wParam
);
3180 case MM_GETMENUHANDLE
:
3181 return GetWindowLongW( hwnd
, 0 );
3184 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
3190 /***********************************************************************
3191 * MENU_GetMenuBarHeight
3193 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3195 UINT
MENU_GetMenuBarHeight( HWND hwnd
, UINT menubarWidth
,
3196 INT orgX
, INT orgY
)
3202 TRACE("HWND 0x%x, width %d, at (%d, %d).\n",
3203 hwnd
, menubarWidth
, orgX
, orgY
);
3205 if (!(lppop
= MENU_GetMenu( GetMenu(hwnd
) ))) return 0;
3207 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| DCX_WINDOW
);
3208 SelectObject( hdc
, hMenuFont
);
3209 SetRect(&rectBar
, orgX
, orgY
, orgX
+menubarWidth
, orgY
+GetSystemMetrics(SM_CYMENU
));
3210 MENU_MenuBarCalcSize( hdc
, &rectBar
, lppop
, hwnd
);
3211 ReleaseDC( hwnd
, hdc
);
3212 return lppop
->Height
;
3216 /*******************************************************************
3217 * ChangeMenu (USER.153)
3219 BOOL16 WINAPI
ChangeMenu16( HMENU16 hMenu
, UINT16 pos
, SEGPTR data
,
3220 UINT16 id
, UINT16 flags
)
3222 TRACE("menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
3223 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3224 if (flags
& MF_APPEND
) return AppendMenu16( hMenu
, flags
& ~MF_APPEND
,
3227 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
3228 /* for MF_DELETE. We should check the parameters for all others */
3229 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
3231 if (flags
& MF_DELETE
) return DeleteMenu16(hMenu
, pos
, flags
& ~MF_DELETE
);
3232 if (flags
& MF_CHANGE
) return ModifyMenu16(hMenu
, pos
, flags
& ~MF_CHANGE
,
3234 if (flags
& MF_REMOVE
) return RemoveMenu16(hMenu
,
3235 flags
& MF_BYPOSITION
? pos
: id
,
3236 flags
& ~MF_REMOVE
);
3237 /* Default: MF_INSERT */
3238 return InsertMenu16( hMenu
, pos
, flags
, id
, data
);
3242 /*******************************************************************
3243 * ChangeMenuA (USER32.@)
3245 BOOL WINAPI
ChangeMenuA( HMENU hMenu
, UINT pos
, LPCSTR data
,
3246 UINT id
, UINT flags
)
3248 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3249 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3250 if (flags
& MF_APPEND
) return AppendMenuA( hMenu
, flags
& ~MF_APPEND
,
3252 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3253 if (flags
& MF_CHANGE
) return ModifyMenuA(hMenu
, pos
, flags
& ~MF_CHANGE
,
3255 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3256 flags
& MF_BYPOSITION
? pos
: id
,
3257 flags
& ~MF_REMOVE
);
3258 /* Default: MF_INSERT */
3259 return InsertMenuA( hMenu
, pos
, flags
, id
, data
);
3263 /*******************************************************************
3264 * ChangeMenuW (USER32.@)
3266 BOOL WINAPI
ChangeMenuW( HMENU hMenu
, UINT pos
, LPCWSTR data
,
3267 UINT id
, UINT flags
)
3269 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3270 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3271 if (flags
& MF_APPEND
) return AppendMenuW( hMenu
, flags
& ~MF_APPEND
,
3273 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3274 if (flags
& MF_CHANGE
) return ModifyMenuW(hMenu
, pos
, flags
& ~MF_CHANGE
,
3276 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3277 flags
& MF_BYPOSITION
? pos
: id
,
3278 flags
& ~MF_REMOVE
);
3279 /* Default: MF_INSERT */
3280 return InsertMenuW( hMenu
, pos
, flags
, id
, data
);
3284 /*******************************************************************
3285 * CheckMenuItem (USER.154)
3287 BOOL16 WINAPI
CheckMenuItem16( HMENU16 hMenu
, UINT16 id
, UINT16 flags
)
3289 return (BOOL16
)CheckMenuItem( hMenu
, id
, flags
);
3293 /*******************************************************************
3294 * CheckMenuItem (USER32.@)
3296 DWORD WINAPI
CheckMenuItem( HMENU hMenu
, UINT id
, UINT flags
)
3301 TRACE("menu=%04x id=%04x flags=%04x\n", hMenu
, id
, flags
);
3302 if (!(item
= MENU_FindItem( &hMenu
, &id
, flags
))) return -1;
3303 ret
= item
->fState
& MF_CHECKED
;
3304 if (flags
& MF_CHECKED
) item
->fState
|= MF_CHECKED
;
3305 else item
->fState
&= ~MF_CHECKED
;
3310 /**********************************************************************
3311 * EnableMenuItem (USER.155)
3313 UINT16 WINAPI
EnableMenuItem16( HMENU16 hMenu
, UINT16 wItemID
, UINT16 wFlags
)
3315 return EnableMenuItem( hMenu
, wItemID
, wFlags
);
3319 /**********************************************************************
3320 * EnableMenuItem (USER32.@)
3322 UINT WINAPI
EnableMenuItem( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3328 TRACE("(%04x, %04X, %04X) !\n",
3329 hMenu
, wItemID
, wFlags
);
3331 /* Get the Popupmenu to access the owner menu */
3332 if (!(menu
= MENU_GetMenu(hMenu
)))
3335 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
)))
3338 oldflags
= item
->fState
& (MF_GRAYED
| MF_DISABLED
);
3339 item
->fState
^= (oldflags
^ wFlags
) & (MF_GRAYED
| MF_DISABLED
);
3341 /* In win95 if the close item in the system menu change update the close button */
3342 if (TWEAK_WineLook
== WIN95_LOOK
)
3343 if((item
->wID
== SC_CLOSE
) && (oldflags
!= wFlags
))
3345 if (menu
->hSysMenuOwner
!= 0)
3347 POPUPMENU
* parentMenu
;
3349 /* Get the parent menu to access*/
3350 if (!(parentMenu
= MENU_GetMenu(menu
->hSysMenuOwner
)))
3353 /* Refresh the frame to reflect the change*/
3354 SetWindowPos(parentMenu
->hWnd
, 0, 0, 0, 0, 0,
3355 SWP_NOACTIVATE
| SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
);
3363 /*******************************************************************
3364 * GetMenuString (USER.161)
3366 INT16 WINAPI
GetMenuString16( HMENU16 hMenu
, UINT16 wItemID
,
3367 LPSTR str
, INT16 nMaxSiz
, UINT16 wFlags
)
3369 return GetMenuStringA( hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3373 /*******************************************************************
3374 * GetMenuStringA (USER32.@)
3376 INT WINAPI
GetMenuStringA(
3377 HMENU hMenu
, /* [in] menuhandle */
3378 UINT wItemID
, /* [in] menu item (dep. on wFlags) */
3379 LPSTR str
, /* [out] outbuffer. If NULL, func returns entry length*/
3380 INT nMaxSiz
, /* [in] length of buffer. if 0, func returns entry len*/
3381 UINT wFlags
/* [in] MF_ flags */
3385 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3386 hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3387 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3388 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3389 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3391 if (!WideCharToMultiByte( CP_ACP
, 0, item
->text
, -1, str
, nMaxSiz
, NULL
, NULL
))
3393 TRACE("returning '%s'\n", str
);
3398 /*******************************************************************
3399 * GetMenuStringW (USER32.@)
3401 INT WINAPI
GetMenuStringW( HMENU hMenu
, UINT wItemID
,
3402 LPWSTR str
, INT nMaxSiz
, UINT wFlags
)
3406 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3407 hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3408 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3409 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3410 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3412 lstrcpynW( str
, item
->text
, nMaxSiz
);
3413 return strlenW(str
);
3417 /**********************************************************************
3418 * HiliteMenuItem (USER32.@)
3420 BOOL WINAPI
HiliteMenuItem( HWND hWnd
, HMENU hMenu
, UINT wItemID
,
3424 TRACE("(%04x, %04x, %04x, %04x);\n",
3425 hWnd
, hMenu
, wItemID
, wHilite
);
3426 if (!MENU_FindItem( &hMenu
, &wItemID
, wHilite
)) return FALSE
;
3427 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3428 if (menu
->FocusedItem
== wItemID
) return TRUE
;
3429 MENU_HideSubPopups( hWnd
, hMenu
, FALSE
);
3430 MENU_SelectItem( hWnd
, hMenu
, wItemID
, TRUE
, 0 );
3435 /**********************************************************************
3436 * GetMenuState (USER.250)
3438 UINT16 WINAPI
GetMenuState16( HMENU16 hMenu
, UINT16 wItemID
, UINT16 wFlags
)
3440 return GetMenuState( hMenu
, wItemID
, wFlags
);
3444 /**********************************************************************
3445 * GetMenuState (USER32.@)
3447 UINT WINAPI
GetMenuState( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3450 TRACE("(menu=%04x, id=%04x, flags=%04x);\n",
3451 hMenu
, wItemID
, wFlags
);
3452 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return -1;
3453 debug_print_menuitem (" item: ", item
, "");
3454 if (item
->fType
& MF_POPUP
)
3456 POPUPMENU
*menu
= MENU_GetMenu( item
->hSubMenu
);
3457 if (!menu
) return -1;
3458 else return (menu
->nItems
<< 8) | ((item
->fState
|item
->fType
) & 0xff);
3462 /* We used to (from way back then) mask the result to 0xff. */
3463 /* I don't know why and it seems wrong as the documented */
3464 /* return flag MF_SEPARATOR is outside that mask. */
3465 return (item
->fType
| item
->fState
);
3470 /**********************************************************************
3471 * GetMenuItemCount (USER.263)
3473 INT16 WINAPI
GetMenuItemCount16( HMENU16 hMenu
)
3475 LPPOPUPMENU menu
= MENU_GetMenu(hMenu
);
3476 if (!menu
) return -1;
3477 TRACE("(%04x) returning %d\n",
3478 hMenu
, menu
->nItems
);
3479 return menu
->nItems
;
3483 /**********************************************************************
3484 * GetMenuItemCount (USER32.@)
3486 INT WINAPI
GetMenuItemCount( HMENU hMenu
)
3488 LPPOPUPMENU menu
= MENU_GetMenu(hMenu
);
3489 if (!menu
) return -1;
3490 TRACE("(%04x) returning %d\n",
3491 hMenu
, menu
->nItems
);
3492 return menu
->nItems
;
3495 /**********************************************************************
3496 * GetMenuItemID (USER.264)
3498 UINT16 WINAPI
GetMenuItemID16( HMENU16 hMenu
, INT16 nPos
)
3500 return (UINT16
) GetMenuItemID (hMenu
, nPos
);
3503 /**********************************************************************
3504 * GetMenuItemID (USER32.@)
3506 UINT WINAPI
GetMenuItemID( HMENU hMenu
, INT nPos
)
3510 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return -1;
3511 if (lpmi
->fType
& MF_POPUP
) return -1;
3516 /*******************************************************************
3517 * InsertMenu (USER.410)
3519 BOOL16 WINAPI
InsertMenu16( HMENU16 hMenu
, UINT16 pos
, UINT16 flags
,
3520 UINT16 id
, SEGPTR data
)
3522 UINT pos32
= (UINT
)pos
;
3523 if ((pos
== (UINT16
)-1) && (flags
& MF_BYPOSITION
)) pos32
= (UINT
)-1;
3524 if (IS_STRING_ITEM(flags
) && data
)
3525 return InsertMenuA( hMenu
, pos32
, flags
, id
, MapSL(data
) );
3526 return InsertMenuA( hMenu
, pos32
, flags
, id
, (LPSTR
)data
);
3530 /*******************************************************************
3531 * InsertMenuW (USER32.@)
3533 BOOL WINAPI
InsertMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3534 UINT_PTR id
, LPCWSTR str
)
3538 if (IS_STRING_ITEM(flags
) && str
)
3539 TRACE("hMenu %04x, pos %d, flags %08x, "
3540 "id %04x, str %s\n",
3541 hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3542 else TRACE("hMenu %04x, pos %d, flags %08x, "
3543 "id %04x, str %08lx (not a string)\n",
3544 hMenu
, pos
, flags
, id
, (DWORD
)str
);
3546 if (!(item
= MENU_InsertItem( hMenu
, pos
, flags
))) return FALSE
;
3548 if (!(MENU_SetItemData( item
, flags
, id
, str
)))
3550 RemoveMenu( hMenu
, pos
, flags
);
3554 if (flags
& MF_POPUP
) /* Set the MF_POPUP flag on the popup-menu */
3555 (MENU_GetMenu((HMENU16
)id
))->wFlags
|= MF_POPUP
;
3557 item
->hCheckBit
= item
->hUnCheckBit
= 0;
3562 /*******************************************************************
3563 * InsertMenuA (USER32.@)
3565 BOOL WINAPI
InsertMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3566 UINT_PTR id
, LPCSTR str
)
3570 if (IS_STRING_ITEM(flags
) && str
)
3572 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3573 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3576 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3577 ret
= InsertMenuW( hMenu
, pos
, flags
, id
, newstr
);
3578 HeapFree( GetProcessHeap(), 0, newstr
);
3582 else return InsertMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3586 /*******************************************************************
3587 * AppendMenu (USER.411)
3589 BOOL16 WINAPI
AppendMenu16(HMENU16 hMenu
, UINT16 flags
, UINT16 id
, SEGPTR data
)
3591 return InsertMenu16( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3595 /*******************************************************************
3596 * AppendMenuA (USER32.@)
3598 BOOL WINAPI
AppendMenuA( HMENU hMenu
, UINT flags
,
3599 UINT_PTR id
, LPCSTR data
)
3601 return InsertMenuA( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3605 /*******************************************************************
3606 * AppendMenuW (USER32.@)
3608 BOOL WINAPI
AppendMenuW( HMENU hMenu
, UINT flags
,
3609 UINT_PTR id
, LPCWSTR data
)
3611 return InsertMenuW( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3615 /**********************************************************************
3616 * RemoveMenu (USER.412)
3618 BOOL16 WINAPI
RemoveMenu16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
)
3620 return RemoveMenu( hMenu
, nPos
, wFlags
);
3624 /**********************************************************************
3625 * RemoveMenu (USER32.@)
3627 BOOL WINAPI
RemoveMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3632 TRACE("(menu=%04x pos=%04x flags=%04x)\n",hMenu
, nPos
, wFlags
);
3633 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3634 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3638 MENU_FreeItemData( item
);
3640 if (--menu
->nItems
== 0)
3642 HeapFree( GetProcessHeap(), 0, menu
->items
);
3647 while(nPos
< menu
->nItems
)
3653 menu
->items
= HeapReAlloc( GetProcessHeap(), 0, menu
->items
,
3654 menu
->nItems
* sizeof(MENUITEM
) );
3660 /**********************************************************************
3661 * DeleteMenu (USER.413)
3663 BOOL16 WINAPI
DeleteMenu16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
)
3665 return DeleteMenu( hMenu
, nPos
, wFlags
);
3669 /**********************************************************************
3670 * DeleteMenu (USER32.@)
3672 BOOL WINAPI
DeleteMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3674 MENUITEM
*item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
);
3675 if (!item
) return FALSE
;
3676 if (item
->fType
& MF_POPUP
) DestroyMenu( item
->hSubMenu
);
3677 /* nPos is now the position of the item */
3678 RemoveMenu( hMenu
, nPos
, wFlags
| MF_BYPOSITION
);
3683 /*******************************************************************
3684 * ModifyMenu (USER.414)
3686 BOOL16 WINAPI
ModifyMenu16( HMENU16 hMenu
, UINT16 pos
, UINT16 flags
,
3687 UINT16 id
, SEGPTR data
)
3689 if (IS_STRING_ITEM(flags
))
3690 return ModifyMenuA( hMenu
, pos
, flags
, id
, MapSL(data
) );
3691 return ModifyMenuA( hMenu
, pos
, flags
, id
, (LPSTR
)data
);
3695 /*******************************************************************
3696 * ModifyMenuW (USER32.@)
3698 BOOL WINAPI
ModifyMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3699 UINT_PTR id
, LPCWSTR str
)
3703 if (IS_STRING_ITEM(flags
))
3705 TRACE("%04x %d %04x %04x %s\n",
3706 hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3707 if (!str
) return FALSE
;
3711 TRACE("%04x %d %04x %04x %08lx\n",
3712 hMenu
, pos
, flags
, id
, (DWORD
)str
);
3715 if (!(item
= MENU_FindItem( &hMenu
, &pos
, flags
))) return FALSE
;
3716 return MENU_SetItemData( item
, flags
, id
, str
);
3720 /*******************************************************************
3721 * ModifyMenuA (USER32.@)
3723 BOOL WINAPI
ModifyMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3724 UINT_PTR id
, LPCSTR str
)
3728 if (IS_STRING_ITEM(flags
) && str
)
3730 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3731 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3734 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3735 ret
= ModifyMenuW( hMenu
, pos
, flags
, id
, newstr
);
3736 HeapFree( GetProcessHeap(), 0, newstr
);
3740 else return ModifyMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3744 /**********************************************************************
3745 * CreatePopupMenu (USER.415)
3747 HMENU16 WINAPI
CreatePopupMenu16(void)
3749 return CreatePopupMenu();
3753 /**********************************************************************
3754 * CreatePopupMenu (USER32.@)
3756 HMENU WINAPI
CreatePopupMenu(void)
3761 if (!(hmenu
= CreateMenu())) return 0;
3762 menu
= MENU_GetMenu( hmenu
);
3763 menu
->wFlags
|= MF_POPUP
;
3764 menu
->bTimeToHide
= FALSE
;
3769 /**********************************************************************
3770 * GetMenuCheckMarkDimensions (USER.417)
3771 * GetMenuCheckMarkDimensions (USER32.@)
3773 DWORD WINAPI
GetMenuCheckMarkDimensions(void)
3775 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK
), GetSystemMetrics(SM_CYMENUCHECK
) );
3779 /**********************************************************************
3780 * SetMenuItemBitmaps (USER.418)
3782 BOOL16 WINAPI
SetMenuItemBitmaps16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
,
3783 HBITMAP16 hNewUnCheck
, HBITMAP16 hNewCheck
)
3785 return SetMenuItemBitmaps( hMenu
, nPos
, wFlags
, hNewUnCheck
, hNewCheck
);
3789 /**********************************************************************
3790 * SetMenuItemBitmaps (USER32.@)
3792 BOOL WINAPI
SetMenuItemBitmaps( HMENU hMenu
, UINT nPos
, UINT wFlags
,
3793 HBITMAP hNewUnCheck
, HBITMAP hNewCheck
)
3796 TRACE("(%04x, %04x, %04x, %04x, %04x)\n",
3797 hMenu
, nPos
, wFlags
, hNewCheck
, hNewUnCheck
);
3798 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3800 if (!hNewCheck
&& !hNewUnCheck
)
3802 item
->fState
&= ~MF_USECHECKBITMAPS
;
3804 else /* Install new bitmaps */
3806 item
->hCheckBit
= hNewCheck
;
3807 item
->hUnCheckBit
= hNewUnCheck
;
3808 item
->fState
|= MF_USECHECKBITMAPS
;
3814 /**********************************************************************
3815 * CreateMenu (USER.151)
3817 HMENU16 WINAPI
CreateMenu16(void)
3819 return CreateMenu();
3823 /**********************************************************************
3824 * CreateMenu (USER32.@)
3826 HMENU WINAPI
CreateMenu(void)
3830 if (!(hMenu
= USER_HEAP_ALLOC( sizeof(POPUPMENU
) ))) return 0;
3831 menu
= (LPPOPUPMENU
) USER_HEAP_LIN_ADDR(hMenu
);
3833 ZeroMemory(menu
, sizeof(POPUPMENU
));
3834 menu
->wMagic
= MENU_MAGIC
;
3835 menu
->FocusedItem
= NO_SELECTED_ITEM
;
3836 menu
->bTimeToHide
= FALSE
;
3838 TRACE("return %04x\n", hMenu
);
3844 /**********************************************************************
3845 * DestroyMenu (USER.152)
3847 BOOL16 WINAPI
DestroyMenu16( HMENU16 hMenu
)
3849 return DestroyMenu( hMenu
);
3853 /**********************************************************************
3854 * DestroyMenu (USER32.@)
3856 BOOL WINAPI
DestroyMenu( HMENU hMenu
)
3858 TRACE("(%04x)\n", hMenu
);
3860 /* Silently ignore attempts to destroy default system popup */
3862 if (hMenu
&& hMenu
!= MENU_DefSysPopup
)
3864 LPPOPUPMENU lppop
= MENU_GetMenu(hMenu
);
3866 if (!lppop
) return FALSE
;
3868 lppop
->wMagic
= 0; /* Mark it as destroyed */
3870 if ((lppop
->wFlags
& MF_POPUP
) && lppop
->hWnd
)
3872 DestroyWindow( lppop
->hWnd
);
3876 if (lppop
->items
) /* recursively destroy submenus */
3879 MENUITEM
*item
= lppop
->items
;
3880 for (i
= lppop
->nItems
; i
> 0; i
--, item
++)
3882 if (item
->fType
& MF_POPUP
) DestroyMenu(item
->hSubMenu
);
3883 MENU_FreeItemData( item
);
3885 HeapFree( GetProcessHeap(), 0, lppop
->items
);
3887 USER_HEAP_FREE( hMenu
);
3889 return (hMenu
!= MENU_DefSysPopup
);
3893 /**********************************************************************
3894 * GetSystemMenu (USER32.@)
3896 HMENU WINAPI
GetSystemMenu( HWND hWnd
, BOOL bRevert
)
3898 WND
*wndPtr
= WIN_FindWndPtr( hWnd
);
3903 if( wndPtr
->hSysMenu
)
3907 DestroyMenu(wndPtr
->hSysMenu
);
3908 wndPtr
->hSysMenu
= 0;
3912 POPUPMENU
*menu
= MENU_GetMenu( wndPtr
->hSysMenu
);
3915 if( menu
->nItems
> 0 && menu
->items
[0].hSubMenu
== MENU_DefSysPopup
)
3916 menu
->items
[0].hSubMenu
= MENU_CopySysPopup();
3920 WARN("Current sys-menu (%04x) of wnd %04x is broken\n",
3921 wndPtr
->hSysMenu
, hWnd
);
3922 wndPtr
->hSysMenu
= 0;
3927 if(!wndPtr
->hSysMenu
&& (wndPtr
->dwStyle
& WS_SYSMENU
) )
3928 wndPtr
->hSysMenu
= MENU_GetSysMenu( hWnd
, (HMENU
)(-1) );
3930 if( wndPtr
->hSysMenu
)
3933 retvalue
= GetSubMenu(wndPtr
->hSysMenu
, 0);
3935 /* Store the dummy sysmenu handle to facilitate the refresh */
3936 /* of the close button if the SC_CLOSE item change */
3937 menu
= MENU_GetMenu(retvalue
);
3939 menu
->hSysMenuOwner
= wndPtr
->hSysMenu
;
3941 WIN_ReleaseWndPtr(wndPtr
);
3943 return bRevert
? 0 : retvalue
;
3947 /*******************************************************************
3948 * SetSystemMenu (USER32.@)
3950 BOOL WINAPI
SetSystemMenu( HWND hwnd
, HMENU hMenu
)
3952 WND
*wndPtr
= WIN_FindWndPtr(hwnd
);
3956 if (wndPtr
->hSysMenu
) DestroyMenu( wndPtr
->hSysMenu
);
3957 wndPtr
->hSysMenu
= MENU_GetSysMenu( hwnd
, hMenu
);
3958 WIN_ReleaseWndPtr(wndPtr
);
3965 /**********************************************************************
3966 * GetMenu (USER32.@)
3968 HMENU WINAPI
GetMenu( HWND hWnd
)
3970 HMENU retvalue
= (HMENU
)GetWindowLongA( hWnd
, GWL_ID
);
3971 TRACE("for %04x returning %04x\n", hWnd
, retvalue
);
3976 /**********************************************************************
3977 * SetMenu (USER32.@)
3979 BOOL WINAPI
SetMenu( HWND hWnd
, HMENU hMenu
)
3981 TRACE("(%04x, %04x);\n", hWnd
, hMenu
);
3983 if (hMenu
&& !IsMenu(hMenu
))
3985 WARN("hMenu %x is not a menu handle\n", hMenu
);
3988 if (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
3990 hWnd
= WIN_GetFullHandle( hWnd
);
3991 if (GetCapture() == hWnd
) MENU_SetCapture(0); /* release the capture */
3997 if (!(lpmenu
= MENU_GetMenu(hMenu
))) return FALSE
;
3999 lpmenu
->hWnd
= hWnd
;
4000 lpmenu
->Height
= 0; /* Make sure we recalculate the size */
4002 SetWindowLongA( hWnd
, GWL_ID
, hMenu
);
4004 if (IsWindowVisible(hWnd
))
4005 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
4006 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
4012 /**********************************************************************
4013 * GetSubMenu (USER.159)
4015 HMENU16 WINAPI
GetSubMenu16( HMENU16 hMenu
, INT16 nPos
)
4017 return GetSubMenu( hMenu
, nPos
);
4021 /**********************************************************************
4022 * GetSubMenu (USER32.@)
4024 HMENU WINAPI
GetSubMenu( HMENU hMenu
, INT nPos
)
4028 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return 0;
4029 if (!(lpmi
->fType
& MF_POPUP
)) return 0;
4030 return lpmi
->hSubMenu
;
4034 /**********************************************************************
4035 * DrawMenuBar (USER32.@)
4037 BOOL WINAPI
DrawMenuBar( HWND hWnd
)
4040 HMENU hMenu
= GetMenu(hWnd
);
4042 if (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
4043 if (!hMenu
|| !(lppop
= MENU_GetMenu( hMenu
))) return FALSE
;
4045 lppop
->Height
= 0; /* Make sure we call MENU_MenuBarCalcSize */
4046 lppop
->hwndOwner
= hWnd
;
4047 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
4048 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
4052 /***********************************************************************
4053 * DrawMenuBarTemp (USER32.@)
4057 * called by W98SE desk.cpl Control Panel Applet
4059 * Not 100% sure about the param names, but close.
4061 DWORD WINAPI
DrawMenuBarTemp(HWND someHWND
, HDC someHDC
, LPRECT someRECT
, HMENU someHMENU
, HFONT someFONT
)
4063 FIXME("(0x%08x, 0x%08x, %p, 0x%08x, 0x%08x): stub\n", someHWND
, someHDC
, someRECT
, someHMENU
, someFONT
);
4067 /***********************************************************************
4068 * EndMenu (USER.187)
4069 * EndMenu (USER32.@)
4071 void WINAPI
EndMenu(void)
4073 /* if we are in the menu code, and it is active */
4074 if (!fEndMenu
&& top_popup
)
4076 /* terminate the menu handling code */
4079 /* needs to be posted to wakeup the internal menu handler */
4080 /* which will now terminate the menu, in the event that */
4081 /* the main window was minimized, or lost focus, so we */
4082 /* don't end up with an orphaned menu */
4083 PostMessageA( top_popup
, WM_CANCELMODE
, 0, 0);
4088 /***********************************************************************
4089 * LookupMenuHandle (USER.217)
4091 HMENU16 WINAPI
LookupMenuHandle16( HMENU16 hmenu
, INT16 id
)
4093 HMENU hmenu32
= hmenu
;
4095 if (!MENU_FindItem( &hmenu32
, &id32
, MF_BYCOMMAND
)) return 0;
4096 else return hmenu32
;
4100 /**********************************************************************
4101 * LoadMenu (USER.150)
4103 HMENU16 WINAPI
LoadMenu16( HINSTANCE16 instance
, LPCSTR name
)
4109 TRACE("(%04x,%s)\n", instance
, debugstr_a(name
) );
4113 if (name
[0] == '#') name
= (LPCSTR
)atoi( name
+ 1 );
4116 if (!name
) return 0;
4118 /* check for Win32 module */
4119 if (HIWORD(instance
)) return LoadMenuA( instance
, name
);
4120 instance
= GetExePtr( instance
);
4122 if (!(hRsrc
= FindResource16( instance
, name
, RT_MENUA
))) return 0;
4123 if (!(handle
= LoadResource16( instance
, hRsrc
))) return 0;
4124 hMenu
= LoadMenuIndirect16(LockResource16(handle
));
4125 FreeResource16( handle
);
4130 /*****************************************************************
4131 * LoadMenuA (USER32.@)
4133 HMENU WINAPI
LoadMenuA( HINSTANCE instance
, LPCSTR name
)
4135 HRSRC hrsrc
= FindResourceA( instance
, name
, RT_MENUA
);
4136 if (!hrsrc
) return 0;
4137 return LoadMenuIndirectA( (LPCVOID
)LoadResource( instance
, hrsrc
));
4141 /*****************************************************************
4142 * LoadMenuW (USER32.@)
4144 HMENU WINAPI
LoadMenuW( HINSTANCE instance
, LPCWSTR name
)
4146 HRSRC hrsrc
= FindResourceW( instance
, name
, RT_MENUW
);
4147 if (!hrsrc
) return 0;
4148 return LoadMenuIndirectW( (LPCVOID
)LoadResource( instance
, hrsrc
));
4152 /**********************************************************************
4153 * LoadMenuIndirect (USER.220)
4155 HMENU16 WINAPI
LoadMenuIndirect16( LPCVOID
template )
4158 WORD version
, offset
;
4159 LPCSTR p
= (LPCSTR
)template;
4161 TRACE("(%p)\n", template );
4162 version
= GET_WORD(p
);
4166 WARN("version must be 0 for Win16\n" );
4169 offset
= GET_WORD(p
);
4170 p
+= sizeof(WORD
) + offset
;
4171 if (!(hMenu
= CreateMenu())) return 0;
4172 if (!MENU_ParseResource( p
, hMenu
, FALSE
))
4174 DestroyMenu( hMenu
);
4181 /**********************************************************************
4182 * LoadMenuIndirectA (USER32.@)
4184 HMENU WINAPI
LoadMenuIndirectA( LPCVOID
template )
4187 WORD version
, offset
;
4188 LPCSTR p
= (LPCSTR
)template;
4190 version
= GET_WORD(p
);
4192 TRACE("%p, ver %d\n", template, version
);
4195 case 0: /* standard format is version of 0 */
4196 offset
= GET_WORD(p
);
4197 p
+= sizeof(WORD
) + offset
;
4198 if (!(hMenu
= CreateMenu())) return 0;
4199 if (!MENU_ParseResource( p
, hMenu
, TRUE
))
4201 DestroyMenu( hMenu
);
4205 case 1: /* extended format is version of 1 */
4206 offset
= GET_WORD(p
);
4207 p
+= sizeof(WORD
) + offset
;
4208 if (!(hMenu
= CreateMenu())) return 0;
4209 if (!MENUEX_ParseResource( p
, hMenu
))
4211 DestroyMenu( hMenu
);
4216 ERR("version %d not supported.\n", version
);
4222 /**********************************************************************
4223 * LoadMenuIndirectW (USER32.@)
4225 HMENU WINAPI
LoadMenuIndirectW( LPCVOID
template )
4227 /* FIXME: is there anything different between A and W? */
4228 return LoadMenuIndirectA( template );
4232 /**********************************************************************
4235 BOOL16 WINAPI
IsMenu16( HMENU16 hmenu
)
4237 return IsMenu( hmenu
);
4241 /**********************************************************************
4244 BOOL WINAPI
IsMenu(HMENU hmenu
)
4246 LPPOPUPMENU menu
= MENU_GetMenu(hmenu
);
4247 return menu
!= NULL
;
4250 /**********************************************************************
4251 * GetMenuItemInfo_common
4254 static BOOL
GetMenuItemInfo_common ( HMENU hmenu
, UINT item
, BOOL bypos
,
4255 LPMENUITEMINFOW lpmii
, BOOL unicode
)
4257 MENUITEM
*menu
= MENU_FindItem (&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0);
4259 debug_print_menuitem("GetMenuItemInfo_common: ", menu
, "");
4264 if (lpmii
->fMask
& MIIM_TYPE
) {
4265 lpmii
->fType
= menu
->fType
;
4266 switch (MENU_ITEM_TYPE(menu
->fType
)) {
4268 break; /* will be done below */
4271 lpmii
->dwTypeData
= menu
->text
;
4278 /* copy the text string */
4279 if ((lpmii
->fMask
& (MIIM_TYPE
|MIIM_STRING
)) &&
4280 (MENU_ITEM_TYPE(menu
->fType
) == MF_STRING
) && menu
->text
)
4285 len
= strlenW(menu
->text
);
4286 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4287 lstrcpynW(lpmii
->dwTypeData
, menu
->text
, lpmii
->cch
);
4291 len
= WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1, NULL
, 0, NULL
, NULL
);
4292 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4293 if (!WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1,
4294 (LPSTR
)lpmii
->dwTypeData
, lpmii
->cch
, NULL
, NULL
))
4295 ((LPSTR
)lpmii
->dwTypeData
)[lpmii
->cch
-1] = 0;
4297 /* if we've copied a substring we return its length */
4298 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4300 if (lpmii
->cch
<= len
) lpmii
->cch
--;
4302 else /* return length of string */
4306 if (lpmii
->fMask
& MIIM_FTYPE
)
4307 lpmii
->fType
= menu
->fType
;
4309 if (lpmii
->fMask
& MIIM_BITMAP
)
4310 lpmii
->hbmpItem
= menu
->hbmpItem
;
4312 if (lpmii
->fMask
& MIIM_STATE
)
4313 lpmii
->fState
= menu
->fState
;
4315 if (lpmii
->fMask
& MIIM_ID
)
4316 lpmii
->wID
= menu
->wID
;
4318 if (lpmii
->fMask
& MIIM_SUBMENU
)
4319 lpmii
->hSubMenu
= menu
->hSubMenu
;
4321 if (lpmii
->fMask
& MIIM_CHECKMARKS
) {
4322 lpmii
->hbmpChecked
= menu
->hCheckBit
;
4323 lpmii
->hbmpUnchecked
= menu
->hUnCheckBit
;
4325 if (lpmii
->fMask
& MIIM_DATA
)
4326 lpmii
->dwItemData
= menu
->dwItemData
;
4331 /**********************************************************************
4332 * GetMenuItemInfoA (USER32.@)
4334 BOOL WINAPI
GetMenuItemInfoA( HMENU hmenu
, UINT item
, BOOL bypos
,
4335 LPMENUITEMINFOA lpmii
)
4337 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4338 (LPMENUITEMINFOW
)lpmii
, FALSE
);
4341 /**********************************************************************
4342 * GetMenuItemInfoW (USER32.@)
4344 BOOL WINAPI
GetMenuItemInfoW( HMENU hmenu
, UINT item
, BOOL bypos
,
4345 LPMENUITEMINFOW lpmii
)
4347 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4352 /* set a menu item text from a ASCII or Unicode string */
4353 inline static void set_menu_item_text( MENUITEM
*menu
, LPCWSTR text
, BOOL unicode
)
4358 menu
->fType
|= MF_SEPARATOR
;
4362 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(text
)+1) * sizeof(WCHAR
) )))
4363 strcpyW( menu
->text
, text
);
4367 LPCSTR str
= (LPCSTR
)text
;
4368 int len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
4369 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
4370 MultiByteToWideChar( CP_ACP
, 0, str
, -1, menu
->text
, len
);
4375 /**********************************************************************
4376 * SetMenuItemInfo_common
4379 static BOOL
SetMenuItemInfo_common(MENUITEM
* menu
,
4380 const MENUITEMINFOW
*lpmii
,
4383 if (!menu
) return FALSE
;
4385 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu
, "");
4387 if (lpmii
->fMask
& MIIM_TYPE
) {
4388 /* Get rid of old string. */
4389 if (IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4390 HeapFree(GetProcessHeap(), 0, menu
->text
);
4394 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4395 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4396 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4398 menu
->text
= lpmii
->dwTypeData
;
4400 if (IS_STRING_ITEM(menu
->fType
))
4401 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4404 if (lpmii
->fMask
& MIIM_FTYPE
) {
4405 /* free the string when the type is changing */
4406 if ( (!IS_STRING_ITEM(lpmii
->fType
)) && IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4407 HeapFree(GetProcessHeap(), 0, menu
->text
);
4410 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4411 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4412 if ( IS_STRING_ITEM(menu
->fType
) && !menu
->text
)
4413 menu
->fType
|= MF_SEPARATOR
;
4416 if (lpmii
->fMask
& MIIM_STRING
) {
4417 /* free the string when used */
4418 if (IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4419 HeapFree(GetProcessHeap(), 0, menu
->text
);
4420 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4424 if (lpmii
->fMask
& MIIM_STATE
)
4426 /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4427 menu
->fState
= lpmii
->fState
;
4430 if (lpmii
->fMask
& MIIM_ID
)
4431 menu
->wID
= lpmii
->wID
;
4433 if (lpmii
->fMask
& MIIM_SUBMENU
) {
4434 menu
->hSubMenu
= lpmii
->hSubMenu
;
4435 if (menu
->hSubMenu
) {
4436 POPUPMENU
*subMenu
= MENU_GetMenu(menu
->hSubMenu
);
4438 subMenu
->wFlags
|= MF_POPUP
;
4439 menu
->fType
|= MF_POPUP
;
4442 /* FIXME: Return an error ? */
4443 menu
->fType
&= ~MF_POPUP
;
4446 menu
->fType
&= ~MF_POPUP
;
4449 if (lpmii
->fMask
& MIIM_CHECKMARKS
)
4451 if (lpmii
->fType
& MFT_RADIOCHECK
)
4452 menu
->fType
|= MFT_RADIOCHECK
;
4454 menu
->hCheckBit
= lpmii
->hbmpChecked
;
4455 menu
->hUnCheckBit
= lpmii
->hbmpUnchecked
;
4457 if (lpmii
->fMask
& MIIM_DATA
)
4458 menu
->dwItemData
= lpmii
->dwItemData
;
4460 debug_print_menuitem("SetMenuItemInfo_common to : ", menu
, "");
4464 /**********************************************************************
4465 * SetMenuItemInfoA (USER32.@)
4467 BOOL WINAPI
SetMenuItemInfoA(HMENU hmenu
, UINT item
, BOOL bypos
,
4468 const MENUITEMINFOA
*lpmii
)
4470 if ((lpmii
->fType
& (MF_HILITE
|MF_POPUP
)) || (lpmii
->fState
)) {
4471 /* QuickTime does pass invalid data into SetMenuItemInfo.
4472 * do some of the checks Windows does.
4474 WARN("Bad masks for type (0x%08x) or state (0x%08x)\n",
4475 lpmii
->fType
,lpmii
->fState
);
4479 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4480 (const MENUITEMINFOW
*)lpmii
, FALSE
);
4483 /**********************************************************************
4484 * SetMenuItemInfoW (USER32.@)
4486 BOOL WINAPI
SetMenuItemInfoW(HMENU hmenu
, UINT item
, BOOL bypos
,
4487 const MENUITEMINFOW
*lpmii
)
4489 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4493 /**********************************************************************
4494 * SetMenuDefaultItem (USER32.@)
4497 BOOL WINAPI
SetMenuDefaultItem(HMENU hmenu
, UINT uItem
, UINT bypos
)
4503 TRACE("(0x%x,%d,%d)\n", hmenu
, uItem
, bypos
);
4505 if (!(menu
= MENU_GetMenu(hmenu
))) return FALSE
;
4507 /* reset all default-item flags */
4509 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4511 item
->fState
&= ~MFS_DEFAULT
;
4514 /* no default item */
4523 if ( uItem
>= menu
->nItems
) return FALSE
;
4524 item
[uItem
].fState
|= MFS_DEFAULT
;
4529 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4531 if (item
->wID
== uItem
)
4533 item
->fState
|= MFS_DEFAULT
;
4542 /**********************************************************************
4543 * GetMenuDefaultItem (USER32.@)
4545 UINT WINAPI
GetMenuDefaultItem(HMENU hmenu
, UINT bypos
, UINT flags
)
4551 TRACE("(0x%x,%d,%d)\n", hmenu
, bypos
, flags
);
4553 if (!(menu
= MENU_GetMenu(hmenu
))) return -1;
4555 /* find default item */
4559 if (! item
) return -1;
4561 while ( !( item
->fState
& MFS_DEFAULT
) )
4564 if (i
>= menu
->nItems
) return -1;
4567 /* default: don't return disabled items */
4568 if ( (!(GMDI_USEDISABLED
& flags
)) && (item
->fState
& MFS_DISABLED
)) return -1;
4570 /* search rekursiv when needed */
4571 if ( (item
->fType
& MF_POPUP
) && (flags
& GMDI_GOINTOPOPUPS
) )
4574 ret
= GetMenuDefaultItem( item
->hSubMenu
, bypos
, flags
);
4575 if ( -1 != ret
) return ret
;
4577 /* when item not found in submenu, return the popup item */
4579 return ( bypos
) ? i
: item
->wID
;
4583 /*******************************************************************
4584 * InsertMenuItem (USER.441)
4588 BOOL16 WINAPI
InsertMenuItem16( HMENU16 hmenu
, UINT16 pos
, BOOL16 byposition
,
4589 const MENUITEMINFO16
*mii
)
4593 miia
.cbSize
= sizeof(miia
);
4594 miia
.fMask
= mii
->fMask
;
4595 miia
.dwTypeData
= (LPSTR
)mii
->dwTypeData
;
4596 miia
.fType
= mii
->fType
;
4597 miia
.fState
= mii
->fState
;
4598 miia
.wID
= mii
->wID
;
4599 miia
.hSubMenu
= mii
->hSubMenu
;
4600 miia
.hbmpChecked
= mii
->hbmpChecked
;
4601 miia
.hbmpUnchecked
= mii
->hbmpUnchecked
;
4602 miia
.dwItemData
= mii
->dwItemData
;
4603 miia
.cch
= mii
->cch
;
4604 if (IS_STRING_ITEM(miia
.fType
))
4605 miia
.dwTypeData
= MapSL(mii
->dwTypeData
);
4606 return InsertMenuItemA( hmenu
, pos
, byposition
, &miia
);
4610 /**********************************************************************
4611 * InsertMenuItemA (USER32.@)
4613 BOOL WINAPI
InsertMenuItemA(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4614 const MENUITEMINFOA
*lpmii
)
4616 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4617 return SetMenuItemInfo_common(item
, (const MENUITEMINFOW
*)lpmii
, FALSE
);
4621 /**********************************************************************
4622 * InsertMenuItemW (USER32.@)
4624 BOOL WINAPI
InsertMenuItemW(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4625 const MENUITEMINFOW
*lpmii
)
4627 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4628 return SetMenuItemInfo_common(item
, lpmii
, TRUE
);
4631 /**********************************************************************
4632 * CheckMenuRadioItem (USER32.@)
4635 BOOL WINAPI
CheckMenuRadioItem(HMENU hMenu
,
4636 UINT first
, UINT last
, UINT check
,
4639 MENUITEM
*mifirst
, *milast
, *micheck
;
4640 HMENU mfirst
= hMenu
, mlast
= hMenu
, mcheck
= hMenu
;
4642 TRACE("ox%x: %d-%d, check %d, bypos=%d\n",
4643 hMenu
, first
, last
, check
, bypos
);
4645 mifirst
= MENU_FindItem (&mfirst
, &first
, bypos
);
4646 milast
= MENU_FindItem (&mlast
, &last
, bypos
);
4647 micheck
= MENU_FindItem (&mcheck
, &check
, bypos
);
4649 if (mifirst
== NULL
|| milast
== NULL
|| micheck
== NULL
||
4650 mifirst
> milast
|| mfirst
!= mlast
|| mfirst
!= mcheck
||
4651 micheck
> milast
|| micheck
< mifirst
)
4654 while (mifirst
<= milast
)
4656 if (mifirst
== micheck
)
4658 mifirst
->fType
|= MFT_RADIOCHECK
;
4659 mifirst
->fState
|= MFS_CHECKED
;
4661 mifirst
->fType
&= ~MFT_RADIOCHECK
;
4662 mifirst
->fState
&= ~MFS_CHECKED
;
4670 /**********************************************************************
4671 * CheckMenuRadioItem (USER.666)
4673 BOOL16 WINAPI
CheckMenuRadioItem16(HMENU16 hMenu
,
4674 UINT16 first
, UINT16 last
, UINT16 check
,
4677 return CheckMenuRadioItem (hMenu
, first
, last
, check
, bypos
);
4680 /**********************************************************************
4681 * GetMenuItemRect (USER32.@)
4683 * ATTENTION: Here, the returned values in rect are the screen
4684 * coordinates of the item just like if the menu was
4685 * always on the upper left side of the application.
4688 BOOL WINAPI
GetMenuItemRect (HWND hwnd
, HMENU hMenu
, UINT uItem
,
4691 POPUPMENU
*itemMenu
;
4695 TRACE("(0x%x,0x%x,%d,%p)\n", hwnd
, hMenu
, uItem
, rect
);
4697 item
= MENU_FindItem (&hMenu
, &uItem
, MF_BYPOSITION
);
4698 referenceHwnd
= hwnd
;
4702 itemMenu
= MENU_GetMenu(hMenu
);
4703 if (itemMenu
== NULL
)
4706 if(itemMenu
->hWnd
== 0)
4708 referenceHwnd
= itemMenu
->hWnd
;
4711 if ((rect
== NULL
) || (item
== NULL
))
4716 MapWindowPoints(referenceHwnd
, 0, (LPPOINT
)rect
, 2);
4722 /**********************************************************************
4723 * SetMenuInfo (USER32.@)
4726 * MIM_APPLYTOSUBMENUS
4727 * actually use the items to draw the menu
4729 BOOL WINAPI
SetMenuInfo (HMENU hMenu
, LPCMENUINFO lpmi
)
4733 TRACE("(0x%04x %p)\n", hMenu
, lpmi
);
4735 if (lpmi
&& (lpmi
->cbSize
==sizeof(MENUINFO
)) && (menu
= MENU_GetMenu(hMenu
)))
4738 if (lpmi
->fMask
& MIM_BACKGROUND
)
4739 menu
->hbrBack
= lpmi
->hbrBack
;
4741 if (lpmi
->fMask
& MIM_HELPID
)
4742 menu
->dwContextHelpID
= lpmi
->dwContextHelpID
;
4744 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4745 menu
->cyMax
= lpmi
->cyMax
;
4747 if (lpmi
->fMask
& MIM_MENUDATA
)
4748 menu
->dwMenuData
= lpmi
->dwMenuData
;
4750 if (lpmi
->fMask
& MIM_STYLE
)
4751 menu
->dwStyle
= lpmi
->dwStyle
;
4758 /**********************************************************************
4759 * GetMenuInfo (USER32.@)
4765 BOOL WINAPI
GetMenuInfo (HMENU hMenu
, LPMENUINFO lpmi
)
4768 TRACE("(0x%04x %p)\n", hMenu
, lpmi
);
4770 if (lpmi
&& (menu
= MENU_GetMenu(hMenu
)))
4773 if (lpmi
->fMask
& MIM_BACKGROUND
)
4774 lpmi
->hbrBack
= menu
->hbrBack
;
4776 if (lpmi
->fMask
& MIM_HELPID
)
4777 lpmi
->dwContextHelpID
= menu
->dwContextHelpID
;
4779 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4780 lpmi
->cyMax
= menu
->cyMax
;
4782 if (lpmi
->fMask
& MIM_MENUDATA
)
4783 lpmi
->dwMenuData
= menu
->dwMenuData
;
4785 if (lpmi
->fMask
& MIM_STYLE
)
4786 lpmi
->dwStyle
= menu
->dwStyle
;
4793 /**********************************************************************
4794 * SetMenuContextHelpId (USER.384)
4796 BOOL16 WINAPI
SetMenuContextHelpId16( HMENU16 hMenu
, DWORD dwContextHelpID
)
4798 return SetMenuContextHelpId( hMenu
, dwContextHelpID
);
4802 /**********************************************************************
4803 * SetMenuContextHelpId (USER32.@)
4805 BOOL WINAPI
SetMenuContextHelpId( HMENU hMenu
, DWORD dwContextHelpID
)
4809 TRACE("(0x%04x 0x%08lx)\n", hMenu
, dwContextHelpID
);
4811 if ((menu
= MENU_GetMenu(hMenu
)))
4813 menu
->dwContextHelpID
= dwContextHelpID
;
4819 /**********************************************************************
4820 * GetMenuContextHelpId (USER.385)
4822 DWORD WINAPI
GetMenuContextHelpId16( HMENU16 hMenu
)
4824 return GetMenuContextHelpId( hMenu
);
4827 /**********************************************************************
4828 * GetMenuContextHelpId (USER32.@)
4830 DWORD WINAPI
GetMenuContextHelpId( HMENU hMenu
)
4834 TRACE("(0x%04x)\n", hMenu
);
4836 if ((menu
= MENU_GetMenu(hMenu
)))
4838 return menu
->dwContextHelpID
;
4843 /**********************************************************************
4844 * MenuItemFromPoint (USER32.@)
4846 UINT WINAPI
MenuItemFromPoint(HWND hWnd
, HMENU hMenu
, POINT ptScreen
)
4848 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
4852 /*FIXME: Do we have to handle hWnd here? */
4853 item
= MENU_FindItemByCoords(menu
, ptScreen
, &pos
);
4859 /**********************************************************************
4860 * translate_accelerator
4862 static BOOL
translate_accelerator( HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
,
4863 BYTE fVirt
, WORD key
, WORD cmd
)
4867 if (wParam
!= key
) return FALSE
;
4869 if (message
== WM_CHAR
)
4871 if ( !(fVirt
& FALT
) && !(fVirt
& FVIRTKEY
) )
4873 TRACE_(accel
)("found accel for WM_CHAR: ('%c')\n", wParam
& 0xff);
4879 if(fVirt
& FVIRTKEY
)
4882 TRACE_(accel
)("found accel for virt_key %04x (scan %04x)\n",
4883 wParam
, 0xff & HIWORD(lParam
));
4884 if(GetKeyState(VK_SHIFT
) & 0x8000) mask
|= FSHIFT
;
4885 if(GetKeyState(VK_CONTROL
) & 0x8000) mask
|= FCONTROL
;
4886 if(GetKeyState(VK_MENU
) & 0x8000) mask
|= FALT
;
4887 if(mask
== (fVirt
& (FSHIFT
| FCONTROL
| FALT
))) goto found
;
4888 TRACE_(accel
)(", but incorrect SHIFT/CTRL/ALT-state\n");
4892 if (!(lParam
& 0x01000000)) /* no special_key */
4894 if ((fVirt
& FALT
) && (lParam
& 0x20000000))
4895 { /* ^^ ALT pressed */
4896 TRACE_(accel
)("found accel for Alt-%c\n", wParam
& 0xff);
4905 if (message
== WM_KEYUP
|| message
== WM_SYSKEYUP
)
4907 else if (GetCapture())
4909 else if (!IsWindowEnabled(hWnd
))
4913 HMENU hMenu
, hSubMenu
, hSysMenu
;
4914 UINT uSysStat
= (UINT
)-1, uStat
= (UINT
)-1, nPos
;
4916 hMenu
= (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) ? 0 : GetMenu(hWnd
);
4917 hSysMenu
= get_win_sys_menu( hWnd
);
4919 /* find menu item and ask application to initialize it */
4920 /* 1. in the system menu */
4921 hSubMenu
= hSysMenu
;
4923 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4925 SendMessageA(hWnd
, WM_INITMENU
, (WPARAM
)hSysMenu
, 0L);
4926 if(hSubMenu
!= hSysMenu
)
4928 nPos
= MENU_FindSubMenu(&hSysMenu
, hSubMenu
);
4929 TRACE_(accel
)("hSysMenu = %04x, hSubMenu = %04x, nPos = %d\n", hSysMenu
, hSubMenu
, nPos
);
4930 SendMessageA(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, TRUE
));
4932 uSysStat
= GetMenuState(GetSubMenu(hSysMenu
, 0), cmd
, MF_BYCOMMAND
);
4934 else /* 2. in the window's menu */
4938 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4940 SendMessageA(hWnd
, WM_INITMENU
, (WPARAM
)hMenu
, 0L);
4941 if(hSubMenu
!= hMenu
)
4943 nPos
= MENU_FindSubMenu(&hMenu
, hSubMenu
);
4944 TRACE_(accel
)("hMenu = %04x, hSubMenu = %04x, nPos = %d\n", hMenu
, hSubMenu
, nPos
);
4945 SendMessageA(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, FALSE
));
4947 uStat
= GetMenuState(hMenu
, cmd
, MF_BYCOMMAND
);
4951 if (uSysStat
!= (UINT
)-1)
4953 if (uSysStat
& (MF_DISABLED
|MF_GRAYED
))
4960 if (uStat
!= (UINT
)-1)
4966 if (uStat
& (MF_DISABLED
|MF_GRAYED
))
4977 if( mesg
==WM_COMMAND
)
4979 TRACE_(accel
)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd
);
4980 SendMessageA(hWnd
, mesg
, 0x10000 | cmd
, 0L);
4982 else if( mesg
==WM_SYSCOMMAND
)
4984 TRACE_(accel
)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd
);
4985 SendMessageA(hWnd
, mesg
, cmd
, 0x00010000L
);
4989 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4990 * #0: unknown (please report!)
4991 * #1: for WM_KEYUP,WM_SYSKEYUP
4992 * #2: mouse is captured
4993 * #3: window is disabled
4994 * #4: it's a disabled system menu option
4995 * #5: it's a menu option, but window is iconic
4996 * #6: it's a menu option, but disabled
4998 TRACE_(accel
)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg
);
5000 ERR_(accel
)(" unknown reason - please report!");
5005 /**********************************************************************
5006 * TranslateAccelerator (USER32.@)
5007 * TranslateAcceleratorA (USER32.@)
5008 * TranslateAcceleratorW (USER32.@)
5010 INT WINAPI
TranslateAccelerator( HWND hWnd
, HACCEL hAccel
, LPMSG msg
)
5013 LPACCEL16 lpAccelTbl
;
5018 WARN_(accel
)("msg null; should hang here to be win compatible\n");
5021 if (!hAccel
|| !(lpAccelTbl
= (LPACCEL16
) LockResource16(HACCEL_16(hAccel
))))
5023 WARN_(accel
)("invalid accel handle=%x\n", hAccel
);
5026 if ((msg
->message
!= WM_KEYDOWN
&&
5027 msg
->message
!= WM_KEYUP
&&
5028 msg
->message
!= WM_SYSKEYDOWN
&&
5029 msg
->message
!= WM_SYSKEYUP
&&
5030 msg
->message
!= WM_CHAR
)) return 0;
5032 TRACE_(accel
)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5033 "msg->hwnd=%04x, msg->message=%04x, wParam=%08x, lParam=%lx\n",
5034 hAccel
,hWnd
,msg
->hwnd
,msg
->message
,msg
->wParam
,msg
->lParam
);
5039 if (translate_accelerator( hWnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
5040 lpAccelTbl
[i
].fVirt
, lpAccelTbl
[i
].key
, lpAccelTbl
[i
].cmd
))
5042 } while ((lpAccelTbl
[i
++].fVirt
& 0x80) == 0);
5043 WARN_(accel
)("couldn't translate accelerator key\n");