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