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