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