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