?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Do not modify pointers in the OPENFILENAME structure passed to
[wine/multimedia.git] / controls / menu.c
blobdcaedebdb8b0b429d4c123ce5e4fcb4cb4b09952
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 }
1378
1379 for (i = 0; lpitem->text[i]; i++)
1380 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
1381 break;
1382
1383 if( (TWEAK_WineLook != WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1384 {
1385 if (!(lpitem->fState & MF_HILITE) )
1386 {
1387 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1388 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1389 DrawTextW( hdc, lpitem->text, i, &rect, uFormat );
1390 --rect.left; --rect.top; --rect.right; --rect.bottom;
1391 }
1392 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1393 }
1394
1395 DrawTextW( hdc, lpitem->text, i, &rect, uFormat);
1396
1397 /* paint the shortcut text */
1398 if (!menuBar && lpitem->text[i]) /* There's a tab or flush-right char */
1399 {
1400 if (lpitem->text[i] == '\t')
1401 {
1402 rect.left = lpitem->xTab;
1403 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
1404 }
1405 else
1406 {
1407 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
1408 }
1409
1410 if( !(TWEAK_WineLook == WIN31_LOOK) && (lpitem->fState & MF_GRAYED))
1411 {
1412 if (!(lpitem->fState & MF_HILITE) )
1413 {
1414 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
1415 SetTextColor(hdc, RGB(0xff, 0xff, 0xff));
1416 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1417 --rect.left; --rect.top; --rect.right; --rect.bottom;
1418 }
1419 SetTextColor(hdc, RGB(0x80, 0x80, 0x80));
1420 }
1421 DrawTextW( hdc, lpitem->text + i + 1, -1, &rect, uFormat );
1422 }
1423
1424 if (hfontOld)
1425 SelectObject (hdc, hfontOld);
1426 }
1427 }
1428
1429
1430 /***********************************************************************
1431 * MENU_DrawPopupMenu
1432 *
1433 * Paint a popup menu.
1434 */
1435 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
1436 {
1437 HBRUSH hPrevBrush = 0;
1438 RECT rect;
1439
1440 TRACE("wnd=0x%04x dc=0x%04x menu=0x%04x\n", hwnd, hdc, hmenu);
1441
1442 GetClientRect( hwnd, &rect );
1443
1444 if(TWEAK_WineLook == WIN31_LOOK)
1445 {
1446 rect.bottom -= POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1447 rect.right -= POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER);
1448 }
1449
1450 if((hPrevBrush = SelectObject( hdc, GetSysColorBrush(COLOR_MENU) ))
1451 && (SelectObject( hdc, hMenuFont)))
1452 {
1453 HPEN hPrevPen;
1454
1455 Rectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
1456
1457 hPrevPen = SelectObject( hdc, GetStockObject( NULL_PEN ) );
1458 if( hPrevPen )
1459 {
1460 INT ropPrev, i;
1461 POPUPMENU *menu;
1462
1463 /* draw 3-d shade */
1464 if(TWEAK_WineLook == WIN31_LOOK) {
1465 SelectObject( hdc, hShadeBrush );
1466 SetBkMode( hdc, TRANSPARENT );
1467 ropPrev = SetROP2( hdc, R2_MASKPEN );
1468
1469 i = rect.right; /* why SetBrushOrg() doesn't? */
1470 PatBlt( hdc, i & 0xfffffffe,
1471 rect.top + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER),
1472 i%2 + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1473 rect.bottom - rect.top, 0x00a000c9 );
1474 i = rect.bottom;
1475 PatBlt( hdc, rect.left + POPUP_XSHADE*GetSystemMetrics(SM_CXBORDER),
1476 i & 0xfffffffe,rect.right - rect.left,
1477 i%2 + POPUP_YSHADE*GetSystemMetrics(SM_CYBORDER), 0x00a000c9 );
1478 SelectObject( hdc, hPrevPen );
1479 SelectObject( hdc, hPrevBrush );
1480 SetROP2( hdc, ropPrev );
1481 }
1482 else
1483 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
1484
1485 /* draw menu items */
1486
1487 menu = MENU_GetMenu( hmenu );
1488 if (menu && menu->nItems)
1489 {
1490 MENUITEM *item;
1491 UINT u;
1492
1493 for (u = menu->nItems, item = menu->items; u > 0; u--, item++)
1494 MENU_DrawMenuItem( hwnd, hmenu, menu->hwndOwner, hdc, item,
1495 menu->Height, FALSE, ODA_DRAWENTIRE );
1496
1497 }
1498 } else
1499 {
1500 SelectObject( hdc, hPrevBrush );
1501 }
1502 }
1503 }
1504
1505 /***********************************************************************
1506 * MENU_DrawMenuBar
1507 *
1508 * Paint a menu bar. Returns the height of the menu bar.
1509 * called from [windows/nonclient.c]
1510 */
1511 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, HWND hwnd,
1512 BOOL suppress_draw)
1513 {
1514 LPPOPUPMENU lppop;
1515 UINT i,retvalue;
1516 HFONT hfontOld = 0;
1517 HMENU hMenu = GetMenu(hwnd);
1518
1519 lppop = MENU_GetMenu( hMenu );
1520 if (lppop == NULL || lprect == NULL)
1521 {
1522 retvalue = GetSystemMetrics(SM_CYMENU);
1523 goto END;
1524 }
1525
1526 TRACE("(%04x, %p, %p)\n", hDC, lprect, lppop);
1527
1528 hfontOld = SelectObject( hDC, hMenuFont);
1529
1530 if (lppop->Height == 0)
1531 MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
1532
1533 lprect->bottom = lprect->top + lppop->Height;
1534
1535 if (suppress_draw)
1536 {
1537 retvalue = lppop->Height;
1538 goto END;
1539 }
1540
1541 FillRect(hDC, lprect, GetSysColorBrush(COLOR_MENU) );
1542
1543 if (TWEAK_WineLook == WIN31_LOOK)
1544 {
1545 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1546 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1547 LineTo( hDC, lprect->right, lprect->bottom );
1548 }
1549 else
1550 {
1551 SelectObject( hDC, SYSCOLOR_GetPen(COLOR_3DFACE));
1552 MoveToEx( hDC, lprect->left, lprect->bottom, NULL );
1553 LineTo( hDC, lprect->right, lprect->bottom );
1554 }
1555
1556 if (lppop->nItems == 0)
1557 {
1558 retvalue = GetSystemMetrics(SM_CYMENU);
1559 goto END;
1560 }
1561
1562 for (i = 0; i < lppop->nItems; i++)
1563 {
1564 MENU_DrawMenuItem( hwnd, hMenu, hwnd,
1565 hDC, &lppop->items[i], lppop->Height, TRUE, ODA_DRAWENTIRE );
1566 }
1567 retvalue = lppop->Height;
1568
1569 END:
1570 if (hfontOld) SelectObject (hDC, hfontOld);
1571 return retvalue;
1572 }
1573
1574
1575 /***********************************************************************
1576 * MENU_ShowPopup
1577 *
1578 * Display a popup menu.
1579 */
1580 static BOOL MENU_ShowPopup( HWND hwndOwner, HMENU hmenu, UINT id,
1581 INT x, INT y, INT xanchor, INT yanchor )
1582 {
1583 POPUPMENU *menu;
1584 UINT width, height;
1585
1586 TRACE("owner=0x%04x hmenu=0x%04x id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
1587 hwndOwner, hmenu, id, x, y, xanchor, yanchor);
1588
1589 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
1590 if (menu->FocusedItem != NO_SELECTED_ITEM)
1591 {
1592 menu->items[menu->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1593 menu->FocusedItem = NO_SELECTED_ITEM;
1594 }
1595
1596 /* store the owner for DrawItem */
1597 menu->hwndOwner = hwndOwner;
1598
1599
1600 MENU_PopupMenuCalcSize( menu, hwndOwner );
1601
1602 /* adjust popup menu pos so that it fits within the desktop */
1603
1604 width = menu->Width + GetSystemMetrics(SM_CXBORDER);
1605 height = menu->Height + GetSystemMetrics(SM_CYBORDER);
1606
1607 if( x + width > GetSystemMetrics(SM_CXSCREEN ))
1608 {
1609 if( xanchor )
1610 x -= width - xanchor;
1611 if( x + width > GetSystemMetrics(SM_CXSCREEN))
1612 x = GetSystemMetrics(SM_CXSCREEN) - width;
1613 }
1614 if( x < 0 ) x = 0;
1615
1616 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1617 {
1618 if( yanchor )
1619 y -= height + yanchor;
1620 if( y + height > GetSystemMetrics(SM_CYSCREEN ))
1621 y = GetSystemMetrics(SM_CYSCREEN) - height;
1622 }
1623 if( y < 0 ) y = 0;
1624
1625 if( TWEAK_WineLook == WIN31_LOOK )
1626 {
1627 width += POPUP_XSHADE * GetSystemMetrics(SM_CXBORDER); /* add space for shading */
1628 height += POPUP_YSHADE * GetSystemMetrics(SM_CYBORDER);
1629 }
1630
1631 /* NOTE: In Windows, top menu popup is not owned. */
1632 menu->hWnd = CreateWindowA( POPUPMENU_CLASS_ATOM, NULL,
1633 WS_POPUP, x, y, width, height,
1634 hwndOwner, 0, GetWindowLongA(hwndOwner,GWL_HINSTANCE),
1635 (LPVOID)hmenu );
1636 if( !menu->hWnd ) return FALSE;
1637 if (!top_popup) top_popup = menu->hWnd;
1638
1639 /* Display the window */
1640
1641 SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
1642 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1643 UpdateWindow( menu->hWnd );
1644 return TRUE;
1645 }
1646
1647
1648 /***********************************************************************
1649 * MENU_SelectItem
1650 */
1651 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
1652 BOOL sendMenuSelect, HMENU topmenu )
1653 {
1654 LPPOPUPMENU lppop;
1655 HDC hdc;
1656
1657 TRACE("owner=0x%04x menu=0x%04x index=0x%04x select=0x%04x\n", hwndOwner, hmenu, wIndex, sendMenuSelect);
1658
1659 lppop = MENU_GetMenu( hmenu );
1660 if ((!lppop) || (!lppop->nItems) || (!lppop->hWnd)) return;
1661
1662 if (lppop->FocusedItem == wIndex) return;
1663 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
1664 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
1665 if (!top_popup) top_popup = lppop->hWnd;
1666
1667 SelectObject( hdc, hMenuFont);
1668
1669 /* Clear previous highlighted item */
1670 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1671 {
1672 lppop->items[lppop->FocusedItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
1673 MENU_DrawMenuItem(lppop->hWnd, hmenu, hwndOwner, hdc,&lppop->items[lppop->FocusedItem],
1674 lppop->Height, !(lppop->wFlags & MF_POPUP),
1675 ODA_SELECT );
1676 }
1677
1678 /* Highlight new item (if any) */
1679 lppop->FocusedItem = wIndex;
1680 if (lppop->FocusedItem != NO_SELECTED_ITEM)
1681 {
1682 if(!(lppop->items[wIndex].fType & MF_SEPARATOR)) {
1683 lppop->items[wIndex].fState |= MF_HILITE;
1684 MENU_DrawMenuItem( lppop->hWnd, hmenu, hwndOwner, hdc,
1685 &lppop->items[wIndex], lppop->Height,
1686 !(lppop->wFlags & MF_POPUP), ODA_SELECT );
1687 }
1688 if (sendMenuSelect)
1689 {
1690 MENUITEM *ip = &lppop->items[lppop->FocusedItem];
1691 SendMessageA( hwndOwner, WM_MENUSELECT,
1692 MAKELONG(ip->fType & MF_POPUP ? wIndex: ip->wID,
1693 ip->fType | ip->fState | MF_MOUSESELECT |
1694 (lppop->wFlags & MF_SYSMENU)), hmenu);
1695 }
1696 }
1697 else if (sendMenuSelect) {
1698 if(topmenu){
1699 int pos;
1700 if((pos=MENU_FindSubMenu(&topmenu, hmenu))!=NO_SELECTED_ITEM){
1701 POPUPMENU *ptm = MENU_GetMenu( topmenu );
1702 MENUITEM *ip = &ptm->items[pos];
1703 SendMessageA( hwndOwner, WM_MENUSELECT, MAKELONG(pos,
1704 ip->fType | ip->fState | MF_MOUSESELECT |
1705 (ptm->wFlags & MF_SYSMENU)), topmenu);
1706 }
1707 }
1708 }
1709 ReleaseDC( lppop->hWnd, hdc );
1710 }
1711
1712
1713 /***********************************************************************
1714 * MENU_MoveSelection
1715 *
1716 * Moves currently selected item according to the offset parameter.
1717 * If there is no selection then it should select the last item if
1718 * offset is ITEM_PREV or the first item if offset is ITEM_NEXT.
1719 */
1720 static void MENU_MoveSelection( HWND hwndOwner, HMENU hmenu, INT offset )
1721 {
1722 INT i;
1723 POPUPMENU *menu;
1724
1725 TRACE("hwnd=0x%04x hmenu=0x%04x off=0x%04x\n", hwndOwner, hmenu, offset);
1726
1727 menu = MENU_GetMenu( hmenu );
1728 if ((!menu) || (!menu->items)) return;
1729
1730 if ( menu->FocusedItem != NO_SELECTED_ITEM )
1731 {
1732 if( menu->nItems == 1 ) return; else
1733 for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems
1734 ; i += offset)
1735 if (!(menu->items[i].fType & MF_SEPARATOR))
1736 {
1737 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1738 return;
1739 }
1740 }
1741
1742 for ( i = (offset > 0) ? 0 : menu->nItems - 1;
1743 i >= 0 && i < menu->nItems ; i += offset)
1744 if (!(menu->items[i].fType & MF_SEPARATOR))
1745 {
1746 MENU_SelectItem( hwndOwner, hmenu, i, TRUE, 0 );
1747 return;
1748 }
1749 }
1750
1751
1752 /**********************************************************************
1753 * MENU_SetItemData
1754 *
1755 * Set an item flags, id and text ptr. Called by InsertMenu() and
1756 * ModifyMenu().
1757 */
1758 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT id,
1759 LPCWSTR str )
1760 {
1761 LPWSTR prevText = IS_STRING_ITEM(item->fType) ? item->text : NULL;
1762
1763 debug_print_menuitem("MENU_SetItemData from: ", item, "");
1764 TRACE("flags=%x str=%p\n", flags, str);
1765
1766 if (IS_STRING_ITEM(flags))
1767 {
1768 if (!str)
1769 {
1770 flags |= MF_SEPARATOR;
1771 item->text = NULL;
1772 }
1773 else
1774 {
1775 LPWSTR text;
1776 /* Item beginning with a backspace is a help item */
1777 if (*str == '\b')
1778 {
1779 flags |= MF_HELP;
1780 str++;
1781 }
1782 if (!(text = HeapAlloc( GetProcessHeap(), 0, (strlenW(str)+1) * sizeof(WCHAR) )))
1783 return FALSE;
1784 strcpyW( text, str );
1785 item->text = text;
1786 }
1787 }
1788 else if (IS_BITMAP_ITEM(flags))
1789 item->text = (LPWSTR)(HBITMAP)LOWORD(str);
1790 else item->text = NULL;
1791
1792 if (flags & MF_OWNERDRAW)
1793 item->dwItemData = (DWORD)str;
1794 else
1795 item->dwItemData = 0;
1796
1797 if ((item->fType & MF_POPUP) && (flags & MF_POPUP) && (item->hSubMenu != id) )
1798 DestroyMenu( item->hSubMenu ); /* ModifyMenu() spec */
1799
1800 if (flags & MF_POPUP)
1801 {
1802 POPUPMENU *menu = MENU_GetMenu((UINT16)id);
1803 if (menu) menu->wFlags |= MF_POPUP;
1804 else
1805 {
1806 item->wID = 0;
1807 item->hSubMenu = 0;
1808 item->fType = 0;
1809 item->fState = 0;
1810 return FALSE;
1811 }
1812 }
1813
1814 item->wID = id;
1815 if (flags & MF_POPUP)
1816 item->hSubMenu = id;
1817
1818 if ((item->fType & MF_POPUP) && !(flags & MF_POPUP) )
1819 flags |= MF_POPUP; /* keep popup */
1820
1821 item->fType = flags & TYPE_MASK;
1822 item->fState = (flags & STATE_MASK) &
1823 ~(MF_HILITE | MF_MOUSESELECT | MF_BYPOSITION);
1824
1825
1826 /* Don't call SetRectEmpty here! */
1827
1828
1829 if (prevText) HeapFree( GetProcessHeap(), 0, prevText );
1830
1831 debug_print_menuitem("MENU_SetItemData to : ", item, "");
1832 return TRUE;
1833 }
1834
1835
1836 /**********************************************************************
1837 * MENU_InsertItem
1838 *
1839 * Insert a new item into a menu.
1840 */
1841 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1842 {
1843 MENUITEM *newItems;
1844 POPUPMENU *menu;
1845
1846 if (!(menu = MENU_GetMenu(hMenu)))
1847 return NULL;
1848
1849 /* Find where to insert new item */
1850
1851 if (flags & MF_BYPOSITION) {
1852 if (pos > menu->nItems)
1853 pos = menu->nItems;
1854 } else {
1855 if (!MENU_FindItem( &hMenu, &pos, flags ))
1856 pos = menu->nItems;
1857 else {
1858 if (!(menu = MENU_GetMenu( hMenu )))
1859 return NULL;
1860 }
1861 }
1862
1863 /* Create new items array */
1864
1865 newItems = HeapAlloc( GetProcessHeap(), 0, sizeof(MENUITEM) * (menu->nItems+1) );
1866 if (!newItems)
1867 {
1868 WARN("allocation failed\n" );
1869 return NULL;
1870 }
1871 if (menu->nItems > 0)
1872 {
1873 /* Copy the old array into the new one */
1874 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1875 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1876 (menu->nItems-pos)*sizeof(MENUITEM) );
1877 HeapFree( GetProcessHeap(), 0, menu->items );
1878 }
1879 menu->items = newItems;
1880 menu->nItems++;
1881 memset( &newItems[pos], 0, sizeof(*newItems) );
1882 menu->Height = 0; /* force size recalculate */
1883 return &newItems[pos];
1884 }
1885
1886
1887 /**********************************************************************
1888 * MENU_ParseResource
1889 *
1890 * Parse a standard menu resource and add items to the menu.
1891 * Return a pointer to the end of the resource.
1892 */
1893 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1894 {
1895 WORD flags, id = 0;
1896 LPCSTR str;
1897
1898 do
1899 {
1900 flags = GET_WORD(res);
1901 res += sizeof(WORD);
1902 if (!(flags & MF_POPUP))
1903 {
1904 id = GET_WORD(res);
1905 res += sizeof(WORD);
1906 }
1907 if (!IS_STRING_ITEM(flags))
1908 ERR("not a string item %04x\n", flags );
1909 str = res;
1910 if (!unicode) res += strlen(str) + 1;
1911 else res += (strlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
1912 if (flags & MF_POPUP)
1913 {
1914 HMENU hSubMenu = CreatePopupMenu();
1915 if (!hSubMenu) return NULL;
1916 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1917 return NULL;
1918 if (!unicode) AppendMenuA( hMenu, flags, (UINT)hSubMenu, str );
1919 else AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1920 }
1921 else /* Not a popup */
1922 {
1923 if (!unicode) AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1924 else AppendMenuW( hMenu, flags, id,
1925 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1926 }
1927 } while (!(flags & MF_END));
1928 return res;
1929 }
1930
1931
1932 /**********************************************************************
1933 * MENUEX_ParseResource
1934 *
1935 * Parse an extended menu resource and add items to the menu.
1936 * Return a pointer to the end of the resource.
1937 */
1938 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
1939 {
1940 WORD resinfo;
1941 do {
1942 MENUITEMINFOW mii;
1943
1944 mii.cbSize = sizeof(mii);
1945 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
1946 mii.fType = GET_DWORD(res);
1947 res += sizeof(DWORD);
1948 mii.fState = GET_DWORD(res);
1949 res += sizeof(DWORD);
1950 mii.wID = GET_DWORD(res);
1951 res += sizeof(DWORD);
1952 resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte. */
1953 res += sizeof(WORD);
1954 /* Align the text on a word boundary. */
1955 res += (~((int)res - 1)) & 1;
1956 mii.dwTypeData = (LPWSTR) res;
1957 res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
1958 /* Align the following fields on a dword boundary. */
1959 res += (~((int)res - 1)) & 3;
1960
1961 TRACE("Menu item: [%08x,%08x,%04x,%04x,%s]\n",
1962 mii.fType, mii.fState, mii.wID, resinfo, debugstr_w(mii.dwTypeData));
1963
1964 if (resinfo & 1) { /* Pop-up? */
1965 /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
1966 res += sizeof(DWORD);
1967 mii.hSubMenu = CreatePopupMenu();
1968 if (!mii.hSubMenu)
1969 return NULL;
1970 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
1971 DestroyMenu(mii.hSubMenu);
1972 return NULL;
1973 }
1974 mii.fMask |= MIIM_SUBMENU;
1975 mii.fType |= MF_POPUP;
1976 }
1977 else if(!*mii.dwTypeData && !(mii.fType & MF_SEPARATOR))
1978 {
1979 WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
1980 mii.wID, mii.fType);
1981 mii.fType |= MF_SEPARATOR;
1982 }
1983 InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
1984 } while (!(resinfo & MF_END));
1985 return res;
1986 }
1987
1988
1989 /***********************************************************************
1990 * MENU_GetSubPopup
1991 *
1992 * Return the handle of the selected sub-popup menu (if any).
1993 */
1994 static HMENU MENU_GetSubPopup( HMENU hmenu )
1995 {
1996 POPUPMENU *menu;
1997 MENUITEM *item;
1998
1999 menu = MENU_GetMenu( hmenu );
2000
2001 if ((!menu) || (menu->FocusedItem == NO_SELECTED_ITEM)) return 0;
2002
2003 item = &menu->items[menu->FocusedItem];
2004 if ((item->fType & MF_POPUP) && (item->fState & MF_MOUSESELECT))
2005 return item->hSubMenu;
2006 return 0;
2007 }
2008
2009
2010 /***********************************************************************
2011 * MENU_HideSubPopups
2012 *
2013 * Hide the sub-popup menus of this menu.
2014 */
2015 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
2016 BOOL sendMenuSelect )
2017 {
2018 POPUPMENU *menu = MENU_GetMenu( hmenu );
2019
2020 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, sendMenuSelect);
2021
2022 if (menu && top_popup)
2023 {
2024 HMENU hsubmenu;
2025 POPUPMENU *submenu;
2026 MENUITEM *item;
2027
2028 if (menu->FocusedItem != NO_SELECTED_ITEM)
2029 {
2030 item = &menu->items[menu->FocusedItem];
2031 if (!(item->fType & MF_POPUP) ||
2032 !(item->fState & MF_MOUSESELECT)) return;
2033 item->fState &= ~MF_MOUSESELECT;
2034 hsubmenu = item->hSubMenu;
2035 } else return;
2036
2037 submenu = MENU_GetMenu( hsubmenu );
2038 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
2039 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect, 0 );
2040 DestroyWindow( submenu->hWnd );
2041 submenu->hWnd = 0;
2042 }
2043 }
2044
2045
2046 /***********************************************************************
2047 * MENU_ShowSubPopup
2048 *
2049 * Display the sub-menu of the selected item of this menu.
2050 * Return the handle of the submenu, or hmenu if no submenu to display.
2051 */
2052 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu,
2053 BOOL selectFirst, UINT wFlags )
2054 {
2055 RECT rect;
2056 POPUPMENU *menu;
2057 MENUITEM *item;
2058 HDC hdc;
2059
2060 TRACE("owner=0x%04x hmenu=0x%04x 0x%04x\n", hwndOwner, hmenu, selectFirst);
2061
2062 if (!(menu = MENU_GetMenu( hmenu ))) return hmenu;
2063
2064 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
2065
2066 item = &menu->items[menu->FocusedItem];
2067 if (!(item->fType & MF_POPUP) || (item->fState & (MF_GRAYED | MF_DISABLED)))
2068 return hmenu;
2069
2070 /* message must be sent before using item,
2071 because nearly everything may be changed by the application ! */
2072
2073 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
2074 if (!(wFlags & TPM_NONOTIFY))
2075 SendMessageA( hwndOwner, WM_INITMENUPOPUP, item->hSubMenu,
2076 MAKELONG( menu->FocusedItem, IS_SYSTEM_MENU(menu) ));
2077
2078 item = &menu->items[menu->FocusedItem];
2079 rect = item->rect;
2080
2081 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
2082 if (!(item->fState & MF_HILITE))
2083 {
2084 if (menu->wFlags & MF_POPUP) hdc = GetDC( menu->hWnd );
2085 else hdc = GetDCEx( menu->hWnd, 0, DCX_CACHE | DCX_WINDOW);
2086
2087 SelectObject( hdc, hMenuFont);
2088
2089 item->fState |= MF_HILITE;
2090 MENU_DrawMenuItem( menu->hWnd, hmenu, hwndOwner, hdc, item, menu->Height, !(menu->wFlags & MF_POPUP), ODA_DRAWENTIRE );
2091 ReleaseDC( menu->hWnd, hdc );
2092 }
2093 if (!item->rect.top && !item->rect.left && !item->rect.bottom && !item->rect.right)
2094 item->rect = rect;
2095
2096 item->fState |= MF_MOUSESELECT;
2097
2098 if (IS_SYSTEM_MENU(menu))
2099 {
2100 MENU_InitSysMenuPopup(item->hSubMenu,
2101 GetWindowLongA( menu->hWnd, GWL_STYLE ),
2102 GetClassLongA( menu->hWnd, GCL_STYLE));
2103
2104 NC_GetSysPopupPos( menu->hWnd, &rect );
2105 rect.top = rect.bottom;
2106 rect.right = GetSystemMetrics(SM_CXSIZE);
2107 rect.bottom = GetSystemMetrics(SM_CYSIZE);
2108 }
2109 else
2110 {
2111 GetWindowRect( menu->hWnd, &rect );
2112 if (menu->wFlags & MF_POPUP)
2113 {
2114 rect.left += item->rect.right - GetSystemMetrics(SM_CXBORDER);
2115 rect.top += item->rect.top;
2116 rect.right = item->rect.left - item->rect.right + GetSystemMetrics(SM_CXBORDER);
2117 rect.bottom = item->rect.top - item->rect.bottom;
2118 }
2119 else
2120 {
2121 rect.left += item->rect.left;
2122 rect.top += item->rect.bottom;
2123 rect.right = item->rect.right - item->rect.left;
2124 rect.bottom = item->rect.bottom - item->rect.top;
2125 }
2126 }
2127
2128 MENU_ShowPopup( hwndOwner, item->hSubMenu, menu->FocusedItem,
2129 rect.left, rect.top, rect.right, rect.bottom );
2130 if (selectFirst)
2131 MENU_MoveSelection( hwndOwner, item->hSubMenu, ITEM_NEXT );
2132 return item->hSubMenu;
2133 }
2134
2135
2136
2137 /**********************************************************************
2138 * MENU_IsMenuActive
2139 */
2140 BOOL MENU_IsMenuActive(void)
2141 {
2142 return (top_popup != 0);
2143 }
2144
2145 /***********************************************************************
2146 * MENU_PtMenu
2147 *
2148 * Walks menu chain trying to find a menu pt maps to.
2149 */
2150 static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
2151 {
2152 POPUPMENU *menu = MENU_GetMenu( hMenu );
2153 UINT item = menu->FocusedItem;
2154 HMENU ret;
2155
2156 /* try subpopup first (if any) */
2157 ret = (item != NO_SELECTED_ITEM &&
2158 (menu->items[item].fType & MF_POPUP) &&
2159 (menu->items[item].fState & MF_MOUSESELECT))
2160 ? MENU_PtMenu(menu->items[item].hSubMenu, pt) : 0;
2161
2162 if (!ret) /* check the current window (avoiding WM_HITTEST) */
2163 {
2164 INT ht = NC_HandleNCHitTest( menu->hWnd, pt );
2165 if( menu->wFlags & MF_POPUP )
2166 {
2167 if (ht != HTNOWHERE && ht != HTERROR) ret = hMenu;
2168 }
2169 else if (ht == HTSYSMENU)
2170 ret = get_win_sys_menu( menu->hWnd );
2171 else if (ht == HTMENU)
2172 ret = GetMenu( menu->hWnd );
2173 }
2174 return ret;
2175 }
2176
2177 /***********************************************************************
2178 * MENU_ExecFocusedItem
2179 *
2180 * Execute a menu item (for instance when user pressed Enter).
2181 * Return the wID of the executed item. Otherwise, -1 indicating
2182 * that no menu item was executed;
2183 * Have to receive the flags for the TrackPopupMenu options to avoid
2184 * sending unwanted message.
2185 *
2186 */
2187 static INT MENU_ExecFocusedItem( MTRACKER* pmt, HMENU hMenu, UINT wFlags )
2188 {
2189 MENUITEM *item;
2190 POPUPMENU *menu = MENU_GetMenu( hMenu );
2191
2192 TRACE("%p hmenu=0x%04x\n", pmt, hMenu);
2193
2194 if (!menu || !menu->nItems ||
2195 (menu->FocusedItem == NO_SELECTED_ITEM)) return -1;
2196
2197 item = &menu->items[menu->FocusedItem];
2198
2199 TRACE("%08x %08x %08x\n",
2200 hMenu, item->wID, item->hSubMenu);
2201
2202 if (!(item->fType & MF_POPUP))
2203 {
2204 if (!(item->fState & (MF_GRAYED | MF_DISABLED)) && !(item->fType & MF_SEPARATOR))
2205 {
2206 /* If TPM_RETURNCMD is set you return the id, but
2207 do not send a message to the owner */
2208 if(!(wFlags & TPM_RETURNCMD))
2209 {
2210 if( menu->wFlags & MF_SYSMENU )
2211 PostMessageA( pmt->hOwnerWnd, WM_SYSCOMMAND, item->wID,
2212 MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) );
2213 else
2214 PostMessageA( pmt->hOwnerWnd, WM_COMMAND, item->wID, 0 );
2215 }
2216 return item->wID;
2217 }
2218 }
2219 else
2220 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hMenu, TRUE, wFlags);
2221
2222 return -1;
2223 }
2224
2225 /***********************************************************************
2226 * MENU_SwitchTracking
2227 *
2228 * Helper function for menu navigation routines.
2229 */
2230 static void MENU_SwitchTracking( MTRACKER* pmt, HMENU hPtMenu, UINT id )
2231 {
2232 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2233 POPUPMENU *topmenu = MENU_GetMenu( pmt->hTopMenu );
2234
2235 TRACE("%p hmenu=0x%04x 0x%04x\n", pmt, hPtMenu, id);
2236
2237 if( pmt->hTopMenu != hPtMenu &&
2238 !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) )
2239 {
2240 /* both are top level menus (system and menu-bar) */
2241 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2242 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2243 pmt->hTopMenu = hPtMenu;
2244 }
2245 else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE );
2246 MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE, 0 );
2247 }
2248
2249
2250 /***********************************************************************
2251 * MENU_ButtonDown
2252 *
2253 * Return TRUE if we can go on with menu tracking.
2254 */
2255 static BOOL MENU_ButtonDown( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2256 {
2257 TRACE("%p hmenu=0x%04x\n", pmt, hPtMenu);
2258
2259 if (hPtMenu)
2260 {
2261 UINT id = 0;
2262 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2263 MENUITEM *item;
2264
2265 if( IS_SYSTEM_MENU(ptmenu) )
2266 item = ptmenu->items;
2267 else
2268 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2269
2270 if( item )
2271 {
2272 if( ptmenu->FocusedItem != id )
2273 MENU_SwitchTracking( pmt, hPtMenu, id );
2274
2275 /* If the popup menu is not already "popped" */
2276 if(!(item->fState & MF_MOUSESELECT ))
2277 {
2278 pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE, wFlags );
2279
2280 /* In win31, a newly popped menu always remains opened for the next buttonup */
2281 if(TWEAK_WineLook == WIN31_LOOK)
2282 ptmenu->bTimeToHide = FALSE;
2283 }
2284
2285 return TRUE;
2286 }
2287 /* Else the click was on the menu bar, finish the tracking */
2288 }
2289 return FALSE;
2290 }
2291
2292 /***********************************************************************
2293 * MENU_ButtonUp
2294 *
2295 * Return the value of MENU_ExecFocusedItem if
2296 * the selected item was not a popup. Else open the popup.
2297 * A -1 return value indicates that we go on with menu tracking.
2298 *
2299 */
2300 static INT MENU_ButtonUp( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags)
2301 {
2302 TRACE("%p hmenu=0x%04x\n", pmt, hPtMenu);
2303
2304 if (hPtMenu)
2305 {
2306 UINT id = 0;
2307 POPUPMENU *ptmenu = MENU_GetMenu( hPtMenu );
2308 MENUITEM *item;
2309
2310 if( IS_SYSTEM_MENU(ptmenu) )
2311 item = ptmenu->items;
2312 else
2313 item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2314
2315 if( item && (ptmenu->FocusedItem == id ))
2316 {
2317 if( !(item->fType & MF_POPUP) )
2318 return MENU_ExecFocusedItem( pmt, hPtMenu, wFlags);
2319
2320 /* If we are dealing with the top-level menu */
2321 /* and this is a click on an already "popped" item: */
2322 /* Stop the menu tracking and close the opened submenus */
2323 if((pmt->hTopMenu == hPtMenu) && (ptmenu->bTimeToHide == TRUE))
2324 return 0;
2325 }
2326 ptmenu->bTimeToHide = TRUE;
2327 }
2328 return -1;
2329 }
2330
2331
2332 /***********************************************************************
2333 * MENU_MouseMove
2334 *
2335 * Return TRUE if we can go on with menu tracking.
2336 */
2337 static BOOL MENU_MouseMove( MTRACKER* pmt, HMENU hPtMenu, UINT wFlags )
2338 {
2339 UINT id = NO_SELECTED_ITEM;
2340 POPUPMENU *ptmenu = NULL;
2341
2342 if( hPtMenu )
2343 {
2344 ptmenu = MENU_GetMenu( hPtMenu );
2345 if( IS_SYSTEM_MENU(ptmenu) )
2346 id = 0;
2347 else
2348 MENU_FindItemByCoords( ptmenu, pmt->pt, &id );
2349 }
2350
2351 if( id == NO_SELECTED_ITEM )
2352 {
2353 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2354 NO_SELECTED_ITEM, TRUE, pmt->hTopMenu);
2355
2356 }
2357 else if( ptmenu->FocusedItem != id )
2358 {
2359 MENU_SwitchTracking( pmt, hPtMenu, id );
2360 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hPtMenu, FALSE, wFlags);
2361 }
2362 return TRUE;
2363 }
2364
2365
2366 /***********************************************************************
2367 * MENU_DoNextMenu
2368 *
2369 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
2370 */
2371 static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT vk )
2372 {
2373 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2374
2375 if( (vk == VK_LEFT && menu->FocusedItem == 0 ) ||
2376 (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1))
2377 {
2378 MDINEXTMENU next_menu;
2379 HMENU hNewMenu;
2380 HWND hNewWnd;
2381 UINT id = 0;
2382
2383 next_menu.hmenuIn = (IS_SYSTEM_MENU(menu)) ? GetSubMenu(pmt->hTopMenu,0) : pmt->hTopMenu;
2384 next_menu.hmenuNext = 0;
2385 next_menu.hwndNext = 0;
2386 SendMessageW( pmt->hOwnerWnd, WM_NEXTMENU, vk, (LPARAM)&next_menu );
2387
2388 TRACE("%04x [%04x] -> %04x [%04x]\n",
2389 pmt->hCurrentMenu, pmt->hOwnerWnd, next_menu.hmenuNext, next_menu.hwndNext );
2390
2391 if (!next_menu.hmenuNext || !next_menu.hwndNext)
2392 {
2393 DWORD style = GetWindowLongA( pmt->hOwnerWnd, GWL_STYLE );
2394 hNewWnd = pmt->hOwnerWnd;
2395 if( IS_SYSTEM_MENU(menu) )
2396 {
2397 /* switch to the menu bar */
2398
2399 if(style & WS_CHILD || !(hNewMenu = GetMenu(hNewWnd))) return FALSE;
2400
2401 if( vk == VK_LEFT )
2402 {
2403 menu = MENU_GetMenu( hNewMenu );
2404 id = menu->nItems - 1;
2405 }
2406 }
2407 else if (style & WS_SYSMENU )
2408 {
2409 /* switch to the system menu */
2410 hNewMenu = get_win_sys_menu( hNewWnd );
2411 }
2412 else return FALSE;
2413 }
2414 else /* application returned a new menu to switch to */
2415 {
2416 hNewMenu = next_menu.hmenuNext;
2417 hNewWnd = WIN_GetFullHandle( next_menu.hwndNext );
2418
2419 if( IsMenu(hNewMenu) && IsWindow(hNewWnd) )
2420 {
2421 DWORD style = GetWindowLongA( hNewWnd, GWL_STYLE );
2422
2423 if (style & WS_SYSMENU &&
2424 GetSubMenu(get_win_sys_menu(hNewWnd), 0) == hNewMenu )
2425 {
2426 /* get the real system menu */
2427 hNewMenu = get_win_sys_menu(hNewWnd);
2428 }
2429 else if (style & WS_CHILD || GetMenu(hNewWnd) != hNewMenu )
2430 {
2431 /* FIXME: Not sure what to do here;
2432 * perhaps try to track hNewMenu as a popup? */
2433
2434 TRACE(" -- got confused.\n");
2435 return FALSE;
2436 }
2437 }
2438 else return FALSE;
2439 }
2440
2441 if( hNewMenu != pmt->hTopMenu )
2442 {
2443 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM,
2444 FALSE, 0 );
2445 if( pmt->hCurrentMenu != pmt->hTopMenu )
2446 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2447 }
2448
2449 if( hNewWnd != pmt->hOwnerWnd )
2450 {
2451 ReleaseCapture();
2452 pmt->hOwnerWnd = hNewWnd;
2453 EVENT_Capture( pmt->hOwnerWnd, HTMENU );
2454 }
2455
2456 pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */
2457 MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE, 0 );
2458
2459 return TRUE;
2460 }
2461 return FALSE;
2462 }
2463
2464 /***********************************************************************
2465 * MENU_SuspendPopup
2466 *
2467 * The idea is not to show the popup if the next input message is
2468 * going to hide it anyway.
2469 */
2470 static BOOL MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg )
2471 {
2472 MSG msg;
2473
2474 msg.hwnd = pmt->hOwnerWnd;
2475
2476 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2477 pmt->trackFlags |= TF_SKIPREMOVE;
2478
2479 switch( uMsg )
2480 {
2481 case WM_KEYDOWN:
2482 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2483 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
2484 {
2485 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE);
2486 PeekMessageA( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE);
2487 if( msg.message == WM_KEYDOWN &&
2488 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
2489 {
2490 pmt->trackFlags |= TF_SUSPENDPOPUP;
2491 return TRUE;
2492 }
2493 }
2494 break;
2495 }
2496
2497 /* failures go through this */
2498 pmt->trackFlags &= ~TF_SUSPENDPOPUP;
2499 return FALSE;
2500 }
2501
2502 /***********************************************************************
2503 * MENU_KeyEscape
2504 *
2505 * Handle a VK_ESCAPE key event in a menu.
2506 */
2507 static BOOL MENU_KeyEscape(MTRACKER* pmt, UINT wFlags)
2508 {
2509 BOOL bEndMenu = TRUE;
2510
2511 if (pmt->hCurrentMenu != pmt->hTopMenu)
2512 {
2513 POPUPMENU *menu = MENU_GetMenu(pmt->hCurrentMenu);
2514
2515 if (menu->wFlags & MF_POPUP)
2516 {
2517 HMENU hmenutmp, hmenuprev;
2518
2519 hmenuprev = hmenutmp = pmt->hTopMenu;
2520
2521 /* close topmost popup */
2522 while (hmenutmp != pmt->hCurrentMenu)
2523 {
2524 hmenuprev = hmenutmp;
2525 hmenutmp = MENU_GetSubPopup( hmenuprev );
2526 }
2527
2528 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2529 pmt->hCurrentMenu = hmenuprev;
2530 bEndMenu = FALSE;
2531 }
2532 }
2533
2534 return bEndMenu;
2535 }
2536
2537 /***********************************************************************
2538 * MENU_KeyLeft
2539 *
2540 * Handle a VK_LEFT key event in a menu.
2541 */
2542 static void MENU_KeyLeft( MTRACKER* pmt, UINT wFlags )
2543 {
2544 POPUPMENU *menu;
2545 HMENU hmenutmp, hmenuprev;
2546 UINT prevcol;
2547
2548 hmenuprev = hmenutmp = pmt->hTopMenu;
2549 menu = MENU_GetMenu( hmenutmp );
2550
2551 /* Try to move 1 column left (if possible) */
2552 if( (prevcol = MENU_GetStartOfPrevColumn( pmt->hCurrentMenu )) !=
2553 NO_SELECTED_ITEM ) {
2554
2555 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2556 prevcol, TRUE, 0 );
2557 return;
2558 }
2559
2560 /* close topmost popup */
2561 while (hmenutmp != pmt->hCurrentMenu)
2562 {
2563 hmenuprev = hmenutmp;
2564 hmenutmp = MENU_GetSubPopup( hmenuprev );
2565 }
2566
2567 MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE );
2568 pmt->hCurrentMenu = hmenuprev;
2569
2570 if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) )
2571 {
2572 /* move menu bar selection if no more popups are left */
2573
2574 if( !MENU_DoNextMenu( pmt, VK_LEFT) )
2575 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV );
2576
2577 if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2578 {
2579 /* A sublevel menu was displayed - display the next one
2580 * unless there is another displacement coming up */
2581
2582 if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) )
2583 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2584 pmt->hTopMenu, TRUE, wFlags);
2585 }
2586 }
2587 }
2588
2589
2590 /***********************************************************************
2591 * MENU_KeyRight
2592 *
2593 * Handle a VK_RIGHT key event in a menu.
2594 */
2595 static void MENU_KeyRight( MTRACKER* pmt, UINT wFlags )
2596 {
2597 HMENU hmenutmp;
2598 POPUPMENU *menu = MENU_GetMenu( pmt->hTopMenu );
2599 UINT nextcol;
2600
2601 TRACE("MENU_KeyRight called, cur %x (%s), top %x (%s).\n",
2602 pmt->hCurrentMenu,
2603 debugstr_w((MENU_GetMenu(pmt->hCurrentMenu))->
2604 items[0].text),
2605 pmt->hTopMenu, debugstr_w(menu->items[0].text) );
2606
2607 if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu))
2608 {
2609 /* If already displaying a popup, try to display sub-popup */
2610
2611 hmenutmp = pmt->hCurrentMenu;
2612 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd, hmenutmp, TRUE, wFlags);
2613
2614 /* if subpopup was displayed then we are done */
2615 if (hmenutmp != pmt->hCurrentMenu) return;
2616 }
2617
2618 /* Check to see if there's another column */
2619 if( (nextcol = MENU_GetStartOfNextColumn( pmt->hCurrentMenu )) !=
2620 NO_SELECTED_ITEM ) {
2621 TRACE("Going to %d.\n", nextcol );
2622 MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu,
2623 nextcol, TRUE, 0 );
2624 return;
2625 }
2626
2627 if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */
2628 {
2629 if( pmt->hCurrentMenu != pmt->hTopMenu )
2630 {
2631 MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE );
2632 hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu;
2633 } else hmenutmp = 0;
2634
2635 /* try to move to the next item */
2636 if( !MENU_DoNextMenu( pmt, VK_RIGHT) )
2637 MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT );
2638
2639 if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP )
2640 if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) )
2641 pmt->hCurrentMenu = MENU_ShowSubPopup(pmt->hOwnerWnd,
2642 pmt->hTopMenu, TRUE, wFlags);
2643 }
2644 }
2645
2646 /***********************************************************************
2647 * MENU_TrackMenu
2648 *
2649 * Menu tracking code.
2650 */
2651 static INT MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
2652 HWND hwnd, const RECT *lprect )
2653 {
2654 MSG msg;
2655 POPUPMENU *menu;
2656 BOOL fRemove;
2657 INT executedMenuId = -1;
2658 MTRACKER mt;
2659 BOOL enterIdleSent = FALSE;
2660
2661 mt.trackFlags = 0;
2662 mt.hCurrentMenu = hmenu;
2663 mt.hTopMenu = hmenu;
2664 mt.hOwnerWnd = WIN_GetFullHandle( hwnd );
2665 mt.pt.x = x;
2666 mt.pt.y = y;
2667
2668 TRACE("hmenu=0x%04x flags=0x%08x (%d,%d) hwnd=0x%04x (%d,%d)-(%d,%d)\n",
2669 hmenu, wFlags, x, y, hwnd, (lprect) ? lprect->left : 0, (lprect) ? lprect->top : 0,
2670 (lprect) ? lprect->right : 0, (lprect) ? lprect->bottom : 0);
2671
2672 fEndMenu = FALSE;
2673 if (!(menu = MENU_GetMenu( hmenu ))) return FALSE;
2674
2675 if (wFlags & TPM_BUTTONDOWN)
2676 {
2677 /* Get the result in order to start the tracking or not */
2678 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2679 fEndMenu = !fRemove;
2680 }
2681
2682 EVENT_Capture( mt.hOwnerWnd, HTMENU );
2683
2684 while (!fEndMenu)
2685 {
2686 menu = MENU_GetMenu( mt.hCurrentMenu );
2687 if (!menu) /* sometimes happens if I do a window manager close */
2688 break;
2689
2690 /* we have to keep the message in the queue until it's
2691 * clear that menu loop is not over yet. */
2692
2693 for (;;)
2694 {
2695 if (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
2696 {
2697 if (!CallMsgFilterA( &msg, MSGF_MENU )) break;
2698 /* remove the message from the queue */
2699 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2700 }
2701 else
2702 {
2703 if (!enterIdleSent)
2704 {
2705 HWND win = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0;
2706 enterIdleSent = TRUE;
2707 SendMessageW( mt.hOwnerWnd, WM_ENTERIDLE, MSGF_MENU, (LPARAM)win );
2708 }
2709 WaitMessage();
2710 }
2711 }
2712
2713 /* check if EndMenu() tried to cancel us, by posting this message */
2714 if(msg.message == WM_CANCELMODE)
2715 {
2716 /* we are now out of the loop */
2717 fEndMenu = TRUE;
2718
2719 /* remove the message from the queue */
2720 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2721
2722 /* break out of internal loop, ala ESCAPE */
2723 break;
2724 }
2725
2726 TranslateMessage( &msg );
2727 mt.pt = msg.pt;
2728
2729 if ( (msg.hwnd==menu->hWnd) || (msg.message!=WM_TIMER) )
2730 enterIdleSent=FALSE;
2731
2732 fRemove = FALSE;
2733 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
2734 {
2735 /*
2736 * use the mouse coordinates in lParam instead of those in the MSG
2737 * struct to properly handle synthetic messages. lParam coords are
2738 * relative to client area, so they must be converted; since they can
2739 * be negative, we must use SLOWORD/SHIWORD instead of LOWORD/HIWORD.
2740 */
2741 mt.pt.x = SLOWORD(msg.lParam);
2742 mt.pt.y = SHIWORD(msg.lParam);
2743 ClientToScreen(msg.hwnd,&mt.pt);
2744
2745 /* Find a menu for this mouse event */
2746 hmenu = MENU_PtMenu( mt.hTopMenu, mt.pt );
2747
2748 switch(msg.message)
2749 {
2750 /* no WM_NC... messages in captured state */
2751
2752 case WM_RBUTTONDBLCLK:
2753 case WM_RBUTTONDOWN:
2754 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2755 /* fall through */
2756 case WM_LBUTTONDBLCLK:
2757 case WM_LBUTTONDOWN:
2758 /* If the message belongs to the menu, removes it from the queue */
2759 /* Else, end menu tracking */
2760 fRemove = MENU_ButtonDown( &mt, hmenu, wFlags );
2761 fEndMenu = !fRemove;
2762 break;
2763
2764 case WM_RBUTTONUP:
2765 if (!(wFlags & TPM_RIGHTBUTTON)) break;
2766 /* fall through */
2767 case WM_LBUTTONUP:
2768 /* Check if a menu was selected by the mouse */
2769 if (hmenu)
2770 {
2771 executedMenuId = MENU_ButtonUp( &mt, hmenu, wFlags);
2772
2773 /* End the loop if executedMenuId is an item ID */
2774 /* or if the job was done (executedMenuId = 0). */
2775 fEndMenu = fRemove = (executedMenuId != -1);
2776 }
2777 /* No menu was selected by the mouse */
2778 /* if the function was called by TrackPopupMenu, continue
2779 with the menu tracking. If not, stop it */
2780 else
2781 fEndMenu = ((wFlags & TPM_POPUPMENU) ? FALSE : TRUE);
2782
2783 break;
2784
2785 case WM_MOUSEMOVE:
2786 /* In win95 winelook, the selected menu item must be changed every time the
2787 mouse moves. In Win31 winelook, the mouse button has to be held down */
2788
2789 if ( hmenu && ((TWEAK_WineLook > WIN31_LOOK) ||
2790 ( (msg.wParam & MK_LBUTTON) ||
2791 ((wFlags & TPM_RIGHTBUTTON) && (msg.wParam & MK_RBUTTON)))) )
2792
2793 fEndMenu |= !MENU_MouseMove( &mt, hmenu, wFlags );
2794
2795 } /* switch(msg.message) - mouse */
2796 }
2797 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
2798 {
2799 fRemove = TRUE; /* Keyboard messages are always removed */
2800 switch(msg.message)
2801 {
2802 case WM_KEYDOWN:
2803 switch(msg.wParam)
2804 {
2805 case VK_HOME:
2806 case VK_END:
2807 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu,
2808 NO_SELECTED_ITEM, FALSE, 0 );
2809 /* fall through */
2810 case VK_UP:
2811 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu,
2812 (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV );
2813 break;
2814
2815 case VK_DOWN: /* If on menu bar, pull-down the menu */
2816
2817 menu = MENU_GetMenu( mt.hCurrentMenu );
2818 if (!(menu->wFlags & MF_POPUP))
2819 mt.hCurrentMenu = MENU_ShowSubPopup(mt.hOwnerWnd, mt.hTopMenu, TRUE, wFlags);
2820 else /* otherwise try to move selection */
2821 MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT );
2822 break;
2823
2824 case VK_LEFT:
2825 MENU_KeyLeft( &mt, wFlags );
2826 break;
2827
2828 case VK_RIGHT:
2829 MENU_KeyRight( &mt, wFlags );
2830 break;
2831
2832 case VK_ESCAPE:
2833 fEndMenu = MENU_KeyEscape(&mt, wFlags);
2834 break;
2835
2836 case VK_F1:
2837 {
2838 HELPINFO hi;
2839 hi.cbSize = sizeof(HELPINFO);
2840 hi.iContextType = HELPINFO_MENUITEM;
2841 if (menu->FocusedItem == NO_SELECTED_ITEM)
2842 hi.iCtrlId = 0;
2843 else
2844 hi.iCtrlId = menu->items[menu->FocusedItem].wID;
2845 hi.hItemHandle = hmenu;
2846 hi.dwContextId = menu->dwContextHelpID;
2847 hi.MousePos = msg.pt;
2848 SendMessageA(hwnd, WM_HELP, 0, (LPARAM)&hi);
2849 break;
2850 }
2851
2852 default:
2853 break;
2854 }
2855 break; /* WM_KEYDOWN */
2856
2857 case WM_SYSKEYDOWN:
2858 switch(msg.wParam)
2859 {
2860 case VK_MENU:
2861 fEndMenu = TRUE;
2862 break;
2863
2864 }
2865 break; /* WM_SYSKEYDOWN */
2866
2867 case WM_CHAR:
2868 {
2869 UINT pos;
2870
2871 if (msg.wParam == '\r' || msg.wParam == ' ')
2872 {
2873 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2874 fEndMenu = (executedMenuId != -1);
2875
2876 break;
2877 }
2878
2879 /* Hack to avoid control chars. */
2880 /* We will find a better way real soon... */
2881 if ((msg.wParam <= 32) || (msg.wParam >= 127)) break;
2882
2883 pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu,
2884 LOWORD(msg.wParam), FALSE );
2885 if (pos == (UINT)-2) fEndMenu = TRUE;
2886 else if (pos == (UINT)-1) MessageBeep(0);
2887 else
2888 {
2889 MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos,
2890 TRUE, 0 );
2891 executedMenuId = MENU_ExecFocusedItem(&mt,mt.hCurrentMenu, wFlags);
2892 fEndMenu = (executedMenuId != -1);
2893 }
2894 }
2895 break;
2896 } /* switch(msg.message) - kbd */
2897 }
2898 else
2899 {
2900 DispatchMessageA( &msg );
2901 }
2902
2903 if (!fEndMenu) fRemove = TRUE;
2904
2905 /* finally remove message from the queue */
2906
2907 if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) )
2908 PeekMessageA( &msg, 0, msg.message, msg.message, PM_REMOVE );
2909 else mt.trackFlags &= ~TF_SKIPREMOVE;
2910 }
2911
2912 ReleaseCapture();
2913
2914 /* If dropdown is still painted and the close box is clicked on
2915 then the menu will be destroyed as part of the DispatchMessage above.
2916 This will then invalidate the menu handle in mt.hTopMenu. We should
2917 check for this first. */
2918 if( IsMenu( mt.hTopMenu ) )
2919 {
2920 menu = MENU_GetMenu( mt.hTopMenu );
2921
2922 if( IsWindow( mt.hOwnerWnd ) )
2923 {
2924 MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE );
2925
2926 if (menu && menu->wFlags & MF_POPUP)
2927 {
2928 DestroyWindow( menu->hWnd );
2929 menu->hWnd = 0;
2930 }
2931 MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE, 0 );
2932 SendMessageA( mt.hOwnerWnd, WM_MENUSELECT, MAKELONG(0,0xffff), 0 );
2933 }
2934
2935 /* Reset the variable for hiding menu */
2936 if( menu ) menu->bTimeToHide = FALSE;
2937 }
2938
2939 /* The return value is only used by TrackPopupMenu */
2940 return ((executedMenuId != -1) ? executedMenuId : 0);
2941 }
2942
2943 /***********************************************************************
2944 * MENU_InitTracking
2945 */
2946 static BOOL MENU_InitTracking(HWND hWnd, HMENU hMenu, BOOL bPopup, UINT wFlags)
2947 {
2948 TRACE("hwnd=0x%04x hmenu=0x%04x\n", hWnd, hMenu);
2949
2950 HideCaret(0);
2951
2952 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
2953 if (!(wFlags & TPM_NONOTIFY))
2954 SendMessageA( hWnd, WM_ENTERMENULOOP, bPopup, 0 );
2955
2956 SendMessageA( hWnd, WM_SETCURSOR, (WPARAM)hWnd, HTCAPTION );
2957
2958 if (!(wFlags & TPM_NONOTIFY))
2959 {
2960 POPUPMENU *menu;
2961 SendMessageA( hWnd, WM_INITMENU, hMenu, 0 );
2962 if ((menu = MENU_GetMenu( hMenu )) && (!menu->Height))
2963 { /* app changed/recreated menu bar entries in WM_INITMENU
2964 Recalculate menu sizes else clicks will not work */
2965 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2966 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2967
2968 }
2969 }
2970 return TRUE;
2971 }
2972 /***********************************************************************
2973 * MENU_ExitTracking
2974 */
2975 static BOOL MENU_ExitTracking(HWND hWnd)
2976 {
2977 TRACE("hwnd=0x%04x\n", hWnd);
2978
2979 SendMessageA( hWnd, WM_EXITMENULOOP, 0, 0 );
2980 ShowCaret(0);
2981 return TRUE;
2982 }
2983
2984 /***********************************************************************
2985 * MENU_TrackMouseMenuBar
2986 *
2987 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
2988 */
2989 void MENU_TrackMouseMenuBar( HWND hWnd, INT ht, POINT pt )
2990 {
2991 HMENU hMenu = (ht == HTSYSMENU) ? get_win_sys_menu( hWnd ) : GetMenu( hWnd );
2992 UINT wFlags = TPM_ENTERIDLEEX | TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
2993
2994 TRACE("wnd=%x ht=0x%04x (%ld,%ld)\n", hWnd, ht, pt.x, pt.y);
2995
2996 if (IsMenu(hMenu))
2997 {
2998 /* map point to parent client coordinates */
2999 HWND parent = GetAncestor( hWnd, GA_PARENT );
3000 if (parent != GetDesktopWindow()) ScreenToClient( parent, &pt );
3001
3002 MENU_InitTracking( hWnd, hMenu, FALSE, wFlags );
3003 MENU_TrackMenu( hMenu, wFlags, pt.x, pt.y, hWnd, NULL );
3004 MENU_ExitTracking(hWnd);
3005 }
3006 }
3007
3008
3009 /***********************************************************************
3010 * MENU_TrackKbdMenuBar
3011 *
3012 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
3013 */
3014 void MENU_TrackKbdMenuBar( HWND hwnd, UINT wParam, INT vkey)
3015 {
3016 UINT uItem = NO_SELECTED_ITEM;
3017 HMENU hTrackMenu;
3018 UINT wFlags = TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON;
3019
3020 /* find window that has a menu */
3021
3022 while (GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)
3023 if (!(hwnd = GetParent( hwnd ))) return;
3024
3025 /* check if we have to track a system menu */
3026
3027 hTrackMenu = GetMenu( hwnd );
3028 if (!hTrackMenu || IsIconic(hwnd) || vkey == VK_SPACE )
3029 {
3030 if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_SYSMENU)) return;
3031 hTrackMenu = get_win_sys_menu( hwnd );
3032 uItem = 0;
3033 wParam |= HTSYSMENU; /* prevent item lookup */
3034 }
3035
3036 if (!IsMenu( hTrackMenu )) return;
3037
3038 MENU_InitTracking( hwnd, hTrackMenu, FALSE, wFlags );
3039
3040 if( vkey && vkey != VK_SPACE )
3041 {
3042 uItem = MENU_FindItemByKey( hwnd, hTrackMenu, vkey, (wParam & HTSYSMENU) );
3043 if( uItem >= (UINT)(-2) )
3044 {
3045 if( uItem == (UINT)(-1) ) MessageBeep(0);
3046 hTrackMenu = 0;
3047 }
3048 }
3049
3050 if( hTrackMenu )
3051 {
3052 MENU_SelectItem( hwnd, hTrackMenu, uItem, TRUE, 0 );
3053
3054 if( uItem == NO_SELECTED_ITEM )
3055 MENU_MoveSelection( hwnd, hTrackMenu, ITEM_NEXT );
3056 else if( vkey )
3057 PostMessageA( hwnd, WM_KEYDOWN, VK_DOWN, 0L );
3058
3059 MENU_TrackMenu( hTrackMenu, wFlags, 0, 0, hwnd, NULL );
3060 }
3061 MENU_ExitTracking( hwnd );
3062 }
3063
3064
3065 /**********************************************************************
3066 * TrackPopupMenu (USER32.@)
3067 *
3068 * Like the win32 API, the function return the command ID only if the
3069 * flag TPM_RETURNCMD is on.
3070 *
3071 */
3072 BOOL WINAPI TrackPopupMenu( HMENU hMenu, UINT wFlags, INT x, INT y,
3073 INT nReserved, HWND hWnd, const RECT *lpRect )
3074 {
3075 BOOL ret = FALSE;
3076
3077 MENU_InitTracking(hWnd, hMenu, TRUE, wFlags);
3078
3079 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3080 if (!(wFlags & TPM_NONOTIFY))
3081 SendMessageA( hWnd, WM_INITMENUPOPUP, hMenu, 0);
3082
3083 if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 ))
3084 ret = MENU_TrackMenu( hMenu, wFlags | TPM_POPUPMENU, 0, 0, hWnd, lpRect );
3085 MENU_ExitTracking(hWnd);
3086
3087 if( (!(wFlags & TPM_RETURNCMD)) && (ret != FALSE) )
3088 ret = 1;
3089
3090 return ret;
3091 }
3092
3093 /**********************************************************************
3094 * TrackPopupMenuEx (USER32.@)
3095 */
3096 BOOL WINAPI TrackPopupMenuEx( HMENU hMenu, UINT wFlags, INT x, INT y,
3097 HWND hWnd, LPTPMPARAMS lpTpm )
3098 {
3099 FIXME("not fully implemented\n" );
3100 return TrackPopupMenu( hMenu, wFlags, x, y, 0, hWnd,
3101 lpTpm ? &lpTpm->rcExclude : NULL );
3102 }
3103
3104 /***********************************************************************
3105 * PopupMenuWndProc
3106 *
3107 * NOTE: Windows has totally different (and undocumented) popup wndproc.
3108 */
3109 static LRESULT WINAPI PopupMenuWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
3110 {
3111 TRACE("hwnd=0x%04x msg=0x%04x wp=0x%04x lp=0x%08lx\n",
3112 hwnd, message, wParam, lParam);
3113
3114 switch(message)
3115 {
3116 case WM_CREATE:
3117 {
3118 CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
3119 SetWindowLongW( hwnd, 0, (LONG)cs->lpCreateParams );
3120 return 0;
3121 }
3122
3123 case WM_MOUSEACTIVATE: /* We don't want to be activated */
3124 return MA_NOACTIVATE;
3125
3126 case WM_PAINT:
3127 {
3128 PAINTSTRUCT ps;
3129 BeginPaint( hwnd, &ps );
3130 MENU_DrawPopupMenu( hwnd, ps.hdc,
3131 (HMENU)GetWindowLongA( hwnd, 0 ) );
3132 EndPaint( hwnd, &ps );
3133 return 0;
3134 }
3135 case WM_ERASEBKGND:
3136 return 1;
3137
3138 case WM_DESTROY:
3139 /* zero out global pointer in case resident popup window was destroyed. */
3140 if (hwnd == top_popup) top_popup = 0;
3141 break;
3142
3143 case WM_SHOWWINDOW:
3144
3145 if( wParam )
3146 {
3147 if (!GetWindowLongW( hwnd, 0 )) ERR("no menu to display\n");
3148 }
3149 else
3150 SetWindowLongW( hwnd, 0, 0 );
3151 break;
3152
3153 case MM_SETMENUHANDLE:
3154 SetWindowLongW( hwnd, 0, wParam );
3155 break;
3156
3157 case MM_GETMENUHANDLE:
3158 return GetWindowLongW( hwnd, 0 );
3159
3160 default:
3161 return DefWindowProcW( hwnd, message, wParam, lParam );
3162 }
3163 return 0;
3164 }
3165
3166
3167 /***********************************************************************
3168 * MENU_GetMenuBarHeight
3169 *
3170 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
3171 */
3172 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth,
3173 INT orgX, INT orgY )
3174 {
3175 HDC hdc;
3176 RECT rectBar;
3177 LPPOPUPMENU lppop;
3178
3179 TRACE("HWND 0x%x, width %d, at (%d, %d).\n",
3180 hwnd, menubarWidth, orgX, orgY );
3181
3182 if (!(lppop = MENU_GetMenu( GetMenu(hwnd) ))) return 0;
3183
3184 hdc = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
3185 SelectObject( hdc, hMenuFont);
3186 SetRect(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+GetSystemMetrics(SM_CYMENU));
3187 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
3188 ReleaseDC( hwnd, hdc );
3189 return lppop->Height;
3190 }
3191
3192
3193 /*******************************************************************
3194 * ChangeMenu (USER.153)
3195 */
3196 BOOL16 WINAPI ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
3197 UINT16 id, UINT16 flags )
3198 {
3199 TRACE("menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
3200 hMenu, pos, (DWORD)data, id, flags );
3201 if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND,
3202 id, data );
3203
3204 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
3205 /* for MF_DELETE. We should check the parameters for all others */
3206 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
3207
3208 if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE);
3209 if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE,
3210 id, data );
3211 if (flags & MF_REMOVE) return RemoveMenu16(hMenu,
3212 flags & MF_BYPOSITION ? pos : id,
3213 flags & ~MF_REMOVE );
3214 /* Default: MF_INSERT */
3215 return InsertMenu16( hMenu, pos, flags, id, data );
3216 }
3217
3218
3219 /*******************************************************************
3220 * ChangeMenuA (USER32.@)
3221 */
3222 BOOL WINAPI ChangeMenuA( HMENU hMenu, UINT pos, LPCSTR data,
3223 UINT id, UINT flags )
3224 {
3225 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3226 hMenu, pos, (DWORD)data, id, flags );
3227 if (flags & MF_APPEND) return AppendMenuA( hMenu, flags & ~MF_APPEND,
3228 id, data );
3229 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3230 if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
3231 id, data );
3232 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3233 flags & MF_BYPOSITION ? pos : id,
3234 flags & ~MF_REMOVE );
3235 /* Default: MF_INSERT */
3236 return InsertMenuA( hMenu, pos, flags, id, data );
3237 }
3238
3239
3240 /*******************************************************************
3241 * ChangeMenuW (USER32.@)
3242 */
3243 BOOL WINAPI ChangeMenuW( HMENU hMenu, UINT pos, LPCWSTR data,
3244 UINT id, UINT flags )
3245 {
3246 TRACE("menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
3247 hMenu, pos, (DWORD)data, id, flags );
3248 if (flags & MF_APPEND) return AppendMenuW( hMenu, flags & ~MF_APPEND,
3249 id, data );
3250 if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
3251 if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
3252 id, data );
3253 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
3254 flags & MF_BYPOSITION ? pos : id,
3255 flags & ~MF_REMOVE );
3256 /* Default: MF_INSERT */
3257 return InsertMenuW( hMenu, pos, flags, id, data );
3258 }
3259
3260
3261 /*******************************************************************
3262 * CheckMenuItem (USER.154)
3263 */
3264 BOOL16 WINAPI CheckMenuItem16( HMENU16 hMenu, UINT16 id, UINT16 flags )
3265 {
3266 return (BOOL16)CheckMenuItem( hMenu, id, flags );
3267 }
3268
3269
3270 /*******************************************************************
3271 * CheckMenuItem (USER32.@)
3272 */
3273 DWORD WINAPI CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
3274 {
3275 MENUITEM *item;
3276 DWORD ret;
3277
3278 TRACE("menu=%04x id=%04x flags=%04x\n", hMenu, id, flags );
3279 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
3280 ret = item->fState & MF_CHECKED;
3281 if (flags & MF_CHECKED) item->fState |= MF_CHECKED;
3282 else item->fState &= ~MF_CHECKED;
3283 return ret;
3284 }
3285
3286
3287 /**********************************************************************
3288 * EnableMenuItem (USER.155)
3289 */
3290 UINT16 WINAPI EnableMenuItem16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3291 {
3292 return EnableMenuItem( hMenu, wItemID, wFlags );
3293 }
3294
3295
3296 /**********************************************************************
3297 * EnableMenuItem (USER32.@)
3298 */
3299 UINT WINAPI EnableMenuItem( HMENU hMenu, UINT wItemID, UINT wFlags )
3300 {
3301 UINT oldflags;
3302 MENUITEM *item;
3303 POPUPMENU *menu;
3304
3305 TRACE("(%04x, %04X, %04X) !\n",
3306 hMenu, wItemID, wFlags);
3307
3308 /* Get the Popupmenu to access the owner menu */
3309 if (!(menu = MENU_GetMenu(hMenu)))
3310 return (UINT)-1;
3311
3312 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags )))
3313 return (UINT)-1;
3314
3315 oldflags = item->fState & (MF_GRAYED | MF_DISABLED);
3316 item->fState ^= (oldflags ^ wFlags) & (MF_GRAYED | MF_DISABLED);
3317
3318 /* In win95 if the close item in the system menu change update the close button */
3319 if (TWEAK_WineLook == WIN95_LOOK)
3320 if((item->wID == SC_CLOSE) && (oldflags != wFlags))
3321 {
3322 if (menu->hSysMenuOwner != 0)
3323 {
3324 POPUPMENU* parentMenu;
3325
3326 /* Get the parent menu to access*/
3327 if (!(parentMenu = MENU_GetMenu(menu->hSysMenuOwner)))
3328 return (UINT)-1;
3329
3330 /* Refresh the frame to reflect the change*/
3331 SetWindowPos(parentMenu->hWnd, 0, 0, 0, 0, 0,
3332 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
3333 }
3334 }
3335
3336 return oldflags;
3337 }
3338
3339
3340 /*******************************************************************
3341 * GetMenuString (USER.161)
3342 */
3343 INT16 WINAPI GetMenuString16( HMENU16 hMenu, UINT16 wItemID,
3344 LPSTR str, INT16 nMaxSiz, UINT16 wFlags )
3345 {
3346 return GetMenuStringA( hMenu, wItemID, str, nMaxSiz, wFlags );
3347 }
3348
3349
3350 /*******************************************************************
3351 * GetMenuStringA (USER32.@)
3352 */
3353 INT WINAPI GetMenuStringA(
3354 HMENU hMenu, /* [in] menuhandle */
3355 UINT wItemID, /* [in] menu item (dep. on wFlags) */
3356 LPSTR str, /* [out] outbuffer. If NULL, func returns entry length*/
3357 INT nMaxSiz, /* [in] length of buffer. if 0, func returns entry len*/
3358 UINT wFlags /* [in] MF_ flags */
3359 ) {
3360 MENUITEM *item;
3361
3362 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3363 hMenu, wItemID, str, nMaxSiz, wFlags );
3364 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3365 if (!IS_STRING_ITEM(item->fType)) return 0;
3366 if (!str || !nMaxSiz) return strlenW(item->text);
3367 str[0] = '\0';
3368 if (!WideCharToMultiByte( CP_ACP, 0, item->text, -1, str, nMaxSiz, NULL, NULL ))
3369 str[nMaxSiz-1] = 0;
3370 TRACE("returning '%s'\n", str );
3371 return strlen(str);
3372 }
3373
3374
3375 /*******************************************************************
3376 * GetMenuStringW (USER32.@)
3377 */
3378 INT WINAPI GetMenuStringW( HMENU hMenu, UINT wItemID,
3379 LPWSTR str, INT nMaxSiz, UINT wFlags )
3380 {
3381 MENUITEM *item;
3382
3383 TRACE("menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
3384 hMenu, wItemID, str, nMaxSiz, wFlags );
3385 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
3386 if (!IS_STRING_ITEM(item->fType)) return 0;
3387 if (!str || !nMaxSiz) return strlenW(item->text);
3388 str[0] = '\0';
3389 lstrcpynW( str, item->text, nMaxSiz );
3390 return strlenW(str);
3391 }
3392
3393
3394 /**********************************************************************
3395 * HiliteMenuItem (USER32.@)
3396 */
3397 BOOL WINAPI HiliteMenuItem( HWND hWnd, HMENU hMenu, UINT wItemID,
3398 UINT wHilite )
3399 {
3400 LPPOPUPMENU menu;
3401 TRACE("(%04x, %04x, %04x, %04x);\n",
3402 hWnd, hMenu, wItemID, wHilite);
3403 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
3404 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3405 if (menu->FocusedItem == wItemID) return TRUE;
3406 MENU_HideSubPopups( hWnd, hMenu, FALSE );
3407 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE, 0 );
3408 return TRUE;
3409 }
3410
3411
3412 /**********************************************************************
3413 * GetMenuState (USER.250)
3414 */
3415 UINT16 WINAPI GetMenuState16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
3416 {
3417 return GetMenuState( hMenu, wItemID, wFlags );
3418 }
3419
3420
3421 /**********************************************************************
3422 * GetMenuState (USER32.@)
3423 */
3424 UINT WINAPI GetMenuState( HMENU hMenu, UINT wItemID, UINT wFlags )
3425 {
3426 MENUITEM *item;
3427 TRACE("(menu=%04x, id=%04x, flags=%04x);\n",
3428 hMenu, wItemID, wFlags);
3429 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
3430 debug_print_menuitem (" item: ", item, "");
3431 if (item->fType & MF_POPUP)
3432 {
3433 POPUPMENU *menu = MENU_GetMenu( item->hSubMenu );
3434 if (!menu) return -1;
3435 else return (menu->nItems << 8) | ((item->fState|item->fType) & 0xff);
3436 }
3437 else
3438 {
3439 /* We used to (from way back then) mask the result to 0xff. */
3440 /* I don't know why and it seems wrong as the documented */
3441 /* return flag MF_SEPARATOR is outside that mask. */
3442 return (item->fType | item->fState);
3443 }
3444 }
3445
3446
3447 /**********************************************************************
3448 * GetMenuItemCount (USER.263)
3449 */
3450 INT16 WINAPI GetMenuItemCount16( HMENU16 hMenu )
3451 {
3452 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3453 if (!menu) return -1;
3454 TRACE("(%04x) returning %d\n",
3455 hMenu, menu->nItems );
3456 return menu->nItems;
3457 }
3458
3459
3460 /**********************************************************************
3461 * GetMenuItemCount (USER32.@)
3462 */
3463 INT WINAPI GetMenuItemCount( HMENU hMenu )
3464 {
3465 LPPOPUPMENU menu = MENU_GetMenu(hMenu);
3466 if (!menu) return -1;
3467 TRACE("(%04x) returning %d\n",
3468 hMenu, menu->nItems );
3469 return menu->nItems;
3470 }
3471
3472 /**********************************************************************
3473 * GetMenuItemID (USER.264)
3474 */
3475 UINT16 WINAPI GetMenuItemID16( HMENU16 hMenu, INT16 nPos )
3476 {
3477 return (UINT16) GetMenuItemID (hMenu, nPos);
3478 }
3479
3480 /**********************************************************************
3481 * GetMenuItemID (USER32.@)
3482 */
3483 UINT WINAPI GetMenuItemID( HMENU hMenu, INT nPos )
3484 {
3485 MENUITEM * lpmi;
3486
3487 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return -1;
3488 if (lpmi->fType & MF_POPUP) return -1;
3489 return lpmi->wID;
3490
3491 }
3492
3493 /*******************************************************************
3494 * InsertMenu (USER.410)
3495 */
3496 BOOL16 WINAPI InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3497 UINT16 id, SEGPTR data )
3498 {
3499 UINT pos32 = (UINT)pos;
3500 if ((pos == (UINT16)-1) && (flags & MF_BYPOSITION)) pos32 = (UINT)-1;
3501 if (IS_STRING_ITEM(flags) && data)
3502 return InsertMenuA( hMenu, pos32, flags, id, MapSL(data) );
3503 return InsertMenuA( hMenu, pos32, flags, id, (LPSTR)data );
3504 }
3505
3506
3507 /*******************************************************************
3508 * InsertMenuW (USER32.@)
3509 */
3510 BOOL WINAPI InsertMenuW( HMENU hMenu, UINT pos, UINT flags,
3511 UINT id, LPCWSTR str )
3512 {
3513 MENUITEM *item;
3514
3515 if (IS_STRING_ITEM(flags) && str)
3516 TRACE("hMenu %04x, pos %d, flags %08x, "
3517 "id %04x, str %s\n",
3518 hMenu, pos, flags, id, debugstr_w(str) );
3519 else TRACE("hMenu %04x, pos %d, flags %08x, "
3520 "id %04x, str %08lx (not a string)\n",
3521 hMenu, pos, flags, id, (DWORD)str );
3522
3523 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
3524
3525 if (!(MENU_SetItemData( item, flags, id, str )))
3526 {
3527 RemoveMenu( hMenu, pos, flags );
3528 return FALSE;
3529 }
3530
3531 if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
3532 (MENU_GetMenu((HMENU16)id))->wFlags |= MF_POPUP;
3533
3534 item->hCheckBit = item->hUnCheckBit = 0;
3535 return TRUE;
3536 }
3537
3538
3539 /*******************************************************************
3540 * InsertMenuA (USER32.@)
3541 */
3542 BOOL WINAPI InsertMenuA( HMENU hMenu, UINT pos, UINT flags,
3543 UINT id, LPCSTR str )
3544 {
3545 BOOL ret = FALSE;
3546
3547 if (IS_STRING_ITEM(flags) && str)
3548 {
3549 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3550 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3551 if (newstr)
3552 {
3553 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3554 ret = InsertMenuW( hMenu, pos, flags, id, newstr );
3555 HeapFree( GetProcessHeap(), 0, newstr );
3556 }
3557 return ret;
3558 }
3559 else return InsertMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3560 }
3561
3562
3563 /*******************************************************************
3564 * AppendMenu (USER.411)
3565 */
3566 BOOL16 WINAPI AppendMenu16(HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data)
3567 {
3568 return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
3569 }
3570
3571
3572 /*******************************************************************
3573 * AppendMenuA (USER32.@)
3574 */
3575 BOOL WINAPI AppendMenuA( HMENU hMenu, UINT flags,
3576 UINT id, LPCSTR data )
3577 {
3578 return InsertMenuA( hMenu, -1, flags | MF_BYPOSITION, id, data );
3579 }
3580
3581
3582 /*******************************************************************
3583 * AppendMenuW (USER32.@)
3584 */
3585 BOOL WINAPI AppendMenuW( HMENU hMenu, UINT flags,
3586 UINT id, LPCWSTR data )
3587 {
3588 return InsertMenuW( hMenu, -1, flags | MF_BYPOSITION, id, data );
3589 }
3590
3591
3592 /**********************************************************************
3593 * RemoveMenu (USER.412)
3594 */
3595 BOOL16 WINAPI RemoveMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3596 {
3597 return RemoveMenu( hMenu, nPos, wFlags );
3598 }
3599
3600
3601 /**********************************************************************
3602 * RemoveMenu (USER32.@)
3603 */
3604 BOOL WINAPI RemoveMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3605 {
3606 LPPOPUPMENU menu;
3607 MENUITEM *item;
3608
3609 TRACE("(menu=%04x pos=%04x flags=%04x)\n",hMenu, nPos, wFlags);
3610 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3611 if (!(menu = MENU_GetMenu(hMenu))) return FALSE;
3612
3613 /* Remove item */
3614
3615 MENU_FreeItemData( item );
3616
3617 if (--menu->nItems == 0)
3618 {
3619 HeapFree( GetProcessHeap(), 0, menu->items );
3620 menu->items = NULL;
3621 }
3622 else
3623 {
3624 while(nPos < menu->nItems)
3625 {
3626 *item = *(item+1);
3627 item++;
3628 nPos++;
3629 }
3630 menu->items = HeapReAlloc( GetProcessHeap(), 0, menu->items,
3631 menu->nItems * sizeof(MENUITEM) );
3632 }
3633 return TRUE;
3634 }
3635
3636
3637 /**********************************************************************
3638 * DeleteMenu (USER.413)
3639 */
3640 BOOL16 WINAPI DeleteMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
3641 {
3642 return DeleteMenu( hMenu, nPos, wFlags );
3643 }
3644
3645
3646 /**********************************************************************
3647 * DeleteMenu (USER32.@)
3648 */
3649 BOOL WINAPI DeleteMenu( HMENU hMenu, UINT nPos, UINT wFlags )
3650 {
3651 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
3652 if (!item) return FALSE;
3653 if (item->fType & MF_POPUP) DestroyMenu( item->hSubMenu );
3654 /* nPos is now the position of the item */
3655 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
3656 return TRUE;
3657 }
3658
3659
3660 /*******************************************************************
3661 * ModifyMenu (USER.414)
3662 */
3663 BOOL16 WINAPI ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
3664 UINT16 id, SEGPTR data )
3665 {
3666 if (IS_STRING_ITEM(flags))
3667 return ModifyMenuA( hMenu, pos, flags, id, MapSL(data) );
3668 return ModifyMenuA( hMenu, pos, flags, id, (LPSTR)data );
3669 }
3670
3671
3672 /*******************************************************************
3673 * ModifyMenuW (USER32.@)
3674 */
3675 BOOL WINAPI ModifyMenuW( HMENU hMenu, UINT pos, UINT flags,
3676 UINT id, LPCWSTR str )
3677 {
3678 MENUITEM *item;
3679
3680 if (IS_STRING_ITEM(flags))
3681 {
3682 TRACE("%04x %d %04x %04x %s\n",
3683 hMenu, pos, flags, id, debugstr_w(str) );
3684 if (!str) return FALSE;
3685 }
3686 else
3687 {
3688 TRACE("%04x %d %04x %04x %08lx\n",
3689 hMenu, pos, flags, id, (DWORD)str );
3690 }
3691
3692 if (!(item = MENU_FindItem( &hMenu, &pos, flags ))) return FALSE;
3693 return MENU_SetItemData( item, flags, id, str );
3694 }
3695
3696
3697 /*******************************************************************
3698 * ModifyMenuA (USER32.@)
3699 */
3700 BOOL WINAPI ModifyMenuA( HMENU hMenu, UINT pos, UINT flags,
3701 UINT id, LPCSTR str )
3702 {
3703 BOOL ret = FALSE;
3704
3705 if (IS_STRING_ITEM(flags) && str)
3706 {
3707 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
3708 LPWSTR newstr = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3709 if (newstr)
3710 {
3711 MultiByteToWideChar( CP_ACP, 0, str, -1, newstr, len );
3712 ret = ModifyMenuW( hMenu, pos, flags, id, newstr );
3713 HeapFree( GetProcessHeap(), 0, newstr );
3714 }
3715 return ret;
3716 }
3717 else return ModifyMenuW( hMenu, pos, flags, id, (LPCWSTR)str );
3718 }
3719
3720
3721 /**********************************************************************
3722 * CreatePopupMenu (USER.415)
3723 */
3724 HMENU16 WINAPI CreatePopupMenu16(void)
3725 {
3726 return CreatePopupMenu();
3727 }
3728
3729
3730 /**********************************************************************
3731 * CreatePopupMenu (USER32.@)
3732 */
3733 HMENU WINAPI CreatePopupMenu(void)
3734 {
3735 HMENU hmenu;
3736 POPUPMENU *menu;
3737
3738 if (!(hmenu = CreateMenu())) return 0;
3739 menu = MENU_GetMenu( hmenu );
3740 menu->wFlags |= MF_POPUP;
3741 menu->bTimeToHide = FALSE;
3742 return hmenu;
3743 }
3744
3745
3746 /**********************************************************************
3747 * GetMenuCheckMarkDimensions (USER.417)
3748 * GetMenuCheckMarkDimensions (USER32.@)
3749 */
3750 DWORD WINAPI GetMenuCheckMarkDimensions(void)
3751 {
3752 return MAKELONG( GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK) );
3753 }
3754
3755
3756 /**********************************************************************
3757 * SetMenuItemBitmaps (USER.418)
3758 */
3759 BOOL16 WINAPI SetMenuItemBitmaps16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags,
3760 HBITMAP16 hNewUnCheck, HBITMAP16 hNewCheck)
3761 {
3762 return SetMenuItemBitmaps( hMenu, nPos, wFlags, hNewUnCheck, hNewCheck );
3763 }
3764
3765
3766 /**********************************************************************
3767 * SetMenuItemBitmaps (USER32.@)
3768 */
3769 BOOL WINAPI SetMenuItemBitmaps( HMENU hMenu, UINT nPos, UINT wFlags,
3770 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
3771 {
3772 MENUITEM *item;
3773 TRACE("(%04x, %04x, %04x, %04x, %04x)\n",
3774 hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
3775 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
3776
3777 if (!hNewCheck && !hNewUnCheck)
3778 {
3779 item->fState &= ~MF_USECHECKBITMAPS;
3780 }
3781 else /* Install new bitmaps */
3782 {
3783 item->hCheckBit = hNewCheck;
3784 item->hUnCheckBit = hNewUnCheck;
3785 item->fState |= MF_USECHECKBITMAPS;
3786 }
3787 return TRUE;
3788 }
3789
3790
3791 /**********************************************************************
3792 * CreateMenu (USER.151)
3793 */
3794 HMENU16 WINAPI CreateMenu16(void)
3795 {
3796 return CreateMenu();
3797 }
3798
3799
3800 /**********************************************************************
3801 * CreateMenu (USER32.@)
3802 */
3803 HMENU WINAPI CreateMenu(void)
3804 {
3805 HMENU hMenu;
3806 LPPOPUPMENU menu;
3807 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) ))) return 0;
3808 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
3809
3810 ZeroMemory(menu, sizeof(POPUPMENU));
3811 menu->wMagic = MENU_MAGIC;
3812 menu->FocusedItem = NO_SELECTED_ITEM;
3813 menu->bTimeToHide = FALSE;
3814
3815 TRACE("return %04x\n", hMenu );
3816
3817 return hMenu;
3818 }
3819
3820
3821 /**********************************************************************
3822 * DestroyMenu (USER.152)
3823 */
3824 BOOL16 WINAPI DestroyMenu16( HMENU16 hMenu )
3825 {
3826 return DestroyMenu( hMenu );
3827 }
3828
3829
3830 /**********************************************************************
3831 * DestroyMenu (USER32.@)
3832 */
3833 BOOL WINAPI DestroyMenu( HMENU hMenu )
3834 {
3835 TRACE("(%04x)\n", hMenu);
3836
3837 /* Silently ignore attempts to destroy default system popup */
3838
3839 if (hMenu && hMenu != MENU_DefSysPopup)
3840 {
3841 LPPOPUPMENU lppop = MENU_GetMenu(hMenu);
3842
3843 if (!lppop) return FALSE;
3844
3845 lppop->wMagic = 0; /* Mark it as destroyed */
3846
3847 if ((lppop->wFlags & MF_POPUP) && lppop->hWnd)
3848 {
3849 DestroyWindow( lppop->hWnd );
3850 lppop->hWnd = 0;
3851 }
3852
3853 if (lppop->items) /* recursively destroy submenus */
3854 {
3855 int i;
3856 MENUITEM *item = lppop->items;
3857 for (i = lppop->nItems; i > 0; i--, item++)
3858 {
3859 if (item->fType & MF_POPUP) DestroyMenu(item->hSubMenu);
3860 MENU_FreeItemData( item );
3861 }
3862 HeapFree( GetProcessHeap(), 0, lppop->items );
3863 }
3864 USER_HEAP_FREE( hMenu );
3865 }
3866 return (hMenu != MENU_DefSysPopup);
3867 }
3868
3869
3870 /**********************************************************************
3871 * GetSystemMenu (USER32.@)
3872 */
3873 HMENU WINAPI GetSystemMenu( HWND hWnd, BOOL bRevert )
3874 {
3875 WND *wndPtr = WIN_FindWndPtr( hWnd );
3876 HMENU retvalue = 0;
3877
3878 if (wndPtr)
3879 {
3880 if( wndPtr->hSysMenu )
3881 {
3882 if( bRevert )
3883 {
3884 DestroyMenu(wndPtr->hSysMenu);
3885 wndPtr->hSysMenu = 0;
3886 }
3887 else
3888 {
3889 POPUPMENU *menu = MENU_GetMenu( wndPtr->hSysMenu );
3890 if( menu )
3891 {
3892 if( menu->nItems > 0 && menu->items[0].hSubMenu == MENU_DefSysPopup )
3893 menu->items[0].hSubMenu = MENU_CopySysPopup();
3894 }
3895 else
3896 {
3897 WARN("Current sys-menu (%04x) of wnd %04x is broken\n",
3898 wndPtr->hSysMenu, hWnd);
3899 wndPtr->hSysMenu = 0;
3900 }
3901 }
3902 }
3903
3904 if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) )
3905 wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU)(-1) );
3906
3907 if( wndPtr->hSysMenu )
3908 {
3909 POPUPMENU *menu;
3910 retvalue = GetSubMenu(wndPtr->hSysMenu, 0);
3911
3912 /* Store the dummy sysmenu handle to facilitate the refresh */
3913 /* of the close button if the SC_CLOSE item change */
3914 menu = MENU_GetMenu(retvalue);
3915 if ( menu )
3916 menu->hSysMenuOwner = wndPtr->hSysMenu;
3917 }
3918 WIN_ReleaseWndPtr(wndPtr);
3919 }
3920 return bRevert ? 0 : retvalue;
3921 }
3922
3923
3924 /*******************************************************************
3925 * SetSystemMenu (USER32.@)
3926 */
3927 BOOL WINAPI SetSystemMenu( HWND hwnd, HMENU hMenu )
3928 {
3929 WND *wndPtr = WIN_FindWndPtr(hwnd);
3930
3931 if (wndPtr)
3932 {
3933 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
3934 wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu );
3935 WIN_ReleaseWndPtr(wndPtr);
3936 return TRUE;
3937 }
3938 return FALSE;
3939 }
3940
3941
3942 /**********************************************************************
3943 * GetMenu (USER32.@)
3944 */
3945 HMENU WINAPI GetMenu( HWND hWnd )
3946 {
3947 HMENU retvalue = (HMENU)GetWindowLongA( hWnd, GWL_ID );
3948 TRACE("for %04x returning %04x\n", hWnd, retvalue);
3949 return retvalue;
3950 }
3951
3952
3953 /**********************************************************************
3954 * SetMenu (USER32.@)
3955 */
3956 BOOL WINAPI SetMenu( HWND hWnd, HMENU hMenu )
3957 {
3958 TRACE("(%04x, %04x);\n", hWnd, hMenu);
3959
3960 if (hMenu && !IsMenu(hMenu))
3961 {
3962 WARN("hMenu %x is not a menu handle\n", hMenu);
3963 return FALSE;
3964 }
3965 if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
3966
3967 hWnd = WIN_GetFullHandle( hWnd );
3968 if (GetCapture() == hWnd) ReleaseCapture();
3969
3970 if (hMenu != 0)
3971 {
3972 LPPOPUPMENU lpmenu;
3973
3974 if (!(lpmenu = MENU_GetMenu(hMenu))) return FALSE;
3975
3976 lpmenu->hWnd = hWnd;
3977 lpmenu->Height = 0; /* Make sure we recalculate the size */
3978 }
3979 SetWindowLongA( hWnd, GWL_ID, hMenu );
3980
3981 if (IsWindowVisible(hWnd))
3982 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
3983 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
3984 return TRUE;
3985 }
3986
3987
3988
3989 /**********************************************************************
3990 * GetSubMenu (USER.159)
3991 */
3992 HMENU16 WINAPI GetSubMenu16( HMENU16 hMenu, INT16 nPos )
3993 {
3994 return GetSubMenu( hMenu, nPos );
3995 }
3996
3997
3998 /**********************************************************************
3999 * GetSubMenu (USER32.@)
4000 */
4001 HMENU WINAPI GetSubMenu( HMENU hMenu, INT nPos )
4002 {
4003 MENUITEM * lpmi;
4004
4005 if (!(lpmi = MENU_FindItem(&hMenu,&nPos,MF_BYPOSITION))) return 0;
4006 if (!(lpmi->fType & MF_POPUP)) return 0;
4007 return lpmi->hSubMenu;
4008 }
4009
4010
4011 /**********************************************************************
4012 * DrawMenuBar (USER32.@)
4013 */
4014 BOOL WINAPI DrawMenuBar( HWND hWnd )
4015 {
4016 LPPOPUPMENU lppop;
4017 HMENU hMenu = GetMenu(hWnd);
4018
4019 if (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) return FALSE;
4020 if (!hMenu || !(lppop = MENU_GetMenu( hMenu ))) return FALSE;
4021
4022 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
4023 lppop->hwndOwner = hWnd;
4024 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4025 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4026 return TRUE;
4027 }
4028
4029 /***********************************************************************
4030 * DrawMenuBarTemp (USER32.@)
4031 *
4032 * UNDOCUMENTED !!
4033 *
4034 * called by W98SE desk.cpl Control Panel Applet
4035 *
4036 * Not 100% sure about the param names, but close.
4037 */
4038 DWORD WINAPI DrawMenuBarTemp(HWND someHWND, HDC someHDC, LPRECT someRECT, HMENU someHMENU, HFONT someFONT)
4039 {
4040 FIXME("(0x%08x, 0x%08x, %p, 0x%08x, 0x%08x): stub\n", someHWND, someHDC, someRECT, someHMENU, someFONT);
4041 return 0;
4042 }
4043
4044 /***********************************************************************
4045 * EndMenu (USER.187)
4046 * EndMenu (USER32.@)
4047 */
4048 void WINAPI EndMenu(void)
4049 {
4050 /* if we are in the menu code, and it is active */
4051 if (!fEndMenu && top_popup)
4052 {
4053 /* terminate the menu handling code */
4054 fEndMenu = TRUE;
4055
4056 /* needs to be posted to wakeup the internal menu handler */
4057 /* which will now terminate the menu, in the event that */
4058 /* the main window was minimized, or lost focus, so we */
4059 /* don't end up with an orphaned menu */
4060 PostMessageA( top_popup, WM_CANCELMODE, 0, 0);
4061 }
4062 }
4063
4064
4065 /***********************************************************************
4066 * LookupMenuHandle (USER.217)
4067 */
4068 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
4069 {
4070 HMENU hmenu32 = hmenu;
4071 UINT id32 = id;
4072 if (!MENU_FindItem( &hmenu32, &id32, MF_BYCOMMAND )) return 0;
4073 else return hmenu32;
4074 }
4075
4076
4077 /**********************************************************************
4078 * LoadMenu (USER.150)
4079 */
4080 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
4081 {
4082 HRSRC16 hRsrc;
4083 HGLOBAL16 handle;
4084 HMENU16 hMenu;
4085
4086 TRACE("(%04x,%s)\n", instance, debugstr_a(name) );
4087
4088 if (HIWORD(name))
4089 {
4090 if (name[0] == '#') name = (LPCSTR)atoi( name + 1 );
4091 }
4092
4093 if (!name) return 0;
4094
4095 /* check for Win32 module */
4096 if (HIWORD(instance)) return LoadMenuA( instance, name );
4097 instance = GetExePtr( instance );
4098
4099 if (!(hRsrc = FindResource16( instance, name, RT_MENUA ))) return 0;
4100 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
4101 hMenu = LoadMenuIndirect16(LockResource16(handle));
4102 FreeResource16( handle );
4103 return hMenu;
4104 }
4105
4106
4107 /*****************************************************************
4108 * LoadMenuA (USER32.@)
4109 */
4110 HMENU WINAPI LoadMenuA( HINSTANCE instance, LPCSTR name )
4111 {
4112 HRSRC hrsrc = FindResourceA( instance, name, RT_MENUA );
4113 if (!hrsrc) return 0;
4114 return LoadMenuIndirectA( (LPCVOID)LoadResource( instance, hrsrc ));
4115 }
4116
4117
4118 /*****************************************************************
4119 * LoadMenuW (USER32.@)
4120 */
4121 HMENU WINAPI LoadMenuW( HINSTANCE instance, LPCWSTR name )
4122 {
4123 HRSRC hrsrc = FindResourceW( instance, name, RT_MENUW );
4124 if (!hrsrc) return 0;
4125 return LoadMenuIndirectW( (LPCVOID)LoadResource( instance, hrsrc ));
4126 }
4127
4128
4129 /**********************************************************************
4130 * LoadMenuIndirect (USER.220)
4131 */
4132 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
4133 {
4134 HMENU16 hMenu;
4135 WORD version, offset;
4136 LPCSTR p = (LPCSTR)template;
4137
4138 TRACE("(%p)\n", template );
4139 version = GET_WORD(p);
4140 p += sizeof(WORD);
4141 if (version)
4142 {
4143 WARN("version must be 0 for Win16\n" );
4144 return 0;
4145 }
4146 offset = GET_WORD(p);
4147 p += sizeof(WORD) + offset;
4148 if (!(hMenu = CreateMenu())) return 0;
4149 if (!MENU_ParseResource( p, hMenu, FALSE ))
4150 {
4151 DestroyMenu( hMenu );
4152 return 0;
4153 }
4154 return hMenu;
4155 }
4156
4157
4158 /**********************************************************************
4159 * LoadMenuIndirectA (USER32.@)
4160 */
4161 HMENU WINAPI LoadMenuIndirectA( LPCVOID template )
4162 {
4163 HMENU16 hMenu;
4164 WORD version, offset;
4165 LPCSTR p = (LPCSTR)template;
4166
4167 TRACE("%p\n", template );
4168 version = GET_WORD(p);
4169 p += sizeof(WORD);
4170 switch (version)
4171 {
4172 case 0:
4173 offset = GET_WORD(p);
4174 p += sizeof(WORD) + offset;
4175 if (!(hMenu = CreateMenu())) return 0;
4176 if (!MENU_ParseResource( p, hMenu, TRUE ))
4177 {
4178 DestroyMenu( hMenu );
4179 return 0;
4180 }
4181 return hMenu;
4182 case 1:
4183 offset = GET_WORD(p);
4184 p += sizeof(WORD) + offset;
4185 if (!(hMenu = CreateMenu())) return 0;
4186 if (!MENUEX_ParseResource( p, hMenu))
4187 {
4188 DestroyMenu( hMenu );
4189 return 0;
4190 }
4191 return hMenu;
4192 default:
4193 ERR("version %d not supported.\n", version);
4194 return 0;
4195 }
4196 }
4197
4198
4199 /**********************************************************************
4200 * LoadMenuIndirectW (USER32.@)
4201 */
4202 HMENU WINAPI LoadMenuIndirectW( LPCVOID template )
4203 {
4204 /* FIXME: is there anything different between A and W? */
4205 return LoadMenuIndirectA( template );
4206 }
4207
4208
4209 /**********************************************************************
4210 * IsMenu (USER.358)
4211 */
4212 BOOL16 WINAPI IsMenu16( HMENU16 hmenu )
4213 {
4214 return IsMenu( hmenu );
4215 }
4216
4217
4218 /**********************************************************************
4219 * IsMenu (USER32.@)
4220 */
4221 BOOL WINAPI IsMenu(HMENU hmenu)
4222 {
4223 LPPOPUPMENU menu = MENU_GetMenu(hmenu);
4224 return menu != NULL;
4225 }
4226
4227 /**********************************************************************
4228 * GetMenuItemInfo_common
4229 */
4230
4231 static BOOL GetMenuItemInfo_common ( HMENU hmenu, UINT item, BOOL bypos,
4232 LPMENUITEMINFOW lpmii, BOOL unicode)
4233 {
4234 MENUITEM *menu = MENU_FindItem (&hmenu, &item, bypos? MF_BYPOSITION : 0);
4235
4236 debug_print_menuitem("GetMenuItemInfo_common: ", menu, "");
4237
4238 if (!menu)
4239 return FALSE;
4240
4241 if (lpmii->fMask & MIIM_TYPE) {
4242 lpmii->fType = menu->fType;
4243 switch (MENU_ITEM_TYPE(menu->fType)) {
4244 case MF_STRING:
4245 break; /* will be done below */
4246 case MF_OWNERDRAW:
4247 case MF_BITMAP:
4248 lpmii->dwTypeData = menu->text;
4249 /* fall through */
4250 default:
4251 lpmii->cch = 0;
4252 }
4253 }
4254
4255 /* copy the text string */
4256 if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING)) &&
4257 (MENU_ITEM_TYPE(menu->fType) == MF_STRING) && menu->text)
4258 {
4259 int len;
4260 if (unicode)
4261 {
4262 len = strlenW(menu->text);
4263 if(lpmii->dwTypeData && lpmii->cch)
4264 lstrcpynW(lpmii->dwTypeData, menu->text, lpmii->cch);
4265 }
4266 else
4267 {
4268 len = WideCharToMultiByte( CP_ACP, 0, menu->text, -1, NULL, 0, NULL, NULL );
4269 if(lpmii->dwTypeData && lpmii->cch)
4270 if (!WideCharToMultiByte( CP_ACP, 0, menu->text, -1,
4271 (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
4272 ((LPSTR)lpmii->dwTypeData)[lpmii->cch-1] = 0;
4273 }
4274 /* if we've copied a substring we return its length */
4275 if(lpmii->dwTypeData && lpmii->cch)
4276 {
4277 if (lpmii->cch <= len) lpmii->cch--;
4278 }
4279 else /* return length of string */
4280 lpmii->cch = len;
4281 }
4282
4283 if (lpmii->fMask & MIIM_FTYPE)
4284 lpmii->fType = menu->fType;
4285
4286 if (lpmii->fMask & MIIM_BITMAP)
4287 lpmii->hbmpItem = menu->hbmpItem;
4288
4289 if (lpmii->fMask & MIIM_STATE)
4290 lpmii->fState = menu->fState;
4291
4292 if (lpmii->fMask & MIIM_ID)
4293 lpmii->wID = menu->wID;
4294
4295 if (lpmii->fMask & MIIM_SUBMENU)
4296 lpmii->hSubMenu = menu->hSubMenu;
4297
4298 if (lpmii->fMask & MIIM_CHECKMARKS) {
4299 lpmii->hbmpChecked = menu->hCheckBit;
4300 lpmii->hbmpUnchecked = menu->hUnCheckBit;
4301 }
4302 if (lpmii->fMask & MIIM_DATA)
4303 lpmii->dwItemData = menu->dwItemData;
4304
4305 return TRUE;
4306 }
4307
4308 /**********************************************************************
4309 * GetMenuItemInfoA (USER32.@)
4310 */
4311 BOOL WINAPI GetMenuItemInfoA( HMENU hmenu, UINT item, BOOL bypos,
4312 LPMENUITEMINFOA lpmii)
4313 {
4314 return GetMenuItemInfo_common (hmenu, item, bypos,
4315 (LPMENUITEMINFOW)lpmii, FALSE);
4316 }
4317
4318 /**********************************************************************
4319 * GetMenuItemInfoW (USER32.@)
4320 */
4321 BOOL WINAPI GetMenuItemInfoW( HMENU hmenu, UINT item, BOOL bypos,
4322 LPMENUITEMINFOW lpmii)
4323 {
4324 return GetMenuItemInfo_common (hmenu, item, bypos,
4325 lpmii, TRUE);
4326 }
4327
4328
4329 /* set a menu item text from a ASCII or Unicode string */
4330 inline static void set_menu_item_text( MENUITEM *menu, LPCWSTR text, BOOL unicode )
4331 {
4332 if (!text)
4333 {
4334 menu->text = NULL;
4335 menu->fType |= MF_SEPARATOR;
4336 }
4337 else if (unicode)
4338 {
4339 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, (strlenW(text)+1) * sizeof(WCHAR) )))
4340 strcpyW( menu->text, text );
4341 }
4342 else
4343 {
4344 LPCSTR str = (LPCSTR)text;
4345 int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
4346 if ((menu->text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
4347 MultiByteToWideChar( CP_ACP, 0, str, -1, menu->text, len );
4348 }
4349 }
4350
4351
4352 /**********************************************************************
4353 * SetMenuItemInfo_common
4354 */
4355
4356 static BOOL SetMenuItemInfo_common(MENUITEM * menu,
4357 const MENUITEMINFOW *lpmii,
4358 BOOL unicode)
4359 {
4360 if (!menu) return FALSE;
4361
4362 debug_print_menuitem("MENU_SetItemInfo_common from: ", menu, "");
4363
4364 if (lpmii->fMask & MIIM_TYPE ) {
4365 /* Get rid of old string. */
4366 if ( IS_STRING_ITEM(menu->fType) && menu->text) {
4367 HeapFree(GetProcessHeap(), 0, menu->text);
4368 menu->text = NULL;
4369 }
4370
4371 /* make only MENU_ITEM_TYPE bits in menu->fType equal lpmii->fType */
4372 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4373 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4374
4375 menu->text = lpmii->dwTypeData;
4376
4377 if (IS_STRING_ITEM(menu->fType))
4378 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4379 }
4380
4381 if (lpmii->fMask & MIIM_FTYPE ) {
4382 /* free the string when the type is changing */
4383 if ( (!IS_STRING_ITEM(lpmii->fType)) && IS_STRING_ITEM(menu->fType) && menu->text) {
4384 HeapFree(GetProcessHeap(), 0, menu->text);
4385 menu->text = NULL;
4386 }
4387 menu->fType &= ~MENU_ITEM_TYPE(menu->fType);
4388 menu->fType |= MENU_ITEM_TYPE(lpmii->fType);
4389 if ( IS_STRING_ITEM(menu->fType) && !menu->text )
4390 menu->fType |= MF_SEPARATOR;
4391 }
4392
4393 if (lpmii->fMask & MIIM_STRING ) {
4394 /* free the string when used */
4395 if ( IS_STRING_ITEM(menu->fType) && menu->text) {
4396 HeapFree(GetProcessHeap(), 0, menu->text);
4397 set_menu_item_text( menu, lpmii->dwTypeData, unicode );
4398 }
4399 }
4400
4401 if (lpmii->fMask & MIIM_STATE)
4402 {
4403 /* FIXME: MFS_DEFAULT do we have to reset the other menu items? */
4404 menu->fState = lpmii->fState;
4405 }
4406
4407 if (lpmii->fMask & MIIM_ID)
4408 menu->wID = lpmii->wID;
4409
4410 if (lpmii->fMask & MIIM_SUBMENU) {
4411 menu->hSubMenu = lpmii->hSubMenu;
4412 if (menu->hSubMenu) {
4413 POPUPMENU *subMenu = MENU_GetMenu((UINT16)menu->hSubMenu);
4414 if (subMenu) {
4415 subMenu->wFlags |= MF_POPUP;
4416 menu->fType |= MF_POPUP;
4417 }
4418 else
4419 /* FIXME: Return an error ? */
4420 menu->fType &= ~MF_POPUP;
4421 }
4422 else
4423 menu->fType &= ~MF_POPUP;
4424 }
4425
4426 if (lpmii->fMask & MIIM_CHECKMARKS)
4427 {
4428 if (lpmii->fType & MFT_RADIOCHECK)
4429 menu->fType |= MFT_RADIOCHECK;
4430
4431 menu->hCheckBit = lpmii->hbmpChecked;
4432 menu->hUnCheckBit = lpmii->hbmpUnchecked;
4433 }
4434 if (lpmii->fMask & MIIM_DATA)
4435 menu->dwItemData = lpmii->dwItemData;
4436
4437 debug_print_menuitem("SetMenuItemInfo_common to : ", menu, "");
4438 return TRUE;
4439 }
4440
4441 /**********************************************************************
4442 * SetMenuItemInfoA (USER32.@)
4443 */
4444 BOOL WINAPI SetMenuItemInfoA(HMENU hmenu, UINT item, BOOL bypos,
4445 const MENUITEMINFOA *lpmii)
4446 {
4447 if ((lpmii->fType & (MF_HILITE|MF_POPUP)) || (lpmii->fState)) {
4448 /* QuickTime does pass invalid data into SetMenuItemInfo.
4449 * do some of the checks Windows does.
4450 */
4451 WARN("Bad masks for type (0x%08x) or state (0x%08x)\n",
4452 lpmii->fType,lpmii->fState );
4453 return FALSE;
4454 }
4455
4456 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4457 (const MENUITEMINFOW *)lpmii, FALSE);
4458 }
4459
4460 /**********************************************************************
4461 * SetMenuItemInfoW (USER32.@)
4462 */
4463 BOOL WINAPI SetMenuItemInfoW(HMENU hmenu, UINT item, BOOL bypos,
4464 const MENUITEMINFOW *lpmii)
4465 {
4466 return SetMenuItemInfo_common(MENU_FindItem(&hmenu, &item, bypos? MF_BYPOSITION : 0),
4467 lpmii, TRUE);
4468 }
4469
4470 /**********************************************************************
4471 * SetMenuDefaultItem (USER32.@)
4472 *
4473 */
4474 BOOL WINAPI SetMenuDefaultItem(HMENU hmenu, UINT uItem, UINT bypos)
4475 {
4476 UINT i;
4477 POPUPMENU *menu;
4478 MENUITEM *item;
4479
4480 TRACE("(0x%x,%d,%d)\n", hmenu, uItem, bypos);
4481
4482 if (!(menu = MENU_GetMenu(hmenu))) return FALSE;
4483
4484 /* reset all default-item flags */
4485 item = menu->items;
4486 for (i = 0; i < menu->nItems; i++, item++)
4487 {
4488 item->fState &= ~MFS_DEFAULT;
4489 }
4490
4491 /* no default item */
4492 if ( -1 == uItem)
4493 {
4494 return TRUE;
4495 }
4496
4497 item = menu->items;
4498 if ( bypos )
4499 {
4500 if ( uItem >= menu->nItems ) return FALSE;
4501 item[uItem].fState |= MFS_DEFAULT;
4502 return TRUE;
4503 }
4504 else
4505 {
4506 for (i = 0; i < menu->nItems; i++, item++)
4507 {
4508 if (item->wID == uItem)
4509 {
4510 item->fState |= MFS_DEFAULT;
4511 return TRUE;
4512 }
4513 }
4514
4515 }
4516 return FALSE;
4517 }
4518
4519 /**********************************************************************
4520 * GetMenuDefaultItem (USER32.@)
4521 */
4522 UINT WINAPI GetMenuDefaultItem(HMENU hmenu, UINT bypos, UINT flags)
4523 {
4524 POPUPMENU *menu;
4525 MENUITEM * item;
4526 UINT i = 0;
4527
4528 TRACE("(0x%x,%d,%d)\n", hmenu, bypos, flags);
4529
4530 if (!(menu = MENU_GetMenu(hmenu))) return -1;
4531
4532 /* find default item */
4533 item = menu->items;
4534
4535 /* empty menu */
4536 if (! item) return -1;
4537
4538 while ( !( item->fState & MFS_DEFAULT ) )
4539 {
4540 i++; item++;
4541 if (i >= menu->nItems ) return -1;
4542 }
4543
4544 /* default: don't return disabled items */
4545 if ( (!(GMDI_USEDISABLED & flags)) && (item->fState & MFS_DISABLED )) return -1;
4546
4547 /* search rekursiv when needed */
4548 if ( (item->fType & MF_POPUP) && (flags & GMDI_GOINTOPOPUPS) )
4549 {
4550 UINT ret;
4551 ret = GetMenuDefaultItem( item->hSubMenu, bypos, flags );
4552 if ( -1 != ret ) return ret;
4553
4554 /* when item not found in submenu, return the popup item */
4555 }
4556 return ( bypos ) ? i : item->wID;
4557
4558 }
4559
4560 /*******************************************************************
4561 * InsertMenuItem (USER.441)
4562 *
4563 * FIXME: untested
4564 */
4565 BOOL16 WINAPI InsertMenuItem16( HMENU16 hmenu, UINT16 pos, BOOL16 byposition,
4566 const MENUITEMINFO16 *mii )
4567 {
4568 MENUITEMINFOA miia;
4569
4570 miia.cbSize = sizeof(miia);
4571 miia.fMask = mii->fMask;
4572 miia.dwTypeData = (LPSTR)mii->dwTypeData;
4573 miia.fType = mii->fType;
4574 miia.fState = mii->fState;
4575 miia.wID = mii->wID;
4576 miia.hSubMenu = mii->hSubMenu;
4577 miia.hbmpChecked = mii->hbmpChecked;
4578 miia.hbmpUnchecked = mii->hbmpUnchecked;
4579 miia.dwItemData = mii->dwItemData;
4580 miia.cch = mii->cch;
4581 if (IS_STRING_ITEM(miia.fType))
4582 miia.dwTypeData = MapSL(mii->dwTypeData);
4583 return InsertMenuItemA( hmenu, pos, byposition, &miia );
4584 }
4585
4586
4587 /**********************************************************************
4588 * InsertMenuItemA (USER32.@)
4589 */
4590 BOOL WINAPI InsertMenuItemA(HMENU hMenu, UINT uItem, BOOL bypos,
4591 const MENUITEMINFOA *lpmii)
4592 {
4593 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4594 return SetMenuItemInfo_common(item, (const MENUITEMINFOW *)lpmii, FALSE);
4595 }
4596
4597
4598 /**********************************************************************
4599 * InsertMenuItemW (USER32.@)
4600 */
4601 BOOL WINAPI InsertMenuItemW(HMENU hMenu, UINT uItem, BOOL bypos,
4602 const MENUITEMINFOW *lpmii)
4603 {
4604 MENUITEM *item = MENU_InsertItem(hMenu, uItem, bypos ? MF_BYPOSITION : 0 );
4605 return SetMenuItemInfo_common(item, lpmii, TRUE);
4606 }
4607
4608 /**********************************************************************
4609 * CheckMenuRadioItem (USER32.@)
4610 */
4611
4612 BOOL WINAPI CheckMenuRadioItem(HMENU hMenu,
4613 UINT first, UINT last, UINT check,
4614 UINT bypos)
4615 {
4616 MENUITEM *mifirst, *milast, *micheck;
4617 HMENU mfirst = hMenu, mlast = hMenu, mcheck = hMenu;
4618
4619 TRACE("ox%x: %d-%d, check %d, bypos=%d\n",
4620 hMenu, first, last, check, bypos);
4621
4622 mifirst = MENU_FindItem (&mfirst, &first, bypos);
4623 milast = MENU_FindItem (&mlast, &last, bypos);
4624 micheck = MENU_FindItem (&mcheck, &check, bypos);
4625
4626 if (mifirst == NULL || milast == NULL || micheck == NULL ||
4627 mifirst > milast || mfirst != mlast || mfirst != mcheck ||
4628 micheck > milast || micheck < mifirst)
4629 return FALSE;
4630
4631 while (mifirst <= milast)
4632 {
4633 if (mifirst == micheck)
4634 {
4635 mifirst->fType |= MFT_RADIOCHECK;
4636 mifirst->fState |= MFS_CHECKED;
4637 } else {
4638 mifirst->fType &= ~MFT_RADIOCHECK;
4639 mifirst->fState &= ~MFS_CHECKED;
4640 }
4641 mifirst++;
4642 }
4643
4644 return TRUE;
4645 }
4646
4647 /**********************************************************************
4648 * CheckMenuRadioItem (USER.666)
4649 */
4650 BOOL16 WINAPI CheckMenuRadioItem16(HMENU16 hMenu,
4651 UINT16 first, UINT16 last, UINT16 check,
4652 BOOL16 bypos)
4653 {
4654 return CheckMenuRadioItem (hMenu, first, last, check, bypos);
4655 }
4656
4657 /**********************************************************************
4658 * GetMenuItemRect (USER32.@)
4659 *
4660 * ATTENTION: Here, the returned values in rect are the screen
4661 * coordinates of the item just like if the menu was
4662 * always on the upper left side of the application.
4663 *
4664 */
4665 BOOL WINAPI GetMenuItemRect (HWND hwnd, HMENU hMenu, UINT uItem,
4666 LPRECT rect)
4667 {
4668 POPUPMENU *itemMenu;
4669 MENUITEM *item;
4670 HWND referenceHwnd;
4671
4672 TRACE("(0x%x,0x%x,%d,%p)\n", hwnd, hMenu, uItem, rect);
4673
4674 item = MENU_FindItem (&hMenu, &uItem, MF_BYPOSITION);
4675 referenceHwnd = hwnd;
4676
4677 if(!hwnd)
4678 {
4679 itemMenu = MENU_GetMenu(hMenu);
4680 if (itemMenu == NULL)
4681 return FALSE;
4682
4683 if(itemMenu->hWnd == 0)
4684 return FALSE;
4685 referenceHwnd = itemMenu->hWnd;
4686 }
4687
4688 if ((rect == NULL) || (item == NULL))
4689 return FALSE;
4690
4691 *rect = item->rect;
4692
4693 MapWindowPoints(referenceHwnd, 0, (LPPOINT)rect, 2);
4694
4695 return TRUE;
4696 }
4697
4698
4699 /**********************************************************************
4700 * SetMenuInfo (USER32.@)
4701 *
4702 * FIXME
4703 * MIM_APPLYTOSUBMENUS
4704 * actually use the items to draw the menu
4705 */
4706 BOOL WINAPI SetMenuInfo (HMENU hMenu, LPCMENUINFO lpmi)
4707 {
4708 POPUPMENU *menu;
4709
4710 TRACE("(0x%04x %p)\n", hMenu, lpmi);
4711
4712 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)) && (menu = MENU_GetMenu(hMenu)))
4713 {
4714
4715 if (lpmi->fMask & MIM_BACKGROUND)
4716 menu->hbrBack = lpmi->hbrBack;
4717
4718 if (lpmi->fMask & MIM_HELPID)
4719 menu->dwContextHelpID = lpmi->dwContextHelpID;
4720
4721 if (lpmi->fMask & MIM_MAXHEIGHT)
4722 menu->cyMax = lpmi->cyMax;
4723
4724 if (lpmi->fMask & MIM_MENUDATA)
4725 menu->dwMenuData = lpmi->dwMenuData;
4726
4727 if (lpmi->fMask & MIM_STYLE)
4728 menu->dwStyle = lpmi->dwStyle;
4729
4730 return TRUE;
4731 }
4732 return FALSE;
4733 }
4734
4735 /**********************************************************************
4736 * GetMenuInfo (USER32.@)
4737 *
4738 * NOTES
4739 * win98/NT5.0
4740 *
4741 */
4742 BOOL WINAPI GetMenuInfo (HMENU hMenu, LPMENUINFO lpmi)
4743 { POPUPMENU *menu;
4744
4745 TRACE("(0x%04x %p)\n", hMenu, lpmi);
4746
4747 if (lpmi && (menu = MENU_GetMenu(hMenu)))
4748 {
4749
4750 if (lpmi->fMask & MIM_BACKGROUND)
4751 lpmi->hbrBack = menu->hbrBack;
4752
4753 if (lpmi->fMask & MIM_HELPID)
4754 lpmi->dwContextHelpID = menu->dwContextHelpID;
4755
4756 if (lpmi->fMask & MIM_MAXHEIGHT)
4757 lpmi->cyMax = menu->cyMax;
4758
4759 if (lpmi->fMask & MIM_MENUDATA)
4760 lpmi->dwMenuData = menu->dwMenuData;
4761
4762 if (lpmi->fMask & MIM_STYLE)
4763 lpmi->dwStyle = menu->dwStyle;
4764
4765 return TRUE;
4766 }
4767 return FALSE;
4768 }
4769
4770 /**********************************************************************
4771 * SetMenuContextHelpId (USER.384)
4772 */
4773 BOOL16 WINAPI SetMenuContextHelpId16( HMENU16 hMenu, DWORD dwContextHelpID)
4774 {
4775 return SetMenuContextHelpId( hMenu, dwContextHelpID );
4776 }
4777
4778
4779 /**********************************************************************
4780 * SetMenuContextHelpId (USER32.@)
4781 */
4782 BOOL WINAPI SetMenuContextHelpId( HMENU hMenu, DWORD dwContextHelpID)
4783 {
4784 LPPOPUPMENU menu;
4785
4786 TRACE("(0x%04x 0x%08lx)\n", hMenu, dwContextHelpID);
4787
4788 if ((menu = MENU_GetMenu(hMenu)))
4789 {
4790 menu->dwContextHelpID = dwContextHelpID;
4791 return TRUE;
4792 }
4793 return FALSE;
4794 }
4795
4796 /**********************************************************************
4797 * GetMenuContextHelpId (USER.385)
4798 */
4799 DWORD WINAPI GetMenuContextHelpId16( HMENU16 hMenu )
4800 {
4801 return GetMenuContextHelpId( hMenu );
4802 }
4803
4804 /**********************************************************************
4805 * GetMenuContextHelpId (USER32.@)
4806 */
4807 DWORD WINAPI GetMenuContextHelpId( HMENU hMenu )
4808 {
4809 LPPOPUPMENU menu;
4810
4811 TRACE("(0x%04x)\n", hMenu);
4812
4813 if ((menu = MENU_GetMenu(hMenu)))
4814 {
4815 return menu->dwContextHelpID;
4816 }
4817 return 0;
4818 }
4819
4820 /**********************************************************************
4821 * MenuItemFromPoint (USER32.@)
4822 */
4823 UINT WINAPI MenuItemFromPoint(HWND hWnd, HMENU hMenu, POINT ptScreen)
4824 {
4825 POPUPMENU *menu = MENU_GetMenu(hMenu);
4826 UINT pos;
4827 MENUITEM *item;
4828
4829 /*FIXME: Do we have to handle hWnd here? */
4830 item = MENU_FindItemByCoords(menu, ptScreen, &pos);
4831
4832 return pos;
4833 }
4834
4835
4836 /**********************************************************************
4837 * translate_accelerator
4838 */
4839 static BOOL translate_accelerator( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
4840 BYTE fVirt, WORD key, WORD cmd )
4841 {
4842 UINT mesg = 0;
4843
4844 if (wParam != key) return FALSE;
4845
4846 if (message == WM_CHAR)
4847 {
4848 if ( !(fVirt & FALT) && !(fVirt & FVIRTKEY) )
4849 {
4850 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", wParam & 0xff);
4851 goto found;
4852 }
4853 }
4854 else
4855 {
4856 if(fVirt & FVIRTKEY)
4857 {
4858 INT mask = 0;
4859 TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
4860 wParam, 0xff & HIWORD(lParam));
4861 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
4862 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
4863 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
4864 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
4865 TRACE_(accel)(", but incorrect SHIFT/CTRL/ALT-state\n");
4866 }
4867 else
4868 {
4869 if (!(lParam & 0x01000000)) /* no special_key */
4870 {
4871 if ((fVirt & FALT) && (lParam & 0x20000000))
4872 { /* ^^ ALT pressed */
4873 TRACE_(accel)("found accel for Alt-%c\n", wParam & 0xff);
4874 goto found;
4875 }
4876 }
4877 }
4878 }
4879 return FALSE;
4880
4881 found:
4882 if (message == WM_KEYUP || message == WM_SYSKEYUP)
4883 mesg = 1;
4884 else if (GetCapture())
4885 mesg = 2;
4886 else if (!IsWindowEnabled(hWnd))
4887 mesg = 3;
4888 else
4889 {
4890 HMENU hMenu, hSubMenu, hSysMenu;
4891 UINT uSysStat = (UINT)-1, uStat = (UINT)-1, nPos;
4892
4893 hMenu = (GetWindowLongA( hWnd, GWL_STYLE ) & WS_CHILD) ? 0 : GetMenu(hWnd);
4894 hSysMenu = get_win_sys_menu( hWnd );
4895
4896 /* find menu item and ask application to initialize it */
4897 /* 1. in the system menu */
4898 hSubMenu = hSysMenu;
4899 nPos = cmd;
4900 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4901 {
4902 SendMessageA(hWnd, WM_INITMENU, (WPARAM)hSysMenu, 0L);
4903 if(hSubMenu != hSysMenu)
4904 {
4905 nPos = MENU_FindSubMenu(&hSysMenu, hSubMenu);
4906 TRACE_(accel)("hSysMenu = %04x, hSubMenu = %04x, nPos = %d\n", hSysMenu, hSubMenu, nPos);
4907 SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, TRUE));
4908 }
4909 uSysStat = GetMenuState(GetSubMenu(hSysMenu, 0), cmd, MF_BYCOMMAND);
4910 }
4911 else /* 2. in the window's menu */
4912 {
4913 hSubMenu = hMenu;
4914 nPos = cmd;
4915 if(MENU_FindItem(&hSubMenu, &nPos, MF_BYCOMMAND))
4916 {
4917 SendMessageA(hWnd, WM_INITMENU, (WPARAM)hMenu, 0L);
4918 if(hSubMenu != hMenu)
4919 {
4920 nPos = MENU_FindSubMenu(&hMenu, hSubMenu);
4921 TRACE_(accel)("hMenu = %04x, hSubMenu = %04x, nPos = %d\n", hMenu, hSubMenu, nPos);
4922 SendMessageA(hWnd, WM_INITMENUPOPUP, (WPARAM)hSubMenu, MAKELPARAM(nPos, FALSE));
4923 }
4924 uStat = GetMenuState(hMenu, cmd, MF_BYCOMMAND);
4925 }
4926 }
4927
4928 if (uSysStat != (UINT)-1)
4929 {
4930 if (uSysStat & (MF_DISABLED|MF_GRAYED))
4931 mesg=4;
4932 else
4933 mesg=WM_SYSCOMMAND;
4934 }
4935 else
4936 {
4937 if (uStat != (UINT)-1)
4938 {
4939 if (IsIconic(hWnd))
4940 mesg=5;
4941 else
4942 {
4943 if (uStat & (MF_DISABLED|MF_GRAYED))
4944 mesg=6;
4945 else
4946 mesg=WM_COMMAND;
4947 }
4948 }
4949 else
4950 mesg=WM_COMMAND;
4951 }
4952 }
4953
4954 if( mesg==WM_COMMAND )
4955 {
4956 TRACE_(accel)(", sending WM_COMMAND, wParam=%0x\n", 0x10000 | cmd);
4957 SendMessageA(hWnd, mesg, 0x10000 | cmd, 0L);
4958 }
4959 else if( mesg==WM_SYSCOMMAND )
4960 {
4961 TRACE_(accel)(", sending WM_SYSCOMMAND, wParam=%0x\n", cmd);
4962 SendMessageA(hWnd, mesg, cmd, 0x00010000L);
4963 }
4964 else
4965 {
4966 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
4967 * #0: unknown (please report!)
4968 * #1: for WM_KEYUP,WM_SYSKEYUP
4969 * #2: mouse is captured
4970 * #3: window is disabled
4971 * #4: it's a disabled system menu option
4972 * #5: it's a menu option, but window is iconic
4973 * #6: it's a menu option, but disabled
4974 */
4975 TRACE_(accel)(", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
4976 if(mesg==0)
4977 ERR_(accel)(" unknown reason - please report!");
4978 }
4979 return TRUE;
4980 }
4981
4982 /**********************************************************************
4983 * TranslateAccelerator (USER32.@)
4984 * TranslateAcceleratorA (USER32.@)
4985 * TranslateAcceleratorW (USER32.@)
4986 */
4987 INT WINAPI TranslateAccelerator( HWND hWnd, HACCEL hAccel, LPMSG msg )
4988 {
4989 /* YES, Accel16! */
4990 LPACCEL16 lpAccelTbl;
4991 int i;
4992
4993 if (msg == NULL)
4994 {
4995 WARN_(accel)("msg null; should hang here to be win compatible\n");
4996 return 0;
4997 }
4998 if (!hAccel || !(lpAccelTbl = (LPACCEL16) LockResource16(hAccel)))
4999 {
5000 WARN_(accel)("invalid accel handle=%x\n", hAccel);
5001 return 0;
5002 }
5003 if ((msg->message != WM_KEYDOWN &&
5004 msg->message != WM_KEYUP &&
5005 msg->message != WM_SYSKEYDOWN &&
5006 msg->message != WM_SYSKEYUP &&
5007 msg->message != WM_CHAR)) return 0;
5008
5009 TRACE_(accel)("TranslateAccelerators hAccel=%04x, hWnd=%04x,"
5010 "msg->hwnd=%04x, msg->message=%04x, wParam=%08x, lParam=%lx\n",
5011 hAccel,hWnd,msg->hwnd,msg->message,msg->wParam,msg->lParam);
5012
5013 i = 0;
5014 do
5015 {
5016 if (translate_accelerator( hWnd, msg->message, msg->wParam, msg->lParam,
5017 lpAccelTbl[i].fVirt, lpAccelTbl[i].key, lpAccelTbl[i].cmd))
5018 return 1;
5019 } while ((lpAccelTbl[i++].fVirt & 0x80) == 0);
5020 WARN_(accel)("couldn't translate accelerator key\n");
5021 return 0;
5022 }
Maarten's multimedia branch