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