?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: ToUnicodeEx should return 0 for an unknown key.
[wine/dibdrv.git] / dlls / user / menu.c
blob59c8386cb6f0e29f64707532ab4ce93956ed0eaa
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=%dx%d\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 INT width, height;
1775 POINT pt;
1776 HMONITOR monitor;
1777 MONITORINFO info;
1778
1779 TRACE("owner=%p hmenu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1780 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1781
1782 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1783 if (menu->FocusedItem != NO_SELECTED_ITEM)
1784 {
1785 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1786 menu->FocusedItem = NO_SELECTED_ITEM;
1787 }
1788
1789 /* store the owner for DrawItem */
1790 menu->hwndOwner = hwndOwner;
1791
1792 menu->nScrollPos = 0;
1793 MENU_PopupMenuCalcSize( menu, hwndOwner );
1794
1795 /* adjust popup menu pos so that it fits within the desktop */
1796
1797 width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1798 height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1799
1800 /* FIXME: should use item rect */
1801 pt.x = x;
1802 pt.y = y;
1803 monitor = MonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
1804 info.cbSize = sizeof(info);
1805 GetMonitorInfoW( monitor, &info );
1806 if( x + width > info.rcWork.right)
1807 {
1808 if( xanchor && x >= width - xanchor )
1809 x -= width - xanchor;
1810
1811 if( x + width > info.rcWork.right)
1812 x = info.rcWork.right - width;
1813 }
1814 if( x < info.rcWork.left ) x = info.rcWork.left;
1815
1816 if( y + height > info.rcWork.bottom)
1817 {
1818 if( yanchor && y >= height + yanchor )
1819 y -= height + yanchor;
1820
1821 if( y + height > info.rcWork.bottom)
1822 y = info.rcWork.bottom - height;
1823 }
1824 if( y < info.rcWork.top ) y = info.rcWork.top;
1825
1826 /* NOTE: In Windows, top menu popup is not owned. */
1827 menu->hWnd = CreateWindowExW( 0, POPUPMENU_CLASS_ATOMW, NULL,
1828 WS_POPUP, x, y, width, height,
1829 hwndOwner, 0, (HINSTANCE)GetWindowLongPtrW(hwndOwner, GWLP_HINSTANCE),
1830 (LPVOID)hmenu );
1831 if( !menu->hWnd ) return FALSE;
1832 if (!top_popup) top_popup = menu->hWnd;
1833
1834 /* Display the window */
1835
1836 SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1837 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1838 UpdateWindow( menu->hWnd );
1839 return TRUE;
1840 }
1841
1842
1843 /***********************************************************************
1844 * MENU_EnsureMenuItemVisible
1845 */
1846 static void
1847 MENU_EnsureMenuItemVisible(LPPOPUPMENU lppop, UINT wIndex, HDC hdc)
1848 {
1849 if (lppop->bScrolling)
1850 {
1851 MENUITEM *item = &lppop->items[wIndex];
1852 UINT nMaxHeight = MENU_GetMaxPopupHeight(lppop);
1853 UINT nOldPos = lppop->nScrollPos;
1854 RECT rc;
1855 UINT arrow_bitmap_height;
1856 BITMAP bmp;
1857
1858 GetClientRect(lppop->hWnd, &rc);
1859
1860 GetObjectW(get_down_arrow_bitmap(), sizeof(bmp), &bmp);
1861 arrow_bitmap_height = bmp.bmHeight;
1862
1863 rc.top += arrow_bitmap_height;
1864 rc.bottom -= arrow_bitmap_height + MENU_BOTTOM_MARGIN;
1865
1866 nMaxHeight -= GetSystemMetrics(SM_CYBORDER) + 2 * arrow_bitmap_height;
1867 if (item->rect.bottom > lppop->nScrollPos + nMaxHeight)
1868 {
1869
1870 lppop->nScrollPos = item->rect.bottom - nMaxHeight;
1871 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, &rc, &rc);
1872 MENU_DrawScrollArrows(lppop, hdc);
1873 }
1874 else if (item->rect.top - MENU_TOP_MARGIN < lppop->nScrollPos)
1875 {
1876 lppop->nScrollPos = item->rect.top - MENU_TOP_MARGIN;
1877 ScrollWindow(lppop->hWnd, 0, nOldPos - lppop->nScrollPos, &rc, &rc);
1878 MENU_DrawScrollArrows(lppop, hdc);
1879 }
1880 }
1881 }
1882
1883
1884 /***********************************************************************
1885 * MENU_SelectItem
1886 */
1887 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1888 BOOL sendMenuSelect, HMENU topmenu )
1889 {
1890 LPPOPUPMENU lppop;
1891 HDC hdc;
1892
1893 TRACE("owner=%p menu=%p index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1894
1895 lppop = MENU_GetMenu( hmenu );
1896 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1897
1898 if (lppop->FocusedItem == wIndex) return;
1899 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1900 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1901 if (!top_popup) top_popup = lppop->hWnd;
1902
1903 SelectObject( hdc, get_menu_font(FALSE));
1904
1905 /* Clear previous highlighted item */
1906 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1907 {
1908 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1909 MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1910 lppop->Height, !(lppop->wFlags & MF_POPUP),
1911 ODA_SELECT );
1912 }
1913
1914 /* Highlight new item (if any) */
1915 lppop->FocusedItem = wIndex;
1916 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1917 {
1918 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1919 lppop->items[wIndex].fState |= MF_HILITE;
1920 MENU_EnsureMenuItemVisible(lppop, wIndex, hdc);
1921 MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1922 &lppop->items[wIndex], lppop->Height,
1923 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1924 }
1925 if (sendMenuSelect)
1926 {
1927 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1928 SendMessageW( hwndOwner, WM_MENUSELECT,
1929 MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1930 ip->fType | ip->fState |
1931 (lppop->wFlags & MF_SYSMENU)), (LPARAM)hmenu);
1932 }
1933 }
1934 else if (sendMenuSelect) {
1935 if(topmenu){
1936 int pos;
1937 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1938 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1939 MENUITEM *ip = &ptm->items[pos];
1940 SendMessageW( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1941 ip->fType | ip->fState |
1942 (ptm->wFlags & MF_SYSMENU)), (LPARAM)topmenu);
1943 }
1944 }
1945 }
1946 ReleaseDC( lppop->hWnd, hdc );
1947 }
1948
1949
1950 /***********************************************************************
1951 * MENU_MoveSelection
1952 *
1953 * Moves currently selected item according to the offset parameter.
1954 * If there is no selection then it should select the last item if
1955 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1956 */
1957 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1958 {
1959 INT i;
1960 POPUPMENU *menu;
1961
1962 TRACE("hwnd=%p hmenu=%p off=0x%04x\n", hwndOwner, hmenu, offset);
1963
1964 menu = MENU_GetMenu( hmenu );
1965 if ((!menu) || (!menu->items)) return;
1966
1967 if ( menu->FocusedItem != NO_SELECTED_ITEM )
1968 {
1969 if( menu->nItems == 1 ) return; else
1970 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1971 ; 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 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1980 i >= 0 && i < menu->nItems ; i += offset)
1981 if (!(menu->items[i].fType & MF_SEPARATOR))
1982 {
1983 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1984 return;
1985 }
1986 }
1987
1988
1989 /**********************************************************************
1990 * MENU_SetItemData
1991 *
1992 * Set an item's flags, id and text ptr. Called by InsertMenu() and
1993 * ModifyMenu().
1994 */
1995 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT_PTR id,
1996 LPCWSTR str )
1997 {
1998 debug_print_menuitem("MENU_SetItemData from: ", item, "");
1999 TRACE("flags=%x str=%p\n", flags, str);
2000
2001 if (IS_STRING_ITEM(flags))
2002 {
2003 LPWSTR prevText = item->text;
2004 if (!str)
2005 {
2006 flags |= MF_SEPARATOR;
2007 item->text = NULL;
2008 }
2009 else
2010 {
2011 LPWSTR text;
2012 /* Item beginning with a backspace is a help item */
2013 if (*str == '\b')
2014 {
2015 flags |= MF_HELP;
2016 str++;
2017 }
2018 if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
2019 return FALSE;
2020 strcpyW( text, str );
2021 item->text = text;
2022 }
2023 item->hbmpItem = NULL;
2024 HeapFree( GetProcessHeap(), 0, prevText );
2025 }
2026 else if(( flags & MFT_BITMAP)) {
2027 item->hbmpItem = HBITMAP_32(LOWORD(str));
2028 /* setting bitmap clears text */
2029 HeapFree( GetProcessHeap(), 0, item->text );
2030 item->text = NULL;
2031 }
2032
2033 if (flags & MF_OWNERDRAW)
2034 item->dwItemData = (DWORD_PTR)str;
2035 else
2036 item->dwItemData = 0;
2037
2038 if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != (HMENU)id) )
2039 DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
2040
2041 if (flags & MF_POPUP)
2042 {
2043 POPUPMENU *menu = MENU_GetMenu((HMENU)id);
2044 if (menu) menu->wFlags |= MF_POPUP;
2045 else
2046 {
2047 item->wID = 0;
2048 item->hSubMenu = 0;
2049 item->fType = 0;
2050 item->fState = 0;
2051 return FALSE;
2052 }
2053 }
2054
2055 item->wID = id;
2056 if (flags & MF_POPUP) item->hSubMenu = (HMENU)id;
2057
2058 if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
2059 flags |= MF_POPUP; /* keep popup */
2060
2061 item->fType = flags & TYPE_MASK;
2062 /* MFS_DEFAULT is not accepted. MF_HILITE is not listed as a valid flag
2063 for ModifyMenu, but Windows accepts it */
2064 item->fState = flags & MENUITEMINFO_STATE_MASK & ~MFS_DEFAULT;
2065
2066 /* Don't call SetRectEmpty here! */
2067
2068 debug_print_menuitem("MENU_SetItemData to : ", item, "");
2069 return TRUE;
2070 }
2071
2072
2073 /**********************************************************************
2074 * MENU_InsertItem
2075 *
2076 * Insert (allocate) a new item into a menu.
2077 */
2078 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
2079 {
2080 MENUITEM *newItems;
2081 POPUPMENU *menu;
2082
2083 if (!(menu = MENU_GetMenu(hMenu)))
2084 return NULL;
2085
2086 /* Find where to insert new item */
2087
2088 if (flags & MF_BYPOSITION) {
2089 if (pos > menu->nItems)
2090 pos = menu->nItems;
2091 } else {
2092 if (!MENU_FindItem( &hMenu, &pos, flags ))
2093 pos = menu->nItems;
2094 else {
2095 if (!(menu = MENU_GetMenu( hMenu )))
2096 return NULL;
2097 }
2098 }
2099
2100 /* Create new items array */
2101
2102 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
2103 if (!newItems)
2104 {
2105 WARN("allocation failed\n" );
2106 return NULL;
2107 }
2108 if (menu->nItems > 0)
2109 {
2110 /* Copy the old array into the new one */
2111 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
2112 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
2113 (menu->nItems-pos)*sizeof(MENUITEM) );
2114 HeapFree( GetProcessHeap(), 0, menu->items );
2115 }
2116 menu->items = newItems;
2117 menu->nItems++;
2118 memset( &newItems[pos], 0, sizeof(*newItems) );
2119 menu->Height = 0; /* force size recalculate */
2120 return &newItems[pos];
2121 }
2122
2123
2124 /**********************************************************************
2125 * MENU_ParseResource
2126 *
2127 * Parse a standard menu resource and add items to the menu.
2128 * Return a pointer to the end of the resource.
2129 *
2130 * NOTE: flags is equivalent to the mtOption field
2131 */
2132 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
2133 {
2134 WORD flags, id = 0;
2135 LPCSTR str;
2136 BOOL end_flag;
2137
2138 do
2139 {
2140 flags = GET_WORD(res);
2141 end_flag = flags & MF_END;
2142 /* Remove MF_END because it has the same value as MF_HILITE */
2143 flags &= ~MF_END;
2144 res += sizeof(WORD);
2145 if (!(flags & MF_POPUP))
2146 {
2147 id = GET_WORD(res);
2148 res += sizeof(WORD);
2149 }
2150 str = res;
2151 if (!unicode) res += strlen(str) + 1;
2152 else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
2153 if (flags & MF_POPUP)
2154 {
2155 HMENU hSubMenu = CreatePopupMenu();
2156 if (!hSubMenu) return NULL;
2157 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
2158 return NULL;
2159 if (!unicode) AppendMenuA( hMenu, flags, (UINT_PTR)hSubMenu, str );
2160 else AppendMenuW( hMenu, flags, (UINT_PTR)hSubMenu, (LPCWSTR)str );
2161 }
2162 else /* Not a popup */
2163 {
2164 if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
2165 else AppendMenuW( hMenu, flags, id,
2166 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
2167 }
2168 } while (!end_flag);
2169 return res;
2170 }
2171
2172
2173 /**********************************************************************
2174 * MENUEX_ParseResource
2175 *
2176 * Parse an extended menu resource and add items to the menu.
2177 * Return a pointer to the end of the resource.
2178 */
2179 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
2180 {
2181 WORD resinfo;
2182 do {
2183 MENUITEMINFOW mii;
2184
2185 mii.cbSize = sizeof(mii);
2186 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
2187 mii.fType = GET_DWORD(res);
2188 res += sizeof(DWORD);
2189 mii.fState = GET_DWORD(res);
2190 res += sizeof(DWORD);
2191 mii.wID = GET_DWORD(res);
2192 res += sizeof(DWORD);
2193 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
2194 res += sizeof(WORD);
2195 /* Align the text on a word boundary. */
2196 res += (~((UINT_PTR)res - 1)) & 1;
2197 mii.dwTypeData = (LPWSTR) res;
2198 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
2199 /* Align the following fields on a dword boundary. */
2200 res += (~((UINT_PTR)res - 1)) & 3;
2201
2202 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
2203 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
2204
2205 if (resinfo & 1) { /* Pop-up? */
2206 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
2207 res += sizeof(DWORD);
2208 mii.hSubMenu = CreatePopupMenu();
2209 if (!mii.hSubMenu)
2210 return NULL;
2211 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
2212 DestroyMenu(mii.hSubMenu);
2213 return NULL;
2214 }
2215 mii.fMask |= MIIM_SUBMENU;
2216 mii.fType |= MF_POPUP;
2217 }
2218 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
2219 {
2220 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
2221 mii.wID, mii.fType);
2222 mii.fType |= MF_SEPARATOR;
2223 }
2224 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
2225 } while (!(resinfo & MF_END));
2226 return res;
2227 }
2228
2229
2230 /***********************************************************************
2231 * MENU_GetSubPopup
2232 *
2233 * Return the handle of the selected sub-popup menu (if any).
2234 */
2235 static HMENU MENU_GetSubPopup( HMENU hmenu )
2236 {
2237 POPUPMENU *menu;
2238 MENUITEM *item;
2239
2240 menu = MENU_GetMenu( hmenu );
2241
2242 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2243
2244 item = &menu->items[menu->FocusedItem];
2245 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2246 return item->hSubMenu;
2247 return 0;
2248 }
2249
2250
2251 /***********************************************************************
2252 * MENU_HideSubPopups
2253 *
2254 * Hide the sub-popup menus of this menu.
2255 */
2256 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2257 BOOL sendMenuSelect )
2258 {
2259 POPUPMENU *menu = MENU_GetMenu( hmenu );
2260
2261 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2262
2263 if (menu && top_popup)
2264 {
2265 HMENU hsubmenu;
2266 POPUPMENU *submenu;
2267 MENUITEM *item;
2268
2269 if (menu->FocusedItem != NO_SELECTED_ITEM)
2270 {
2271 item = &menu->items[menu->FocusedItem];
2272 if (!(item->fType & MF_POPUP) ||
2273 !(item->fState & MF_MOUSESELECT)) return;
2274 item->fState &= ~MF_MOUSESELECT;
2275 hsubmenu = item->hSubMenu;
2276 } else return;
2277
2278 submenu = MENU_GetMenu( hsubmenu );
2279 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
2280 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2281 DestroyWindow( submenu->hWnd );
2282 submenu->hWnd = 0;
2283 }
2284 }
2285
2286
2287 /***********************************************************************
2288 * MENU_ShowSubPopup
2289 *
2290 * Display the sub-menu of the selected item of this menu.
2291 * Return the handle of the submenu, or hmenu if no submenu to display.
2292 */
2293 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2294 BOOL selectFirst, UINT wFlags )
2295 {
2296 RECT rect;
2297 POPUPMENU *menu;
2298 MENUITEM *item;
2299 HDC hdc;
2300
2301 TRACE("owner=%p hmenu=%p 0x%04x\n", hwndOwner, hmenu, selectFirst);
2302
2303 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2304
2305 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2306
2307 item = &menu->items[menu->FocusedItem];
2308 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2309 return hmenu;
2310
2311 /* message must be sent before using item,
2312 because nearly everything may be changed by the application ! */
2313
2314 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2315 if (!(wFlags & TPM_NONOTIFY))
2316 SendMessageW( hwndOwner, WM_INITMENUPOPUP, (WPARAM)item->hSubMenu,
2317 MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2318
2319 item = &menu->items[menu->FocusedItem];
2320 rect = item->rect;
2321
2322 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2323 if (!(item->fState & MF_HILITE))
2324 {
2325 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2326 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2327
2328 SelectObject( hdc, get_menu_font(FALSE));
2329
2330 item->fState |= MF_HILITE;
2331 MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2332 ReleaseDC( menu->hWnd, hdc );
2333 }
2334 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2335 item->rect = rect;
2336
2337 item->fState |= MF_MOUSESELECT;
2338
2339 if (IS_SYSTEM_MENU(menu))
2340 {
2341 MENU_InitSysMenuPopup(item->hSubMenu,
2342 GetWindowLongW( menu->hWnd, GWL_STYLE ),
2343 GetClassLongW( menu->hWnd, GCL_STYLE));
2344
2345 NC_GetSysPopupPos( menu->hWnd, &rect );
2346 rect.top = rect.bottom;
2347 rect.right = GetSystemMetrics(SM_CXSIZE);
2348 rect.bottom = GetSystemMetrics(SM_CYSIZE);
2349 }
2350 else
2351 {
2352 GetWindowRect( menu->hWnd, &rect );
2353 if (menu->wFlags & MF_POPUP)
2354 {
2355 RECT rc = item->rect;
2356
2357 MENU_AdjustMenuItemRect(menu, &rc);
2358
2359 /* The first item in the popup menu has to be at the
2360 same y position as the focused menu item */
2361 rect.left += rc.right - GetSystemMetrics(SM_CXBORDER);
2362 rect.top += rc.top - MENU_TOP_MARGIN;
2363 rect.right = rc.left - rc.right + GetSystemMetrics(SM_CXBORDER);
2364 rect.bottom = rc.top - rc.bottom - MENU_TOP_MARGIN
2365 - MENU_BOTTOM_MARGIN - GetSystemMetrics(SM_CYBORDER);
2366 }
2367 else
2368 {
2369 rect.left += item->rect.left;
2370 rect.top += item->rect.bottom;
2371 rect.right = item->rect.right - item->rect.left;
2372 rect.bottom = item->rect.bottom - item->rect.top;
2373 }
2374 }
2375
2376 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2377 rect.left, rect.top, rect.right, rect.bottom );
2378 if (selectFirst)
2379 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2380 return item->hSubMenu;
2381 }
2382
2383
2384
2385 /**********************************************************************
2386 * MENU_IsMenuActive
2387 */
2388 HWND MENU_IsMenuActive(void)
2389 {
2390 return top_popup;
2391 }
2392
2393 /***********************************************************************
2394 * MENU_PtMenu
2395 *
2396 * Walks menu chain trying to find a menu pt maps to.
2397 */
2398 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2399 {
2400 POPUPMENU *menu = MENU_GetMenu( hMenu );
2401 UINT item = menu->FocusedItem;
2402 HMENU ret;
2403
2404 /* try subpopup first (if any) */
2405 ret = (item != NO_SELECTED_ITEM &&
2406 (menu->items[item].fType & MF_POPUP) &&
2407 (menu->items[item].fState & MF_MOUSESELECT))
2408 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2409
2410 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2411 {
2412 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2413 if( menu->wFlags & MF_POPUP )
2414 {
2415 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2416 }
2417 else if (ht == HTSYSMENU)
2418 ret = get_win_sys_menu( menu->hWnd );
2419 else if (ht == HTMENU)
2420 ret = GetMenu( menu->hWnd );
2421 }
2422 return ret;
2423 }
2424
2425 /***********************************************************************
2426 * MENU_ExecFocusedItem
2427 *
2428 * Execute a menu item (for instance when user pressed Enter).
2429 * Return the wID of the executed item. Otherwise, -1 indicating
2430 * that no menu item was executed, -2 if a popup is shown;
2431 * Have to receive the flags for the TrackPopupMenu options to avoid
2432 * sending unwanted message.
2433 *
2434 */
2435 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2436 {
2437 MENUITEM *item;
2438 POPUPMENU *menu = MENU_GetMenu( hMenu );
2439
2440 TRACE("%p hmenu=%p\n", pmt, hMenu);
2441
2442 if (!menu || !menu->nItems ||
2443 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2444
2445 item = &menu->items[menu->FocusedItem];
2446
2447 TRACE("hMenu %p wID %08x hSubMenu %p fType %04x\n", hMenu, item->wID, item->hSubMenu, item->fType);
2448
2449 if (!(item->fType & MF_POPUP))
2450 {
2451 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2452 {
2453 /* If TPM_RETURNCMD is set you return the id, but
2454 do not send a message to the owner */
2455 if(!(wFlags & TPM_RETURNCMD))
2456 {
2457 if( menu->wFlags & MF_SYSMENU )
2458 PostMessageW( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2459 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2460 else
2461 {
2462 if (menu->dwStyle & MNS_NOTIFYBYPOS)
2463 PostMessageW( pmt->hOwnerWnd, WM_MENUCOMMAND, menu->FocusedItem,
2464 (LPARAM)hMenu);
2465 else
2466 PostMessageW( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2467 }
2468 }
2469 return item->wID;
2470 }
2471 }
2472 else
2473 {
2474 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2475 return -2;
2476 }
2477
2478 return -1;
2479 }
2480
2481 /***********************************************************************
2482 * MENU_SwitchTracking
2483 *
2484 * Helper function for menu navigation routines.
2485 */
2486 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2487 {
2488 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2489 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2490
2491 TRACE("%p hmenu=%p 0x%04x\n", pmt, hPtMenu, id);
2492
2493 if( pmt->hTopMenu != hPtMenu &&
2494 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2495 {
2496 /* both are top level menus (system and menu-bar) */
2497 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2498 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2499 pmt->hTopMenu = hPtMenu;
2500 }
2501 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2502 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2503 }
2504
2505
2506 /***********************************************************************
2507 * MENU_ButtonDown
2508 *
2509 * Return TRUE if we can go on with menu tracking.
2510 */
2511 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2512 {
2513 TRACE("%p hPtMenu=%p\n", pmt, hPtMenu);
2514
2515 if (hPtMenu)
2516 {
2517 UINT id = 0;
2518 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2519 MENUITEM *item;
2520
2521 if( IS_SYSTEM_MENU(ptmenu) )
2522 item = ptmenu->items;
2523 else
2524 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2525
2526 if( item )
2527 {
2528 if( ptmenu->FocusedItem != id )
2529 MENU_SwitchTracking( pmt, hPtMenu, id );
2530
2531 /* If the popup menu is not already "popped" */
2532 if(!(item->fState & MF_MOUSESELECT ))
2533 {
2534 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2535 }
2536
2537 return TRUE;
2538 }
2539 /* Else the click was on the menu bar, finish the tracking */
2540 }
2541 return FALSE;
2542 }
2543
2544 /***********************************************************************
2545 * MENU_ButtonUp
2546 *
2547 * Return the value of MENU_ExecFocusedItem if
2548 * the selected item was not a popup. Else open the popup.
2549 * A -1 return value indicates that we go on with menu tracking.
2550 *
2551 */
2552 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2553 {
2554 TRACE("%p hmenu=%p\n", pmt, hPtMenu);
2555
2556 if (hPtMenu)
2557 {
2558 UINT id = 0;
2559 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2560 MENUITEM *item;
2561
2562 if( IS_SYSTEM_MENU(ptmenu) )
2563 item = ptmenu->items;
2564 else
2565 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2566
2567 if( item && (ptmenu->FocusedItem == id ))
2568 {
2569 debug_print_menuitem ("FocusedItem: ", item, "");
2570
2571 if( !(item->fType & MF_POPUP) )
2572 {
2573 INT executedMenuId = MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2574 if (executedMenuId == -1 || executedMenuId == -2) return -1;
2575 return executedMenuId;
2576 }
2577
2578 /* If we are dealing with the top-level menu */
2579 /* and this is a click on an already "popped" item: */
2580 /* Stop the menu tracking and close the opened submenus */
2581 if((pmt->hTopMenu == hPtMenu) && ptmenu->bTimeToHide)
2582 return 0;
2583 }
2584 ptmenu->bTimeToHide = TRUE;
2585 }
2586 return -1;
2587 }
2588
2589
2590 /***********************************************************************
2591 * MENU_MouseMove
2592 *
2593 * Return TRUE if we can go on with menu tracking.
2594 */
2595 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2596 {
2597 UINT id = NO_SELECTED_ITEM;
2598 POPUPMENU *ptmenu = NULL;
2599
2600 if( hPtMenu )
2601 {
2602 ptmenu = MENU_GetMenu( hPtMenu );
2603 if( IS_SYSTEM_MENU(ptmenu) )
2604 id = 0;
2605 else
2606 MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2607 }
2608
2609 if( id == NO_SELECTED_ITEM )
2610 {
2611 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2612 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2613
2614 }
2615 else if( ptmenu->FocusedItem != id )
2616 {
2617 MENU_SwitchTracking( pmt, hPtMenu, id );
2618 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2619 }
2620 return TRUE;
2621 }
2622
2623
2624 /***********************************************************************
2625 * MENU_SetCapture
2626 */
2627 static void MENU_SetCapture( HWND hwnd )
2628 {
2629 HWND previous = 0;
2630
2631 SERVER_START_REQ( set_capture_window )
2632 {
2633 req->handle = hwnd;
2634 req->flags = CAPTURE_MENU;
2635 if (!wine_server_call_err( req ))
2636 {
2637 previous = reply->previous;
2638 hwnd = reply->full_handle;
2639 }
2640 }
2641 SERVER_END_REQ;
2642
2643 if (previous && previous != hwnd)
2644 SendMessageW( previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd );
2645 }
2646
2647
2648 /***********************************************************************
2649 * MENU_DoNextMenu
2650 *
2651 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2652 */
2653 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2654 {
2655 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2656
2657 if( (vk == VK_LEFT && menu->FocusedItem == 0 ) ||
2658 (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2659 {
2660 MDINEXTMENU next_menu;
2661 HMENU hNewMenu;
2662 HWND hNewWnd;
2663 UINT id = 0;
2664
2665 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2666 next_menu.hmenuNext = 0;
2667 next_menu.hwndNext = 0;
2668 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2669
2670 TRACE("%p [%p] -> %p [%p]\n",
2671 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2672
2673 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2674 {
2675 DWORD style = GetWindowLongW( pmt->hOwnerWnd, GWL_STYLE );
2676 hNewWnd = pmt->hOwnerWnd;
2677 if( IS_SYSTEM_MENU(menu) )
2678 {
2679 /* switch to the menu bar */
2680
2681 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2682
2683 if( vk == VK_LEFT )
2684 {
2685 menu = MENU_GetMenu( hNewMenu );
2686 id = menu->nItems - 1;
2687 }
2688 }
2689 else if (style & WS_SYSMENU )
2690 {
2691 /* switch to the system menu */
2692 hNewMenu = get_win_sys_menu( hNewWnd );
2693 }
2694 else return FALSE;
2695 }
2696 else /* application returned a new menu to switch to */
2697 {
2698 hNewMenu = next_menu.hmenuNext;
2699 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2700
2701 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2702 {
2703 DWORD style = GetWindowLongW( hNewWnd, GWL_STYLE );
2704
2705 if (style & WS_SYSMENU &&
2706 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2707 {
2708 /* get the real system menu */
2709 hNewMenu = get_win_sys_menu(hNewWnd);
2710 }
2711 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2712 {
2713 /* FIXME: Not sure what to do here;
2714 * perhaps try to track hNewMenu as a popup? */
2715
2716 TRACE(" -- got confused.\n");
2717 return FALSE;
2718 }
2719 }
2720 else return FALSE;
2721 }
2722
2723 if( hNewMenu != pmt->hTopMenu )
2724 {
2725 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2726 FALSE, 0 );
2727 if( pmt->hCurrentMenu != pmt->hTopMenu )
2728 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2729 }
2730
2731 if( hNewWnd != pmt->hOwnerWnd )
2732 {
2733 pmt->hOwnerWnd = hNewWnd;
2734 MENU_SetCapture( pmt->hOwnerWnd );
2735 }
2736
2737 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2738 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2739
2740 return TRUE;
2741 }
2742 return FALSE;
2743 }
2744
2745 /***********************************************************************
2746 * MENU_SuspendPopup
2747 *
2748 * The idea is not to show the popup if the next input message is
2749 * going to hide it anyway.
2750 */
2751 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2752 {
2753 MSG msg;
2754
2755 msg.hwnd = pmt->hOwnerWnd;
2756
2757 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2758 pmt->trackFlags |= TF_SKIPREMOVE;
2759
2760 switch( uMsg )
2761 {
2762 case WM_KEYDOWN:
2763 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2764 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2765 {
2766 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2767 PeekMessageW( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2768 if( msg.message == WM_KEYDOWN &&
2769 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2770 {
2771 pmt->trackFlags |= TF_SUSPENDPOPUP;
2772 return TRUE;
2773 }
2774 }
2775 break;
2776 }
2777
2778 /* failures go through this */
2779 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2780 return FALSE;
2781 }
2782
2783 /***********************************************************************
2784 * MENU_KeyEscape
2785 *
2786 * Handle a VK_ESCAPE key event in a menu.
2787 */
2788 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2789 {
2790 BOOL bEndMenu = TRUE;
2791
2792 if (pmt->hCurrentMenu != pmt->hTopMenu)
2793 {
2794 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2795
2796 if (menu->wFlags & MF_POPUP)
2797 {
2798 HMENU hmenutmp, hmenuprev;
2799
2800 hmenuprev = hmenutmp = pmt->hTopMenu;
2801
2802 /* close topmost popup */
2803 while (hmenutmp != pmt->hCurrentMenu)
2804 {
2805 hmenuprev = hmenutmp;
2806 hmenutmp = MENU_GetSubPopup( hmenuprev );
2807 }
2808
2809 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2810 pmt->hCurrentMenu = hmenuprev;
2811 bEndMenu = FALSE;
2812 }
2813 }
2814
2815 return bEndMenu;
2816 }
2817
2818 /***********************************************************************
2819 * MENU_KeyLeft
2820 *
2821 * Handle a VK_LEFT key event in a menu.
2822 */
2823 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2824 {
2825 POPUPMENU *menu;
2826 HMENU hmenutmp, hmenuprev;
2827 UINT prevcol;
2828
2829 hmenuprev = hmenutmp = pmt->hTopMenu;
2830 menu = MENU_GetMenu( hmenutmp );
2831
2832 /* Try to move 1 column left (if possible) */
2833 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2834 NO_SELECTED_ITEM ) {
2835
2836 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2837 prevcol, TRUE, 0 );
2838 return;
2839 }
2840
2841 /* close topmost popup */
2842 while (hmenutmp != pmt->hCurrentMenu)
2843 {
2844 hmenuprev = hmenutmp;
2845 hmenutmp = MENU_GetSubPopup( hmenuprev );
2846 }
2847
2848 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2849 pmt->hCurrentMenu = hmenuprev;
2850
2851 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2852 {
2853 /* move menu bar selection if no more popups are left */
2854
2855 if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2856 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2857
2858 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2859 {
2860 /* A sublevel menu was displayed - display the next one
2861 * unless there is another displacement coming up */
2862
2863 if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2864 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2865 pmt->hTopMenu, TRUE, wFlags);
2866 }
2867 }
2868 }
2869
2870
2871 /***********************************************************************
2872 * MENU_KeyRight
2873 *
2874 * Handle a VK_RIGHT key event in a menu.
2875 */
2876 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2877 {
2878 HMENU hmenutmp;
2879 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2880 UINT nextcol;
2881
2882 TRACE("MENU_KeyRight called, cur %p (%s), top %p (%s).\n",
2883 pmt->hCurrentMenu,
2884 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->items[0].text),
2885 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2886
2887 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2888 {
2889 /* If already displaying a popup, try to display sub-popup */
2890
2891 hmenutmp = pmt->hCurrentMenu;
2892 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2893
2894 /* if subpopup was displayed then we are done */
2895 if (hmenutmp != pmt->hCurrentMenu) return;
2896 }
2897
2898 /* Check to see if there's another column */
2899 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2900 NO_SELECTED_ITEM ) {
2901 TRACE("Going to %d.\n", nextcol );
2902 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2903 nextcol, TRUE, 0 );
2904 return;
2905 }
2906
2907 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2908 {
2909 if( pmt->hCurrentMenu != pmt->hTopMenu )
2910 {
2911 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2912 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2913 } else hmenutmp = 0;
2914
2915 /* try to move to the next item */
2916 if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2917 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2918
2919 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2920 if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2921 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2922 pmt->hTopMenu, TRUE, wFlags);
2923 }
2924 }
2925
2926 /***********************************************************************
2927 * MENU_TrackMenu
2928 *
2929 * Menu tracking code.
2930 */
2931 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2932 HWND hwnd, const RECT *lprect )
2933 {
2934 MSG msg;
2935 POPUPMENU *menu;
2936 BOOL fRemove;
2937 INT executedMenuId = -1;
2938 MTRACKER mt;
2939 BOOL enterIdleSent = FALSE;
2940
2941 mt.trackFlags = 0;
2942 mt.hCurrentMenu = hmenu;
2943 mt.hTopMenu = hmenu;
2944 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2945 mt.pt.x = x;
2946 mt.pt.y = y;
2947
2948 TRACE("hmenu=%p flags=0x%08x (%d,%d) hwnd=%p %s\n",
2949 hmenu, wFlags, x, y, hwnd, wine_dbgstr_rect( lprect));
2950
2951 fEndMenu = FALSE;
2952 if (!(menu = MENU_GetMenu( hmenu )))
2953 {
2954 WARN("Invalid menu handle %p\n", hmenu);
2955 SetLastError(ERROR_INVALID_MENU_HANDLE);
2956 return FALSE;
2957 }
2958
2959 if (wFlags & TPM_BUTTONDOWN)
2960 {
2961 /* Get the result in order to start the tracking or not */
2962 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2963 fEndMenu = !fRemove;
2964 }
2965
2966 if (wFlags & TF_ENDMENU) fEndMenu = TRUE;
2967
2968 MENU_SetCapture( mt.hOwnerWnd );
2969
2970 while (!fEndMenu)
2971 {
2972 menu = MENU_GetMenu( mt.hCurrentMenu );
2973 if (!menu) /* sometimes happens if I do a window manager close */
2974 break;
2975
2976 /* we have to keep the message in the queue until it's
2977 * clear that menu loop is not over yet. */
2978
2979 for (;;)
2980 {
2981 if (PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ))
2982 {
2983 if (!CallMsgFilterW( &msg, MSGF_MENU )) break;
2984 /* remove the message from the queue */
2985 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
2986 }
2987 else
2988 {
2989 if (!enterIdleSent)
2990 {
2991 HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2992 enterIdleSent = TRUE;
2993 SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2994 }
2995 WaitMessage();
2996 }
2997 }
2998
2999 /* check if EndMenu() tried to cancel us, by posting this message */
3000 if(msg.message == WM_CANCELMODE)
3001 {
3002 /* we are now out of the loop */
3003 fEndMenu = TRUE;
3004
3005 /* remove the message from the queue */
3006 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3007
3008 /* break out of internal loop, ala ESCAPE */
3009 break;
3010 }
3011
3012 TranslateMessage( &msg );
3013 mt.pt = msg.pt;
3014
3015 if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
3016 enterIdleSent=FALSE;
3017
3018 fRemove = FALSE;
3019 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
3020 {
3021 /*
3022 * Use the mouse coordinates in lParam instead of those in the MSG
3023 * struct to properly handle synthetic messages. They are already
3024 * in screen coordinates.
3025 */
3026 mt.pt.x = (short)LOWORD(msg.lParam);
3027 mt.pt.y = (short)HIWORD(msg.lParam);
3028
3029 /* Find a menu for this mouse event */
3030 hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
3031
3032 switch(msg.message)
3033 {
3034 /* no WM_NC... messages in captured state */
3035
3036 case WM_RBUTTONDBLCLK:
3037 case WM_RBUTTONDOWN:
3038 if (!(wFlags & TPM_RIGHTBUTTON)) break;
3039 /* fall through */
3040 case WM_LBUTTONDBLCLK:
3041 case WM_LBUTTONDOWN:
3042 /* If the message belongs to the menu, removes it from the queue */
3043 /* Else, end menu tracking */
3044 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
3045 fEndMenu = !fRemove;
3046 break;
3047
3048 case WM_RBUTTONUP:
3049 if (!(wFlags & TPM_RIGHTBUTTON)) break;
3050 /* fall through */
3051 case WM_LBUTTONUP:
3052 /* Check if a menu was selected by the mouse */
3053 if (hmenu)
3054 {
3055 executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
3056 TRACE("executedMenuId %d\n", executedMenuId);
3057
3058 /* End the loop if executedMenuId is an item ID */
3059 /* or if the job was done (executedMenuId = 0). */
3060 fEndMenu = fRemove = (executedMenuId != -1);
3061 }
3062 /* No menu was selected by the mouse */
3063 /* if the function was called by TrackPopupMenu, continue
3064 with the menu tracking. If not, stop it */
3065 else
3066 fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
3067
3068 break;
3069
3070 case WM_MOUSEMOVE:
3071 /* the selected menu item must be changed every time */
3072 /* the mouse moves. */
3073
3074 if (hmenu)
3075 fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
3076
3077 } /* switch(msg.message) - mouse */
3078 }
3079 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
3080 {
3081 fRemove = TRUE; /* Keyboard messages are always removed */
3082 switch(msg.message)
3083 {
3084 case WM_KEYDOWN:
3085 case WM_SYSKEYDOWN:
3086 switch(msg.wParam)
3087 {
3088 case VK_MENU:
3089 fEndMenu = TRUE;
3090 break;
3091
3092 case VK_HOME:
3093 case VK_END:
3094 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
3095 NO_SELECTED_ITEM, FALSE, 0 );
3096 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
3097 (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
3098 break;
3099
3100 case VK_UP:
3101 case VK_DOWN: /* If on menu bar, pull-down the menu */
3102
3103 menu = MENU_GetMenu( mt.hCurrentMenu );
3104 if (!(menu->wFlags & MF_POPUP))
3105 mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
3106 else /* otherwise try to move selection */
3107 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
3108 (msg.wParam == VK_UP)? ITEM_PREV : ITEM_NEXT );
3109 break;
3110
3111 case VK_LEFT:
3112 MENU_KeyLeft( &mt, wFlags );
3113 break;
3114
3115 case VK_RIGHT:
3116 MENU_KeyRight( &mt, wFlags );
3117 break;
3118
3119 case VK_ESCAPE:
3120 fEndMenu = MENU_KeyEscape(&mt, wFlags);
3121 break;
3122
3123 case VK_F1:
3124 {
3125 HELPINFO hi;
3126 hi.cbSize = sizeof(HELPINFO);
3127 hi.iContextType = HELPINFO_MENUITEM;
3128 if (menu->FocusedItem == NO_SELECTED_ITEM)
3129 hi.iCtrlId = 0;
3130 else
3131 hi.iCtrlId = menu->items[menu->FocusedItem].wID;
3132 hi.hItemHandle = hmenu;
3133 hi.dwContextId = menu->dwContextHelpID;
3134 hi.MousePos = msg.pt;
3135 SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
3136 break;
3137 }
3138
3139 default:
3140 break;
3141 }
3142 break; /* WM_KEYDOWN */
3143
3144 case WM_CHAR:
3145 case WM_SYSCHAR:
3146 {
3147 UINT pos;
3148
3149 if (msg.wParam == '\r' || msg.wParam == ' ')
3150 {
3151 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
3152 fEndMenu = (executedMenuId != -2);
3153
3154 break;
3155 }
3156
3157 /* Hack to avoid control chars. */
3158 /* We will find a better way real soon... */
3159 if (msg.wParam < 32) break;
3160
3161 pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
3162 LOWORD(msg.wParam), FALSE );
3163 if (pos == (UINT)-2) fEndMenu = TRUE;
3164 else if (pos == (UINT)-1) MessageBeep(0);
3165 else
3166 {
3167 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
3168 TRUE, 0 );
3169 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
3170 fEndMenu = (executedMenuId != -2);
3171 }
3172 }
3173 break;
3174 } /* switch(msg.message) - kbd */
3175 }
3176 else
3177 {
3178 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3179 DispatchMessageW( &msg );
3180 continue;
3181 }
3182
3183 if (!fEndMenu) fRemove = TRUE;
3184
3185 /* finally remove message from the queue */
3186
3187 if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
3188 PeekMessageW( &msg, 0, msg.message, msg.message, PM_REMOVE );
3189 else mt.trackFlags &= ~TF_SKIPREMOVE;
3190 }
3191
3192 MENU_SetCapture(0); /* release the capture */
3193
3194 /* If dropdown is still painted and the close box is clicked on
3195 then the menu will be destroyed as part of the DispatchMessage above.
3196 This will then invalidate the menu handle in mt.hTopMenu. We should
3197 check for this first. */
3198 if( IsMenu( mt.hTopMenu ) )
3199 {
3200 menu = MENU_GetMenu( mt.hTopMenu );
3201
3202 if( IsWindow( mt.hOwnerWnd ) )
3203 {
3204 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
3205
3206 if (menu && (menu->wFlags & MF_POPUP))
3207 {
3208 DestroyWindow( menu->hWnd );
3209 menu->hWnd = 0;
3210 }
3211 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
3212 SendMessageW( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
3213 }
3214
3215 /* Reset the variable for hiding menu */
3216 if( menu ) menu->bTimeToHide = FALSE;
3217 }
3218
3219 /* The return value is only used by TrackPopupMenu */
3220 if (!(wFlags & TPM_RETURNCMD)) return TRUE;
3221 if (executedMenuId == -1) executedMenuId = 0;
3222 return executedMenuId;
3223 }
3224
3225 /***********************************************************************
3226 * MENU_InitTracking
3227 */
3228 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
3229 {
3230 POPUPMENU *menu;
3231
3232 TRACE("hwnd=%p hmenu=%p\n", hWnd, hMenu);
3233
3234 HideCaret(0);
3235
3236 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
3237 if (!(wFlags & TPM_NONOTIFY))
3238 SendMessageW( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
3239
3240 SendMessageW( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
3241
3242 if (!(wFlags & TPM_NONOTIFY))
3243 {
3244 SendMessageW( hWnd, WM_INITMENU, (WPARAM)hMenu, 0 );
3245 /* If an app changed/recreated menu bar entries in WM_INITMENU
3246 * menu sizes will be recalculated once the menu created/shown.
3247 */
3248 }
3249
3250 /* This makes the menus of applications built with Delphi work.
3251 * It also enables menus to be displayed in more than one window,
3252 * but there are some bugs left that need to be fixed in this case.
3253 */
3254 if ((menu = MENU_GetMenu( hMenu ))) menu->hWnd = hWnd;
3255
3256 return TRUE;
3257 }
3258 /***********************************************************************
3259 * MENU_ExitTracking
3260 */
3261 static BOOL MENU_ExitTracking(HWND hWnd)
3262 {
3263 TRACE("hwnd=%p\n", hWnd);
3264
3265 SendMessageW( hWnd, WM_EXITMENULOOP, 0, 0 );
3266 ShowCaret(0);
3267 top_popup = 0;
3268 return TRUE;
3269 }
3270
3271 /***********************************************************************
3272 * MENU_TrackMouseMenuBar
3273 *
3274 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
3275 */
3276 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
3277 {
3278 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
3279 UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3280
3281 TRACE("wnd=%p ht=0x%04x %s\n", hWnd, ht, wine_dbgstr_point( &pt));
3282
3283 if (IsMenu(hMenu))
3284 {
3285 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3286 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3287 MENU_ExitTracking(hWnd);
3288 }
3289 }
3290
3291
3292 /***********************************************************************
3293 * MENU_TrackKbdMenuBar
3294 *
3295 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3296 */
3297 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, WCHAR wChar)
3298 {
3299 UINT uItem = NO_SELECTED_ITEM;
3300 HMENU hTrackMenu;
3301 UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3302
3303 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", hwnd, wParam, wChar);
3304
3305 /* find window that has a menu */
3306
3307 while (!WIN_ALLOWED_MENU(GetWindowLongW( hwnd, GWL_STYLE )))
3308 if (!(hwnd = GetAncestor( hwnd, GA_PARENT ))) return;
3309
3310 /* check if we have to track a system menu */
3311
3312 hTrackMenu = GetMenu( hwnd );
3313 if (!hTrackMenu || IsIconic(hwnd) || wChar == ' ' )
3314 {
3315 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3316 hTrackMenu = get_win_sys_menu( hwnd );
3317 uItem = 0;
3318 wParam |= HTSYSMENU; /* prevent item lookup */
3319 }
3320
3321 if (!IsMenu( hTrackMenu )) return;
3322
3323 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3324
3325 if( wChar && wChar != ' ' )
3326 {
3327 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, wChar, (wParam & HTSYSMENU) );
3328 if ( uItem >= (UINT)(-2) )
3329 {
3330 if( uItem == (UINT)(-1) ) MessageBeep(0);
3331 /* schedule end of menu tracking */
3332 wFlags |= TF_ENDMENU;
3333 goto track_menu;
3334 }
3335 }
3336
3337 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3338
3339 if (wParam & HTSYSMENU)
3340 {
3341 /* prevent sysmenu activation for managed windows on Alt down/up */
3342 if (GetPropA( hwnd, "__wine_x11_managed" ))
3343 wFlags |= TF_ENDMENU; /* schedule end of menu tracking */
3344 }
3345 else
3346 {
3347 if( uItem == NO_SELECTED_ITEM )
3348 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3349 else
3350 PostMessageW( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3351 }
3352
3353 track_menu:
3354 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3355 MENU_ExitTracking( hwnd );
3356 }
3357
3358
3359 /**********************************************************************
3360 * TrackPopupMenu (USER32.@)
3361 *
3362 * Like the win32 API, the function return the command ID only if the
3363 * flag TPM_RETURNCMD is on.
3364 *
3365 */
3366 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3367 INT nReserved, HWND hWnd, const RECT *lpRect )
3368 {
3369 BOOL ret = FALSE;
3370
3371 TRACE("hmenu %p flags %04x (%d,%d) reserved %d hwnd %p rect %s\n",
3372 hMenu, wFlags, x, y, nReserved, hWnd, wine_dbgstr_rect(lpRect));
3373
3374 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3375
3376 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3377 if (!(wFlags & TPM_NONOTIFY))
3378 SendMessageW( hWnd, WM_INITMENUPOPUP, (WPARAM)hMenu, 0);
3379
3380 if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
3381 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3382 MENU_ExitTracking(hWnd);
3383
3384 return ret;
3385 }
3386
3387 /**********************************************************************
3388 * TrackPopupMenuEx (USER32.@)
3389 */
3390 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3391 HWND hWnd, LPTPMPARAMS lpTpm )
3392 {
3393 FIXME("not fully implemented\n" );
3394 return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3395 lpTpm ? &lpTpm->rcExclude : NULL );
3396 }
3397
3398 /***********************************************************************
3399 * PopupMenuWndProc
3400 *
3401 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3402 */
3403 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3404 {
3405 TRACE("hwnd=%p msg=0x%04x wp=0x%04x lp=0x%08lx\n", hwnd, message, wParam, lParam);
3406
3407 switch(message)
3408 {
3409 case WM_CREATE:
3410 {
3411 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3412 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)cs->lpCreateParams );
3413 return 0;
3414 }
3415
3416 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3417 return MA_NOACTIVATE;
3418
3419 case WM_PAINT:
3420 {
3421 PAINTSTRUCT ps;
3422 BeginPaint( hwnd, &ps );
3423 MENU_DrawPopupMenu( hwnd, ps.hdc,
3424 (HMENU)GetWindowLongPtrW( hwnd, 0 ) );
3425 EndPaint( hwnd, &ps );
3426 return 0;
3427 }
3428 case WM_ERASEBKGND:
3429 return 1;
3430
3431 case WM_DESTROY:
3432 /* zero out global pointer in case resident popup window was destroyed. */
3433 if (hwnd == top_popup) top_popup = 0;
3434 break;
3435
3436 case WM_SHOWWINDOW:
3437
3438 if( wParam )
3439 {
3440 if (!GetWindowLongPtrW( hwnd, 0 )) ERR("no menu to display\n");
3441 }
3442 else
3443 SetWindowLongPtrW( hwnd, 0, 0 );
3444 break;
3445
3446 case MM_SETMENUHANDLE:
3447 SetWindowLongPtrW( hwnd, 0, wParam );
3448 break;
3449
3450 case MM_GETMENUHANDLE:
3451 return GetWindowLongPtrW( hwnd, 0 );
3452
3453 default:
3454 return DefWindowProcW( hwnd, message, wParam, lParam );
3455 }
3456 return 0;
3457 }
3458
3459
3460 /***********************************************************************
3461 * MENU_GetMenuBarHeight
3462 *
3463 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3464 */
3465 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3466 INT orgX, INT orgY )
3467 {
3468 HDC hdc;
3469 RECT rectBar;
3470 LPPOPUPMENU lppop;
3471
3472 TRACE("HWND %p, width %d, at (%d, %d).\n", hwnd, menubarWidth, orgX, orgY );
3473
3474 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3475
3476 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3477 SelectObject( hdc, get_menu_font(FALSE));
3478 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3479 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3480 ReleaseDC( hwnd, hdc );
3481 return lppop->Height;
3482 }
3483
3484
3485 /*******************************************************************
3486 * ChangeMenuA (USER32.@)
3487 */
3488 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3489 UINT id, UINT flags )
3490 {
3491 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3492 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3493 id, data );
3494 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3495 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3496 id, data );
3497 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3498 flags & MF_BYPOSITION ? pos : id,
3499 flags & ~MF_REMOVE );
3500 /* Default: MF_INSERT */
3501 return InsertMenuA( hMenu, pos, flags, id, data );
3502 }
3503
3504
3505 /*******************************************************************
3506 * ChangeMenuW (USER32.@)
3507 */
3508 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3509 UINT id, UINT flags )
3510 {
3511 TRACE("menu=%p pos=%d data=%p id=%08x flags=%08x\n", hMenu, pos, data, id, flags );
3512 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3513 id, data );
3514 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3515 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3516 id, data );
3517 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3518 flags & MF_BYPOSITION ? pos : id,
3519 flags & ~MF_REMOVE );
3520 /* Default: MF_INSERT */
3521 return InsertMenuW( hMenu, pos, flags, id, data );
3522 }
3523
3524
3525 /*******************************************************************
3526 * CheckMenuItem (USER32.@)
3527 */
3528 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3529 {
3530 MENUITEM *item;
3531 DWORD ret;
3532
3533 TRACE("menu=%p id=%04x flags=%04x\n", hMenu, id, flags );
3534 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3535 ret = item->fState & MF_CHECKED;
3536 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3537 else item->fState &= ~MF_CHECKED;
3538 return ret;
3539 }
3540
3541
3542 /**********************************************************************
3543 * EnableMenuItem (USER32.@)
3544 */
3545 BOOL WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3546 {
3547 UINT oldflags;
3548 MENUITEM *item;
3549 POPUPMENU *menu;
3550
3551 TRACE("(%p, %04x, %04x) !\n", hMenu, wItemID, wFlags);
3552
3553 /* Get the Popupmenu to access the owner menu */
3554 if (!(menu = MENU_GetMenu(hMenu)))
3555 return (UINT)-1;
3556
3557 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3558 return (UINT)-1;
3559
3560 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3561 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3562
3563 /* If the close item in the system menu change update the close button */
3564 if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3565 {
3566 if (menu->hSysMenuOwner != 0)
3567 {
3568 RECT rc;
3569 POPUPMENU* parentMenu;
3570
3571 /* Get the parent menu to access*/
3572 if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3573 return (UINT)-1;
3574
3575 /* Refresh the frame to reflect the change */
3576 GetWindowRect(parentMenu->hWnd, &rc);
3577 MapWindowPoints(0, parentMenu->hWnd, (POINT *)&rc, 2);
3578 rc.bottom = 0;
3579 RedrawWindow(parentMenu->hWnd, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
3580 }
3581 }
3582
3583 return oldflags;
3584 }
3585
3586
3587 /*******************************************************************
3588 * GetMenuStringA (USER32.@)
3589 */
3590 INT WINAPI GetMenuStringA(
3591 HMENU hMenu, /* [in] menuhandle */
3592 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3593 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3594 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3595 UINT wFlags /* [in] MF_ flags */
3596 ) {
3597 MENUITEM *item;
3598
3599 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3600 if (str && nMaxSiz) str[0] = '\0';
3601 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) {
3602 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3603 return 0;
3604 }
3605 if (!item->text) return 0;
3606 if (!str || !nMaxSiz) return strlenW(item->text);
3607 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3608 str[nMaxSiz-1] = 0;
3609 TRACE("returning '%s'\n", str );
3610 return strlen(str);
3611 }
3612
3613
3614 /*******************************************************************
3615 * GetMenuStringW (USER32.@)
3616 */
3617 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3618 LPWSTR str, INT nMaxSiz, UINT wFlags )
3619 {
3620 MENUITEM *item;
3621
3622 TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, wItemID, str, nMaxSiz, wFlags );
3623 if (str && nMaxSiz) str[0] = '\0';
3624 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) {
3625 SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
3626 return 0;
3627 }
3628 if (!str || !nMaxSiz) return item->text ? strlenW(item->text) : 0;
3629 if( !(item->text)) {
3630 str[0] = 0;
3631 return 0;
3632 }
3633 lstrcpynW( str, item->text, nMaxSiz );
3634 return strlenW(str);
3635 }
3636
3637
3638 /**********************************************************************
3639 * HiliteMenuItem (USER32.@)
3640 */
3641 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3642 UINT wHilite )
3643 {
3644 LPPOPUPMENU menu;
3645 TRACE("(%p, %p, %04x, %04x);\n", hWnd, hMenu, wItemID, wHilite);
3646 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3647 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3648 if (menu->FocusedItem == wItemID) return TRUE;
3649 MENU_HideSubPopups( hWnd, hMenu, FALSE );
3650 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3651 return TRUE;
3652 }
3653
3654
3655 /**********************************************************************
3656 * GetMenuState (USER32.@)
3657 */
3658 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3659 {
3660 MENUITEM *item;
3661 TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, wItemID, wFlags);
3662 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3663 debug_print_menuitem (" item: ", item, "");
3664 if (item->fType & MF_POPUP)
3665 {
3666 POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3667 if (!menu) return -1;
3668 else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3669 }
3670 else
3671 {
3672 /* We used to (from way back then) mask the result to 0xff. */
3673 /* I don't know why and it seems wrong as the documented */
3674 /* return flag MF_SEPARATOR is outside that mask. */
3675 return (item->fType | item->fState);
3676 }
3677 }
3678
3679
3680 /**********************************************************************
3681 * GetMenuItemCount (USER32.@)
3682 */
3683 INT WINAPI GetMenuItemCount( HMENU hMenu )
3684 {
3685 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3686 if (!menu) return -1;
3687 TRACE("(%p) returning %d\n", hMenu, menu->nItems );
3688 return menu->nItems;
3689 }
3690
3691
3692 /**********************************************************************
3693 * GetMenuItemID (USER32.@)
3694 */
3695 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3696 {
3697 MENUITEM * lpmi;
3698
3699 if (!(lpmi = MENU_FindItem(&hMenu,(UINT*)&nPos,MF_BYPOSITION))) return -1;
3700 if (lpmi->fType & MF_POPUP) return -1;
3701 return lpmi->wID;
3702
3703 }
3704
3705
3706 /*******************************************************************
3707 * InsertMenuW (USER32.@)
3708 */
3709 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3710 UINT_PTR id, LPCWSTR str )
3711 {
3712 MENUITEM *item;
3713
3714 if (IS_STRING_ITEM(flags) && str)
3715 TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %s\n",
3716 hMenu, pos, flags, id, debugstr_w(str) );
3717 else TRACE("hMenu %p, pos %d, flags %08x, id %04x, str %p (not a string)\n",
3718 hMenu, pos, flags, id, str );
3719
3720 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3721
3722 if (!(MENU_SetItemData( item, flags, id, str )))
3723 {
3724 RemoveMenu( hMenu, pos, flags );
3725 return FALSE;
3726 }
3727
3728 if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
3729 (MENU_GetMenu((HMENU)id))->wFlags |= MF_POPUP;
3730
3731 item->hCheckBit = item->hUnCheckBit = 0;
3732 return TRUE;
3733 }
3734
3735
3736 /*******************************************************************
3737 * InsertMenuA (USER32.@)
3738 */
3739 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3740 UINT_PTR id, LPCSTR str )
3741 {
3742 BOOL ret = FALSE;
3743
3744 if (IS_STRING_ITEM(flags) && str)
3745 {
3746 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3747 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3748 if (newstr)
3749 {
3750 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3751 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3752 HeapFree( GetProcessHeap(), 0, newstr );
3753 }
3754 return ret;
3755 }
3756 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3757 }
3758
3759
3760 /*******************************************************************
3761 * AppendMenuA (USER32.@)
3762 */
3763 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3764 UINT_PTR id, LPCSTR data )
3765 {
3766 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3767 }
3768
3769
3770 /*******************************************************************
3771 * AppendMenuW (USER32.@)
3772 */
3773 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3774 UINT_PTR id, LPCWSTR data )
3775 {
3776 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3777 }
3778
3779
3780 /**********************************************************************
3781 * RemoveMenu (USER32.@)
3782 */
3783 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3784 {
3785 LPPOPUPMENU menu;
3786 MENUITEM *item;
3787
3788 TRACE("(menu=%p pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3789 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3790 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3791
3792 /* Remove item */
3793
3794 MENU_FreeItemData( item );
3795
3796 if (--menu->nItems == 0)
3797 {
3798 HeapFree( GetProcessHeap(), 0, menu->items );
3799 menu->items = NULL;
3800 }
3801 else
3802 {
3803 while(nPos < menu->nItems)
3804 {
3805 *item = *(item+1);
3806 item++;
3807 nPos++;
3808 }
3809 menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3810 menu->nItems * sizeof(MENUITEM) );
3811 }
3812 return TRUE;
3813 }
3814
3815
3816 /**********************************************************************
3817 * DeleteMenu (USER32.@)
3818 */
3819 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3820 {
3821 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3822 if (!item) return FALSE;
3823 if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3824 /* nPos is now the position of the item */
3825 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3826 return TRUE;
3827 }
3828
3829
3830 /*******************************************************************
3831 * ModifyMenuW (USER32.@)
3832 */
3833 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3834 UINT_PTR id, LPCWSTR str )
3835 {
3836 MENUITEM *item;
3837
3838 if (IS_STRING_ITEM(flags))
3839 TRACE("%p %d %04x %04x %s\n", hMenu, pos, flags, id, debugstr_w(str) );
3840 else
3841 TRACE("%p %d %04x %04x %p\n", hMenu, pos, flags, id, str );
3842
3843 if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3844 MENU_GetMenu(hMenu)->Height = 0; /* force size recalculate */
3845 return MENU_SetItemData( item, flags, id, str );
3846 }
3847
3848
3849 /*******************************************************************
3850 * ModifyMenuA (USER32.@)
3851 */
3852 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3853 UINT_PTR id, LPCSTR str )
3854 {
3855 BOOL ret = FALSE;
3856
3857 if (IS_STRING_ITEM(flags) && str)
3858 {
3859 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3860 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3861 if (newstr)
3862 {
3863 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3864 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3865 HeapFree( GetProcessHeap(), 0, newstr );
3866 }
3867 return ret;
3868 }
3869 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3870 }
3871
3872
3873 /**********************************************************************
3874 * CreatePopupMenu (USER32.@)
3875 */
3876 HMENU WINAPI CreatePopupMenu(void)
3877 {
3878 HMENU hmenu;
3879 POPUPMENU *menu;
3880
3881 if (!(hmenu = CreateMenu())) return 0;
3882 menu = MENU_GetMenu( hmenu );
3883 menu->wFlags |= MF_POPUP;
3884 menu->bTimeToHide = FALSE;
3885 return hmenu;
3886 }
3887
3888
3889 /**********************************************************************
3890 * GetMenuCheckMarkDimensions (USER.417)
3891 * GetMenuCheckMarkDimensions (USER32.@)
3892 */
3893 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3894 {
3895 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3896 }
3897
3898
3899 /**********************************************************************
3900 * SetMenuItemBitmaps (USER32.@)
3901 */
3902 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3903 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3904 {
3905 MENUITEM *item;
3906 TRACE("(%p, %04x, %04x, %p, %p)\n",
3907 hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3908 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3909
3910 if (!hNewCheck && !hNewUnCheck)
3911 {
3912 item->fState &= ~MF_USECHECKBITMAPS;
3913 }
3914 else /* Install new bitmaps */
3915 {
3916 item->hCheckBit = hNewCheck;
3917 item->hUnCheckBit = hNewUnCheck;
3918 item->fState |= MF_USECHECKBITMAPS;
3919 }
3920 return TRUE;
3921 }
3922
3923
3924 /**********************************************************************
3925 * CreateMenu (USER32.@)
3926 */
3927 HMENU WINAPI CreateMenu(void)
3928 {
3929 HMENU hMenu;
3930 LPPOPUPMENU menu;
3931 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3932 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3933
3934 ZeroMemory(menu, sizeof(POPUPMENU));
3935 menu->wMagic = MENU_MAGIC;
3936 menu->FocusedItem = NO_SELECTED_ITEM;
3937 menu->bTimeToHide = FALSE;
3938
3939 TRACE("return %p\n", hMenu );
3940
3941 return hMenu;
3942 }
3943
3944
3945 /**********************************************************************
3946 * DestroyMenu (USER32.@)
3947 */
3948 BOOL WINAPI DestroyMenu( HMENU hMenu )
3949 {
3950 LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3951
3952 TRACE("(%p)\n", hMenu);
3953
3954
3955 if (!lppop) return FALSE;
3956
3957 lppop->wMagic = 0; /* Mark it as destroyed */
3958
3959 /* DestroyMenu should not destroy system menu popup owner */
3960 if ((lppop->wFlags & (MF_POPUP | MF_SYSMENU)) == MF_POPUP && lppop->hWnd)
3961 {
3962 DestroyWindow( lppop->hWnd );
3963 lppop->hWnd = 0;
3964 }
3965
3966 if (lppop->items) /* recursively destroy submenus */
3967 {
3968 int i;
3969 MENUITEM *item = lppop->items;
3970 for (i = lppop->nItems; i > 0; i--, item++)
3971 {
3972 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3973 MENU_FreeItemData( item );
3974 }
3975 HeapFree( GetProcessHeap(), 0, lppop->items );
3976 }
3977 USER_HEAP_FREE( hMenu );
3978 return TRUE;
3979 }
3980
3981
3982 /**********************************************************************
3983 * GetSystemMenu (USER32.@)
3984 */
3985 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3986 {
3987 WND *wndPtr = WIN_GetPtr( hWnd );
3988 HMENU retvalue = 0;
3989
3990 if (wndPtr == WND_DESKTOP) return 0;
3991 if (wndPtr == WND_OTHER_PROCESS)
3992 {
3993 if (IsWindow( hWnd )) FIXME( "not supported on other process window %p\n", hWnd );
3994 }
3995 else if (wndPtr)
3996 {
3997 if (wndPtr->hSysMenu && bRevert)
3998 {
3999 DestroyMenu(wndPtr->hSysMenu);
4000 wndPtr->hSysMenu = 0;
4001 }
4002
4003 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
4004 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, 0 );
4005
4006 if( wndPtr->hSysMenu )
4007 {
4008 POPUPMENU *menu;
4009 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
4010
4011 /* Store the dummy sysmenu handle to facilitate the refresh */
4012 /* of the close button if the SC_CLOSE item change */
4013 menu = MENU_GetMenu(retvalue);
4014 if ( menu )
4015 menu->hSysMenuOwner = wndPtr->hSysMenu;
4016 }
4017 WIN_ReleasePtr( wndPtr );
4018 }
4019 return bRevert ? 0 : retvalue;
4020 }
4021
4022
4023 /*******************************************************************
4024 * SetSystemMenu (USER32.@)
4025 */
4026 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
4027 {
4028 WND *wndPtr = WIN_GetPtr( hwnd );
4029
4030 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
4031 {
4032 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
4033 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
4034 WIN_ReleasePtr( wndPtr );
4035 return TRUE;
4036 }
4037 return FALSE;
4038 }
4039
4040
4041 /**********************************************************************
4042 * GetMenu (USER32.@)
4043 */
4044 HMENU WINAPI GetMenu( HWND hWnd )
4045 {
4046 HMENU retvalue = (HMENU)GetWindowLongPtrW( hWnd, GWLP_ID );
4047 TRACE("for %p returning %p\n", hWnd, retvalue);
4048 return retvalue;
4049 }
4050
4051 /**********************************************************************
4052 * GetMenuBarInfo (USER32.@)
4053 */
4054 BOOL WINAPI GetMenuBarInfo( HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi )
4055 {
4056 FIXME( "(%p,0x%08x,0x%08x,%p)\n", hwnd, idObject, idItem, pmbi );
4057 return FALSE;
4058 }
4059
4060 /**********************************************************************
4061 * MENU_SetMenu
4062 *
4063 * Helper for SetMenu. Also called by WIN_CreateWindowEx to avoid the
4064 * SetWindowPos call that would result if SetMenu were called directly.
4065 */
4066 BOOL MENU_SetMenu( HWND hWnd, HMENU hMenu )
4067 {
4068 TRACE("(%p, %p);\n", hWnd, hMenu);
4069
4070 if (hMenu && !IsMenu(hMenu))
4071 {
4072 WARN("hMenu %p is not a menu handle\n", hMenu);
4073 return FALSE;
4074 }
4075 if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
4076 return FALSE;
4077
4078 hWnd = WIN_GetFullHandle( hWnd );
4079 if (GetCapture() == hWnd) MENU_SetCapture(0); /* release the capture */
4080
4081 if (hMenu != 0)
4082 {
4083 LPPOPUPMENU lpmenu;
4084
4085 if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
4086
4087 lpmenu->hWnd = hWnd;
4088 lpmenu->Height = 0; /* Make sure we recalculate the size */
4089 }
4090 SetWindowLongPtrW( hWnd, GWLP_ID, (LONG_PTR)hMenu );
4091 return TRUE;
4092 }
4093
4094
4095 /**********************************************************************
4096 * SetMenu (USER32.@)
4097 */
4098 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
4099 {
4100 if(!MENU_SetMenu(hWnd, hMenu))
4101 return FALSE;
4102
4103 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4104 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4105 return TRUE;
4106 }
4107
4108
4109 /**********************************************************************
4110 * GetSubMenu (USER32.@)
4111 */
4112 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4113 {
4114 MENUITEM * lpmi;
4115
4116 if (!(lpmi = MENU_FindItem(&hMenu,(UINT*)&nPos,MF_BYPOSITION))) return 0;
4117 if (!(lpmi->fType & MF_POPUP)) return 0;
4118 return lpmi->hSubMenu;
4119 }
4120
4121
4122 /**********************************************************************
4123 * DrawMenuBar (USER32.@)
4124 */
4125 BOOL WINAPI DrawMenuBar( HWND hWnd )
4126 {
4127 LPPOPUPMENU lppop;
4128 HMENU hMenu = GetMenu(hWnd);
4129
4130 if (!WIN_ALLOWED_MENU(GetWindowLongW( hWnd, GWL_STYLE )))
4131 return FALSE;
4132 if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
4133
4134 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4135 lppop->hwndOwner = hWnd;
4136 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4137 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4138 return TRUE;
4139 }
4140
4141 /***********************************************************************
4142 * DrawMenuBarTemp (USER32.@)
4143 *
4144 * UNDOCUMENTED !!
4145 *
4146 * called by W98SE desk.cpl Control Panel Applet
4147 *
4148 * Not 100% sure about the param names, but close.
4149 */
4150 DWORD WINAPI DrawMenuBarTemp(HWND hwnd, HDC hDC, LPRECT lprect, HMENU hMenu, HFONT hFont)
4151 {
4152 LPPOPUPMENU lppop;
4153 UINT i,retvalue;
4154 HFONT hfontOld = 0;
4155 BOOL flat_menu = FALSE;
4156
4157 SystemParametersInfoW (SPI_GETFLATMENU, 0, &flat_menu, 0);
4158
4159 if (!hMenu)
4160 hMenu = GetMenu(hwnd);
4161
4162 if (!hFont)
4163 hFont = get_menu_font(FALSE);
4164
4165 lppop = MENU_GetMenu( hMenu );
4166 if (lppop == NULL || lprect == NULL)
4167 {
4168 retvalue = GetSystemMetrics(SM_CYMENU);
4169 goto END;
4170 }
4171
4172 TRACE("(%p, %p, %p, %p, %p)\n", hwnd, hDC, lprect, hMenu, hFont);
4173
4174 hfontOld = SelectObject( hDC, hFont);
4175
4176 if (lppop->Height == 0)
4177 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
4178
4179 lprect->bottom = lprect->top + lppop->Height;
4180
4181 FillRect(hDC, lprect, GetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU) );
4182
4183 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
4184 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
4185 LineTo( hDC, lprect->right, lprect->bottom );
4186
4187 if (lppop->nItems == 0)
4188 {
4189 retvalue = GetSystemMetrics(SM_CYMENU);
4190 goto END;
4191 }
4192
4193 for (i = 0; i < lppop->nItems; i++)
4194 {
4195 MENU_DrawMenuItem( hwnd, hMenu, hwnd,
4196 hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
4197 }
4198 retvalue = lppop->Height;
4199
4200 END:
4201 if (hfontOld) SelectObject (hDC, hfontOld);
4202 return retvalue;
4203 }
4204
4205 /***********************************************************************
4206 * EndMenu (USER.187)
4207 * EndMenu (USER32.@)
4208 */
4209 void WINAPI EndMenu(void)
4210 {
4211 /* if we are in the menu code, and it is active */
4212 if (!fEndMenu && top_popup)
4213 {
4214 /* terminate the menu handling code */
4215 fEndMenu = TRUE;
4216
4217 /* needs to be posted to wakeup the internal menu handler */
4218 /* which will now terminate the menu, in the event that */
4219 /* the main window was minimized, or lost focus, so we */
4220 /* don't end up with an orphaned menu */
4221 PostMessageW( top_popup, WM_CANCELMODE, 0, 0);
4222 }
4223 }
4224
4225
4226 /***********************************************************************
4227 * LookupMenuHandle (USER.217)
4228 */
4229 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
4230 {
4231 HMENU hmenu32 = HMENU_32(hmenu);
4232 UINT id32 = id;
4233 if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
4234 else return HMENU_16(hmenu32);
4235 }
4236
4237
4238 /**********************************************************************
4239 * LoadMenu (USER.150)
4240 */
4241 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
4242 {
4243 HRSRC16 hRsrc;
4244 HGLOBAL16 handle;
4245 HMENU16 hMenu;
4246
4247 if (HIWORD(name) && name[0] == '#') name = (LPCSTR)atoi( name + 1 );
4248 if (!name) return 0;
4249
4250 instance = GetExePtr( instance );
4251 if (!(hRsrc = FindResource16( instance, name, (LPSTR)RT_MENU ))) return 0;
4252 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
4253 hMenu = LoadMenuIndirect16(LockResource16(handle));
4254 FreeResource16( handle );
4255 return hMenu;
4256 }
4257
4258
4259 /*****************************************************************
4260 * LoadMenuA (USER32.@)
4261 */
4262 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4263 {
4264 HRSRC hrsrc = FindResourceA( instance, name, (LPSTR)RT_MENU );
4265 if (!hrsrc) return 0;
4266 return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
4267 }
4268
4269
4270 /*****************************************************************
4271 * LoadMenuW (USER32.@)
4272 */
4273 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4274 {
4275 HRSRC hrsrc = FindResourceW( instance, name, (LPWSTR)RT_MENU );
4276 if (!hrsrc) return 0;
4277 return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
4278 }
4279
4280
4281 /**********************************************************************
4282 * LoadMenuIndirect (USER.220)
4283 */
4284 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
4285 {
4286 HMENU hMenu;
4287 WORD version, offset;
4288 LPCSTR p = (LPCSTR)template;
4289
4290 TRACE("(%p)\n", template );
4291 version = GET_WORD(p);
4292 p += sizeof(WORD);
4293 if (version)
4294 {
4295 WARN("version must be 0 for Win16\n" );
4296 return 0;
4297 }
4298 offset = GET_WORD(p);
4299 p += sizeof(WORD) + offset;
4300 if (!(hMenu = CreateMenu())) return 0;
4301 if (!MENU_ParseResource( p, hMenu, FALSE ))
4302 {
4303 DestroyMenu( hMenu );
4304 return 0;
4305 }
4306 return HMENU_16(hMenu);
4307 }
4308
4309
4310 /**********************************************************************
4311 * LoadMenuIndirectW (USER32.@)
4312 */
4313 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4314 {
4315 HMENU hMenu;
4316 WORD version, offset;
4317 LPCSTR p = (LPCSTR)template;
4318
4319 version = GET_WORD(p);
4320 p += sizeof(WORD);
4321 TRACE("%p, ver %d\n", template, version );
4322 switch (version)
4323 {
4324 case 0: /* standard format is version of 0 */
4325 offset = GET_WORD(p);
4326 p += sizeof(WORD) + offset;
4327 if (!(hMenu = CreateMenu())) return 0;
4328 if (!MENU_ParseResource( p, hMenu, TRUE ))
4329 {
4330 DestroyMenu( hMenu );
4331 return 0;
4332 }
4333 return hMenu;
4334 case 1: /* extended format is version of 1 */
4335 offset = GET_WORD(p);
4336 p += sizeof(WORD) + offset;
4337 if (!(hMenu = CreateMenu())) return 0;
4338 if (!MENUEX_ParseResource( p, hMenu))
4339 {
4340 DestroyMenu( hMenu );
4341 return 0;
4342 }
4343 return hMenu;
4344 default:
4345 ERR("version %d not supported.\n", version);
4346 return 0;
4347 }
4348 }
4349
4350
4351 /**********************************************************************
4352 * LoadMenuIndirectA (USER32.@)
4353 */
4354 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4355 {
4356 return LoadMenuIndirectW( template );
4357 }
4358
4359
4360 /**********************************************************************
4361 * IsMenu (USER32.@)
4362 */
4363 BOOL WINAPI IsMenu(HMENU hmenu)
4364 {
4365 LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4366
4367 if (!menu)
4368 {
4369 SetLastError(ERROR_INVALID_MENU_HANDLE);
4370 return FALSE;
4371 }
4372 return TRUE;
4373 }
4374
4375 /**********************************************************************
4376 * GetMenuItemInfo_common
4377 */
4378
4379 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4380 LPMENUITEMINFOW lpmii, BOOL unicode)
4381 {
4382 MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos ? MF_BYPOSITION : 0);
4383
4384 debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4385
4386 if (!menu)
4387 return FALSE;
4388
4389 if( lpmii->fMask & MIIM_TYPE) {
4390 if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) {
4391 WARN("invalid combination of fMask bits used\n");
4392 /* this does not happen on Win9x/ME */
4393 SetLastError( ERROR_INVALID_PARAMETER);
4394 return FALSE;
4395 }
4396 lpmii->fType = menu->fType & MENUITEMINFO_TYPE_MASK;
4397 if( menu->hbmpItem) lpmii->fType |= MFT_BITMAP;
4398 lpmii->hbmpItem = menu->hbmpItem; /* not on Win9x/ME */
4399 if( lpmii->fType & MFT_BITMAP) {
4400 lpmii->dwTypeData = (LPWSTR) menu->hbmpItem;
4401 lpmii->cch = 0;
4402 } else if( lpmii->fType & (MFT_OWNERDRAW | MFT_SEPARATOR)) {
4403 /* this does not happen on Win9x/ME */
4404 lpmii->dwTypeData = 0;
4405 lpmii->cch = 0;
4406 }
4407 }
4408
4409 /* copy the text string */
4410 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING))) {
4411 if( !menu->text ) {
4412 if(lpmii->dwTypeData && lpmii->cch) {
4413 lpmii->cch = 0;
4414 if( unicode)
4415 *((WCHAR *)lpmii->dwTypeData) = 0;
4416 else
4417 *((CHAR *)lpmii->dwTypeData) = 0;
4418 }
4419 } else {
4420 int len;
4421 if (unicode)
4422 {
4423 len = strlenW(menu->text);
4424 if(lpmii->dwTypeData && lpmii->cch)
4425 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4426 }
4427 else
4428 {
4429 len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL,
4430 0, NULL, NULL ) - 1;
4431 if(lpmii->dwTypeData && lpmii->cch)
4432 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4433 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4434 ((LPSTR)lpmii->dwTypeData)[lpmii->cch - 1] = 0;
4435 }
4436 /* if we've copied a substring we return its length */
4437 if(lpmii->dwTypeData && lpmii->cch)
4438 if (lpmii->cch <= len + 1)
4439 lpmii->cch--;
4440 else
4441 lpmii->cch = len;
4442 else {
4443 /* return length of string */
4444 /* not on Win9x/ME if fType & MFT_BITMAP */
4445 lpmii->cch = len;
4446 }
4447 }
4448 }
4449
4450 if (lpmii->fMask & MIIM_FTYPE)
4451 lpmii->fType = menu->fType & MENUITEMINFO_TYPE_MASK;
4452
4453 if (lpmii->fMask & MIIM_BITMAP)
4454 lpmii->hbmpItem = menu->hbmpItem;
4455
4456 if (lpmii->fMask & MIIM_STATE)
4457 lpmii->fState = menu->fState & MENUITEMINFO_STATE_MASK;
4458
4459 if (lpmii->fMask & MIIM_ID)
4460 lpmii->wID = menu->wID;
4461
4462 if (lpmii->fMask & MIIM_SUBMENU)
4463 lpmii->hSubMenu = menu->hSubMenu;
4464 else {
4465 /* hSubMenu is always cleared
4466 * (not on Win9x/ME ) */
4467 lpmii->hSubMenu = 0;
4468 }
4469
4470 if (lpmii->fMask & MIIM_CHECKMARKS) {
4471 lpmii->hbmpChecked = menu->hCheckBit;
4472 lpmii->hbmpUnchecked = menu->hUnCheckBit;
4473 }
4474 if (lpmii->fMask & MIIM_DATA)
4475 lpmii->dwItemData = menu->dwItemData;
4476
4477 return TRUE;
4478 }
4479
4480 /**********************************************************************
4481 * GetMenuItemInfoA (USER32.@)
4482 */
4483 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4484 LPMENUITEMINFOA lpmii)
4485 {
4486 BOOL ret;
4487 MENUITEMINFOA mii;
4488 if( lpmii->cbSize != sizeof( mii) &&
4489 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4490 SetLastError( ERROR_INVALID_PARAMETER);
4491 return FALSE;
4492 }
4493 memcpy( &mii, lpmii, lpmii->cbSize);
4494 mii.cbSize = sizeof( mii);
4495 ret = GetMenuItemInfo_common (hmenu, item, bypos,
4496 (LPMENUITEMINFOW)&mii, FALSE);
4497 mii.cbSize = lpmii->cbSize;
4498 memcpy( lpmii, &mii, mii.cbSize);
4499 return ret;
4500 }
4501
4502 /**********************************************************************
4503 * GetMenuItemInfoW (USER32.@)
4504 */
4505 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4506 LPMENUITEMINFOW lpmii)
4507 {
4508 BOOL ret;
4509 MENUITEMINFOW mii;
4510 if( lpmii->cbSize != sizeof( mii) &&
4511 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4512 SetLastError( ERROR_INVALID_PARAMETER);
4513 return FALSE;
4514 }
4515 memcpy( &mii, lpmii, lpmii->cbSize);
4516 mii.cbSize = sizeof( mii);
4517 ret = GetMenuItemInfo_common (hmenu, item, bypos, &mii, TRUE);
4518 mii.cbSize = lpmii->cbSize;
4519 memcpy( lpmii, &mii, mii.cbSize);
4520 return ret;
4521 }
4522
4523
4524 /* set a menu item text from a ASCII or Unicode string */
4525 inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4526 {
4527 if (!text)
4528 menu->text = NULL;
4529 else if (unicode)
4530 {
4531 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4532 strcpyW( menu->text, text );
4533 }
4534 else
4535 {
4536 LPCSTR str = (LPCSTR)text;
4537 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4538 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4539 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4540 }
4541 }
4542
4543
4544 /**********************************************************************
4545 * SetMenuItemInfo_common
4546 */
4547
4548 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4549 const MENUITEMINFOW *lpmii,
4550 BOOL unicode)
4551 {
4552 if (!menu) return FALSE;
4553
4554 debug_print_menuitem("SetMenuItemInfo_common from: ", menu, "");
4555
4556 if (lpmii->fMask & MIIM_TYPE ) {
4557 if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) {
4558 WARN("invalid combination of fMask bits used\n");
4559 /* this does not happen on Win9x/ME */
4560 SetLastError( ERROR_INVALID_PARAMETER);
4561 return FALSE;
4562 }
4563
4564 /* Remove the old type bits and replace them with the new ones */
4565 menu->fType &= ~MENUITEMINFO_TYPE_MASK;
4566 menu->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
4567
4568 if (IS_STRING_ITEM(menu->fType)) {
4569 HeapFree(GetProcessHeap(), 0, menu->text);
4570 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4571 } else if( (menu->fType) & MFT_BITMAP)
4572 menu->hbmpItem = HBITMAP_32(LOWORD(lpmii->dwTypeData));
4573 }
4574
4575 if (lpmii->fMask & MIIM_FTYPE ) {
4576 if(( lpmii->fType & MFT_BITMAP)) {
4577 SetLastError( ERROR_INVALID_PARAMETER);
4578 return FALSE;
4579 }
4580 menu->fType &= ~MENUITEMINFO_TYPE_MASK;
4581 menu->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
4582 }
4583 if (lpmii->fMask & MIIM_STRING ) {
4584 /* free the string when used */
4585 HeapFree(GetProcessHeap(), 0, menu->text);
4586 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4587 }
4588
4589 if (lpmii->fMask & MIIM_STATE)
4590 {
4591 /* Other menu items having MFS_DEFAULT are not converted
4592 to normal items */
4593 menu->fState = lpmii->fState & MENUITEMINFO_STATE_MASK;
4594 }
4595
4596 if (lpmii->fMask & MIIM_ID)
4597 menu->wID = lpmii->wID;
4598
4599 if (lpmii->fMask & MIIM_SUBMENU) {
4600 menu->hSubMenu = lpmii->hSubMenu;
4601 if (menu->hSubMenu) {
4602 POPUPMENU *subMenu = MENU_GetMenu(menu->hSubMenu);
4603 if (subMenu) {
4604 subMenu->wFlags |= MF_POPUP;
4605 menu->fType |= MF_POPUP;
4606 }
4607 else {
4608 SetLastError( ERROR_INVALID_PARAMETER);
4609 return FALSE;
4610 }
4611 }
4612 else
4613 menu->fType &= ~MF_POPUP;
4614 }
4615
4616 if (lpmii->fMask & MIIM_CHECKMARKS)
4617 {
4618 menu->hCheckBit = lpmii->hbmpChecked;
4619 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4620 }
4621 if (lpmii->fMask & MIIM_DATA)
4622 menu->dwItemData = lpmii->dwItemData;
4623
4624 if (lpmii->fMask & MIIM_BITMAP)
4625 menu->hbmpItem = lpmii->hbmpItem;
4626
4627 if( !menu->text && !(menu->fType & MFT_OWNERDRAW) && !menu->hbmpItem)
4628 menu->fType |= MFT_SEPARATOR;
4629
4630 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4631 return TRUE;
4632 }
4633
4634 /**********************************************************************
4635 * SetMenuItemInfoA (USER32.@)
4636 */
4637 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4638 const MENUITEMINFOA *lpmii)
4639 {
4640 MENUITEMINFOA mii;
4641 if( lpmii->cbSize != sizeof( mii) &&
4642 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4643 SetLastError( ERROR_INVALID_PARAMETER);
4644 return FALSE;
4645 }
4646 memcpy( &mii, lpmii, lpmii->cbSize);
4647 if( lpmii->cbSize != sizeof( mii)) {
4648 mii.cbSize = sizeof( mii);
4649 mii.hbmpItem = NULL;
4650 }
4651 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4652 (const MENUITEMINFOW *)&mii, FALSE);
4653 }
4654
4655 /**********************************************************************
4656 * SetMenuItemInfoW (USER32.@)
4657 */
4658 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4659 const MENUITEMINFOW *lpmii)
4660 {
4661 MENUITEMINFOW mii;
4662 if( lpmii->cbSize != sizeof( mii) &&
4663 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4664 SetLastError( ERROR_INVALID_PARAMETER);
4665 return FALSE;
4666 }
4667 memcpy( &mii, lpmii, lpmii->cbSize);
4668 if( lpmii->cbSize != sizeof( mii)) {
4669 mii.cbSize = sizeof( mii);
4670 mii.hbmpItem = NULL;
4671 }
4672 return SetMenuItemInfo_common(MENU_FindItem(&hmenu,
4673 &item, bypos? MF_BYPOSITION : 0), &mii, TRUE);
4674 }
4675
4676 /**********************************************************************
4677 * SetMenuDefaultItem (USER32.@)
4678 *
4679 */
4680 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4681 {
4682 UINT i;
4683 POPUPMENU *menu;
4684 MENUITEM *item;
4685
4686 TRACE("(%p,%d,%d)\n", hmenu, uItem, bypos);
4687
4688 if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4689
4690 /* reset all default-item flags */
4691 item = menu->items;
4692 for (i = 0; i < menu->nItems; i++, item++)
4693 {
4694 item->fState &= ~MFS_DEFAULT;
4695 }
4696
4697 /* no default item */
4698 if ( -1 == uItem)
4699 {
4700 return TRUE;
4701 }
4702
4703 item = menu->items;
4704 if ( bypos )
4705 {
4706 if ( uItem >= menu->nItems ) return FALSE;
4707 item[uItem].fState |= MFS_DEFAULT;
4708 return TRUE;
4709 }
4710 else
4711 {
4712 for (i = 0; i < menu->nItems; i++, item++)
4713 {
4714 if (item->wID == uItem)
4715 {
4716 item->fState |= MFS_DEFAULT;
4717 return TRUE;
4718 }
4719 }
4720
4721 }
4722 return FALSE;
4723 }
4724
4725 /**********************************************************************
4726 * GetMenuDefaultItem (USER32.@)
4727 */
4728 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4729 {
4730 POPUPMENU *menu;
4731 MENUITEM * item;
4732 UINT i = 0;
4733
4734 TRACE("(%p,%d,%d)\n", hmenu, bypos, flags);
4735
4736 if (!(menu = MENU_GetMenu(hmenu))) return -1;
4737
4738 /* find default item */
4739 item = menu->items;
4740
4741 /* empty menu */
4742 if (! item) return -1;
4743
4744 while ( !( item->fState & MFS_DEFAULT ) )
4745 {
4746 i++; item++;
4747 if (i >= menu->nItems ) return -1;
4748 }
4749
4750 /* default: don't return disabled items */
4751 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4752
4753 /* search rekursiv when needed */
4754 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4755 {
4756 UINT ret;
4757 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4758 if ( -1 != ret ) return ret;
4759
4760 /* when item not found in submenu, return the popup item */
4761 }
4762 return ( bypos ) ? i : item->wID;
4763
4764 }
4765
4766
4767 /**********************************************************************
4768 * InsertMenuItemA (USER32.@)
4769 */
4770 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4771 const MENUITEMINFOA *lpmii)
4772 {
4773 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4774 MENUITEMINFOA mii;
4775 if( lpmii->cbSize != sizeof( mii) &&
4776 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4777 SetLastError( ERROR_INVALID_PARAMETER);
4778 return FALSE;
4779 }
4780 memcpy( &mii, lpmii, lpmii->cbSize);
4781 if( lpmii->cbSize != sizeof( mii)) {
4782 mii.cbSize = sizeof( mii);
4783 mii.hbmpItem = NULL;
4784 }
4785 return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)&mii, FALSE);
4786 }
4787
4788
4789 /**********************************************************************
4790 * InsertMenuItemW (USER32.@)
4791 */
4792 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4793 const MENUITEMINFOW *lpmii)
4794 {
4795 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4796 MENUITEMINFOW mii;
4797 if( lpmii->cbSize != sizeof( mii) &&
4798 lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem)) {
4799 SetLastError( ERROR_INVALID_PARAMETER);
4800 return FALSE;
4801 }
4802 memcpy( &mii, lpmii, lpmii->cbSize);
4803 if( lpmii->cbSize != sizeof( mii)) {
4804 mii.cbSize = sizeof( mii);
4805 mii.hbmpItem = NULL;
4806 }
4807 return SetMenuItemInfo_common(item, &mii, TRUE);
4808 }
4809
4810 /**********************************************************************
4811 * CheckMenuRadioItem (USER32.@)
4812 */
4813
4814 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4815 UINT first, UINT last, UINT check,
4816 UINT bypos)
4817 {
4818 MENUITEM *mifirst, *milast, *micheck;
4819 HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4820
4821 TRACE("%p: %d-%d, check %d, bypos=%d\n", hMenu, first, last, check, bypos);
4822
4823 mifirst = MENU_FindItem (&mfirst, &first, bypos);
4824 milast = MENU_FindItem (&mlast, &last, bypos);
4825 micheck = MENU_FindItem (&mcheck, &check, bypos);
4826
4827 if (mifirst == NULL || milast == NULL || micheck == NULL ||
4828 mifirst > milast || mfirst != mlast || mfirst != mcheck ||
4829 micheck > milast || micheck < mifirst)
4830 return FALSE;
4831
4832 while (mifirst <= milast)
4833 {
4834 if (mifirst == micheck)
4835 {
4836 mifirst->fType |= MFT_RADIOCHECK;
4837 mifirst->fState |= MFS_CHECKED;
4838 } else {
4839 mifirst->fType &= ~MFT_RADIOCHECK;
4840 mifirst->fState &= ~MFS_CHECKED;
4841 }
4842 mifirst++;
4843 }
4844
4845 return TRUE;
4846 }
4847
4848
4849 /**********************************************************************
4850 * GetMenuItemRect (USER32.@)
4851 *
4852 * ATTENTION: Here, the returned values in rect are the screen
4853 * coordinates of the item just like if the menu was
4854 * always on the upper left side of the application.
4855 *
4856 */
4857 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4858 LPRECT rect)
4859 {
4860 POPUPMENU *itemMenu;
4861 MENUITEM *item;
4862 HWND referenceHwnd;
4863
4864 TRACE("(%p,%p,%d,%p)\n", hwnd, hMenu, uItem, rect);
4865
4866 item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4867 referenceHwnd = hwnd;
4868
4869 if(!hwnd)
4870 {
4871 itemMenu = MENU_GetMenu(hMenu);
4872 if (itemMenu == NULL)
4873 return FALSE;
4874
4875 if(itemMenu->hWnd == 0)
4876 return FALSE;
4877 referenceHwnd = itemMenu->hWnd;
4878 }
4879
4880 if ((rect == NULL) || (item == NULL))
4881 return FALSE;
4882
4883 *rect = item->rect;
4884
4885 MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4886
4887 return TRUE;
4888 }
4889
4890
4891 /**********************************************************************
4892 * SetMenuInfo (USER32.@)
4893 *
4894 * FIXME
4895 * MIM_APPLYTOSUBMENUS
4896 * actually use the items to draw the menu
4897 */
4898 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4899 {
4900 POPUPMENU *menu;
4901
4902 TRACE("(%p %p)\n", hMenu, lpmi);
4903
4904 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4905 {
4906
4907 if (lpmi->fMask & MIM_BACKGROUND)
4908 menu->hbrBack = lpmi->hbrBack;
4909
4910 if (lpmi->fMask & MIM_HELPID)
4911 menu->dwContextHelpID = lpmi->dwContextHelpID;
4912
4913 if (lpmi->fMask & MIM_MAXHEIGHT)
4914 menu->cyMax = lpmi->cyMax;
4915
4916 if (lpmi->fMask & MIM_MENUDATA)
4917 menu->dwMenuData = lpmi->dwMenuData;
4918
4919 if (lpmi->fMask & MIM_STYLE)
4920 {
4921 menu->dwStyle = lpmi->dwStyle;
4922 if (menu->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented\n");
4923 if (menu->dwStyle & MNS_DRAGDROP) FIXME("MNS_DRAGDROP unimplemented\n");
4924 if (menu->dwStyle & MNS_MODELESS) FIXME("MNS_MODELESS unimplemented\n");
4925 if (menu->dwStyle & MNS_NOTIFYBYPOS) FIXME("MNS_NOTIFYBYPOS partially implemented\n");
4926 }
4927
4928 return TRUE;
4929 }
4930 return FALSE;
4931 }
4932
4933 /**********************************************************************
4934 * GetMenuInfo (USER32.@)
4935 *
4936 * NOTES
4937 * win98/NT5.0
4938 *
4939 */
4940 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4941 { POPUPMENU *menu;
4942
4943 TRACE("(%p %p)\n", hMenu, lpmi);
4944
4945 if (lpmi && (menu = MENU_GetMenu(hMenu)))
4946 {
4947
4948 if (lpmi->fMask & MIM_BACKGROUND)
4949 lpmi->hbrBack = menu->hbrBack;
4950
4951 if (lpmi->fMask & MIM_HELPID)
4952 lpmi->dwContextHelpID = menu->dwContextHelpID;
4953
4954 if (lpmi->fMask & MIM_MAXHEIGHT)
4955 lpmi->cyMax = menu->cyMax;
4956
4957 if (lpmi->fMask & MIM_MENUDATA)
4958 lpmi->dwMenuData = menu->dwMenuData;
4959
4960 if (lpmi->fMask & MIM_STYLE)
4961 lpmi->dwStyle = menu->dwStyle;
4962
4963 return TRUE;
4964 }
4965 return FALSE;
4966 }
4967
4968
4969 /**********************************************************************
4970 * SetMenuContextHelpId (USER32.@)
4971 */
4972 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4973 {
4974 LPPOPUPMENU menu;
4975
4976 TRACE("(%p 0x%08x)\n", hMenu, dwContextHelpID);
4977
4978 if ((menu = MENU_GetMenu(hMenu)))
4979 {
4980 menu->dwContextHelpID = dwContextHelpID;
4981 return TRUE;
4982 }
4983 return FALSE;
4984 }
4985
4986
4987 /**********************************************************************
4988 * GetMenuContextHelpId (USER32.@)
4989 */
4990 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4991 {
4992 LPPOPUPMENU menu;
4993
4994 TRACE("(%p)\n", hMenu);
4995
4996 if ((menu = MENU_GetMenu(hMenu)))
4997 {
4998 return menu->dwContextHelpID;
4999 }
5000 return 0;
5001 }
5002
5003 /**********************************************************************
5004 * MenuItemFromPoint (USER32.@)
5005 */
5006 INT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
5007 {
5008 POPUPMENU *menu = MENU_GetMenu(hMenu);
5009 UINT pos;
5010
5011 /*FIXME: Do we have to handle hWnd here? */
5012 if (!menu) return -1;
5013 if (!MENU_FindItemByCoords(menu, ptScreen, &pos)) return -1;
5014 return pos;
5015 }
5016
5017
5018 /**********************************************************************
5019 * translate_accelerator
5020 */
5021 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
5022 BYTE fVirt, WORD key, WORD cmd )
5023 {
5024 INT mask = 0;
5025 UINT mesg = 0;
5026
5027 if (wParam != key) return FALSE;
5028
5029 if (GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
5030 if (GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
5031 if (GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
5032
5033 if (message == WM_CHAR || message == WM_SYSCHAR)
5034 {
5035 if ( !(fVirt & FVIRTKEY) && (mask & FALT) == (fVirt & FALT) )
5036 {
5037 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
5038 goto found;
5039 }
5040 }
5041 else
5042 {
5043 if(fVirt & FVIRTKEY)
5044 {
5045 TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
5046 wParam, 0xff & HIWORD(lParam));
5047
5048 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
5049 TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
5050 }
5051 else
5052 {
5053 if (!(lParam & 0x01000000)) /* no special_key */
5054 {
5055 if ((fVirt & FALT) && (lParam & 0x20000000))
5056 { /* ^^ ALT pressed */
5057 TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
5058 goto found;
5059 }
5060 }
5061 }
5062 }
5063 return FALSE;
5064
5065 found:
5066 if (message == WM_KEYUP || message == WM_SYSKEYUP)
5067 mesg = 1;
5068 else
5069 {
5070 HMENU hMenu, hSubMenu, hSysMenu;
5071 UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
5072
5073 hMenu = (GetWindowLongW( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
5074 hSysMenu = get_win_sys_menu( hWnd );
5075
5076 /* find menu item and ask application to initialize it */
5077 /* 1. in the system menu */
5078 hSubMenu = hSysMenu;
5079 nPos = cmd;
5080 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
5081 {
5082 if (GetCapture())
5083 mesg = 2;
5084 if (!IsWindowEnabled(hWnd))
5085 mesg = 3;
5086 else
5087 {
5088 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
5089 if(hSubMenu != hSysMenu)
5090 {
5091 nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
5092 TRACE_(accel)("hSysMenu = %p, hSubMenu = %p, nPos = %d\n", hSysMenu, hSubMenu, nPos);
5093 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
5094 }
5095 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
5096 }
5097 }
5098 else /* 2. in the window's menu */
5099 {
5100 hSubMenu = hMenu;
5101 nPos = cmd;
5102 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
5103 {
5104 if (GetCapture())
5105 mesg = 2;
5106 if (!IsWindowEnabled(hWnd))
5107 mesg = 3;
5108 else
5109 {
5110 SendMessageW(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
5111 if(hSubMenu != hMenu)
5112 {
5113 nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
5114 TRACE_(accel)("hMenu = %p, hSubMenu = %p, nPos = %d\n", hMenu, hSubMenu, nPos);
5115 SendMessageW(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
5116 }
5117 uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
5118 }
5119 }
5120 }
5121
5122 if (mesg == 0)
5123 {
5124 if (uSysStat != (UINT)-1)
5125 {
5126 if (uSysStat & (MF_DISABLED|MF_GRAYED))
5127 mesg=4;
5128 else
5129 mesg=WM_SYSCOMMAND;
5130 }
5131 else
5132 {
5133 if (uStat != (UINT)-1)
5134 {
5135 if (IsIconic(hWnd))
5136 mesg=5;
5137 else
5138 {
5139 if (uStat & (MF_DISABLED|MF_GRAYED))
5140 mesg=6;
5141 else
5142 mesg=WM_COMMAND;
5143 }
5144 }
5145 else
5146 mesg=WM_COMMAND;
5147 }
5148 }
5149 }
5150
5151 if( mesg==WM_COMMAND )
5152 {
5153 TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
5154 SendMessageW(hWnd, mesg, 0x10000 | cmd, 0L);
5155 }
5156 else if( mesg==WM_SYSCOMMAND )
5157 {
5158 TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
5159 SendMessageW(hWnd, mesg, cmd, 0x00010000L);
5160 }
5161 else
5162 {
5163 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
5164 * #0: unknown (please report!)
5165 * #1: for WM_KEYUP,WM_SYSKEYUP
5166 * #2: mouse is captured
5167 * #3: window is disabled
5168 * #4: it's a disabled system menu option
5169 * #5: it's a menu option, but window is iconic
5170 * #6: it's a menu option, but disabled
5171 */
5172 TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
5173 if(mesg==0)
5174 ERR_(accel)(" unknown reason - please report!\n");
5175 }
5176 return TRUE;
5177 }
5178
5179 /**********************************************************************
5180 * TranslateAcceleratorA (USER32.@)
5181 * TranslateAccelerator (USER32.@)
5182 */
5183 INT WINAPI TranslateAcceleratorA( HWND hWnd, HACCEL hAccel, LPMSG msg )
5184 {
5185 /* YES, Accel16! */
5186 LPACCEL16 lpAccelTbl;
5187 int i;
5188 WPARAM wParam;
5189
5190 if (!hWnd || !msg) return 0;
5191
5192 if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
5193 {
5194 WARN_(accel)("invalid accel handle=%p\n", hAccel);
5195 return 0;
5196 }
5197
5198 wParam = msg->wParam;
5199
5200 switch (msg->message)
5201 {
5202 case WM_KEYDOWN:
5203 case WM_SYSKEYDOWN:
5204 break;
5205
5206 case WM_CHAR:
5207 case WM_SYSCHAR:
5208 {
5209 char ch = LOWORD(wParam);
5210 WCHAR wch;
5211 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
5212 wParam = MAKEWPARAM(wch, HIWORD(wParam));
5213 }
5214 break;
5215
5216 default:
5217 return 0;
5218 }
5219
5220 TRACE_(accel)("hAccel %p, hWnd %p, msg->hwnd %p, msg->message %04x, wParam %08x, lParam %08lx\n",
5221 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5222 i = 0;
5223 do
5224 {
5225 if (translate_accelerator( hWnd, msg->message, wParam, msg->lParam,
5226 lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
5227 return 1;
5228 } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
5229
5230 return 0;
5231 }
5232
5233 /**********************************************************************
5234 * TranslateAcceleratorW (USER32.@)
5235 */
5236 INT WINAPI TranslateAcceleratorW( HWND hWnd, HACCEL hAccel, LPMSG msg )
5237 {
5238 /* YES, Accel16! */
5239 LPACCEL16 lpAccelTbl;
5240 int i;
5241
5242 if (!hWnd || !msg) return 0;
5243
5244 if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(HACCEL_16(hAccel))))
5245 {
5246 WARN_(accel)("invalid accel handle=%p\n", hAccel);
5247 return 0;
5248 }
5249
5250 switch (msg->message)
5251 {
5252 case WM_KEYDOWN:
5253 case WM_SYSKEYDOWN:
5254 case WM_CHAR:
5255 case WM_SYSCHAR:
5256 break;
5257
5258 default:
5259 return 0;
5260 }
5261
5262 TRACE_(accel)("hAccel %p, hWnd %p, msg->hwnd %p, msg->message %04x, wParam %08x, lParam %08lx\n",
5263 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5264 i = 0;
5265 do
5266 {
5267 if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
5268 lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
5269 return 1;
5270 } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
5271
5272 return 0;
5273 }
GDI DIB driver