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