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