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