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