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