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