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