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