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