?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Don't set target flags if build and host are the same.
[wine/multimedia.git] / dlls / user32 / menu.c
blobefb14c6ba68ca5b87e4f030279b81c016a0e0067
1 /*
2 * Menu functions
3 *
4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994 Alexandre Julliard
6 * Copyright 1997 Morten Welinder
7 * Copyright 2005 Maxime Bellengé
8 * Copyright 2006 Phil Krylov
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 /*
26 * Note: the style MF_MOUSESELECT is used to mark popup items that
27 * have been selected, i.e. their popup menu is currently displayed.
28 * This is probably not the meaning this style has in MS-Windows.
29 *
30 * Note 2: where there is a difference, these menu API's are according
31 * the behavior of Windows 2k and Windows XP. Known differences with
32 * Windows 9x/ME are documented in the comments, in case an application
33 * is found to depend on the old behavior.
34 *
35 * TODO:
36 * implements styles :
37 * - MNS_AUTODISMISS
38 * - MNS_DRAGDROP
39 * - MNS_MODELESS
40 */
41
42 #include "config.h"
43 #include "wine/port.h"
44
45 #include <stdarg.h>
46 #include <string.h>
47
48 #define OEMRESOURCE
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "wingdi.h"
53 #include "winnls.h"
54 #include "wine/winbase16.h"
55 #include "wine/winuser16.h"
56 #include "wownt32.h"
57 #include "wine/server.h"
58 #include "wine/unicode.h"
59 #include "wine/exception.h"
60 #include "win.h"
61 #include "controls.h"
62 #include "user_private.h"
63 #include "wine/debug.h"
64
65 WINE_DEFAULT_DEBUG_CHANNEL(menu);
66 WINE_DECLARE_DEBUG_CHANNEL(accel);
67
68 /* internal popup menu window messages */
69
70 #define MM_SETMENUHANDLE (WM_USER + 0)
71 #define MM_GETMENUHANDLE (WM_USER + 1)
72
73 /* Menu item structure */
74 typedef struct {
75 /* ----------- MENUITEMINFO Stuff ----------- */
76 UINT fType; /* Item type. */
77 UINT fState; /* Item state. */
78 UINT_PTR wID; /* Item id. */
79 HMENU hSubMenu; /* Pop-up menu. */
80 HBITMAP hCheckBit; /* Bitmap when checked. */
81 HBITMAP hUnCheckBit; /* Bitmap when unchecked. */
82 LPWSTR text; /* Item text. */
83 ULONG_PTR dwItemData; /* Application defined. */
84 LPWSTR dwTypeData; /* depends on fMask */
85 HBITMAP hbmpItem; /* bitmap */
86 /* ----------- Wine stuff ----------- */
87 RECT rect; /* Item area (relative to menu window) */
88 UINT xTab; /* X position of text after Tab */
89 SIZE bmpsize; /* size needed for the HBMMENU_CALLBACK
90 * bitmap */
91 } MENUITEM;
92
93 /* Popup menu structure */
94 typedef struct {
95 WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
96 WORD wMagic; /* Magic number */
97 WORD Width; /* Width of the whole menu */
98 WORD Height; /* Height of the whole menu */
99 UINT nItems; /* Number of items in the menu */
100 HWND hWnd; /* Window containing the menu */
101 MENUITEM *items; /* Array of menu items */
102 UINT FocusedItem; /* Currently focused item */
103 HWND hwndOwner; /* window receiving the messages for ownerdraw */
104 BOOL bTimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
105 BOOL bScrolling; /* Scroll arrows are active */
106 UINT nScrollPos; /* Current scroll position */
107 UINT nTotalHeight; /* Total height of menu items inside menu */
108 /* ------------ MENUINFO members ------ */
109 DWORD dwStyle; /* Extended menu style */
110 UINT cyMax; /* max height of the whole menu, 0 is screen height */
111 HBRUSH hbrBack; /* brush for menu background */
112 DWORD dwContextHelpID;
113 DWORD dwMenuData; /* application defined value */
114 HMENU hSysMenuOwner; /* Handle to the dummy sys menu holder */
115 SIZE maxBmpSize; /* Maximum size of the bitmap items */
116 } POPUPMENU, *LPPOPUPMENU;
117
118 /* internal flags for menu tracking */
119
120 #define TF_ENDMENU 0x10000
121 #define TF_SUSPENDPOPUP 0x20000
122 #define TF_SKIPREMOVE 0x40000
123
124 typedef struct
125 {
126 UINT trackFlags;
127 HMENU hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/
128 HMENU hTopMenu; /* initial menu */
129 HWND hOwnerWnd; /* where notifications are sent */
130 POINT pt;
131 } MTRACKER;
132
133 #define MENU_MAGIC 0x554d /* 'MU' */
134
135 #define ITEM_PREV -1
136 #define ITEM_NEXT 1
137
138 /* Internal MENU_TrackMenu() flags */
139 #define TPM_INTERNAL 0xF0000000
140 #define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */
141 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
142 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
143
144 /* Space between 2 columns */
145 #define MENU_COL_SPACE 4
146
147 /* top and bottom margins for popup menus */
148 #define MENU_TOP_MARGIN 3
149 #define MENU_BOTTOM_MARGIN 2
150
151 /* (other menu->FocusedItem values give the position of the focused item) */
152 #define NO_SELECTED_ITEM 0xffff
153
154 #define MENU_ITEM_TYPE(flags) \
155 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
156
157 /* macro to test that flags do not indicate bitmap, ownerdraw or separator */
158 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
159 #define IS_MAGIC_BITMAP(id) ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))
160
161 #define IS_SYSTEM_MENU(menu) \
162 (!((menu)->wFlags & MF_POPUP) && ((menu)->wFlags & MF_SYSMENU))
163
164 #define MENUITEMINFO_TYPE_MASK \
165 (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
166 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
167 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY /* same as MF_HELP */ )
168 #define TYPE_MASK (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)
169 #define STATE_MASK (~TYPE_MASK)
170 #define MENUITEMINFO_STATE_MASK (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT))
171
172 #define WIN_ALLOWED_MENU(style) ((style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
173
174 static SIZE menucharsize;
175 static UINT ODitemheight; /* default owner drawn item height */
176
177 /* Use global popup window because there's no way 2 menus can
178 * be tracked at the same time. */
179 static HWND top_popup;
180
181 /* Flag set by EndMenu() to force an exit from menu tracking */
182 static BOOL fEndMenu = FALSE;
183
184 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
185
186 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont);
187
188 /*********************************************************************
189 * menu class descriptor
190 */
191 const struct builtin_class_descr MENU_builtin_class =
192 {
193 (LPCWSTR)POPUPMENU_CLASS_ATOM, /* name */
194 CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS, /* style */
195 NULL, /* procA (winproc is Unicode only) */
196 PopupMenuWndProc, /* procW */
197 sizeof(HMENU), /* extra */
198 IDC_ARROW, /* cursor */
199 (HBRUSH)(COLOR_MENU+1) /* brush */
200 };
201
202
203 /***********************************************************************
204 * debug_print_menuitem
205 *
206 * Print a menuitem in readable form.
207 */
208
209 #define debug_print_menuitem(pre, mp, post) \
210 do { if (TRACE_ON(menu)) do_debug_print_menuitem(pre, mp, post); } while (0)
211
212 #define MENUOUT(text) \
213 TRACE("%s%s", (count++ ? "," : ""), (text))
214
215 #define MENUFLAG(bit,text) \
216 do { \
217 if (flags & (bit)) { flags &= ~(bit); MENUOUT ((text)); } \
218 } while (0)
219
220 static void do_debug_print_menuitem(const char *prefix, const MENUITEM *mp,
221 const char *postfix)
222 {
223 static const char * const hbmmenus[] = { "HBMMENU_CALLBACK", "", "HBMMENU_SYSTEM",
224 "HBMMENU_MBAR_RESTORE", "HBMMENU_MBAR_MINIMIZE", "UNKNOWN BITMAP", "HBMMENU_MBAR_CLOSE",
225 "HBMMENU_MBAR_CLOSE_D", "HBMMENU_MBAR_MINIMIZE_D", "HBMMENU_POPUP_CLOSE",
226 "HBMMENU_POPUP_RESTORE", "HBMMENU_POPUP_MAXIMIZE", "HBMMENU_POPUP_MINIMIZE"};
227 TRACE("%s ", prefix);
228 if (mp) {
229 UINT flags = mp->fType;
230 TRACE( "{ ID=0x%lx", mp->wID);
231 if ( mp->hSubMenu)
232 TRACE( ", Sub=%p", mp->hSubMenu);
233 if (flags) {
234 int count = 0;
235 TRACE( ", fType=");
236 MENUFLAG( MFT_SEPARATOR, "sep");
237 MENUFLAG( MFT_OWNERDRAW, "own");
238 MENUFLAG( MFT_BITMAP, "bit");
239 MENUFLAG(MF_POPUP, "pop");
240 MENUFLAG(MFT_MENUBARBREAK, "barbrk");
241 MENUFLAG(MFT_MENUBREAK, "brk");
242 MENUFLAG(MFT_RADIOCHECK, "radio");
243 MENUFLAG(MFT_RIGHTORDER, "rorder");
244 MENUFLAG(MF_SYSMENU, "sys");
245 MENUFLAG(MFT_RIGHTJUSTIFY, "right"); /* same as MF_HELP */
246 if (flags)
247 TRACE( "+0x%x", flags);
248 }
249 flags = mp->fState;
250 if (flags) {
251 int count = 0;
252 TRACE( ", State=");
253 MENUFLAG(MFS_GRAYED, "grey");
254 MENUFLAG(MFS_DEFAULT, "default");
255 MENUFLAG(MFS_DISABLED, "dis");
256 MENUFLAG(MFS_CHECKED, "check");
257 MENUFLAG(MFS_HILITE, "hi");
258 MENUFLAG(MF_USECHECKBITMAPS, "usebit");
259 MENUFLAG(MF_MOUSESELECT, "mouse");
260 if (flags)
261 TRACE( "+0x%x", flags);
262 }
263 if (mp->hCheckBit)
264 TRACE( ", Chk=%p", mp->hCheckBit);
265 if (mp->hUnCheckBit)
266 TRACE( ", Unc=%p", mp->hUnCheckBit);
267 if (mp->text)
268 TRACE( ", Text=%s", debugstr_w(mp->text));
269 if (mp->dwItemData)
270 TRACE( ", ItemData=0x%08lx", mp->dwItemData);
271 if (mp->hbmpItem)
272 {
273 if( IS_MAGIC_BITMAP(mp->hbmpItem))
274 TRACE( ", hbitmap=%s", hbmmenus[ (INT_PTR)mp->hbmpItem + 1]);
275 else
276 TRACE( ", hbitmap=%p", mp->hbmpItem);
277 }
278 TRACE( " }");
279 } else
280 TRACE( "NULL");
281 TRACE(" %s\n", postfix);
282 }
283
284 #undef MENUOUT
285 #undef MENUFLAG
286
287
288 /***********************************************************************
289 * MENU_GetMenu
290 *
291 * Validate the given menu handle and returns the menu structure pointer.
292 */
293 static POPUPMENU *MENU_GetMenu(HMENU hMenu)
294 {
295 POPUPMENU *menu = USER_HEAP_LIN_ADDR(hMenu);
296 if (!menu || menu->wMagic != MENU_MAGIC)
297 {
298 WARN("invalid menu handle=%p, ptr=%p, magic=%x\n", hMenu, menu, menu? menu->wMagic:0);
299 menu = NULL;
300 }
301 return menu;
302 }
303
304 /***********************************************************************
305 * get_win_sys_menu
306 *
307 * Get the system menu of a window
308 */
309 static HMENU get_win_sys_menu( HWND hwnd )
310 {
311 HMENU ret = 0;
312 WND *win = WIN_GetPtr( hwnd );
313 if (win && win != WND_OTHER_PROCESS && win != WND_DESKTOP)
314 {
315 ret = win->hSysMenu;
316 WIN_ReleasePtr( win );
317 }
318 return ret;
319 }
320
321 /***********************************************************************
322 * get_menu_font
323 */
324 static HFONT get_menu_font( BOOL bold )
325 {
326 static HFONT hMenuFont, hMenuFontBold;
327
328 HFONT ret = bold ? hMenuFontBold : hMenuFont;
329
330 if (!ret)
331 {
332 NONCLIENTMETRICSW ncm;
333 HFONT prev;
334
335 ncm.cbSize = sizeof(NONCLIENTMETRICSW);
336 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSW), &ncm, 0);
337
338 if (bold)
339 {
340 ncm.lfMenuFont.lfWeight += 300;
341 if (ncm.lfMenuFont.lfWeight > 1000) ncm.lfMenuFont.lfWeight = 1000;
342 }
343 if (!(ret = CreateFontIndirectW( &ncm.lfMenuFont ))) return 0;
344 prev = InterlockedCompareExchangePointer( (void **)(bold ? &hMenuFontBold : &hMenuFont),
345 ret, NULL );
346 if (prev)
347 {
348 /* another thread beat us to it */
349 DeleteObject( ret );
350 ret = prev;
351 }
352 }
353 return ret;
354 }
355
356 /***********************************************************************
357 * get_arrow_bitmap
358 */
359 static HBITMAP get_arrow_bitmap(void)
360 {
361 static HBITMAP arrow_bitmap;
362
363 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW));
364 return arrow_bitmap;
365 }
366
367 /***********************************************************************
368 * get_down_arrow_bitmap
369 */
370 static HBITMAP get_down_arrow_bitmap(void)
371 {
372 static HBITMAP arrow_bitmap;
373
374 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROW));
375 return arrow_bitmap;
376 }
377
378 /***********************************************************************
379 * get_down_arrow_inactive_bitmap
380 */
381 static HBITMAP get_down_arrow_inactive_bitmap(void)
382 {
383 static HBITMAP arrow_bitmap;
384
385 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROWI));
386 return arrow_bitmap;
387 }
388
389 /***********************************************************************
390 * get_up_arrow_bitmap
391 */
392 static HBITMAP get_up_arrow_bitmap(void)
393 {
394 static HBITMAP arrow_bitmap;
395
396 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROW));
397 return arrow_bitmap;
398 }
399
400 /***********************************************************************
401 * get_up_arrow_inactive_bitmap
402 */
403 static HBITMAP get_up_arrow_inactive_bitmap(void)
404 {
405 static HBITMAP arrow_bitmap;
406
407 if (!arrow_bitmap) arrow_bitmap = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROWI));
408 return arrow_bitmap;
409 }
410
411 /***********************************************************************
412 * MENU_CopySysPopup
413 *
414 * Return the default system menu.
415 */
416 static HMENU MENU_CopySysPopup(void)
417 {
418 static const WCHAR sysmenuW[] = {'S','Y','S','M','E','N','U',0};
419 HMENU hMenu = LoadMenuW(user32_module, sysmenuW);
420
421 if( hMenu ) {
422 POPUPMENU* menu = MENU_GetMenu(hMenu);
423 menu->wFlags |= MF_SYSMENU | MF_POPUP;
424 SetMenuDefaultItem(hMenu, SC_CLOSE, FALSE);
425 }
426 else
427 ERR("Unable to load default system menu\n" );
428
429 TRACE("returning %p.\n", hMenu );
430
431 return hMenu;
432 }
433
434
435 /**********************************************************************
436 * MENU_GetSysMenu
437 *
438 * Create a copy of the system menu. System menu in Windows is
439 * a special menu bar with the single entry - system menu popup.
440 * This popup is presented to the outside world as a "system menu".
441 * However, the real system menu handle is sometimes seen in the
442 * WM_MENUSELECT parameters (and Word 6 likes it this way).
443 */
444 static HMENU MENU_GetSysMenu( HWND hWnd, HMENU hPopupMenu )
445 {
446 HMENU hMenu;
447
448 TRACE("loading system menu, hWnd %p, hPopupMenu %p\n", hWnd, hPopupMenu);
449 if ((hMenu = CreateMenu()))
450 {
451 POPUPMENU *menu = MENU_GetMenu(hMenu);
452 menu->wFlags = MF_SYSMENU;
453 menu->hWnd = WIN_GetFullHandle( hWnd );
454 TRACE("hWnd %p (hMenu %p)\n", menu->hWnd, hMenu);
455
456 if (!hPopupMenu)
457 hPopupMenu = MENU_CopySysPopup();
458
459 if (hPopupMenu)
460 {
461 if (GetClassLongW(hWnd, GCL_STYLE) & CS_NOCLOSE)
462 DeleteMenu(hPopupMenu, SC_CLOSE, MF_BYCOMMAND);
463
464 InsertMenuW( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION,
465 (UINT_PTR)hPopupMenu, NULL );
466
467 menu->items[0].fType = MF_SYSMENU | MF_POPUP;
468 menu->items[0].fState = 0;
469 if ((menu = MENU_GetMenu(hPopupMenu))) menu->wFlags |= MF_SYSMENU;
470
471 TRACE("hMenu=%p (hPopup %p)\n", hMenu, hPopupMenu );
472 return hMenu;
473 }
474 DestroyMenu( hMenu );
475 }
476 ERR("failed to load system menu!\n");
477 return 0;
478 }
479
480
481 /***********************************************************************
482 * MENU_InitSysMenuPopup
483 *
484 * Grey the appropriate items in System menu.
485 */
486 static void MENU_InitSysMenuPopup( HMENU hmenu, DWORD style, DWORD clsStyle )
487 {
488 BOOL gray;
489
490 gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
491 EnableMenuItem( hmenu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
492 gray = ((style & WS_MAXIMIZE) != 0);
493 EnableMenuItem( hmenu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
494 gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
495 EnableMenuItem( hmenu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
496 gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
497 EnableMenuItem( hmenu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
498 gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
499 EnableMenuItem( hmenu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
500 gray = (clsStyle & CS_NOCLOSE) != 0;
501
502 /* The menu item must keep its state if it's disabled */
503 if(gray)
504 EnableMenuItem( hmenu, SC_CLOSE, MF_GRAYED);
505 }
506
507
508 /******************************************************************************
509 *
510 * UINT MENU_GetStartOfNextColumn(
511 * HMENU hMenu )
512 *
513 *****************************************************************************/
514
515 static UINT MENU_GetStartOfNextColumn(
516 HMENU hMenu )
517 {
518 POPUPMENU *menu = MENU_GetMenu(hMenu);
519 UINT i;
520
521 if(!menu)
522 return NO_SELECTED_ITEM;
523
524 i = menu->FocusedItem + 1;
525 if( i == NO_SELECTED_ITEM )
526 return i;
527
528 for( ; i < menu->nItems; ++i ) {
529 if (menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
530 return i;
531 }
532
533 return NO_SELECTED_ITEM;
534 }
535
536
537 /******************************************************************************
538 *
539 * UINT MENU_GetStartOfPrevColumn(
540 * HMENU hMenu )
541 *
542 *****************************************************************************/
543
544 static UINT MENU_GetStartOfPrevColumn(
545 HMENU hMenu )
546 {
547 POPUPMENU *menu = MENU_GetMenu(hMenu);
548 UINT i;
549
550 if( !menu )
551 return NO_SELECTED_ITEM;
552
553 if( menu->FocusedItem == 0 || menu->FocusedItem == NO_SELECTED_ITEM )
554 return NO_SELECTED_ITEM;
555
556 /* Find the start of the column */
557
558 for(i = menu->FocusedItem; i != 0 &&
559 !(menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK));
560 --i); /* empty */
561
562 if(i == 0)
563 return NO_SELECTED_ITEM;
564
565 for(--i; i != 0; --i) {
566 if (menu->items[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
567 break;
568 }
569
570 TRACE("ret %d.\n", i );
571
572 return i;
573 }
574
575
576
577 /***********************************************************************
578 * MENU_FindItem
579 *
580 * Find a menu item. Return a pointer on the item, and modifies *hmenu
581 * in case the item was in a sub-menu.
582 */
583 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
584 {
585 POPUPMENU *menu;
586 MENUITEM *fallback = NULL;
587 UINT fallback_pos = 0;
588 UINT i;
589
590 if ((*hmenu == (HMENU)0xffff) || (!(menu = MENU_GetMenu(*hmenu)))) return NULL;
591 if (wFlags & MF_BYPOSITION)
592 {
593 if (*nPos >= menu->nItems) return NULL;
594 return &menu->items[*nPos];
595 }
596 else
597 {
598 MENUITEM *item = menu->items;
599 for (i = 0; i < menu->nItems; i++, item++)
600 {
601 if (item->fType & MF_POPUP)
602 {
603 HMENU hsubmenu = item->hSubMenu;
604 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
605 if (subitem)
606 {
607 *hmenu = hsubmenu;
608 return subitem;
609 }
610 else if (item->wID == *nPos)
611 {
612 /* fallback to this item if nothing else found */
613 fallback_pos = i;
614 fallback = item;
615 }
616 }
617 else if (item->wID == *nPos)
618 {
619 *nPos = i;
620 return item;
621 }
622 }
623 }
624
625 if (fallback)
626 *nPos = fallback_pos;
627
628 return fallback;
629 }
630
631 /***********************************************************************
632 * MENU_FindSubMenu
633 *
634 * Find a Sub menu. Return the position of the submenu, and modifies
635 * *hmenu in case it is found in another sub-menu.
636 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
637 */
638 UINT MENU_FindSubMenu( HMENU *hmenu, HMENU hSubTarget )
639 {
640 POPUPMENU *menu;
641 UINT i;
642 MENUITEM *item;
643 if (((*hmenu)==(HMENU)0xffff) ||
644 (!(menu = MENU_GetMenu(*hmenu))))
645 return NO_SELECTED_ITEM;
646 item = menu->items;
647 for (i = 0; i < menu->nItems; i++, item++) {
648 if(!(item->fType & MF_POPUP)) continue;
649 if (item->hSubMenu == hSubTarget) {
650 return i;
651 }
652 else {
653 HMENU hsubmenu = item->hSubMenu;
654 UINT pos = MENU_FindSubMenu( &hsubmenu, hSubTarget );
655 if (pos != NO_SELECTED_ITEM) {
656 *hmenu = hsubmenu;
657 return pos;
658 }
659 }
660 }
661 return NO_SELECTED_ITEM;
662 }
663
664 /***********************************************************************
665 * MENU_FreeItemData
666 */
667 static void MENU_FreeItemData( MENUITEM* item )
668 {
669 /* delete text */
670 HeapFree( GetProcessHeap(), 0, item->text );
671 }
672
673 /***********************************************************************
674 * MENU_AdjustMenuItemRect
675 *
676 * Adjust menu item rectangle according to scrolling state.
677 */
678 static void
679 MENU_AdjustMenuItemRect(const POPUPMENU *menu, LPRECT rect)
680 {
681 if (menu->bScrolling)
682 {
683 UINT arrow_bitmap_height;
684 BITMAP bmp;
685
686 GetObjectW(get_up_arrow_bitmap(), sizeof(bmp), &bmp);
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 UINT 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 UINT start, i, helpPos;
1204 int orgX, orgY, maxY;
1205
1206 if ((lprect == NULL) || (lppop == NULL)) return;
1207 if (lppop->nItems == 0) return;
1208 TRACE("lprect %p %s\n", lprect, wine_dbgstr_rect( lprect));
1209 lppop->Width = lprect->right - lprect->left;
1210 lppop->Height = 0;
1211 maxY = lprect->top+1;
1212 start = 0;
1213 helpPos = ~0U;
1214 lppop->maxBmpSize.cx = 0;
1215 lppop->maxBmpSize.cy = 0;
1216 while (start < lppop->nItems)
1217 {
1218 lpitem = &lppop->items[start];
1219 orgX = lprect->left;
1220 orgY = maxY;
1221
1222 /* Parse items until line break or end of menu */
1223 for (i = start; i < lppop->nItems; i++, lpitem++)
1224 {
1225 if ((helpPos == ~0U) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
1226 if ((i != start) &&
1227 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
1228
1229 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n", orgX, orgY );
1230 debug_print_menuitem (" item: ", lpitem, "");
1231 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE, lppop );
1232
1233 if (lpitem->rect.right > lprect->right)
1234 {
1235 if (i != start) break;
1236 else lpitem->rect.right = lprect->right;
1237 }
1238 maxY = max( maxY, lpitem->rect.bottom );
1239 orgX = lpitem->rect.right;
1240 }
1241
1242 /* Finish the line (set all items to the largest height found) */
1243 while (start < i) lppop->items[start++].rect.bottom = maxY;
1244 }
1245
1246 lprect->bottom = maxY;
1247 lppop->Height = lprect->bottom - lprect->top;
1248
1249 /* Flush right all items between the MF_RIGHTJUSTIFY and */
1250 /* the last item (if several lines, only move the last line) */
1251 if (helpPos == ~0U) return;
1252 lpitem = &lppop->items[lppop->nItems-1];
1253 orgY = lpitem->rect.top;
1254 orgX = lprect->right;
1255 for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--) {
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 }
1509 else if (menu->dwStyle & MNS_NOCHECK)
1510 bmprc.left = 4;
1511 else if (menu->dwStyle & MNS_CHECKORBMP)
1512 bmprc.left = 2;
1513 else
1514 bmprc.left = 4 + GetSystemMetrics(SM_CXMENUCHECK);
1515 bmprc.right = bmprc.left + lpitem->bmpsize.cx;
1516 if( menuBar && !(lpitem->hbmpItem == HBMMENU_CALLBACK))
1517 bmprc.top = 0;
1518 else
1519 bmprc.top = (rect.bottom - rect.top -
1520 lpitem->bmpsize.cy) / 2;
1521 bmprc.bottom = bmprc.top + lpitem->bmpsize.cy;
1522 }
1523
1524 if (!menuBar)
1525 {
1526 HBITMAP bm;
1527 INT y = rect.top + rect.bottom;
1528 RECT rc = rect;
1529 int checked = FALSE;
1530 UINT check_bitmap_width = GetSystemMetrics( SM_CXMENUCHECK );
1531 UINT check_bitmap_height = GetSystemMetrics( SM_CYMENUCHECK );
1532 /* Draw the check mark
1533 *
1534 * FIXME:
1535 * Custom checkmark bitmaps are monochrome but not always 1bpp.
1536 */
1537 if( !(menu->dwStyle & MNS_NOCHECK)) {
1538 bm = (lpitem->fState & MF_CHECKED) ? lpitem->hCheckBit :
1539 lpitem->hUnCheckBit;
1540 if (bm) /* we have a custom bitmap */
1541 {
1542 HDC hdcMem = CreateCompatibleDC( hdc );
1543
1544 SelectObject( hdcMem, bm );
1545 BitBlt( hdc, rc.left, (y - check_bitmap_height) / 2,
1546 check_bitmap_width, check_bitmap_height,
1547 hdcMem, 0, 0, SRCCOPY );
1548 DeleteDC( hdcMem );
1549 checked = TRUE;
1550 }
1551 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
1552 {
1553 RECT r;
1554 HBITMAP bm = CreateBitmap( check_bitmap_width,
1555 check_bitmap_height, 1, 1, NULL );
1556 HDC hdcMem = CreateCompatibleDC( hdc );
1557
1558 SelectObject( hdcMem, bm );
1559 SetRect( &r, 0, 0, check_bitmap_width, check_bitmap_height);
1560 DrawFrameControl( hdcMem, &r, DFC_MENU,
1561 (lpitem->fType & MFT_RADIOCHECK) ?
1562 DFCS_MENUBULLET : DFCS_MENUCHECK );
1563 BitBlt( hdc, rc.left, (y - r.bottom) / 2, r.right, r.bottom,
1564 hdcMem, 0, 0, SRCCOPY );
1565 DeleteDC( hdcMem );
1566 DeleteObject( bm );
1567 checked = TRUE;
1568 }
1569 }
1570 if( lpitem->hbmpItem &&
1571 !( checked && (menu->dwStyle & MNS_CHECKORBMP))) {
1572 POINT origorg;
1573 /* some applications make this assumption on the DC's origin */
1574 SetViewportOrgEx( hdc, rect.left, rect.top, &origorg);
1575 MENU_DrawBitmapItem(hdc, lpitem, &bmprc, hmenu, hwndOwner,
1576 odaction, FALSE);
1577 SetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1578 }
1579 /* Draw the popup-menu arrow */
1580 if (lpitem->fType & MF_POPUP)
1581 draw_popup_arrow( hdc, rect, arrow_bitmap_width,
1582 arrow_bitmap_height);
1583 rect.left += 4;
1584 if( !(menu->dwStyle & MNS_NOCHECK))
1585 rect.left += check_bitmap_width;
1586 rect.right -= arrow_bitmap_width;
1587 }
1588 else if( lpitem->hbmpItem)
1589 { /* Draw the bitmap */
1590 POINT origorg;
1591
1592 SetViewportOrgEx( hdc, rect.left, rect.top, &origorg);
1593 MENU_DrawBitmapItem( hdc, lpitem, &bmprc, hmenu, hwndOwner,
1594 odaction, menuBar);
1595 SetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1596 }
1597 /* process text if present */
1598 if (lpitem->text)
1599 {
1600 register int i;
1601 HFONT hfontOld = 0;
1602
1603 UINT uFormat = (menuBar) ?
1604 DT_CENTER | DT_VCENTER | DT_SINGLELINE :
1605 DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1606
1607 if( !(menu->dwStyle & MNS_CHECKORBMP))
1608 rect.left += menu->maxBmpSize.cx;
1609
1610 if ( lpitem->fState & MFS_DEFAULT )
1611 {
1612 hfontOld = SelectObject( hdc, get_menu_font(TRUE) );
1613 }
1614
1615 if (menuBar) {
1616 if( lpitem->hbmpItem)
1617 rect.left += lpitem->bmpsize.cx;
1618 if( !(lpitem->hbmpItem == HBMMENU_CALLBACK))
1619 rect.left += menucharsize.cx;
1620 rect.right -= menucharsize.cx;
1621 }
1622
1623 for (i = 0; lpitem->text[i]; i++)
1624 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1625 break;
1626
1627 if(lpitem->fState & MF_GRAYED)
1628 {
1629 if (!(lpitem->fState & MF_HILITE) )
1630 {
1631 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1632 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1633 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1634 --rect.left; --rect.top; --rect.right; --rect.bottom;
1635 }
1636 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1637 }
1638
1639 DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1640
1641 /* paint the shortcut text */
1642 if (!menuBar && lpitem->text[i]) /* There's a tab or flush-right char */
1643 {
1644 if (lpitem->text[i] == '\t')
1645 {
1646 rect.left = lpitem->xTab;
1647 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1648 }
1649 else
1650 {
1651 rect.right = lpitem->xTab;
1652 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1653 }
1654
1655 if(lpitem->fState & MF_GRAYED)
1656 {
1657 if (!(lpitem->fState & MF_HILITE) )
1658 {
1659 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1660 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1661 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1662 --rect.left; --rect.top; --rect.right; --rect.bottom;
1663 }
1664 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1665 }
1666 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1667 }
1668
1669 if (hfontOld)
1670 SelectObject (hdc, hfontOld);
1671 }
1672 }
1673
1674
1675 /***********************************************************************
1676 * MENU_DrawPopupMenu
1677 *
1678 * Paint a popup menu.
1679 */
1680 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1681 {
1682 HBRUSH hPrevBrush = 0;
1683 RECT rect;
1684
1685 TRACE("wnd=%p dc=%p menu=%p\n", hwnd, hdc, hmenu);
1686
1687 GetClientRect( hwnd, &rect );
1688
1689 if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1690 && (SelectObject( hdc, get_menu_font(FALSE))))
1691 {
1692 HPEN hPrevPen;
1693
1694 Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1695
1696 hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1697 if( hPrevPen )
1698 {
1699 POPUPMENU *menu;
1700 BOOL flat_menu = FALSE;
1701
1702 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
1703 if (flat_menu)
1704 FrameRect(hdc, &rect, GetSysColorBrush(COLOR_BTNSHADOW));
1705 else
1706 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1707
1708 if( (menu = MENU_GetMenu( hmenu )))
1709 {
1710 /* draw menu items */
1711 if( menu->nItems)
1712 {
1713 MENUITEM *item;
1714 UINT u;
1715
1716 item = menu->items;
1717 for( u = menu->nItems; u > 0; u--, item++)
1718 MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc,
1719 item, menu->Height, FALSE, ODA_DRAWENTIRE );
1720 }
1721 /* draw scroll arrows */
1722 if (menu->bScrolling)
1723 MENU_DrawScrollArrows(menu, hdc);
1724 }
1725 } else
1726 {
1727 SelectObject( hdc, hPrevBrush );
1728 }
1729 }
1730 }
1731
1732 /***********************************************************************
1733 * MENU_DrawMenuBar
1734 *
1735 * Paint a menu bar. Returns the height of the menu bar.
1736 * called from [windows/nonclient.c]
1737 */
1738 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1739 BOOL suppress_draw)
1740 {
1741 LPPOPUPMENU lppop;
1742 HFONT hfontOld = 0;
1743 HMENU hMenu = GetMenu(hwnd);
1744
1745 lppop = MENU_GetMenu( hMenu );
1746 if (lppop == NULL || lprect == NULL)
1747 {
1748 return GetSystemMetrics(SM_CYMENU);
1749 }
1750
1751 if (suppress_draw)
1752 {
1753 hfontOld = SelectObject( hDC, get_menu_font(FALSE));
1754
1755 if (lppop->Height == 0)
1756 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1757
1758 lprect->bottom = lprect->top + lppop->Height;
1759
1760 if (hfontOld) SelectObject( hDC, hfontOld);
1761 return lppop->Height;
1762 }
1763 else
1764 return DrawMenuBarTemp(hwnd, hDC, lprect, hMenu, NULL);
1765 }
1766
1767
1768 /***********************************************************************
1769 * MENU_ShowPopup
1770 *
1771 * Display a popup menu.
1772 */
1773 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id, UINT flags,
1774 INT x, INT y, INT xanchor, INT yanchor )
1775 {
1776 POPUPMENU *menu;
1777 INT width, height;
1778 POINT pt;
1779 HMONITOR monitor;
1780 MONITORINFO info;
1781
1782 TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1783 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1784
1785 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1786 if (menu->FocusedItem != NO_SELECTED_ITEM)
1787 {
1788 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1789 menu->FocusedItem = NO_SELECTED_ITEM;
1790 }
1791
1792 /* store the owner for DrawItem */
1793 menu->hwndOwner = hwndOwner;
1794
1795 menu->nScrollPos = 0;
1796 MENU_PopupMenuCalcSize( menu );
1797
1798 /* adjust popup menu pos so that it fits within the desktop */
1799
1800 width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1801 height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1802
1803 /* FIXME: should use item rect */
1804 pt.x = x;
1805 pt.y = y;
1806 monitor = MonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
1807 info.cbSize = sizeof(info);
1808 GetMonitorInfoW( monitor, &info );
1809
1810 if( flags & TPM_RIGHTALIGN ) x -= width;
1811 if( flags & TPM_CENTERALIGN ) x -= width / 2;
1812
1813 if( flags & TPM_BOTTOMALIGN ) y -= height;
1814 if( flags & TPM_VCENTERALIGN ) y -= height / 2;
1815
1816 if( x + width > info.rcWork.right)
1817 {
1818 if( xanchor && x >= width - xanchor )
1819 x -= width - xanchor;
1820
1821 if( x + width > info.rcWork.right)
1822 x = info.rcWork.right - width;
1823 }
1824 if( x < info.rcWork.left ) x = info.rcWork.left;
1825
1826 if( y + height > info.rcWork.bottom)
1827 {
1828 if( yanchor && y >= height + yanchor )
1829 y -= height + yanchor;
1830
1831 if( y + height > info.rcWork.bottom)
1832 y = info.rcWork.bottom - height;
1833 }
1834 if( y < info.rcWork.top ) y = info.rcWork.top;
1835
1836 /* NOTE: In Windows, top menu popup is not owned. */
1837 menu->hWnd = CreateWindowExW( 0, (LPCWSTR)POPUPMENU_CLASS_ATOM, NULL,
1838 WS_POPUP, x, y, width, height,
1839 hwndOwner, 0, (HINSTANCE)GetWindowLongPtrW(hwndOwner, GWLP_HINSTANCE),
1840 (LPVOID)hmenu );
1841 if( !menu->hWnd ) return FALSE;
1842 if (!top_popup) top_popup = menu->hWnd;
1843
1844 /* Display the window */
1845
1846 SetWindowPos( menu->hWnd, HWND_TOPMOST, 0, 0, 0, 0,
1847 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1848 UpdateWindow( menu->hWnd );
1849 return TRUE;
1850 }
1851
1852
1853 /***********************************************************************
1854 * MENU_EnsureMenuItemVisible
1855 */
1856 static void
1857 MENU_EnsureMenuItemVisible(LPPOPUPMENU lppop, UINT wIndex, HDC hdc)
1858 {
1859 if (lppop->bScrolling)
1860 {
1861 MENUITEM *item = &lppop->items[wIndex];
1862 UINT nMaxHeight = MENU_GetMaxPopupHeight(lppop);
1863 UINT nOldPos = lppop->nScrollPos;
1864 RECT rc;
1865 UINT arrow_bitmap_height;
1866 BITMAP bmp;
1867
1868 GetClientRect(lppop->hWnd, &rc);
1869
1870 GetObjectW(get_down_arrow_bitmap(), sizeof(bmp), &bmp);
1871 arrow_bitmap_height = bmp.bmHeight;
1872
1873 rc.top += arrow_bitmap_height;
1874 rc.bottom -= arrow_bitmap_height + MENU_BOTTOM_MARGIN;
1875
1876 nMaxHeight -= GetSystemMetrics(SM_CYBORDER) + 2 * arrow_bitmap_height;
1877 if (item->rect.bottom > lppop->nScrollPos + nMaxHeight)
1878 {
1879
1880 lppop->nScrollPos = item->rect.bottom - nMaxHeight;
1881 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, &rc, &rc);
1882 MENU_DrawScrollArrows(lppop, hdc);
1883 }
1884 else if (item->rect.top - MENU_TOP_MARGIN < lppop->nScrollPos)
1885 {
1886 lppop->nScrollPos = item->rect.top - MENU_TOP_MARGIN;
1887 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, &rc, &rc);
1888 MENU_DrawScrollArrows(lppop, hdc);
1889 }
1890 }
1891 }
1892
1893
1894 /***********************************************************************
1895 * MENU_SelectItem
1896 */
1897 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1898 BOOL sendMenuSelect, HMENU topmenu )
1899 {
1900 LPPOPUPMENU lppop;
1901 HDC hdc;
1902
1903 TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1904
1905 lppop = MENU_GetMenu( hmenu );
1906 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1907
1908 if (lppop->FocusedItem == wIndex) return;
1909 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1910 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1911 if (!top_popup) top_popup = lppop->hWnd;
1912
1913 SelectObject( hdc, get_menu_font(FALSE));
1914
1915 /* Clear previous highlighted item */
1916 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1917 {
1918 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1919 MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1920 lppop->Height, !(lppop->wFlags & MF_POPUP),
1921 ODA_SELECT );
1922 }
1923
1924 /* Highlight new item (if any) */
1925 lppop->FocusedItem = wIndex;
1926 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1927 {
1928 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1929 lppop->items[wIndex].fState |= MF_HILITE;
1930 MENU_EnsureMenuItemVisible(lppop, wIndex, hdc);
1931 MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1932 &lppop->items[wIndex], lppop->Height,
1933 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1934 }
1935 if (sendMenuSelect)
1936 {
1937 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1938 SendMessageW( hwndOwner, WM_MENUSELECT,
1939 MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1940 ip->fType | ip->fState |
1941 (lppop->wFlags & MF_SYSMENU)), (LPARAM)hmenu);
1942 }
1943 }
1944 else if (sendMenuSelect) {
1945 if(topmenu){
1946 int pos;
1947 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1948 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1949 MENUITEM *ip = &ptm->items[pos];
1950 SendMessageW( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1951 ip->fType | ip->fState |
1952 (ptm->wFlags & MF_SYSMENU)), (LPARAM)topmenu);
1953 }
1954 }
1955 }
1956 ReleaseDC( lppop->hWnd, hdc );
1957 }
1958
1959
1960 /***********************************************************************
1961 * MENU_MoveSelection
1962 *
1963 * Moves currently selected item according to the offset parameter.
1964 * If there is no selection then it should select the last item if
1965 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1966 */
1967 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1968 {
1969 INT i;
1970 POPUPMENU *menu;
1971
1972 TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner, hmenu, offset);
1973
1974 menu = MENU_GetMenu( hmenu );
1975 if ((!menu) || (!menu->items)) return;
1976
1977 if ( menu->FocusedItem != NO_SELECTED_ITEM )
1978 {
1979 if( menu->nItems == 1 ) return; else
1980 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1981 ; 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 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1990 i >= 0 && i < menu->nItems ; i += offset)
1991 if (!(menu->items[i].fType & MF_SEPARATOR))
1992 {
1993 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1994 return;
1995 }
1996 }
1997
1998
1999 /**********************************************************************
2000 * MENU_SetItemData
2001 *
2002 * Set an item's flags, id and text ptr. Called by InsertMenu() and
2003 * ModifyMenu().
2004 */
2005 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT_PTR id,
2006 LPCWSTR str )
2007 {
2008 debug_print_menuitem("MENU_SetItemData from: ", item, "");
2009 TRACE("flags=%x str=%p\n", flags, str);
2010
2011 if (IS_STRING_ITEM(flags))
2012 {
2013 LPWSTR prevText = item->text;
2014 if (!str)
2015 {
2016 flags |= MF_SEPARATOR;
2017 item->text = NULL;
2018 }
2019 else
2020 {
2021 LPWSTR text;
2022 /* Item beginning with a backspace is a help item */
2023 if (*str == '\b')
2024 {
2025 flags |= MF_HELP;
2026 str++;
2027 }
2028 if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
2029 return FALSE;
2030 strcpyW( text, str );
2031 item->text = text;
2032 }
2033 item->hbmpItem = NULL;
2034 HeapFree( GetProcessHeap(), 0, prevText );
2035 }
2036 else if(( flags & MFT_BITMAP)) {
2037 item->hbmpItem = HBITMAP_32(LOWORD(str));
2038 /* setting bitmap clears text */
2039 HeapFree( GetProcessHeap(), 0, item->text );
2040 item->text = NULL;
2041 }
2042
2043 if (flags & MF_SEPARATOR) flags |= MF_GRAYED | MF_DISABLED;
2044
2045 if (flags & MF_OWNERDRAW)
2046 item->dwItemData = (DWORD_PTR)str;
2047 else
2048 item->dwItemData = 0;
2049
2050 if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != (HMENU)id) )
2051 DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
2052
2053 if (flags & MF_POPUP)
2054 {
2055 POPUPMENU *menu = MENU_GetMenu((HMENU)id);
2056 if (menu) menu->wFlags |= MF_POPUP;
2057 else
2058 {
2059 item->wID = 0;
2060 item->hSubMenu = 0;
2061 item->fType = 0;
2062 item->fState = 0;
2063 return FALSE;
2064 }
2065 }
2066
2067 item->wID = id;
2068 if (flags & MF_POPUP) item->hSubMenu = (HMENU)id;
2069
2070 if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
2071 flags |= MF_POPUP; /* keep popup */
2072
2073 item->fType = flags & TYPE_MASK;
2074 /* MFS_DEFAULT is not accepted. MF_HILITE is not listed as a valid flag
2075 for ModifyMenu, but Windows accepts it */
2076 item->fState = flags & MENUITEMINFO_STATE_MASK & ~MFS_DEFAULT;
2077
2078 /* Don't call SetRectEmpty here! */
2079
2080 debug_print_menuitem("MENU_SetItemData to : ", item, "");
2081 return TRUE;
2082 }
2083
2084
2085 /**********************************************************************
2086 * MENU_InsertItem
2087 *
2088 * Insert (allocate) a new item into a menu.
2089 */
2090 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
2091 {
2092 MENUITEM *newItems;
2093 POPUPMENU *menu;
2094
2095 if (!(menu = MENU_GetMenu(hMenu)))
2096 return NULL;
2097
2098 /* Find where to insert new item */
2099
2100 if (flags & MF_BYPOSITION) {
2101 if (pos > menu->nItems)
2102 pos = menu->nItems;
2103 } else {
2104 if (!MENU_FindItem( &hMenu, &pos, flags ))
2105 pos = menu->nItems;
2106 else {
2107 if (!(menu = MENU_GetMenu( hMenu )))
2108 return NULL;
2109 }
2110 }
2111
2112 /* Make sure that MDI system buttons stay on the right side.
2113 * Note: XP treats only bitmap handles 1 - 6 as "magic" ones
2114 * regardless of their id.
2115 */
2116 while (pos > 0 && (menu->items[pos - 1].fType & MFT_BITMAP) &&
2117 (INT_PTR)menu->items[pos - 1].hbmpItem >= (INT_PTR)HBMMENU_SYSTEM &&
2118 (INT_PTR)menu->items[pos - 1].hbmpItem <= (INT_PTR)HBMMENU_MBAR_CLOSE_D)
2119 pos--;
2120
2121 TRACE("inserting at %u by pos %u\n", pos, flags & MF_BYPOSITION);
2122
2123 /* Create new items array */
2124
2125 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
2126 if (!newItems)
2127 {
2128 WARN("allocation failed\n" );
2129 return NULL;
2130 }
2131 if (menu->nItems > 0)
2132 {
2133 /* Copy the old array into the new one */
2134 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
2135 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
2136 (menu->nItems-pos)*sizeof(MENUITEM) );
2137 HeapFree( GetProcessHeap(), 0, menu->items );
2138 }
2139 menu->items = newItems;
2140 menu->nItems++;
2141 memset( &newItems[pos], 0, sizeof(*newItems) );
2142 menu->Height = 0; /* force size recalculate */
2143 return &newItems[pos];
2144 }
2145
2146
2147 /**********************************************************************
2148 * MENU_ParseResource
2149 *
2150 * Parse a standard menu resource and add items to the menu.
2151 * Return a pointer to the end of the resource.
2152 *
2153 * NOTE: flags is equivalent to the mtOption field
2154 */
2155 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
2156 {
2157 WORD flags, id = 0;
2158 LPCSTR str;
2159 BOOL end_flag;
2160
2161 do
2162 {
2163 flags = GET_WORD(res);
2164 end_flag = flags & MF_END;
2165 /* Remove MF_END because it has the same value as MF_HILITE */
2166 flags &= ~MF_END;
2167 res += sizeof(WORD);
2168 if (!(flags & MF_POPUP))
2169 {
2170 id = GET_WORD(res);
2171 res += sizeof(WORD);
2172 }
2173 str = res;
2174 if (!unicode) res += strlen(str) + 1;
2175 else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
2176 if (flags & MF_POPUP)
2177 {
2178 HMENU hSubMenu = CreatePopupMenu();
2179 if (!hSubMenu) return NULL;
2180 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
2181 return NULL;
2182 if (!unicode) AppendMenuA( hMenu, flags, (UINT_PTR)hSubMenu, str );
2183 else AppendMenuW( hMenu, flags, (UINT_PTR)hSubMenu, (LPCWSTR)str );
2184 }
2185 else /* Not a popup */
2186 {
2187 if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
2188 else AppendMenuW( hMenu, flags, id,
2189 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
2190 }
2191 } while (!end_flag);
2192 return res;
2193 }
2194
2195
2196 /**********************************************************************
2197 * MENUEX_ParseResource
2198 *
2199 * Parse an extended menu resource and add items to the menu.
2200 * Return a pointer to the end of the resource.
2201 */
2202 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
2203 {
2204 WORD resinfo;
2205 do {
2206 MENUITEMINFOW mii;
2207
2208 mii.cbSize = sizeof(mii);
2209 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
2210 mii.fType = GET_DWORD(res);
2211 res += sizeof(DWORD);
2212 mii.fState = GET_DWORD(res);
2213 res += sizeof(DWORD);
2214 mii.wID = GET_DWORD(res);
2215 res += sizeof(DWORD);
2216 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
2217 res += sizeof(WORD);
2218 /* Align the text on a word boundary. */
2219 res += (~((UINT_PTR)res - 1)) & 1;
2220 mii.dwTypeData = (LPWSTR) res;
2221 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
2222 /* Align the following fields on a dword boundary. */
2223 res += (~((UINT_PTR)res - 1)) & 3;
2224
2225 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
2226 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
2227
2228 if (resinfo & 1) { /* Pop-up? */
2229 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
2230 res += sizeof(DWORD);
2231 mii.hSubMenu = CreatePopupMenu();
2232 if (!mii.hSubMenu)
2233 return NULL;
2234 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
2235 DestroyMenu(mii.hSubMenu);
2236 return NULL;
2237 }
2238 mii.fMask |= MIIM_SUBMENU;
2239 mii.fType |= MF_POPUP;
2240 }
2241 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
2242 {
2243 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
2244 mii.wID, mii.fType);
2245 mii.fType |= MF_SEPARATOR;
2246 }
2247 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
2248 } while (!(resinfo & MF_END));
2249 return res;
2250 }
2251
2252
2253 /***********************************************************************
2254 * MENU_GetSubPopup
2255 *
2256 * Return the handle of the selected sub-popup menu (if any).
2257 */
2258 static HMENU MENU_GetSubPopup( HMENU hmenu )
2259 {
2260 POPUPMENU *menu;
2261 MENUITEM *item;
2262
2263 menu = MENU_GetMenu( hmenu );
2264
2265 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2266
2267 item = &menu->items[menu->FocusedItem];
2268 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2269 return item->hSubMenu;
2270 return 0;
2271 }
2272
2273
2274 /***********************************************************************
2275 * MENU_HideSubPopups
2276 *
2277 * Hide the sub-popup menus of this menu.
2278 */
2279 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2280 BOOL sendMenuSelect, UINT wFlags )
2281 {
2282 POPUPMENU *menu = MENU_GetMenu( hmenu );
2283
2284 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2285
2286 if (menu && top_popup)
2287 {
2288 HMENU hsubmenu;
2289 POPUPMENU *submenu;
2290 MENUITEM *item;
2291
2292 if (menu->FocusedItem != NO_SELECTED_ITEM)
2293 {
2294 item = &menu->items[menu->FocusedItem];
2295 if (!(item->fType & MF_POPUP) ||
2296 !(item->fState & MF_MOUSESELECT)) return;
2297 item->fState &= ~MF_MOUSESELECT;
2298 hsubmenu = item->hSubMenu;
2299 } else return;
2300
2301 if (!(submenu = MENU_GetMenu( hsubmenu ))) return;
2302 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE, wFlags );
2303 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2304 DestroyWindow( submenu->hWnd );
2305 submenu->hWnd = 0;
2306
2307 if (!(wFlags & TPM_NONOTIFY))
2308 SendMessageW( hwndOwner, WM_UNINITMENUPOPUP, (WPARAM)hsubmenu,
2309 MAKELPARAM(0, IS_SYSTEM_MENU(submenu)) );
2310 }
2311 }
2312
2313
2314 /***********************************************************************
2315 * MENU_ShowSubPopup
2316 *
2317 * Display the sub-menu of the selected item of this menu.
2318 * Return the handle of the submenu, or hmenu if no submenu to display.
2319 */
2320 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2321 BOOL selectFirst, UINT wFlags )
2322 {
2323 RECT rect;
2324 POPUPMENU *menu;
2325 MENUITEM *item;
2326 HDC hdc;
2327
2328 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, selectFirst);
2329
2330 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2331
2332 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2333
2334 item = &menu->items[menu->FocusedItem];
2335 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2336 return hmenu;
2337
2338 /* message must be sent before using item,
2339 because nearly everything may be changed by the application ! */
2340
2341 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2342 if (!(wFlags & TPM_NONOTIFY))
2343 SendMessageW( hwndOwner, WM_INITMENUPOPUP, (WPARAM)item->hSubMenu,
2344 MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2345
2346 item = &menu->items[menu->FocusedItem];
2347 rect = item->rect;
2348
2349 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2350 if (!(item->fState & MF_HILITE))
2351 {
2352 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2353 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2354
2355 SelectObject( hdc, get_menu_font(FALSE));
2356
2357 item->fState |= MF_HILITE;
2358 MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2359 ReleaseDC( menu->hWnd, hdc );
2360 }
2361 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2362 item->rect = rect;
2363
2364 item->fState |= MF_MOUSESELECT;
2365
2366 if (IS_SYSTEM_MENU(menu))
2367 {
2368 MENU_InitSysMenuPopup(item->hSubMenu,
2369 GetWindowLongW( menu->hWnd, GWL_STYLE ),
2370 GetClassLongW( menu->hWnd, GCL_STYLE));
2371
2372 NC_GetSysPopupPos( menu->hWnd, &rect );
2373 rect.top = rect.bottom;
2374 rect.right = GetSystemMetrics(SM_CXSIZE);
2375 rect.bottom = GetSystemMetrics(SM_CYSIZE);
2376 }
2377 else
2378 {
2379 GetWindowRect( menu->hWnd, &rect );
2380 if (menu->wFlags & MF_POPUP)
2381 {
2382 RECT rc = item->rect;
2383
2384 MENU_AdjustMenuItemRect(menu, &rc);
2385
2386 /* The first item in the popup menu has to be at the
2387 same y position as the focused menu item */
2388 rect.left += rc.right - GetSystemMetrics(SM_CXBORDER);
2389 rect.top += rc.top - MENU_TOP_MARGIN;
2390 rect.right = rc.left - rc.right + GetSystemMetrics(SM_CXBORDER);
2391 rect.bottom = rc.top - rc.bottom - MENU_TOP_MARGIN
2392 - MENU_BOTTOM_MARGIN - GetSystemMetrics(SM_CYBORDER);
2393 }
2394 else
2395 {
2396 rect.left += item->rect.left;
2397 rect.top += item->rect.bottom;
2398 rect.right = item->rect.right - item->rect.left;
2399 rect.bottom = item->rect.bottom - item->rect.top;
2400 }
2401 }
2402
2403 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem, 0,
2404 rect.left, rect.top, rect.right, rect.bottom );
2405 if (selectFirst)
2406 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2407 return item->hSubMenu;
2408 }
2409
2410
2411
2412 /**********************************************************************
2413 * MENU_IsMenuActive
2414 */
2415 HWND MENU_IsMenuActive(void)
2416 {
2417 return top_popup;
2418 }
2419
2420 /***********************************************************************
2421 * MENU_PtMenu
2422 *
2423 * Walks menu chain trying to find a menu pt maps to.
2424 */
2425 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2426 {
2427 POPUPMENU *menu = MENU_GetMenu( hMenu );
2428 UINT item = menu->FocusedItem;
2429 HMENU ret;
2430
2431 /* try subpopup first (if any) */
2432 ret = (item != NO_SELECTED_ITEM &&
2433 (menu->items[item].fType & MF_POPUP) &&
2434 (menu->items[item].fState & MF_MOUSESELECT))
2435 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2436
2437 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2438 {
2439 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2440 if( menu->wFlags & MF_POPUP )
2441 {
2442 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2443 }
2444 else if (ht == HTSYSMENU)
2445 ret = get_win_sys_menu( menu->hWnd );
2446 else if (ht == HTMENU)
2447 ret = GetMenu( menu->hWnd );
2448 }
2449 return ret;
2450 }
2451
2452 /***********************************************************************
2453 * MENU_ExecFocusedItem
2454 *
2455 * Execute a menu item (for instance when user pressed Enter).
2456 * Return the wID of the executed item. Otherwise, -1 indicating
2457 * that no menu item was executed, -2 if a popup is shown;
2458 * Have to receive the flags for the TrackPopupMenu options to avoid
2459 * sending unwanted message.
2460 *
2461 */
2462 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2463 {
2464 MENUITEM *item;
2465 POPUPMENU *menu = MENU_GetMenu( hMenu );
2466
2467 TRACE("%p hmenu=%p\n", pmt, hMenu);
2468
2469 if (!menu || !menu->nItems ||
2470 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2471
2472 item = &menu->items[menu->FocusedItem];
2473
2474 TRACE("hMenu %p wID %08lx hSubMenu %p fType %04x\n", hMenu, item->wID, item->hSubMenu, item->fType);
2475
2476 if (!(item->fType & MF_POPUP))
2477 {
2478 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2479 {
2480 /* If TPM_RETURNCMD is set you return the id, but
2481 do not send a message to the owner */
2482 if(!(wFlags & TPM_RETURNCMD))
2483 {
2484 if( menu->wFlags & MF_SYSMENU )
2485 PostMessageW( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2486 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2487 else
2488 {
2489 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2490 DWORD dwStyle = menu->dwStyle | (topmenu ? topmenu->dwStyle : 0);
2491
2492 if (dwStyle & MNS_NOTIFYBYPOS)
2493 PostMessageW( pmt->hOwnerWnd, WM_MENUCOMMAND, menu->FocusedItem,
2494 (LPARAM)hMenu);
2495 else
2496 PostMessageW( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2497 }
2498 }
2499 return item->wID;
2500 }
2501 }
2502 else
2503 {
2504 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2505 return -2;
2506 }
2507
2508 return -1;
2509 }
2510
2511 /***********************************************************************
2512 * MENU_SwitchTracking
2513 *
2514 * Helper function for menu navigation routines.
2515 */
2516 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id, UINT wFlags )
2517 {
2518 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2519 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2520
2521 TRACE("%p hmenu=%p 0x%04x\n", pmt, hPtMenu, id);
2522
2523 if( pmt->hTopMenu != hPtMenu &&
2524 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2525 {
2526 /* both are top level menus (system and menu-bar) */
2527 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
2528 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2529 pmt->hTopMenu = hPtMenu;
2530 }
2531 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2532 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2533 }
2534
2535
2536 /***********************************************************************
2537 * MENU_ButtonDown
2538 *
2539 * Return TRUE if we can go on with menu tracking.
2540 */
2541 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2542 {
2543 TRACE("%p hPtMenu=%p\n", pmt, hPtMenu);
2544
2545 if (hPtMenu)
2546 {
2547 UINT id = 0;
2548 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2549 MENUITEM *item;
2550
2551 if( IS_SYSTEM_MENU(ptmenu) )
2552 item = ptmenu->items;
2553 else
2554 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2555
2556 if( item )
2557 {
2558 if( ptmenu->FocusedItem != id )
2559 MENU_SwitchTracking( pmt, hPtMenu, id, wFlags );
2560
2561 /* If the popup menu is not already "popped" */
2562 if(!(item->fState & MF_MOUSESELECT ))
2563 {
2564 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2565 }
2566
2567 return TRUE;
2568 }
2569 /* Else the click was on the menu bar, finish the tracking */
2570 }
2571 return FALSE;
2572 }
2573
2574 /***********************************************************************
2575 * MENU_ButtonUp
2576 *
2577 * Return the value of MENU_ExecFocusedItem if
2578 * the selected item was not a popup. Else open the popup.
2579 * A -1 return value indicates that we go on with menu tracking.
2580 *
2581 */
2582 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2583 {
2584 TRACE("%p hmenu=%p\n", pmt, hPtMenu);
2585
2586 if (hPtMenu)
2587 {
2588 UINT id = 0;
2589 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2590 MENUITEM *item;
2591
2592 if( IS_SYSTEM_MENU(ptmenu) )
2593 item = ptmenu->items;
2594 else
2595 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2596
2597 if( item && (ptmenu->FocusedItem == id ))
2598 {
2599 debug_print_menuitem ("FocusedItem: ", item, "");
2600
2601 if( !(item->fType & MF_POPUP) )
2602 {
2603 INT executedMenuId = MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2604 if (executedMenuId == -1 || executedMenuId == -2) return -1;
2605 return executedMenuId;
2606 }
2607
2608 /* If we are dealing with the top-level menu */
2609 /* and this is a click on an already "popped" item: */
2610 /* Stop the menu tracking and close the opened submenus */
2611 if((pmt->hTopMenu == hPtMenu) && ptmenu->bTimeToHide)
2612 return 0;
2613 }
2614 ptmenu->bTimeToHide = TRUE;
2615 }
2616 return -1;
2617 }
2618
2619
2620 /***********************************************************************
2621 * MENU_MouseMove
2622 *
2623 * Return TRUE if we can go on with menu tracking.
2624 */
2625 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2626 {
2627 UINT id = NO_SELECTED_ITEM;
2628 POPUPMENU *ptmenu = NULL;
2629
2630 if( hPtMenu )
2631 {
2632 ptmenu = MENU_GetMenu( hPtMenu );
2633 if( IS_SYSTEM_MENU(ptmenu) )
2634 id = 0;
2635 else
2636 MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2637 }
2638
2639 if( id == NO_SELECTED_ITEM )
2640 {
2641 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2642 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2643
2644 }
2645 else if( ptmenu->FocusedItem != id )
2646 {
2647 MENU_SwitchTracking( pmt, hPtMenu, id, wFlags );
2648 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2649 }
2650 return TRUE;
2651 }
2652
2653
2654 /***********************************************************************
2655 * MENU_DoNextMenu
2656 *
2657 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2658 */
2659 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk, UINT wFlags )
2660 {
2661 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2662 BOOL atEnd = FALSE;
2663
2664 /* When skipping left, we need to do something special after the
2665 first menu. */
2666 if (vk == VK_LEFT && menu->FocusedItem == 0)
2667 {
2668 atEnd = TRUE;
2669 }
2670 /* When skipping right, for the non-system menu, we need to
2671 handle the last non-special menu item (ie skip any window
2672 icons such as MDI maximize, restore or close) */
2673 else if ((vk == VK_RIGHT) && !IS_SYSTEM_MENU(menu))
2674 {
2675 UINT i = menu->FocusedItem + 1;
2676 while (i < menu->nItems) {
2677 if ((menu->items[i].wID >= SC_SIZE &&
2678 menu->items[i].wID <= SC_RESTORE)) {
2679 i++;
2680 } else break;
2681 }
2682 if (i == menu->nItems) {
2683 atEnd = TRUE;
2684 }
2685 }
2686 /* When skipping right, we need to cater for the system menu */
2687 else if ((vk == VK_RIGHT) && IS_SYSTEM_MENU(menu))
2688 {
2689 if (menu->FocusedItem == (menu->nItems - 1)) {
2690 atEnd = TRUE;
2691 }
2692 }
2693
2694 if( atEnd )
2695 {
2696 MDINEXTMENU next_menu;
2697 HMENU hNewMenu;
2698 HWND hNewWnd;
2699 UINT id = 0;
2700
2701 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2702 next_menu.hmenuNext = 0;
2703 next_menu.hwndNext = 0;
2704 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2705
2706 TRACE("%p [%p] -> %p [%p]\n",
2707 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2708
2709 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2710 {
2711 DWORD style = GetWindowLongW( pmt->hOwnerWnd, GWL_STYLE );
2712 hNewWnd = pmt->hOwnerWnd;
2713 if( IS_SYSTEM_MENU(menu) )
2714 {
2715 /* switch to the menu bar */
2716
2717 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2718
2719 if( vk == VK_LEFT )
2720 {
2721 menu = MENU_GetMenu( hNewMenu );
2722 id = menu->nItems - 1;
2723
2724 /* Skip backwards over any system predefined icons,
2725 eg. MDI close, restore etc icons */
2726 while ((id > 0) &&
2727 (menu->items[id].wID >= SC_SIZE &&
2728 menu->items[id].wID <= SC_RESTORE)) id--;
2729 }
2730 }
2731 else if (style & WS_SYSMENU )
2732 {
2733 /* switch to the system menu */
2734 hNewMenu = get_win_sys_menu( hNewWnd );
2735 }
2736 else return FALSE;
2737 }
2738 else /* application returned a new menu to switch to */
2739 {
2740 hNewMenu = next_menu.hmenuNext;
2741 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2742
2743 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2744 {
2745 DWORD style = GetWindowLongW( hNewWnd, GWL_STYLE );
2746
2747 if (style & WS_SYSMENU &&
2748 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2749 {
2750 /* get the real system menu */
2751 hNewMenu = get_win_sys_menu(hNewWnd);
2752 }
2753 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2754 {
2755 /* FIXME: Not sure what to do here;
2756 * perhaps try to track hNewMenu as a popup? */
2757
2758 TRACE(" -- got confused.\n");
2759 return FALSE;
2760 }
2761 }
2762 else return FALSE;
2763 }
2764
2765 if( hNewMenu != pmt->hTopMenu )
2766 {
2767 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2768 FALSE, 0 );
2769 if( pmt->hCurrentMenu != pmt->hTopMenu )
2770 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
2771 }
2772
2773 if( hNewWnd != pmt->hOwnerWnd )
2774 {
2775 pmt->hOwnerWnd = hNewWnd;
2776 set_capture_window( pmt->hOwnerWnd, GUI_INMENUMODE, NULL );
2777 }
2778
2779 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2780 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2781
2782 return TRUE;
2783 }
2784 return FALSE;
2785 }
2786
2787 /***********************************************************************
2788 * MENU_SuspendPopup
2789 *
2790 * The idea is not to show the popup if the next input message is
2791 * going to hide it anyway.
2792 */
2793 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2794 {
2795 MSG msg;
2796
2797 msg.hwnd = pmt->hOwnerWnd;
2798
2799 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2800 pmt->trackFlags |= TF_SKIPREMOVE;
2801
2802 switch( uMsg )
2803 {
2804 case WM_KEYDOWN:
2805 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2806 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2807 {
2808 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2809 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2810 if( msg.message == WM_KEYDOWN &&
2811 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2812 {
2813 pmt->trackFlags |= TF_SUSPENDPOPUP;
2814 return TRUE;
2815 }
2816 }
2817 break;
2818 }
2819
2820 /* failures go through this */
2821 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2822 return FALSE;
2823 }
2824
2825 /***********************************************************************
2826 * MENU_KeyEscape
2827 *
2828 * Handle a VK_ESCAPE key event in a menu.
2829 */
2830 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2831 {
2832 BOOL bEndMenu = TRUE;
2833
2834 if (pmt->hCurrentMenu != pmt->hTopMenu)
2835 {
2836 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2837
2838 if (menu->wFlags & MF_POPUP)
2839 {
2840 HMENU hmenutmp, hmenuprev;
2841
2842 hmenuprev = hmenutmp = pmt->hTopMenu;
2843
2844 /* close topmost popup */
2845 while (hmenutmp != pmt->hCurrentMenu)
2846 {
2847 hmenuprev = hmenutmp;
2848 hmenutmp = MENU_GetSubPopup( hmenuprev );
2849 }
2850
2851 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE, wFlags );
2852 pmt->hCurrentMenu = hmenuprev;
2853 bEndMenu = FALSE;
2854 }
2855 }
2856
2857 return bEndMenu;
2858 }
2859
2860 /***********************************************************************
2861 * MENU_KeyLeft
2862 *
2863 * Handle a VK_LEFT key event in a menu.
2864 */
2865 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2866 {
2867 POPUPMENU *menu;
2868 HMENU hmenutmp, hmenuprev;
2869 UINT prevcol;
2870
2871 hmenuprev = hmenutmp = pmt->hTopMenu;
2872 menu = MENU_GetMenu( hmenutmp );
2873
2874 /* Try to move 1 column left (if possible) */
2875 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2876 NO_SELECTED_ITEM ) {
2877
2878 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2879 prevcol, TRUE, 0 );
2880 return;
2881 }
2882
2883 /* close topmost popup */
2884 while (hmenutmp != pmt->hCurrentMenu)
2885 {
2886 hmenuprev = hmenutmp;
2887 hmenutmp = MENU_GetSubPopup( hmenuprev );
2888 }
2889
2890 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE, wFlags );
2891 pmt->hCurrentMenu = hmenuprev;
2892
2893 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2894 {
2895 /* move menu bar selection if no more popups are left */
2896
2897 if( !MENU_DoNextMenu( pmt, VK_LEFT, wFlags ) )
2898 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2899
2900 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2901 {
2902 /* A sublevel menu was displayed - display the next one
2903 * unless there is another displacement coming up */
2904
2905 if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2906 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2907 pmt->hTopMenu, TRUE, wFlags);
2908 }
2909 }
2910 }
2911
2912
2913 /***********************************************************************
2914 * MENU_KeyRight
2915 *
2916 * Handle a VK_RIGHT key event in a menu.
2917 */
2918 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2919 {
2920 HMENU hmenutmp;
2921 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2922 UINT nextcol;
2923
2924 TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2925 pmt->hCurrentMenu,
2926 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->items[0].text),
2927 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2928
2929 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2930 {
2931 /* If already displaying a popup, try to display sub-popup */
2932
2933 hmenutmp = pmt->hCurrentMenu;
2934 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2935
2936 /* if subpopup was displayed then we are done */
2937 if (hmenutmp != pmt->hCurrentMenu) return;
2938 }
2939
2940 /* Check to see if there's another column */
2941 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2942 NO_SELECTED_ITEM ) {
2943 TRACE("Going to %d.\n", nextcol );
2944 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2945 nextcol, TRUE, 0 );
2946 return;
2947 }
2948
2949 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2950 {
2951 if( pmt->hCurrentMenu != pmt->hTopMenu )
2952 {
2953 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE, wFlags );
2954 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2955 } else hmenutmp = 0;
2956
2957 /* try to move to the next item */
2958 if( !MENU_DoNextMenu( pmt, VK_RIGHT, wFlags ) )
2959 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2960
2961 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2962 if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2963 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2964 pmt->hTopMenu, TRUE, wFlags);
2965 }
2966 }
2967
2968 static void CALLBACK release_capture( BOOL __normal )
2969 {
2970 set_capture_window( 0, GUI_INMENUMODE, NULL );
2971 }
2972
2973 /***********************************************************************
2974 * MENU_TrackMenu
2975 *
2976 * Menu tracking code.
2977 */
2978 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2979 HWND hwnd, const RECT *lprect )
2980 {
2981 MSG msg;
2982 POPUPMENU *menu;
2983 BOOL fRemove;
2984 INT executedMenuId = -1;
2985 MTRACKER mt;
2986 BOOL enterIdleSent = FALSE;
2987 HWND capture_win;
2988
2989 mt.trackFlags = 0;
2990 mt.hCurrentMenu = hmenu;
2991 mt.hTopMenu = hmenu;
2992 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2993 mt.pt.x = x;
2994 mt.pt.y = y;
2995
2996 TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p %s\n",
2997 hmenu, wFlags, x, y, hwnd, wine_dbgstr_rect( lprect));
2998
2999 fEndMenu = FALSE;
3000 if (!(menu = MENU_GetMenu( hmenu )))
3001 {
3002 WARN("Invalid menu handle %p\n", hmenu);
3003 SetLastError(ERROR_INVALID_MENU_HANDLE);
3004 return FALSE;
3005 }
3006
3007 if (wFlags & TPM_BUTTONDOWN)
3008 {
3009 /* Get the result in order to start the tracking or not */
3010 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
3011 fEndMenu = !fRemove;
3012 }
3013
3014 if (wFlags & TF_ENDMENU) fEndMenu = TRUE;
3015
3016 /* owner may not be visible when tracking a popup, so use the menu itself */
3017 capture_win = (wFlags & TPM_POPUPMENU) ? menu->hWnd : mt.hOwnerWnd;
3018 set_capture_window( capture_win, GUI_INMENUMODE, NULL );
3019
3020 __TRY 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 __FINALLY( release_capture )
3242
3243 /* If dropdown is still painted and the close box is clicked on
3244 then the menu will be destroyed as part of the DispatchMessage above.
3245 This will then invalidate the menu handle in mt.hTopMenu. We should
3246 check for this first. */
3247 if( IsMenu( mt.hTopMenu ) )
3248 {
3249 menu = MENU_GetMenu( mt.hTopMenu );
3250
3251 if( IsWindow( mt.hOwnerWnd ) )
3252 {
3253 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE, wFlags );
3254
3255 if (menu && (menu->wFlags & MF_POPUP))
3256 {
3257 DestroyWindow( menu->hWnd );
3258 menu->hWnd = 0;
3259
3260 if (!(wFlags & TPM_NONOTIFY))
3261 SendMessageW( mt.hOwnerWnd, WM_UNINITMENUPOPUP, (WPARAM)mt.hTopMenu,
3262 MAKELPARAM(0, IS_SYSTEM_MENU(menu)) );
3263 }
3264 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
3265 SendMessageW( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
3266 }
3267
3268 /* Reset the variable for hiding menu */
3269 if( menu ) menu->bTimeToHide = FALSE;
3270 }
3271
3272 /* The return value is only used by TrackPopupMenu */
3273 if (!(wFlags & TPM_RETURNCMD)) return TRUE;
3274 if (executedMenuId == -1) executedMenuId = 0;
3275 return executedMenuId;
3276 }
3277
3278 /***********************************************************************
3279 * MENU_InitTracking
3280 */
3281 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
3282 {
3283 POPUPMENU *menu;
3284
3285 TRACE("hwnd=%p hmenu=%p\n", hWnd, hMenu);
3286
3287 HideCaret(0);
3288
3289 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
3290 if (!(wFlags & TPM_NONOTIFY))
3291 SendMessageW( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
3292
3293 SendMessageW( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
3294
3295 if (!(wFlags & TPM_NONOTIFY))
3296 {
3297 SendMessageW( hWnd, WM_INITMENU, (WPARAM)hMenu, 0 );
3298 /* If an app changed/recreated menu bar entries in WM_INITMENU
3299 * menu sizes will be recalculated once the menu created/shown.
3300 */
3301 }
3302
3303 /* This makes the menus of applications built with Delphi work.
3304 * It also enables menus to be displayed in more than one window,
3305 * but there are some bugs left that need to be fixed in this case.
3306 */
3307 if ((menu = MENU_GetMenu( hMenu ))) menu->hWnd = hWnd;
3308
3309 return TRUE;
3310 }
3311 /***********************************************************************
3312 * MENU_ExitTracking
3313 */
3314 static BOOL MENU_ExitTracking(HWND hWnd)
3315 {
3316 TRACE("hwnd=%p\n", hWnd);
3317
3318 SendMessageW( hWnd, WM_EXITMENULOOP, 0, 0 );
3319 ShowCaret(0);
3320 top_popup = 0;
3321 return TRUE;
3322 }
3323
3324 /***********************************************************************
3325 * MENU_TrackMouseMenuBar
3326 *
3327 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
3328 */
3329 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
3330 {
3331 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
3332 UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3333
3334 TRACE("wnd=%p ht=0x%04x %s\n", hWnd, ht, wine_dbgstr_point( &pt));
3335
3336 if (IsMenu(hMenu))
3337 {
3338 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3339 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3340 MENU_ExitTracking(hWnd);
3341 }
3342 }
3343
3344
3345 /***********************************************************************
3346 * MENU_TrackKbdMenuBar
3347 *
3348 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3349 */
3350 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, WCHAR wChar)
3351 {
3352 UINT uItem = NO_SELECTED_ITEM;
3353 HMENU hTrackMenu;
3354 UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3355
3356 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd, wParam, wChar);
3357
3358 /* find window that has a menu */
3359
3360 while (!WIN_ALLOWED_MENU(GetWindowLongW( hwnd, GWL_STYLE )))
3361 if (!(hwnd = GetAncestor( hwnd, GA_PARENT ))) return;
3362
3363 /* check if we have to track a system menu */
3364
3365 hTrackMenu = GetMenu( hwnd );
3366 if (!hTrackMenu || IsIconic(hwnd) || wChar == ' ' )
3367 {
3368 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3369 hTrackMenu = get_win_sys_menu( hwnd );
3370 uItem = 0;
3371 wParam |= HTSYSMENU; /* prevent item lookup */
3372 }
3373
3374 if (!IsMenu( hTrackMenu )) return;
3375
3376 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3377
3378 if( wChar && wChar != ' ' )
3379 {
3380 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, wChar, (wParam & HTSYSMENU) );
3381 if ( uItem >= (UINT)(-2) )
3382 {
3383 if( uItem == (UINT)(-1) ) MessageBeep(0);
3384 /* schedule end of menu tracking */
3385 wFlags |= TF_ENDMENU;
3386 goto track_menu;
3387 }
3388 }
3389
3390 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3391
3392 if (!(wParam & HTSYSMENU) || wChar == ' ')
3393 {
3394 if( uItem == NO_SELECTED_ITEM )
3395 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3396 else
3397 PostMessageW( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3398 }
3399
3400 track_menu:
3401 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3402 MENU_ExitTracking( hwnd );
3403 }
3404
3405
3406 /**********************************************************************
3407 * TrackPopupMenu (USER32.@)
3408 *
3409 * Like the win32 API, the function return the command ID only if the
3410 * flag TPM_RETURNCMD is on.
3411 *
3412 */
3413 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3414 INT nReserved, HWND hWnd, const RECT *lpRect )
3415 {
3416 BOOL ret = FALSE;
3417
3418 TRACE("hmenu %p flags %04x (%d,%d) reserved %d hwnd %p rect %s\n",
3419 hMenu, wFlags, x, y, nReserved, hWnd, wine_dbgstr_rect(lpRect));
3420
3421 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3422
3423 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3424 if (!(wFlags & TPM_NONOTIFY))
3425 SendMessageW( hWnd, WM_INITMENUPOPUP, (WPARAM)hMenu, 0);
3426
3427 if (MENU_ShowPopup( hWnd, hMenu, 0, wFlags, x, y, 0, 0 ))
3428 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3429 MENU_ExitTracking(hWnd);
3430
3431 return ret;
3432 }
3433
3434 /**********************************************************************
3435 * TrackPopupMenuEx (USER32.@)
3436 */
3437 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3438 HWND hWnd, LPTPMPARAMS lpTpm )
3439 {
3440 FIXME("not fully implemented\n" );
3441 return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3442 lpTpm ? &lpTpm->rcExclude : NULL );
3443 }
3444
3445 /***********************************************************************
3446 * PopupMenuWndProc
3447 *
3448 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3449 */
3450 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3451 {
3452 TRACE("hwnd=%p msg=0x%04x wp=0x%04lx lp=0x%08lx\n", hwnd, message, wParam, lParam);
3453
3454 switch(message)
3455 {
3456 case WM_CREATE:
3457 {
3458 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3459 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)cs->lpCreateParams );
3460 return 0;
3461 }
3462
3463 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3464 return MA_NOACTIVATE;
3465
3466 case WM_PAINT:
3467 {
3468 PAINTSTRUCT ps;
3469 BeginPaint( hwnd, &ps );
3470 MENU_DrawPopupMenu( hwnd, ps.hdc,
3471 (HMENU)GetWindowLongPtrW( hwnd, 0 ) );
3472 EndPaint( hwnd, &ps );
3473 return 0;
3474 }
3475 case WM_ERASEBKGND:
3476 return 1;
3477
3478 case WM_DESTROY:
3479 /* zero out global pointer in case resident popup window was destroyed. */
3480 if (hwnd == top_popup) top_popup = 0;
3481 break;
3482
3483 case WM_SHOWWINDOW:
3484
3485 if( wParam )
3486 {
3487 if (!GetWindowLongPtrW( hwnd, 0 )) ERR("no menu to display\n");
3488 }
3489 else
3490 SetWindowLongPtrW( hwnd, 0, 0 );
3491 break;
3492
3493 case MM_SETMENUHANDLE:
3494 SetWindowLongPtrW( hwnd, 0, wParam );
3495 break;
3496
3497 case MM_GETMENUHANDLE:
3498 return GetWindowLongPtrW( hwnd, 0 );
3499
3500 default:
3501 return DefWindowProcW( hwnd, message, wParam, lParam );
3502 }
3503 return 0;
3504 }
3505
3506
3507 /***********************************************************************
3508 * MENU_GetMenuBarHeight
3509 *
3510 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3511 */
3512 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3513 INT orgX, INT orgY )
3514 {
3515 HDC hdc;
3516 RECT rectBar;
3517 LPPOPUPMENU lppop;
3518
3519 TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd, menubarWidth, orgX, orgY );
3520
3521 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3522
3523 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3524 SelectObject( hdc, get_menu_font(FALSE));
3525 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3526 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3527 ReleaseDC( hwnd, hdc );
3528 return lppop->Height;
3529 }
3530
3531
3532 /*******************************************************************
3533 * ChangeMenuA (USER32.@)
3534 */
3535 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3536 UINT id, UINT flags )
3537 {
3538 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3539 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3540 id, data );
3541 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3542 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3543 id, data );
3544 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3545 flags & MF_BYPOSITION ? pos : id,
3546 flags & ~MF_REMOVE );
3547 /* Default: MF_INSERT */
3548 return InsertMenuA( hMenu, pos, flags, id, data );
3549 }
3550
3551
3552 /*******************************************************************
3553 * ChangeMenuW (USER32.@)
3554 */
3555 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3556 UINT id, UINT flags )
3557 {
3558 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3559 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3560 id, data );
3561 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3562 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3563 id, data );
3564 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3565 flags & MF_BYPOSITION ? pos : id,
3566 flags & ~MF_REMOVE );
3567 /* Default: MF_INSERT */
3568 return InsertMenuW( hMenu, pos, flags, id, data );
3569 }
3570
3571
3572 /*******************************************************************
3573 * CheckMenuItem (USER32.@)
3574 */
3575 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3576 {
3577 MENUITEM *item;
3578 DWORD ret;
3579
3580 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3581 ret = item->fState & MF_CHECKED;
3582 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3583 else item->fState &= ~MF_CHECKED;
3584 return ret;
3585 }
3586
3587
3588 /**********************************************************************
3589 * EnableMenuItem (USER32.@)
3590 */
3591 BOOL WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3592 {
3593 UINT oldflags;
3594 MENUITEM *item;
3595 POPUPMENU *menu;
3596
3597 TRACE("(%p, %04x, %04x) !\n", hMenu, wItemID, wFlags);
3598
3599 /* Get the Popupmenu to access the owner menu */
3600 if (!(menu = MENU_GetMenu(hMenu)))
3601 return (UINT)-1;
3602
3603 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3604 return (UINT)-1;
3605
3606 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3607 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3608
3609 /* If the close item in the system menu change update the close button */
3610 if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3611 {
3612 if (menu->hSysMenuOwner != 0)
3613 {
3614 RECT rc;
3615 POPUPMENU* parentMenu;
3616
3617 /* Get the parent menu to access*/
3618 if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3619 return (UINT)-1;
3620
3621 /* Refresh the frame to reflect the change */
3622 GetWindowRect(parentMenu->hWnd, &rc);
3623 MapWindowPoints(0, parentMenu->hWnd, (POINT *)&rc, 2);
3624 rc.bottom = 0;
3625 RedrawWindow(parentMenu->hWnd, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
3626 }
3627 }
3628
3629 return oldflags;
3630 }
3631
3632
3633 /*******************************************************************
3634 * GetMenuStringA (USER32.@)
3635 */
3636 INT WINAPI GetMenuStringA(
3637 HMENU hMenu, /* [in] menuhandle */
3638 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3639 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3640 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3641 UINT wFlags /* [in] MF_ flags */
3642 ) {
3643 MENUITEM *item;
3644
3645 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3646 if (str && nMaxSiz) str[0] = '\0';
3647 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) {
3648 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3649 return 0;
3650 }
3651 if (!item->text) return 0;
3652 if (!str || !nMaxSiz) return strlenW(item->text);
3653 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3654 str[nMaxSiz-1] = 0;
3655 TRACE("returning %s\n", debugstr_a(str));
3656 return strlen(str);
3657 }
3658
3659
3660 /*******************************************************************
3661 * GetMenuStringW (USER32.@)
3662 */
3663 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3664 LPWSTR str, INT nMaxSiz, UINT wFlags )
3665 {
3666 MENUITEM *item;
3667
3668 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3669 if (str && nMaxSiz) str[0] = '\0';
3670 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) {
3671 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3672 return 0;
3673 }
3674 if (!str || !nMaxSiz) return item->text ? strlenW(item->text) : 0;
3675 if( !(item->text)) {
3676 str[0] = 0;
3677 return 0;
3678 }
3679 lstrcpynW( str, item->text, nMaxSiz );
3680 TRACE("returning %s\n", debugstr_w(str));
3681 return strlenW(str);
3682 }
3683
3684
3685 /**********************************************************************
3686 * HiliteMenuItem (USER32.@)
3687 */
3688 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3689 UINT wHilite )
3690 {
3691 LPPOPUPMENU menu;
3692 TRACE("(%p, %p, %04x, %04x);\n", hWnd, hMenu, wItemID, wHilite);
3693 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3694 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3695 if (menu->FocusedItem == wItemID) return TRUE;
3696 MENU_HideSubPopups( hWnd, hMenu, FALSE, 0 );
3697 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3698 return TRUE;
3699 }
3700
3701
3702 /**********************************************************************
3703 * GetMenuState (USER32.@)
3704 */
3705 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3706 {
3707 MENUITEM *item;
3708 TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, wItemID, wFlags);
3709 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3710 debug_print_menuitem (" item: ", item, "");
3711 if (item->fType & MF_POPUP)
3712 {
3713 POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3714 if (!menu) return -1;
3715 else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3716 }
3717 else
3718 {
3719 /* We used to (from way back then) mask the result to 0xff. */
3720 /* I don't know why and it seems wrong as the documented */
3721 /* return flag MF_SEPARATOR is outside that mask. */
3722 return (item->fType | item->fState);
3723 }
3724 }
3725
3726
3727 /**********************************************************************
3728 * GetMenuItemCount (USER32.@)
3729 */
3730 INT WINAPI GetMenuItemCount( HMENU hMenu )
3731 {
3732 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3733 if (!menu) return -1;
3734 TRACE("(%p) returning %d\n", hMenu, menu->nItems );
3735 return menu->nItems;
3736 }
3737
3738
3739 /**********************************************************************
3740 * GetMenuItemID (USER32.@)
3741 */
3742 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3743 {
3744 MENUITEM * lpmi;
3745
3746 if (!(lpmi = MENU_FindItem(&hMenu,(UINT*)&nPos,MF_BYPOSITION))) return -1;
3747 if (lpmi->fType & MF_POPUP) return -1;
3748 return lpmi->wID;
3749
3750 }
3751
3752
3753 /*******************************************************************
3754 * InsertMenuW (USER32.@)
3755 */
3756 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3757 UINT_PTR id, LPCWSTR str )
3758 {
3759 MENUITEM *item;
3760
3761 if (IS_STRING_ITEM(flags) && str)
3762 TRACE("hMenu %p, pos %d, flags %08x, id %04lx, str %s\n",
3763 hMenu, pos, flags, id, debugstr_w(str) );
3764 else TRACE("hMenu %p, pos %d, flags %08x, id %04lx, str %p (not a string)\n",
3765 hMenu, pos, flags, id, str );
3766
3767 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3768
3769 if (!(MENU_SetItemData( item, flags, id, str )))
3770 {
3771 RemoveMenu( hMenu, pos, flags );
3772 return FALSE;
3773 }
3774
3775 item->hCheckBit = item->hUnCheckBit = 0;
3776 return TRUE;
3777 }
3778
3779
3780 /*******************************************************************
3781 * InsertMenuA (USER32.@)
3782 */
3783 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3784 UINT_PTR id, LPCSTR str )
3785 {
3786 BOOL ret = FALSE;
3787
3788 if (IS_STRING_ITEM(flags) && str)
3789 {
3790 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3791 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3792 if (newstr)
3793 {
3794 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3795 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3796 HeapFree( GetProcessHeap(), 0, newstr );
3797 }
3798 return ret;
3799 }
3800 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3801 }
3802
3803
3804 /*******************************************************************
3805 * AppendMenuA (USER32.@)
3806 */
3807 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3808 UINT_PTR id, LPCSTR data )
3809 {
3810 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3811 }
3812
3813
3814 /*******************************************************************
3815 * AppendMenuW (USER32.@)
3816 */
3817 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3818 UINT_PTR id, LPCWSTR data )
3819 {
3820 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3821 }
3822
3823
3824 /**********************************************************************
3825 * RemoveMenu (USER32.@)
3826 */
3827 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3828 {
3829 LPPOPUPMENU menu;
3830 MENUITEM *item;
3831
3832 TRACE("(menu=%p pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3833 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3834 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3835
3836 /* Remove item */
3837
3838 MENU_FreeItemData( item );
3839
3840 if (--menu->nItems == 0)
3841 {
3842 HeapFree( GetProcessHeap(), 0, menu->items );
3843 menu->items = NULL;
3844 }
3845 else
3846 {
3847 while(nPos < menu->nItems)
3848 {
3849 *item = *(item+1);
3850 item++;
3851 nPos++;
3852 }
3853 menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3854 menu->nItems * sizeof(MENUITEM) );
3855 }
3856 return TRUE;
3857 }
3858
3859
3860 /**********************************************************************
3861 * DeleteMenu (USER32.@)
3862 */
3863 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3864 {
3865 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3866 if (!item) return FALSE;
3867 if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3868 /* nPos is now the position of the item */
3869 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3870 return TRUE;
3871 }
3872
3873
3874 /*******************************************************************
3875 * ModifyMenuW (USER32.@)
3876 */
3877 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3878 UINT_PTR id, LPCWSTR str )
3879 {
3880 MENUITEM *item;
3881
3882 if (IS_STRING_ITEM(flags))
3883 TRACE("%p %d %04x %04lx %s\n", hMenu, pos, flags, id, debugstr_w(str) );
3884 else
3885 TRACE("%p %d %04x %04lx %p\n", hMenu, pos, flags, id, str );
3886
3887 if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3888 MENU_GetMenu(hMenu)->Height = 0; /* force size recalculate */
3889 return MENU_SetItemData( item, flags, id, str );
3890 }
3891
3892
3893 /*******************************************************************
3894 * ModifyMenuA (USER32.@)
3895 */
3896 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3897 UINT_PTR id, LPCSTR str )
3898 {
3899 BOOL ret = FALSE;
3900
3901 if (IS_STRING_ITEM(flags) && str)
3902 {
3903 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3904 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3905 if (newstr)
3906 {
3907 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3908 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3909 HeapFree( GetProcessHeap(), 0, newstr );
3910 }
3911 return ret;
3912 }
3913 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3914 }
3915
3916
3917 /**********************************************************************
3918 * CreatePopupMenu (USER32.@)
3919 */
3920 HMENU WINAPI CreatePopupMenu(void)
3921 {
3922 HMENU hmenu;
3923 POPUPMENU *menu;
3924
3925 if (!(hmenu = CreateMenu())) return 0;
3926 menu = MENU_GetMenu( hmenu );
3927 menu->wFlags |= MF_POPUP;
3928 menu->bTimeToHide = FALSE;
3929 return hmenu;
3930 }
3931
3932
3933 /**********************************************************************
3934 * GetMenuCheckMarkDimensions (USER.417)
3935 * GetMenuCheckMarkDimensions (USER32.@)
3936 */
3937 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3938 {
3939 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3940 }
3941
3942
3943 /**********************************************************************
3944 * SetMenuItemBitmaps (USER32.@)
3945 */
3946 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3947 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3948 {
3949 MENUITEM *item;
3950
3951 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3952
3953 if (!hNewCheck && !hNewUnCheck)
3954 {
3955 item->fState &= ~MF_USECHECKBITMAPS;
3956 }
3957 else /* Install new bitmaps */
3958 {
3959 item->hCheckBit = hNewCheck;
3960 item->hUnCheckBit = hNewUnCheck;
3961 item->fState |= MF_USECHECKBITMAPS;
3962 }
3963 return TRUE;
3964 }
3965
3966
3967 /**********************************************************************
3968 * CreateMenu (USER32.@)
3969 */
3970 HMENU WINAPI CreateMenu(void)
3971 {
3972 HMENU hMenu;
3973 LPPOPUPMENU menu;
3974 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3975 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3976
3977 ZeroMemory(menu, sizeof(POPUPMENU));
3978 menu->wMagic = MENU_MAGIC;
3979 menu->FocusedItem = NO_SELECTED_ITEM;
3980 menu->bTimeToHide = FALSE;
3981
3982 TRACE("return %p\n", hMenu );
3983
3984 return hMenu;
3985 }
3986
3987
3988 /**********************************************************************
3989 * DestroyMenu (USER32.@)
3990 */
3991 BOOL WINAPI DestroyMenu( HMENU hMenu )
3992 {
3993 LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3994
3995 TRACE("(%p)\n", hMenu);
3996
3997
3998 if (!lppop) return FALSE;
3999
4000 lppop->wMagic = 0; /* Mark it as destroyed */
4001
4002 /* DestroyMenu should not destroy system menu popup owner */
4003 if ((lppop->wFlags & (MF_POPUP | MF_SYSMENU)) == MF_POPUP && lppop->hWnd)
4004 {
4005 DestroyWindow( lppop->hWnd );
4006 lppop->hWnd = 0;
4007 }
4008
4009 if (lppop->items) /* recursively destroy submenus */
4010 {
4011 int i;
4012 MENUITEM *item = lppop->items;
4013 for (i = lppop->nItems; i > 0; i--, item++)
4014 {
4015 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
4016 MENU_FreeItemData( item );
4017 }
4018 HeapFree( GetProcessHeap(), 0, lppop->items );
4019 }
4020 USER_HEAP_FREE( hMenu );
4021 return TRUE;
4022 }
4023
4024
4025 /**********************************************************************
4026 * GetSystemMenu (USER32.@)
4027 */
4028 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
4029 {
4030 WND *wndPtr = WIN_GetPtr( hWnd );
4031 HMENU retvalue = 0;
4032
4033 if (wndPtr == WND_DESKTOP) return 0;
4034 if (wndPtr == WND_OTHER_PROCESS)
4035 {
4036 if (IsWindow( hWnd )) FIXME( "not supported on other process window %p\n", hWnd );
4037 }
4038 else if (wndPtr)
4039 {
4040 if (wndPtr->hSysMenu && bRevert)
4041 {
4042 DestroyMenu(wndPtr->hSysMenu);
4043 wndPtr->hSysMenu = 0;
4044 }
4045
4046 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
4047 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, 0 );
4048
4049 if( wndPtr->hSysMenu )
4050 {
4051 POPUPMENU *menu;
4052 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
4053
4054 /* Store the dummy sysmenu handle to facilitate the refresh */
4055 /* of the close button if the SC_CLOSE item change */
4056 menu = MENU_GetMenu(retvalue);
4057 if ( menu )
4058 menu->hSysMenuOwner = wndPtr->hSysMenu;
4059 }
4060 WIN_ReleasePtr( wndPtr );
4061 }
4062 return bRevert ? 0 : retvalue;
4063 }
4064
4065
4066 /*******************************************************************
4067 * SetSystemMenu (USER32.@)
4068 */
4069 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
4070 {
4071 WND *wndPtr = WIN_GetPtr( hwnd );
4072
4073 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
4074 {
4075 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
4076 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
4077 WIN_ReleasePtr( wndPtr );
4078 return TRUE;
4079 }
4080 return FALSE;
4081 }
4082
4083
4084 /**********************************************************************
4085 * GetMenu (USER32.@)
4086 */
4087 HMENU WINAPI GetMenu( HWND hWnd )
4088 {
4089 HMENU retvalue = (HMENU)GetWindowLongPtrW( hWnd, GWLP_ID );
4090 TRACE("for %p returning %p\n", hWnd, retvalue);
4091 return retvalue;
4092 }
4093
4094 /**********************************************************************
4095 * GetMenuBarInfo (USER32.@)
4096 */
4097 BOOL WINAPI GetMenuBarInfo( HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi )
4098 {
4099 FIXME( "(%p,0x%08x,0x%08x,%p)\n", hwnd, idObject, idItem, pmbi );
4100 return FALSE;
4101 }
4102
4103 /**********************************************************************
4104 * MENU_SetMenu
4105 *
4106 * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
4107 * SetWindowPos call that would result if SetMenu were called directly.
4108 */
4109 BOOL MENU_SetMenu( HWND hWnd, HMENU hMenu )
4110 {
4111 TRACE("(%p, %p);\n", hWnd, hMenu);
4112
4113 if (hMenu && !IsMenu(hMenu))
4114 {
4115 WARN("hMenu %p is not a menu handle\n", hMenu);
4116 return FALSE;
4117 }
4118 if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
4119 return FALSE;
4120
4121 hWnd = WIN_GetFullHandle( hWnd );
4122 if (GetCapture() == hWnd)
4123 set_capture_window( 0, GUI_INMENUMODE, NULL ); /* release the capture */
4124
4125 if (hMenu != 0)
4126 {
4127 LPPOPUPMENU lpmenu;
4128
4129 if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
4130
4131 lpmenu->hWnd = hWnd;
4132 lpmenu->Height = 0; /* Make sure we recalculate the size */
4133 }
4134 SetWindowLongPtrW( hWnd, GWLP_ID, (LONG_PTR)hMenu );
4135 return TRUE;
4136 }
4137
4138
4139 /**********************************************************************
4140 * SetMenu (USER32.@)
4141 */
4142 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
4143 {
4144 if(!MENU_SetMenu(hWnd, hMenu))
4145 return FALSE;
4146
4147 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4148 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4149 return TRUE;
4150 }
4151
4152
4153 /**********************************************************************
4154 * GetSubMenu (USER32.@)
4155 */
4156 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4157 {
4158 MENUITEM * lpmi;
4159
4160 if (!(lpmi = MENU_FindItem(&hMenu,(UINT*)&nPos,MF_BYPOSITION))) return 0;
4161 if (!(lpmi->fType & MF_POPUP)) return 0;
4162 return lpmi->hSubMenu;
4163 }
4164
4165
4166 /**********************************************************************
4167 * DrawMenuBar (USER32.@)
4168 */
4169 BOOL WINAPI DrawMenuBar( HWND hWnd )
4170 {
4171 LPPOPUPMENU lppop;
4172 HMENU hMenu = GetMenu(hWnd);
4173
4174 if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
4175 return FALSE;
4176 if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
4177
4178 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4179 lppop->hwndOwner = hWnd;
4180 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4181 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4182 return TRUE;
4183 }
4184
4185 /***********************************************************************
4186 * DrawMenuBarTemp (USER32.@)
4187 *
4188 * UNDOCUMENTED !!
4189 *
4190 * called by W98SE desk.cpl Control Panel Applet
4191 *
4192 * Not 100% sure about the param names, but close.
4193 */
4194 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont)
4195 {
4196 LPPOPUPMENU lppop;
4197 UINT i,retvalue;
4198 HFONT hfontOld = 0;
4199 BOOL flat_menu = FALSE;
4200
4201 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
4202
4203 if (!hMenu)
4204 hMenu = GetMenu(hwnd);
4205
4206 if (!hFont)
4207 hFont = get_menu_font(FALSE);
4208
4209 lppop = MENU_GetMenu( hMenu );
4210 if (lppop == NULL || lprect == NULL)
4211 {
4212 retvalue = GetSystemMetrics(SM_CYMENU);
4213 goto END;
4214 }
4215
4216 TRACE("(%p, %p, %p, %p, %p)\n", hwnd, hDC, lprect, hMenu, hFont);
4217
4218 hfontOld = SelectObject( hDC, hFont);
4219
4220 if (lppop->Height == 0)
4221 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
4222
4223 lprect->bottom = lprect->top + lppop->Height;
4224
4225 FillRect(hDC, lprect, GetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU) );
4226
4227 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
4228 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
4229 LineTo( hDC, lprect->right, lprect->bottom );
4230
4231 if (lppop->nItems == 0)
4232 {
4233 retvalue = GetSystemMetrics(SM_CYMENU);
4234 goto END;
4235 }
4236
4237 for (i = 0; i < lppop->nItems; i++)
4238 {
4239 MENU_DrawMenuItem( hwnd, hMenu, hwnd,
4240 hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
4241 }
4242 retvalue = lppop->Height;
4243
4244 END:
4245 if (hfontOld) SelectObject (hDC, hfontOld);
4246 return retvalue;
4247 }
4248
4249 /***********************************************************************
4250 * EndMenu (USER.187)
4251 * EndMenu (USER32.@)
4252 */
4253 BOOL WINAPI EndMenu(void)
4254 {
4255 /* if we are in the menu code, and it is active */
4256 if (!fEndMenu && top_popup)
4257 {
4258 /* terminate the menu handling code */
4259 fEndMenu = TRUE;
4260
4261 /* needs to be posted to wakeup the internal menu handler */
4262 /* which will now terminate the menu, in the event that */
4263 /* the main window was minimized, or lost focus, so we */
4264 /* don't end up with an orphaned menu */
4265 PostMessageW( top_popup, WM_CANCELMODE, 0, 0);
4266 }
4267 return fEndMenu;
4268 }
4269
4270
4271 /***********************************************************************
4272 * LookupMenuHandle (USER.217)
4273 */
4274 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
4275 {
4276 HMENU hmenu32 = HMENU_32(hmenu);
4277 UINT id32 = id;
4278 if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
4279 else return HMENU_16(hmenu32);
4280 }
4281
4282
4283 /**********************************************************************
4284 * LoadMenu (USER.150)
4285 */
4286 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
4287 {
4288 HRSRC16 hRsrc;
4289 HGLOBAL16 handle;
4290 HMENU16 hMenu;
4291
4292 if (HIWORD(name) && name[0] == '#') name = ULongToPtr(atoi( name + 1 ));
4293 if (!name) return 0;
4294
4295 instance = GetExePtr( instance );
4296 if (!(hRsrc = FindResource16( instance, name, (LPSTR)RT_MENU ))) return 0;
4297 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
4298 hMenu = LoadMenuIndirect16(LockResource16(handle));
4299 FreeResource16( handle );
4300 return hMenu;
4301 }
4302
4303
4304 /*****************************************************************
4305 * LoadMenuA (USER32.@)
4306 */
4307 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4308 {
4309 HRSRC hrsrc = FindResourceA( instance, name, (LPSTR)RT_MENU );
4310 if (!hrsrc) return 0;
4311 return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
4312 }
4313
4314
4315 /*****************************************************************
4316 * LoadMenuW (USER32.@)
4317 */
4318 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4319 {
4320 HRSRC hrsrc = FindResourceW( instance, name, (LPWSTR)RT_MENU );
4321 if (!hrsrc) return 0;
4322 return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
4323 }
4324
4325
4326 /**********************************************************************
4327 * LoadMenuIndirect (USER.220)
4328 */
4329 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
4330 {
4331 HMENU hMenu;
4332 WORD version, offset;
4333 LPCSTR p = (LPCSTR)template;
4334
4335 TRACE("(%p)\n", template );
4336 version = GET_WORD(p);
4337 p += sizeof(WORD);
4338 if (version)
4339 {
4340 WARN("version must be 0 for Win16\n" );
4341 return 0;
4342 }
4343 offset = GET_WORD(p);
4344 p += sizeof(WORD) + offset;
4345 if (!(hMenu = CreateMenu())) return 0;
4346 if (!MENU_ParseResource( p, hMenu, FALSE ))
4347 {
4348 DestroyMenu( hMenu );
4349 return 0;
4350 }
4351 return HMENU_16(hMenu);
4352 }
4353
4354
4355 /**********************************************************************
4356 * LoadMenuIndirectW (USER32.@)
4357 */
4358 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4359 {
4360 HMENU hMenu;
4361 WORD version, offset;
4362 LPCSTR p = (LPCSTR)template;
4363
4364 version = GET_WORD(p);
4365 p += sizeof(WORD);
4366 TRACE("%p, ver %d\n", template, version );
4367 switch (version)
4368 {
4369 case 0: /* standard format is version of 0 */
4370 offset = GET_WORD(p);
4371 p += sizeof(WORD) + offset;
4372 if (!(hMenu = CreateMenu())) return 0;
4373 if (!MENU_ParseResource( p, hMenu, TRUE ))
4374 {
4375 DestroyMenu( hMenu );
4376 return 0;
4377 }
4378 return hMenu;
4379 case 1: /* extended format is version of 1 */
4380 offset = GET_WORD(p);
4381 p += sizeof(WORD) + offset;
4382 if (!(hMenu = CreateMenu())) return 0;
4383 if (!MENUEX_ParseResource( p, hMenu))
4384 {
4385 DestroyMenu( hMenu );
4386 return 0;
4387 }
4388 return hMenu;
4389 default:
4390 ERR("version %d not supported.\n", version);
4391 return 0;
4392 }
4393 }
4394
4395
4396 /**********************************************************************
4397 * LoadMenuIndirectA (USER32.@)
4398 */
4399 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4400 {
4401 return LoadMenuIndirectW( template );
4402 }
4403
4404
4405 /**********************************************************************
4406 * IsMenu (USER32.@)
4407 */
4408 BOOL WINAPI IsMenu(HMENU hmenu)
4409 {
4410 LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4411
4412 if (!menu)
4413 {
4414 SetLastError(ERROR_INVALID_MENU_HANDLE);
4415 return FALSE;
4416 }
4417 return TRUE;
4418 }
4419
4420 /**********************************************************************
4421 * GetMenuItemInfo_common
4422 */
4423
4424 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4425 LPMENUITEMINFOW lpmii, BOOL unicode)
4426 {
4427 MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos ? MF_BYPOSITION : 0);
4428
4429 debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4430
4431 if (!menu) {
4432 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
4433 return FALSE;
4434 }
4435
4436 if( lpmii->fMask & MIIM_TYPE) {
4437 if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) {
4438 WARN("invalid combination of fMask bits used\n");
4439 /* this does not happen on Win9x/ME */
4440 SetLastError( ERROR_INVALID_PARAMETER);
4441 return FALSE;
4442 }
4443 lpmii->fType = menu->fType & MENUITEMINFO_TYPE_MASK;
4444 if( menu->hbmpItem) lpmii->fType |= MFT_BITMAP;
4445 lpmii->hbmpItem = menu->hbmpItem; /* not on Win9x/ME */
4446 if( lpmii->fType & MFT_BITMAP) {
4447 lpmii->dwTypeData = (LPWSTR) menu->hbmpItem;
4448 lpmii->cch = 0;
4449 } else if( lpmii->fType & (MFT_OWNERDRAW | MFT_SEPARATOR)) {
4450 /* this does not happen on Win9x/ME */
4451 lpmii->dwTypeData = 0;
4452 lpmii->cch = 0;
4453 }
4454 }
4455
4456 /* copy the text string */
4457 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING))) {
4458 if( !menu->text ) {
4459 if(lpmii->dwTypeData && lpmii->cch) {
4460 lpmii->cch = 0;
4461 if( unicode)
4462 *((WCHAR *)lpmii->dwTypeData) = 0;
4463 else
4464 *((CHAR *)lpmii->dwTypeData) = 0;
4465 }
4466 } else {
4467 int len;
4468 if (unicode)
4469 {
4470 len = strlenW(menu->text);
4471 if(lpmii->dwTypeData && lpmii->cch)
4472 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4473 }
4474 else
4475 {
4476 len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL,
4477 0, NULL, NULL ) - 1;
4478 if(lpmii->dwTypeData && lpmii->cch)
4479 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4480 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4481 ((LPSTR)lpmii->dwTypeData)[lpmii->cch - 1] = 0;
4482 }
4483 /* if we've copied a substring we return its length */
4484 if(lpmii->dwTypeData && lpmii->cch)
4485 if (lpmii->cch <= len + 1)
4486 lpmii->cch--;
4487 else
4488 lpmii->cch = len;
4489 else {
4490 /* return length of string */
4491 /* not on Win9x/ME if fType & MFT_BITMAP */
4492 lpmii->cch = len;
4493 }
4494 }
4495 }
4496
4497 if (lpmii->fMask & MIIM_FTYPE)
4498 lpmii->fType = menu->fType & MENUITEMINFO_TYPE_MASK;
4499
4500 if (lpmii->fMask & MIIM_BITMAP)
4501 lpmii->hbmpItem = menu->hbmpItem;
4502
4503 if (lpmii->fMask & MIIM_STATE)
4504 lpmii->fState = menu->fState & MENUITEMINFO_STATE_MASK;
4505
4506 if (lpmii->fMask & MIIM_ID)
4507 lpmii->wID = menu->wID;
4508
4509 if (lpmii->fMask & MIIM_SUBMENU)
4510 lpmii->hSubMenu = menu->hSubMenu;
4511 else {
4512 /* hSubMenu is always cleared
4513 * (not on Win9x/ME ) */
4514 lpmii->hSubMenu = 0;
4515 }
4516
4517 if (lpmii->fMask & MIIM_CHECKMARKS) {
4518 lpmii->hbmpChecked = menu->hCheckBit;
4519 lpmii->hbmpUnchecked = menu->hUnCheckBit;
4520 }
4521 if (lpmii->fMask & MIIM_DATA)
4522 lpmii->dwItemData = menu->dwItemData;
4523
4524 return TRUE;
4525 }
4526
4527 /**********************************************************************
4528 * GetMenuItemInfoA (USER32.@)
4529 */
4530 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4531 LPMENUITEMINFOA lpmii)
4532 {
4533 BOOL ret;
4534 MENUITEMINFOA mii;
4535 if( lpmii->cbSize != sizeof( mii) &&
4536 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4537 SetLastError( ERROR_INVALID_PARAMETER);
4538 return FALSE;
4539 }
4540 memcpy( &mii, lpmii, lpmii->cbSize);
4541 mii.cbSize = sizeof( mii);
4542 ret = GetMenuItemInfo_common (hmenu, item, bypos,
4543 (LPMENUITEMINFOW)&mii, FALSE);
4544 mii.cbSize = lpmii->cbSize;
4545 memcpy( lpmii, &mii, mii.cbSize);
4546 return ret;
4547 }
4548
4549 /**********************************************************************
4550 * GetMenuItemInfoW (USER32.@)
4551 */
4552 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4553 LPMENUITEMINFOW lpmii)
4554 {
4555 BOOL ret;
4556 MENUITEMINFOW mii;
4557 if( lpmii->cbSize != sizeof( mii) &&
4558 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4559 SetLastError( ERROR_INVALID_PARAMETER);
4560 return FALSE;
4561 }
4562 memcpy( &mii, lpmii, lpmii->cbSize);
4563 mii.cbSize = sizeof( mii);
4564 ret = GetMenuItemInfo_common (hmenu, item, bypos, &mii, TRUE);
4565 mii.cbSize = lpmii->cbSize;
4566 memcpy( lpmii, &mii, mii.cbSize);
4567 return ret;
4568 }
4569
4570
4571 /* set a menu item text from a ASCII or Unicode string */
4572 static inline void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4573 {
4574 if (!text)
4575 menu->text = NULL;
4576 else if (unicode)
4577 {
4578 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4579 strcpyW( menu->text, text );
4580 }
4581 else
4582 {
4583 LPCSTR str = (LPCSTR)text;
4584 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4585 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4586 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4587 }
4588 }
4589
4590
4591 /**********************************************************************
4592 * SetMenuItemInfo_common
4593 */
4594
4595 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4596 const MENUITEMINFOW *lpmii,
4597 BOOL unicode)
4598 {
4599 if (!menu) return FALSE;
4600
4601 debug_print_menuitem("SetMenuItemInfo_common from: ", menu, "");
4602
4603 if (lpmii->fMask & MIIM_TYPE ) {
4604 if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) {
4605 WARN("invalid combination of fMask bits used\n");
4606 /* this does not happen on Win9x/ME */
4607 SetLastError( ERROR_INVALID_PARAMETER);
4608 return FALSE;
4609 }
4610
4611 /* Remove the old type bits and replace them with the new ones */
4612 menu->fType &= ~MENUITEMINFO_TYPE_MASK;
4613 menu->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
4614
4615 if (IS_STRING_ITEM(menu->fType)) {
4616 HeapFree(GetProcessHeap(), 0, menu->text);
4617 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4618 } else if( (menu->fType) & MFT_BITMAP)
4619 menu->hbmpItem = HBITMAP_32(LOWORD(lpmii->dwTypeData));
4620 }
4621
4622 if (lpmii->fMask & MIIM_FTYPE ) {
4623 if(( lpmii->fType & MFT_BITMAP)) {
4624 SetLastError( ERROR_INVALID_PARAMETER);
4625 return FALSE;
4626 }
4627 menu->fType &= ~MENUITEMINFO_TYPE_MASK;
4628 menu->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
4629 }
4630 if (lpmii->fMask & MIIM_STRING ) {
4631 /* free the string when used */
4632 HeapFree(GetProcessHeap(), 0, menu->text);
4633 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4634 }
4635
4636 if (lpmii->fMask & MIIM_STATE)
4637 {
4638 /* Other menu items having MFS_DEFAULT are not converted
4639 to normal items */
4640 menu->fState = lpmii->fState & MENUITEMINFO_STATE_MASK;
4641 }
4642
4643 if (lpmii->fMask & MIIM_ID)
4644 menu->wID = lpmii->wID;
4645
4646 if (lpmii->fMask & MIIM_SUBMENU) {
4647 menu->hSubMenu = lpmii->hSubMenu;
4648 if (menu->hSubMenu) {
4649 POPUPMENU *subMenu = MENU_GetMenu(menu->hSubMenu);
4650 if (subMenu) {
4651 subMenu->wFlags |= MF_POPUP;
4652 menu->fType |= MF_POPUP;
4653 }
4654 else {
4655 SetLastError( ERROR_INVALID_PARAMETER);
4656 return FALSE;
4657 }
4658 }
4659 else
4660 menu->fType &= ~MF_POPUP;
4661 }
4662
4663 if (lpmii->fMask & MIIM_CHECKMARKS)
4664 {
4665 menu->hCheckBit = lpmii->hbmpChecked;
4666 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4667 }
4668 if (lpmii->fMask & MIIM_DATA)
4669 menu->dwItemData = lpmii->dwItemData;
4670
4671 if (lpmii->fMask & MIIM_BITMAP)
4672 menu->hbmpItem = lpmii->hbmpItem;
4673
4674 if( !menu->text && !(menu->fType & MFT_OWNERDRAW) && !menu->hbmpItem)
4675 menu->fType |= MFT_SEPARATOR;
4676
4677 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4678 return TRUE;
4679 }
4680
4681 /**********************************************************************
4682 * SetMenuItemInfoA (USER32.@)
4683 */
4684 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4685 const MENUITEMINFOA *lpmii)
4686 {
4687 MENUITEMINFOA mii;
4688
4689 TRACE("hmenu %p, item %u, by pos %d, info %p\n", hmenu, item, bypos, lpmii);
4690
4691 if( lpmii->cbSize != sizeof( mii) &&
4692 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4693 SetLastError( ERROR_INVALID_PARAMETER);
4694 return FALSE;
4695 }
4696 memcpy( &mii, lpmii, lpmii->cbSize);
4697 if( lpmii->cbSize != sizeof( mii)) {
4698 mii.cbSize = sizeof( mii);
4699 mii.hbmpItem = NULL;
4700 }
4701 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4702 (const MENUITEMINFOW *)&mii, FALSE);
4703 }
4704
4705 /**********************************************************************
4706 * SetMenuItemInfoW (USER32.@)
4707 */
4708 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4709 const MENUITEMINFOW *lpmii)
4710 {
4711 MENUITEMINFOW mii;
4712
4713 TRACE("hmenu %p, item %u, by pos %d, info %p\n", hmenu, item, bypos, lpmii);
4714
4715 if( lpmii->cbSize != sizeof( mii) &&
4716 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4717 SetLastError( ERROR_INVALID_PARAMETER);
4718 return FALSE;
4719 }
4720 memcpy( &mii, lpmii, lpmii->cbSize);
4721 if( lpmii->cbSize != sizeof( mii)) {
4722 mii.cbSize = sizeof( mii);
4723 mii.hbmpItem = NULL;
4724 }
4725 return SetMenuItemInfo_common(MENU_FindItem(&hmenu,
4726 &item, bypos? MF_BYPOSITION : 0), &mii, TRUE);
4727 }
4728
4729 /**********************************************************************
4730 * SetMenuDefaultItem (USER32.@)
4731 *
4732 */
4733 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4734 {
4735 UINT i;
4736 POPUPMENU *menu;
4737 MENUITEM *item;
4738
4739 TRACE("(%p,%d,%d)\n", hmenu, uItem, bypos);
4740
4741 if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4742
4743 /* reset all default-item flags */
4744 item = menu->items;
4745 for (i = 0; i < menu->nItems; i++, item++)
4746 {
4747 item->fState &= ~MFS_DEFAULT;
4748 }
4749
4750 /* no default item */
4751 if ( -1 == uItem)
4752 {
4753 return TRUE;
4754 }
4755
4756 item = menu->items;
4757 if ( bypos )
4758 {
4759 if ( uItem >= menu->nItems ) return FALSE;
4760 item[uItem].fState |= MFS_DEFAULT;
4761 return TRUE;
4762 }
4763 else
4764 {
4765 for (i = 0; i < menu->nItems; i++, item++)
4766 {
4767 if (item->wID == uItem)
4768 {
4769 item->fState |= MFS_DEFAULT;
4770 return TRUE;
4771 }
4772 }
4773
4774 }
4775 return FALSE;
4776 }
4777
4778 /**********************************************************************
4779 * GetMenuDefaultItem (USER32.@)
4780 */
4781 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4782 {
4783 POPUPMENU *menu;
4784 MENUITEM * item;
4785 UINT i = 0;
4786
4787 TRACE("(%p,%d,%d)\n", hmenu, bypos, flags);
4788
4789 if (!(menu = MENU_GetMenu(hmenu))) return -1;
4790
4791 /* find default item */
4792 item = menu->items;
4793
4794 /* empty menu */
4795 if (! item) return -1;
4796
4797 while ( !( item->fState & MFS_DEFAULT ) )
4798 {
4799 i++; item++;
4800 if (i >= menu->nItems ) return -1;
4801 }
4802
4803 /* default: don't return disabled items */
4804 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4805
4806 /* search rekursiv when needed */
4807 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4808 {
4809 UINT ret;
4810 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4811 if ( -1 != ret ) return ret;
4812
4813 /* when item not found in submenu, return the popup item */
4814 }
4815 return ( bypos ) ? i : item->wID;
4816
4817 }
4818
4819
4820 /**********************************************************************
4821 * InsertMenuItemA (USER32.@)
4822 */
4823 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4824 const MENUITEMINFOA *lpmii)
4825 {
4826 MENUITEM *item;
4827 MENUITEMINFOA mii;
4828
4829 TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, bypos, lpmii);
4830
4831 if( lpmii->cbSize != sizeof( mii) &&
4832 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4833 SetLastError( ERROR_INVALID_PARAMETER);
4834 return FALSE;
4835 }
4836 memcpy( &mii, lpmii, lpmii->cbSize);
4837 if( lpmii->cbSize != sizeof( mii)) {
4838 mii.cbSize = sizeof( mii);
4839 mii.hbmpItem = NULL;
4840 }
4841
4842 item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4843 return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)&mii, FALSE);
4844 }
4845
4846
4847 /**********************************************************************
4848 * InsertMenuItemW (USER32.@)
4849 */
4850 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4851 const MENUITEMINFOW *lpmii)
4852 {
4853 MENUITEM *item;
4854 MENUITEMINFOW mii;
4855
4856 TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, bypos, lpmii);
4857
4858 if( lpmii->cbSize != sizeof( mii) &&
4859 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4860 SetLastError( ERROR_INVALID_PARAMETER);
4861 return FALSE;
4862 }
4863 memcpy( &mii, lpmii, lpmii->cbSize);
4864 if( lpmii->cbSize != sizeof( mii)) {
4865 mii.cbSize = sizeof( mii);
4866 mii.hbmpItem = NULL;
4867 }
4868
4869 item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4870 return SetMenuItemInfo_common(item, &mii, TRUE);
4871 }
4872
4873 /**********************************************************************
4874 * CheckMenuRadioItem (USER32.@)
4875 */
4876
4877 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4878 UINT first, UINT last, UINT check,
4879 UINT bypos)
4880 {
4881 BOOL done = FALSE;
4882 UINT i;
4883 MENUITEM *mi_first = NULL, *mi_check;
4884 HMENU m_first, m_check;
4885
4886 for (i = first; i <= last; i++)
4887 {
4888 UINT pos = i;
4889
4890 if (!mi_first)
4891 {
4892 m_first = hMenu;
4893 mi_first = MENU_FindItem(&m_first, &pos, bypos);
4894 if (!mi_first) continue;
4895 mi_check = mi_first;
4896 m_check = m_first;
4897 }
4898 else
4899 {
4900 m_check = hMenu;
4901 mi_check = MENU_FindItem(&m_check, &pos, bypos);
4902 if (!mi_check) continue;
4903 }
4904
4905 if (m_first != m_check) continue;
4906 if (mi_check->fType == MFT_SEPARATOR) continue;
4907
4908 if (i == check)
4909 {
4910 mi_check->fType |= MFT_RADIOCHECK;
4911 mi_check->fState |= MFS_CHECKED;
4912 done = TRUE;
4913 }
4914 else
4915 {
4916 /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
4917 mi_check->fState &= ~MFS_CHECKED;
4918 }
4919 }
4920
4921 return done;
4922 }
4923
4924
4925 /**********************************************************************
4926 * GetMenuItemRect (USER32.@)
4927 *
4928 * ATTENTION: Here, the returned values in rect are the screen
4929 * coordinates of the item just like if the menu was
4930 * always on the upper left side of the application.
4931 *
4932 */
4933 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4934 LPRECT rect)
4935 {
4936 POPUPMENU *itemMenu;
4937 MENUITEM *item;
4938 HWND referenceHwnd;
4939
4940 TRACE("(%p,%p,%d,%p)\n", hwnd, hMenu, uItem, rect);
4941
4942 item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4943 referenceHwnd = hwnd;
4944
4945 if(!hwnd)
4946 {
4947 itemMenu = MENU_GetMenu(hMenu);
4948 if (itemMenu == NULL)
4949 return FALSE;
4950
4951 if(itemMenu->hWnd == 0)
4952 return FALSE;
4953 referenceHwnd = itemMenu->hWnd;
4954 }
4955
4956 if ((rect == NULL) || (item == NULL))
4957 return FALSE;
4958
4959 *rect = item->rect;
4960
4961 MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4962
4963 return TRUE;
4964 }
4965
4966
4967 /**********************************************************************
4968 * SetMenuInfo (USER32.@)
4969 *
4970 * FIXME
4971 * MIM_APPLYTOSUBMENUS
4972 * actually use the items to draw the menu
4973 */
4974 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4975 {
4976 POPUPMENU *menu;
4977
4978 TRACE("(%p %p)\n", hMenu, lpmi);
4979
4980 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4981 {
4982
4983 if (lpmi->fMask & MIM_BACKGROUND)
4984 menu->hbrBack = lpmi->hbrBack;
4985
4986 if (lpmi->fMask & MIM_HELPID)
4987 menu->dwContextHelpID = lpmi->dwContextHelpID;
4988
4989 if (lpmi->fMask & MIM_MAXHEIGHT)
4990 menu->cyMax = lpmi->cyMax;
4991
4992 if (lpmi->fMask & MIM_MENUDATA)
4993 menu->dwMenuData = lpmi->dwMenuData;
4994
4995 if (lpmi->fMask & MIM_STYLE)
4996 {
4997 menu->dwStyle = lpmi->dwStyle;
4998 if (menu->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented\n");
4999 if (menu->dwStyle & MNS_DRAGDROP) FIXME("MNS_DRAGDROP unimplemented\n");
5000 if (menu->dwStyle & MNS_MODELESS) FIXME("MNS_MODELESS unimplemented\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 }
Maarten's multimedia branch