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