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