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