?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Simplify CheckMenuRadioItem().
[wine.git] / dlls / user32 / menu.c
blob8c541cc4f913201015933d91ca3872aad1751c56
1 /*
2 * Menu functions
3 *
4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994 Alexandre Julliard
6 * Copyright 1997 Morten Welinder
7 * Copyright 2005 Maxime Bellengé
8 * Copyright 2006 Phil Krylov
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 /*
26 * Note: the style MF_MOUSESELECT is used to mark popup items that
27 * have been selected, i.e. their popup menu is currently displayed.
28 * This is probably not the meaning this style has in MS-Windows.
29 *
30 * Note 2: where there is a difference, these menu API's are according
31 * the behavior of Windows 2k and Windows XP. Known differences with
32 * Windows 9x/ME are documented in the comments, in case an application
33 * is found to depend on the old behavior.
34 *
35 * TODO:
36 * implements styles :
37 * - MNS_AUTODISMISS
38 * - MNS_DRAGDROP
39 * - MNS_MODELESS
40 */
41
42 #include "config.h"
43 #include "wine/port.h"
44
45 #include <stdarg.h>
46 #include <string.h>
47
48 #define OEMRESOURCE
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "wingdi.h"
53 #include "winnls.h"
54 #include "wine/server.h"
55 #include "wine/unicode.h"
56 #include "wine/exception.h"
57 #include "win.h"
58 #include "controls.h"
59 #include "user_private.h"
60 #include "wine/debug.h"
61
62 WINE_DEFAULT_DEBUG_CHANNEL(menu);
63 WINE_DECLARE_DEBUG_CHANNEL(accel);
64
65 /* Menu item structure */
66 typedef struct {
67 /* ----------- MENUITEMINFO Stuff ----------- */
68 UINT fType; /* Item type. */
69 UINT fState; /* Item state. */
70 UINT_PTR wID; /* Item id. */
71 HMENU hSubMenu; /* Pop-up menu. */
72 HBITMAP hCheckBit; /* Bitmap when checked. */
73 HBITMAP hUnCheckBit; /* Bitmap when unchecked. */
74 LPWSTR text; /* Item text. */
75 ULONG_PTR dwItemData; /* Application defined. */
76 LPWSTR dwTypeData; /* depends on fMask */
77 HBITMAP hbmpItem; /* bitmap */
78 /* ----------- Wine stuff ----------- */
79 RECT rect; /* Item area (relative to the items_rect).
80 * See MENU_AdjustMenuItemRect(). */
81 UINT xTab; /* X position of text after Tab */
82 SIZE bmpsize; /* size needed for the HBMMENU_CALLBACK
83 * bitmap */
84 } MENUITEM;
85
86 /* Popup menu structure */
87 typedef struct {
88 struct user_object obj;
89 WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
90 WORD Width; /* Width of the whole menu */
91 WORD Height; /* Height of the whole menu */
92 UINT nItems; /* Number of items in the menu */
93 HWND hWnd; /* Window containing the menu */
94 MENUITEM *items; /* Array of menu items */
95 UINT FocusedItem; /* Currently focused item */
96 HWND hwndOwner; /* window receiving the messages for ownerdraw */
97 BOOL bScrolling; /* Scroll arrows are active */
98 UINT nScrollPos; /* Current scroll position */
99 UINT nTotalHeight; /* Total height of menu items inside menu */
100 RECT items_rect; /* Rectangle within which the items lie. Excludes margins and scroll arrows */
101 LONG refcount;
102 /* ------------ MENUINFO members ------ */
103 DWORD dwStyle; /* Extended menu style */
104 UINT cyMax; /* max height of the whole menu, 0 is screen height */
105 HBRUSH hbrBack; /* brush for menu background */
106 DWORD dwContextHelpID;
107 DWORD dwMenuData; /* application defined value */
108 HMENU hSysMenuOwner; /* Handle to the dummy sys menu holder */
109 WORD textOffset; /* Offset of text when items have both bitmaps and text */
110 } POPUPMENU, *LPPOPUPMENU;
111
112 /* internal flags for menu tracking */
113
114 #define TF_ENDMENU 0x10000
115 #define TF_SUSPENDPOPUP 0x20000
116 #define TF_SKIPREMOVE 0x40000
117 #define TF_RCVD_BTN_UP 0x80000
118
119 typedef struct
120 {
121 UINT trackFlags;
122 HMENU hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
123 HMENU hTopMenu; /* initial menu */
124 HWND hOwnerWnd; /* where notifications are sent */
125 POINT pt;
126 } MTRACKER;
127
128 #define ITEM_PREV -1
129 #define ITEM_NEXT 1
130
131 /* Internal MENU_TrackMenu() flags */
132 #define TPM_INTERNAL 0xF0000000
133 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
134 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
135
136 /* Space between 2 columns */
137 #define MENU_COL_SPACE 4
138
139 /* Margins for popup menus */
140 #define MENU_MARGIN 3
141
142 /* maximum allowed depth of any branch in the menu tree.
143 * This value is slightly larger than in windows (25) to
144 * stay on the safe side. */
145 #define MAXMENUDEPTH 30
146
147 /* (other menu->FocusedItem values give the position of the focused item) */
148 #define NO_SELECTED_ITEM 0xffff
149
150 #define MENU_ITEM_TYPE(flags) \
151 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
152
153 /* macro to test that flags do not indicate bitmap, ownerdraw or separator */
154 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
155 #define IS_MAGIC_BITMAP(id) ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))
156
157 #define IS_SYSTEM_MENU(menu) \
158 (!((menu)->wFlags & MF_POPUP) && ((menu)->wFlags & MF_SYSMENU))
159
160 #define MENUITEMINFO_TYPE_MASK \
161 (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
162 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
163 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY /* same as MF_HELP */ )
164 #define TYPE_MASK (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)
165 #define STATE_MASK (~TYPE_MASK)
166 #define MENUITEMINFO_STATE_MASK (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT))
167
168 static SIZE menucharsize;
169 static UINT ODitemheight; /* default owner drawn item height */
170
171 /* Use global popup window because there's no way 2 menus can
172 * be tracked at the same time. */
173 static HWND top_popup;
174 static HMENU top_popup_hmenu;
175
176 /* Flag set by EndMenu() to force an exit from menu tracking */
177 static BOOL fEndMenu = FALSE;
178
179 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont);
180
181 static BOOL SetMenuItemInfo_common( MENUITEM *, const MENUITEMINFOW *, BOOL);
182
183 static BOOL is_win_menu_disallowed(HWND hwnd)
184 {
185 return (GetWindowLongW(hwnd, GWL_STYLE) & (WS_CHILD | WS_POPUP)) == WS_CHILD;
186 }
187
188 /*********************************************************************
189 * menu class descriptor
190 */
191 const struct builtin_class_descr MENU_builtin_class =
192 {
193 (LPCWSTR)POPUPMENU_CLASS_ATOM, /* name */
194 CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS, /* style */
195 WINPROC_MENU, /* proc */
196 sizeof(HMENU), /* extra */
197 IDC_ARROW, /* cursor */
198 (HBRUSH)(COLOR_MENU+1) /* brush */
199 };
200
201
202 /***********************************************************************
203 * debug_print_menuitem
204 *
205 * Print a menuitem in readable form.
206 */
207
208 #define debug_print_menuitem(pre, mp, post) \
209 do { if (TRACE_ON(menu)) do_debug_print_menuitem(pre, mp, post); } while (0)
210
211 #define MENUOUT(text) \
212 TRACE("%s%s", (count++ ? "," : ""), (text))
213
214 #define MENUFLAG(bit,text) \
215 do { \
216 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
217 } while (0)
218
219 static void do_debug_print_menuitem(const char *prefix, const MENUITEM *mp,
220 const char *postfix)
221 {
222 static const char * const hbmmenus[] = { "HBMMENU_CALLBACK", "", "HBMMENU_SYSTEM",
223 "HBMMENU_MBAR_RESTORE", "HBMMENU_MBAR_MINIMIZE", "UNKNOWN BITMAP", "HBMMENU_MBAR_CLOSE",
224 "HBMMENU_MBAR_CLOSE_D", "HBMMENU_MBAR_MINIMIZE_D", "HBMMENU_POPUP_CLOSE",
225 "HBMMENU_POPUP_RESTORE", "HBMMENU_POPUP_MAXIMIZE", "HBMMENU_POPUP_MINIMIZE"};
226 TRACE("%s ", prefix);
227 if (mp) {
228 UINT flags = mp->fType;
229 TRACE( "{ ID=0x%lx", mp->wID);
230 if ( mp->hSubMenu)
231 TRACE( ", Sub=%p", mp->hSubMenu);
232 if (flags) {
233 int count = 0;
234 TRACE( ", fType=");
235 MENUFLAG( MFT_SEPARATOR, "sep");
236 MENUFLAG( MFT_OWNERDRAW, "own");
237 MENUFLAG( MFT_BITMAP, "bit");
238 MENUFLAG(MF_POPUP, "pop");
239 MENUFLAG(MFT_MENUBARBREAK, "barbrk");
240 MENUFLAG(MFT_MENUBREAK, "brk");
241 MENUFLAG(MFT_RADIOCHECK, "radio");
242 MENUFLAG(MFT_RIGHTORDER, "rorder");
243 MENUFLAG(MF_SYSMENU, "sys");
244 MENUFLAG(MFT_RIGHTJUSTIFY, "right"); /* same as MF_HELP */
245 if (flags)
246 TRACE( "+0x%x", flags);
247 }
248 flags = mp->fState;
249 if (flags) {
250 int count = 0;
251 TRACE( ", State=");
252 MENUFLAG(MFS_GRAYED, "grey");
253 MENUFLAG(MFS_DEFAULT, "default");
254 MENUFLAG(MFS_DISABLED, "dis");
255 MENUFLAG(MFS_CHECKED, "check");
256 MENUFLAG(MFS_HILITE, "hi");
257 MENUFLAG(MF_USECHECKBITMAPS, "usebit");
258 MENUFLAG(MF_MOUSESELECT, "mouse");
259 if (flags)
260 TRACE( "+0x%x", flags);
261 }
262 if (mp->hCheckBit)
263 TRACE( ", Chk=%p", mp->hCheckBit);
264 if (mp->hUnCheckBit)
265 TRACE( ", Unc=%p", mp->hUnCheckBit);
266 if (mp->text)
267 TRACE( ", Text=%s", debugstr_w(mp->text));
268 if (mp->dwItemData)
269 TRACE( ", ItemData=0x%08lx", mp->dwItemData);
270 if (mp->hbmpItem)
271 {
272 if( IS_MAGIC_BITMAP(mp->hbmpItem))
273 TRACE( ", hbitmap=%s", hbmmenus[ (INT_PTR)mp->hbmpItem + 1]);
274 else
275 TRACE( ", hbitmap=%p", mp->hbmpItem);
276 }
277 TRACE( " }");
278 } else
279 TRACE( "NULL");
280 TRACE(" %s\n", postfix);
281 }
282
283 #undef MENUOUT
284 #undef MENUFLAG
285
286
287 /***********************************************************************
288 * MENU_GetMenu
289 *
290 * Validate the given menu handle and returns the menu structure pointer.
291 */
292 static POPUPMENU *MENU_GetMenu(HMENU hMenu)
293 {
294 POPUPMENU *menu = get_user_handle_ptr( hMenu, USER_MENU );
295
296 if (menu == OBJ_OTHER_PROCESS)
297 {
298 WARN( "other process menu %p?\n", hMenu);
299 return NULL;
300 }
301 if (menu) release_user_handle_ptr( menu ); /* FIXME! */
302 else WARN("invalid menu handle=%p\n", hMenu);
303 return menu;
304 }
305
306 static POPUPMENU *grab_menu_ptr(HMENU hMenu)
307 {
308 POPUPMENU *menu = get_user_handle_ptr( hMenu, USER_MENU );
309
310 if (menu == OBJ_OTHER_PROCESS)
311 {
312 WARN("other process menu %p?\n", hMenu);
313 return NULL;
314 }
315
316 if (menu)
317 menu->refcount++;
318 else
319 WARN("invalid menu handle=%p\n", hMenu);
320 return menu;
321 }
322
323 static void release_menu_ptr(POPUPMENU *menu)
324 {
325 if (menu)
326 {
327 menu->refcount--;
328 release_user_handle_ptr(menu);
329 }
330 }
331
332 /***********************************************************************
333 * get_win_sys_menu
334 *
335 * Get the system menu of a window
336 */
337 static HMENU get_win_sys_menu( HWND hwnd )
338 {
339 HMENU ret = 0;
340 WND *win = WIN_GetPtr( hwnd );
341 if (win && win != WND_OTHER_PROCESS && win != WND_DESKTOP)
342 {
343 ret = win->hSysMenu;
344 WIN_ReleasePtr( win );
345 }
346 return ret;
347 }
348
349 /***********************************************************************
350 * get_menu_font
351 */
352 static HFONT get_menu_font( BOOL bold )
353 {
354 static HFONT hMenuFont, hMenuFontBold;
355
356 HFONT ret = bold ? hMenuFontBold : hMenuFont;
357
358 if (!ret)
359 {
360 NONCLIENTMETRICSW ncm;
361 HFONT prev;
362
363 ncm.cbSize = sizeof(NONCLIENTMETRICSW);
364 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSW), &ncm, 0);
365
366 if (bold)
367 {
368 ncm.lfMenuFont.lfWeight += 300;
369 if (ncm.lfMenuFont.lfWeight > 1000) ncm.lfMenuFont.lfWeight = 1000;
370 }
371 if (!(ret = CreateFontIndirectW( &ncm.lfMenuFont ))) return 0;
372 prev = InterlockedCompareExchangePointer( (void **)(bold ? &hMenuFontBold : &hMenuFont),
373 ret, NULL );
374 if (prev)
375 {
376 /* another thread beat us to it */
377 DeleteObject( ret );
378 ret = prev;
379 }
380 }
381 return ret;
382 }
383
384 /***********************************************************************
385 * get_arrow_bitmap
386 */
387 static HBITMAP get_arrow_bitmap(void)
388 {
389 static HBITMAP arrow_bitmap;
390
391 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW));
392 return arrow_bitmap;
393 }
394
395 static inline UINT get_scroll_arrow_height(const POPUPMENU *menu)
396 {
397 return menucharsize.cy + 4;
398 }
399
400 /***********************************************************************
401 * MENU_CopySysPopup
402 *
403 * Return the default system menu.
404 */
405 static HMENU MENU_CopySysPopup(BOOL mdi)
406 {
407 static const WCHAR sysmenuW[] = {'S','Y','S','M','E','N','U',0};
408 static const WCHAR sysmenumdiW[] = {'S','Y','S','M','E','N','U','M','D','I',0};
409 HMENU hMenu = LoadMenuW(user32_module, (mdi ? sysmenumdiW : sysmenuW));
410
411 if( hMenu ) {
412 MENUINFO minfo;
413 MENUITEMINFOW miteminfo;
414 POPUPMENU* menu = MENU_GetMenu(hMenu);
415 menu->wFlags |= MF_SYSMENU | MF_POPUP;
416 /* decorate the menu with bitmaps */
417 minfo.cbSize = sizeof( MENUINFO);
418 minfo.dwStyle = MNS_CHECKORBMP;
419 minfo.fMask = MIM_STYLE;
420 SetMenuInfo( hMenu, &minfo);
421 miteminfo.cbSize = sizeof( MENUITEMINFOW);
422 miteminfo.fMask = MIIM_BITMAP;
423 miteminfo.hbmpItem = HBMMENU_POPUP_CLOSE;
424 SetMenuItemInfoW( hMenu, SC_CLOSE, FALSE, &miteminfo);
425 miteminfo.hbmpItem = HBMMENU_POPUP_RESTORE;
426 SetMenuItemInfoW( hMenu, SC_RESTORE, FALSE, &miteminfo);
427 miteminfo.hbmpItem = HBMMENU_POPUP_MAXIMIZE;
428 SetMenuItemInfoW( hMenu, SC_MAXIMIZE, FALSE, &miteminfo);
429 miteminfo.hbmpItem = HBMMENU_POPUP_MINIMIZE;
430 SetMenuItemInfoW( hMenu, SC_MINIMIZE, FALSE, &miteminfo);
431 SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
432 }
433 else
434 ERR("Unable to load default system menu\n" );
435
436 TRACE("returning %p (mdi=%d).\n", hMenu, mdi );
437
438 return hMenu;
439 }
440
441
442 /**********************************************************************
443 * MENU_GetSysMenu
444 *
445 * Create a copy of the system menu. System menu in Windows is
446 * a special menu bar with the single entry - system menu popup.
447 * This popup is presented to the outside world as a "system menu".
448 * However, the real system menu handle is sometimes seen in the
449 * WM_MENUSELECT parameters (and Word 6 likes it this way).
450 */
451 static HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
452 {
453 HMENU hMenu;
454
455 TRACE("loading system menu, hWnd %p, hPopupMenu %p\n", hWnd, hPopupMenu);
456 if ((hMenu = CreateMenu()))
457 {
458 POPUPMENU *menu = MENU_GetMenu(hMenu);
459 menu->wFlags = MF_SYSMENU;
460 menu->hWnd = WIN_GetFullHandle( hWnd );
461 TRACE("hWnd %p (hMenu %p)\n", menu->hWnd, hMenu);
462
463 if (!hPopupMenu)
464 {
465 if (GetWindowLongW(hWnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
466 hPopupMenu = MENU_CopySysPopup(TRUE);
467 else
468 hPopupMenu = MENU_CopySysPopup(FALSE);
469 }
470
471 if (hPopupMenu)
472 {
473 if (GetClassLongW(hWnd, GCL_STYLE) & CS_NOCLOSE)
474 DeleteMenu(hPopupMenu, SC_CLOSE, MF_BYCOMMAND);
475
476 InsertMenuW( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION,
477 (UINT_PTR)hPopupMenu, NULL );
478
479 menu->items[0].fType = MF_SYSMENU | MF_POPUP;
480 menu->items[0].fState = 0;
481 if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags |= MF_SYSMENU;
482
483 TRACE("hMenu=%p (hPopup %p)\n", hMenu, hPopupMenu );
484 return hMenu;
485 }
486 DestroyMenu( hMenu );
487 }
488 ERR("failed to load system menu!\n");
489 return 0;
490 }
491
492
493 /***********************************************************************
494 * MENU_InitSysMenuPopup
495 *
496 * Grey the appropriate items in System menu.
497 */
498 static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
499 {
500 BOOL gray;
501
502 gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
503 EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
504 gray = ((style & WS_MAXIMIZE) != 0);
505 EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
506 gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
507 EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
508 gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
509 EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
510 gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
511 EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
512 gray = (clsStyle & CS_NOCLOSE) != 0;
513
514 /* The menu item must keep its state if it's disabled */
515 if(gray)
516 EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
517 }
518
519
520 /******************************************************************************
521 *
522 * UINT MENU_GetStartOfNextColumn(
523 * HMENU hMenu )
524 *
525 *****************************************************************************/
526
527 static UINT MENU_GetStartOfNextColumn(
528 HMENU hMenu )
529 {
530 POPUPMENU *menu = MENU_GetMenu(hMenu);
531 UINT i;
532
533 if(!menu)
534 return NO_SELECTED_ITEM;
535
536 i = menu->FocusedItem + 1;
537 if( i == NO_SELECTED_ITEM )
538 return i;
539
540 for( ; i < menu->nItems; ++i ) {
541 if (menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
542 return i;
543 }
544
545 return NO_SELECTED_ITEM;
546 }
547
548
549 /******************************************************************************
550 *
551 * UINT MENU_GetStartOfPrevColumn(
552 * HMENU hMenu )
553 *
554 *****************************************************************************/
555
556 static UINT MENU_GetStartOfPrevColumn(
557 HMENU hMenu )
558 {
559 POPUPMENU *menu = MENU_GetMenu(hMenu);
560 UINT i;
561
562 if( !menu )
563 return NO_SELECTED_ITEM;
564
565 if( menu->FocusedItem == 0 || menu->FocusedItem == NO_SELECTED_ITEM )
566 return NO_SELECTED_ITEM;
567
568 /* Find the start of the column */
569
570 for(i = menu->FocusedItem; i != 0 &&
571 !(menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK));
572 --i); /* empty */
573
574 if(i == 0)
575 return NO_SELECTED_ITEM;
576
577 for(--i; i != 0; --i) {
578 if (menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
579 break;
580 }
581
582 TRACE("ret %d.\n", i );
583
584 return i;
585 }
586
587 static POPUPMENU *find_menu_item(HMENU hmenu, UINT id, UINT flags, UINT *pos)
588 {
589 UINT fallback_pos = ~0u, i;
590 POPUPMENU *menu;
591
592 menu = grab_menu_ptr(hmenu);
593 if (!menu)
594 return NULL;
595
596 if (flags & MF_BYPOSITION)
597 {
598 if (id >= menu->nItems)
599 {
600 release_menu_ptr(menu);
601 return NULL;
602 }
603
604 if (pos) *pos = id;
605 return menu;
606 }
607 else
608 {
609 MENUITEM *item = menu->items;
610 for (i = 0; i < menu->nItems; i++, item++)
611 {
612 if (item->fType & MF_POPUP)
613 {
614 POPUPMENU *submenu = find_menu_item(item->hSubMenu, id, flags, pos);
615
616 if (submenu)
617 {
618 release_menu_ptr(menu);
619 return submenu;
620 }
621 else if (item->wID == id)
622 {
623 /* fallback to this item if nothing else found */
624 fallback_pos = i;
625 }
626 }
627 else if (item->wID == id)
628 {
629 if (pos) *pos = i;
630 return menu;
631 }
632 }
633 }
634
635 if (fallback_pos != ~0u)
636 *pos = fallback_pos;
637 else
638 {
639 release_menu_ptr(menu);
640 menu = NULL;
641 }
642
643 return menu;
644 }
645
646 /***********************************************************************
647 * MENU_FindSubMenu
648 *
649 * Find a Sub menu. Return the position of the submenu, and modifies
650 * *hmenu in case it is found in another sub-menu.
651 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
652 */
653 static UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
654 {
655 POPUPMENU *menu;
656 UINT i;
657 MENUITEM *item;
658 if (((*hmenu)==(HMENU)0xffff) ||
659 (!(menu = MENU_GetMenu(*hmenu))))
660 return NO_SELECTED_ITEM;
661 item = menu->items;
662 for (i = 0; i < menu->nItems; i++, item++) {
663 if(!(item->fType & MF_POPUP)) continue;
664 if (item->hSubMenu == hSubTarget) {
665 return i;
666 }
667 else {
668 HMENU hsubmenu = item->hSubMenu;
669 UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
670 if (pos != NO_SELECTED_ITEM) {
671 *hmenu = hsubmenu;
672 return pos;
673 }
674 }
675 }
676 return NO_SELECTED_ITEM;
677 }
678
679 /***********************************************************************
680 * MENU_FreeItemData
681 */
682 static void MENU_FreeItemData( MENUITEM* item )
683 {
684 /* delete text */
685 HeapFree( GetProcessHeap(), 0, item->text );
686 }
687
688 /***********************************************************************
689 * MENU_AdjustMenuItemRect
690 *
691 * Adjust menu item rectangle according to scrolling state.
692 */
693 static void
694 MENU_AdjustMenuItemRect(const POPUPMENU *menu, LPRECT rect)
695 {
696 INT scroll_offset = menu->bScrolling ? menu->nScrollPos : 0;
697
698 OffsetRect( rect, menu->items_rect.left, menu->items_rect.top - scroll_offset );
699 }
700
701 enum hittest
702 {
703 ht_nowhere, /* outside the menu */
704 ht_border, /* anywhere that's not an item or a scroll arrow */
705 ht_item, /* a menu item */
706 ht_scroll_up, /* scroll up arrow */
707 ht_scroll_down /* scroll down arrow */
708 };
709
710 /***********************************************************************
711 * MENU_FindItemByCoords
712 *
713 * Find the item at the specified coordinates (screen coords). Does
714 * not work for child windows and therefore should not be called for
715 * an arbitrary system menu.
716 *
717 * Returns a hittest code. *pos will contain the position of the
718 * item or NO_SELECTED_ITEM. If the hittest code is ht_scroll_up
719 * or ht_scroll_down then *pos will contain the position of the
720 * item that's just outside the items_rect - ie, the one that would
721 * be scrolled completely into view.
722 */
723 static enum hittest MENU_FindItemByCoords( const POPUPMENU *menu, POINT pt, UINT *pos )
724 {
725 MENUITEM *item;
726 UINT i;
727 RECT rect;
728 enum hittest ht = ht_border;
729
730 *pos = NO_SELECTED_ITEM;
731
732 if (!GetWindowRect(menu->hWnd, &rect) || !PtInRect(&rect, pt))
733 return ht_nowhere;
734
735 if (GetWindowLongW( menu->hWnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) pt.x = rect.right - 1 - pt.x;
736 else pt.x -= rect.left;
737 pt.y -= rect.top;
738
739 if (!PtInRect(&menu->items_rect, pt))
740 {
741 if (!menu->bScrolling || pt.x < menu->items_rect.left || pt.x >= menu->items_rect.right)
742 return ht_border;
743
744 /* On a scroll arrow. Update pt so that it points to the item just outside items_rect */
745 if (pt.y < menu->items_rect.top)
746 {
747 ht = ht_scroll_up;
748 pt.y = menu->items_rect.top - 1;
749 }
750 else
751 {
752 ht = ht_scroll_down;
753 pt.y = menu->items_rect.bottom;
754 }
755 }
756
757 item = menu->items;
758 for (i = 0; i < menu->nItems; i++, item++)
759 {
760 rect = item->rect;
761 MENU_AdjustMenuItemRect(menu, &rect);
762 if (PtInRect(&rect, pt))
763 {
764 *pos = i;
765 if (ht != ht_scroll_up && ht != ht_scroll_down) ht = ht_item;
766 break;
767 }
768 }
769
770 return ht;
771 }
772
773
774 /***********************************************************************
775 * MENU_FindItemByKey
776 *
777 * Find the menu item selected by a key press.
778 * Return item id, -1 if none, -2 if we should close the menu.
779 */
780 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu,
781 WCHAR key, BOOL forceMenuChar )
782 {
783 TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)key, key, hmenu );
784
785 if (!IsMenu( hmenu )) hmenu = GetSubMenu( get_win_sys_menu(hwndOwner), 0);
786
787 if (hmenu)
788 {
789 POPUPMENU *menu = MENU_GetMenu( hmenu );
790 MENUITEM *item = menu->items;
791 LRESULT menuchar;
792
793 if( !forceMenuChar )
794 {
795 UINT i;
796 BOOL cjk = GetSystemMetrics( SM_DBCSENABLED );
797
798 for (i = 0; i < menu->nItems; i++, item++)
799 {
800 if( item->text)
801 {
802 const WCHAR *p = item->text - 2;
803 do
804 {
805 const WCHAR *q = p + 2;
806 p = strchrW (q, '&');
807 if (!p && cjk) p = strchrW (q, '\036'); /* Japanese Win16 */
808 }
809 while (p != NULL && p [1] == '&');
810 if (p && (toupperW(p[1]) == toupperW(key))) return i;
811 }
812 }
813 }
814 menuchar = SendMessageW( hwndOwner, WM_MENUCHAR,
815 MAKEWPARAM( key, menu->wFlags ), (LPARAM)hmenu );
816 if (HIWORD(menuchar) == MNC_EXECUTE) return LOWORD(menuchar);
817 if (HIWORD(menuchar) == MNC_CLOSE) return (UINT)(-2);
818 }
819 return (UINT)(-1);
820 }
821
822
823 /***********************************************************************
824 * MENU_GetBitmapItemSize
825 *
826 * Get the size of a bitmap item.
827 */
828 static void MENU_GetBitmapItemSize( MENUITEM *lpitem, SIZE *size,
829 HWND hwndOwner)
830 {
831 BITMAP bm;
832 HBITMAP bmp = lpitem->hbmpItem;
833
834 size->cx = size->cy = 0;
835
836 /* check if there is a magic menu item associated with this item */
837 switch( (INT_PTR) bmp )
838 {
839 case (INT_PTR)HBMMENU_CALLBACK:
840 {
841 MEASUREITEMSTRUCT measItem;
842 measItem.CtlType = ODT_MENU;
843 measItem.CtlID = 0;
844 measItem.itemID = lpitem->wID;
845 measItem.itemWidth = lpitem->rect.right - lpitem->rect.left;
846 measItem.itemHeight = lpitem->rect.bottom - lpitem->rect.top;
847 measItem.itemData = lpitem->dwItemData;
848 SendMessageW( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&measItem);
849 size->cx = measItem.itemWidth;
850 size->cy = measItem.itemHeight;
851 return;
852 }
853 break;
854 case (INT_PTR)HBMMENU_SYSTEM:
855 if (lpitem->dwItemData)
856 {
857 bmp = (HBITMAP)lpitem->dwItemData;
858 break;
859 }
860 /* fall through */
861 case (INT_PTR)HBMMENU_MBAR_RESTORE:
862 case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
863 case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
864 case (INT_PTR)HBMMENU_MBAR_CLOSE:
865 case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
866 size->cx = GetSystemMetrics( SM_CYMENU ) - 4;
867 size->cy = size->cx;
868 return;
869 case (INT_PTR)HBMMENU_POPUP_CLOSE:
870 case (INT_PTR)HBMMENU_POPUP_RESTORE:
871 case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
872 case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
873 size->cx = GetSystemMetrics( SM_CXMENUSIZE);
874 size->cy = GetSystemMetrics( SM_CYMENUSIZE);
875 return;
876 }
877 if (GetObjectW(bmp, sizeof(bm), &bm ))
878 {
879 size->cx = bm.bmWidth;
880 size->cy = bm.bmHeight;
881 }
882 }
883
884 /***********************************************************************
885 * MENU_DrawBitmapItem
886 *
887 * Draw a bitmap item.
888 */
889 static void MENU_DrawBitmapItem( HDC hdc, MENUITEM *lpitem, const RECT *rect,
890 POPUPMENU *menu, HWND hwndOwner, UINT odaction )
891 {
892 BITMAP bm;
893 DWORD rop;
894 HDC hdcMem;
895 HBITMAP bmp;
896 int w = rect->right - rect->left;
897 int h = rect->bottom - rect->top;
898 int bmp_xoffset = 0;
899 int left, top;
900 HBITMAP hbmToDraw = lpitem->hbmpItem;
901 bmp = hbmToDraw;
902
903 /* Check if there is a magic menu item associated with this item */
904 if (IS_MAGIC_BITMAP(hbmToDraw))
905 {
906 UINT flags = 0;
907 WCHAR bmchr = 0;
908 RECT r;
909
910 switch((INT_PTR)hbmToDraw)
911 {
912 case (INT_PTR)HBMMENU_SYSTEM:
913 if (lpitem->dwItemData)
914 {
915 bmp = (HBITMAP)lpitem->dwItemData;
916 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
917 }
918 else
919 {
920 static HBITMAP hBmpSysMenu;
921
922 if (!hBmpSysMenu) hBmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
923 bmp = hBmpSysMenu;
924 if (!GetObjectW( bmp, sizeof(bm), &bm )) return;
925 /* only use right half of the bitmap */
926 bmp_xoffset = bm.bmWidth / 2;
927 bm.bmWidth -= bmp_xoffset;
928 }
929 goto got_bitmap;
930 case (INT_PTR)HBMMENU_MBAR_RESTORE:
931 flags = DFCS_CAPTIONRESTORE;
932 break;
933 case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
934 flags = DFCS_CAPTIONMIN;
935 break;
936 case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
937 flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
938 break;
939 case (INT_PTR)HBMMENU_MBAR_CLOSE:
940 flags = DFCS_CAPTIONCLOSE;
941 break;
942 case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
943 flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
944 break;
945 case (INT_PTR)HBMMENU_CALLBACK:
946 {
947 DRAWITEMSTRUCT drawItem;
948 drawItem.CtlType = ODT_MENU;
949 drawItem.CtlID = 0;
950 drawItem.itemID = lpitem->wID;
951 drawItem.itemAction = odaction;
952 drawItem.itemState = (lpitem->fState & MF_CHECKED)?ODS_CHECKED:0;
953 drawItem.itemState |= (lpitem->fState & MF_DEFAULT)?ODS_DEFAULT:0;
954 drawItem.itemState |= (lpitem->fState & MF_DISABLED)?ODS_DISABLED:0;
955 drawItem.itemState |= (lpitem->fState & MF_GRAYED)?ODS_GRAYED|ODS_DISABLED:0;
956 drawItem.itemState |= (lpitem->fState & MF_HILITE)?ODS_SELECTED:0;
957 drawItem.hwndItem = (HWND)menu->obj.handle;
958 drawItem.hDC = hdc;
959 drawItem.itemData = lpitem->dwItemData;
960 drawItem.rcItem = *rect;
961 SendMessageW( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&drawItem);
962 return;
963 }
964 break;
965 case (INT_PTR)HBMMENU_POPUP_CLOSE:
966 bmchr = 0x72;
967 break;
968 case (INT_PTR)HBMMENU_POPUP_RESTORE:
969 bmchr = 0x32;
970 break;
971 case (INT_PTR)HBMMENU_POPUP_MAXIMIZE:
972 bmchr = 0x31;
973 break;
974 case (INT_PTR)HBMMENU_POPUP_MINIMIZE:
975 bmchr = 0x30;
976 break;
977 default:
978 FIXME("Magic %p not implemented\n", hbmToDraw);
979 return;
980 }
981 if (bmchr)
982 {
983 /* draw the magic bitmaps using marlett font characters */
984 /* FIXME: fontsize and the position (x,y) could probably be better */
985 HFONT hfont, hfontsav;
986 LOGFONTW logfont = { 0, 0, 0, 0, FW_NORMAL,
987 0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0,
988 { 'M','a','r','l','e','t','t',0 } };
989 logfont.lfHeight = min( h, w) - 5 ;
990 TRACE(" height %d rect %s\n", logfont.lfHeight, wine_dbgstr_rect( rect));
991 hfont = CreateFontIndirectW( &logfont);
992 hfontsav = SelectObject(hdc, hfont);
993 TextOutW( hdc, rect->left, rect->top + 2, &bmchr, 1);
994 SelectObject(hdc, hfontsav);
995 DeleteObject( hfont);
996 }
997 else
998 {
999 r = *rect;
1000 InflateRect( &r, -1, -1 );
1001 if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
1002 DrawFrameControl( hdc, &r, DFC_CAPTION, flags );
1003 }
1004 return;
1005 }
1006
1007 if (!bmp || !GetObjectW( bmp, sizeof(bm), &bm )) return;
1008
1009 got_bitmap:
1010 hdcMem = CreateCompatibleDC( hdc );
1011 SelectObject( hdcMem, bmp );
1012
1013 /* handle fontsize > bitmap_height */
1014 top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
1015 left=rect->left;
1016 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_BITMAP(hbmToDraw)) ? NOTSRCCOPY : SRCCOPY;
1017 if ((lpitem->fState & MF_HILITE) && lpitem->hbmpItem)
1018 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1019 BitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop );
1020 DeleteDC( hdcMem );
1021 }
1022
1023
1024 /***********************************************************************
1025 * MENU_CalcItemSize
1026 *
1027 * Calculate the size of the menu item and store it in lpitem->rect.
1028 */
1029 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
1030 INT orgX, INT orgY, BOOL menuBar, POPUPMENU* lppop )
1031 {
1032 WCHAR *p;
1033 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1034 UINT arrow_bitmap_width;
1035 BITMAP bm;
1036 INT itemheight;
1037
1038 TRACE("dc=%p owner=%p (%d,%d)\n", hdc, hwndOwner, orgX, orgY);
1039 debug_print_menuitem("MENU_CalcItemSize: menuitem:", lpitem,
1040 (menuBar ? " (MenuBar)" : ""));
1041
1042 GetObjectW( get_arrow_bitmap(), sizeof(bm), &bm );
1043 arrow_bitmap_width = bm.bmWidth;
1044
1045 /* not done in Menu_Init: GetDialogBaseUnits() breaks there */
1046 if( !menucharsize.cx ) {
1047 menucharsize.cx = GdiGetCharDimensions( hdc, NULL, &menucharsize.cy );
1048 /* Win95/98/ME will use menucharsize.cy here. Testing is possible
1049 * but it is unlikely an application will depend on that */
1050 ODitemheight = HIWORD( GetDialogBaseUnits());
1051 }
1052
1053 SetRect( &lpitem->rect, orgX, orgY, orgX, orgY );
1054
1055 if (lpitem->fType & MF_OWNERDRAW)
1056 {
1057 MEASUREITEMSTRUCT mis;
1058 mis.CtlType = ODT_MENU;
1059 mis.CtlID = 0;
1060 mis.itemID = lpitem->wID;
1061 mis.itemData = lpitem->dwItemData;
1062 mis.itemHeight = ODitemheight;
1063 mis.itemWidth = 0;
1064 SendMessageW( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)&mis );
1065 /* Tests reveal that Windows ( Win95 through WinXP) adds twice the average
1066 * width of a menufont character to the width of an owner-drawn menu.
1067 */
1068 lpitem->rect.right += mis.itemWidth + 2 * menucharsize.cx;
1069 if (menuBar) {
1070 /* under at least win95 you seem to be given a standard
1071 height for the menu and the height value is ignored */
1072 lpitem->rect.bottom += GetSystemMetrics(SM_CYMENUSIZE);
1073 } else
1074 lpitem->rect.bottom += mis.itemHeight;
1075
1076 TRACE("id=%04lx size=%dx%d\n",
1077 lpitem->wID, lpitem->rect.right-lpitem->rect.left,
1078 lpitem->rect.bottom-lpitem->rect.top);
1079 return;
1080 }
1081
1082 if (lpitem->fType & MF_SEPARATOR)
1083 {
1084 lpitem->rect.bottom += GetSystemMetrics( SM_CYMENUSIZE)/2;
1085 if( !menuBar)
1086 lpitem->rect.right += arrow_bitmap_width + menucharsize.cx;
1087 return;
1088 }
1089
1090 itemheight = 0;
1091 lpitem->xTab = 0;
1092
1093 if (!menuBar) {
1094 if (lpitem->hbmpItem) {
1095 SIZE size;
1096
1097 MENU_GetBitmapItemSize(lpitem, &size, hwndOwner);
1098 /* Keep the size of the bitmap in callback mode to be able
1099 * to draw it correctly */
1100 lpitem->bmpsize = size;
1101 lppop->textOffset = max( lppop->textOffset, size.cx);
1102 lpitem->rect.right += size.cx + 2;
1103 itemheight = size.cy + 2;
1104 }
1105 if( !(lppop->dwStyle & MNS_NOCHECK))
1106 lpitem->rect.right += check_bitmap_width;
1107 lpitem->rect.right += 4 + menucharsize.cx;
1108 lpitem->xTab = lpitem->rect.right;
1109 lpitem->rect.right += arrow_bitmap_width;
1110 } else if (lpitem->hbmpItem) { /* menuBar */
1111 SIZE size;
1112
1113 MENU_GetBitmapItemSize( lpitem, &size, hwndOwner );
1114 lpitem->bmpsize = size;
1115 lpitem->rect.right += size.cx;
1116 if( lpitem->text) lpitem->rect.right += 2;
1117 itemheight = size.cy;
1118 }
1119
1120 /* it must be a text item - unless it's the system menu */
1121 if (!(lpitem->fType & MF_SYSMENU) && lpitem->text) {
1122 HFONT hfontOld = NULL;
1123 RECT rc = lpitem->rect;
1124 LONG txtheight, txtwidth;
1125
1126 if ( lpitem->fState & MFS_DEFAULT ) {
1127 hfontOld = SelectObject( hdc, get_menu_font(TRUE) );
1128 }
1129 if (menuBar) {
1130 txtheight = DrawTextW( hdc, lpitem->text, -1, &rc,
1131 DT_SINGLELINE|DT_CALCRECT);
1132 lpitem->rect.right += rc.right - rc.left;
1133 itemheight = max( max( itemheight, txtheight),
1134 GetSystemMetrics( SM_CYMENU) - 1);
1135 lpitem->rect.right += 2 * menucharsize.cx;
1136 } else {
1137 if ((p = strchrW( lpitem->text, '\t' )) != NULL) {
1138 RECT tmprc = rc;
1139 LONG tmpheight;
1140 int n = (int)( p - lpitem->text);
1141 /* Item contains a tab (only meaningful in popup menus) */
1142 /* get text size before the tab */
1143 txtheight = DrawTextW( hdc, lpitem->text, n, &rc,
1144 DT_SINGLELINE|DT_CALCRECT);
1145 txtwidth = rc.right - rc.left;
1146 p += 1; /* advance past the Tab */
1147 /* get text size after the tab */
1148 tmpheight = DrawTextW( hdc, p, -1, &tmprc,
1149 DT_SINGLELINE|DT_CALCRECT);
1150 lpitem->xTab += txtwidth;
1151 txtheight = max( txtheight, tmpheight);
1152 txtwidth += menucharsize.cx + /* space for the tab */
1153 tmprc.right - tmprc.left; /* space for the short cut */
1154 } else {
1155 txtheight = DrawTextW( hdc, lpitem->text, -1, &rc,
1156 DT_SINGLELINE|DT_CALCRECT);
1157 txtwidth = rc.right - rc.left;
1158 lpitem->xTab += txtwidth;
1159 }
1160 lpitem->rect.right += 2 + txtwidth;
1161 itemheight = max( itemheight,
1162 max( txtheight + 2, menucharsize.cy + 4));
1163 }
1164 if (hfontOld) SelectObject (hdc, hfontOld);
1165 } else if( menuBar) {
1166 itemheight = max( itemheight, GetSystemMetrics(SM_CYMENU)-1);
1167 }
1168 lpitem->rect.bottom += itemheight;
1169 TRACE("%s\n", wine_dbgstr_rect( &lpitem->rect));
1170 }
1171
1172 /***********************************************************************
1173 * MENU_PopupMenuCalcSize
1174 *
1175 * Calculate the size of a popup menu.
1176 */
1177 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, UINT max_height )
1178 {
1179 MENUITEM *lpitem;
1180 HDC hdc;
1181 UINT start, i;
1182 BOOL textandbmp = FALSE, multi_col = FALSE;
1183 int orgX, orgY, maxTab, maxTabWidth;
1184
1185 lppop->Width = lppop->Height = 0;
1186 SetRectEmpty(&lppop->items_rect);
1187
1188 if (lppop->nItems == 0) return;
1189 hdc = GetDC( 0 );
1190
1191 SelectObject( hdc, get_menu_font(FALSE));
1192
1193 start = 0;
1194
1195 lppop->textOffset = 0;
1196
1197 while (start < lppop->nItems)
1198 {
1199 lpitem = &lppop->items[start];
1200 orgX = lppop->items_rect.right;
1201 if( lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))
1202 orgX += MENU_COL_SPACE;
1203 orgY = lppop->items_rect.top;
1204
1205 maxTab = maxTabWidth = 0;
1206 /* Parse items until column break or end of menu */
1207 for (i = start; i < lppop->nItems; i++, lpitem++)
1208 {
1209 if (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))
1210 {
1211 multi_col = TRUE;
1212 if (i != start) break;
1213 }
1214
1215 MENU_CalcItemSize( hdc, lpitem, lppop->hwndOwner, orgX, orgY, FALSE, lppop );
1216 lppop->items_rect.right = max( lppop->items_rect.right, lpitem->rect.right );
1217 orgY = lpitem->rect.bottom;
1218 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1219 {
1220 maxTab = max( maxTab, lpitem->xTab );
1221 maxTabWidth = max(maxTabWidth,lpitem->rect.right-lpitem->xTab);
1222 }
1223 if( lpitem->text && lpitem->hbmpItem) textandbmp = TRUE;
1224 }
1225
1226 /* Finish the column (set all items to the largest width found) */
1227 lppop->items_rect.right = max( lppop->items_rect.right, maxTab + maxTabWidth );
1228 for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
1229 {
1230 lpitem->rect.right = lppop->items_rect.right;
1231 if (IS_STRING_ITEM(lpitem->fType) && lpitem->xTab)
1232 lpitem->xTab = maxTab;
1233
1234 }
1235 lppop->items_rect.bottom = max( lppop->items_rect.bottom, orgY );
1236 }
1237
1238 /* if none of the items have both text and bitmap then
1239 * the text and bitmaps are all aligned on the left. If there is at
1240 * least one item with both text and bitmap then bitmaps are
1241 * on the left and texts left aligned with the right hand side
1242 * of the bitmaps */
1243 if( !textandbmp) lppop->textOffset = 0;
1244
1245 lppop->nTotalHeight = lppop->items_rect.bottom;
1246
1247 /* space for the border */
1248 OffsetRect(&lppop->items_rect, MENU_MARGIN, MENU_MARGIN);
1249 lppop->Height = lppop->items_rect.bottom + MENU_MARGIN;
1250 lppop->Width = lppop->items_rect.right + MENU_MARGIN;
1251
1252 /* Adjust popup height if it exceeds maximum */
1253 if (lppop->Height >= max_height)
1254 {
1255 lppop->Height = max_height;
1256 lppop->bScrolling = !multi_col;
1257 /* When the scroll arrows are present, don't add the top/bottom margin as well */
1258 if (lppop->bScrolling)
1259 {
1260 lppop->items_rect.top = get_scroll_arrow_height(lppop);
1261 lppop->items_rect.bottom = lppop->Height - get_scroll_arrow_height(lppop);
1262 }
1263 }
1264 else
1265 {
1266 lppop->bScrolling = FALSE;
1267 }
1268
1269 ReleaseDC( 0, hdc );
1270 }
1271
1272
1273 /***********************************************************************
1274 * MENU_MenuBarCalcSize
1275 *
1276 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
1277 * height is off by 1 pixel which causes lengthy window relocations when
1278 * active document window is maximized/restored.
1279 *
1280 * Calculate the size of the menu bar.
1281 */
1282 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect,
1283 LPPOPUPMENU lppop, HWND hwndOwner )
1284 {
1285 MENUITEM *lpitem;
1286 UINT start, i, helpPos;
1287 int orgX, orgY;
1288
1289 if ((lprect == NULL) || (lppop == NULL)) return;
1290 if (lppop->nItems == 0) return;
1291 TRACE("lprect %p %s\n", lprect, wine_dbgstr_rect( lprect));
1292 /* Start with a 1 pixel top border.
1293 This corresponds to the difference between SM_CYMENU and SM_CYMENUSIZE. */
1294 SetRect(&lppop->items_rect, 0, 0, lprect->right - lprect->left, 1);
1295 start = 0;
1296 helpPos = ~0U;
1297 lppop->textOffset = 0;
1298 while (start < lppop->nItems)
1299 {
1300 lpitem = &lppop->items[start];
1301 orgX = lppop->items_rect.left;
1302 orgY = lppop->items_rect.bottom;
1303
1304 /* Parse items until line break or end of menu */
1305 for (i = start; i < lppop->nItems; i++, lpitem++)
1306 {
1307 if ((helpPos == ~0U) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1308 if ((i != start) &&
1309 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1310
1311 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n", orgX, orgY );
1312 debug_print_menuitem (" item: ", lpitem, "");
1313 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE, lppop );
1314
1315 if (lpitem->rect.right > lppop->items_rect.right)
1316 {
1317 if (i != start) break;
1318 else lpitem->rect.right = lppop->items_rect.right;
1319 }
1320 lppop->items_rect.bottom = max( lppop->items_rect.bottom, lpitem->rect.bottom );
1321 orgX = lpitem->rect.right;
1322 }
1323
1324 /* Finish the line (set all items to the largest height found) */
1325 while (start < i) lppop->items[start++].rect.bottom = lppop->items_rect.bottom;
1326 }
1327
1328 OffsetRect(&lppop->items_rect, lprect->left, lprect->top);
1329 lppop->Width = lppop->items_rect.right - lppop->items_rect.left;
1330 lppop->Height = lppop->items_rect.bottom - lppop->items_rect.top;
1331 lprect->bottom = lppop->items_rect.bottom;
1332
1333 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1334 /* the last item (if several lines, only move the last line) */
1335 if (helpPos == ~0U) return;
1336 lpitem = &lppop->items[lppop->nItems-1];
1337 orgY = lpitem->rect.top;
1338 orgX = lprect->right - lprect->left;
1339 for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
1340 if (lpitem->rect.top != orgY) break; /* Other line */
1341 if (lpitem->rect.right >= orgX) break; /* Too far right already */
1342 lpitem->rect.left += orgX - lpitem->rect.right;
1343 lpitem->rect.right = orgX;
1344 orgX = lpitem->rect.left;
1345 }
1346 }
1347
1348 static void draw_scroll_arrow(HDC hdc, int x, int top, int height, BOOL up, BOOL enabled)
1349 {
1350 RECT rect, light_rect;
1351 HBRUSH brush = GetSysColorBrush( enabled ? COLOR_BTNTEXT : COLOR_BTNSHADOW );
1352 HBRUSH light = GetSysColorBrush( COLOR_3DLIGHT );
1353
1354 if (!up)
1355 {
1356 top = top + height;
1357 if (!enabled)
1358 {
1359 SetRect( &rect, x + 1, top, x + 2, top + 1);
1360 FillRect( hdc, &rect, light );
1361 }
1362 top--;
1363 }
1364
1365 SetRect( &rect, x, top, x + 1, top + 1);
1366 while (height--)
1367 {
1368 FillRect( hdc, &rect, brush );
1369 if (!enabled && !up && height)
1370 {
1371 SetRect( &light_rect, rect.right, rect.top, rect.right + 2, rect.bottom );
1372 FillRect( hdc, &light_rect, light );
1373 }
1374 InflateRect( &rect, 1, 0 );
1375 OffsetRect( &rect, 0, up ? 1 : -1 );
1376 }
1377
1378 if (!enabled && up)
1379 {
1380 rect.left += 2;
1381 FillRect( hdc, &rect, light );
1382 }
1383 }
1384
1385 /***********************************************************************
1386 * MENU_DrawScrollArrows
1387 *
1388 * Draw scroll arrows.
1389 */
1390 static void
1391 MENU_DrawScrollArrows(const POPUPMENU *menu, HDC hdc)
1392 {
1393 UINT full_height = get_scroll_arrow_height( menu );
1394 UINT arrow_height = full_height / 3;
1395 BOOL at_end = menu->nScrollPos + menu->items_rect.bottom - menu->items_rect.top == menu->nTotalHeight;
1396
1397 draw_scroll_arrow( hdc, menu->Width / 3, arrow_height, arrow_height,
1398 TRUE, menu->nScrollPos != 0);
1399 draw_scroll_arrow( hdc, menu->Width / 3, menu->Height - 2 * arrow_height, arrow_height,
1400 FALSE, !at_end );
1401 }
1402
1403
1404 /***********************************************************************
1405 * draw_popup_arrow
1406 *
1407 * Draws the popup-menu arrow.
1408 */
1409 static void draw_popup_arrow( HDC hdc, RECT rect, UINT arrow_bitmap_width,
1410 UINT arrow_bitmap_height)
1411 {
1412 HDC hdcMem = CreateCompatibleDC( hdc );
1413 HBITMAP hOrigBitmap;
1414
1415 hOrigBitmap = SelectObject( hdcMem, get_arrow_bitmap() );
1416 BitBlt( hdc, rect.right - arrow_bitmap_width - 1,
1417 (rect.top + rect.bottom - arrow_bitmap_height) / 2,
1418 arrow_bitmap_width, arrow_bitmap_height,
1419 hdcMem, 0, 0, SRCCOPY );
1420 SelectObject( hdcMem, hOrigBitmap );
1421 DeleteDC( hdcMem );
1422 }
1423 /***********************************************************************
1424 * MENU_DrawMenuItem
1425 *
1426 * Draw a single menu item.
1427 */
1428 static void MENU_DrawMenuItem( HWND hwnd, POPUPMENU *menu, HWND hwndOwner, HDC hdc,
1429 MENUITEM *lpitem, BOOL menuBar, UINT odaction )
1430 {
1431 RECT rect, bmprc;
1432 BOOL flat_menu = FALSE;
1433 int bkgnd;
1434 UINT arrow_bitmap_width = 0, arrow_bitmap_height = 0;
1435 HRGN old_clip = NULL, clip;
1436
1437 debug_print_menuitem("MENU_DrawMenuItem: ", lpitem, "");
1438
1439 if (!menuBar) {
1440 BITMAP bmp;
1441 GetObjectW( get_arrow_bitmap(), sizeof(bmp), &bmp );
1442 arrow_bitmap_width = bmp.bmWidth;
1443 arrow_bitmap_height = bmp.bmHeight;
1444 }
1445
1446 if (lpitem->fType & MF_SYSMENU)
1447 {
1448 if( !IsIconic(hwnd) )
1449 NC_DrawSysButton( hwnd, hdc, lpitem->fState & (MF_HILITE | MF_MOUSESELECT) );
1450 return;
1451 }
1452
1453 TRACE( "rect=%s\n", wine_dbgstr_rect( &lpitem->rect ) );
1454 rect = lpitem->rect;
1455 MENU_AdjustMenuItemRect( menu, &rect );
1456 if (!IntersectRect( &bmprc, &rect, &menu->items_rect )) /* bmprc is used as a dummy */
1457 return;
1458
1459 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
1460 bkgnd = (menuBar && flat_menu) ? COLOR_MENUBAR : COLOR_MENU;
1461
1462 /* Setup colors */
1463
1464 if (lpitem->fState & MF_HILITE)
1465 {
1466 if(menuBar && !flat_menu) {
1467 SetTextColor(hdc, GetSysColor(COLOR_MENUTEXT));
1468 SetBkColor(hdc, GetSysColor(COLOR_MENU));
1469 } else {
1470 if(lpitem->fState & MF_GRAYED)
1471 SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
1472 else
1473 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1474 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1475 }
1476 }
1477 else
1478 {
1479 if (lpitem->fState & MF_GRAYED)
1480 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
1481 else
1482 SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
1483 SetBkColor( hdc, GetSysColor( bkgnd ) );
1484 }
1485
1486 old_clip = CreateRectRgn( 0, 0, 0, 0 );
1487 if (GetClipRgn( hdc, old_clip ) <= 0)
1488 {
1489 DeleteObject( old_clip );
1490 old_clip = NULL;
1491 }
1492 clip = CreateRectRgnIndirect( &menu->items_rect );
1493 ExtSelectClipRgn( hdc, clip, RGN_AND );
1494 DeleteObject( clip );
1495
1496 if (lpitem->fType & MF_OWNERDRAW)
1497 {
1498 /*
1499 ** Experimentation under Windows reveals that an owner-drawn
1500 ** menu is given the rectangle which includes the space it requested
1501 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
1502 ** and a popup-menu arrow. This is the value of lpitem->rect.
1503 ** Windows will leave all drawing to the application except for
1504 ** the popup-menu arrow. Windows always draws that itself, after
1505 ** the menu owner has finished drawing.
1506 */
1507 DRAWITEMSTRUCT dis;
1508 COLORREF old_bk, old_text;
1509
1510 dis.CtlType = ODT_MENU;
1511 dis.CtlID = 0;
1512 dis.itemID = lpitem->wID;
1513 dis.itemData = lpitem->dwItemData;
1514 dis.itemState = 0;
1515 if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
1516 if (lpitem->fState & MF_GRAYED) dis.itemState |= ODS_GRAYED|ODS_DISABLED;
1517 if (lpitem->fState & MF_HILITE) dis.itemState |= ODS_SELECTED;
1518 dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
1519 dis.hwndItem = (HWND)menu->obj.handle;
1520 dis.hDC = hdc;
1521 dis.rcItem = rect;
1522 TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
1523 "hwndItem=%p, hdc=%p, rcItem=%s\n", hwndOwner,
1524 dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
1525 dis.hDC, wine_dbgstr_rect( &dis.rcItem));
1526 old_bk = GetBkColor( hdc );
1527 old_text = GetTextColor( hdc );
1528 SendMessageW( hwndOwner, WM_DRAWITEM, 0, (LPARAM)&dis );
1529 /* Draw the popup-menu arrow */
1530 SetBkColor( hdc, old_bk );
1531 SetTextColor( hdc, old_text );
1532 if (lpitem->fType & MF_POPUP)
1533 draw_popup_arrow( hdc, rect, arrow_bitmap_width,
1534 arrow_bitmap_height);
1535 goto done;
1536 }
1537
1538 if (menuBar && (lpitem->fType & MF_SEPARATOR)) goto done;
1539
1540 if (lpitem->fState & MF_HILITE)
1541 {
1542 if (flat_menu)
1543 {
1544 InflateRect (&rect, -1, -1);
1545 FillRect(hdc, &rect, GetSysColorBrush(COLOR_MENUHILIGHT));
1546 InflateRect (&rect, 1, 1);
1547 FrameRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1548 }
1549 else
1550 {
1551 if(menuBar)
1552 DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
1553 else
1554 FillRect(hdc, &rect, GetSysColorBrush(COLOR_HIGHLIGHT));
1555 }
1556 }
1557 else
1558 FillRect( hdc, &rect, GetSysColorBrush(bkgnd) );
1559
1560 SetBkMode( hdc, TRANSPARENT );
1561
1562 /* vertical separator */
1563 if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
1564 {
1565 HPEN oldPen;
1566 RECT rc = rect;
1567
1568 rc.left -= MENU_COL_SPACE / 2 + 1;
1569 rc.top = 3;
1570 rc.bottom = menu->Height - 3;
1571 if (flat_menu)
1572 {
1573 oldPen = SelectObject( hdc, SYSCOLOR_GetPen(COLOR_BTNSHADOW) );
1574 MoveToEx( hdc, rc.left, rc.top, NULL );
1575 LineTo( hdc, rc.left, rc.bottom );
1576 SelectObject( hdc, oldPen );
1577 }
1578 else
1579 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
1580 }
1581
1582 /* horizontal separator */
1583 if (lpitem->fType & MF_SEPARATOR)
1584 {
1585 HPEN oldPen;
1586 RECT rc = rect;
1587
1588 InflateRect( &rc, -1, 0 );
1589 rc.top = ( rc.top + rc.bottom) / 2;
1590 if (flat_menu)
1591 {
1592 oldPen = SelectObject( hdc, SYSCOLOR_GetPen(COLOR_BTNSHADOW) );
1593 MoveToEx( hdc, rc.left, rc.top, NULL );
1594 LineTo( hdc, rc.right, rc.top );
1595 SelectObject( hdc, oldPen );
1596 }
1597 else
1598 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
1599 goto done;
1600 }
1601
1602 /* helper lines for debugging */
1603 /* FrameRect(hdc, &rect, GetStockObject(BLACK_BRUSH));
1604 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1605 MoveToEx( hdc, rect.left, (rect.top + rect.bottom)/2, NULL );
1606 LineTo( hdc, rect.right, (rect.top + rect.bottom)/2 );
1607 */
1608
1609 if (lpitem->hbmpItem) {
1610 /* calculate the bitmap rectangle in coordinates relative
1611 * to the item rectangle */
1612 if( menuBar) {
1613 if( lpitem->hbmpItem == HBMMENU_CALLBACK)
1614 bmprc.left = 3;
1615 else
1616 bmprc.left = lpitem->text ? menucharsize.cx : 0;
1617 }
1618 else if (menu->dwStyle & MNS_NOCHECK)
1619 bmprc.left = 4;
1620 else if (menu->dwStyle & MNS_CHECKORBMP)
1621 bmprc.left = 2;
1622 else
1623 bmprc.left = 4 + GetSystemMetrics(SM_CXMENUCHECK);
1624 bmprc.right = bmprc.left + lpitem->bmpsize.cx;
1625 if( menuBar && !(lpitem->hbmpItem == HBMMENU_CALLBACK))
1626 bmprc.top = 0;
1627 else
1628 bmprc.top = (rect.bottom - rect.top -
1629 lpitem->bmpsize.cy) / 2;
1630 bmprc.bottom = bmprc.top + lpitem->bmpsize.cy;
1631 }
1632
1633 if (!menuBar)
1634 {
1635 HBITMAP bm;
1636 INT y = rect.top + rect.bottom;
1637 BOOL checked = FALSE;
1638 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1639 UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1640 /* Draw the check mark
1641 *
1642 * FIXME:
1643 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1644 */
1645 if (!(menu->dwStyle & MNS_NOCHECK))
1646 {
1647 bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit :
1648 lpitem->hUnCheckBit;
1649 if (bm) /* we have a custom bitmap */
1650 {
1651 HDC hdcMem = CreateCompatibleDC( hdc );
1652
1653 SelectObject( hdcMem, bm );
1654 BitBlt( hdc, rect.left, (y - check_bitmap_height) / 2,
1655 check_bitmap_width, check_bitmap_height,
1656 hdcMem, 0, 0, SRCCOPY );
1657 DeleteDC( hdcMem );
1658 checked = TRUE;
1659 }
1660 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
1661 {
1662 RECT r;
1663 HBITMAP bm = CreateBitmap( check_bitmap_width,
1664 check_bitmap_height, 1, 1, NULL );
1665 HDC hdcMem = CreateCompatibleDC( hdc );
1666
1667 SelectObject( hdcMem, bm );
1668 SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height);
1669 DrawFrameControl( hdcMem, &r, DFC_MENU,
1670 (lpitem->fType & MFT_RADIOCHECK) ?
1671 DFCS_MENUBULLET : DFCS_MENUCHECK );
1672 BitBlt( hdc, rect.left, (y - r.bottom) / 2, r.right, r.bottom,
1673 hdcMem, 0, 0, SRCCOPY );
1674 DeleteDC( hdcMem );
1675 DeleteObject( bm );
1676 checked = TRUE;
1677 }
1678 }
1679 if (lpitem->hbmpItem && !(checked && (menu->dwStyle & MNS_CHECKORBMP)))
1680 {
1681 POINT origorg;
1682 /* some applications make this assumption on the DC's origin */
1683 SetViewportOrgEx( hdc, rect.left, rect.top, &origorg);
1684 MENU_DrawBitmapItem( hdc, lpitem, &bmprc, menu, hwndOwner, odaction );
1685 SetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1686 }
1687 /* Draw the popup-menu arrow */
1688 if (lpitem->fType & MF_POPUP)
1689 draw_popup_arrow( hdc, rect, arrow_bitmap_width,
1690 arrow_bitmap_height);
1691 rect.left += 4;
1692 if( !(menu->dwStyle & MNS_NOCHECK))
1693 rect.left += check_bitmap_width;
1694 rect.right -= arrow_bitmap_width;
1695 }
1696 else if (lpitem->hbmpItem)
1697 { /* Draw the bitmap */
1698 POINT origorg;
1699
1700 SetViewportOrgEx( hdc, rect.left, rect.top, &origorg);
1701 MENU_DrawBitmapItem( hdc, lpitem, &bmprc, menu, hwndOwner, odaction );
1702 SetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1703 }
1704 /* process text if present */
1705 if (lpitem->text)
1706 {
1707 int i;
1708 HFONT hfontOld = 0;
1709
1710 UINT uFormat = (menuBar) ?
1711 DT_CENTER | DT_VCENTER | DT_SINGLELINE :
1712 DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1713
1714 if( !(menu->dwStyle & MNS_CHECKORBMP))
1715 rect.left += menu->textOffset;
1716
1717 if ( lpitem->fState & MFS_DEFAULT )
1718 {
1719 hfontOld = SelectObject( hdc, get_menu_font(TRUE) );
1720 }
1721
1722 if (menuBar) {
1723 if( lpitem->hbmpItem)
1724 rect.left += lpitem->bmpsize.cx;
1725 if( !(lpitem->hbmpItem == HBMMENU_CALLBACK))
1726 rect.left += menucharsize.cx;
1727 rect.right -= menucharsize.cx;
1728 }
1729
1730 for (i = 0; lpitem->text[i]; i++)
1731 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1732 break;
1733
1734 if(lpitem->fState & MF_GRAYED)
1735 {
1736 if (!(lpitem->fState & MF_HILITE) )
1737 {
1738 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1739 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1740 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1741 --rect.left; --rect.top; --rect.right; --rect.bottom;
1742 }
1743 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1744 }
1745
1746 DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1747
1748 /* paint the shortcut text */
1749 if (!menuBar && lpitem->text[i]) /* There's a tab or flush-right char */
1750 {
1751 if (lpitem->text[i] == '\t')
1752 {
1753 rect.left = lpitem->xTab;
1754 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1755 }
1756 else
1757 {
1758 rect.right = lpitem->xTab;
1759 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1760 }
1761
1762 if(lpitem->fState & MF_GRAYED)
1763 {
1764 if (!(lpitem->fState & MF_HILITE) )
1765 {
1766 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1767 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1768 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1769 --rect.left; --rect.top; --rect.right; --rect.bottom;
1770 }
1771 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1772 }
1773 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1774 }
1775
1776 if (hfontOld)
1777 SelectObject (hdc, hfontOld);
1778 }
1779
1780 done:
1781 ExtSelectClipRgn( hdc, old_clip, RGN_COPY );
1782 if (old_clip) DeleteObject( old_clip );
1783 }
1784
1785
1786 /***********************************************************************
1787 * MENU_DrawPopupMenu
1788 *
1789 * Paint a popup menu.
1790 */
1791 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1792 {
1793 HBRUSH hPrevBrush, brush = GetSysColorBrush( COLOR_MENU );
1794 RECT rect;
1795 POPUPMENU *menu = MENU_GetMenu( hmenu );
1796
1797 TRACE("wnd=%p dc=%p menu=%p\n", hwnd, hdc, hmenu);
1798
1799 GetClientRect( hwnd, &rect );
1800
1801 if (menu && menu->hbrBack) brush = menu->hbrBack;
1802 if ((hPrevBrush = SelectObject( hdc, brush ))
1803 && SelectObject( hdc, get_menu_font(FALSE) ))
1804 {
1805 HPEN hPrevPen;
1806
1807 Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1808
1809 hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1810 if( hPrevPen )
1811 {
1812 BOOL flat_menu = FALSE;
1813
1814 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
1815 if (flat_menu)
1816 FrameRect(hdc, &rect, GetSysColorBrush(COLOR_BTNSHADOW));
1817 else
1818 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1819
1820 if (menu)
1821 {
1822 TRACE("hmenu %p Style %08x\n", hmenu, menu->dwStyle);
1823 /* draw menu items */
1824 if (menu->nItems)
1825 {
1826 MENUITEM *item;
1827 UINT u;
1828
1829 item = menu->items;
1830 for (u = menu->nItems; u > 0; u--, item++)
1831 MENU_DrawMenuItem( hwnd, menu, menu->hwndOwner, hdc,
1832 item, FALSE, ODA_DRAWENTIRE );
1833 }
1834 /* draw scroll arrows */
1835 if (menu->bScrolling)
1836 MENU_DrawScrollArrows(menu, hdc);
1837 }
1838 } else
1839 {
1840 SelectObject( hdc, hPrevBrush );
1841 }
1842 }
1843 }
1844
1845 /***********************************************************************
1846 * MENU_DrawMenuBar
1847 *
1848 * Paint a menu bar. Returns the height of the menu bar.
1849 * called from [windows/nonclient.c]
1850 */
1851 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd )
1852 {
1853 LPPOPUPMENU lppop;
1854 HMENU hMenu = GetMenu(hwnd);
1855
1856 lppop = MENU_GetMenu( hMenu );
1857 if (lppop == NULL || lprect == NULL)
1858 {
1859 return GetSystemMetrics(SM_CYMENU);
1860 }
1861
1862 return DrawMenuBarTemp(hwnd, hDC, lprect, hMenu, NULL);
1863 }
1864
1865
1866 /***********************************************************************
1867 * MENU_InitPopup
1868 *
1869 * Popup menu initialization before WM_ENTERMENULOOP.
1870 */
1871 static BOOL MENU_InitPopup( HWND hwndOwner, HMENU hmenu, UINT flags )
1872 {
1873 POPUPMENU *menu;
1874 DWORD ex_style = 0;
1875
1876 TRACE("owner=%p hmenu=%p\n", hwndOwner, hmenu);
1877
1878 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1879
1880 /* store the owner for DrawItem */
1881 if (!IsWindow( hwndOwner ))
1882 {
1883 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1884 return FALSE;
1885 }
1886 menu->hwndOwner = hwndOwner;
1887
1888 if (flags & TPM_LAYOUTRTL)
1889 ex_style = WS_EX_LAYOUTRTL;
1890
1891 /* NOTE: In Windows, top menu popup is not owned. */
1892 menu->hWnd = CreateWindowExW( ex_style, (LPCWSTR)POPUPMENU_CLASS_ATOM, NULL,
1893 WS_POPUP, 0, 0, 0, 0,
1894 hwndOwner, 0, (HINSTANCE)GetWindowLongPtrW(hwndOwner, GWLP_HINSTANCE),
1895 (LPVOID)hmenu );
1896 if( !menu->hWnd ) return FALSE;
1897 return TRUE;
1898 }
1899
1900
1901 /***********************************************************************
1902 * MENU_ShowPopup
1903 *
1904 * Display a popup menu.
1905 */
1906 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id, UINT flags,
1907 INT x, INT y, INT xanchor, INT yanchor )
1908 {
1909 POPUPMENU *menu;
1910 POINT pt;
1911 HMONITOR monitor;
1912 MONITORINFO info;
1913 UINT max_height;
1914
1915 TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1916 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1917
1918 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1919 if (menu->FocusedItem != NO_SELECTED_ITEM)
1920 {
1921 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1922 menu->FocusedItem = NO_SELECTED_ITEM;
1923 }
1924
1925 menu->nScrollPos = 0;
1926
1927 /* FIXME: should use item rect */
1928 pt.x = x;
1929 pt.y = y;
1930 monitor = MonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
1931 info.cbSize = sizeof(info);
1932 GetMonitorInfoW( monitor, &info );
1933
1934 max_height = info.rcWork.bottom - info.rcWork.top;
1935 if (menu->cyMax)
1936 max_height = min( max_height, menu->cyMax );
1937
1938 MENU_PopupMenuCalcSize( menu, max_height );
1939
1940 /* adjust popup menu pos so that it fits within the desktop */
1941
1942 if (flags & TPM_LAYOUTRTL)
1943 flags ^= TPM_RIGHTALIGN;
1944
1945 if( flags & TPM_RIGHTALIGN ) x -= menu->Width;
1946 if( flags & TPM_CENTERALIGN ) x -= menu->Width / 2;
1947
1948 if( flags & TPM_BOTTOMALIGN ) y -= menu->Height;
1949 if( flags & TPM_VCENTERALIGN ) y -= menu->Height / 2;
1950
1951 if( x + menu->Width > info.rcWork.right)
1952 {
1953 if( xanchor && x >= menu->Width - xanchor )
1954 x -= menu->Width - xanchor;
1955
1956 if( x + menu->Width > info.rcWork.right)
1957 x = info.rcWork.right - menu->Width;
1958 }
1959 if( x < info.rcWork.left ) x = info.rcWork.left;
1960
1961 if( y + menu->Height > info.rcWork.bottom)
1962 {
1963 if( yanchor && y >= menu->Height + yanchor )
1964 y -= menu->Height + yanchor;
1965
1966 if( y + menu->Height > info.rcWork.bottom)
1967 y = info.rcWork.bottom - menu->Height;
1968 }
1969 if( y < info.rcWork.top ) y = info.rcWork.top;
1970
1971 if (!top_popup) {
1972 top_popup = menu->hWnd;
1973 top_popup_hmenu = hmenu;
1974 }
1975 /* Display the window */
1976
1977 SetWindowPos( menu->hWnd, HWND_TOPMOST, x, y, menu->Width, menu->Height,
1978 SWP_SHOWWINDOW | SWP_NOACTIVATE );
1979 UpdateWindow( menu->hWnd );
1980 return TRUE;
1981 }
1982
1983
1984 /***********************************************************************
1985 * MENU_EnsureMenuItemVisible
1986 */
1987 static void
1988 MENU_EnsureMenuItemVisible(LPPOPUPMENU lppop, UINT wIndex, HDC hdc)
1989 {
1990 if (lppop->bScrolling)
1991 {
1992 MENUITEM *item = &lppop->items[wIndex];
1993 UINT nOldPos = lppop->nScrollPos;
1994 const RECT *rc = &lppop->items_rect;
1995 UINT scroll_height = rc->bottom - rc->top;
1996
1997 if (item->rect.bottom > lppop->nScrollPos + scroll_height)
1998 {
1999 lppop->nScrollPos = item->rect.bottom - scroll_height;
2000 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, rc, rc);
2001 }
2002 else if (item->rect.top < lppop->nScrollPos)
2003 {
2004 lppop->nScrollPos = item->rect.top;
2005 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, rc, rc);
2006 }
2007
2008 /* Invalidate the scroll arrows if necessary */
2009 if (nOldPos != lppop->nScrollPos)
2010 {
2011 RECT arrow_rect = lppop->items_rect;
2012 if (nOldPos == 0 || lppop->nScrollPos == 0)
2013 {
2014 arrow_rect.top = 0;
2015 arrow_rect.bottom = lppop->items_rect.top;
2016 InvalidateRect(lppop->hWnd, &arrow_rect, FALSE);
2017 }
2018 if (nOldPos + scroll_height == lppop->nTotalHeight ||
2019 lppop->nScrollPos + scroll_height == lppop->nTotalHeight)
2020 {
2021 arrow_rect.top = lppop->items_rect.bottom;
2022 arrow_rect.bottom = lppop->Height;
2023 InvalidateRect(lppop->hWnd, &arrow_rect, FALSE);
2024 }
2025 }
2026 }
2027 }
2028
2029
2030 /***********************************************************************
2031 * MENU_SelectItem
2032 */
2033 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
2034 BOOL sendMenuSelect, HMENU topmenu )
2035 {
2036 LPPOPUPMENU lppop;
2037 HDC hdc;
2038
2039 TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
2040
2041 lppop = MENU_GetMenu( hmenu );
2042 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
2043
2044 if (lppop->FocusedItem == wIndex) return;
2045 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
2046 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2047 if (!top_popup) {
2048 top_popup = lppop->hWnd;
2049 top_popup_hmenu = hmenu;
2050 }
2051
2052 SelectObject( hdc, get_menu_font(FALSE));
2053
2054 /* Clear previous highlighted item */
2055 if (lppop->FocusedItem != NO_SELECTED_ITEM)
2056 {
2057 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
2058 MENU_DrawMenuItem( lppop->hWnd, lppop, hwndOwner, hdc, &lppop->items[lppop->FocusedItem],
2059 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
2060 }
2061
2062 /* Highlight new item (if any) */
2063 lppop->FocusedItem = wIndex;
2064 if (lppop->FocusedItem != NO_SELECTED_ITEM)
2065 {
2066 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
2067 lppop->items[wIndex].fState |= MF_HILITE;
2068 MENU_EnsureMenuItemVisible(lppop, wIndex, hdc);
2069 MENU_DrawMenuItem( lppop->hWnd, lppop, hwndOwner, hdc, &lppop->items[wIndex],
2070 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
2071 }
2072 if (sendMenuSelect)
2073 {
2074 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
2075 SendMessageW( hwndOwner, WM_MENUSELECT,
2076 MAKEWPARAM(ip->fType & MF_POPUP ? wIndex: ip->wID,
2077 ip->fType | ip->fState |
2078 (lppop->wFlags & MF_SYSMENU)), (LPARAM)hmenu);
2079 }
2080 }
2081 else if (sendMenuSelect) {
2082 if(topmenu){
2083 int pos;
2084 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
2085 POPUPMENU *ptm = MENU_GetMenu( topmenu );
2086 MENUITEM *ip = &ptm->items[pos];
2087 SendMessageW( hwndOwner, WM_MENUSELECT, MAKEWPARAM(pos,
2088 ip->fType | ip->fState |
2089 (ptm->wFlags & MF_SYSMENU)), (LPARAM)topmenu);
2090 }
2091 }
2092 }
2093 ReleaseDC( lppop->hWnd, hdc );
2094 }
2095
2096
2097 /***********************************************************************
2098 * MENU_MoveSelection
2099 *
2100 * Moves currently selected item according to the offset parameter.
2101 * If there is no selection then it should select the last item if
2102 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
2103 */
2104 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
2105 {
2106 INT i;
2107 POPUPMENU *menu;
2108
2109 TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner, hmenu, offset);
2110
2111 menu = MENU_GetMenu( hmenu );
2112 if ((!menu) || (!menu->items)) return;
2113
2114 if ( menu->FocusedItem != NO_SELECTED_ITEM )
2115 {
2116 if( menu->nItems == 1 ) return; else
2117 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
2118 ; i += offset)
2119 if (!(menu->items[i].fType & MF_SEPARATOR))
2120 {
2121 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
2122 return;
2123 }
2124 }
2125
2126 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
2127 i >= 0 && i < menu->nItems ; i += offset)
2128 if (!(menu->items[i].fType & MF_SEPARATOR))
2129 {
2130 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
2131 return;
2132 }
2133 }
2134
2135
2136 /**********************************************************************
2137 * insert_menu_item
2138 *
2139 * Insert (allocate) a new item into a menu.
2140 */
2141 static POPUPMENU *insert_menu_item(HMENU hMenu, UINT id, UINT flags, UINT *ret_pos)
2142 {
2143 MENUITEM *newItems;
2144 POPUPMENU *menu;
2145 UINT pos = id;
2146
2147 /* Find where to insert new item */
2148 if (!(menu = find_menu_item(hMenu, id, flags, &pos)))
2149 {
2150 if (!(menu = grab_menu_ptr(hMenu)))
2151 return NULL;
2152 pos = menu->nItems;
2153 }
2154
2155 /* Make sure that MDI system buttons stay on the right side.
2156 * Note: XP treats only bitmap handles 1 - 6 as "magic" ones
2157 * regardless of their id.
2158 */
2159 while (pos > 0 && (INT_PTR)menu->items[pos - 1].hbmpItem >= (INT_PTR)HBMMENU_SYSTEM &&
2160 (INT_PTR)menu->items[pos - 1].hbmpItem <= (INT_PTR)HBMMENU_MBAR_CLOSE_D)
2161 pos--;
2162
2163 TRACE("inserting at %u flags %x\n", pos, flags);
2164
2165 /* Create new items array */
2166
2167 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
2168 if (!newItems)
2169 {
2170 release_menu_ptr(menu);
2171 WARN("allocation failed\n" );
2172 return NULL;
2173 }
2174 if (menu->nItems > 0)
2175 {
2176 /* Copy the old array into the new one */
2177 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
2178 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
2179 (menu->nItems-pos)*sizeof(MENUITEM) );
2180 HeapFree( GetProcessHeap(), 0, menu->items );
2181 }
2182 menu->items = newItems;
2183 menu->nItems++;
2184 memset( &newItems[pos], 0, sizeof(*newItems) );
2185 menu->Height = 0; /* force size recalculate */
2186
2187 *ret_pos = pos;
2188 return menu;
2189 }
2190
2191
2192 /**********************************************************************
2193 * MENU_ParseResource
2194 *
2195 * Parse a standard menu resource and add items to the menu.
2196 * Return a pointer to the end of the resource.
2197 *
2198 * NOTE: flags is equivalent to the mtOption field
2199 */
2200 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu )
2201 {
2202 WORD flags, id = 0;
2203 LPCWSTR str;
2204 BOOL end_flag;
2205
2206 do
2207 {
2208 flags = GET_WORD(res);
2209 end_flag = flags & MF_END;
2210 /* Remove MF_END because it has the same value as MF_HILITE */
2211 flags &= ~MF_END;
2212 res += sizeof(WORD);
2213 if (!(flags & MF_POPUP))
2214 {
2215 id = GET_WORD(res);
2216 res += sizeof(WORD);
2217 }
2218 str = (LPCWSTR)res;
2219 res += (strlenW(str) + 1) * sizeof(WCHAR);
2220 if (flags & MF_POPUP)
2221 {
2222 HMENU hSubMenu = CreatePopupMenu();
2223 if (!hSubMenu) return NULL;
2224 if (!(res = MENU_ParseResource( res, hSubMenu ))) return NULL;
2225 AppendMenuW( hMenu, flags, (UINT_PTR)hSubMenu, str );
2226 }
2227 else /* Not a popup */
2228 {
2229 AppendMenuW( hMenu, flags, id, *str ? str : NULL );
2230 }
2231 } while (!end_flag);
2232 return res;
2233 }
2234
2235
2236 /**********************************************************************
2237 * MENUEX_ParseResource
2238 *
2239 * Parse an extended menu resource and add items to the menu.
2240 * Return a pointer to the end of the resource.
2241 */
2242 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
2243 {
2244 WORD resinfo;
2245 do {
2246 MENUITEMINFOW mii;
2247
2248 mii.cbSize = sizeof(mii);
2249 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
2250 mii.fType = GET_DWORD(res);
2251 res += sizeof(DWORD);
2252 mii.fState = GET_DWORD(res);
2253 res += sizeof(DWORD);
2254 mii.wID = GET_DWORD(res);
2255 res += sizeof(DWORD);
2256 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
2257 res += sizeof(WORD);
2258 /* Align the text on a word boundary. */
2259 res += (~((UINT_PTR)res - 1)) & 1;
2260 mii.dwTypeData = (LPWSTR) res;
2261 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
2262 /* Align the following fields on a dword boundary. */
2263 res += (~((UINT_PTR)res - 1)) & 3;
2264
2265 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
2266 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
2267
2268 if (resinfo & 1) { /* Pop-up? */
2269 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
2270 res += sizeof(DWORD);
2271 mii.hSubMenu = CreatePopupMenu();
2272 if (!mii.hSubMenu)
2273 return NULL;
2274 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
2275 DestroyMenu(mii.hSubMenu);
2276 return NULL;
2277 }
2278 mii.fMask |= MIIM_SUBMENU;
2279 mii.fType |= MF_POPUP;
2280 }
2281 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
2282 {
2283 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
2284 mii.wID, mii.fType);
2285 mii.fType |= MF_SEPARATOR;
2286 }
2287 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
2288 } while (!(resinfo & MF_END));
2289 return res;
2290 }
2291
2292
2293 /***********************************************************************
2294 * MENU_GetSubPopup
2295 *
2296 * Return the handle of the selected sub-popup menu (if any).
2297 */
2298 static HMENU MENU_GetSubPopup( HMENU hmenu )
2299 {
2300 POPUPMENU *menu;
2301 MENUITEM *item;
2302
2303 menu = MENU_GetMenu( hmenu );
2304
2305 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2306
2307 item = &menu->items[menu->FocusedItem];
2308 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2309 return item->hSubMenu;
2310 return 0;
2311 }
2312
2313
2314 /***********************************************************************
2315 * MENU_HideSubPopups
2316 *
2317 * Hide the sub-popup menus of this menu.
2318 */
2319 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2320 BOOL sendMenuSelect, UINT wFlags )
2321 {
2322 POPUPMENU *menu = MENU_GetMenu( hmenu );
2323
2324 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2325
2326 if (menu && top_popup)
2327 {
2328 HMENU hsubmenu;
2329 POPUPMENU *submenu;
2330 MENUITEM *item;
2331
2332 if (menu->FocusedItem != NO_SELECTED_ITEM)
2333 {
2334 item = &menu->items[menu->FocusedItem];
2335 if (!(item->fType & MF_POPUP) ||
2336 !(item->fState & MF_MOUSESELECT)) return;
2337 item->fState &= ~MF_MOUSESELECT;
2338 hsubmenu = item->hSubMenu;
2339 } else return;
2340
2341 if (!(submenu = MENU_GetMenu( hsubmenu ))) return;
2342 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE, wFlags );
2343 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2344 DestroyWindow( submenu->hWnd );
2345 submenu->hWnd = 0;
2346
2347 if (!(wFlags & TPM_NONOTIFY))
2348 SendMessageW( hwndOwner, WM_UNINITMENUPOPUP, (WPARAM)hsubmenu,
2349 MAKELPARAM(0, IS_SYSTEM_MENU(submenu)) );
2350 }
2351 }
2352
2353
2354 /***********************************************************************
2355 * MENU_ShowSubPopup
2356 *
2357 * Display the sub-menu of the selected item of this menu.
2358 * Return the handle of the submenu, or hmenu if no submenu to display.
2359 */
2360 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2361 BOOL selectFirst, UINT wFlags )
2362 {
2363 RECT rect;
2364 POPUPMENU *menu;
2365 MENUITEM *item;
2366 HDC hdc;
2367
2368 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, selectFirst);
2369
2370 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2371
2372 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2373
2374 item = &menu->items[menu->FocusedItem];
2375 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2376 return hmenu;
2377
2378 /* message must be sent before using item,
2379 because nearly everything may be changed by the application ! */
2380
2381 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2382 if (!(wFlags & TPM_NONOTIFY))
2383 SendMessageW( hwndOwner, WM_INITMENUPOPUP, (WPARAM)item->hSubMenu,
2384 MAKELPARAM( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2385
2386 item = &menu->items[menu->FocusedItem];
2387 rect = item->rect;
2388
2389 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2390 if (!(item->fState & MF_HILITE))
2391 {
2392 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2393 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2394
2395 SelectObject( hdc, get_menu_font(FALSE));
2396
2397 item->fState |= MF_HILITE;
2398 MENU_DrawMenuItem( menu->hWnd, menu, hwndOwner, hdc, item, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2399 ReleaseDC( menu->hWnd, hdc );
2400 }
2401 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2402 item->rect = rect;
2403
2404 item->fState |= MF_MOUSESELECT;
2405
2406 if (IS_SYSTEM_MENU(menu))
2407 {
2408 MENU_InitSysMenuPopup(item->hSubMenu,
2409 GetWindowLongW( menu->hWnd, GWL_STYLE ),
2410 GetClassLongW( menu->hWnd, GCL_STYLE));
2411
2412 NC_GetSysPopupPos( menu->hWnd, &rect );
2413 if (wFlags & TPM_LAYOUTRTL) rect.left = rect.right;
2414 rect.top = rect.bottom;
2415 rect.right = GetSystemMetrics(SM_CXSIZE);
2416 rect.bottom = GetSystemMetrics(SM_CYSIZE);
2417 }
2418 else
2419 {
2420 RECT item_rect = item->rect;
2421
2422 MENU_AdjustMenuItemRect(menu, &item_rect);
2423 GetWindowRect( menu->hWnd, &rect );
2424
2425 if (menu->wFlags & MF_POPUP)
2426 {
2427 /* The first item in the popup menu has to be at the
2428 same y position as the focused menu item */
2429 if (wFlags & TPM_LAYOUTRTL)
2430 rect.left += GetSystemMetrics(SM_CXBORDER);
2431 else
2432 rect.left += item_rect.right - GetSystemMetrics(SM_CXBORDER);
2433 rect.top += item_rect.top - MENU_MARGIN;
2434 rect.right = item_rect.left - item_rect.right + GetSystemMetrics(SM_CXBORDER);
2435 rect.bottom = item_rect.top - item_rect.bottom - 2 * MENU_MARGIN;
2436 }
2437 else
2438 {
2439 if (wFlags & TPM_LAYOUTRTL)
2440 rect.left = rect.right - item_rect.left;
2441 else
2442 rect.left += item_rect.left;
2443 rect.top += item_rect.bottom;
2444 rect.right = item_rect.right - item_rect.left;
2445 rect.bottom = item_rect.bottom - item_rect.top;
2446 }
2447 }
2448
2449 /* use default alignment for submenus */
2450 wFlags &= ~(TPM_CENTERALIGN | TPM_RIGHTALIGN | TPM_VCENTERALIGN | TPM_BOTTOMALIGN);
2451
2452 MENU_InitPopup( hwndOwner, item->hSubMenu, wFlags );
2453
2454 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem, wFlags,
2455 rect.left, rect.top, rect.right, rect.bottom );
2456 if (selectFirst)
2457 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2458 return item->hSubMenu;
2459 }
2460
2461
2462
2463 /**********************************************************************
2464 * MENU_IsMenuActive
2465 */
2466 HWND MENU_IsMenuActive(void)
2467 {
2468 return top_popup;
2469 }
2470
2471 /**********************************************************************
2472 * MENU_EndMenu
2473 *
2474 * Calls EndMenu() if the hwnd parameter belongs to the menu owner
2475 *
2476 * Does the (menu stuff) of the default window handling of WM_CANCELMODE
2477 */
2478 void MENU_EndMenu( HWND hwnd )
2479 {
2480 POPUPMENU *menu;
2481 menu = top_popup_hmenu ? MENU_GetMenu( top_popup_hmenu ) : NULL;
2482 if (menu && (hwnd == menu->hWnd || hwnd == menu->hwndOwner)) EndMenu();
2483 }
2484
2485 /***********************************************************************
2486 * MENU_PtMenu
2487 *
2488 * Walks menu chain trying to find a menu pt maps to.
2489 */
2490 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2491 {
2492 POPUPMENU *menu = MENU_GetMenu( hMenu );
2493 UINT item = menu->FocusedItem;
2494 HMENU ret;
2495
2496 /* try subpopup first (if any) */
2497 ret = (item != NO_SELECTED_ITEM &&
2498 (menu->items[item].fType & MF_POPUP) &&
2499 (menu->items[item].fState & MF_MOUSESELECT))
2500 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2501
2502 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2503 {
2504 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2505 if( menu->wFlags & MF_POPUP )
2506 {
2507 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2508 }
2509 else if (ht == HTSYSMENU)
2510 ret = get_win_sys_menu( menu->hWnd );
2511 else if (ht == HTMENU)
2512 ret = GetMenu( menu->hWnd );
2513 }
2514 return ret;
2515 }
2516
2517 /***********************************************************************
2518 * MENU_ExecFocusedItem
2519 *
2520 * Execute a menu item (for instance when user pressed Enter).
2521 * Return the wID of the executed item. Otherwise, -1 indicating
2522 * that no menu item was executed, -2 if a popup is shown;
2523 * Have to receive the flags for the TrackPopupMenu options to avoid
2524 * sending unwanted message.
2525 *
2526 */
2527 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2528 {
2529 MENUITEM *item;
2530 POPUPMENU *menu = MENU_GetMenu( hMenu );
2531
2532 TRACE("%p hmenu=%p\n", pmt, hMenu);
2533
2534 if (!menu || !menu->nItems ||
2535 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2536
2537 item = &menu->items[menu->FocusedItem];
2538
2539 TRACE("hMenu %p wID %08lx hSubMenu %p fType %04x\n", hMenu, item->wID, item->hSubMenu, item->fType);
2540
2541 if (!(item->fType & MF_POPUP))
2542 {
2543 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2544 {
2545 /* If TPM_RETURNCMD is set you return the id, but
2546 do not send a message to the owner */
2547 if(!(wFlags & TPM_RETURNCMD))
2548 {
2549 if( menu->wFlags & MF_SYSMENU )
2550 PostMessageW( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2551 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2552 else
2553 {
2554 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2555 DWORD dwStyle = menu->dwStyle | (topmenu ? topmenu->dwStyle : 0);
2556
2557 if (dwStyle & MNS_NOTIFYBYPOS)
2558 PostMessageW( pmt->hOwnerWnd, WM_MENUCOMMAND, menu->FocusedItem,
2559 (LPARAM)hMenu);
2560 else
2561 PostMessageW( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2562 }
2563 }
2564 return item->wID;
2565 }
2566 }
2567 else
2568 {
2569 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2570 return -2;
2571 }
2572
2573 return -1;
2574 }
2575
2576 /***********************************************************************
2577 * MENU_SwitchTracking
2578 *
2579 * Helper function for menu navigation routines.
2580 */
2581 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id, UINT wFlags )
2582 {
2583 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2584 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2585
2586 TRACE("%p hmenu=%p 0x%04x\n", pmt, hPtMenu, id);
2587
2588 if( pmt->hTopMenu != hPtMenu &&
2589 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2590 {
2591 /* both are top level menus (system and menu-bar) */
2592 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
2593 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2594 pmt->hTopMenu = hPtMenu;
2595 }
2596 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2597 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2598 }
2599
2600
2601 /***********************************************************************
2602 * MENU_ButtonDown
2603 *
2604 * Return TRUE if we can go on with menu tracking.
2605 */
2606 static BOOL MENU_ButtonDown( MTRACKER* pmt, UINT message, HMENU hPtMenu, UINT wFlags )
2607 {
2608 TRACE("%p hPtMenu=%p\n", pmt, hPtMenu);
2609
2610 if (hPtMenu)
2611 {
2612 UINT pos;
2613 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2614 enum hittest ht = ht_item;
2615
2616 if( IS_SYSTEM_MENU(ptmenu) )
2617 {
2618 if (message == WM_LBUTTONDBLCLK) return FALSE;
2619 pos = 0;
2620 }
2621 else
2622 ht = MENU_FindItemByCoords( ptmenu, pmt->pt, &pos );
2623
2624 if (pos != NO_SELECTED_ITEM)
2625 {
2626 if (ptmenu->FocusedItem != pos)
2627 MENU_SwitchTracking( pmt, hPtMenu, pos, wFlags );
2628
2629 /* If the popup menu is not already "popped" */
2630 if (!(ptmenu->items[pos].fState & MF_MOUSESELECT))
2631 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2632 }
2633
2634 /* A click on an item or anywhere on a popup keeps tracking going */
2635 if (ht == ht_item || ((ptmenu->wFlags & MF_POPUP) && ht != ht_nowhere))
2636 return TRUE;
2637 }
2638 return FALSE;
2639 }
2640
2641 /***********************************************************************
2642 * MENU_ButtonUp
2643 *
2644 * Return the value of MENU_ExecFocusedItem if
2645 * the selected item was not a popup. Else open the popup.
2646 * A -1 return value indicates that we go on with menu tracking.
2647 *
2648 */
2649 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2650 {
2651 TRACE("%p hmenu=%p\n", pmt, hPtMenu);
2652
2653 if (hPtMenu)
2654 {
2655 UINT pos;
2656 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2657
2658 if( IS_SYSTEM_MENU(ptmenu) )
2659 pos = 0;
2660 else if (MENU_FindItemByCoords( ptmenu, pmt->pt, &pos ) != ht_item)
2661 pos = NO_SELECTED_ITEM;
2662
2663 if (pos != NO_SELECTED_ITEM && (ptmenu->FocusedItem == pos))
2664 {
2665 debug_print_menuitem ("FocusedItem: ", &ptmenu->items[pos], "");
2666
2667 if (!(ptmenu->items[pos].fType & MF_POPUP))
2668 {
2669 INT executedMenuId = MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2670 if (executedMenuId == -1 || executedMenuId == -2) return -1;
2671 return executedMenuId;
2672 }
2673
2674 /* If we are dealing with the menu bar */
2675 /* and this is a click on an already "popped" item: */
2676 /* Stop the menu tracking and close the opened submenus */
2677 if(((pmt->hTopMenu == hPtMenu) || IS_SYSTEM_MENU(ptmenu)) && (pmt->trackFlags & TF_RCVD_BTN_UP))
2678 return 0;
2679 }
2680 if( GetMenu(ptmenu->hWnd) == hPtMenu || IS_SYSTEM_MENU(ptmenu) )
2681 {
2682 if (pos == NO_SELECTED_ITEM) return 0;
2683 pmt->trackFlags |= TF_RCVD_BTN_UP;
2684 }
2685 }
2686 return -1;
2687 }
2688
2689
2690 /***********************************************************************
2691 * MENU_MouseMove
2692 *
2693 * Return TRUE if we can go on with menu tracking.
2694 */
2695 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2696 {
2697 UINT id = NO_SELECTED_ITEM;
2698 POPUPMENU *ptmenu = NULL;
2699
2700 if( hPtMenu )
2701 {
2702 ptmenu = MENU_GetMenu( hPtMenu );
2703 if( IS_SYSTEM_MENU(ptmenu) )
2704 id = 0;
2705 else if (MENU_FindItemByCoords( ptmenu, pmt->pt, &id ) != ht_item)
2706 id = NO_SELECTED_ITEM;
2707 }
2708
2709 if( id == NO_SELECTED_ITEM )
2710 {
2711 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2712 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2713
2714 }
2715 else if( ptmenu->FocusedItem != id )
2716 {
2717 MENU_SwitchTracking( pmt, hPtMenu, id, wFlags );
2718 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2719 }
2720 return TRUE;
2721 }
2722
2723
2724 /***********************************************************************
2725 * MENU_DoNextMenu
2726 *
2727 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2728 */
2729 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk, UINT wFlags )
2730 {
2731 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2732 BOOL atEnd = FALSE;
2733
2734 /* When skipping left, we need to do something special after the
2735 first menu. */
2736 if (vk == VK_LEFT && menu->FocusedItem == 0)
2737 {
2738 atEnd = TRUE;
2739 }
2740 /* When skipping right, for the non-system menu, we need to
2741 handle the last non-special menu item (ie skip any window
2742 icons such as MDI maximize, restore or close) */
2743 else if ((vk == VK_RIGHT) && !IS_SYSTEM_MENU(menu))
2744 {
2745 UINT i = menu->FocusedItem + 1;
2746 while (i < menu->nItems) {
2747 if ((menu->items[i].wID >= SC_SIZE &&
2748 menu->items[i].wID <= SC_RESTORE)) {
2749 i++;
2750 } else break;
2751 }
2752 if (i == menu->nItems) {
2753 atEnd = TRUE;
2754 }
2755 }
2756 /* When skipping right, we need to cater for the system menu */
2757 else if ((vk == VK_RIGHT) && IS_SYSTEM_MENU(menu))
2758 {
2759 if (menu->FocusedItem == (menu->nItems - 1)) {
2760 atEnd = TRUE;
2761 }
2762 }
2763
2764 if( atEnd )
2765 {
2766 MDINEXTMENU next_menu;
2767 HMENU hNewMenu;
2768 HWND hNewWnd;
2769 UINT id = 0;
2770
2771 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2772 next_menu.hmenuNext = 0;
2773 next_menu.hwndNext = 0;
2774 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2775
2776 TRACE("%p [%p] -> %p [%p]\n",
2777 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2778
2779 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2780 {
2781 DWORD style = GetWindowLongW( pmt->hOwnerWnd, GWL_STYLE );
2782 hNewWnd = pmt->hOwnerWnd;
2783 if( IS_SYSTEM_MENU(menu) )
2784 {
2785 /* switch to the menu bar */
2786
2787 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2788
2789 if( vk == VK_LEFT )
2790 {
2791 menu = MENU_GetMenu( hNewMenu );
2792 id = menu->nItems - 1;
2793
2794 /* Skip backwards over any system predefined icons,
2795 eg. MDI close, restore etc icons */
2796 while ((id > 0) &&
2797 (menu->items[id].wID >= SC_SIZE &&
2798 menu->items[id].wID <= SC_RESTORE)) id--;
2799 }
2800 }
2801 else if (style & WS_SYSMENU )
2802 {
2803 /* switch to the system menu */
2804 hNewMenu = get_win_sys_menu( hNewWnd );
2805 }
2806 else return FALSE;
2807 }
2808 else /* application returned a new menu to switch to */
2809 {
2810 hNewMenu = next_menu.hmenuNext;
2811 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2812
2813 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2814 {
2815 DWORD style = GetWindowLongW( hNewWnd, GWL_STYLE );
2816
2817 if (style & WS_SYSMENU &&
2818 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2819 {
2820 /* get the real system menu */
2821 hNewMenu = get_win_sys_menu(hNewWnd);
2822 }
2823 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2824 {
2825 /* FIXME: Not sure what to do here;
2826 * perhaps try to track hNewMenu as a popup? */
2827
2828 TRACE(" -- got confused.\n");
2829 return FALSE;
2830 }
2831 }
2832 else return FALSE;
2833 }
2834
2835 if( hNewMenu != pmt->hTopMenu )
2836 {
2837 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2838 FALSE, 0 );
2839 if( pmt->hCurrentMenu != pmt->hTopMenu )
2840 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
2841 }
2842
2843 if( hNewWnd != pmt->hOwnerWnd )
2844 {
2845 pmt->hOwnerWnd = hNewWnd;
2846 set_capture_window( pmt->hOwnerWnd, GUI_INMENUMODE, NULL );
2847 }
2848
2849 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2850 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2851
2852 return TRUE;
2853 }
2854 return FALSE;
2855 }
2856
2857 /***********************************************************************
2858 * MENU_SuspendPopup
2859 *
2860 * The idea is not to show the popup if the next input message is
2861 * going to hide it anyway.
2862 */
2863 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT uMsg )
2864 {
2865 MSG msg;
2866
2867 msg.hwnd = pmt->hOwnerWnd;
2868
2869 PeekMessageW( &msg, 0, uMsg, uMsg, PM_NOYIELD | PM_REMOVE);
2870 pmt->trackFlags |= TF_SKIPREMOVE;
2871
2872 switch( uMsg )
2873 {
2874 case WM_KEYDOWN:
2875 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2876 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2877 {
2878 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2879 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2880 if( msg.message == WM_KEYDOWN &&
2881 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2882 {
2883 pmt->trackFlags |= TF_SUSPENDPOPUP;
2884 return TRUE;
2885 }
2886 }
2887 break;
2888 }
2889
2890 /* failures go through this */
2891 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2892 return FALSE;
2893 }
2894
2895 /***********************************************************************
2896 * MENU_KeyEscape
2897 *
2898 * Handle a VK_ESCAPE key event in a menu.
2899 */
2900 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2901 {
2902 BOOL bEndMenu = TRUE;
2903
2904 if (pmt->hCurrentMenu != pmt->hTopMenu)
2905 {
2906 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2907
2908 if (menu->wFlags & MF_POPUP)
2909 {
2910 HMENU hmenutmp, hmenuprev;
2911
2912 hmenuprev = hmenutmp = pmt->hTopMenu;
2913
2914 /* close topmost popup */
2915 while (hmenutmp != pmt->hCurrentMenu)
2916 {
2917 hmenuprev = hmenutmp;
2918 hmenutmp = MENU_GetSubPopup( hmenuprev );
2919 }
2920
2921 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE, wFlags );
2922 pmt->hCurrentMenu = hmenuprev;
2923 bEndMenu = FALSE;
2924 }
2925 }
2926
2927 return bEndMenu;
2928 }
2929
2930 /***********************************************************************
2931 * MENU_KeyLeft
2932 *
2933 * Handle a VK_LEFT key event in a menu.
2934 */
2935 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags, UINT msg )
2936 {
2937 POPUPMENU *menu;
2938 HMENU hmenutmp, hmenuprev;
2939 UINT prevcol;
2940
2941 hmenuprev = hmenutmp = pmt->hTopMenu;
2942 menu = MENU_GetMenu( hmenutmp );
2943
2944 /* Try to move 1 column left (if possible) */
2945 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2946 NO_SELECTED_ITEM ) {
2947
2948 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2949 prevcol, TRUE, 0 );
2950 return;
2951 }
2952
2953 /* close topmost popup */
2954 while (hmenutmp != pmt->hCurrentMenu)
2955 {
2956 hmenuprev = hmenutmp;
2957 hmenutmp = MENU_GetSubPopup( hmenuprev );
2958 }
2959
2960 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE, wFlags );
2961 pmt->hCurrentMenu = hmenuprev;
2962
2963 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2964 {
2965 /* move menu bar selection if no more popups are left */
2966
2967 if( !MENU_DoNextMenu( pmt, VK_LEFT, wFlags ) )
2968 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2969
2970 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2971 {
2972 /* A sublevel menu was displayed - display the next one
2973 * unless there is another displacement coming up */
2974
2975 if( !MENU_SuspendPopup( pmt, msg ) )
2976 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2977 pmt->hTopMenu, TRUE, wFlags);
2978 }
2979 }
2980 }
2981
2982
2983 /***********************************************************************
2984 * MENU_KeyRight
2985 *
2986 * Handle a VK_RIGHT key event in a menu.
2987 */
2988 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags, UINT msg )
2989 {
2990 HMENU hmenutmp;
2991 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2992 UINT nextcol;
2993
2994 TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2995 pmt->hCurrentMenu,
2996 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->items[0].text),
2997 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2998
2999 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
3000 {
3001 /* If already displaying a popup, try to display sub-popup */
3002
3003 hmenutmp = pmt->hCurrentMenu;
3004 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
3005
3006 /* if subpopup was displayed then we are done */
3007 if (hmenutmp != pmt->hCurrentMenu) return;
3008 }
3009
3010 /* Check to see if there's another column */
3011 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
3012 NO_SELECTED_ITEM ) {
3013 TRACE("Going to %d.\n", nextcol );
3014 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
3015 nextcol, TRUE, 0 );
3016 return;
3017 }
3018
3019 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
3020 {
3021 if( pmt->hCurrentMenu != pmt->hTopMenu )
3022 {
3023 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
3024 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
3025 } else hmenutmp = 0;
3026
3027 /* try to move to the next item */
3028 if( !MENU_DoNextMenu( pmt, VK_RIGHT, wFlags ) )
3029 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
3030
3031 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
3032 if( !MENU_SuspendPopup( pmt, msg ) )
3033 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
3034 pmt->hTopMenu, TRUE, wFlags);
3035 }
3036 }
3037
3038 static void CALLBACK release_capture( BOOL __normal )
3039 {
3040 set_capture_window( 0, GUI_INMENUMODE, NULL );
3041 }
3042
3043 /***********************************************************************
3044 * MENU_TrackMenu
3045 *
3046 * Menu tracking code.
3047 */
3048 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
3049 HWND hwnd, const RECT *lprect )
3050 {
3051 MSG msg;
3052 POPUPMENU *menu;
3053 BOOL fRemove;
3054 INT executedMenuId = -1;
3055 MTRACKER mt;
3056 BOOL enterIdleSent = FALSE;
3057 HWND capture_win;
3058
3059 mt.trackFlags = 0;
3060 mt.hCurrentMenu = hmenu;
3061 mt.hTopMenu = hmenu;
3062 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
3063 mt.pt.x = x;
3064 mt.pt.y = y;
3065
3066 TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p %s\n",
3067 hmenu, wFlags, x, y, hwnd, wine_dbgstr_rect( lprect));
3068
3069 if (!(menu = MENU_GetMenu( hmenu )))
3070 {
3071 WARN("Invalid menu handle %p\n", hmenu);
3072 SetLastError(ERROR_INVALID_MENU_HANDLE);
3073 return FALSE;
3074 }
3075
3076 if (wFlags & TPM_BUTTONDOWN)
3077 {
3078 /* Get the result in order to start the tracking or not */
3079 fRemove = MENU_ButtonDown( &mt, WM_LBUTTONDOWN, hmenu, wFlags );
3080 fEndMenu = !fRemove;
3081 }
3082
3083 if (wFlags & TF_ENDMENU) fEndMenu = TRUE;
3084
3085 /* owner may not be visible when tracking a popup, so use the menu itself */
3086 capture_win = (wFlags & TPM_POPUPMENU) ? menu->hWnd : mt.hOwnerWnd;
3087 set_capture_window( capture_win, GUI_INMENUMODE, NULL );
3088
3089 if ((wFlags & TPM_POPUPMENU) && menu->nItems == 0)
3090 return FALSE;
3091
3092 __TRY while (!fEndMenu)
3093 {
3094 menu = MENU_GetMenu( mt.hCurrentMenu );
3095 if (!menu) /* sometimes happens if I do a window manager close */
3096 break;
3097
3098 /* we have to keep the message in the queue until it's
3099 * clear that menu loop is not over yet. */
3100
3101 for (;;)
3102 {
3103 if (PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ))
3104 {
3105 if (!CallMsgFilterW( &msg, MSGF_MENU )) break;
3106 /* remove the message from the queue */
3107 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3108 }
3109 else
3110 {
3111 if (!enterIdleSent)
3112 {
3113 HWND win = menu->wFlags & MF_POPUP ? menu->hWnd : 0;
3114 enterIdleSent = TRUE;
3115 SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
3116 }
3117 WaitMessage();
3118 }
3119 }
3120
3121 /* check if EndMenu() tried to cancel us, by posting this message */
3122 if(msg.message == WM_CANCELMODE)
3123 {
3124 /* we are now out of the loop */
3125 fEndMenu = TRUE;
3126
3127 /* remove the message from the queue */
3128 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3129
3130 /* break out of internal loop, ala ESCAPE */
3131 break;
3132 }
3133
3134 mt.pt = msg.pt;
3135
3136 if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
3137 enterIdleSent=FALSE;
3138
3139 fRemove = FALSE;
3140 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
3141 {
3142 /*
3143 * Use the mouse coordinates in lParam instead of those in the MSG
3144 * struct to properly handle synthetic messages. They are already
3145 * in screen coordinates.
3146 */
3147 mt.pt.x = (short)LOWORD(msg.lParam);
3148 mt.pt.y = (short)HIWORD(msg.lParam);
3149
3150 /* Find a menu for this mouse event */
3151 hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
3152
3153 switch(msg.message)
3154 {
3155 /* no WM_NC... messages in captured state */
3156
3157 case WM_RBUTTONDBLCLK:
3158 case WM_RBUTTONDOWN:
3159 if (!(wFlags & TPM_RIGHTBUTTON)) break;
3160 /* fall through */
3161 case WM_LBUTTONDBLCLK:
3162 case WM_LBUTTONDOWN:
3163 /* If the message belongs to the menu, removes it from the queue */
3164 /* Else, end menu tracking */
3165 fRemove = MENU_ButtonDown( &mt, msg.message, hmenu, wFlags );
3166 fEndMenu = !fRemove;
3167 break;
3168
3169 case WM_RBUTTONUP:
3170 if (!(wFlags & TPM_RIGHTBUTTON)) break;
3171 /* fall through */
3172 case WM_LBUTTONUP:
3173 /* Check if a menu was selected by the mouse */
3174 if (hmenu)
3175 {
3176 executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
3177 TRACE("executedMenuId %d\n", executedMenuId);
3178
3179 /* End the loop if executedMenuId is an item ID */
3180 /* or if the job was done (executedMenuId = 0). */
3181 fEndMenu = fRemove = (executedMenuId != -1);
3182 }
3183 /* No menu was selected by the mouse */
3184 /* if the function was called by TrackPopupMenu, continue
3185 with the menu tracking. If not, stop it */
3186 else
3187 fEndMenu = !(wFlags & TPM_POPUPMENU);
3188
3189 break;
3190
3191 case WM_MOUSEMOVE:
3192 /* the selected menu item must be changed every time */
3193 /* the mouse moves. */
3194
3195 if (hmenu)
3196 fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
3197
3198 } /* switch(msg.message) - mouse */
3199 }
3200 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
3201 {
3202 fRemove = TRUE; /* Keyboard messages are always removed */
3203 switch(msg.message)
3204 {
3205 case WM_KEYDOWN:
3206 case WM_SYSKEYDOWN:
3207 switch(msg.wParam)
3208 {
3209 case VK_MENU:
3210 case VK_F10:
3211 fEndMenu = TRUE;
3212 break;
3213
3214 case VK_HOME:
3215 case VK_END:
3216 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
3217 NO_SELECTED_ITEM, FALSE, 0 );
3218 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
3219 (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
3220 break;
3221
3222 case VK_UP:
3223 case VK_DOWN: /* If on menu bar, pull-down the menu */
3224
3225 menu = MENU_GetMenu( mt.hCurrentMenu );
3226 if (!(menu->wFlags & MF_POPUP))
3227 mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
3228 else /* otherwise try to move selection */
3229 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
3230 (msg.wParam == VK_UP)? ITEM_PREV : ITEM_NEXT );
3231 break;
3232
3233 case VK_LEFT:
3234 MENU_KeyLeft( &mt, wFlags, msg.message );
3235 break;
3236
3237 case VK_RIGHT:
3238 MENU_KeyRight( &mt, wFlags, msg.message );
3239 break;
3240
3241 case VK_ESCAPE:
3242 fEndMenu = MENU_KeyEscape(&mt, wFlags);
3243 break;
3244
3245 case VK_F1:
3246 {
3247 HELPINFO hi;
3248 hi.cbSize = sizeof(HELPINFO);
3249 hi.iContextType = HELPINFO_MENUITEM;
3250 if (menu->FocusedItem == NO_SELECTED_ITEM)
3251 hi.iCtrlId = 0;
3252 else
3253 hi.iCtrlId = menu->items[menu->FocusedItem].wID;
3254 hi.hItemHandle = hmenu;
3255 hi.dwContextId = menu->dwContextHelpID;
3256 hi.MousePos = msg.pt;
3257 SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
3258 break;
3259 }
3260
3261 default:
3262 TranslateMessage( &msg );
3263 break;
3264 }
3265 break; /* WM_KEYDOWN */
3266
3267 case WM_CHAR:
3268 case WM_SYSCHAR:
3269 {
3270 UINT pos;
3271
3272 if (msg.wParam == '\r' || msg.wParam == ' ')
3273 {
3274 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
3275 fEndMenu = (executedMenuId != -2);
3276
3277 break;
3278 }
3279
3280 /* Hack to avoid control chars. */
3281 /* We will find a better way real soon... */
3282 if (msg.wParam < 32) break;
3283
3284 pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
3285 LOWORD(msg.wParam), FALSE );
3286 if (pos == (UINT)-2) fEndMenu = TRUE;
3287 else if (pos == (UINT)-1) MessageBeep(0);
3288 else
3289 {
3290 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
3291 TRUE, 0 );
3292 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
3293 fEndMenu = (executedMenuId != -2);
3294 }
3295 }
3296 break;
3297 } /* switch(msg.message) - kbd */
3298 }
3299 else
3300 {
3301 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3302 DispatchMessageW( &msg );
3303 continue;
3304 }
3305
3306 if (!fEndMenu) fRemove = TRUE;
3307
3308 /* finally remove message from the queue */
3309
3310 if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
3311 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3312 else mt.trackFlags &= ~TF_SKIPREMOVE;
3313 }
3314 __FINALLY( release_capture )
3315
3316 /* If dropdown is still painted and the close box is clicked on
3317 then the menu will be destroyed as part of the DispatchMessage above.
3318 This will then invalidate the menu handle in mt.hTopMenu. We should
3319 check for this first. */
3320 if( IsMenu( mt.hTopMenu ) )
3321 {
3322 menu = MENU_GetMenu( mt.hTopMenu );
3323
3324 if( IsWindow( mt.hOwnerWnd ) )
3325 {
3326 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE, wFlags );
3327
3328 if (menu && (menu->wFlags & MF_POPUP))
3329 {
3330 DestroyWindow( menu->hWnd );
3331 menu->hWnd = 0;
3332
3333 if (!(wFlags & TPM_NONOTIFY))
3334 SendMessageW( mt.hOwnerWnd, WM_UNINITMENUPOPUP, (WPARAM)mt.hTopMenu,
3335 MAKELPARAM(0, IS_SYSTEM_MENU(menu)) );
3336 }
3337 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
3338 SendMessageW( mt.hOwnerWnd, WM_MENUSELECT, MAKEWPARAM(0,0xffff), 0 );
3339 }
3340 }
3341
3342 SetLastError( ERROR_SUCCESS );
3343 /* The return value is only used by TrackPopupMenu */
3344 if (!(wFlags & TPM_RETURNCMD)) return TRUE;
3345 if (executedMenuId == -1) executedMenuId = 0;
3346 return executedMenuId;
3347 }
3348
3349 /***********************************************************************
3350 * MENU_InitTracking
3351 */
3352 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
3353 {
3354 POPUPMENU *menu;
3355
3356 TRACE("hwnd=%p hmenu=%p\n", hWnd, hMenu);
3357
3358 HideCaret(0);
3359
3360 if (!(menu = MENU_GetMenu( hMenu ))) return FALSE;
3361
3362 /* This makes the menus of applications built with Delphi work.
3363 * It also enables menus to be displayed in more than one window,
3364 * but there are some bugs left that need to be fixed in this case.
3365 */
3366 if (!bPopup) menu->hWnd = hWnd;
3367 if (!top_popup)
3368 {
3369 top_popup = menu->hWnd;
3370 top_popup_hmenu = hMenu;
3371 }
3372
3373 fEndMenu = FALSE;
3374
3375 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
3376 if (!(wFlags & TPM_NONOTIFY))
3377 SendMessageW( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
3378
3379 SendMessageW( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
3380
3381 if (!(wFlags & TPM_NONOTIFY))
3382 {
3383 SendMessageW( hWnd, WM_INITMENU, (WPARAM)hMenu, 0 );
3384 /* If an app changed/recreated menu bar entries in WM_INITMENU
3385 * menu sizes will be recalculated once the menu created/shown.
3386 */
3387 }
3388
3389 return TRUE;
3390 }
3391
3392 /***********************************************************************
3393 * MENU_ExitTracking
3394 */
3395 static BOOL MENU_ExitTracking(HWND hWnd, BOOL bPopup)
3396 {
3397 TRACE("hwnd=%p\n", hWnd);
3398
3399 SendMessageW( hWnd, WM_EXITMENULOOP, bPopup, 0 );
3400 ShowCaret(0);
3401 top_popup = 0;
3402 top_popup_hmenu = NULL;
3403 return TRUE;
3404 }
3405
3406 /***********************************************************************
3407 * MENU_TrackMouseMenuBar
3408 *
3409 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
3410 */
3411 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
3412 {
3413 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
3414 UINT wFlags = TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3415
3416 TRACE("wnd=%p ht=0x%04x %s\n", hWnd, ht, wine_dbgstr_point( &pt));
3417
3418 if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) wFlags |= TPM_LAYOUTRTL;
3419 if (IsMenu(hMenu))
3420 {
3421 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3422
3423 /* fetch the window menu again, it may have changed */
3424 hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
3425 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3426 MENU_ExitTracking(hWnd, FALSE);
3427 }
3428 }
3429
3430
3431 /***********************************************************************
3432 * MENU_TrackKbdMenuBar
3433 *
3434 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3435 */
3436 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, WCHAR wChar)
3437 {
3438 UINT uItem = NO_SELECTED_ITEM;
3439 HMENU hTrackMenu;
3440 UINT wFlags = TPM_LEFTALIGN | TPM_LEFTBUTTON;
3441
3442 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd, wParam, wChar);
3443
3444 /* find window that has a menu */
3445
3446 while (is_win_menu_disallowed(hwnd))
3447 if (!(hwnd = GetAncestor( hwnd, GA_PARENT ))) return;
3448
3449 /* check if we have to track a system menu */
3450
3451 hTrackMenu = GetMenu( hwnd );
3452 if (!hTrackMenu || IsIconic(hwnd) || wChar == ' ' )
3453 {
3454 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3455 hTrackMenu = get_win_sys_menu( hwnd );
3456 uItem = 0;
3457 wParam |= HTSYSMENU; /* prevent item lookup */
3458 }
3459 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) wFlags |= TPM_LAYOUTRTL;
3460
3461 if (!IsMenu( hTrackMenu )) return;
3462
3463 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3464
3465 /* fetch the window menu again, it may have changed */
3466 hTrackMenu = (wParam & HTSYSMENU) ? get_win_sys_menu( hwnd ) : GetMenu( hwnd );
3467
3468 if( wChar && wChar != ' ' )
3469 {
3470 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, wChar, (wParam & HTSYSMENU) );
3471 if ( uItem >= (UINT)(-2) )
3472 {
3473 if( uItem == (UINT)(-1) ) MessageBeep(0);
3474 /* schedule end of menu tracking */
3475 wFlags |= TF_ENDMENU;
3476 goto track_menu;
3477 }
3478 }
3479
3480 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3481
3482 if (!(wParam & HTSYSMENU) || wChar == ' ')
3483 {
3484 if( uItem == NO_SELECTED_ITEM )
3485 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3486 else
3487 PostMessageW( hwnd, WM_KEYDOWN, VK_RETURN, 0 );
3488 }
3489
3490 track_menu:
3491 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3492 MENU_ExitTracking( hwnd, FALSE );
3493 }
3494
3495 /**********************************************************************
3496 * TrackPopupMenuEx (USER32.@)
3497 */
3498 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3499 HWND hWnd, LPTPMPARAMS lpTpm )
3500 {
3501 POPUPMENU *menu;
3502 BOOL ret = FALSE;
3503
3504 TRACE("hmenu %p flags %04x (%d,%d) hwnd %p lpTpm %p rect %s\n",
3505 hMenu, wFlags, x, y, hWnd, lpTpm,
3506 lpTpm ? wine_dbgstr_rect( &lpTpm->rcExclude) : "-" );
3507
3508 /* Parameter check */
3509 /* FIXME: this check is performed several times, here and in the called
3510 functions. That could be optimized */
3511 if (!(menu = MENU_GetMenu( hMenu )))
3512 {
3513 SetLastError( ERROR_INVALID_MENU_HANDLE );
3514 return FALSE;
3515 }
3516
3517 if (IsWindow(menu->hWnd))
3518 {
3519 SetLastError( ERROR_POPUP_ALREADY_ACTIVE );
3520 return FALSE;
3521 }
3522
3523 if (MENU_InitPopup( hWnd, hMenu, wFlags ))
3524 {
3525 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3526
3527 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3528 if (!(wFlags & TPM_NONOTIFY))
3529 SendMessageW( hWnd, WM_INITMENUPOPUP, (WPARAM)hMenu, 0);
3530
3531 if (menu->wFlags & MF_SYSMENU)
3532 MENU_InitSysMenuPopup( hMenu, GetWindowLongW( hWnd, GWL_STYLE ),
3533 GetClassLongW( hWnd, GCL_STYLE));
3534
3535 if (MENU_ShowPopup( hWnd, hMenu, 0, wFlags, x, y, 0, 0 ))
3536 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd,
3537 lpTpm ? &lpTpm->rcExclude : NULL );
3538 MENU_ExitTracking(hWnd, TRUE);
3539
3540 if (menu->hWnd)
3541 {
3542 DestroyWindow( menu->hWnd );
3543 menu->hWnd = 0;
3544
3545 if (!(wFlags & TPM_NONOTIFY))
3546 SendMessageW( hWnd, WM_UNINITMENUPOPUP, (WPARAM)hMenu,
3547 MAKELPARAM(0, IS_SYSTEM_MENU(menu)) );
3548 }
3549 SetLastError(0);
3550 }
3551
3552 return ret;
3553 }
3554
3555 /**********************************************************************
3556 * TrackPopupMenu (USER32.@)
3557 *
3558 * Like the win32 API, the function return the command ID only if the
3559 * flag TPM_RETURNCMD is on.
3560 *
3561 */
3562 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3563 INT nReserved, HWND hWnd, const RECT *lpRect )
3564 {
3565 return TrackPopupMenuEx( hMenu, wFlags, x, y, hWnd, NULL);
3566 }
3567
3568 /***********************************************************************
3569 * PopupMenuWndProc
3570 *
3571 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3572 */
3573 LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3574 {
3575 TRACE("hwnd=%p msg=0x%04x wp=0x%04lx lp=0x%08lx\n", hwnd, message, wParam, lParam);
3576
3577 switch(message)
3578 {
3579 case WM_CREATE:
3580 {
3581 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3582 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)cs->lpCreateParams );
3583 return 0;
3584 }
3585
3586 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3587 return MA_NOACTIVATE;
3588
3589 case WM_PAINT:
3590 {
3591 PAINTSTRUCT ps;
3592 BeginPaint( hwnd, &ps );
3593 MENU_DrawPopupMenu( hwnd, ps.hdc,
3594 (HMENU)GetWindowLongPtrW( hwnd, 0 ) );
3595 EndPaint( hwnd, &ps );
3596 return 0;
3597 }
3598
3599 case WM_PRINTCLIENT:
3600 {
3601 MENU_DrawPopupMenu( hwnd, (HDC)wParam,
3602 (HMENU)GetWindowLongPtrW( hwnd, 0 ) );
3603 return 0;
3604 }
3605
3606 case WM_ERASEBKGND:
3607 return 1;
3608
3609 case WM_DESTROY:
3610 /* zero out global pointer in case resident popup window was destroyed. */
3611 if (hwnd == top_popup) {
3612 top_popup = 0;
3613 top_popup_hmenu = NULL;
3614 }
3615 break;
3616
3617 case WM_SHOWWINDOW:
3618
3619 if( wParam )
3620 {
3621 if (!GetWindowLongPtrW( hwnd, 0 )) ERR("no menu to display\n");
3622 }
3623 else
3624 SetWindowLongPtrW( hwnd, 0, 0 );
3625 break;
3626
3627 case MN_GETHMENU:
3628 return GetWindowLongPtrW( hwnd, 0 );
3629
3630 default:
3631 return DefWindowProcW( hwnd, message, wParam, lParam );
3632 }
3633 return 0;
3634 }
3635
3636
3637 /***********************************************************************
3638 * MENU_GetMenuBarHeight
3639 *
3640 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3641 */
3642 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3643 INT orgX, INT orgY )
3644 {
3645 HDC hdc;
3646 RECT rectBar;
3647 LPPOPUPMENU lppop;
3648
3649 TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd, menubarWidth, orgX, orgY );
3650
3651 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3652
3653 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3654 SelectObject( hdc, get_menu_font(FALSE));
3655 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3656 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3657 ReleaseDC( hwnd, hdc );
3658 return lppop->Height;
3659 }
3660
3661
3662 /*******************************************************************
3663 * ChangeMenuA (USER32.@)
3664 */
3665 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3666 UINT id, UINT flags )
3667 {
3668 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3669 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3670 id, data );
3671 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3672 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3673 id, data );
3674 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3675 flags & MF_BYPOSITION ? pos : id,
3676 flags & ~MF_REMOVE );
3677 /* Default: MF_INSERT */
3678 return InsertMenuA( hMenu, pos, flags, id, data );
3679 }
3680
3681
3682 /*******************************************************************
3683 * ChangeMenuW (USER32.@)
3684 */
3685 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3686 UINT id, UINT flags )
3687 {
3688 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3689 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3690 id, data );
3691 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3692 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3693 id, data );
3694 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3695 flags & MF_BYPOSITION ? pos : id,
3696 flags & ~MF_REMOVE );
3697 /* Default: MF_INSERT */
3698 return InsertMenuW( hMenu, pos, flags, id, data );
3699 }
3700
3701
3702 /*******************************************************************
3703 * CheckMenuItem (USER32.@)
3704 */
3705 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3706 {
3707 POPUPMENU *menu;
3708 MENUITEM *item;
3709 DWORD ret;
3710 UINT pos;
3711
3712 if (!(menu = find_menu_item(hMenu, id, flags, &pos)))
3713 return -1;
3714 item = &menu->items[pos];
3715
3716 ret = item->fState & MF_CHECKED;
3717 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3718 else item->fState &= ~MF_CHECKED;
3719 release_menu_ptr(menu);
3720 return ret;
3721 }
3722
3723
3724 /**********************************************************************
3725 * EnableMenuItem (USER32.@)
3726 */
3727 BOOL WINAPI EnableMenuItem( HMENU hMenu, UINT id, UINT wFlags )
3728 {
3729 UINT oldflags, pos;
3730 POPUPMENU *menu;
3731 MENUITEM *item;
3732
3733 TRACE("(%p, %04x, %04x)\n", hMenu, id, wFlags);
3734
3735 /* Get the Popupmenu to access the owner menu */
3736 if (!(menu = find_menu_item(hMenu, id, wFlags, &pos)))
3737 return (UINT)-1;
3738
3739 item = &menu->items[pos];
3740 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3741 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3742
3743 /* If the close item in the system menu change update the close button */
3744 if ((item->wID == SC_CLOSE) && (oldflags != wFlags))
3745 {
3746 if (menu->hSysMenuOwner)
3747 {
3748 RECT rc;
3749 POPUPMENU* parentMenu;
3750 HWND hwnd;
3751
3752 /* Get the parent menu to access*/
3753 parentMenu = grab_menu_ptr(menu->hSysMenuOwner);
3754 release_menu_ptr(menu);
3755 if (!parentMenu)
3756 return (UINT)-1;
3757
3758 hwnd = parentMenu->hWnd;
3759 release_menu_ptr(parentMenu);
3760
3761 /* Refresh the frame to reflect the change */
3762 WIN_GetRectangles( hwnd, COORDS_CLIENT, &rc, NULL );
3763 rc.bottom = 0;
3764 RedrawWindow(hwnd, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
3765 }
3766 }
3767 else
3768 release_menu_ptr(menu);
3769
3770 return oldflags;
3771 }
3772
3773
3774 /*******************************************************************
3775 * GetMenuStringA (USER32.@)
3776 */
3777 INT WINAPI GetMenuStringA(
3778 HMENU hMenu, /* [in] menuhandle */
3779 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3780 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3781 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3782 UINT wFlags /* [in] MF_ flags */
3783 )
3784 {
3785 POPUPMENU *menu;
3786 MENUITEM *item;
3787 UINT pos;
3788 INT ret;
3789
3790 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3791 if (str && nMaxSiz) str[0] = '\0';
3792
3793 if (!(menu = find_menu_item(hMenu, wItemID, wFlags, &pos)))
3794 {
3795 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3796 return 0;
3797 }
3798 item = &menu->items[pos];
3799
3800 if (!item->text)
3801 ret = 0;
3802 else if (!str || !nMaxSiz)
3803 ret = WideCharToMultiByte( CP_ACP, 0, item->text, -1, NULL, 0, NULL, NULL );
3804 else
3805 {
3806 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3807 str[nMaxSiz-1] = 0;
3808 ret = strlen(str);
3809 }
3810 release_menu_ptr(menu);
3811
3812 TRACE("returning %s\n", debugstr_a(str));
3813 return ret;
3814 }
3815
3816
3817 /*******************************************************************
3818 * GetMenuStringW (USER32.@)
3819 */
3820 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3821 LPWSTR str, INT nMaxSiz, UINT wFlags )
3822 {
3823 POPUPMENU *menu;
3824 MENUITEM *item;
3825 UINT pos;
3826 INT ret;
3827
3828 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3829 if (str && nMaxSiz) str[0] = '\0';
3830
3831 if (!(menu = find_menu_item(hMenu, wItemID, wFlags, &pos)))
3832 {
3833 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3834 return 0;
3835 }
3836 item = &menu->items[pos];
3837
3838 if (!str || !nMaxSiz)
3839 ret = item->text ? strlenW(item->text) : 0;
3840 else if (!item->text)
3841 {
3842 str[0] = 0;
3843 ret = 0;
3844 }
3845 else
3846 {
3847 lstrcpynW( str, item->text, nMaxSiz );
3848 ret = strlenW(str);
3849 }
3850 release_menu_ptr(menu);
3851
3852 TRACE("returning %s\n", debugstr_w(str));
3853 return ret;
3854 }
3855
3856
3857 /**********************************************************************
3858 * HiliteMenuItem (USER32.@)
3859 */
3860 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3861 UINT wHilite )
3862 {
3863 POPUPMENU *menu;
3864 UINT pos;
3865
3866 TRACE("(%p, %p, %04x, %04x);\n", hWnd, hMenu, wItemID, wHilite);
3867
3868 if (!(menu = find_menu_item(hMenu, wItemID, wHilite, &pos))) return FALSE;
3869
3870 if (menu->FocusedItem != pos)
3871 {
3872 MENU_HideSubPopups( hWnd, menu->obj.handle, FALSE, 0 );
3873 MENU_SelectItem( hWnd, menu->obj.handle, pos, TRUE, 0 );
3874 }
3875 release_menu_ptr(menu);
3876 return TRUE;
3877 }
3878
3879
3880 /**********************************************************************
3881 * GetMenuState (USER32.@)
3882 */
3883 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3884 {
3885 POPUPMENU *menu;
3886 UINT state, pos;
3887 MENUITEM *item;
3888
3889 TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, wItemID, wFlags);
3890
3891 if (!(menu = find_menu_item(hMenu, wItemID, wFlags, &pos)))
3892 return -1;
3893
3894 item = &menu->items[pos];
3895 debug_print_menuitem (" item: ", item, "");
3896 if (item->fType & MF_POPUP)
3897 {
3898 POPUPMENU *submenu = grab_menu_ptr(item->hSubMenu);
3899 if (submenu)
3900 state = (submenu->nItems << 8) | ((item->fState | item->fType) & 0xff);
3901 else
3902 state = -1;
3903 release_menu_ptr(submenu);
3904 }
3905 else
3906 {
3907 /* We used to (from way back then) mask the result to 0xff. */
3908 /* I don't know why and it seems wrong as the documented */
3909 /* return flag MF_SEPARATOR is outside that mask. */
3910 state = (item->fType | item->fState);
3911 }
3912 release_menu_ptr(menu);
3913 return state;
3914 }
3915
3916
3917 /**********************************************************************
3918 * GetMenuItemCount (USER32.@)
3919 */
3920 INT WINAPI GetMenuItemCount( HMENU hMenu )
3921 {
3922 POPUPMENU *menu = grab_menu_ptr(hMenu);
3923 INT count;
3924
3925 if (!menu) return -1;
3926 count = menu->nItems;
3927 release_menu_ptr(menu);
3928
3929 TRACE("(%p) returning %d\n", hMenu, count);
3930 return count;
3931 }
3932
3933
3934 /**********************************************************************
3935 * GetMenuItemID (USER32.@)
3936 */
3937 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3938 {
3939 POPUPMENU *menu;
3940 UINT id, pos;
3941
3942 if (!(menu = find_menu_item(hMenu, nPos, MF_BYPOSITION, &pos)))
3943 return -1;
3944
3945 id = menu->items[pos].fType & MF_POPUP ? -1 : menu->items[pos].wID;
3946 release_menu_ptr(menu);
3947 return id;
3948 }
3949
3950
3951 /**********************************************************************
3952 * MENU_mnu2mnuii
3953 *
3954 * Uses flags, id and text ptr, passed by InsertMenu() and
3955 * ModifyMenu() to setup a MenuItemInfo structure.
3956 */
3957 static void MENU_mnu2mnuii( UINT flags, UINT_PTR id, LPCWSTR str,
3958 LPMENUITEMINFOW pmii)
3959 {
3960 ZeroMemory( pmii, sizeof( MENUITEMINFOW));
3961 pmii->cbSize = sizeof( MENUITEMINFOW);
3962 pmii->fMask = MIIM_STATE | MIIM_ID | MIIM_FTYPE;
3963 /* setting bitmap clears text and vice versa */
3964 if( IS_STRING_ITEM(flags)) {
3965 pmii->fMask |= MIIM_STRING | MIIM_BITMAP;
3966 if( !str)
3967 flags |= MF_SEPARATOR;
3968 /* Item beginning with a backspace is a help item */
3969 /* FIXME: wrong place, this is only true in win16 */
3970 else if( *str == '\b') {
3971 flags |= MF_HELP;
3972 str++;
3973 }
3974 pmii->dwTypeData = (LPWSTR)str;
3975 } else if( flags & MFT_BITMAP){
3976 pmii->fMask |= MIIM_BITMAP | MIIM_STRING;
3977 pmii->hbmpItem = (HBITMAP)str;
3978 }
3979 if( flags & MF_OWNERDRAW){
3980 pmii->fMask |= MIIM_DATA;
3981 pmii->dwItemData = (ULONG_PTR) str;
3982 }
3983 if( flags & MF_POPUP && MENU_GetMenu((HMENU)id)) {
3984 pmii->fMask |= MIIM_SUBMENU;
3985 pmii->hSubMenu = (HMENU)id;
3986 }
3987 if( flags & MF_SEPARATOR) flags |= MF_GRAYED | MF_DISABLED;
3988 pmii->fState = flags & MENUITEMINFO_STATE_MASK & ~MFS_DEFAULT;
3989 pmii->fType = flags & MENUITEMINFO_TYPE_MASK;
3990 pmii->wID = (UINT)id;
3991 }
3992
3993
3994 /*******************************************************************
3995 * InsertMenuW (USER32.@)
3996 */
3997 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3998 UINT_PTR id, LPCWSTR str )
3999 {
4000 MENUITEMINFOW mii;
4001 POPUPMENU *menu;
4002 MENUITEM *item;
4003 UINT newpos;
4004 BOOL ret;
4005
4006 if (IS_STRING_ITEM(flags) && str)
4007 TRACE("hMenu %p, pos %d, flags %08x, id %04lx, str %s\n",
4008 hMenu, pos, flags, id, debugstr_w(str) );
4009 else TRACE("hMenu %p, pos %d, flags %08x, id %04lx, str %p (not a string)\n",
4010 hMenu, pos, flags, id, str );
4011
4012 if (!(menu = insert_menu_item(hMenu, pos, flags, &newpos)))
4013 return FALSE;
4014
4015 MENU_mnu2mnuii( flags, id, str, &mii);
4016
4017 item = &menu->items[newpos];
4018 ret = SetMenuItemInfo_common( item, &mii, TRUE);
4019 if (ret)
4020 item->hCheckBit = item->hUnCheckBit = 0;
4021 else
4022 RemoveMenu( hMenu, pos, flags );
4023 release_menu_ptr(menu);
4024
4025 return ret;
4026 }
4027
4028
4029 /*******************************************************************
4030 * InsertMenuA (USER32.@)
4031 */
4032 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
4033 UINT_PTR id, LPCSTR str )
4034 {
4035 BOOL ret = FALSE;
4036
4037 if (IS_STRING_ITEM(flags) && str)
4038 {
4039 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4040 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
4041 if (newstr)
4042 {
4043 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
4044 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
4045 HeapFree( GetProcessHeap(), 0, newstr );
4046 }
4047 return ret;
4048 }
4049 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
4050 }
4051
4052
4053 /*******************************************************************
4054 * AppendMenuA (USER32.@)
4055 */
4056 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
4057 UINT_PTR id, LPCSTR data )
4058 {
4059 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
4060 }
4061
4062
4063 /*******************************************************************
4064 * AppendMenuW (USER32.@)
4065 */
4066 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
4067 UINT_PTR id, LPCWSTR data )
4068 {
4069 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
4070 }
4071
4072
4073 /**********************************************************************
4074 * RemoveMenu (USER32.@)
4075 */
4076 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT id, UINT flags )
4077 {
4078 POPUPMENU *menu;
4079 UINT pos;
4080
4081 TRACE("(menu=%p id=%#x flags=%04x)\n", hMenu, id, flags);
4082
4083 if (!(menu = find_menu_item(hMenu, id, flags, &pos)))
4084 return FALSE;
4085
4086 /* Remove item */
4087 MENU_FreeItemData( &menu->items[pos] );
4088
4089 if (--menu->nItems == 0)
4090 {
4091 HeapFree( GetProcessHeap(), 0, menu->items );
4092 menu->items = NULL;
4093 }
4094 else
4095 {
4096 MENUITEM *new_items, *item = &menu->items[pos];
4097
4098 while (pos < menu->nItems)
4099 {
4100 *item = *(item+1);
4101 item++;
4102 pos++;
4103 }
4104 new_items = HeapReAlloc( GetProcessHeap(), 0, menu->items, menu->nItems * sizeof(MENUITEM) );
4105 if (new_items) menu->items = new_items;
4106 }
4107 release_menu_ptr(menu);
4108
4109 return TRUE;
4110 }
4111
4112
4113 /**********************************************************************
4114 * DeleteMenu (USER32.@)
4115 */
4116 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT id, UINT flags )
4117 {
4118 POPUPMENU *menu;
4119 UINT pos;
4120
4121 if (!(menu = find_menu_item(hMenu, id, flags, &pos)))
4122 return FALSE;
4123
4124 if (menu->items[pos].fType & MF_POPUP)
4125 DestroyMenu(menu->items[pos].hSubMenu);
4126
4127 RemoveMenu(menu->obj.handle, pos, flags | MF_BYPOSITION);
4128 release_menu_ptr(menu);
4129 return TRUE;
4130 }
4131
4132
4133 /*******************************************************************
4134 * ModifyMenuW (USER32.@)
4135 */
4136 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
4137 UINT_PTR id, LPCWSTR str )
4138 {
4139 MENUITEMINFOW mii;
4140 POPUPMENU *menu;
4141 UINT item_pos;
4142 BOOL ret;
4143
4144 if (IS_STRING_ITEM(flags))
4145 TRACE("%p %d %04x %04lx %s\n", hMenu, pos, flags, id, debugstr_w(str) );
4146 else
4147 TRACE("%p %d %04x %04lx %p\n", hMenu, pos, flags, id, str );
4148
4149 if (!(menu = find_menu_item(hMenu, pos, flags, &item_pos)))
4150 {
4151 /* workaround for Word 95: pretend that SC_TASKLIST item exists */
4152 if (pos == SC_TASKLIST && !(flags & MF_BYPOSITION)) return TRUE;
4153 return FALSE;
4154 }
4155 menu->Height = 0; /* force size recalculate */
4156 MENU_mnu2mnuii( flags, id, str, &mii);
4157 ret = SetMenuItemInfo_common(&menu->items[item_pos], &mii, TRUE);
4158 release_menu_ptr(menu);
4159 return ret;
4160 }
4161
4162
4163 /*******************************************************************
4164 * ModifyMenuA (USER32.@)
4165 */
4166 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
4167 UINT_PTR id, LPCSTR str )
4168 {
4169 BOOL ret = FALSE;
4170
4171 if (IS_STRING_ITEM(flags) && str)
4172 {
4173 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4174 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
4175 if (newstr)
4176 {
4177 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
4178 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
4179 HeapFree( GetProcessHeap(), 0, newstr );
4180 }
4181 return ret;
4182 }
4183 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
4184 }
4185
4186
4187 /**********************************************************************
4188 * CreatePopupMenu (USER32.@)
4189 */
4190 HMENU WINAPI CreatePopupMenu(void)
4191 {
4192 HMENU hmenu;
4193 POPUPMENU *menu;
4194
4195 if (!(hmenu = CreateMenu())) return 0;
4196 menu = MENU_GetMenu( hmenu );
4197 menu->wFlags |= MF_POPUP;
4198 return hmenu;
4199 }
4200
4201
4202 /**********************************************************************
4203 * GetMenuCheckMarkDimensions (USER.417)
4204 * GetMenuCheckMarkDimensions (USER32.@)
4205 */
4206 DWORD WINAPI GetMenuCheckMarkDimensions(void)
4207 {
4208 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
4209 }
4210
4211
4212 /**********************************************************************
4213 * SetMenuItemBitmaps (USER32.@)
4214 */
4215 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
4216 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
4217 {
4218 POPUPMENU *menu;
4219 MENUITEM *item;
4220 UINT pos;
4221
4222 if (!(menu = find_menu_item(hMenu, nPos, wFlags, &pos)))
4223 return FALSE;
4224
4225 item = &menu->items[pos];
4226 if (!hNewCheck && !hNewUnCheck)
4227 {
4228 item->fState &= ~MF_USECHECKBITMAPS;
4229 }
4230 else /* Install new bitmaps */
4231 {
4232 item->hCheckBit = hNewCheck;
4233 item->hUnCheckBit = hNewUnCheck;
4234 item->fState |= MF_USECHECKBITMAPS;
4235 }
4236 release_menu_ptr(menu);
4237
4238 return TRUE;
4239 }
4240
4241
4242 /**********************************************************************
4243 * CreateMenu (USER32.@)
4244 */
4245 HMENU WINAPI CreateMenu(void)
4246 {
4247 HMENU hMenu;
4248 LPPOPUPMENU menu;
4249
4250 if (!(menu = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*menu) ))) return 0;
4251 menu->FocusedItem = NO_SELECTED_ITEM;
4252 menu->refcount = 1;
4253
4254 if (!(hMenu = alloc_user_handle( &menu->obj, USER_MENU ))) HeapFree( GetProcessHeap(), 0, menu );
4255
4256 TRACE("return %p\n", hMenu );
4257
4258 return hMenu;
4259 }
4260
4261
4262 /**********************************************************************
4263 * DestroyMenu (USER32.@)
4264 */
4265 BOOL WINAPI DestroyMenu( HMENU hMenu )
4266 {
4267 LPPOPUPMENU lppop;
4268
4269 TRACE("(%p)\n", hMenu);
4270
4271 if (!(lppop = free_user_handle( hMenu, USER_MENU ))) return FALSE;
4272 if (lppop == OBJ_OTHER_PROCESS) return FALSE;
4273
4274 /* DestroyMenu should not destroy system menu popup owner */
4275 if ((lppop->wFlags & (MF_POPUP | MF_SYSMENU)) == MF_POPUP && lppop->hWnd)
4276 {
4277 DestroyWindow( lppop->hWnd );
4278 lppop->hWnd = 0;
4279 }
4280
4281 if (lppop->items) /* recursively destroy submenus */
4282 {
4283 int i;
4284 MENUITEM *item = lppop->items;
4285 for (i = lppop->nItems; i > 0; i--, item++)
4286 {
4287 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
4288 MENU_FreeItemData( item );
4289 }
4290 HeapFree( GetProcessHeap(), 0, lppop->items );
4291 }
4292 HeapFree( GetProcessHeap(), 0, lppop );
4293 return TRUE;
4294 }
4295
4296
4297 /**********************************************************************
4298 * GetSystemMenu (USER32.@)
4299 */
4300 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
4301 {
4302 WND *wndPtr = WIN_GetPtr( hWnd );
4303 HMENU retvalue = 0;
4304
4305 if (wndPtr == WND_DESKTOP) return 0;
4306 if (wndPtr == WND_OTHER_PROCESS)
4307 {
4308 if (IsWindow( hWnd )) FIXME( "not supported on other process window %p\n", hWnd );
4309 }
4310 else if (wndPtr)
4311 {
4312 if (wndPtr->hSysMenu && bRevert)
4313 {
4314 DestroyMenu(wndPtr->hSysMenu);
4315 wndPtr->hSysMenu = 0;
4316 }
4317
4318 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
4319 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, 0 );
4320
4321 if( wndPtr->hSysMenu )
4322 {
4323 POPUPMENU *menu;
4324 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
4325
4326 /* Store the dummy sysmenu handle to facilitate the refresh */
4327 /* of the close button if the SC_CLOSE item change */
4328 menu = MENU_GetMenu(retvalue);
4329 if ( menu )
4330 menu->hSysMenuOwner = wndPtr->hSysMenu;
4331 }
4332 WIN_ReleasePtr( wndPtr );
4333 }
4334 return bRevert ? 0 : retvalue;
4335 }
4336
4337
4338 /*******************************************************************
4339 * SetSystemMenu (USER32.@)
4340 */
4341 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
4342 {
4343 WND *wndPtr = WIN_GetPtr( hwnd );
4344
4345 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
4346 {
4347 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
4348 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
4349 WIN_ReleasePtr( wndPtr );
4350 return TRUE;
4351 }
4352 return FALSE;
4353 }
4354
4355
4356 /**********************************************************************
4357 * GetMenu (USER32.@)
4358 */
4359 HMENU WINAPI GetMenu( HWND hWnd )
4360 {
4361 HMENU retvalue = (HMENU)GetWindowLongPtrW( hWnd, GWLP_ID );
4362 TRACE("for %p returning %p\n", hWnd, retvalue);
4363 return retvalue;
4364 }
4365
4366 /**********************************************************************
4367 * GetMenuBarInfo (USER32.@)
4368 */
4369 BOOL WINAPI GetMenuBarInfo( HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi )
4370 {
4371 POPUPMENU *menu;
4372 HMENU hmenu = NULL;
4373 ATOM class_atom;
4374
4375 TRACE( "(%p,0x%08x,0x%08x,%p)\n", hwnd, idObject, idItem, pmbi );
4376
4377 switch (idObject)
4378 {
4379 case OBJID_CLIENT:
4380 class_atom = GetClassLongW(hwnd, GCW_ATOM);
4381 if (!class_atom)
4382 return FALSE;
4383 if (class_atom != POPUPMENU_CLASS_ATOM)
4384 {
4385 WARN("called on invalid window: %d\n", class_atom);
4386 SetLastError(ERROR_INVALID_MENU_HANDLE);
4387 return FALSE;
4388 }
4389
4390 hmenu = (HMENU)GetWindowLongPtrW(hwnd, 0);
4391 break;
4392 case OBJID_MENU:
4393 hmenu = GetMenu(hwnd);
4394 break;
4395 case OBJID_SYSMENU:
4396 hmenu = GetSystemMenu(hwnd, FALSE);
4397 break;
4398 default:
4399 return FALSE;
4400 }
4401
4402 if (!hmenu)
4403 return FALSE;
4404
4405 if (pmbi->cbSize != sizeof(MENUBARINFO))
4406 {
4407 SetLastError(ERROR_INVALID_PARAMETER);
4408 return FALSE;
4409 }
4410
4411 menu = MENU_GetMenu(hmenu);
4412 if (!menu)
4413 return FALSE;
4414 if (idItem < 0 || idItem > menu->nItems)
4415 return FALSE;
4416
4417 if (!menu->Height)
4418 {
4419 SetRectEmpty(&pmbi->rcBar);
4420 }
4421 else if (idItem == 0)
4422 {
4423 GetMenuItemRect(hwnd, hmenu, 0, &pmbi->rcBar);
4424 pmbi->rcBar.right = pmbi->rcBar.left + menu->Width;
4425 pmbi->rcBar.bottom = pmbi->rcBar.top + menu->Height;
4426 }
4427 else
4428 {
4429 GetMenuItemRect(hwnd, hmenu, idItem - 1, &pmbi->rcBar);
4430 }
4431
4432 pmbi->hMenu = hmenu;
4433 pmbi->hwndMenu = NULL;
4434 pmbi->fBarFocused = top_popup_hmenu == hmenu;
4435 if (idItem)
4436 {
4437 pmbi->fFocused = menu->FocusedItem == idItem - 1;
4438 if (pmbi->fFocused && (menu->items[idItem - 1].fType & MF_POPUP))
4439 {
4440 menu = MENU_GetMenu(menu->items[idItem - 1].hSubMenu);
4441 if (menu)
4442 pmbi->hwndMenu = menu->hWnd;
4443 }
4444 }
4445 else
4446 {
4447 pmbi->fFocused = pmbi->fBarFocused;
4448 }
4449
4450 return TRUE;
4451 }
4452
4453 /**********************************************************************
4454 * MENU_SetMenu
4455 *
4456 * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
4457 * SetWindowPos call that would result if SetMenu were called directly.
4458 */
4459 BOOL MENU_SetMenu( HWND hWnd, HMENU hMenu )
4460 {
4461 TRACE("(%p, %p);\n", hWnd, hMenu);
4462
4463 if (hMenu && !IsMenu(hMenu))
4464 {
4465 WARN("hMenu %p is not a menu handle\n", hMenu);
4466 return FALSE;
4467 }
4468 if (is_win_menu_disallowed(hWnd))
4469 return FALSE;
4470
4471 hWnd = WIN_GetFullHandle( hWnd );
4472 if (GetCapture() == hWnd)
4473 set_capture_window( 0, GUI_INMENUMODE, NULL ); /* release the capture */
4474
4475 if (hMenu)
4476 {
4477 POPUPMENU *menu;
4478
4479 if (!(menu = grab_menu_ptr(hMenu))) return FALSE;
4480 menu->hWnd = hWnd;
4481 menu->Height = 0; /* Make sure we recalculate the size */
4482 release_menu_ptr(menu);
4483 }
4484 SetWindowLongPtrW( hWnd, GWLP_ID, (LONG_PTR)hMenu );
4485 return TRUE;
4486 }
4487
4488
4489 /**********************************************************************
4490 * SetMenu (USER32.@)
4491 */
4492 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
4493 {
4494 if(!MENU_SetMenu(hWnd, hMenu))
4495 return FALSE;
4496
4497 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4498 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4499 return TRUE;
4500 }
4501
4502
4503 /**********************************************************************
4504 * GetSubMenu (USER32.@)
4505 */
4506 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4507 {
4508 POPUPMENU *menu;
4509 HMENU submenu;
4510 UINT pos;
4511
4512 if (!(menu = find_menu_item(hMenu, nPos, MF_BYPOSITION, &pos)))
4513 return 0;
4514
4515 if (menu->items[pos].fType & MF_POPUP)
4516 submenu = menu->items[pos].hSubMenu;
4517 else
4518 submenu = 0;
4519
4520 release_menu_ptr(menu);
4521 return submenu;
4522 }
4523
4524
4525 /**********************************************************************
4526 * DrawMenuBar (USER32.@)
4527 */
4528 BOOL WINAPI DrawMenuBar( HWND hWnd )
4529 {
4530 HMENU hMenu;
4531
4532 if (!IsWindow( hWnd ))
4533 return FALSE;
4534 if (is_win_menu_disallowed(hWnd))
4535 return TRUE;
4536
4537 if ((hMenu = GetMenu( hWnd )))
4538 {
4539 POPUPMENU *menu = grab_menu_ptr(hMenu);
4540 if (menu)
4541 {
4542 menu->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4543 menu->hwndOwner = hWnd;
4544 release_menu_ptr(menu);
4545 }
4546 }
4547
4548 return SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4549 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4550 }
4551
4552 /***********************************************************************
4553 * DrawMenuBarTemp (USER32.@)
4554 *
4555 * UNDOCUMENTED !!
4556 *
4557 * called by W98SE desk.cpl Control Panel Applet
4558 *
4559 * Not 100% sure about the param names, but close.
4560 */
4561 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont)
4562 {
4563 LPPOPUPMENU lppop;
4564 UINT i,retvalue;
4565 HFONT hfontOld = 0;
4566 BOOL flat_menu = FALSE;
4567
4568 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
4569
4570 if (!hMenu)
4571 hMenu = GetMenu(hwnd);
4572
4573 if (!hFont)
4574 hFont = get_menu_font(FALSE);
4575
4576 lppop = MENU_GetMenu( hMenu );
4577 if (lppop == NULL || lprect == NULL)
4578 {
4579 retvalue = GetSystemMetrics(SM_CYMENU);
4580 goto END;
4581 }
4582
4583 TRACE("(%p, %p, %p, %p, %p)\n", hwnd, hDC, lprect, hMenu, hFont);
4584
4585 hfontOld = SelectObject( hDC, hFont);
4586
4587 if (lppop->Height == 0)
4588 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
4589
4590 lprect->bottom = lprect->top + lppop->Height;
4591
4592 FillRect(hDC, lprect, GetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU) );
4593
4594 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
4595 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
4596 LineTo( hDC, lprect->right, lprect->bottom );
4597
4598 if (lppop->nItems == 0)
4599 {
4600 retvalue = GetSystemMetrics(SM_CYMENU);
4601 goto END;
4602 }
4603
4604 for (i = 0; i < lppop->nItems; i++)
4605 MENU_DrawMenuItem( hwnd, lppop, hwnd, hDC, &lppop->items[i], TRUE, ODA_DRAWENTIRE );
4606
4607 retvalue = lppop->Height;
4608
4609 END:
4610 if (hfontOld) SelectObject (hDC, hfontOld);
4611 return retvalue;
4612 }
4613
4614 /***********************************************************************
4615 * EndMenu (USER.187)
4616 * EndMenu (USER32.@)
4617 */
4618 BOOL WINAPI EndMenu(void)
4619 {
4620 /* if we are in the menu code, and it is active */
4621 if (!fEndMenu && top_popup)
4622 {
4623 /* terminate the menu handling code */
4624 fEndMenu = TRUE;
4625
4626 /* needs to be posted to wakeup the internal menu handler */
4627 /* which will now terminate the menu, in the event that */
4628 /* the main window was minimized, or lost focus, so we */
4629 /* don't end up with an orphaned menu */
4630 PostMessageW( top_popup, WM_CANCELMODE, 0, 0);
4631 }
4632 return fEndMenu;
4633 }
4634
4635
4636 /*****************************************************************
4637 * LoadMenuA (USER32.@)
4638 */
4639 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4640 {
4641 HRSRC hrsrc = FindResourceA( instance, name, (LPSTR)RT_MENU );
4642 if (!hrsrc) return 0;
4643 return LoadMenuIndirectA( LoadResource( instance, hrsrc ));
4644 }
4645
4646
4647 /*****************************************************************
4648 * LoadMenuW (USER32.@)
4649 */
4650 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4651 {
4652 HRSRC hrsrc = FindResourceW( instance, name, (LPWSTR)RT_MENU );
4653 if (!hrsrc) return 0;
4654 return LoadMenuIndirectW( LoadResource( instance, hrsrc ));
4655 }
4656
4657
4658 /**********************************************************************
4659 * LoadMenuIndirectW (USER32.@)
4660 */
4661 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4662 {
4663 HMENU hMenu;
4664 WORD version, offset;
4665 LPCSTR p = template;
4666
4667 version = GET_WORD(p);
4668 p += sizeof(WORD);
4669 TRACE("%p, ver %d\n", template, version );
4670 switch (version)
4671 {
4672 case 0: /* standard format is version of 0 */
4673 offset = GET_WORD(p);
4674 p += sizeof(WORD) + offset;
4675 if (!(hMenu = CreateMenu())) return 0;
4676 if (!MENU_ParseResource( p, hMenu ))
4677 {
4678 DestroyMenu( hMenu );
4679 return 0;
4680 }
4681 return hMenu;
4682 case 1: /* extended format is version of 1 */
4683 offset = GET_WORD(p);
4684 p += sizeof(WORD) + offset;
4685 if (!(hMenu = CreateMenu())) return 0;
4686 if (!MENUEX_ParseResource( p, hMenu))
4687 {
4688 DestroyMenu( hMenu );
4689 return 0;
4690 }
4691 return hMenu;
4692 default:
4693 ERR("version %d not supported.\n", version);
4694 return 0;
4695 }
4696 }
4697
4698
4699 /**********************************************************************
4700 * LoadMenuIndirectA (USER32.@)
4701 */
4702 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4703 {
4704 return LoadMenuIndirectW( template );
4705 }
4706
4707
4708 /**********************************************************************
4709 * IsMenu (USER32.@)
4710 */
4711 BOOL WINAPI IsMenu(HMENU hmenu)
4712 {
4713 POPUPMENU *menu;
4714 BOOL is_menu;
4715
4716 menu = grab_menu_ptr(hmenu);
4717 is_menu = menu != NULL;
4718 release_menu_ptr(menu);
4719
4720 if (!is_menu)
4721 SetLastError(ERROR_INVALID_MENU_HANDLE);
4722
4723 return is_menu;
4724 }
4725
4726 /**********************************************************************
4727 * GetMenuItemInfo_common
4728 */
4729
4730 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT id, BOOL bypos,
4731 LPMENUITEMINFOW lpmii, BOOL unicode)
4732 {
4733 POPUPMENU *menu;
4734 MENUITEM *item;
4735 UINT pos;
4736
4737 menu = find_menu_item(hmenu, id, bypos ? MF_BYPOSITION : 0, &pos);
4738
4739 item = menu ? &menu->items[pos] : NULL;
4740
4741 debug_print_menuitem("GetMenuItemInfo_common: ", item, "");
4742
4743 if (!menu)
4744 {
4745 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
4746 return FALSE;
4747 }
4748
4749 if( lpmii->fMask & MIIM_TYPE) {
4750 if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) {
4751 release_menu_ptr(menu);
4752 WARN("invalid combination of fMask bits used\n");
4753 /* this does not happen on Win9x/ME */
4754 SetLastError( ERROR_INVALID_PARAMETER);
4755 return FALSE;
4756 }
4757 lpmii->fType = item->fType & MENUITEMINFO_TYPE_MASK;
4758 if (item->hbmpItem && !IS_MAGIC_BITMAP(item->hbmpItem))
4759 lpmii->fType |= MFT_BITMAP;
4760 lpmii->hbmpItem = item->hbmpItem; /* not on Win9x/ME */
4761 if( lpmii->fType & MFT_BITMAP) {
4762 lpmii->dwTypeData = (LPWSTR) item->hbmpItem;
4763 lpmii->cch = 0;
4764 } else if( lpmii->fType & (MFT_OWNERDRAW | MFT_SEPARATOR)) {
4765 /* this does not happen on Win9x/ME */
4766 lpmii->dwTypeData = 0;
4767 lpmii->cch = 0;
4768 }
4769 }
4770
4771 /* copy the text string */
4772 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING))) {
4773 if (!item->text) {
4774 if(lpmii->dwTypeData && lpmii->cch) {
4775 if( unicode)
4776 *((WCHAR *)lpmii->dwTypeData) = 0;
4777 else
4778 *((CHAR *)lpmii->dwTypeData) = 0;
4779 }
4780 lpmii->cch = 0;
4781 } else {
4782 int len;
4783 if (unicode)
4784 {
4785 len = strlenW(item->text);
4786 if(lpmii->dwTypeData && lpmii->cch)
4787 lstrcpynW(lpmii->dwTypeData, item->text, lpmii->cch);
4788 }
4789 else
4790 {
4791 len = WideCharToMultiByte( CP_ACP, 0, item->text, -1, NULL,
4792 0, NULL, NULL ) - 1;
4793 if(lpmii->dwTypeData && lpmii->cch)
4794 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1,
4795 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4796 ((LPSTR)lpmii->dwTypeData)[lpmii->cch - 1] = 0;
4797 }
4798 /* if we've copied a substring we return its length */
4799 if(lpmii->dwTypeData && lpmii->cch)
4800 if (lpmii->cch <= len + 1)
4801 lpmii->cch--;
4802 else
4803 lpmii->cch = len;
4804 else {
4805 /* return length of string */
4806 /* not on Win9x/ME if fType & MFT_BITMAP */
4807 lpmii->cch = len;
4808 }
4809 }
4810 }
4811
4812 if (lpmii->fMask & MIIM_FTYPE)
4813 lpmii->fType = item->fType & MENUITEMINFO_TYPE_MASK;
4814
4815 if (lpmii->fMask & MIIM_BITMAP)
4816 lpmii->hbmpItem = item->hbmpItem;
4817
4818 if (lpmii->fMask & MIIM_STATE)
4819 lpmii->fState = item->fState & MENUITEMINFO_STATE_MASK;
4820
4821 if (lpmii->fMask & MIIM_ID)
4822 lpmii->wID = item->wID;
4823
4824 if (lpmii->fMask & MIIM_SUBMENU)
4825 lpmii->hSubMenu = item->hSubMenu;
4826 else {
4827 /* hSubMenu is always cleared
4828 * (not on Win9x/ME ) */
4829 lpmii->hSubMenu = 0;
4830 }
4831
4832 if (lpmii->fMask & MIIM_CHECKMARKS) {
4833 lpmii->hbmpChecked = item->hCheckBit;
4834 lpmii->hbmpUnchecked = item->hUnCheckBit;
4835 }
4836 if (lpmii->fMask & MIIM_DATA)
4837 lpmii->dwItemData = item->dwItemData;
4838
4839 release_menu_ptr(menu);
4840 return TRUE;
4841 }
4842
4843 /**********************************************************************
4844 * GetMenuItemInfoA (USER32.@)
4845 */
4846 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4847 LPMENUITEMINFOA lpmii)
4848 {
4849 BOOL ret;
4850 MENUITEMINFOA mii;
4851 if( lpmii->cbSize != sizeof( mii) &&
4852 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4853 SetLastError( ERROR_INVALID_PARAMETER);
4854 return FALSE;
4855 }
4856 memcpy( &mii, lpmii, lpmii->cbSize);
4857 mii.cbSize = sizeof( mii);
4858 ret = GetMenuItemInfo_common (hmenu, item, bypos,
4859 (LPMENUITEMINFOW)&mii, FALSE);
4860 mii.cbSize = lpmii->cbSize;
4861 memcpy( lpmii, &mii, mii.cbSize);
4862 return ret;
4863 }
4864
4865 /**********************************************************************
4866 * GetMenuItemInfoW (USER32.@)
4867 */
4868 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4869 LPMENUITEMINFOW lpmii)
4870 {
4871 BOOL ret;
4872 MENUITEMINFOW mii;
4873 if( lpmii->cbSize != sizeof( mii) &&
4874 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4875 SetLastError( ERROR_INVALID_PARAMETER);
4876 return FALSE;
4877 }
4878 memcpy( &mii, lpmii, lpmii->cbSize);
4879 mii.cbSize = sizeof( mii);
4880 ret = GetMenuItemInfo_common (hmenu, item, bypos, &mii, TRUE);
4881 mii.cbSize = lpmii->cbSize;
4882 memcpy( lpmii, &mii, mii.cbSize);
4883 return ret;
4884 }
4885
4886
4887 /* set a menu item text from a ASCII or Unicode string */
4888 static inline void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4889 {
4890 if (!text)
4891 menu->text = NULL;
4892 else if (unicode)
4893 {
4894 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4895 strcpyW( menu->text, text );
4896 }
4897 else
4898 {
4899 LPCSTR str = (LPCSTR)text;
4900 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4901 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4902 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4903 }
4904 }
4905
4906
4907 /**********************************************************************
4908 * MENU_depth
4909 *
4910 * detect if there are loops in the menu tree (or the depth is too large)
4911 */
4912 static int MENU_depth( POPUPMENU *pmenu, int depth)
4913 {
4914 UINT i;
4915 MENUITEM *item;
4916 int subdepth;
4917
4918 depth++;
4919 if( depth > MAXMENUDEPTH) return depth;
4920 item = pmenu->items;
4921 subdepth = depth;
4922 for( i = 0; i < pmenu->nItems && subdepth <= MAXMENUDEPTH; i++, item++){
4923 POPUPMENU *psubmenu = item->hSubMenu ? MENU_GetMenu( item->hSubMenu) : NULL;
4924 if( psubmenu){
4925 int bdepth = MENU_depth( psubmenu, depth);
4926 if( bdepth > subdepth) subdepth = bdepth;
4927 }
4928 if( subdepth > MAXMENUDEPTH)
4929 TRACE("<- hmenu %p\n", item->hSubMenu);
4930 }
4931 return subdepth;
4932 }
4933
4934
4935 /**********************************************************************
4936 * SetMenuItemInfo_common
4937 *
4938 * Note: does not support the MIIM_TYPE flag. Use the MIIM_FTYPE,
4939 * MIIM_BITMAP and MIIM_STRING flags instead.
4940 */
4941
4942 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4943 const MENUITEMINFOW *lpmii,
4944 BOOL unicode)
4945 {
4946 if (!menu) return FALSE;
4947
4948 debug_print_menuitem("SetMenuItemInfo_common from: ", menu, "");
4949
4950 if (lpmii->fMask & MIIM_FTYPE ) {
4951 menu->fType &= ~MENUITEMINFO_TYPE_MASK;
4952 menu->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
4953 }
4954 if (lpmii->fMask & MIIM_STRING ) {
4955 /* free the string when used */
4956 HeapFree(GetProcessHeap(), 0, menu->text);
4957 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4958 }
4959
4960 if (lpmii->fMask & MIIM_STATE)
4961 /* Other menu items having MFS_DEFAULT are not converted
4962 to normal items */
4963 menu->fState = lpmii->fState & MENUITEMINFO_STATE_MASK;
4964
4965 if (lpmii->fMask & MIIM_ID)
4966 menu->wID = lpmii->wID;
4967
4968 if (lpmii->fMask & MIIM_SUBMENU) {
4969 menu->hSubMenu = lpmii->hSubMenu;
4970 if (menu->hSubMenu) {
4971 POPUPMENU *subMenu = MENU_GetMenu(menu->hSubMenu);
4972 if (subMenu) {
4973 if( MENU_depth( subMenu, 0) > MAXMENUDEPTH) {
4974 ERR( "Loop detected in menu hierarchy or maximum menu depth exceeded!\n");
4975 menu->hSubMenu = 0;
4976 return FALSE;
4977 }
4978 subMenu->wFlags |= MF_POPUP;
4979 menu->fType |= MF_POPUP;
4980 } else {
4981 SetLastError( ERROR_INVALID_PARAMETER);
4982 return FALSE;
4983 }
4984 }
4985 else
4986 menu->fType &= ~MF_POPUP;
4987 }
4988
4989 if (lpmii->fMask & MIIM_CHECKMARKS)
4990 {
4991 menu->hCheckBit = lpmii->hbmpChecked;
4992 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4993 }
4994 if (lpmii->fMask & MIIM_DATA)
4995 menu->dwItemData = lpmii->dwItemData;
4996
4997 if (lpmii->fMask & MIIM_BITMAP)
4998 menu->hbmpItem = lpmii->hbmpItem;
4999
5000 if( !menu->text && !(menu->fType & MFT_OWNERDRAW) && !menu->hbmpItem)
5001 menu->fType |= MFT_SEPARATOR;
5002
5003 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
5004 return TRUE;
5005 }
5006
5007 /**********************************************************************
5008 * MENU_NormalizeMenuItemInfoStruct
5009 *
5010 * Helper for SetMenuItemInfo and InsertMenuItemInfo:
5011 * check, copy and extend the MENUITEMINFO struct from the version that the application
5012 * supplied to the version used by wine source. */
5013 static BOOL MENU_NormalizeMenuItemInfoStruct( const MENUITEMINFOW *pmii_in,
5014 MENUITEMINFOW *pmii_out )
5015 {
5016 /* do we recognize the size? */
5017 if( !pmii_in || (pmii_in->cbSize != sizeof( MENUITEMINFOW) &&
5018 pmii_in->cbSize != sizeof( MENUITEMINFOW) - sizeof( pmii_in->hbmpItem)) ) {
5019 SetLastError( ERROR_INVALID_PARAMETER);
5020 return FALSE;
5021 }
5022 /* copy the fields that we have */
5023 memcpy( pmii_out, pmii_in, pmii_in->cbSize);
5024 /* if the hbmpItem member is missing then extend */
5025 if( pmii_in->cbSize != sizeof( MENUITEMINFOW)) {
5026 pmii_out->cbSize = sizeof( MENUITEMINFOW);
5027 pmii_out->hbmpItem = NULL;
5028 }
5029 /* test for invalid bit combinations */
5030 if( (pmii_out->fMask & MIIM_TYPE &&
5031 pmii_out->fMask & (MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) ||
5032 (pmii_out->fMask & MIIM_FTYPE && pmii_out->fType & MFT_BITMAP)) {
5033 WARN("invalid combination of fMask bits used\n");
5034 /* this does not happen on Win9x/ME */
5035 SetLastError( ERROR_INVALID_PARAMETER);
5036 return FALSE;
5037 }
5038 /* convert old style (MIIM_TYPE) to the new */
5039 if( pmii_out->fMask & MIIM_TYPE){
5040 pmii_out->fMask |= MIIM_FTYPE;
5041 if( IS_STRING_ITEM(pmii_out->fType)){
5042 pmii_out->fMask |= MIIM_STRING;
5043 } else if( (pmii_out->fType) & MFT_BITMAP){
5044 pmii_out->fMask |= MIIM_BITMAP;
5045 pmii_out->hbmpItem = UlongToHandle(LOWORD(pmii_out->dwTypeData));
5046 }
5047 }
5048 return TRUE;
5049 }
5050
5051 /**********************************************************************
5052 * SetMenuItemInfoA (USER32.@)
5053 */
5054 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
5055 const MENUITEMINFOA *lpmii)
5056 {
5057 MENUITEMINFOW mii;
5058 POPUPMENU *menu;
5059 UINT pos;
5060 BOOL ret;
5061
5062 TRACE("hmenu %p, item %u, by pos %d, info %p\n", hmenu, item, bypos, lpmii);
5063
5064 if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &mii )) return FALSE;
5065
5066 if (!(menu = find_menu_item(hmenu, item, bypos ? MF_BYPOSITION : 0, &pos)))
5067 {
5068 /* workaround for Word 95: pretend that SC_TASKLIST item exists */
5069 if (item == SC_TASKLIST && !bypos) return TRUE;
5070 return FALSE;
5071 }
5072 ret = SetMenuItemInfo_common(&menu->items[pos], &mii, FALSE);
5073 release_menu_ptr(menu);
5074 return ret;
5075 }
5076
5077 /**********************************************************************
5078 * SetMenuItemInfoW (USER32.@)
5079 */
5080 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
5081 const MENUITEMINFOW *lpmii)
5082 {
5083 MENUITEMINFOW mii;
5084 POPUPMENU *menu;
5085 BOOL ret;
5086 UINT pos;
5087
5088 TRACE("hmenu %p, item %u, by pos %d, info %p\n", hmenu, item, bypos, lpmii);
5089
5090 if (!MENU_NormalizeMenuItemInfoStruct( lpmii, &mii )) return FALSE;
5091
5092 if (!(menu = find_menu_item(hmenu, item, bypos ? MF_BYPOSITION : 0, &pos)))
5093 {
5094 /* workaround for Word 95: pretend that SC_TASKLIST item exists */
5095 if (item == SC_TASKLIST && !bypos) return TRUE;
5096 return FALSE;
5097 }
5098
5099 ret = SetMenuItemInfo_common(&menu->items[pos], &mii, TRUE);
5100 release_menu_ptr(menu);
5101 return ret;
5102 }
5103
5104 static BOOL set_menu_default_item(POPUPMENU *menu, UINT uItem, UINT bypos)
5105 {
5106 unsigned int i;
5107 MENUITEM *item;
5108
5109 /* reset all default-item flags */
5110 item = menu->items;
5111 for (i = 0; i < menu->nItems; i++, item++)
5112 {
5113 item->fState &= ~MFS_DEFAULT;
5114 }
5115
5116 /* no default item */
5117 if (-1 == uItem)
5118 return TRUE;
5119
5120 item = menu->items;
5121 if ( bypos )
5122 {
5123 if ( uItem >= menu->nItems ) return FALSE;
5124 item[uItem].fState |= MFS_DEFAULT;
5125 return TRUE;
5126 }
5127 else
5128 {
5129 for (i = 0; i < menu->nItems; i++, item++)
5130 {
5131 if (item->wID == uItem)
5132 {
5133 item->fState |= MFS_DEFAULT;
5134 return TRUE;
5135 }
5136 }
5137 }
5138
5139 return FALSE;
5140 }
5141
5142 /**********************************************************************
5143 * SetMenuDefaultItem (USER32.@)
5144 *
5145 */
5146 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
5147 {
5148 POPUPMENU *menu;
5149 BOOL ret;
5150
5151 TRACE("(%p,%d,%d)\n", hmenu, uItem, bypos);
5152
5153 if (!(menu = grab_menu_ptr(hmenu))) return FALSE;
5154 ret = set_menu_default_item(menu, uItem, bypos);
5155 release_menu_ptr(menu);
5156
5157 return ret;
5158 }
5159
5160 /**********************************************************************
5161 * GetMenuDefaultItem (USER32.@)
5162 */
5163 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
5164 {
5165 POPUPMENU *menu;
5166 MENUITEM * item;
5167 UINT i = 0;
5168
5169 TRACE("(%p,%d,%d)\n", hmenu, bypos, flags);
5170
5171 if (!(menu = MENU_GetMenu(hmenu))) return -1;
5172
5173 /* find default item */
5174 item = menu->items;
5175
5176 /* empty menu */
5177 if (! item) return -1;
5178
5179 while ( !( item->fState & MFS_DEFAULT ) )
5180 {
5181 i++; item++;
5182 if (i >= menu->nItems ) return -1;
5183 }
5184
5185 /* default: don't return disabled items */
5186 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
5187
5188 /* search rekursiv when needed */
5189 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
5190 {
5191 UINT ret;
5192 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
5193 if ( -1 != ret ) return ret;
5194
5195 /* when item not found in submenu, return the popup item */
5196 }
5197 return ( bypos ) ? i : item->wID;
5198
5199 }
5200
5201
5202 /**********************************************************************
5203 * InsertMenuItemA (USER32.@)
5204 */
5205 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
5206 const MENUITEMINFOA *lpmii)
5207 {
5208 MENUITEMINFOW mii;
5209 POPUPMENU *menu;
5210 UINT pos;
5211 BOOL ret;
5212
5213 TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, bypos, lpmii);
5214
5215 if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &mii )) return FALSE;
5216
5217 if (!(menu = insert_menu_item(hMenu, uItem, bypos ? MF_BYPOSITION : 0, &pos)))
5218 return FALSE;
5219
5220 ret = SetMenuItemInfo_common(&menu->items[pos], &mii, FALSE);
5221 release_menu_ptr(menu);
5222 return ret;
5223 }
5224
5225
5226 /**********************************************************************
5227 * InsertMenuItemW (USER32.@)
5228 */
5229 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
5230 const MENUITEMINFOW *lpmii)
5231 {
5232 MENUITEMINFOW mii;
5233 POPUPMENU *menu;
5234 UINT pos;
5235 BOOL ret;
5236
5237 TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, bypos, lpmii);
5238
5239 if (!MENU_NormalizeMenuItemInfoStruct( lpmii, &mii )) return FALSE;
5240
5241 if (!(menu = insert_menu_item(hMenu, uItem, bypos ? MF_BYPOSITION : 0, &pos)))
5242 return FALSE;
5243
5244 ret = SetMenuItemInfo_common(&menu->items[pos], &mii, TRUE);
5245 release_menu_ptr(menu);
5246 return ret;
5247 }
5248
5249 /**********************************************************************
5250 * CheckMenuRadioItem (USER32.@)
5251 */
5252
5253 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu, UINT first, UINT last,
5254 UINT check, UINT flags)
5255 {
5256 POPUPMENU *first_menu = NULL, *check_menu;
5257 UINT i, check_pos;
5258 BOOL done = FALSE;
5259
5260 for (i = first; i <= last; i++)
5261 {
5262 MENUITEM *item;
5263
5264 if (!(check_menu = find_menu_item(hMenu, i, flags, &check_pos)))
5265 continue;
5266
5267 if (!first_menu)
5268 first_menu = grab_menu_ptr(check_menu->obj.handle);
5269
5270 if (first_menu != check_menu)
5271 {
5272 release_menu_ptr(check_menu);
5273 continue;
5274 }
5275
5276 item = &check_menu->items[check_pos];
5277 if (item->fType != MFT_SEPARATOR)
5278 {
5279 if (i == check)
5280 {
5281 item->fType |= MFT_RADIOCHECK;
5282 item->fState |= MFS_CHECKED;
5283 done = TRUE;
5284 }
5285 else
5286 {
5287 /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
5288 item->fState &= ~MFS_CHECKED;
5289 }
5290 }
5291
5292 release_menu_ptr(check_menu);
5293 }
5294 release_menu_ptr(first_menu);
5295
5296 return done;
5297 }
5298
5299
5300 /**********************************************************************
5301 * GetMenuItemRect (USER32.@)
5302 *
5303 * ATTENTION: Here, the returned values in rect are the screen
5304 * coordinates of the item just like if the menu was
5305 * always on the upper left side of the application.
5306 *
5307 */
5308 BOOL WINAPI GetMenuItemRect(HWND hwnd, HMENU hMenu, UINT uItem, RECT *rect)
5309 {
5310 POPUPMENU *menu;
5311 UINT pos;
5312
5313 TRACE("(%p,%p,%d,%p)\n", hwnd, hMenu, uItem, rect);
5314
5315 if (!rect)
5316 return FALSE;
5317
5318 if (!(menu = find_menu_item(hMenu, uItem, MF_BYPOSITION, &pos)))
5319 return FALSE;
5320
5321 if (!hwnd) hwnd = menu->hWnd;
5322 if (!hwnd)
5323 {
5324 release_menu_ptr(menu);
5325 return FALSE;
5326 }
5327
5328 *rect = menu->items[pos].rect;
5329 OffsetRect(rect, menu->items_rect.left, menu->items_rect.top);
5330 release_menu_ptr(menu);
5331
5332 MapWindowPoints(hwnd, 0, (POINT *)rect, 2);
5333 return TRUE;
5334 }
5335
5336 /**********************************************************************
5337 * SetMenuInfo (USER32.@)
5338 *
5339 * FIXME
5340 * actually use the items to draw the menu
5341 * (recalculate and/or redraw)
5342 */
5343 static BOOL menu_SetMenuInfo( HMENU hMenu, LPCMENUINFO lpmi)
5344 {
5345 POPUPMENU *menu;
5346 if( !(menu = MENU_GetMenu(hMenu))) return FALSE;
5347
5348 if (lpmi->fMask & MIM_BACKGROUND)
5349 menu->hbrBack = lpmi->hbrBack;
5350
5351 if (lpmi->fMask & MIM_HELPID)
5352 menu->dwContextHelpID = lpmi->dwContextHelpID;
5353
5354 if (lpmi->fMask & MIM_MAXHEIGHT)
5355 menu->cyMax = lpmi->cyMax;
5356
5357 if (lpmi->fMask & MIM_MENUDATA)
5358 menu->dwMenuData = lpmi->dwMenuData;
5359
5360 if (lpmi->fMask & MIM_STYLE)
5361 menu->dwStyle = lpmi->dwStyle;
5362
5363 if( lpmi->fMask & MIM_APPLYTOSUBMENUS) {
5364 int i;
5365 MENUITEM *item = menu->items;
5366 for( i = menu->nItems; i; i--, item++)
5367 if( item->fType & MF_POPUP)
5368 menu_SetMenuInfo( item->hSubMenu, lpmi);
5369 }
5370 return TRUE;
5371 }
5372
5373 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
5374 {
5375 TRACE("(%p %p)\n", hMenu, lpmi);
5376 if( lpmi && (lpmi->cbSize == sizeof( MENUINFO)) && (menu_SetMenuInfo( hMenu, lpmi))) {
5377 if( lpmi->fMask & MIM_STYLE) {
5378 if (lpmi->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented\n");
5379 if (lpmi->dwStyle & MNS_DRAGDROP) FIXME("MNS_DRAGDROP unimplemented\n");
5380 if (lpmi->dwStyle & MNS_MODELESS) FIXME("MNS_MODELESS unimplemented\n");
5381 }
5382 return TRUE;
5383 }
5384 SetLastError( ERROR_INVALID_PARAMETER);
5385 return FALSE;
5386 }
5387
5388 /**********************************************************************
5389 * GetMenuInfo (USER32.@)
5390 *
5391 * NOTES
5392 * win98/NT5.0
5393 *
5394 */
5395 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
5396 {
5397 POPUPMENU *menu;
5398
5399 TRACE("(%p %p)\n", hMenu, lpmi);
5400
5401 if (lpmi && (lpmi->cbSize == sizeof(MENUINFO)) && (menu = grab_menu_ptr(hMenu)))
5402 {
5403 if (lpmi->fMask & MIM_BACKGROUND)
5404 lpmi->hbrBack = menu->hbrBack;
5405
5406 if (lpmi->fMask & MIM_HELPID)
5407 lpmi->dwContextHelpID = menu->dwContextHelpID;
5408
5409 if (lpmi->fMask & MIM_MAXHEIGHT)
5410 lpmi->cyMax = menu->cyMax;
5411
5412 if (lpmi->fMask & MIM_MENUDATA)
5413 lpmi->dwMenuData = menu->dwMenuData;
5414
5415 if (lpmi->fMask & MIM_STYLE)
5416 lpmi->dwStyle = menu->dwStyle;
5417
5418 release_menu_ptr(menu);
5419 return TRUE;
5420 }
5421 SetLastError( ERROR_INVALID_PARAMETER);
5422 return FALSE;
5423 }
5424
5425
5426 /**********************************************************************
5427 * SetMenuContextHelpId (USER32.@)
5428 */
5429 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
5430 {
5431 POPUPMENU *menu;
5432
5433 TRACE("(%p 0x%08x)\n", hMenu, dwContextHelpID);
5434
5435 if ((menu = grab_menu_ptr(hMenu)))
5436 {
5437 menu->dwContextHelpID = dwContextHelpID;
5438 release_menu_ptr(menu);
5439 return TRUE;
5440 }
5441 return FALSE;
5442 }
5443
5444
5445 /**********************************************************************
5446 * GetMenuContextHelpId (USER32.@)
5447 */
5448 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
5449 {
5450 DWORD help_id = 0;
5451 POPUPMENU *menu;
5452
5453 TRACE("(%p)\n", hMenu);
5454
5455 if ((menu = grab_menu_ptr(hMenu)))
5456 {
5457 help_id = menu->dwContextHelpID;
5458 release_menu_ptr(menu);
5459 }
5460
5461 return help_id;
5462 }
5463
5464 /**********************************************************************
5465 * MenuItemFromPoint (USER32.@)
5466 */
5467 INT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
5468 {
5469 POPUPMENU *menu = grab_menu_ptr(hMenu);
5470 UINT pos;
5471
5472 /*FIXME: Do we have to handle hWnd here? */
5473 if (!menu) return -1;
5474
5475 if (MENU_FindItemByCoords( menu, ptScreen, &pos ) != ht_item)
5476 pos = -1;
5477
5478 release_menu_ptr(menu);
5479 return pos;
5480 }
5481
5482
5483 /**********************************************************************
5484 * CalcMenuBar (USER32.@)
5485 */
5486 DWORD WINAPI CalcMenuBar(HWND hwnd, DWORD left, DWORD right, DWORD top, RECT *rect)
5487 {
5488 FIXME("(%p, %d, %d, %d, %p): stub\n", hwnd, left, right, top, rect);
5489 return 0;
5490 }
5491
5492
5493 /**********************************************************************
5494 * translate_accelerator
5495 */
5496 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
5497 BYTE fVirt, WORD key, WORD cmd )
5498 {
5499 INT mask = 0;
5500 UINT mesg = 0;
5501
5502 if (wParam != key) return FALSE;
5503
5504 if (GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
5505 if (GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
5506 if (GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
5507
5508 if (message == WM_CHAR || message == WM_SYSCHAR)
5509 {
5510 if ( !(fVirt & FVIRTKEY) && (mask & FALT) == (fVirt & FALT) )
5511 {
5512 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", LOWORD(wParam) & 0xff);
5513 goto found;
5514 }
5515 }
5516 else
5517 {
5518 if(fVirt & FVIRTKEY)
5519 {
5520 TRACE_(accel)("found accel for virt_key %04lx (scan %04x)\n",
5521 wParam, 0xff & HIWORD(lParam));
5522
5523 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
5524 TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
5525 }
5526 else
5527 {
5528 if (!(lParam & 0x01000000)) /* no special_key */
5529 {
5530 if ((fVirt & FALT) && (lParam & 0x20000000))
5531 { /* ^^ ALT pressed */
5532 TRACE_(accel)("found accel for Alt-%c\n", LOWORD(wParam) & 0xff);
5533 goto found;
5534 }
5535 }
5536 }
5537 }
5538 return FALSE;
5539
5540 found:
5541 if (message == WM_KEYUP || message == WM_SYSKEYUP)
5542 mesg = 1;
5543 else
5544 {
5545 HMENU hMenu, hSubMenu, hSysMenu;
5546 UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
5547 POPUPMENU *menu;
5548
5549 hMenu = (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
5550 hSysMenu = get_win_sys_menu( hWnd );
5551
5552 /* find menu item and ask application to initialize it */
5553 /* 1. in the system menu */
5554 if ((menu = find_menu_item(hSysMenu, cmd, MF_BYCOMMAND, NULL)))
5555 {
5556 hSubMenu = menu->obj.handle;
5557 release_menu_ptr(menu);
5558
5559 if (GetCapture())
5560 mesg = 2;
5561 if (!IsWindowEnabled(hWnd))
5562 mesg = 3;
5563 else
5564 {
5565 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
5566 if(hSubMenu != hSysMenu)
5567 {
5568 nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
5569 TRACE_(accel)("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hSysMenu, hSubMenu, nPos);
5570 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
5571 }
5572 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
5573 }
5574 }
5575 else /* 2. in the window's menu */
5576 {
5577 if ((menu = find_menu_item(hMenu, cmd, MF_BYCOMMAND, NULL)))
5578 {
5579 hSubMenu = menu->obj.handle;
5580 release_menu_ptr(menu);
5581
5582 if (GetCapture())
5583 mesg = 2;
5584 if (!IsWindowEnabled(hWnd))
5585 mesg = 3;
5586 else
5587 {
5588 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
5589 if(hSubMenu != hMenu)
5590 {
5591 nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
5592 TRACE_(accel)("hMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
5593 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
5594 }
5595 uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
5596 }
5597 }
5598 }
5599
5600 if (mesg == 0)
5601 {
5602 if (uSysStat != (UINT)-1)
5603 {
5604 if (uSysStat & (MF_DISABLED|MF_GRAYED))
5605 mesg=4;
5606 else
5607 mesg=WM_SYSCOMMAND;
5608 }
5609 else
5610 {
5611 if (uStat != (UINT)-1)
5612 {
5613 if (IsIconic(hWnd))
5614 mesg=5;
5615 else
5616 {
5617 if (uStat & (MF_DISABLED|MF_GRAYED))
5618 mesg=6;
5619 else
5620 mesg=WM_COMMAND;
5621 }
5622 }
5623 else
5624 mesg=WM_COMMAND;
5625 }
5626 }
5627 }
5628
5629 if( mesg==WM_COMMAND )
5630 {
5631 TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
5632 SendMessageW(hWnd, mesg, 0x10000 | cmd, 0L);
5633 }
5634 else if( mesg==WM_SYSCOMMAND )
5635 {
5636 TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
5637 SendMessageW(hWnd, mesg, cmd, 0x00010000L);
5638 }
5639 else
5640 {
5641 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
5642 * #0: unknown (please report!)
5643 * #1: for WM_KEYUP,WM_SYSKEYUP
5644 * #2: mouse is captured
5645 * #3: window is disabled
5646 * #4: it's a disabled system menu option
5647 * #5: it's a menu option, but window is iconic
5648 * #6: it's a menu option, but disabled
5649 */
5650 TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
5651 if(mesg==0)
5652 ERR_(accel)(" unknown reason - please report!\n");
5653 }
5654 return TRUE;
5655 }
5656
5657 /**********************************************************************
5658 * TranslateAcceleratorA (USER32.@)
5659 * TranslateAccelerator (USER32.@)
5660 */
5661 INT WINAPI TranslateAcceleratorA( HWND hWnd, HACCEL hAccel, LPMSG msg )
5662 {
5663 switch (msg->message)
5664 {
5665 case WM_KEYDOWN:
5666 case WM_SYSKEYDOWN:
5667 return TranslateAcceleratorW( hWnd, hAccel, msg );
5668
5669 case WM_CHAR:
5670 case WM_SYSCHAR:
5671 {
5672 MSG msgW = *msg;
5673 char ch = LOWORD(msg->wParam);
5674 WCHAR wch;
5675 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
5676 msgW.wParam = MAKEWPARAM(wch, HIWORD(msg->wParam));
5677 return TranslateAcceleratorW( hWnd, hAccel, &msgW );
5678 }
5679
5680 default:
5681 return 0;
5682 }
5683 }
5684
5685 /**********************************************************************
5686 * TranslateAcceleratorW (USER32.@)
5687 */
5688 INT WINAPI TranslateAcceleratorW( HWND hWnd, HACCEL hAccel, LPMSG msg )
5689 {
5690 ACCEL data[32], *ptr = data;
5691 int i, count;
5692
5693 if (!hWnd) return 0;
5694
5695 if (msg->message != WM_KEYDOWN &&
5696 msg->message != WM_SYSKEYDOWN &&
5697 msg->message != WM_CHAR &&
5698 msg->message != WM_SYSCHAR)
5699 return 0;
5700
5701 TRACE_(accel)("hAccel %p, hWnd %p, msg->hwnd %p, msg->message %04x, wParam %08lx, lParam %08lx\n",
5702 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5703
5704 if (!(count = CopyAcceleratorTableW( hAccel, NULL, 0 ))) return 0;
5705 if (count > ARRAY_SIZE( data ))
5706 {
5707 if (!(ptr = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ptr) ))) return 0;
5708 }
5709 count = CopyAcceleratorTableW( hAccel, ptr, count );
5710 for (i = 0; i < count; i++)
5711 {
5712 if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
5713 ptr[i].fVirt, ptr[i].key, ptr[i].cmd))
5714 break;
5715 }
5716 if (ptr != data) HeapFree( GetProcessHeap(), 0, ptr );
5717 return (i < count);
5718 }
Windows API implementation