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