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