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