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