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