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