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