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