4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994 Alexandre Julliard
6 * Copyright 1997 Morten Welinder
10 * Note: the style MF_MOUSESELECT is used to mark popup items that
11 * have been selected, i.e. their popup menu is currently displayed.
12 * This is probably not the meaning this style has in MS-Windows.
23 #include "wine/winbase16.h"
24 #include "wine/winuser16.h"
25 #include "wine/unicode.h"
26 #include "wine/port.h"
29 #include "nonclient.h"
33 #include "debugtools.h"
35 DEFAULT_DEBUG_CHANNEL(menu
);
36 DECLARE_DEBUG_CHANNEL(accel
);
38 /* internal popup menu window messages */
40 #define MM_SETMENUHANDLE (WM_USER + 0)
41 #define MM_GETMENUHANDLE (WM_USER + 1)
43 /* Menu item structure */
45 /* ----------- MENUITEMINFO Stuff ----------- */
46 UINT fType
; /* Item type. */
47 UINT fState
; /* Item state. */
48 UINT wID
; /* Item id. */
49 HMENU hSubMenu
; /* Pop-up menu. */
50 HBITMAP hCheckBit
; /* Bitmap when checked. */
51 HBITMAP hUnCheckBit
; /* Bitmap when unchecked. */
52 LPWSTR text
; /* Item text or bitmap handle. */
53 DWORD dwItemData
; /* Application defined. */
54 DWORD dwTypeData
; /* depends on fMask */
55 HBITMAP hbmpItem
; /* bitmap in win98 style menus */
56 /* ----------- Wine stuff ----------- */
57 RECT rect
; /* Item area (relative to menu window) */
58 UINT xTab
; /* X position of text after Tab */
61 /* Popup menu structure */
63 WORD wFlags
; /* Menu flags (MF_POPUP, MF_SYSMENU) */
64 WORD wMagic
; /* Magic number */
65 WORD Width
; /* Width of the whole menu */
66 WORD Height
; /* Height of the whole menu */
67 UINT nItems
; /* Number of items in the menu */
68 HWND hWnd
; /* Window containing the menu */
69 MENUITEM
*items
; /* Array of menu items */
70 UINT FocusedItem
; /* Currently focused item */
71 HWND hwndOwner
; /* window receiving the messages for ownerdraw */
72 BOOL bTimeToHide
; /* Request hiding when receiving a second click in the top-level menu item */
73 /* ------------ MENUINFO members ------ */
74 DWORD dwStyle
; /* Extended mennu style */
75 UINT cyMax
; /* max hight of the whole menu, 0 is screen hight */
76 HBRUSH hbrBack
; /* brush for menu background */
77 DWORD dwContextHelpID
;
78 DWORD dwMenuData
; /* application defined value */
79 HMENU hSysMenuOwner
; /* Handle to the dummy sys menu holder */
80 } POPUPMENU
, *LPPOPUPMENU
;
82 /* internal flags for menu tracking */
84 #define TF_ENDMENU 0x0001
85 #define TF_SUSPENDPOPUP 0x0002
86 #define TF_SKIPREMOVE 0x0004
91 HMENU hCurrentMenu
; /* current submenu (can be equal to hTopMenu)*/
92 HMENU hTopMenu
; /* initial menu */
93 HWND hOwnerWnd
; /* where notifications are sent */
97 #define MENU_MAGIC 0x554d /* 'MU' */
102 /* Internal MENU_TrackMenu() flags */
103 #define TPM_INTERNAL 0xF0000000
104 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
105 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
106 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
108 /* popup menu shade thickness */
109 #define POPUP_XSHADE 4
110 #define POPUP_YSHADE 4
112 /* Space between 2 menu bar items */
113 #define MENU_BAR_ITEMS_SPACE 12
115 /* Minimum width of a tab character */
116 #define MENU_TAB_SPACE 8
118 /* Height of a separator item */
119 #define SEPARATOR_HEIGHT 5
121 /* (other menu->FocusedItem values give the position of the focused item) */
122 #define NO_SELECTED_ITEM 0xffff
124 #define MENU_ITEM_TYPE(flags) \
125 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
127 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
128 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
129 #define IS_MAGIC_ITEM(text) (LOWORD((int)text)<12)
131 #define IS_SYSTEM_MENU(menu) \
132 (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU)
134 #define IS_SYSTEM_POPUP(menu) \
135 ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU)
137 #define TYPE_MASK (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
138 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
139 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY | \
140 MF_POPUP | MF_SYSMENU | MF_HELP)
141 #define STATE_MASK (~TYPE_MASK)
143 /* Dimension of the menu bitmaps */
144 static WORD arrow_bitmap_width
= 0, arrow_bitmap_height
= 0;
146 static HBITMAP hStdMnArrow
= 0;
148 /* Minimze/restore/close buttons to be inserted in menubar */
149 static HBITMAP hBmpMinimize
= 0;
150 static HBITMAP hBmpMinimizeD
= 0;
151 static HBITMAP hBmpMaximize
= 0;
152 static HBITMAP hBmpMaximizeD
= 0;
153 static HBITMAP hBmpClose
= 0;
154 static HBITMAP hBmpCloseD
= 0;
157 static HBRUSH hShadeBrush
= 0;
158 static HFONT hMenuFont
= 0;
159 static HFONT hMenuFontBold
= 0;
161 static HMENU MENU_DefSysPopup
= 0; /* Default system menu popup */
163 /* Use global popup window because there's no way 2 menus can
164 * be tracked at the same time. */
165 static HWND top_popup
;
167 /* Flag set by EndMenu() to force an exit from menu tracking */
168 static BOOL fEndMenu
= FALSE
;
170 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
173 /*********************************************************************
174 * menu class descriptor
176 const struct builtin_class_descr MENU_builtin_class
=
178 POPUPMENU_CLASS_ATOM
, /* name */
179 CS_GLOBALCLASS
| CS_SAVEBITS
, /* style */
180 NULL
, /* procA (winproc is Unicode only) */
181 PopupMenuWndProc
, /* procW */
182 sizeof(HMENU
), /* extra */
183 IDC_ARROWA
, /* cursor */
184 COLOR_MENU
+1 /* brush */
188 /***********************************************************************
189 * debug_print_menuitem
191 * Print a menuitem in readable form.
194 #define debug_print_menuitem(pre, mp, post) \
195 if(!TRACE_ON(menu)) ; else do_debug_print_menuitem(pre, mp, post)
197 #define MENUOUT(text) \
198 DPRINTF("%s%s", (count++ ? "," : ""), (text))
200 #define MENUFLAG(bit,text) \
202 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
205 static void do_debug_print_menuitem(const char *prefix
, MENUITEM
* mp
,
208 TRACE("%s ", prefix
);
210 UINT flags
= mp
->fType
;
211 int typ
= MENU_ITEM_TYPE(flags
);
212 DPRINTF( "{ ID=0x%x", mp
->wID
);
213 if (flags
& MF_POPUP
)
214 DPRINTF( ", Sub=0x%x", mp
->hSubMenu
);
218 if (typ
== MFT_STRING
)
220 else if (typ
== MFT_SEPARATOR
)
222 else if (typ
== MFT_OWNERDRAW
)
224 else if (typ
== MFT_BITMAP
)
230 MENUFLAG(MF_POPUP
, "pop");
231 MENUFLAG(MFT_MENUBARBREAK
, "barbrk");
232 MENUFLAG(MFT_MENUBREAK
, "brk");
233 MENUFLAG(MFT_RADIOCHECK
, "radio");
234 MENUFLAG(MFT_RIGHTORDER
, "rorder");
235 MENUFLAG(MF_SYSMENU
, "sys");
236 MENUFLAG(MFT_RIGHTJUSTIFY
, "right"); /* same as MF_HELP */
239 DPRINTF( "+0x%x", flags
);
244 DPRINTF( ", State=");
245 MENUFLAG(MFS_GRAYED
, "grey");
246 MENUFLAG(MFS_DEFAULT
, "default");
247 MENUFLAG(MFS_DISABLED
, "dis");
248 MENUFLAG(MFS_CHECKED
, "check");
249 MENUFLAG(MFS_HILITE
, "hi");
250 MENUFLAG(MF_USECHECKBITMAPS
, "usebit");
251 MENUFLAG(MF_MOUSESELECT
, "mouse");
253 DPRINTF( "+0x%x", flags
);
256 DPRINTF( ", Chk=0x%x", mp
->hCheckBit
);
258 DPRINTF( ", Unc=0x%x", mp
->hUnCheckBit
);
260 if (typ
== MFT_STRING
) {
262 DPRINTF( ", Text=%s", debugstr_w(mp
->text
));
264 DPRINTF( ", Text=Null");
265 } else if (mp
->text
== NULL
)
268 DPRINTF( ", Text=%p", mp
->text
);
270 DPRINTF( ", ItemData=0x%08lx", mp
->dwItemData
);
276 DPRINTF(" %s\n", postfix
);
283 /***********************************************************************
286 * Validate the given menu handle and returns the menu structure pointer.
288 static POPUPMENU
*MENU_GetMenu(HMENU hMenu
)
290 POPUPMENU
*menu
= USER_HEAP_LIN_ADDR(hMenu
);
291 if (!menu
|| menu
->wMagic
!= MENU_MAGIC
)
293 WARN("invalid menu handle=%x, ptr=%p, magic=%x\n", hMenu
, menu
, menu
? menu
->wMagic
:0);
299 /***********************************************************************
302 * Get the system menu of a window
304 static HMENU
get_win_sys_menu( HWND hwnd
)
307 WND
*win
= WIN_FindWndPtr( hwnd
);
311 WIN_ReleaseWndPtr( win
);
316 /***********************************************************************
319 * Return the default system menu.
321 static HMENU
MENU_CopySysPopup(void)
323 HMENU hMenu
= LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU");
326 POPUPMENU
* menu
= MENU_GetMenu(hMenu
);
327 menu
->wFlags
|= MF_SYSMENU
| MF_POPUP
;
328 SetMenuDefaultItem(hMenu
, SC_CLOSE
, FALSE
);
331 ERR("Unable to load default system menu\n" );
333 TRACE("returning %x.\n", hMenu
);
339 /**********************************************************************
342 * Create a copy of the system menu. System menu in Windows is
343 * a special menu bar with the single entry - system menu popup.
344 * This popup is presented to the outside world as a "system menu".
345 * However, the real system menu handle is sometimes seen in the
346 * WM_MENUSELECT parameters (and Word 6 likes it this way).
348 HMENU
MENU_GetSysMenu( HWND hWnd
, HMENU hPopupMenu
)
352 if ((hMenu
= CreateMenu()))
354 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
355 menu
->wFlags
= MF_SYSMENU
;
358 if (hPopupMenu
== (HMENU
)(-1))
359 hPopupMenu
= MENU_CopySysPopup();
360 else if( !hPopupMenu
) hPopupMenu
= MENU_DefSysPopup
;
364 InsertMenuA( hMenu
, -1, MF_SYSMENU
| MF_POPUP
| MF_BYPOSITION
, hPopupMenu
, NULL
);
366 menu
->items
[0].fType
= MF_SYSMENU
| MF_POPUP
;
367 menu
->items
[0].fState
= 0;
368 if ((menu
= MENU_GetMenu(hPopupMenu
))) menu
->wFlags
|= MF_SYSMENU
;
370 TRACE("GetSysMenu hMenu=%04x (%04x)\n", hMenu
, hPopupMenu
);
373 DestroyMenu( hMenu
);
375 ERR("failed to load system menu!\n");
380 /***********************************************************************
383 * Menus initialisation.
388 NONCLIENTMETRICSA ncm
;
390 static unsigned char shade_bits
[16] = { 0x55, 0, 0xAA, 0,
395 /* Load menu bitmaps */
396 hStdMnArrow
= LoadBitmapA(0, MAKEINTRESOURCEA(OBM_MNARROW
));
397 /* Load system buttons bitmaps */
398 hBmpMinimize
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_REDUCE
));
399 hBmpMinimizeD
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_REDUCED
));
400 hBmpMaximize
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_RESTORE
));
401 hBmpMaximizeD
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_RESTORED
));
402 hBmpClose
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_CLOSE
));
403 hBmpCloseD
= LoadBitmapA(0,MAKEINTRESOURCEA(OBM_CLOSED
));
408 GetObjectA( hStdMnArrow
, sizeof(bm
), &bm
);
409 arrow_bitmap_width
= bm
.bmWidth
;
410 arrow_bitmap_height
= bm
.bmHeight
;
414 if (! (hBitmap
= CreateBitmap( 8, 8, 1, 1, shade_bits
)))
417 if(!(hShadeBrush
= CreatePatternBrush( hBitmap
)))
420 DeleteObject( hBitmap
);
421 if (!(MENU_DefSysPopup
= MENU_CopySysPopup()))
424 ncm
.cbSize
= sizeof (NONCLIENTMETRICSA
);
425 if (!(SystemParametersInfoA(SPI_GETNONCLIENTMETRICS
, sizeof(NONCLIENTMETRICSA
), &ncm
, 0)))
428 if (!(hMenuFont
= CreateFontIndirectA( &ncm
.lfMenuFont
)))
431 ncm
.lfMenuFont
.lfWeight
+= 300;
432 if ( ncm
.lfMenuFont
.lfWeight
> 1000)
433 ncm
.lfMenuFont
.lfWeight
= 1000;
435 if (!(hMenuFontBold
= CreateFontIndirectA( &ncm
.lfMenuFont
)))
441 /***********************************************************************
442 * MENU_InitSysMenuPopup
444 * Grey the appropriate items in System menu.
446 static void MENU_InitSysMenuPopup( HMENU hmenu
, DWORD style
, DWORD clsStyle
)
450 gray
= !(style
& WS_THICKFRAME
) || (style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
451 EnableMenuItem( hmenu
, SC_SIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
452 gray
= ((style
& WS_MAXIMIZE
) != 0);
453 EnableMenuItem( hmenu
, SC_MOVE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
454 gray
= !(style
& WS_MINIMIZEBOX
) || (style
& WS_MINIMIZE
);
455 EnableMenuItem( hmenu
, SC_MINIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
456 gray
= !(style
& WS_MAXIMIZEBOX
) || (style
& WS_MAXIMIZE
);
457 EnableMenuItem( hmenu
, SC_MAXIMIZE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
458 gray
= !(style
& (WS_MAXIMIZE
| WS_MINIMIZE
));
459 EnableMenuItem( hmenu
, SC_RESTORE
, (gray
? MF_GRAYED
: MF_ENABLED
) );
460 gray
= (clsStyle
& CS_NOCLOSE
) != 0;
462 /* The menu item must keep its state if it's disabled */
464 EnableMenuItem( hmenu
, SC_CLOSE
, MF_GRAYED
);
468 /******************************************************************************
470 * UINT MENU_GetStartOfNextColumn(
473 *****************************************************************************/
475 static UINT
MENU_GetStartOfNextColumn(
478 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
482 return NO_SELECTED_ITEM
;
484 i
= menu
->FocusedItem
+ 1;
485 if( i
== NO_SELECTED_ITEM
)
488 for( ; i
< menu
->nItems
; ++i
) {
489 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
493 return NO_SELECTED_ITEM
;
497 /******************************************************************************
499 * UINT MENU_GetStartOfPrevColumn(
502 *****************************************************************************/
504 static UINT
MENU_GetStartOfPrevColumn(
507 POPUPMENU
*menu
= MENU_GetMenu(hMenu
);
511 return NO_SELECTED_ITEM
;
513 if( menu
->FocusedItem
== 0 || menu
->FocusedItem
== NO_SELECTED_ITEM
)
514 return NO_SELECTED_ITEM
;
516 /* Find the start of the column */
518 for(i
= menu
->FocusedItem
; i
!= 0 &&
519 !(menu
->items
[i
].fType
& MF_MENUBARBREAK
);
523 return NO_SELECTED_ITEM
;
525 for(--i
; i
!= 0; --i
) {
526 if (menu
->items
[i
].fType
& MF_MENUBARBREAK
)
530 TRACE("ret %d.\n", i
);
537 /***********************************************************************
540 * Find a menu item. Return a pointer on the item, and modifies *hmenu
541 * in case the item was in a sub-menu.
543 static MENUITEM
*MENU_FindItem( HMENU
*hmenu
, UINT
*nPos
, UINT wFlags
)
548 if (((*hmenu
)==0xffff) || (!(menu
= MENU_GetMenu(*hmenu
)))) return NULL
;
549 if (wFlags
& MF_BYPOSITION
)
551 if (*nPos
>= menu
->nItems
) return NULL
;
552 return &menu
->items
[*nPos
];
556 MENUITEM
*item
= menu
->items
;
557 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
559 if (item
->wID
== *nPos
)
564 else if (item
->fType
& MF_POPUP
)
566 HMENU hsubmenu
= item
->hSubMenu
;
567 MENUITEM
*subitem
= MENU_FindItem( &hsubmenu
, nPos
, wFlags
);
579 /***********************************************************************
582 * Find a Sub menu. Return the position of the submenu, and modifies
583 * *hmenu in case it is found in another sub-menu.
584 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
586 UINT
MENU_FindSubMenu( HMENU
*hmenu
, HMENU hSubTarget
)
591 if (((*hmenu
)==0xffff) ||
592 (!(menu
= MENU_GetMenu(*hmenu
))))
593 return NO_SELECTED_ITEM
;
595 for (i
= 0; i
< menu
->nItems
; i
++, item
++) {
596 if(!(item
->fType
& MF_POPUP
)) continue;
597 if (item
->hSubMenu
== hSubTarget
) {
601 HMENU hsubmenu
= item
->hSubMenu
;
602 UINT pos
= MENU_FindSubMenu( &hsubmenu
, hSubTarget
);
603 if (pos
!= NO_SELECTED_ITEM
) {
609 return NO_SELECTED_ITEM
;
612 /***********************************************************************
615 static void MENU_FreeItemData( MENUITEM
* item
)
618 if (IS_STRING_ITEM(item
->fType
) && item
->text
)
619 HeapFree( GetProcessHeap(), 0, item
->text
);
622 /***********************************************************************
623 * MENU_FindItemByCoords
625 * Find the item at the specified coordinates (screen coords). Does
626 * not work for child windows and therefore should not be called for
627 * an arbitrary system menu.
629 static MENUITEM
*MENU_FindItemByCoords( POPUPMENU
*menu
,
630 POINT pt
, UINT
*pos
)
636 if (!GetWindowRect(menu
->hWnd
,&wrect
)) return NULL
;
637 pt
.x
-= wrect
.left
;pt
.y
-= wrect
.top
;
639 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
641 if ((pt
.x
>= item
->rect
.left
) && (pt
.x
< item
->rect
.right
) &&
642 (pt
.y
>= item
->rect
.top
) && (pt
.y
< item
->rect
.bottom
))
652 /***********************************************************************
655 * Find the menu item selected by a key press.
656 * Return item id, -1 if none, -2 if we should close the menu.
658 static UINT
MENU_FindItemByKey( HWND hwndOwner
, HMENU hmenu
,
659 UINT key
, BOOL forceMenuChar
)
661 TRACE("\tlooking for '%c' in [%04x]\n", (char)key
, (UINT16
)hmenu
);
663 if (!IsMenu( hmenu
)) hmenu
= GetSubMenu( get_win_sys_menu(hwndOwner
), 0);
667 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
668 MENUITEM
*item
= menu
->items
;
676 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
678 if (item
->text
&& (IS_STRING_ITEM(item
->fType
)))
680 WCHAR
*p
= item
->text
- 2;
683 p
= strchrW (p
+ 2, '&');
685 while (p
!= NULL
&& p
[1] == '&');
686 if (p
&& (toupper(p
[1]) == key
)) return i
;
690 menuchar
= SendMessageA( hwndOwner
, WM_MENUCHAR
,
691 MAKEWPARAM( key
, menu
->wFlags
), hmenu
);
692 if (HIWORD(menuchar
) == 2) return LOWORD(menuchar
);
693 if (HIWORD(menuchar
) == 1) return (UINT
)(-2);
697 /***********************************************************************
700 * Load the bitmap associated with the magic menu item and its style
703 static HBITMAP
MENU_LoadMagicItem(UINT id
, BOOL hilite
, DWORD dwItemData
)
706 * Magic menu item id's section
707 * These magic id's are used by windows to insert "standard" mdi
708 * buttons (minimize,restore,close) on menu. Under windows,
709 * these magic id's make sure the right things appear when those
710 * bitmap buttons are pressed/selected/released.
714 { case HBMMENU_SYSTEM
:
715 return (dwItemData
) ?
716 (HBITMAP
)dwItemData
:
717 (hilite
? hBmpMinimizeD
: hBmpMinimize
);
718 case HBMMENU_MBAR_RESTORE
:
719 return (hilite
? hBmpMaximizeD
: hBmpMaximize
);
720 case HBMMENU_MBAR_MINIMIZE
:
721 return (hilite
? hBmpMinimizeD
: hBmpMinimize
);
722 case HBMMENU_MBAR_CLOSE
:
723 return (hilite
? hBmpCloseD
: hBmpClose
);
724 case HBMMENU_CALLBACK
:
725 case HBMMENU_MBAR_CLOSE_D
:
726 case HBMMENU_MBAR_MINIMIZE_D
:
727 case HBMMENU_POPUP_CLOSE
:
728 case HBMMENU_POPUP_RESTORE
:
729 case HBMMENU_POPUP_MAXIMIZE
:
730 case HBMMENU_POPUP_MINIMIZE
:
732 FIXME("Magic 0x%08x not implemented\n", id
);
738 /***********************************************************************
741 * Calculate the size of the menu item and store it in lpitem->rect.
743 static void MENU_CalcItemSize( HDC hdc
, MENUITEM
*lpitem
, HWND hwndOwner
,
744 INT orgX
, INT orgY
, BOOL menuBar
)
747 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
749 TRACE("dc=0x%04x owner=0x%04x (%d,%d)\n", hdc
, hwndOwner
, orgX
, orgY
);
750 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem
,
751 (menuBar
? " (MenuBar)" : ""));
753 SetRect( &lpitem
->rect
, orgX
, orgY
, orgX
, orgY
);
755 if (lpitem
->fType
& MF_OWNERDRAW
)
758 ** Experimentation under Windows reveals that an owner-drawn
759 ** menu is expected to return the size of the content part of
760 ** the menu item, not including the checkmark nor the submenu
761 ** arrow. Windows adds those values itself and returns the
762 ** enlarged rectangle on subsequent WM_DRAWITEM messages.
764 MEASUREITEMSTRUCT mis
;
765 mis
.CtlType
= ODT_MENU
;
767 mis
.itemID
= lpitem
->wID
;
768 mis
.itemData
= (DWORD
)lpitem
->dwItemData
;
771 SendMessageA( hwndOwner
, WM_MEASUREITEM
, 0, (LPARAM
)&mis
);
772 lpitem
->rect
.right
+= mis
.itemWidth
;
776 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
779 /* under at least win95 you seem to be given a standard
780 height for the menu and the height value is ignored */
782 if (TWEAK_WineLook
== WIN31_LOOK
)
783 lpitem
->rect
.bottom
+= GetSystemMetrics(SM_CYMENU
);
785 lpitem
->rect
.bottom
+= GetSystemMetrics(SM_CYMENU
)-1;
788 lpitem
->rect
.bottom
+= mis
.itemHeight
;
790 TRACE("id=%04x size=%dx%d\n",
791 lpitem
->wID
, mis
.itemWidth
, mis
.itemHeight
);
792 /* Fall through to get check/arrow width calculation. */
795 if (lpitem
->fType
& MF_SEPARATOR
)
797 lpitem
->rect
.bottom
+= SEPARATOR_HEIGHT
;
803 lpitem
->rect
.right
+= 2 * check_bitmap_width
;
804 if (lpitem
->fType
& MF_POPUP
)
805 lpitem
->rect
.right
+= arrow_bitmap_width
;
808 if (lpitem
->fType
& MF_OWNERDRAW
)
811 if (IS_BITMAP_ITEM(lpitem
->fType
))
816 /* Check if there is a magic menu item associated with this item */
817 if (IS_MAGIC_ITEM(lpitem
->text
))
819 resBmp
= MENU_LoadMagicItem((int)lpitem
->text
, (lpitem
->fType
& MF_HILITE
),
823 resBmp
= (HBITMAP
)lpitem
->text
;
825 if (GetObjectA(resBmp
, sizeof(bm
), &bm
))
827 lpitem
->rect
.right
+= bm
.bmWidth
;
828 lpitem
->rect
.bottom
+= bm
.bmHeight
;
829 if (TWEAK_WineLook
== WIN98_LOOK
) {
830 /* Leave space for the sunken border */
831 lpitem
->rect
.right
+= 2;
832 lpitem
->rect
.bottom
+= 2;
839 /* it must be a text item - unless it's the system menu */
840 if (!(lpitem
->fType
& MF_SYSMENU
) && IS_STRING_ITEM( lpitem
->fType
))
843 GetTextExtentPoint32W(hdc
, lpitem
->text
, strlenW(lpitem
->text
), &size
);
845 lpitem
->rect
.right
+= size
.cx
;
846 if (TWEAK_WineLook
== WIN31_LOOK
)
847 lpitem
->rect
.bottom
+= max( size
.cy
, GetSystemMetrics(SM_CYMENU
) );
849 lpitem
->rect
.bottom
+= max(size
.cy
, GetSystemMetrics(SM_CYMENU
)-1);
854 lpitem
->rect
.right
+= MENU_BAR_ITEMS_SPACE
;
856 else if ((p
= strchrW( lpitem
->text
, '\t' )) != NULL
)
858 /* Item contains a tab (only meaningful in popup menus) */
859 GetTextExtentPoint32W(hdc
, lpitem
->text
, (int)(p
- lpitem
->text
) , &size
);
860 lpitem
->xTab
= check_bitmap_width
+ MENU_TAB_SPACE
+ size
.cx
;
861 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
865 if (strchrW( lpitem
->text
, '\b' ))
866 lpitem
->rect
.right
+= MENU_TAB_SPACE
;
867 lpitem
->xTab
= lpitem
->rect
.right
- check_bitmap_width
868 - arrow_bitmap_width
;
871 TRACE("(%d,%d)-(%d,%d)\n", lpitem
->rect
.left
, lpitem
->rect
.top
, lpitem
->rect
.right
, lpitem
->rect
.bottom
);
875 /***********************************************************************
876 * MENU_PopupMenuCalcSize
878 * Calculate the size of a popup menu.
880 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop
, HWND hwndOwner
)
885 int orgX
, orgY
, maxX
, maxTab
, maxTabWidth
;
887 lppop
->Width
= lppop
->Height
= 0;
888 if (lppop
->nItems
== 0) return;
891 SelectObject( hdc
, hMenuFont
);
894 maxX
= (TWEAK_WineLook
== WIN31_LOOK
) ? GetSystemMetrics(SM_CXBORDER
) : 2+1 ;
896 while (start
< lppop
->nItems
)
898 lpitem
= &lppop
->items
[start
];
900 orgY
= (TWEAK_WineLook
== WIN31_LOOK
) ? GetSystemMetrics(SM_CYBORDER
) : 2;
902 maxTab
= maxTabWidth
= 0;
904 /* Parse items until column break or end of menu */
905 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
908 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
910 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, FALSE
);
912 if (lpitem
->fType
& MF_MENUBARBREAK
) orgX
++;
913 maxX
= max( maxX
, lpitem
->rect
.right
);
914 orgY
= lpitem
->rect
.bottom
;
915 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
917 maxTab
= max( maxTab
, lpitem
->xTab
);
918 maxTabWidth
= max(maxTabWidth
,lpitem
->rect
.right
-lpitem
->xTab
);
922 /* Finish the column (set all items to the largest width found) */
923 maxX
= max( maxX
, maxTab
+ maxTabWidth
);
924 for (lpitem
= &lppop
->items
[start
]; start
< i
; start
++, lpitem
++)
926 lpitem
->rect
.right
= maxX
;
927 if (IS_STRING_ITEM(lpitem
->fType
) && lpitem
->xTab
)
928 lpitem
->xTab
= maxTab
;
931 lppop
->Height
= max( lppop
->Height
, orgY
);
936 /* space for 3d border */
937 if(TWEAK_WineLook
> WIN31_LOOK
)
947 /***********************************************************************
948 * MENU_MenuBarCalcSize
950 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
951 * height is off by 1 pixel which causes lengthy window relocations when
952 * active document window is maximized/restored.
954 * Calculate the size of the menu bar.
956 static void MENU_MenuBarCalcSize( HDC hdc
, LPRECT lprect
,
957 LPPOPUPMENU lppop
, HWND hwndOwner
)
960 int start
, i
, orgX
, orgY
, maxY
, helpPos
;
962 if ((lprect
== NULL
) || (lppop
== NULL
)) return;
963 if (lppop
->nItems
== 0) return;
964 TRACE("left=%d top=%d right=%d bottom=%d\n",
965 lprect
->left
, lprect
->top
, lprect
->right
, lprect
->bottom
);
966 lppop
->Width
= lprect
->right
- lprect
->left
;
968 maxY
= lprect
->top
+1;
971 while (start
< lppop
->nItems
)
973 lpitem
= &lppop
->items
[start
];
977 /* Parse items until line break or end of menu */
978 for (i
= start
; i
< lppop
->nItems
; i
++, lpitem
++)
980 if ((helpPos
== -1) && (lpitem
->fType
& MF_RIGHTJUSTIFY
)) helpPos
= i
;
982 (lpitem
->fType
& (MF_MENUBREAK
| MF_MENUBARBREAK
))) break;
984 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n",
986 debug_print_menuitem (" item: ", lpitem
, "");
987 MENU_CalcItemSize( hdc
, lpitem
, hwndOwner
, orgX
, orgY
, TRUE
);
989 if (lpitem
->rect
.right
> lprect
->right
)
991 if (i
!= start
) break;
992 else lpitem
->rect
.right
= lprect
->right
;
994 maxY
= max( maxY
, lpitem
->rect
.bottom
);
995 orgX
= lpitem
->rect
.right
;
998 /* Finish the line (set all items to the largest height found) */
999 while (start
< i
) lppop
->items
[start
++].rect
.bottom
= maxY
;
1002 lprect
->bottom
= maxY
;
1003 lppop
->Height
= lprect
->bottom
- lprect
->top
;
1005 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1006 /* the last item (if several lines, only move the last line) */
1007 lpitem
= &lppop
->items
[lppop
->nItems
-1];
1008 orgY
= lpitem
->rect
.top
;
1009 orgX
= lprect
->right
;
1010 for (i
= lppop
->nItems
- 1; i
>= helpPos
; i
--, lpitem
--) {
1011 if ( (helpPos
==-1) || (helpPos
>i
) )
1013 if (lpitem
->rect
.top
!= orgY
) break; /* Other line */
1014 if (lpitem
->rect
.right
>= orgX
) break; /* Too far right already */
1015 lpitem
->rect
.left
+= orgX
- lpitem
->rect
.right
;
1016 lpitem
->rect
.right
= orgX
;
1017 orgX
= lpitem
->rect
.left
;
1021 /***********************************************************************
1024 * Draw a single menu item.
1026 static void MENU_DrawMenuItem( HWND hwnd
, HMENU hmenu
, HWND hwndOwner
, HDC hdc
, MENUITEM
*lpitem
,
1027 UINT height
, BOOL menuBar
, UINT odaction
)
1031 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem
, "");
1033 if (lpitem
->fType
& MF_SYSMENU
)
1035 if( !IsIconic(hwnd
) ) {
1036 if (TWEAK_WineLook
> WIN31_LOOK
)
1037 NC_DrawSysButton95( hwnd
, hdc
,
1039 (MF_HILITE
| MF_MOUSESELECT
) );
1041 NC_DrawSysButton( hwnd
, hdc
,
1043 (MF_HILITE
| MF_MOUSESELECT
) );
1049 if (lpitem
->fType
& MF_OWNERDRAW
)
1052 ** Experimentation under Windows reveals that an owner-drawn
1053 ** menu is given the rectangle which includes the space it requested
1054 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1055 ** and a popup-menu arrow. This is the value of lpitem->rect.
1056 ** Windows will leave all drawing to the application except for
1057 ** the popup-menu arrow. Windows always draws that itself, after
1058 ** the menu owner has finished drawing.
1062 dis
.CtlType
= ODT_MENU
;
1064 dis
.itemID
= lpitem
->wID
;
1065 dis
.itemData
= (DWORD
)lpitem
->dwItemData
;
1067 if (lpitem
->fState
& MF_CHECKED
) dis
.itemState
|= ODS_CHECKED
;
1068 if (lpitem
->fState
& MF_GRAYED
) dis
.itemState
|= ODS_GRAYED
;
1069 if (lpitem
->fState
& MF_HILITE
) dis
.itemState
|= ODS_SELECTED
;
1070 dis
.itemAction
= odaction
; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1071 dis
.hwndItem
= hmenu
;
1073 dis
.rcItem
= lpitem
->rect
;
1074 TRACE("Ownerdraw: owner=%04x itemID=%d, itemState=%d, itemAction=%d, "
1075 "hwndItem=%04x, hdc=%04x, rcItem={%d,%d,%d,%d}\n", hwndOwner
,
1076 dis
.itemID
, dis
.itemState
, dis
.itemAction
, dis
.hwndItem
,
1077 dis
.hDC
, dis
.rcItem
.left
, dis
.rcItem
.top
, dis
.rcItem
.right
,
1079 SendMessageA( hwndOwner
, WM_DRAWITEM
, 0, (LPARAM
)&dis
);
1080 /* Fall through to draw popup-menu arrow */
1083 TRACE("rect={%d,%d,%d,%d}\n", lpitem
->rect
.left
, lpitem
->rect
.top
,
1084 lpitem
->rect
.right
,lpitem
->rect
.bottom
);
1086 if (menuBar
&& (lpitem
->fType
& MF_SEPARATOR
)) return;
1088 rect
= lpitem
->rect
;
1090 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1092 if (lpitem
->fState
& MF_HILITE
)
1094 if(TWEAK_WineLook
== WIN98_LOOK
)
1097 DrawEdge(hdc
, &rect
, BDR_SUNKENOUTER
, BF_RECT
);
1099 FillRect(hdc
, &rect
, GetSysColorBrush(COLOR_HIGHLIGHT
));
1101 else /* Not Win98 Look */
1103 if(!IS_BITMAP_ITEM(lpitem
->fType
))
1104 FillRect(hdc
, &rect
, GetSysColorBrush(COLOR_HIGHLIGHT
));
1108 FillRect( hdc
, &rect
, GetSysColorBrush(COLOR_MENU
) );
1111 SetBkMode( hdc
, TRANSPARENT
);
1113 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1115 /* vertical separator */
1116 if (!menuBar
&& (lpitem
->fType
& MF_MENUBARBREAK
))
1118 if (TWEAK_WineLook
> WIN31_LOOK
)
1122 rc
.bottom
= height
- 3;
1123 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_LEFT
);
1127 SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
1128 MoveToEx( hdc
, rect
.left
, 0, NULL
);
1129 LineTo( hdc
, rect
.left
, height
);
1133 /* horizontal separator */
1134 if (lpitem
->fType
& MF_SEPARATOR
)
1136 if (TWEAK_WineLook
> WIN31_LOOK
)
1141 rc
.top
+= SEPARATOR_HEIGHT
/ 2;
1142 DrawEdge (hdc
, &rc
, EDGE_ETCHED
, BF_TOP
);
1146 SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
1147 MoveToEx( hdc
, rect
.left
, rect
.top
+ SEPARATOR_HEIGHT
/2, NULL
);
1148 LineTo( hdc
, rect
.right
, rect
.top
+ SEPARATOR_HEIGHT
/2 );
1156 if (lpitem
->fState
& MF_HILITE
)
1158 if(TWEAK_WineLook
== WIN98_LOOK
)
1161 SetTextColor(hdc
, GetSysColor(COLOR_MENUTEXT
));
1162 SetBkColor(hdc
, GetSysColor(COLOR_MENU
));
1164 if(lpitem
->fState
& MF_GRAYED
)
1165 SetTextColor(hdc
, GetSysColor(COLOR_GRAYTEXT
));
1167 SetTextColor(hdc
, GetSysColor(COLOR_HIGHLIGHTTEXT
));
1168 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1171 else /* Not Win98 Look */
1173 SetTextColor(hdc
, GetSysColor(COLOR_HIGHLIGHTTEXT
));
1174 if(!IS_BITMAP_ITEM(lpitem
->fType
))
1175 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1180 if (lpitem
->fState
& MF_GRAYED
)
1181 SetTextColor( hdc
, GetSysColor( COLOR_GRAYTEXT
) );
1183 SetTextColor( hdc
, GetSysColor( COLOR_MENUTEXT
) );
1184 SetBkColor( hdc
, GetSysColor( COLOR_MENU
) );
1187 /* helper lines for debugging */
1188 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1189 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1190 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1191 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1196 INT y
= rect
.top
+ rect
.bottom
;
1197 UINT check_bitmap_width
= GetSystemMetrics( SM_CXMENUCHECK
);
1198 UINT check_bitmap_height
= GetSystemMetrics( SM_CYMENUCHECK
);
1200 if (!(lpitem
->fType
& MF_OWNERDRAW
))
1202 /* Draw the check mark
1205 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1207 HBITMAP bm
= (lpitem
->fState
& MF_CHECKED
) ? lpitem
->hCheckBit
: lpitem
->hUnCheckBit
;
1208 if (bm
) /* we have a custom bitmap */
1210 HDC hdcMem
= CreateCompatibleDC( hdc
);
1211 SelectObject( hdcMem
, bm
);
1212 BitBlt( hdc
, rect
.left
, (y
- check_bitmap_height
) / 2,
1213 check_bitmap_width
, check_bitmap_height
,
1214 hdcMem
, 0, 0, SRCCOPY
);
1217 else if (lpitem
->fState
& MF_CHECKED
) /* standard bitmaps */
1220 HBITMAP bm
= CreateBitmap( check_bitmap_width
, check_bitmap_height
, 1, 1, NULL
);
1221 HDC hdcMem
= CreateCompatibleDC( hdc
);
1222 SelectObject( hdcMem
, bm
);
1223 SetRect( &r
, 0, 0, check_bitmap_width
, check_bitmap_height
);
1224 DrawFrameControl( hdcMem
, &r
, DFC_MENU
,
1225 (lpitem
->fType
& MFT_RADIOCHECK
) ?
1226 DFCS_MENUBULLET
: DFCS_MENUCHECK
);
1227 BitBlt( hdc
, rect
.left
, (y
- r
.bottom
) / 2, r
.right
, r
.bottom
,
1228 hdcMem
, 0, 0, SRCCOPY
);
1234 /* Draw the popup-menu arrow */
1235 if (lpitem
->fType
& MF_POPUP
)
1237 HDC hdcMem
= CreateCompatibleDC( hdc
);
1238 HBITMAP hOrigBitmap
;
1240 hOrigBitmap
= SelectObject( hdcMem
, hStdMnArrow
);
1241 BitBlt( hdc
, rect
.right
- arrow_bitmap_width
- 1,
1242 (y
- arrow_bitmap_height
) / 2,
1243 arrow_bitmap_width
, arrow_bitmap_height
,
1244 hdcMem
, 0, 0, SRCCOPY
);
1245 SelectObject( hdcMem
, hOrigBitmap
);
1249 rect
.left
+= check_bitmap_width
;
1250 rect
.right
-= arrow_bitmap_width
;
1253 /* Done for owner-drawn */
1254 if (lpitem
->fType
& MF_OWNERDRAW
)
1257 /* Draw the item text or bitmap */
1258 if (IS_BITMAP_ITEM(lpitem
->fType
))
1265 HDC hdcMem
= CreateCompatibleDC( hdc
);
1268 * Check if there is a magic menu item associated with this item
1269 * and load the appropriate bitmap
1271 if (IS_MAGIC_ITEM(lpitem
->text
))
1273 resBmp
= MENU_LoadMagicItem((int)lpitem
->text
, (lpitem
->fState
& MF_HILITE
),
1274 lpitem
->dwItemData
);
1277 resBmp
= (HBITMAP
)lpitem
->text
;
1282 GetObjectA( resBmp
, sizeof(bm
), &bm
);
1284 SelectObject(hdcMem
,resBmp
);
1286 /* handle fontsize > bitmap_height */
1287 h
=rect
.bottom
- rect
.top
;
1288 top
= (h
>bm
.bmHeight
) ?
1289 rect
.top
+(h
-bm
.bmHeight
)/2 : rect
.top
;
1290 w
=rect
.right
- rect
.left
;
1292 if (TWEAK_WineLook
== WIN95_LOOK
) {
1293 rop
=((lpitem
->fState
& MF_HILITE
) && !IS_MAGIC_ITEM(lpitem
->text
)) ? NOTSRCCOPY
: SRCCOPY
;
1294 if ((lpitem
->fState
& MF_HILITE
) && IS_BITMAP_ITEM(lpitem
->fType
))
1295 SetBkColor(hdc
, GetSysColor(COLOR_HIGHLIGHT
));
1299 rop
=((lpitem
->fState
& MF_HILITE
) && !IS_MAGIC_ITEM(lpitem
->text
) && (!menuBar
)) ? MERGEPAINT
: SRCCOPY
;
1301 BitBlt( hdc
, left
, top
, w
,
1310 /* No bitmap - process text if present */
1311 else if (IS_STRING_ITEM(lpitem
->fType
))
1316 UINT uFormat
= (menuBar
) ?
1317 DT_CENTER
| DT_VCENTER
| DT_SINGLELINE
:
1318 DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1320 if ( lpitem
->fState
& MFS_DEFAULT
)
1322 hfontOld
= SelectObject( hdc
, hMenuFontBold
);
1327 rect
.left
+= MENU_BAR_ITEMS_SPACE
/ 2;
1328 rect
.right
-= MENU_BAR_ITEMS_SPACE
/ 2;
1329 i
= strlenW( lpitem
->text
);
1333 for (i
= 0; lpitem
->text
[i
]; i
++)
1334 if ((lpitem
->text
[i
] == '\t') || (lpitem
->text
[i
] == '\b'))
1338 if( !(TWEAK_WineLook
== WIN31_LOOK
) && (lpitem
->fState
& MF_GRAYED
))
1340 if (!(lpitem
->fState
& MF_HILITE
) )
1342 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1343 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1344 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1345 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1347 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1350 DrawTextW( hdc
, lpitem
->text
, i
, &rect
, uFormat
);
1352 /* paint the shortcut text */
1353 if (lpitem
->text
[i
]) /* There's a tab or flush-right char */
1355 if (lpitem
->text
[i
] == '\t')
1357 rect
.left
= lpitem
->xTab
;
1358 uFormat
= DT_LEFT
| DT_VCENTER
| DT_SINGLELINE
;
1362 uFormat
= DT_RIGHT
| DT_VCENTER
| DT_SINGLELINE
;
1365 if( !(TWEAK_WineLook
== WIN31_LOOK
) && (lpitem
->fState
& MF_GRAYED
))
1367 if (!(lpitem
->fState
& MF_HILITE
) )
1369 ++rect
.left
; ++rect
.top
; ++rect
.right
; ++rect
.bottom
;
1370 SetTextColor(hdc
, RGB(0xff, 0xff, 0xff));
1371 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1372 --rect
.left
; --rect
.top
; --rect
.right
; --rect
.bottom
;
1374 SetTextColor(hdc
, RGB(0x80, 0x80, 0x80));
1376 DrawTextW( hdc
, lpitem
->text
+ i
+ 1, -1, &rect
, uFormat
);
1380 SelectObject (hdc
, hfontOld
);
1385 /***********************************************************************
1386 * MENU_DrawPopupMenu
1388 * Paint a popup menu.
1390 static void MENU_DrawPopupMenu( HWND hwnd
, HDC hdc
, HMENU hmenu
)
1392 HBRUSH hPrevBrush
= 0;
1395 TRACE("wnd=0x%04x dc=0x%04x menu=0x%04x\n", hwnd
, hdc
, hmenu
);
1397 GetClientRect( hwnd
, &rect
);
1399 if(TWEAK_WineLook
== WIN31_LOOK
)
1401 rect
.bottom
-= POPUP_YSHADE
* GetSystemMetrics(SM_CYBORDER
);
1402 rect
.right
-= POPUP_XSHADE
* GetSystemMetrics(SM_CXBORDER
);
1405 if((hPrevBrush
= SelectObject( hdc
, GetSysColorBrush(COLOR_MENU
) ))
1406 && (SelectObject( hdc
, hMenuFont
)))
1410 Rectangle( hdc
, rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
1412 hPrevPen
= SelectObject( hdc
, GetStockObject( NULL_PEN
) );
1418 /* draw 3-d shade */
1419 if(TWEAK_WineLook
== WIN31_LOOK
) {
1420 SelectObject( hdc
, hShadeBrush
);
1421 SetBkMode( hdc
, TRANSPARENT
);
1422 ropPrev
= SetROP2( hdc
, R2_MASKPEN
);
1424 i
= rect
.right
; /* why SetBrushOrg() doesn't? */
1425 PatBlt( hdc
, i
& 0xfffffffe,
1426 rect
.top
+ POPUP_YSHADE
*GetSystemMetrics(SM_CYBORDER
),
1427 i
%2 + POPUP_XSHADE
*GetSystemMetrics(SM_CXBORDER
),
1428 rect
.bottom
- rect
.top
, 0x00a000c9 );
1430 PatBlt( hdc
, rect
.left
+ POPUP_XSHADE
*GetSystemMetrics(SM_CXBORDER
),
1431 i
& 0xfffffffe,rect
.right
- rect
.left
,
1432 i
%2 + POPUP_YSHADE
*GetSystemMetrics(SM_CYBORDER
), 0x00a000c9 );
1433 SelectObject( hdc
, hPrevPen
);
1434 SelectObject( hdc
, hPrevBrush
);
1435 SetROP2( hdc
, ropPrev
);
1438 DrawEdge (hdc
, &rect
, EDGE_RAISED
, BF_RECT
);
1440 /* draw menu items */
1442 menu
= MENU_GetMenu( hmenu
);
1443 if (menu
&& menu
->nItems
)
1448 for (u
= menu
->nItems
, item
= menu
->items
; u
> 0; u
--, item
++)
1449 MENU_DrawMenuItem( hwnd
, hmenu
, menu
->hwndOwner
, hdc
, item
,
1450 menu
->Height
, FALSE
, ODA_DRAWENTIRE
);
1455 SelectObject( hdc
, hPrevBrush
);
1460 /***********************************************************************
1463 * Paint a menu bar. Returns the height of the menu bar.
1464 * called from [windows/nonclient.c]
1466 UINT
MENU_DrawMenuBar( HDC hDC
, LPRECT lprect
, HWND hwnd
,
1472 HMENU hMenu
= GetMenu(hwnd
);
1474 lppop
= MENU_GetMenu( hMenu
);
1475 if (lppop
== NULL
|| lprect
== NULL
)
1477 retvalue
= GetSystemMetrics(SM_CYMENU
);
1481 TRACE("(%04x, %p, %p)\n", hDC
, lprect
, lppop
);
1483 hfontOld
= SelectObject( hDC
, hMenuFont
);
1485 if (lppop
->Height
== 0)
1486 MENU_MenuBarCalcSize(hDC
, lprect
, lppop
, hwnd
);
1488 lprect
->bottom
= lprect
->top
+ lppop
->Height
;
1492 retvalue
= lppop
->Height
;
1496 FillRect(hDC
, lprect
, GetSysColorBrush(COLOR_MENU
) );
1498 if (TWEAK_WineLook
== WIN31_LOOK
)
1500 SelectObject( hDC
, GetSysColorPen(COLOR_WINDOWFRAME
) );
1501 MoveToEx( hDC
, lprect
->left
, lprect
->bottom
, NULL
);
1502 LineTo( hDC
, lprect
->right
, lprect
->bottom
);
1506 SelectObject( hDC
, GetSysColorPen(COLOR_3DFACE
));
1507 MoveToEx( hDC
, lprect
->left
, lprect
->bottom
, NULL
);
1508 LineTo( hDC
, lprect
->right
, lprect
->bottom
);
1511 if (lppop
->nItems
== 0)
1513 retvalue
= GetSystemMetrics(SM_CYMENU
);
1517 for (i
= 0; i
< lppop
->nItems
; i
++)
1519 MENU_DrawMenuItem( hwnd
, hMenu
, hwnd
,
1520 hDC
, &lppop
->items
[i
], lppop
->Height
, TRUE
, ODA_DRAWENTIRE
);
1522 retvalue
= lppop
->Height
;
1525 if (hfontOld
) SelectObject (hDC
, hfontOld
);
1530 /***********************************************************************
1533 * Display a popup menu.
1535 static BOOL
MENU_ShowPopup( HWND hwndOwner
, HMENU hmenu
, UINT id
,
1536 INT x
, INT y
, INT xanchor
, INT yanchor
)
1541 TRACE("owner=0x%04x hmenu=0x%04x id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1542 hwndOwner
, hmenu
, id
, x
, y
, xanchor
, yanchor
);
1544 if (!(menu
= MENU_GetMenu( hmenu
))) return FALSE
;
1545 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1547 menu
->items
[menu
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1548 menu
->FocusedItem
= NO_SELECTED_ITEM
;
1551 /* store the owner for DrawItem */
1552 menu
->hwndOwner
= hwndOwner
;
1555 MENU_PopupMenuCalcSize( menu
, hwndOwner
);
1557 /* adjust popup menu pos so that it fits within the desktop */
1559 width
= menu
->Width
+ GetSystemMetrics(SM_CXBORDER
);
1560 height
= menu
->Height
+ GetSystemMetrics(SM_CYBORDER
);
1562 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1565 x
-= width
- xanchor
;
1566 if( x
+ width
> GetSystemMetrics(SM_CXSCREEN
))
1567 x
= GetSystemMetrics(SM_CXSCREEN
) - width
;
1571 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1574 y
-= height
+ yanchor
;
1575 if( y
+ height
> GetSystemMetrics(SM_CYSCREEN
))
1576 y
= GetSystemMetrics(SM_CYSCREEN
) - height
;
1580 if( TWEAK_WineLook
== WIN31_LOOK
)
1582 width
+= POPUP_XSHADE
* GetSystemMetrics(SM_CXBORDER
); /* add space for shading */
1583 height
+= POPUP_YSHADE
* GetSystemMetrics(SM_CYBORDER
);
1586 /* NOTE: In Windows, top menu popup is not owned. */
1587 menu
->hWnd
= CreateWindowA( POPUPMENU_CLASS_ATOM
, NULL
,
1588 WS_POPUP
, x
, y
, width
, height
,
1589 hwndOwner
, 0, GetWindowLongA(hwndOwner
,GWL_HINSTANCE
),
1591 if( !menu
->hWnd
) return FALSE
;
1592 if (!top_popup
) top_popup
= menu
->hWnd
;
1594 /* Display the window */
1596 SetWindowPos( menu
->hWnd
, HWND_TOP
, 0, 0, 0, 0,
1597 SWP_SHOWWINDOW
| SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
1598 UpdateWindow( menu
->hWnd
);
1603 /***********************************************************************
1606 static void MENU_SelectItem( HWND hwndOwner
, HMENU hmenu
, UINT wIndex
,
1607 BOOL sendMenuSelect
, HMENU topmenu
)
1612 TRACE("owner=0x%04x menu=0x%04x index=0x%04x select=0x%04x\n", hwndOwner
, hmenu
, wIndex
, sendMenuSelect
);
1614 lppop
= MENU_GetMenu( hmenu
);
1615 if ((!lppop
) || (!lppop
->nItems
) || (!lppop
->hWnd
)) return;
1617 if (lppop
->FocusedItem
== wIndex
) return;
1618 if (lppop
->wFlags
& MF_POPUP
) hdc
= GetDC( lppop
->hWnd
);
1619 else hdc
= GetDCEx( lppop
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1621 SelectObject( hdc
, hMenuFont
);
1623 /* Clear previous highlighted item */
1624 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1626 lppop
->items
[lppop
->FocusedItem
].fState
&= ~(MF_HILITE
|MF_MOUSESELECT
);
1627 MENU_DrawMenuItem(lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,&lppop
->items
[lppop
->FocusedItem
],
1628 lppop
->Height
, !(lppop
->wFlags
& MF_POPUP
),
1632 /* Highlight new item (if any) */
1633 lppop
->FocusedItem
= wIndex
;
1634 if (lppop
->FocusedItem
!= NO_SELECTED_ITEM
)
1636 if(!(lppop
->items
[wIndex
].fType
& MF_SEPARATOR
)) {
1637 lppop
->items
[wIndex
].fState
|= MF_HILITE
;
1638 MENU_DrawMenuItem( lppop
->hWnd
, hmenu
, hwndOwner
, hdc
,
1639 &lppop
->items
[wIndex
], lppop
->Height
,
1640 !(lppop
->wFlags
& MF_POPUP
), ODA_SELECT
);
1644 MENUITEM
*ip
= &lppop
->items
[lppop
->FocusedItem
];
1645 SendMessageA( hwndOwner
, WM_MENUSELECT
,
1646 MAKELONG(ip
->fType
& MF_POPUP
? wIndex
: ip
->wID
,
1647 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1648 (lppop
->wFlags
& MF_SYSMENU
)), hmenu
);
1651 else if (sendMenuSelect
) {
1654 if((pos
=MENU_FindSubMenu(&topmenu
, hmenu
))!=NO_SELECTED_ITEM
){
1655 POPUPMENU
*ptm
= MENU_GetMenu( topmenu
);
1656 MENUITEM
*ip
= &ptm
->items
[pos
];
1657 SendMessageA( hwndOwner
, WM_MENUSELECT
, MAKELONG(pos
,
1658 ip
->fType
| ip
->fState
| MF_MOUSESELECT
|
1659 (ptm
->wFlags
& MF_SYSMENU
)), topmenu
);
1663 ReleaseDC( lppop
->hWnd
, hdc
);
1667 /***********************************************************************
1668 * MENU_MoveSelection
1670 * Moves currently selected item according to the offset parameter.
1671 * If there is no selection then it should select the last item if
1672 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1674 static void MENU_MoveSelection( HWND hwndOwner
, HMENU hmenu
, INT offset
)
1679 TRACE("hwnd=0x%04x hmenu=0x%04x off=0x%04x\n", hwndOwner
, hmenu
, offset
);
1681 menu
= MENU_GetMenu( hmenu
);
1682 if ((!menu
) || (!menu
->items
)) return;
1684 if ( menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1686 if( menu
->nItems
== 1 ) return; else
1687 for (i
= menu
->FocusedItem
+ offset
; i
>= 0 && i
< menu
->nItems
1689 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1691 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1696 for ( i
= (offset
> 0) ? 0 : menu
->nItems
- 1;
1697 i
>= 0 && i
< menu
->nItems
; i
+= offset
)
1698 if (!(menu
->items
[i
].fType
& MF_SEPARATOR
))
1700 MENU_SelectItem( hwndOwner
, hmenu
, i
, TRUE
, 0 );
1706 /**********************************************************************
1709 * Set an item flags, id and text ptr. Called by InsertMenu() and
1712 static BOOL
MENU_SetItemData( MENUITEM
*item
, UINT flags
, UINT id
,
1715 LPWSTR prevText
= IS_STRING_ITEM(item
->fType
) ? item
->text
: NULL
;
1717 debug_print_menuitem("MENU_SetItemData from: ", item
, "");
1718 TRACE("flags=%x str=%p\n", flags
, str
);
1720 if (IS_STRING_ITEM(flags
))
1724 flags
|= MF_SEPARATOR
;
1730 /* Item beginning with a backspace is a help item */
1736 if (!(text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(str
)+1) * sizeof(WCHAR
) )))
1738 strcpyW( text
, str
);
1742 else if (IS_BITMAP_ITEM(flags
))
1743 item
->text
= (LPWSTR
)(HBITMAP
)LOWORD(str
);
1744 else item
->text
= NULL
;
1746 if (flags
& MF_OWNERDRAW
)
1747 item
->dwItemData
= (DWORD
)str
;
1749 item
->dwItemData
= 0;
1751 if ((item
->fType
& MF_POPUP
) && (flags
& MF_POPUP
) && (item
->hSubMenu
!= id
) )
1752 DestroyMenu( item
->hSubMenu
); /* ModifyMenu() spec */
1754 if (flags
& MF_POPUP
)
1756 POPUPMENU
*menu
= MENU_GetMenu((UINT16
)id
);
1757 if (menu
) menu
->wFlags
|= MF_POPUP
;
1769 if (flags
& MF_POPUP
)
1770 item
->hSubMenu
= id
;
1772 if ((item
->fType
& MF_POPUP
) && !(flags
& MF_POPUP
) )
1773 flags
|= MF_POPUP
; /* keep popup */
1775 item
->fType
= flags
& TYPE_MASK
;
1776 item
->fState
= (flags
& STATE_MASK
) &
1777 ~(MF_HILITE
| MF_MOUSESELECT
| MF_BYPOSITION
);
1780 /* Don't call SetRectEmpty here! */
1783 if (prevText
) HeapFree( GetProcessHeap(), 0, prevText
);
1785 debug_print_menuitem("MENU_SetItemData to : ", item
, "");
1790 /**********************************************************************
1793 * Insert a new item into a menu.
1795 static MENUITEM
*MENU_InsertItem( HMENU hMenu
, UINT pos
, UINT flags
)
1800 if (!(menu
= MENU_GetMenu(hMenu
)))
1803 /* Find where to insert new item */
1805 if (flags
& MF_BYPOSITION
) {
1806 if (pos
> menu
->nItems
)
1809 if (!MENU_FindItem( &hMenu
, &pos
, flags
))
1812 if (!(menu
= MENU_GetMenu( hMenu
)))
1817 /* Create new items array */
1819 newItems
= HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM
) * (menu
->nItems
+1) );
1822 WARN("allocation failed\n" );
1825 if (menu
->nItems
> 0)
1827 /* Copy the old array into the new one */
1828 if (pos
> 0) memcpy( newItems
, menu
->items
, pos
* sizeof(MENUITEM
) );
1829 if (pos
< menu
->nItems
) memcpy( &newItems
[pos
+1], &menu
->items
[pos
],
1830 (menu
->nItems
-pos
)*sizeof(MENUITEM
) );
1831 HeapFree( GetProcessHeap(), 0, menu
->items
);
1833 menu
->items
= newItems
;
1835 memset( &newItems
[pos
], 0, sizeof(*newItems
) );
1836 menu
->Height
= 0; /* force size recalculate */
1837 return &newItems
[pos
];
1841 /**********************************************************************
1842 * MENU_ParseResource
1844 * Parse a standard menu resource and add items to the menu.
1845 * Return a pointer to the end of the resource.
1847 static LPCSTR
MENU_ParseResource( LPCSTR res
, HMENU hMenu
, BOOL unicode
)
1854 flags
= GET_WORD(res
);
1855 res
+= sizeof(WORD
);
1856 if (!(flags
& MF_POPUP
))
1859 res
+= sizeof(WORD
);
1861 if (!IS_STRING_ITEM(flags
))
1862 ERR("not a string item %04x\n", flags
);
1864 if (!unicode
) res
+= strlen(str
) + 1;
1865 else res
+= (strlenW((LPCWSTR
)str
) + 1) * sizeof(WCHAR
);
1866 if (flags
& MF_POPUP
)
1868 HMENU hSubMenu
= CreatePopupMenu();
1869 if (!hSubMenu
) return NULL
;
1870 if (!(res
= MENU_ParseResource( res
, hSubMenu
, unicode
)))
1872 if (!unicode
) AppendMenuA( hMenu
, flags
, (UINT
)hSubMenu
, str
);
1873 else AppendMenuW( hMenu
, flags
, (UINT
)hSubMenu
, (LPCWSTR
)str
);
1875 else /* Not a popup */
1877 if (!unicode
) AppendMenuA( hMenu
, flags
, id
, *str
? str
: NULL
);
1878 else AppendMenuW( hMenu
, flags
, id
,
1879 *(LPCWSTR
)str
? (LPCWSTR
)str
: NULL
);
1881 } while (!(flags
& MF_END
));
1886 /**********************************************************************
1887 * MENUEX_ParseResource
1889 * Parse an extended menu resource and add items to the menu.
1890 * Return a pointer to the end of the resource.
1892 static LPCSTR
MENUEX_ParseResource( LPCSTR res
, HMENU hMenu
)
1898 mii
.cbSize
= sizeof(mii
);
1899 mii
.fMask
= MIIM_STATE
| MIIM_ID
| MIIM_TYPE
;
1900 mii
.fType
= GET_DWORD(res
);
1901 res
+= sizeof(DWORD
);
1902 mii
.fState
= GET_DWORD(res
);
1903 res
+= sizeof(DWORD
);
1904 mii
.wID
= GET_DWORD(res
);
1905 res
+= sizeof(DWORD
);
1906 resinfo
= GET_WORD(res
); /* FIXME: for 16-bit apps this is a byte. */
1907 res
+= sizeof(WORD
);
1908 /* Align the text on a word boundary. */
1909 res
+= (~((int)res
- 1)) & 1;
1910 mii
.dwTypeData
= (LPWSTR
) res
;
1911 res
+= (1 + strlenW(mii
.dwTypeData
)) * sizeof(WCHAR
);
1912 /* Align the following fields on a dword boundary. */
1913 res
+= (~((int)res
- 1)) & 3;
1915 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1916 mii
.fType
, mii
.fState
, mii
.wID
, resinfo
, debugstr_w(mii
.dwTypeData
));
1918 if (resinfo
& 1) { /* Pop-up? */
1919 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1920 res
+= sizeof(DWORD
);
1921 mii
.hSubMenu
= CreatePopupMenu();
1924 if (!(res
= MENUEX_ParseResource(res
, mii
.hSubMenu
))) {
1925 DestroyMenu(mii
.hSubMenu
);
1928 mii
.fMask
|= MIIM_SUBMENU
;
1929 mii
.fType
|= MF_POPUP
;
1931 InsertMenuItemW(hMenu
, -1, MF_BYPOSITION
, &mii
);
1932 } while (!(resinfo
& MF_END
));
1937 /***********************************************************************
1940 * Return the handle of the selected sub-popup menu (if any).
1942 static HMENU
MENU_GetSubPopup( HMENU hmenu
)
1947 menu
= MENU_GetMenu( hmenu
);
1949 if ((!menu
) || (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return 0;
1951 item
= &menu
->items
[menu
->FocusedItem
];
1952 if ((item
->fType
& MF_POPUP
) && (item
->fState
& MF_MOUSESELECT
))
1953 return item
->hSubMenu
;
1958 /***********************************************************************
1959 * MENU_HideSubPopups
1961 * Hide the sub-popup menus of this menu.
1963 static void MENU_HideSubPopups( HWND hwndOwner
, HMENU hmenu
,
1964 BOOL sendMenuSelect
)
1966 POPUPMENU
*menu
= MENU_GetMenu( hmenu
);
1968 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner
, hmenu
, sendMenuSelect
);
1970 if (menu
&& top_popup
)
1976 if (menu
->FocusedItem
!= NO_SELECTED_ITEM
)
1978 item
= &menu
->items
[menu
->FocusedItem
];
1979 if (!(item
->fType
& MF_POPUP
) ||
1980 !(item
->fState
& MF_MOUSESELECT
)) return;
1981 item
->fState
&= ~MF_MOUSESELECT
;
1982 hsubmenu
= item
->hSubMenu
;
1985 submenu
= MENU_GetMenu( hsubmenu
);
1986 MENU_HideSubPopups( hwndOwner
, hsubmenu
, FALSE
);
1987 MENU_SelectItem( hwndOwner
, hsubmenu
, NO_SELECTED_ITEM
, sendMenuSelect
, 0 );
1988 DestroyWindow( submenu
->hWnd
);
1994 /***********************************************************************
1997 * Display the sub-menu of the selected item of this menu.
1998 * Return the handle of the submenu, or hmenu if no submenu to display.
2000 static HMENU
MENU_ShowSubPopup( HWND hwndOwner
, HMENU hmenu
,
2001 BOOL selectFirst
, UINT wFlags
)
2008 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner
, hmenu
, selectFirst
);
2010 if (!(menu
= MENU_GetMenu( hmenu
))) return hmenu
;
2012 if (menu
->FocusedItem
== NO_SELECTED_ITEM
) return hmenu
;
2014 item
= &menu
->items
[menu
->FocusedItem
];
2015 if (!(item
->fType
& MF_POPUP
) || (item
->fState
& (MF_GRAYED
| MF_DISABLED
)))
2018 /* message must be sent before using item,
2019 because nearly everything may be changed by the application ! */
2021 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2022 if (!(wFlags
& TPM_NONOTIFY
))
2023 SendMessageA( hwndOwner
, WM_INITMENUPOPUP
, item
->hSubMenu
,
2024 MAKELONG( menu
->FocusedItem
, IS_SYSTEM_MENU(menu
) ));
2026 item
= &menu
->items
[menu
->FocusedItem
];
2029 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2030 if (!(item
->fState
& MF_HILITE
))
2032 if (menu
->wFlags
& MF_POPUP
) hdc
= GetDC( menu
->hWnd
);
2033 else hdc
= GetDCEx( menu
->hWnd
, 0, DCX_CACHE
| DCX_WINDOW
);
2035 SelectObject( hdc
, hMenuFont
);
2037 item
->fState
|= MF_HILITE
;
2038 MENU_DrawMenuItem( menu
->hWnd
, hmenu
, hwndOwner
, hdc
, item
, menu
->Height
, !(menu
->wFlags
& MF_POPUP
), ODA_DRAWENTIRE
);
2039 ReleaseDC( menu
->hWnd
, hdc
);
2041 if (!item
->rect
.top
&& !item
->rect
.left
&& !item
->rect
.bottom
&& !item
->rect
.right
)
2044 item
->fState
|= MF_MOUSESELECT
;
2046 if (IS_SYSTEM_MENU(menu
))
2048 MENU_InitSysMenuPopup(item
->hSubMenu
,
2049 GetWindowLongA( menu
->hWnd
, GWL_STYLE
),
2050 GetClassLongA( menu
->hWnd
, GCL_STYLE
));
2052 NC_GetSysPopupPos( menu
->hWnd
, &rect
);
2053 rect
.top
= rect
.bottom
;
2054 rect
.right
= GetSystemMetrics(SM_CXSIZE
);
2055 rect
.bottom
= GetSystemMetrics(SM_CYSIZE
);
2059 GetWindowRect( menu
->hWnd
, &rect
);
2060 if (menu
->wFlags
& MF_POPUP
)
2062 rect
.left
+= item
->rect
.right
- GetSystemMetrics(SM_CXBORDER
);
2063 rect
.top
+= item
->rect
.top
;
2064 rect
.right
= item
->rect
.left
- item
->rect
.right
+ GetSystemMetrics(SM_CXBORDER
);
2065 rect
.bottom
= item
->rect
.top
- item
->rect
.bottom
;
2069 rect
.left
+= item
->rect
.left
;
2070 rect
.top
+= item
->rect
.bottom
;
2071 rect
.right
= item
->rect
.right
- item
->rect
.left
;
2072 rect
.bottom
= item
->rect
.bottom
- item
->rect
.top
;
2076 MENU_ShowPopup( hwndOwner
, item
->hSubMenu
, menu
->FocusedItem
,
2077 rect
.left
, rect
.top
, rect
.right
, rect
.bottom
);
2079 MENU_MoveSelection( hwndOwner
, item
->hSubMenu
, ITEM_NEXT
);
2080 return item
->hSubMenu
;
2085 /**********************************************************************
2088 BOOL
MENU_IsMenuActive(void)
2090 return (top_popup
!= 0);
2093 /***********************************************************************
2096 * Walks menu chain trying to find a menu pt maps to.
2098 static HMENU
MENU_PtMenu( HMENU hMenu
, POINT pt
)
2100 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2101 UINT item
= menu
->FocusedItem
;
2104 /* try subpopup first (if any) */
2105 ret
= (item
!= NO_SELECTED_ITEM
&&
2106 (menu
->items
[item
].fType
& MF_POPUP
) &&
2107 (menu
->items
[item
].fState
& MF_MOUSESELECT
))
2108 ? MENU_PtMenu(menu
->items
[item
].hSubMenu
, pt
) : 0;
2110 if (!ret
) /* check the current window (avoiding WM_HITTEST) */
2112 INT ht
= NC_HandleNCHitTest( menu
->hWnd
, pt
);
2113 if( menu
->wFlags
& MF_POPUP
)
2115 if (ht
!= HTNOWHERE
&& ht
!= HTERROR
) ret
= hMenu
;
2117 else if (ht
== HTSYSMENU
)
2118 ret
= get_win_sys_menu( menu
->hWnd
);
2119 else if (ht
== HTMENU
)
2120 ret
= GetMenu( menu
->hWnd
);
2125 /***********************************************************************
2126 * MENU_ExecFocusedItem
2128 * Execute a menu item (for instance when user pressed Enter).
2129 * Return the wID of the executed item. Otherwise, -1 indicating
2130 * that no menu item was executed;
2131 * Have to receive the flags for the TrackPopupMenu options to avoid
2132 * sending unwanted message.
2135 static INT
MENU_ExecFocusedItem( MTRACKER
* pmt
, HMENU hMenu
, UINT wFlags
)
2138 POPUPMENU
*menu
= MENU_GetMenu( hMenu
);
2140 TRACE("%p hmenu=0x%04x\n", pmt
, hMenu
);
2142 if (!menu
|| !menu
->nItems
||
2143 (menu
->FocusedItem
== NO_SELECTED_ITEM
)) return -1;
2145 item
= &menu
->items
[menu
->FocusedItem
];
2147 TRACE("%08x %08x %08x\n",
2148 hMenu
, item
->wID
, item
->hSubMenu
);
2150 if (!(item
->fType
& MF_POPUP
))
2152 if (!(item
->fState
& (MF_GRAYED
| MF_DISABLED
)) && !(item
->fType
& MF_SEPARATOR
))
2154 /* If TPM_RETURNCMD is set you return the id, but
2155 do not send a message to the owner */
2156 if(!(wFlags
& TPM_RETURNCMD
))
2158 if( menu
->wFlags
& MF_SYSMENU
)
2159 PostMessageA( pmt
->hOwnerWnd
, WM_SYSCOMMAND
, item
->wID
,
2160 MAKELPARAM((INT16
)pmt
->pt
.x
, (INT16
)pmt
->pt
.y
) );
2162 PostMessageA( pmt
->hOwnerWnd
, WM_COMMAND
, item
->wID
, 0 );
2168 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hMenu
, TRUE
, wFlags
);
2173 /***********************************************************************
2174 * MENU_SwitchTracking
2176 * Helper function for menu navigation routines.
2178 static void MENU_SwitchTracking( MTRACKER
* pmt
, HMENU hPtMenu
, UINT id
)
2180 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2181 POPUPMENU
*topmenu
= MENU_GetMenu( pmt
->hTopMenu
);
2183 TRACE("%p hmenu=0x%04x 0x%04x\n", pmt
, hPtMenu
, id
);
2185 if( pmt
->hTopMenu
!= hPtMenu
&&
2186 !((ptmenu
->wFlags
| topmenu
->wFlags
) & MF_POPUP
) )
2188 /* both are top level menus (system and menu-bar) */
2189 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2190 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2191 pmt
->hTopMenu
= hPtMenu
;
2193 else MENU_HideSubPopups( pmt
->hOwnerWnd
, hPtMenu
, FALSE
);
2194 MENU_SelectItem( pmt
->hOwnerWnd
, hPtMenu
, id
, TRUE
, 0 );
2198 /***********************************************************************
2201 * Return TRUE if we can go on with menu tracking.
2203 static BOOL
MENU_ButtonDown( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2205 TRACE("%p hmenu=0x%04x\n", pmt
, hPtMenu
);
2210 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2213 if( IS_SYSTEM_MENU(ptmenu
) )
2214 item
= ptmenu
->items
;
2216 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2220 if( ptmenu
->FocusedItem
!= id
)
2221 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2223 /* If the popup menu is not already "popped" */
2224 if(!(item
->fState
& MF_MOUSESELECT
))
2226 pmt
->hCurrentMenu
= MENU_ShowSubPopup( pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2228 /* In win31, a newly popped menu always remains opened for the next buttonup */
2229 if(TWEAK_WineLook
== WIN31_LOOK
)
2230 ptmenu
->bTimeToHide
= FALSE
;
2235 /* Else the click was on the menu bar, finish the tracking */
2240 /***********************************************************************
2243 * Return the value of MENU_ExecFocusedItem if
2244 * the selected item was not a popup. Else open the popup.
2245 * A -1 return value indicates that we go on with menu tracking.
2248 static INT
MENU_ButtonUp( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2250 TRACE("%p hmenu=0x%04x\n", pmt
, hPtMenu
);
2255 POPUPMENU
*ptmenu
= MENU_GetMenu( hPtMenu
);
2258 if( IS_SYSTEM_MENU(ptmenu
) )
2259 item
= ptmenu
->items
;
2261 item
= MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2263 if( item
&& (ptmenu
->FocusedItem
== id
))
2265 if( !(item
->fType
& MF_POPUP
) )
2266 return MENU_ExecFocusedItem( pmt
, hPtMenu
, wFlags
);
2268 /* If we are dealing with the top-level menu */
2269 /* and this is a click on an already "popped" item: */
2270 /* Stop the menu tracking and close the opened submenus */
2271 if((pmt
->hTopMenu
== hPtMenu
) && (ptmenu
->bTimeToHide
== TRUE
))
2274 ptmenu
->bTimeToHide
= TRUE
;
2280 /***********************************************************************
2283 * Return TRUE if we can go on with menu tracking.
2285 static BOOL
MENU_MouseMove( MTRACKER
* pmt
, HMENU hPtMenu
, UINT wFlags
)
2287 UINT id
= NO_SELECTED_ITEM
;
2288 POPUPMENU
*ptmenu
= NULL
;
2292 ptmenu
= MENU_GetMenu( hPtMenu
);
2293 if( IS_SYSTEM_MENU(ptmenu
) )
2296 MENU_FindItemByCoords( ptmenu
, pmt
->pt
, &id
);
2299 if( id
== NO_SELECTED_ITEM
)
2301 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2302 NO_SELECTED_ITEM
, TRUE
, pmt
->hTopMenu
);
2305 else if( ptmenu
->FocusedItem
!= id
)
2307 MENU_SwitchTracking( pmt
, hPtMenu
, id
);
2308 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hPtMenu
, FALSE
, wFlags
);
2314 /***********************************************************************
2317 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2319 static LRESULT
MENU_DoNextMenu( MTRACKER
* pmt
, UINT vk
)
2321 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2323 if( (vk
== VK_LEFT
&& menu
->FocusedItem
== 0 ) ||
2324 (vk
== VK_RIGHT
&& menu
->FocusedItem
== menu
->nItems
- 1))
2329 LRESULT l
= SendMessageA( pmt
->hOwnerWnd
, WM_NEXTMENU
, vk
,
2330 (IS_SYSTEM_MENU(menu
)) ? GetSubMenu(pmt
->hTopMenu
,0) : pmt
->hTopMenu
);
2332 TRACE("%04x [%04x] -> %04x [%04x]\n",
2333 (UINT16
)pmt
->hCurrentMenu
, (UINT16
)pmt
->hOwnerWnd
, LOWORD(l
), HIWORD(l
) );
2337 DWORD style
= GetWindowLongA( pmt
->hOwnerWnd
, GWL_STYLE
);
2338 hNewWnd
= pmt
->hOwnerWnd
;
2339 if( IS_SYSTEM_MENU(menu
) )
2341 /* switch to the menu bar */
2343 if(style
& WS_CHILD
|| !(hNewMenu
= GetMenu(hNewWnd
))) return FALSE
;
2347 menu
= MENU_GetMenu( hNewMenu
);
2348 id
= menu
->nItems
- 1;
2351 else if (style
& WS_SYSMENU
)
2353 /* switch to the system menu */
2354 hNewMenu
= get_win_sys_menu( hNewWnd
);
2358 else /* application returned a new menu to switch to */
2360 hNewMenu
= LOWORD(l
);
2361 hNewWnd
= HIWORD(l
);
2363 if( IsMenu(hNewMenu
) && IsWindow(hNewWnd
) )
2365 DWORD style
= GetWindowLongA( hNewWnd
, GWL_STYLE
);
2367 if (style
& WS_SYSMENU
&&
2368 GetSubMenu(get_win_sys_menu(hNewWnd
), 0) == hNewMenu
)
2370 /* get the real system menu */
2371 hNewMenu
= get_win_sys_menu(hNewWnd
);
2373 else if (style
& WS_CHILD
|| GetMenu(hNewWnd
) != hNewMenu
)
2375 /* FIXME: Not sure what to do here;
2376 * perhaps try to track hNewMenu as a popup? */
2378 TRACE(" -- got confused.\n");
2385 if( hNewMenu
!= pmt
->hTopMenu
)
2387 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, NO_SELECTED_ITEM
,
2389 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2390 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2393 if( hNewWnd
!= pmt
->hOwnerWnd
)
2396 pmt
->hOwnerWnd
= hNewWnd
;
2397 EVENT_Capture( pmt
->hOwnerWnd
, HTMENU
);
2400 pmt
->hTopMenu
= pmt
->hCurrentMenu
= hNewMenu
; /* all subpopups are hidden */
2401 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hTopMenu
, id
, TRUE
, 0 );
2408 /***********************************************************************
2411 * The idea is not to show the popup if the next input message is
2412 * going to hide it anyway.
2414 static BOOL
MENU_SuspendPopup( MTRACKER
* pmt
, UINT16 uMsg
)
2418 msg
.hwnd
= pmt
->hOwnerWnd
;
2420 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2421 pmt
->trackFlags
|= TF_SKIPREMOVE
;
2426 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2427 if( msg
.message
== WM_KEYUP
|| msg
.message
== WM_PAINT
)
2429 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_REMOVE
);
2430 PeekMessageA( &msg
, 0, 0, 0, PM_NOYIELD
| PM_NOREMOVE
);
2431 if( msg
.message
== WM_KEYDOWN
&&
2432 (msg
.wParam
== VK_LEFT
|| msg
.wParam
== VK_RIGHT
))
2434 pmt
->trackFlags
|= TF_SUSPENDPOPUP
;
2441 /* failures go through this */
2442 pmt
->trackFlags
&= ~TF_SUSPENDPOPUP
;
2446 /***********************************************************************
2449 * Handle a VK_ESCAPE key event in a menu.
2451 static BOOL
MENU_KeyEscape(MTRACKER
* pmt
, UINT wFlags
)
2453 BOOL bEndMenu
= TRUE
;
2455 if (pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2457 POPUPMENU
*menu
= MENU_GetMenu(pmt
->hCurrentMenu
);
2459 if (menu
->wFlags
& MF_POPUP
)
2461 HMENU hmenutmp
, hmenuprev
;
2463 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2465 /* close topmost popup */
2466 while (hmenutmp
!= pmt
->hCurrentMenu
)
2468 hmenuprev
= hmenutmp
;
2469 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2472 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2473 pmt
->hCurrentMenu
= hmenuprev
;
2481 /***********************************************************************
2484 * Handle a VK_LEFT key event in a menu.
2486 static void MENU_KeyLeft( MTRACKER
* pmt
, UINT wFlags
)
2489 HMENU hmenutmp
, hmenuprev
;
2492 hmenuprev
= hmenutmp
= pmt
->hTopMenu
;
2493 menu
= MENU_GetMenu( hmenutmp
);
2495 /* Try to move 1 column left (if possible) */
2496 if( (prevcol
= MENU_GetStartOfPrevColumn( pmt
->hCurrentMenu
)) !=
2497 NO_SELECTED_ITEM
) {
2499 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2504 /* close topmost popup */
2505 while (hmenutmp
!= pmt
->hCurrentMenu
)
2507 hmenuprev
= hmenutmp
;
2508 hmenutmp
= MENU_GetSubPopup( hmenuprev
);
2511 MENU_HideSubPopups( pmt
->hOwnerWnd
, hmenuprev
, TRUE
);
2512 pmt
->hCurrentMenu
= hmenuprev
;
2514 if ( (hmenuprev
== pmt
->hTopMenu
) && !(menu
->wFlags
& MF_POPUP
) )
2516 /* move menu bar selection if no more popups are left */
2518 if( !MENU_DoNextMenu( pmt
, VK_LEFT
) )
2519 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_PREV
);
2521 if ( hmenuprev
!= hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2523 /* A sublevel menu was displayed - display the next one
2524 * unless there is another displacement coming up */
2526 if( !MENU_SuspendPopup( pmt
, WM_KEYDOWN
) )
2527 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2528 pmt
->hTopMenu
, TRUE
, wFlags
);
2534 /***********************************************************************
2537 * Handle a VK_RIGHT key event in a menu.
2539 static void MENU_KeyRight( MTRACKER
* pmt
, UINT wFlags
)
2542 POPUPMENU
*menu
= MENU_GetMenu( pmt
->hTopMenu
);
2545 TRACE("MENU_KeyRight called, cur %x (%s), top %x (%s).\n",
2547 debugstr_w((MENU_GetMenu(pmt
->hCurrentMenu
))->
2549 pmt
->hTopMenu
, debugstr_w(menu
->items
[0].text
) );
2551 if ( (menu
->wFlags
& MF_POPUP
) || (pmt
->hCurrentMenu
!= pmt
->hTopMenu
))
2553 /* If already displaying a popup, try to display sub-popup */
2555 hmenutmp
= pmt
->hCurrentMenu
;
2556 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
, hmenutmp
, TRUE
, wFlags
);
2558 /* if subpopup was displayed then we are done */
2559 if (hmenutmp
!= pmt
->hCurrentMenu
) return;
2562 /* Check to see if there's another column */
2563 if( (nextcol
= MENU_GetStartOfNextColumn( pmt
->hCurrentMenu
)) !=
2564 NO_SELECTED_ITEM
) {
2565 TRACE("Going to %d.\n", nextcol
);
2566 MENU_SelectItem( pmt
->hOwnerWnd
, pmt
->hCurrentMenu
,
2571 if (!(menu
->wFlags
& MF_POPUP
)) /* menu bar tracking */
2573 if( pmt
->hCurrentMenu
!= pmt
->hTopMenu
)
2575 MENU_HideSubPopups( pmt
->hOwnerWnd
, pmt
->hTopMenu
, FALSE
);
2576 hmenutmp
= pmt
->hCurrentMenu
= pmt
->hTopMenu
;
2577 } else hmenutmp
= 0;
2579 /* try to move to the next item */
2580 if( !MENU_DoNextMenu( pmt
, VK_RIGHT
) )
2581 MENU_MoveSelection( pmt
->hOwnerWnd
, pmt
->hTopMenu
, ITEM_NEXT
);
2583 if( hmenutmp
|| pmt
->trackFlags
& TF_SUSPENDPOPUP
)
2584 if( !MENU_SuspendPopup(pmt
, WM_KEYDOWN
) )
2585 pmt
->hCurrentMenu
= MENU_ShowSubPopup(pmt
->hOwnerWnd
,
2586 pmt
->hTopMenu
, TRUE
, wFlags
);
2590 /***********************************************************************
2593 * Menu tracking code.
2595 static INT
MENU_TrackMenu( HMENU hmenu
, UINT wFlags
, INT x
, INT y
,
2596 HWND hwnd
, const RECT
*lprect
)
2601 INT executedMenuId
= -1;
2603 BOOL enterIdleSent
= FALSE
;
2606 mt
.hCurrentMenu
= hmenu
;
2607 mt
.hTopMenu
= hmenu
;
2608 mt
.hOwnerWnd
= hwnd
;
2612 TRACE("hmenu=0x%04x flags=0x%08x (%d,%d) hwnd=0x%04x (%d,%d)-(%d,%d)\n",
2613 hmenu
, wFlags
, x
, y
, hwnd
, (lprect
) ? lprect
->left
: 0, (lprect
) ? lprect
->top
: 0,
2614 (lprect
) ? lprect
->right
: 0, (lprect
) ? lprect
->bottom
: 0);
2617 if (!(menu
= MENU_GetMenu( hmenu
))) return FALSE
;
2619 if (wFlags
& TPM_BUTTONDOWN
)
2621 /* Get the result in order to start the tracking or not */
2622 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2623 fEndMenu
= !fRemove
;
2626 EVENT_Capture( mt
.hOwnerWnd
, HTMENU
);
2630 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2631 if (!menu
) /* sometimes happens if I do a window manager close */
2634 /* we have to keep the message in the queue until it's
2635 * clear that menu loop is not over yet. */
2639 if (PeekMessageA( &msg
, 0, 0, 0, PM_NOREMOVE
))
2641 if (!CallMsgFilterA( &msg
, MSGF_MENU
)) break;
2642 /* remove the message from the queue */
2643 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2649 HWND win
= (wFlags
& TPM_ENTERIDLEEX
&& menu
->wFlags
& MF_POPUP
) ? menu
->hWnd
: 0;
2650 enterIdleSent
= TRUE
;
2651 SendMessageW( mt
.hOwnerWnd
, WM_ENTERIDLE
, MSGF_MENU
, (LPARAM
)win
);
2657 /* check if EndMenu() tried to cancel us, by posting this message */
2658 if(msg
.message
== WM_CANCELMODE
)
2660 /* we are now out of the loop */
2663 /* remove the message from the queue */
2664 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2666 /* break out of internal loop, ala ESCAPE */
2670 TranslateMessage( &msg
);
2673 if ( (msg
.hwnd
==menu
->hWnd
) || (msg
.message
!=WM_TIMER
) )
2674 enterIdleSent
=FALSE
;
2677 if ((msg
.message
>= WM_MOUSEFIRST
) && (msg
.message
<= WM_MOUSELAST
))
2680 * use the mouse coordinates in lParam instead of those in the MSG
2681 * struct to properly handle synthetic messages. lParam coords are
2682 * relative to client area, so they must be converted; since they can
2683 * be negative, we must use SLOWORD/SHIWORD instead of LOWORD/HIWORD.
2685 mt
.pt
.x
= SLOWORD(msg
.lParam
);
2686 mt
.pt
.y
= SHIWORD(msg
.lParam
);
2687 ClientToScreen(msg
.hwnd
,&mt
.pt
);
2689 /* Find a menu for this mouse event */
2690 hmenu
= MENU_PtMenu( mt
.hTopMenu
, mt
.pt
);
2694 /* no WM_NC... messages in captured state */
2696 case WM_RBUTTONDBLCLK
:
2697 case WM_RBUTTONDOWN
:
2698 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2700 case WM_LBUTTONDBLCLK
:
2701 case WM_LBUTTONDOWN
:
2702 /* If the message belongs to the menu, removes it from the queue */
2703 /* Else, end menu tracking */
2704 fRemove
= MENU_ButtonDown( &mt
, hmenu
, wFlags
);
2705 fEndMenu
= !fRemove
;
2709 if (!(wFlags
& TPM_RIGHTBUTTON
)) break;
2712 /* Check if a menu was selected by the mouse */
2715 executedMenuId
= MENU_ButtonUp( &mt
, hmenu
, wFlags
);
2717 /* End the loop if executedMenuId is an item ID */
2718 /* or if the job was done (executedMenuId = 0). */
2719 fEndMenu
= fRemove
= (executedMenuId
!= -1);
2721 /* No menu was selected by the mouse */
2722 /* if the function was called by TrackPopupMenu, continue
2723 with the menu tracking. If not, stop it */
2725 fEndMenu
= ((wFlags
& TPM_POPUPMENU
) ? FALSE
: TRUE
);
2730 /* In win95 winelook, the selected menu item must be changed every time the
2731 mouse moves. In Win31 winelook, the mouse button has to be held down */
2733 if ( (TWEAK_WineLook
> WIN31_LOOK
) ||
2734 ( (msg
.wParam
& MK_LBUTTON
) ||
2735 ((wFlags
& TPM_RIGHTBUTTON
) && (msg
.wParam
& MK_RBUTTON
))) )
2737 fEndMenu
|= !MENU_MouseMove( &mt
, hmenu
, wFlags
);
2739 } /* switch(msg.message) - mouse */
2741 else if ((msg
.message
>= WM_KEYFIRST
) && (msg
.message
<= WM_KEYLAST
))
2743 fRemove
= TRUE
; /* Keyboard messages are always removed */
2751 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2752 NO_SELECTED_ITEM
, FALSE
, 0 );
2755 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2756 (msg
.wParam
== VK_HOME
)? ITEM_NEXT
: ITEM_PREV
);
2759 case VK_DOWN
: /* If on menu bar, pull-down the menu */
2761 menu
= MENU_GetMenu( mt
.hCurrentMenu
);
2762 if (!(menu
->wFlags
& MF_POPUP
))
2763 mt
.hCurrentMenu
= MENU_ShowSubPopup(mt
.hOwnerWnd
, mt
.hTopMenu
, TRUE
, wFlags
);
2764 else /* otherwise try to move selection */
2765 MENU_MoveSelection( mt
.hOwnerWnd
, mt
.hCurrentMenu
, ITEM_NEXT
);
2769 MENU_KeyLeft( &mt
, wFlags
);
2773 MENU_KeyRight( &mt
, wFlags
);
2777 fEndMenu
= MENU_KeyEscape(&mt
, wFlags
);
2783 hi
.cbSize
= sizeof(HELPINFO
);
2784 hi
.iContextType
= HELPINFO_MENUITEM
;
2785 if (menu
->FocusedItem
== NO_SELECTED_ITEM
)
2788 hi
.iCtrlId
= menu
->items
[menu
->FocusedItem
].wID
;
2789 hi
.hItemHandle
= hmenu
;
2790 hi
.dwContextId
= menu
->dwContextHelpID
;
2791 hi
.MousePos
= msg
.pt
;
2792 SendMessageA(hwnd
, WM_HELP
, 0, (LPARAM
)&hi
);
2799 break; /* WM_KEYDOWN */
2809 break; /* WM_SYSKEYDOWN */
2815 if (msg
.wParam
== '\r' || msg
.wParam
== ' ')
2817 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2818 fEndMenu
= (executedMenuId
!= -1);
2823 /* Hack to avoid control chars. */
2824 /* We will find a better way real soon... */
2825 if ((msg
.wParam
<= 32) || (msg
.wParam
>= 127)) break;
2827 pos
= MENU_FindItemByKey( mt
.hOwnerWnd
, mt
.hCurrentMenu
,
2828 LOWORD(msg
.wParam
), FALSE
);
2829 if (pos
== (UINT
)-2) fEndMenu
= TRUE
;
2830 else if (pos
== (UINT
)-1) MessageBeep(0);
2833 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hCurrentMenu
, pos
,
2835 executedMenuId
= MENU_ExecFocusedItem(&mt
,mt
.hCurrentMenu
, wFlags
);
2836 fEndMenu
= (executedMenuId
!= -1);
2840 } /* switch(msg.message) - kbd */
2844 DispatchMessageA( &msg
);
2847 if (!fEndMenu
) fRemove
= TRUE
;
2849 /* finally remove message from the queue */
2851 if (fRemove
&& !(mt
.trackFlags
& TF_SKIPREMOVE
) )
2852 PeekMessageA( &msg
, 0, msg
.message
, msg
.message
, PM_REMOVE
);
2853 else mt
.trackFlags
&= ~TF_SKIPREMOVE
;
2858 /* If dropdown is still painted and the close box is clicked on
2859 then the menu will be destroyed as part of the DispatchMessage above.
2860 This will then invalidate the menu handle in mt.hTopMenu. We should
2861 check for this first. */
2862 if( IsMenu( mt
.hTopMenu
) )
2864 menu
= MENU_GetMenu( mt
.hTopMenu
);
2866 if( IsWindow( mt
.hOwnerWnd
) )
2868 MENU_HideSubPopups( mt
.hOwnerWnd
, mt
.hTopMenu
, FALSE
);
2870 if (menu
&& menu
->wFlags
& MF_POPUP
)
2872 DestroyWindow( menu
->hWnd
);
2875 MENU_SelectItem( mt
.hOwnerWnd
, mt
.hTopMenu
, NO_SELECTED_ITEM
, FALSE
, 0 );
2876 SendMessageA( mt
.hOwnerWnd
, WM_MENUSELECT
, MAKELONG(0,0xffff), 0 );
2879 /* Reset the variable for hiding menu */
2880 if( menu
) menu
->bTimeToHide
= FALSE
;
2883 /* The return value is only used by TrackPopupMenu */
2884 return ((executedMenuId
!= -1) ? executedMenuId
: 0);
2887 /***********************************************************************
2890 static BOOL
MENU_InitTracking(HWND hWnd
, HMENU hMenu
, BOOL bPopup
, UINT wFlags
)
2892 TRACE("hwnd=0x%04x hmenu=0x%04x\n", hWnd
, hMenu
);
2896 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2897 if (!(wFlags
& TPM_NONOTIFY
))
2898 SendMessageA( hWnd
, WM_ENTERMENULOOP
, bPopup
, 0 );
2900 SendMessageA( hWnd
, WM_SETCURSOR
, hWnd
, HTCAPTION
);
2902 if (!(wFlags
& TPM_NONOTIFY
))
2905 SendMessageA( hWnd
, WM_INITMENU
, hMenu
, 0 );
2906 if ((menu
= MENU_GetMenu( hMenu
)) && (!menu
->Height
))
2907 { /* app changed/recreated menu bar entries in WM_INITMENU
2908 Recalculate menu sizes else clicks will not work */
2909 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
2910 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
2916 /***********************************************************************
2919 static BOOL
MENU_ExitTracking(HWND hWnd
)
2921 TRACE("hwnd=0x%04x\n", hWnd
);
2923 SendMessageA( hWnd
, WM_EXITMENULOOP
, 0, 0 );
2928 /***********************************************************************
2929 * MENU_TrackMouseMenuBar
2931 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2933 void MENU_TrackMouseMenuBar( HWND hWnd
, INT ht
, POINT pt
)
2935 HMENU hMenu
= (ht
== HTSYSMENU
) ? get_win_sys_menu( hWnd
) : GetMenu( hWnd
);
2936 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_BUTTONDOWN
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
2938 TRACE("wnd=%x ht=0x%04x (%ld,%ld)\n", hWnd
, ht
, pt
.x
, pt
.y
);
2942 MENU_InitTracking( hWnd
, hMenu
, FALSE
, wFlags
);
2943 MENU_TrackMenu( hMenu
, wFlags
, pt
.x
, pt
.y
, hWnd
, NULL
);
2944 MENU_ExitTracking(hWnd
);
2949 /***********************************************************************
2950 * MENU_TrackKbdMenuBar
2952 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
2954 void MENU_TrackKbdMenuBar( HWND hwnd
, UINT wParam
, INT vkey
)
2956 UINT uItem
= NO_SELECTED_ITEM
;
2958 UINT wFlags
= TPM_ENTERIDLEEX
| TPM_LEFTALIGN
| TPM_LEFTBUTTON
;
2960 /* find window that has a menu */
2962 while (GetWindowLongA( hwnd
, GWL_STYLE
) & WS_CHILD
)
2963 if (!(hwnd
= GetParent( hwnd
))) return;
2965 /* check if we have to track a system menu */
2967 hTrackMenu
= GetMenu( hwnd
);
2968 if (!hTrackMenu
|| IsIconic(hwnd
) || vkey
== VK_SPACE
)
2970 if (!(GetWindowLongA( hwnd
, GWL_STYLE
) & WS_SYSMENU
)) return;
2971 hTrackMenu
= get_win_sys_menu( hwnd
);
2973 wParam
|= HTSYSMENU
; /* prevent item lookup */
2976 if (!IsMenu( hTrackMenu
)) return;
2978 MENU_InitTracking( hwnd
, hTrackMenu
, FALSE
, wFlags
);
2980 if( vkey
&& vkey
!= VK_SPACE
)
2982 uItem
= MENU_FindItemByKey( hwnd
, hTrackMenu
, vkey
, (wParam
& HTSYSMENU
) );
2983 if( uItem
>= (UINT
)(-2) )
2985 if( uItem
== (UINT
)(-1) ) MessageBeep(0);
2992 MENU_SelectItem( hwnd
, hTrackMenu
, uItem
, TRUE
, 0 );
2994 if( uItem
== NO_SELECTED_ITEM
)
2995 MENU_MoveSelection( hwnd
, hTrackMenu
, ITEM_NEXT
);
2997 PostMessageA( hwnd
, WM_KEYDOWN
, VK_DOWN
, 0L );
2999 MENU_TrackMenu( hTrackMenu
, wFlags
, 0, 0, hwnd
, NULL
);
3001 MENU_ExitTracking( hwnd
);
3005 /**********************************************************************
3006 * TrackPopupMenu (USER.416)
3008 BOOL16 WINAPI
TrackPopupMenu16( HMENU16 hMenu
, UINT16 wFlags
, INT16 x
, INT16 y
,
3009 INT16 nReserved
, HWND16 hWnd
, const RECT16
*lpRect
)
3013 CONV_RECT16TO32( lpRect
, &r
);
3014 return TrackPopupMenu( hMenu
, wFlags
, x
, y
, nReserved
, hWnd
,
3015 lpRect
? &r
: NULL
);
3019 /**********************************************************************
3020 * TrackPopupMenu (USER32.@)
3022 * Like the win32 API, the function return the command ID only if the
3023 * flag TPM_RETURNCMD is on.
3026 BOOL WINAPI
TrackPopupMenu( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
3027 INT nReserved
, HWND hWnd
, const RECT
*lpRect
)
3031 MENU_InitTracking(hWnd
, hMenu
, TRUE
, wFlags
);
3033 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3034 if (!(wFlags
& TPM_NONOTIFY
))
3035 SendMessageA( hWnd
, WM_INITMENUPOPUP
, hMenu
, 0);
3037 if (MENU_ShowPopup( hWnd
, hMenu
, 0, x
, y
, 0, 0 ))
3038 ret
= MENU_TrackMenu( hMenu
, wFlags
| TPM_POPUPMENU
, 0, 0, hWnd
, lpRect
);
3039 MENU_ExitTracking(hWnd
);
3041 if( (!(wFlags
& TPM_RETURNCMD
)) && (ret
!= FALSE
) )
3047 /**********************************************************************
3048 * TrackPopupMenuEx (USER32.@)
3050 BOOL WINAPI
TrackPopupMenuEx( HMENU hMenu
, UINT wFlags
, INT x
, INT y
,
3051 HWND hWnd
, LPTPMPARAMS lpTpm
)
3053 FIXME("not fully implemented\n" );
3054 return TrackPopupMenu( hMenu
, wFlags
, x
, y
, 0, hWnd
,
3055 lpTpm
? &lpTpm
->rcExclude
: NULL
);
3058 /***********************************************************************
3061 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3063 static LRESULT WINAPI
PopupMenuWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
3065 TRACE("hwnd=0x%04x msg=0x%04x wp=0x%04x lp=0x%08lx\n",
3066 hwnd
, message
, wParam
, lParam
);
3072 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lParam
;
3073 SetWindowLongW( hwnd
, 0, (LONG
)cs
->lpCreateParams
);
3077 case WM_MOUSEACTIVATE
: /* We don't want to be activated */
3078 return MA_NOACTIVATE
;
3083 BeginPaint( hwnd
, &ps
);
3084 MENU_DrawPopupMenu( hwnd
, ps
.hdc
,
3085 (HMENU
)GetWindowLongA( hwnd
, 0 ) );
3086 EndPaint( hwnd
, &ps
);
3093 /* zero out global pointer in case resident popup window was destroyed. */
3094 if (hwnd
== top_popup
) top_popup
= 0;
3101 if (!GetWindowLongW( hwnd
, 0 )) ERR("no menu to display\n");
3104 SetWindowLongW( hwnd
, 0, 0 );
3107 case MM_SETMENUHANDLE
:
3108 SetWindowLongW( hwnd
, 0, wParam
);
3111 case MM_GETMENUHANDLE
:
3112 return GetWindowLongW( hwnd
, 0 );
3115 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
3121 /***********************************************************************
3122 * MENU_GetMenuBarHeight
3124 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3126 UINT
MENU_GetMenuBarHeight( HWND hwnd
, UINT menubarWidth
,
3127 INT orgX
, INT orgY
)
3133 TRACE("HWND 0x%x, width %d, at (%d, %d).\n",
3134 hwnd
, menubarWidth
, orgX
, orgY
);
3136 if (!(lppop
= MENU_GetMenu( GetMenu(hwnd
) ))) return 0;
3138 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| DCX_WINDOW
);
3139 SelectObject( hdc
, hMenuFont
);
3140 SetRect(&rectBar
, orgX
, orgY
, orgX
+menubarWidth
, orgY
+GetSystemMetrics(SM_CYMENU
));
3141 MENU_MenuBarCalcSize( hdc
, &rectBar
, lppop
, hwnd
);
3142 ReleaseDC( hwnd
, hdc
);
3143 return lppop
->Height
;
3147 /*******************************************************************
3148 * ChangeMenu (USER.153)
3150 BOOL16 WINAPI
ChangeMenu16( HMENU16 hMenu
, UINT16 pos
, SEGPTR data
,
3151 UINT16 id
, UINT16 flags
)
3153 TRACE("menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
3154 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3155 if (flags
& MF_APPEND
) return AppendMenu16( hMenu
, flags
& ~MF_APPEND
,
3158 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
3159 /* for MF_DELETE. We should check the parameters for all others */
3160 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
3162 if (flags
& MF_DELETE
) return DeleteMenu16(hMenu
, pos
, flags
& ~MF_DELETE
);
3163 if (flags
& MF_CHANGE
) return ModifyMenu16(hMenu
, pos
, flags
& ~MF_CHANGE
,
3165 if (flags
& MF_REMOVE
) return RemoveMenu16(hMenu
,
3166 flags
& MF_BYPOSITION
? pos
: id
,
3167 flags
& ~MF_REMOVE
);
3168 /* Default: MF_INSERT */
3169 return InsertMenu16( hMenu
, pos
, flags
, id
, data
);
3173 /*******************************************************************
3174 * ChangeMenuA (USER32.@)
3176 BOOL WINAPI
ChangeMenuA( HMENU hMenu
, UINT pos
, LPCSTR data
,
3177 UINT id
, UINT flags
)
3179 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3180 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3181 if (flags
& MF_APPEND
) return AppendMenuA( hMenu
, flags
& ~MF_APPEND
,
3183 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3184 if (flags
& MF_CHANGE
) return ModifyMenuA(hMenu
, pos
, flags
& ~MF_CHANGE
,
3186 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3187 flags
& MF_BYPOSITION
? pos
: id
,
3188 flags
& ~MF_REMOVE
);
3189 /* Default: MF_INSERT */
3190 return InsertMenuA( hMenu
, pos
, flags
, id
, data
);
3194 /*******************************************************************
3195 * ChangeMenuW (USER32.@)
3197 BOOL WINAPI
ChangeMenuW( HMENU hMenu
, UINT pos
, LPCWSTR data
,
3198 UINT id
, UINT flags
)
3200 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3201 hMenu
, pos
, (DWORD
)data
, id
, flags
);
3202 if (flags
& MF_APPEND
) return AppendMenuW( hMenu
, flags
& ~MF_APPEND
,
3204 if (flags
& MF_DELETE
) return DeleteMenu(hMenu
, pos
, flags
& ~MF_DELETE
);
3205 if (flags
& MF_CHANGE
) return ModifyMenuW(hMenu
, pos
, flags
& ~MF_CHANGE
,
3207 if (flags
& MF_REMOVE
) return RemoveMenu( hMenu
,
3208 flags
& MF_BYPOSITION
? pos
: id
,
3209 flags
& ~MF_REMOVE
);
3210 /* Default: MF_INSERT */
3211 return InsertMenuW( hMenu
, pos
, flags
, id
, data
);
3215 /*******************************************************************
3216 * CheckMenuItem (USER.154)
3218 BOOL16 WINAPI
CheckMenuItem16( HMENU16 hMenu
, UINT16 id
, UINT16 flags
)
3220 return (BOOL16
)CheckMenuItem( hMenu
, id
, flags
);
3224 /*******************************************************************
3225 * CheckMenuItem (USER32.@)
3227 DWORD WINAPI
CheckMenuItem( HMENU hMenu
, UINT id
, UINT flags
)
3232 TRACE("menu=%04x id=%04x flags=%04x\n", hMenu
, id
, flags
);
3233 if (!(item
= MENU_FindItem( &hMenu
, &id
, flags
))) return -1;
3234 ret
= item
->fState
& MF_CHECKED
;
3235 if (flags
& MF_CHECKED
) item
->fState
|= MF_CHECKED
;
3236 else item
->fState
&= ~MF_CHECKED
;
3241 /**********************************************************************
3242 * EnableMenuItem (USER.155)
3244 UINT16 WINAPI
EnableMenuItem16( HMENU16 hMenu
, UINT16 wItemID
, UINT16 wFlags
)
3246 return EnableMenuItem( hMenu
, wItemID
, wFlags
);
3250 /**********************************************************************
3251 * EnableMenuItem (USER32.@)
3253 UINT WINAPI
EnableMenuItem( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3259 TRACE("(%04x, %04X, %04X) !\n",
3260 hMenu
, wItemID
, wFlags
);
3262 /* Get the Popupmenu to access the owner menu */
3263 if (!(menu
= MENU_GetMenu(hMenu
)))
3266 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
)))
3269 oldflags
= item
->fState
& (MF_GRAYED
| MF_DISABLED
);
3270 item
->fState
^= (oldflags
^ wFlags
) & (MF_GRAYED
| MF_DISABLED
);
3272 /* In win95 if the close item in the system menu change update the close button */
3273 if (TWEAK_WineLook
== WIN95_LOOK
)
3274 if((item
->wID
== SC_CLOSE
) && (oldflags
!= wFlags
))
3276 if (menu
->hSysMenuOwner
!= 0)
3278 POPUPMENU
* parentMenu
;
3280 /* Get the parent menu to access*/
3281 if (!(parentMenu
= MENU_GetMenu(menu
->hSysMenuOwner
)))
3284 /* Refresh the frame to reflect the change*/
3285 SetWindowPos(parentMenu
->hWnd
, 0, 0, 0, 0, 0,
3286 SWP_NOACTIVATE
| SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
);
3294 /*******************************************************************
3295 * GetMenuString (USER.161)
3297 INT16 WINAPI
GetMenuString16( HMENU16 hMenu
, UINT16 wItemID
,
3298 LPSTR str
, INT16 nMaxSiz
, UINT16 wFlags
)
3300 return GetMenuStringA( hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3304 /*******************************************************************
3305 * GetMenuStringA (USER32.@)
3307 INT WINAPI
GetMenuStringA(
3308 HMENU hMenu
, /* [in] menuhandle */
3309 UINT wItemID
, /* [in] menu item (dep. on wFlags) */
3310 LPSTR str
, /* [out] outbuffer. If NULL, func returns entry length*/
3311 INT nMaxSiz
, /* [in] length of buffer. if 0, func returns entry len*/
3312 UINT wFlags
/* [in] MF_ flags */
3316 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3317 hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3318 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3319 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3320 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3322 if (!WideCharToMultiByte( CP_ACP
, 0, item
->text
, -1, str
, nMaxSiz
, NULL
, NULL
))
3324 TRACE("returning '%s'\n", str
);
3329 /*******************************************************************
3330 * GetMenuStringW (USER32.@)
3332 INT WINAPI
GetMenuStringW( HMENU hMenu
, UINT wItemID
,
3333 LPWSTR str
, INT nMaxSiz
, UINT wFlags
)
3337 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3338 hMenu
, wItemID
, str
, nMaxSiz
, wFlags
);
3339 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return 0;
3340 if (!IS_STRING_ITEM(item
->fType
)) return 0;
3341 if (!str
|| !nMaxSiz
) return strlenW(item
->text
);
3343 lstrcpynW( str
, item
->text
, nMaxSiz
);
3344 return strlenW(str
);
3348 /**********************************************************************
3349 * HiliteMenuItem (USER.162)
3351 BOOL16 WINAPI
HiliteMenuItem16( HWND16 hWnd
, HMENU16 hMenu
, UINT16 wItemID
,
3354 return HiliteMenuItem( hWnd
, hMenu
, wItemID
, wHilite
);
3358 /**********************************************************************
3359 * HiliteMenuItem (USER32.@)
3361 BOOL WINAPI
HiliteMenuItem( HWND hWnd
, HMENU hMenu
, UINT wItemID
,
3365 TRACE("(%04x, %04x, %04x, %04x);\n",
3366 hWnd
, hMenu
, wItemID
, wHilite
);
3367 if (!MENU_FindItem( &hMenu
, &wItemID
, wHilite
)) return FALSE
;
3368 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3369 if (menu
->FocusedItem
== wItemID
) return TRUE
;
3370 MENU_HideSubPopups( hWnd
, hMenu
, FALSE
);
3371 MENU_SelectItem( hWnd
, hMenu
, wItemID
, TRUE
, 0 );
3376 /**********************************************************************
3377 * GetMenuState (USER.250)
3379 UINT16 WINAPI
GetMenuState16( HMENU16 hMenu
, UINT16 wItemID
, UINT16 wFlags
)
3381 return GetMenuState( hMenu
, wItemID
, wFlags
);
3385 /**********************************************************************
3386 * GetMenuState (USER32.@)
3388 UINT WINAPI
GetMenuState( HMENU hMenu
, UINT wItemID
, UINT wFlags
)
3391 TRACE("(menu=%04x, id=%04x, flags=%04x);\n",
3392 hMenu
, wItemID
, wFlags
);
3393 if (!(item
= MENU_FindItem( &hMenu
, &wItemID
, wFlags
))) return -1;
3394 debug_print_menuitem (" item: ", item
, "");
3395 if (item
->fType
& MF_POPUP
)
3397 POPUPMENU
*menu
= MENU_GetMenu( item
->hSubMenu
);
3398 if (!menu
) return -1;
3399 else return (menu
->nItems
<< 8) | ((item
->fState
|item
->fType
) & 0xff);
3403 /* We used to (from way back then) mask the result to 0xff. */
3404 /* I don't know why and it seems wrong as the documented */
3405 /* return flag MF_SEPARATOR is outside that mask. */
3406 return (item
->fType
| item
->fState
);
3411 /**********************************************************************
3412 * GetMenuItemCount (USER.263)
3414 INT16 WINAPI
GetMenuItemCount16( HMENU16 hMenu
)
3416 LPPOPUPMENU menu
= MENU_GetMenu(hMenu
);
3417 if (!menu
) return -1;
3418 TRACE("(%04x) returning %d\n",
3419 hMenu
, menu
->nItems
);
3420 return menu
->nItems
;
3424 /**********************************************************************
3425 * GetMenuItemCount (USER32.@)
3427 INT WINAPI
GetMenuItemCount( HMENU hMenu
)
3429 LPPOPUPMENU menu
= MENU_GetMenu(hMenu
);
3430 if (!menu
) return -1;
3431 TRACE("(%04x) returning %d\n",
3432 hMenu
, menu
->nItems
);
3433 return menu
->nItems
;
3436 /**********************************************************************
3437 * GetMenuItemID (USER.264)
3439 UINT16 WINAPI
GetMenuItemID16( HMENU16 hMenu
, INT16 nPos
)
3441 return (UINT16
) GetMenuItemID (hMenu
, nPos
);
3444 /**********************************************************************
3445 * GetMenuItemID (USER32.@)
3447 UINT WINAPI
GetMenuItemID( HMENU hMenu
, INT nPos
)
3451 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return -1;
3452 if (lpmi
->fType
& MF_POPUP
) return -1;
3457 /*******************************************************************
3458 * InsertMenu (USER.410)
3460 BOOL16 WINAPI
InsertMenu16( HMENU16 hMenu
, UINT16 pos
, UINT16 flags
,
3461 UINT16 id
, SEGPTR data
)
3463 UINT pos32
= (UINT
)pos
;
3464 if ((pos
== (UINT16
)-1) && (flags
& MF_BYPOSITION
)) pos32
= (UINT
)-1;
3465 if (IS_STRING_ITEM(flags
) && data
)
3466 return InsertMenuA( hMenu
, pos32
, flags
, id
, MapSL(data
) );
3467 return InsertMenuA( hMenu
, pos32
, flags
, id
, (LPSTR
)data
);
3471 /*******************************************************************
3472 * InsertMenuW (USER32.@)
3474 BOOL WINAPI
InsertMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3475 UINT id
, LPCWSTR str
)
3479 if (IS_STRING_ITEM(flags
) && str
)
3480 TRACE("hMenu %04x, pos %d, flags %08x, "
3481 "id %04x, str %s\n",
3482 hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3483 else TRACE("hMenu %04x, pos %d, flags %08x, "
3484 "id %04x, str %08lx (not a string)\n",
3485 hMenu
, pos
, flags
, id
, (DWORD
)str
);
3487 if (!(item
= MENU_InsertItem( hMenu
, pos
, flags
))) return FALSE
;
3489 if (!(MENU_SetItemData( item
, flags
, id
, str
)))
3491 RemoveMenu( hMenu
, pos
, flags
);
3495 if (flags
& MF_POPUP
) /* Set the MF_POPUP flag on the popup-menu */
3496 (MENU_GetMenu((HMENU16
)id
))->wFlags
|= MF_POPUP
;
3498 item
->hCheckBit
= item
->hUnCheckBit
= 0;
3503 /*******************************************************************
3504 * InsertMenuA (USER32.@)
3506 BOOL WINAPI
InsertMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3507 UINT id
, LPCSTR str
)
3511 if (IS_STRING_ITEM(flags
) && str
)
3513 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3514 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3517 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3518 ret
= InsertMenuW( hMenu
, pos
, flags
, id
, newstr
);
3519 HeapFree( GetProcessHeap(), 0, newstr
);
3523 else return InsertMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3527 /*******************************************************************
3528 * AppendMenu (USER.411)
3530 BOOL16 WINAPI
AppendMenu16(HMENU16 hMenu
, UINT16 flags
, UINT16 id
, SEGPTR data
)
3532 return InsertMenu16( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3536 /*******************************************************************
3537 * AppendMenuA (USER32.@)
3539 BOOL WINAPI
AppendMenuA( HMENU hMenu
, UINT flags
,
3540 UINT id
, LPCSTR data
)
3542 return InsertMenuA( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3546 /*******************************************************************
3547 * AppendMenuW (USER32.@)
3549 BOOL WINAPI
AppendMenuW( HMENU hMenu
, UINT flags
,
3550 UINT id
, LPCWSTR data
)
3552 return InsertMenuW( hMenu
, -1, flags
| MF_BYPOSITION
, id
, data
);
3556 /**********************************************************************
3557 * RemoveMenu (USER.412)
3559 BOOL16 WINAPI
RemoveMenu16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
)
3561 return RemoveMenu( hMenu
, nPos
, wFlags
);
3565 /**********************************************************************
3566 * RemoveMenu (USER32.@)
3568 BOOL WINAPI
RemoveMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3573 TRACE("(menu=%04x pos=%04x flags=%04x)\n",hMenu
, nPos
, wFlags
);
3574 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3575 if (!(menu
= MENU_GetMenu(hMenu
))) return FALSE
;
3579 MENU_FreeItemData( item
);
3581 if (--menu
->nItems
== 0)
3583 HeapFree( GetProcessHeap(), 0, menu
->items
);
3588 while(nPos
< menu
->nItems
)
3594 menu
->items
= HeapReAlloc( GetProcessHeap(), 0, menu
->items
,
3595 menu
->nItems
* sizeof(MENUITEM
) );
3601 /**********************************************************************
3602 * DeleteMenu (USER.413)
3604 BOOL16 WINAPI
DeleteMenu16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
)
3606 return DeleteMenu( hMenu
, nPos
, wFlags
);
3610 /**********************************************************************
3611 * DeleteMenu (USER32.@)
3613 BOOL WINAPI
DeleteMenu( HMENU hMenu
, UINT nPos
, UINT wFlags
)
3615 MENUITEM
*item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
);
3616 if (!item
) return FALSE
;
3617 if (item
->fType
& MF_POPUP
) DestroyMenu( item
->hSubMenu
);
3618 /* nPos is now the position of the item */
3619 RemoveMenu( hMenu
, nPos
, wFlags
| MF_BYPOSITION
);
3624 /*******************************************************************
3625 * ModifyMenu (USER.414)
3627 BOOL16 WINAPI
ModifyMenu16( HMENU16 hMenu
, UINT16 pos
, UINT16 flags
,
3628 UINT16 id
, SEGPTR data
)
3630 if (IS_STRING_ITEM(flags
))
3631 return ModifyMenuA( hMenu
, pos
, flags
, id
, MapSL(data
) );
3632 return ModifyMenuA( hMenu
, pos
, flags
, id
, (LPSTR
)data
);
3636 /*******************************************************************
3637 * ModifyMenuW (USER32.@)
3639 BOOL WINAPI
ModifyMenuW( HMENU hMenu
, UINT pos
, UINT flags
,
3640 UINT id
, LPCWSTR str
)
3644 if (IS_STRING_ITEM(flags
))
3646 TRACE("%04x %d %04x %04x %s\n",
3647 hMenu
, pos
, flags
, id
, debugstr_w(str
) );
3648 if (!str
) return FALSE
;
3652 TRACE("%04x %d %04x %04x %08lx\n",
3653 hMenu
, pos
, flags
, id
, (DWORD
)str
);
3656 if (!(item
= MENU_FindItem( &hMenu
, &pos
, flags
))) return FALSE
;
3657 return MENU_SetItemData( item
, flags
, id
, str
);
3661 /*******************************************************************
3662 * ModifyMenuA (USER32.@)
3664 BOOL WINAPI
ModifyMenuA( HMENU hMenu
, UINT pos
, UINT flags
,
3665 UINT id
, LPCSTR str
)
3669 if (IS_STRING_ITEM(flags
) && str
)
3671 INT len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
3672 LPWSTR newstr
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
3675 MultiByteToWideChar( CP_ACP
, 0, str
, -1, newstr
, len
);
3676 ret
= ModifyMenuW( hMenu
, pos
, flags
, id
, newstr
);
3677 HeapFree( GetProcessHeap(), 0, newstr
);
3681 else return ModifyMenuW( hMenu
, pos
, flags
, id
, (LPCWSTR
)str
);
3685 /**********************************************************************
3686 * CreatePopupMenu (USER.415)
3688 HMENU16 WINAPI
CreatePopupMenu16(void)
3690 return CreatePopupMenu();
3694 /**********************************************************************
3695 * CreatePopupMenu (USER32.@)
3697 HMENU WINAPI
CreatePopupMenu(void)
3702 if (!(hmenu
= CreateMenu())) return 0;
3703 menu
= MENU_GetMenu( hmenu
);
3704 menu
->wFlags
|= MF_POPUP
;
3705 menu
->bTimeToHide
= FALSE
;
3710 /**********************************************************************
3711 * GetMenuCheckMarkDimensions (USER.417)
3712 * GetMenuCheckMarkDimensions (USER32.@)
3714 DWORD WINAPI
GetMenuCheckMarkDimensions(void)
3716 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK
), GetSystemMetrics(SM_CYMENUCHECK
) );
3720 /**********************************************************************
3721 * SetMenuItemBitmaps (USER.418)
3723 BOOL16 WINAPI
SetMenuItemBitmaps16( HMENU16 hMenu
, UINT16 nPos
, UINT16 wFlags
,
3724 HBITMAP16 hNewUnCheck
, HBITMAP16 hNewCheck
)
3726 return SetMenuItemBitmaps( hMenu
, nPos
, wFlags
, hNewUnCheck
, hNewCheck
);
3730 /**********************************************************************
3731 * SetMenuItemBitmaps (USER32.@)
3733 BOOL WINAPI
SetMenuItemBitmaps( HMENU hMenu
, UINT nPos
, UINT wFlags
,
3734 HBITMAP hNewUnCheck
, HBITMAP hNewCheck
)
3737 TRACE("(%04x, %04x, %04x, %04x, %04x)\n",
3738 hMenu
, nPos
, wFlags
, hNewCheck
, hNewUnCheck
);
3739 if (!(item
= MENU_FindItem( &hMenu
, &nPos
, wFlags
))) return FALSE
;
3741 if (!hNewCheck
&& !hNewUnCheck
)
3743 item
->fState
&= ~MF_USECHECKBITMAPS
;
3745 else /* Install new bitmaps */
3747 item
->hCheckBit
= hNewCheck
;
3748 item
->hUnCheckBit
= hNewUnCheck
;
3749 item
->fState
|= MF_USECHECKBITMAPS
;
3755 /**********************************************************************
3756 * CreateMenu (USER.151)
3758 HMENU16 WINAPI
CreateMenu16(void)
3760 return CreateMenu();
3764 /**********************************************************************
3765 * CreateMenu (USER32.@)
3767 HMENU WINAPI
CreateMenu(void)
3771 if (!(hMenu
= USER_HEAP_ALLOC( sizeof(POPUPMENU
) ))) return 0;
3772 menu
= (LPPOPUPMENU
) USER_HEAP_LIN_ADDR(hMenu
);
3774 ZeroMemory(menu
, sizeof(POPUPMENU
));
3775 menu
->wMagic
= MENU_MAGIC
;
3776 menu
->FocusedItem
= NO_SELECTED_ITEM
;
3777 menu
->bTimeToHide
= FALSE
;
3779 TRACE("return %04x\n", hMenu
);
3785 /**********************************************************************
3786 * DestroyMenu (USER.152)
3788 BOOL16 WINAPI
DestroyMenu16( HMENU16 hMenu
)
3790 return DestroyMenu( hMenu
);
3794 /**********************************************************************
3795 * DestroyMenu (USER32.@)
3797 BOOL WINAPI
DestroyMenu( HMENU hMenu
)
3799 TRACE("(%04x)\n", hMenu
);
3801 /* Silently ignore attempts to destroy default system popup */
3803 if (hMenu
&& hMenu
!= MENU_DefSysPopup
)
3805 LPPOPUPMENU lppop
= MENU_GetMenu(hMenu
);
3807 if (!lppop
) return FALSE
;
3809 lppop
->wMagic
= 0; /* Mark it as destroyed */
3811 if ((lppop
->wFlags
& MF_POPUP
) && lppop
->hWnd
)
3813 DestroyWindow( lppop
->hWnd
);
3817 if (lppop
->items
) /* recursively destroy submenus */
3820 MENUITEM
*item
= lppop
->items
;
3821 for (i
= lppop
->nItems
; i
> 0; i
--, item
++)
3823 if (item
->fType
& MF_POPUP
) DestroyMenu(item
->hSubMenu
);
3824 MENU_FreeItemData( item
);
3826 HeapFree( GetProcessHeap(), 0, lppop
->items
);
3828 USER_HEAP_FREE( hMenu
);
3830 return (hMenu
!= MENU_DefSysPopup
);
3834 /**********************************************************************
3835 * GetSystemMenu (USER.156)
3837 HMENU16 WINAPI
GetSystemMenu16( HWND16 hWnd
, BOOL16 bRevert
)
3839 return GetSystemMenu( hWnd
, bRevert
);
3843 /**********************************************************************
3844 * GetSystemMenu (USER32.@)
3846 HMENU WINAPI
GetSystemMenu( HWND hWnd
, BOOL bRevert
)
3848 WND
*wndPtr
= WIN_FindWndPtr( hWnd
);
3853 if( wndPtr
->hSysMenu
)
3857 DestroyMenu(wndPtr
->hSysMenu
);
3858 wndPtr
->hSysMenu
= 0;
3862 POPUPMENU
*menu
= MENU_GetMenu( wndPtr
->hSysMenu
);
3865 if( menu
->nItems
> 0 && menu
->items
[0].hSubMenu
== MENU_DefSysPopup
)
3866 menu
->items
[0].hSubMenu
= MENU_CopySysPopup();
3870 WARN("Current sys-menu (%04x) of wnd %04x is broken\n",
3871 wndPtr
->hSysMenu
, hWnd
);
3872 wndPtr
->hSysMenu
= 0;
3877 if(!wndPtr
->hSysMenu
&& (wndPtr
->dwStyle
& WS_SYSMENU
) )
3878 wndPtr
->hSysMenu
= MENU_GetSysMenu( hWnd
, (HMENU
)(-1) );
3880 if( wndPtr
->hSysMenu
)
3883 retvalue
= GetSubMenu(wndPtr
->hSysMenu
, 0);
3885 /* Store the dummy sysmenu handle to facilitate the refresh */
3886 /* of the close button if the SC_CLOSE item change */
3887 menu
= MENU_GetMenu(retvalue
);
3889 menu
->hSysMenuOwner
= wndPtr
->hSysMenu
;
3891 WIN_ReleaseWndPtr(wndPtr
);
3893 return bRevert
? 0 : retvalue
;
3897 /*******************************************************************
3898 * SetSystemMenu (USER.280)
3900 BOOL16 WINAPI
SetSystemMenu16( HWND16 hwnd
, HMENU16 hMenu
)
3902 return SetSystemMenu( hwnd
, hMenu
);
3906 /*******************************************************************
3907 * SetSystemMenu (USER32.@)
3909 BOOL WINAPI
SetSystemMenu( HWND hwnd
, HMENU hMenu
)
3911 WND
*wndPtr
= WIN_FindWndPtr(hwnd
);
3915 if (wndPtr
->hSysMenu
) DestroyMenu( wndPtr
->hSysMenu
);
3916 wndPtr
->hSysMenu
= MENU_GetSysMenu( hwnd
, hMenu
);
3917 WIN_ReleaseWndPtr(wndPtr
);
3924 /**********************************************************************
3925 * GetMenu (USER.157)
3927 HMENU16 WINAPI
GetMenu16( HWND16 hWnd
)
3929 return (HMENU16
)GetMenu(hWnd
);
3933 /**********************************************************************
3934 * GetMenu (USER32.@)
3936 HMENU WINAPI
GetMenu( HWND hWnd
)
3938 HMENU retvalue
= (HMENU
)GetWindowLongA( hWnd
, GWL_ID
);
3939 TRACE("for %04x returning %04x\n", hWnd
, retvalue
);
3944 /**********************************************************************
3945 * SetMenu (USER.158)
3947 BOOL16 WINAPI
SetMenu16( HWND16 hWnd
, HMENU16 hMenu
)
3949 return SetMenu( hWnd
, hMenu
);
3953 /**********************************************************************
3954 * SetMenu (USER32.@)
3956 BOOL WINAPI
SetMenu( HWND hWnd
, HMENU hMenu
)
3958 TRACE("(%04x, %04x);\n", hWnd
, hMenu
);
3960 if (hMenu
&& !IsMenu(hMenu
))
3962 WARN("hMenu %x is not a menu handle\n", hMenu
);
3965 if (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
3967 if (GetCapture() == hWnd
) ReleaseCapture();
3973 if (!(lpmenu
= MENU_GetMenu(hMenu
))) return FALSE
;
3975 lpmenu
->hWnd
= hWnd
;
3976 lpmenu
->Height
= 0; /* Make sure we recalculate the size */
3978 SetWindowLongA( hWnd
, GWL_ID
, hMenu
);
3980 if (IsWindowVisible(hWnd
))
3981 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
3982 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
3988 /**********************************************************************
3989 * GetSubMenu (USER.159)
3991 HMENU16 WINAPI
GetSubMenu16( HMENU16 hMenu
, INT16 nPos
)
3993 return GetSubMenu( hMenu
, nPos
);
3997 /**********************************************************************
3998 * GetSubMenu (USER32.@)
4000 HMENU WINAPI
GetSubMenu( HMENU hMenu
, INT nPos
)
4004 if (!(lpmi
= MENU_FindItem(&hMenu
,&nPos
,MF_BYPOSITION
))) return 0;
4005 if (!(lpmi
->fType
& MF_POPUP
)) return 0;
4006 return lpmi
->hSubMenu
;
4010 /**********************************************************************
4011 * DrawMenuBar (USER.160)
4013 void WINAPI
DrawMenuBar16( HWND16 hWnd
)
4015 DrawMenuBar( hWnd
);
4019 /**********************************************************************
4020 * DrawMenuBar (USER32.@)
4022 BOOL WINAPI
DrawMenuBar( HWND hWnd
)
4025 HMENU hMenu
= GetMenu(hWnd
);
4027 if (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) return FALSE
;
4028 if (!hMenu
|| !(lppop
= MENU_GetMenu( hMenu
))) return FALSE
;
4030 lppop
->Height
= 0; /* Make sure we call MENU_MenuBarCalcSize */
4031 lppop
->hwndOwner
= hWnd
;
4032 SetWindowPos( hWnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
4033 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
4037 /***********************************************************************
4038 * DrawMenuBarTemp (USER32.@)
4040 DWORD WINAPI
DrawMenuBarTemp(DWORD p1
, DWORD p2
)
4042 FIXME("(%08lx %08lx): stub\n", p1
, p2
);
4046 /***********************************************************************
4047 * EndMenu (USER.187)
4048 * EndMenu (USER32.@)
4050 void WINAPI
EndMenu(void)
4052 /* if we are in the menu code, and it is active */
4053 if (!fEndMenu
&& top_popup
)
4055 /* terminate the menu handling code */
4058 /* needs to be posted to wakeup the internal menu handler */
4059 /* which will now terminate the menu, in the event that */
4060 /* the main window was minimized, or lost focus, so we */
4061 /* don't end up with an orphaned menu */
4062 PostMessageA( top_popup
, WM_CANCELMODE
, 0, 0);
4067 /***********************************************************************
4068 * LookupMenuHandle (USER.217)
4070 HMENU16 WINAPI
LookupMenuHandle16( HMENU16 hmenu
, INT16 id
)
4072 HMENU hmenu32
= hmenu
;
4074 if (!MENU_FindItem( &hmenu32
, &id32
, MF_BYCOMMAND
)) return 0;
4075 else return hmenu32
;
4079 /**********************************************************************
4080 * LoadMenu (USER.150)
4082 HMENU16 WINAPI
LoadMenu16( HINSTANCE16 instance
, LPCSTR name
)
4088 TRACE("(%04x,%s)\n", instance
, debugres_a(name
) );
4092 if (name
[0] == '#') name
= (LPCSTR
)atoi( name
+ 1 );
4095 if (!name
) return 0;
4097 /* check for Win32 module */
4098 if (HIWORD(instance
)) return LoadMenuA( instance
, name
);
4099 instance
= GetExePtr( instance
);
4101 if (!(hRsrc
= FindResource16( instance
, name
, RT_MENUA
))) return 0;
4102 if (!(handle
= LoadResource16( instance
, hRsrc
))) return 0;
4103 hMenu
= LoadMenuIndirect16(LockResource16(handle
));
4104 FreeResource16( handle
);
4109 /*****************************************************************
4110 * LoadMenuA (USER32.@)
4112 HMENU WINAPI
LoadMenuA( HINSTANCE instance
, LPCSTR name
)
4114 HRSRC hrsrc
= FindResourceA( instance
, name
, RT_MENUA
);
4115 if (!hrsrc
) return 0;
4116 return LoadMenuIndirectA( (LPCVOID
)LoadResource( instance
, hrsrc
));
4120 /*****************************************************************
4121 * LoadMenuW (USER32.@)
4123 HMENU WINAPI
LoadMenuW( HINSTANCE instance
, LPCWSTR name
)
4125 HRSRC hrsrc
= FindResourceW( instance
, name
, RT_MENUW
);
4126 if (!hrsrc
) return 0;
4127 return LoadMenuIndirectW( (LPCVOID
)LoadResource( instance
, hrsrc
));
4131 /**********************************************************************
4132 * LoadMenuIndirect (USER.220)
4134 HMENU16 WINAPI
LoadMenuIndirect16( LPCVOID
template )
4137 WORD version
, offset
;
4138 LPCSTR p
= (LPCSTR
)template;
4140 TRACE("(%p)\n", template );
4141 version
= GET_WORD(p
);
4145 WARN("version must be 0 for Win16\n" );
4148 offset
= GET_WORD(p
);
4149 p
+= sizeof(WORD
) + offset
;
4150 if (!(hMenu
= CreateMenu())) return 0;
4151 if (!MENU_ParseResource( p
, hMenu
, FALSE
))
4153 DestroyMenu( hMenu
);
4160 /**********************************************************************
4161 * LoadMenuIndirectA (USER32.@)
4163 HMENU WINAPI
LoadMenuIndirectA( LPCVOID
template )
4166 WORD version
, offset
;
4167 LPCSTR p
= (LPCSTR
)template;
4169 TRACE("%p\n", template );
4170 version
= GET_WORD(p
);
4175 offset
= GET_WORD(p
);
4176 p
+= sizeof(WORD
) + offset
;
4177 if (!(hMenu
= CreateMenu())) return 0;
4178 if (!MENU_ParseResource( p
, hMenu
, TRUE
))
4180 DestroyMenu( hMenu
);
4185 offset
= GET_WORD(p
);
4186 p
+= sizeof(WORD
) + offset
;
4187 if (!(hMenu
= CreateMenu())) return 0;
4188 if (!MENUEX_ParseResource( p
, hMenu
))
4190 DestroyMenu( hMenu
);
4195 ERR("version %d not supported.\n", version
);
4201 /**********************************************************************
4202 * LoadMenuIndirectW (USER32.@)
4204 HMENU WINAPI
LoadMenuIndirectW( LPCVOID
template )
4206 /* FIXME: is there anything different between A and W? */
4207 return LoadMenuIndirectA( template );
4211 /**********************************************************************
4214 BOOL16 WINAPI
IsMenu16( HMENU16 hmenu
)
4216 return IsMenu( hmenu
);
4220 /**********************************************************************
4223 BOOL WINAPI
IsMenu(HMENU hmenu
)
4225 LPPOPUPMENU menu
= MENU_GetMenu(hmenu
);
4226 return menu
!= NULL
;
4229 /**********************************************************************
4230 * GetMenuItemInfo_common
4233 static BOOL
GetMenuItemInfo_common ( HMENU hmenu
, UINT item
, BOOL bypos
,
4234 LPMENUITEMINFOW lpmii
, BOOL unicode
)
4236 MENUITEM
*menu
= MENU_FindItem (&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0);
4238 debug_print_menuitem("GetMenuItemInfo_common: ", menu
, "");
4243 if (lpmii
->fMask
& MIIM_TYPE
) {
4244 lpmii
->fType
= menu
->fType
;
4245 switch (MENU_ITEM_TYPE(menu
->fType
)) {
4247 break; /* will be done below */
4250 lpmii
->dwTypeData
= menu
->text
;
4257 /* copy the text string */
4258 if ((lpmii
->fMask
& (MIIM_TYPE
|MIIM_STRING
)) &&
4259 (MENU_ITEM_TYPE(menu
->fType
) == MF_STRING
) && menu
->text
)
4264 len
= strlenW(menu
->text
);
4265 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4266 lstrcpynW(lpmii
->dwTypeData
, menu
->text
, lpmii
->cch
);
4270 len
= WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1, NULL
, 0, NULL
, NULL
);
4271 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4272 if (!WideCharToMultiByte( CP_ACP
, 0, menu
->text
, -1,
4273 (LPSTR
)lpmii
->dwTypeData
, lpmii
->cch
, NULL
, NULL
))
4274 ((LPSTR
)lpmii
->dwTypeData
)[lpmii
->cch
-1] = 0;
4276 /* if we've copied a substring we return its length */
4277 if(lpmii
->dwTypeData
&& lpmii
->cch
)
4279 if (lpmii
->cch
<= len
) lpmii
->cch
--;
4281 else /* return length of string */
4285 if (lpmii
->fMask
& MIIM_FTYPE
)
4286 lpmii
->fType
= menu
->fType
;
4288 if (lpmii
->fMask
& MIIM_BITMAP
)
4289 lpmii
->hbmpItem
= menu
->hbmpItem
;
4291 if (lpmii
->fMask
& MIIM_STATE
)
4292 lpmii
->fState
= menu
->fState
;
4294 if (lpmii
->fMask
& MIIM_ID
)
4295 lpmii
->wID
= menu
->wID
;
4297 if (lpmii
->fMask
& MIIM_SUBMENU
)
4298 lpmii
->hSubMenu
= menu
->hSubMenu
;
4300 if (lpmii
->fMask
& MIIM_CHECKMARKS
) {
4301 lpmii
->hbmpChecked
= menu
->hCheckBit
;
4302 lpmii
->hbmpUnchecked
= menu
->hUnCheckBit
;
4304 if (lpmii
->fMask
& MIIM_DATA
)
4305 lpmii
->dwItemData
= menu
->dwItemData
;
4310 /**********************************************************************
4311 * GetMenuItemInfoA (USER32.@)
4313 BOOL WINAPI
GetMenuItemInfoA( HMENU hmenu
, UINT item
, BOOL bypos
,
4314 LPMENUITEMINFOA lpmii
)
4316 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4317 (LPMENUITEMINFOW
)lpmii
, FALSE
);
4320 /**********************************************************************
4321 * GetMenuItemInfoW (USER32.@)
4323 BOOL WINAPI
GetMenuItemInfoW( HMENU hmenu
, UINT item
, BOOL bypos
,
4324 LPMENUITEMINFOW lpmii
)
4326 return GetMenuItemInfo_common (hmenu
, item
, bypos
,
4331 /* set a menu item text from a ASCII or Unicode string */
4332 inline static void set_menu_item_text( MENUITEM
*menu
, LPCWSTR text
, BOOL unicode
)
4337 menu
->fType
|= MF_SEPARATOR
;
4341 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, (strlenW(text
)+1) * sizeof(WCHAR
) )))
4342 strcpyW( menu
->text
, text
);
4346 LPCSTR str
= (LPCSTR
)text
;
4347 int len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
4348 if ((menu
->text
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
4349 MultiByteToWideChar( CP_ACP
, 0, str
, -1, menu
->text
, len
);
4354 /**********************************************************************
4355 * SetMenuItemInfo_common
4358 static BOOL
SetMenuItemInfo_common(MENUITEM
* menu
,
4359 const MENUITEMINFOW
*lpmii
,
4362 if (!menu
) return FALSE
;
4364 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu
, "");
4366 if (lpmii
->fMask
& MIIM_TYPE
) {
4367 /* Get rid of old string. */
4368 if ( IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4369 HeapFree(GetProcessHeap(), 0, menu
->text
);
4373 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4374 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4375 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4377 menu
->text
= lpmii
->dwTypeData
;
4379 if (IS_STRING_ITEM(menu
->fType
))
4380 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4383 if (lpmii
->fMask
& MIIM_FTYPE
) {
4384 /* free the string when the type is changing */
4385 if ( (!IS_STRING_ITEM(lpmii
->fType
)) && IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4386 HeapFree(GetProcessHeap(), 0, menu
->text
);
4389 menu
->fType
&= ~MENU_ITEM_TYPE(menu
->fType
);
4390 menu
->fType
|= MENU_ITEM_TYPE(lpmii
->fType
);
4391 if ( IS_STRING_ITEM(menu
->fType
) && !menu
->text
)
4392 menu
->fType
|= MF_SEPARATOR
;
4395 if (lpmii
->fMask
& MIIM_STRING
) {
4396 /* free the string when used */
4397 if ( IS_STRING_ITEM(menu
->fType
) && menu
->text
) {
4398 HeapFree(GetProcessHeap(), 0, menu
->text
);
4399 set_menu_item_text( menu
, lpmii
->dwTypeData
, unicode
);
4403 if (lpmii
->fMask
& MIIM_STATE
)
4405 /* fixme: MFS_DEFAULT do we have to reset the other menu items? */
4406 menu
->fState
= lpmii
->fState
;
4409 if (lpmii
->fMask
& MIIM_ID
)
4410 menu
->wID
= lpmii
->wID
;
4412 if (lpmii
->fMask
& MIIM_SUBMENU
) {
4413 menu
->hSubMenu
= lpmii
->hSubMenu
;
4414 if (menu
->hSubMenu
) {
4415 POPUPMENU
*subMenu
= MENU_GetMenu((UINT16
)menu
->hSubMenu
);
4417 subMenu
->wFlags
|= MF_POPUP
;
4418 menu
->fType
|= MF_POPUP
;
4421 /* FIXME: Return an error ? */
4422 menu
->fType
&= ~MF_POPUP
;
4425 menu
->fType
&= ~MF_POPUP
;
4428 if (lpmii
->fMask
& MIIM_CHECKMARKS
)
4430 if (lpmii
->fType
& MFT_RADIOCHECK
)
4431 menu
->fType
|= MFT_RADIOCHECK
;
4433 menu
->hCheckBit
= lpmii
->hbmpChecked
;
4434 menu
->hUnCheckBit
= lpmii
->hbmpUnchecked
;
4436 if (lpmii
->fMask
& MIIM_DATA
)
4437 menu
->dwItemData
= lpmii
->dwItemData
;
4439 debug_print_menuitem("SetMenuItemInfo_common to : ", menu
, "");
4443 /**********************************************************************
4444 * SetMenuItemInfoA (USER32.@)
4446 BOOL WINAPI
SetMenuItemInfoA(HMENU hmenu
, UINT item
, BOOL bypos
,
4447 const MENUITEMINFOA
*lpmii
)
4449 if ((lpmii
->fType
& (MF_HILITE
|MF_POPUP
)) || (lpmii
->fState
)) {
4450 /* QuickTime does pass invalid data into SetMenuItemInfo.
4451 * do some of the checks Windows does.
4453 WARN("Bad masks for type (0x%08x) or state (0x%08x)\n",
4454 lpmii
->fType
,lpmii
->fState
);
4458 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4459 (const MENUITEMINFOW
*)lpmii
, FALSE
);
4462 /**********************************************************************
4463 * SetMenuItemInfoW (USER32.@)
4465 BOOL WINAPI
SetMenuItemInfoW(HMENU hmenu
, UINT item
, BOOL bypos
,
4466 const MENUITEMINFOW
*lpmii
)
4468 return SetMenuItemInfo_common(MENU_FindItem(&hmenu
, &item
, bypos
? MF_BYPOSITION
: 0),
4472 /**********************************************************************
4473 * SetMenuDefaultItem (USER32.@)
4476 BOOL WINAPI
SetMenuDefaultItem(HMENU hmenu
, UINT uItem
, UINT bypos
)
4482 TRACE("(0x%x,%d,%d)\n", hmenu
, uItem
, bypos
);
4484 if (!(menu
= MENU_GetMenu(hmenu
))) return FALSE
;
4486 /* reset all default-item flags */
4488 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4490 item
->fState
&= ~MFS_DEFAULT
;
4493 /* no default item */
4502 if ( uItem
>= menu
->nItems
) return FALSE
;
4503 item
[uItem
].fState
|= MFS_DEFAULT
;
4508 for (i
= 0; i
< menu
->nItems
; i
++, item
++)
4510 if (item
->wID
== uItem
)
4512 item
->fState
|= MFS_DEFAULT
;
4521 /**********************************************************************
4522 * GetMenuDefaultItem (USER32.@)
4524 UINT WINAPI
GetMenuDefaultItem(HMENU hmenu
, UINT bypos
, UINT flags
)
4530 TRACE("(0x%x,%d,%d)\n", hmenu
, bypos
, flags
);
4532 if (!(menu
= MENU_GetMenu(hmenu
))) return -1;
4534 /* find default item */
4538 if (! item
) return -1;
4540 while ( !( item
->fState
& MFS_DEFAULT
) )
4543 if (i
>= menu
->nItems
) return -1;
4546 /* default: don't return disabled items */
4547 if ( (!(GMDI_USEDISABLED
& flags
)) && (item
->fState
& MFS_DISABLED
)) return -1;
4549 /* search rekursiv when needed */
4550 if ( (item
->fType
& MF_POPUP
) && (flags
& GMDI_GOINTOPOPUPS
) )
4553 ret
= GetMenuDefaultItem( item
->hSubMenu
, bypos
, flags
);
4554 if ( -1 != ret
) return ret
;
4556 /* when item not found in submenu, return the popup item */
4558 return ( bypos
) ? i
: item
->wID
;
4562 /*******************************************************************
4563 * InsertMenuItem (USER.441)
4567 BOOL16 WINAPI
InsertMenuItem16( HMENU16 hmenu
, UINT16 pos
, BOOL16 byposition
,
4568 const MENUITEMINFO16
*mii
)
4572 miia
.cbSize
= sizeof(miia
);
4573 miia
.fMask
= mii
->fMask
;
4574 miia
.dwTypeData
= (LPSTR
)mii
->dwTypeData
;
4575 miia
.fType
= mii
->fType
;
4576 miia
.fState
= mii
->fState
;
4577 miia
.wID
= mii
->wID
;
4578 miia
.hSubMenu
= mii
->hSubMenu
;
4579 miia
.hbmpChecked
= mii
->hbmpChecked
;
4580 miia
.hbmpUnchecked
= mii
->hbmpUnchecked
;
4581 miia
.dwItemData
= mii
->dwItemData
;
4582 miia
.cch
= mii
->cch
;
4583 if (IS_STRING_ITEM(miia
.fType
))
4584 miia
.dwTypeData
= MapSL(mii
->dwTypeData
);
4585 return InsertMenuItemA( hmenu
, pos
, byposition
, &miia
);
4589 /**********************************************************************
4590 * InsertMenuItemA (USER32.@)
4592 BOOL WINAPI
InsertMenuItemA(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4593 const MENUITEMINFOA
*lpmii
)
4595 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4596 return SetMenuItemInfo_common(item
, (const MENUITEMINFOW
*)lpmii
, FALSE
);
4600 /**********************************************************************
4601 * InsertMenuItemW (USER32.@)
4603 BOOL WINAPI
InsertMenuItemW(HMENU hMenu
, UINT uItem
, BOOL bypos
,
4604 const MENUITEMINFOW
*lpmii
)
4606 MENUITEM
*item
= MENU_InsertItem(hMenu
, uItem
, bypos
? MF_BYPOSITION
: 0 );
4607 return SetMenuItemInfo_common(item
, lpmii
, TRUE
);
4610 /**********************************************************************
4611 * CheckMenuRadioItem (USER32.@)
4614 BOOL WINAPI
CheckMenuRadioItem(HMENU hMenu
,
4615 UINT first
, UINT last
, UINT check
,
4618 MENUITEM
*mifirst
, *milast
, *micheck
;
4619 HMENU mfirst
= hMenu
, mlast
= hMenu
, mcheck
= hMenu
;
4621 TRACE("ox%x: %d-%d, check %d, bypos=%d\n",
4622 hMenu
, first
, last
, check
, bypos
);
4624 mifirst
= MENU_FindItem (&mfirst
, &first
, bypos
);
4625 milast
= MENU_FindItem (&mlast
, &last
, bypos
);
4626 micheck
= MENU_FindItem (&mcheck
, &check
, bypos
);
4628 if (mifirst
== NULL
|| milast
== NULL
|| micheck
== NULL
||
4629 mifirst
> milast
|| mfirst
!= mlast
|| mfirst
!= mcheck
||
4630 micheck
> milast
|| micheck
< mifirst
)
4633 while (mifirst
<= milast
)
4635 if (mifirst
== micheck
)
4637 mifirst
->fType
|= MFT_RADIOCHECK
;
4638 mifirst
->fState
|= MFS_CHECKED
;
4640 mifirst
->fType
&= ~MFT_RADIOCHECK
;
4641 mifirst
->fState
&= ~MFS_CHECKED
;
4649 /**********************************************************************
4650 * CheckMenuRadioItem (USER.666)
4652 BOOL16 WINAPI
CheckMenuRadioItem16(HMENU16 hMenu
,
4653 UINT16 first
, UINT16 last
, UINT16 check
,
4656 return CheckMenuRadioItem (hMenu
, first
, last
, check
, bypos
);
4659 /**********************************************************************
4660 * GetMenuItemRect (USER32.@)
4662 * ATTENTION: Here, the returned values in rect are the screen
4663 * coordinates of the item just like if the menu was
4664 * always on the upper left side of the application.
4667 BOOL WINAPI
GetMenuItemRect (HWND hwnd
, HMENU hMenu
, UINT uItem
,
4670 POPUPMENU
*itemMenu
;
4674 TRACE("(0x%x,0x%x,%d,%p)\n", hwnd
, hMenu
, uItem
, rect
);
4676 item
= MENU_FindItem (&hMenu
, &uItem
, MF_BYPOSITION
);
4677 referenceHwnd
= hwnd
;
4681 itemMenu
= MENU_GetMenu(hMenu
);
4682 if (itemMenu
== NULL
)
4685 if(itemMenu
->hWnd
== 0)
4687 referenceHwnd
= itemMenu
->hWnd
;
4690 if ((rect
== NULL
) || (item
== NULL
))
4695 MapWindowPoints(referenceHwnd
, 0, (LPPOINT
)rect
, 2);
4700 /**********************************************************************
4701 * GetMenuItemRect (USER.665)
4704 BOOL16 WINAPI
GetMenuItemRect16 (HWND16 hwnd
, HMENU16 hMenu
, UINT16 uItem
,
4710 if (!rect
) return FALSE
;
4711 res
= GetMenuItemRect (hwnd
, hMenu
, uItem
, &r32
);
4712 CONV_RECT32TO16 (&r32
, rect
);
4716 /**********************************************************************
4717 * SetMenuInfo (USER32.@)
4720 * MIM_APPLYTOSUBMENUS
4721 * actually use the items to draw the menu
4723 BOOL WINAPI
SetMenuInfo (HMENU hMenu
, LPCMENUINFO lpmi
)
4727 TRACE("(0x%04x %p)\n", hMenu
, lpmi
);
4729 if (lpmi
&& (lpmi
->cbSize
==sizeof(MENUINFO
)) && (menu
= MENU_GetMenu(hMenu
)))
4732 if (lpmi
->fMask
& MIM_BACKGROUND
)
4733 menu
->hbrBack
= lpmi
->hbrBack
;
4735 if (lpmi
->fMask
& MIM_HELPID
)
4736 menu
->dwContextHelpID
= lpmi
->dwContextHelpID
;
4738 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4739 menu
->cyMax
= lpmi
->cyMax
;
4741 if (lpmi
->fMask
& MIM_MENUDATA
)
4742 menu
->dwMenuData
= lpmi
->dwMenuData
;
4744 if (lpmi
->fMask
& MIM_STYLE
)
4745 menu
->dwStyle
= lpmi
->dwStyle
;
4752 /**********************************************************************
4753 * GetMenuInfo (USER32.@)
4759 BOOL WINAPI
GetMenuInfo (HMENU hMenu
, LPMENUINFO lpmi
)
4762 TRACE("(0x%04x %p)\n", hMenu
, lpmi
);
4764 if (lpmi
&& (menu
= MENU_GetMenu(hMenu
)))
4767 if (lpmi
->fMask
& MIM_BACKGROUND
)
4768 lpmi
->hbrBack
= menu
->hbrBack
;
4770 if (lpmi
->fMask
& MIM_HELPID
)
4771 lpmi
->dwContextHelpID
= menu
->dwContextHelpID
;
4773 if (lpmi
->fMask
& MIM_MAXHEIGHT
)
4774 lpmi
->cyMax
= menu
->cyMax
;
4776 if (lpmi
->fMask
& MIM_MENUDATA
)
4777 lpmi
->dwMenuData
= menu
->dwMenuData
;
4779 if (lpmi
->fMask
& MIM_STYLE
)
4780 lpmi
->dwStyle
= menu
->dwStyle
;
4787 /**********************************************************************
4788 * SetMenuContextHelpId (USER.384)
4790 BOOL16 WINAPI
SetMenuContextHelpId16( HMENU16 hMenu
, DWORD dwContextHelpID
)
4792 return SetMenuContextHelpId( hMenu
, dwContextHelpID
);
4796 /**********************************************************************
4797 * SetMenuContextHelpId (USER32.@)
4799 BOOL WINAPI
SetMenuContextHelpId( HMENU hMenu
, DWORD dwContextHelpID
)
4803 TRACE("(0x%04x 0x%08lx)\n", hMenu
, dwContextHelpID
);
4805 if ((menu
= MENU_GetMenu(hMenu
)))
4807 menu
->dwContextHelpID
= dwContextHelpID
;
4813 /**********************************************************************
4814 * GetMenuContextHelpId (USER.385)
4816 DWORD WINAPI
GetMenuContextHelpId16( HMENU16 hMenu
)
4818 return GetMenuContextHelpId( hMenu
);
4821 /**********************************************************************
4822 * GetMenuContextHelpId (USER32.@)
4824 DWORD WINAPI
GetMenuContextHelpId( HMENU hMenu
)
4828 TRACE("(0x%04x)\n", hMenu
);
4830 if ((menu
= MENU_GetMenu(hMenu
)))
4832 return menu
->dwContextHelpID
;
4837 /**********************************************************************
4838 * MenuItemFromPoint (USER32.@)
4840 UINT WINAPI
MenuItemFromPoint(HWND hWnd
, HMENU hMenu
, POINT ptScreen
)
4842 FIXME("(0x%04x,0x%04x,(%ld,%ld)):stub\n",
4843 hWnd
, hMenu
, ptScreen
.x
, ptScreen
.y
);
4848 /**********************************************************************
4849 * translate_accelerator
4851 static BOOL
translate_accelerator( HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
,
4852 BYTE fVirt
, WORD key
, WORD cmd
)
4856 if (wParam
!= key
) return FALSE
;
4858 if (message
== WM_CHAR
)
4860 if ( !(fVirt
& FALT
) && !(fVirt
& FVIRTKEY
) )
4862 TRACE_(accel
)("found accel for WM_CHAR: ('%c')\n", wParam
& 0xff);
4868 if(fVirt
& FVIRTKEY
)
4871 TRACE_(accel
)("found accel for virt_key %04x (scan %04x)\n",
4872 wParam
, 0xff & HIWORD(lParam
));
4873 if(GetKeyState(VK_SHIFT
) & 0x8000) mask
|= FSHIFT
;
4874 if(GetKeyState(VK_CONTROL
) & 0x8000) mask
|= FCONTROL
;
4875 if(GetKeyState(VK_MENU
) & 0x8000) mask
|= FALT
;
4876 if(mask
== (fVirt
& (FSHIFT
| FCONTROL
| FALT
))) goto found
;
4877 TRACE_(accel
)(", but incorrect SHIFT/CTRL/ALT-state\n");
4881 if (!(lParam
& 0x01000000)) /* no special_key */
4883 if ((fVirt
& FALT
) && (lParam
& 0x20000000))
4884 { /* ^^ ALT pressed */
4885 TRACE_(accel
)("found accel for Alt-%c\n", wParam
& 0xff);
4894 if (message
== WM_KEYUP
|| message
== WM_SYSKEYUP
)
4896 else if (GetCapture())
4898 else if (!IsWindowEnabled(hWnd
))
4902 HMENU hMenu
, hSubMenu
, hSysMenu
;
4903 UINT uSysStat
= (UINT
)-1, uStat
= (UINT
)-1, nPos
;
4905 hMenu
= (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_CHILD
) ? 0 : GetMenu(hWnd
);
4906 hSysMenu
= get_win_sys_menu( hWnd
);
4908 /* find menu item and ask application to initialize it */
4909 /* 1. in the system menu */
4910 hSubMenu
= hSysMenu
;
4912 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4914 SendMessageA(hWnd
, WM_INITMENU
, (WPARAM
)hSysMenu
, 0L);
4915 if(hSubMenu
!= hSysMenu
)
4917 nPos
= MENU_FindSubMenu(&hSysMenu
, hSubMenu
);
4918 TRACE_(accel
)("hSysMenu = %04x, hSubMenu = %04x, nPos = %d\n", hSysMenu
, hSubMenu
, nPos
);
4919 SendMessageA(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, TRUE
));
4921 uSysStat
= GetMenuState(GetSubMenu(hSysMenu
, 0), cmd
, MF_BYCOMMAND
);
4923 else /* 2. in the window's menu */
4927 if(MENU_FindItem(&hSubMenu
, &nPos
, MF_BYCOMMAND
))
4929 SendMessageA(hWnd
, WM_INITMENU
, (WPARAM
)hMenu
, 0L);
4930 if(hSubMenu
!= hMenu
)
4932 nPos
= MENU_FindSubMenu(&hMenu
, hSubMenu
);
4933 TRACE_(accel
)("hMenu = %04x, hSubMenu = %04x, nPos = %d\n", hMenu
, hSubMenu
, nPos
);
4934 SendMessageA(hWnd
, WM_INITMENUPOPUP
, (WPARAM
)hSubMenu
, MAKELPARAM(nPos
, FALSE
));
4936 uStat
= GetMenuState(hMenu
, cmd
, MF_BYCOMMAND
);
4940 if (uSysStat
!= (UINT
)-1)
4942 if (uSysStat
& (MF_DISABLED
|MF_GRAYED
))
4949 if (uStat
!= (UINT
)-1)
4955 if (uStat
& (MF_DISABLED
|MF_GRAYED
))
4966 if( mesg
==WM_COMMAND
)
4968 TRACE_(accel
)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd
);
4969 SendMessageA(hWnd
, mesg
, 0x10000 | cmd
, 0L);
4971 else if( mesg
==WM_SYSCOMMAND
)
4973 TRACE_(accel
)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd
);
4974 SendMessageA(hWnd
, mesg
, cmd
, 0x00010000L
);
4978 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4979 * #0: unknown (please report!)
4980 * #1: for WM_KEYUP,WM_SYSKEYUP
4981 * #2: mouse is captured
4982 * #3: window is disabled
4983 * #4: it's a disabled system menu option
4984 * #5: it's a menu option, but window is iconic
4985 * #6: it's a menu option, but disabled
4987 TRACE_(accel
)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg
);
4989 ERR_(accel
)(" unknown reason - please report!");
4994 /**********************************************************************
4995 * TranslateAccelerator (USER32.@)
4996 * TranslateAcceleratorA (USER32.@)
4997 * TranslateAcceleratorW (USER32.@)
4999 INT WINAPI
TranslateAccelerator( HWND hWnd
, HACCEL hAccel
, LPMSG msg
)
5002 LPACCEL16 lpAccelTbl
;
5007 WARN_(accel
)("msg null; should hang here to be win compatible\n");
5010 if (!hAccel
|| !(lpAccelTbl
= (LPACCEL16
) LockResource16(hAccel
)))
5012 WARN_(accel
)("invalid accel handle=%x\n", hAccel
);
5015 if ((msg
->message
!= WM_KEYDOWN
&&
5016 msg
->message
!= WM_KEYUP
&&
5017 msg
->message
!= WM_SYSKEYDOWN
&&
5018 msg
->message
!= WM_SYSKEYUP
&&
5019 msg
->message
!= WM_CHAR
)) return 0;
5021 TRACE_(accel
)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5022 "msg->hwnd=%04x, msg->message=%04x, wParam=%08x, lParam=%lx\n",
5023 hAccel
,hWnd
,msg
->hwnd
,msg
->message
,msg
->wParam
,msg
->lParam
);
5028 if (translate_accelerator( hWnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
5029 lpAccelTbl
[i
].fVirt
, lpAccelTbl
[i
].key
, lpAccelTbl
[i
].cmd
))
5031 } while ((lpAccelTbl
[i
++].fVirt
& 0x80) == 0);
5032 WARN_(accel
)("couldn't translate accelerator key\n");
5037 /**********************************************************************
5038 * TranslateAccelerator (USER.178)
5040 INT16 WINAPI
TranslateAccelerator16( HWND16 hWnd
, HACCEL16 hAccel
, LPMSG16 msg
)
5042 LPACCEL16 lpAccelTbl
;
5047 WARN_(accel
)("msg null; should hang here to be win compatible\n");
5050 if (!hAccel
|| !(lpAccelTbl
= (LPACCEL16
) LockResource16(hAccel
)))
5052 WARN_(accel
)("invalid accel handle=%x\n", hAccel
);
5055 if ((msg
->message
!= WM_KEYDOWN
&&
5056 msg
->message
!= WM_KEYUP
&&
5057 msg
->message
!= WM_SYSKEYDOWN
&&
5058 msg
->message
!= WM_SYSKEYUP
&&
5059 msg
->message
!= WM_CHAR
)) return 0;
5061 TRACE_(accel
)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5062 "msg->hwnd=%04x, msg->message=%04x, wParam=%04x, lParam=%lx\n",
5063 hAccel
,hWnd
,msg
->hwnd
,msg
->message
,msg
->wParam
,msg
->lParam
);
5068 if (translate_accelerator( hWnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
5069 lpAccelTbl
[i
].fVirt
, lpAccelTbl
[i
].key
, lpAccelTbl
[i
].cmd
))
5071 } while ((lpAccelTbl
[i
++].fVirt
& 0x80) == 0);
5072 WARN_(accel
)("couldn't translate accelerator key\n");