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