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