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