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