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