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