?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 960717
[wine/multimedia.git] / controls / menu.c
blobc88082927d0a73d24a01ad2b362672eba1d7c9bc
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 <ctype.h>
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <string.h>
18 #include "windows.h"
19 #include "syscolor.h"
20 #include "sysmetrics.h"
21 #include "task.h"
22 #include "win.h"
23 #include "heap.h"
24 #include "menu.h"
25 #include "module.h"
26 #include "neexe.h"
27 #include "user.h"
28 #include "message.h"
29 #include "graphics.h"
30 #include "resource.h"
31 #include "string32.h"
32 #include "stddebug.h"
33 #include "debug.h"
34
35 /* Menu item structure */
36 typedef struct
37 {
38 WORD item_flags; /* Item flags */
39 UINT item_id; /* Item or popup id */
40 RECT16 rect; /* Item area (relative to menu window) */
41 WORD xTab; /* X position of text after Tab */
42 HBITMAP hCheckBit; /* Bitmap for checked item */
43 HBITMAP hUnCheckBit; /* Bitmap for unchecked item */
44 LPSTR text; /* Item text or bitmap handle */
45 } MENUITEM;
46
47 /* Popup menu structure */
48 typedef struct
49 {
50 WORD wFlags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
51 WORD wMagic; /* Magic number */
52 HANDLE hTaskQ; /* Task queue for this menu */
53 WORD Width; /* Width of the whole menu */
54 WORD Height; /* Height of the whole menu */
55 WORD nItems; /* Number of items in the menu */
56 HWND hWnd; /* Window containing the menu */
57 MENUITEM *items; /* Array of menu items */
58 UINT FocusedItem; /* Currently focused item */
59 } POPUPMENU, *LPPOPUPMENU;
60
61 #define MENU_MAGIC 0x554d /* 'MU' */
62
63 /* Dimension of the menu bitmaps */
64 static WORD check_bitmap_width = 0, check_bitmap_height = 0;
65 static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0;
66
67 /* Flag set by EndMenu() to force an exit from menu tracking */
68 static BOOL fEndMenuCalled = FALSE;
69
70 /* Space between 2 menu bar items */
71 #define MENU_BAR_ITEMS_SPACE 16
72
73 /* Minimum width of a tab character */
74 #define MENU_TAB_SPACE 8
75
76 /* Height of a separator item */
77 #define SEPARATOR_HEIGHT 5
78
79 /* Values for menu->FocusedItem */
80 /* (other values give the position of the focused item) */
81 #define NO_SELECTED_ITEM 0xffff
82 #define SYSMENU_SELECTED 0xfffe /* Only valid on menu-bars */
83
84 #define IS_STRING_ITEM(flags) (!((flags) & (MF_BITMAP | MF_OWNERDRAW | \
85 MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR)))
86
87 extern void NC_DrawSysButton(HWND hwnd, HDC hdc, BOOL down); /* nonclient.c */
88
89 static HBITMAP hStdCheck = 0;
90 static HBITMAP hStdMnArrow = 0;
91 static HMENU MENU_DefSysMenu = 0; /* Default system menu */
92
93
94 /* we _can_ use global popup window because there's no way 2 menues can
95 * be tracked at the same time.
96 */
97
98 static WND* pTopPWnd = 0;
99 static UINT uSubPWndLevel = 0;
100
101
102 /**********************************************************************
103 * MENU_CopySysMenu
104 *
105 * Load a copy of the system menu.
106 */
107 static HMENU MENU_CopySysMenu(void)
108 {
109 HMENU hMenu;
110 HGLOBAL handle;
111 POPUPMENU *menu;
112
113 if (!(handle = SYSRES_LoadResource( SYSRES_MENU_SYSMENU ))) return 0;
114 hMenu = LoadMenuIndirect16( GlobalLock16( handle ) );
115 SYSRES_FreeResource( handle );
116 if (!hMenu)
117 {
118 dprintf_menu(stddeb,"No SYSMENU\n");
119 return 0;
120 }
121 menu = (POPUPMENU*) USER_HEAP_LIN_ADDR(hMenu);
122 menu->wFlags |= MF_SYSMENU | MF_POPUP;
123 dprintf_menu(stddeb,"CopySysMenu hMenu=%04x !\n", hMenu);
124 return hMenu;
125 }
126
127
128 /***********************************************************************
129 * MENU_Init
130 *
131 * Menus initialisation.
132 */
133 BOOL MENU_Init()
134 {
135 BITMAP16 bm;
136
137 /* Load bitmaps */
138
139 if (!(hStdCheck = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_CHECK) )))
140 return FALSE;
141 GetObject16( hStdCheck, sizeof(bm), &bm );
142 check_bitmap_width = bm.bmWidth;
143 check_bitmap_height = bm.bmHeight;
144 if (!(hStdMnArrow = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_MNARROW) )))
145 return FALSE;
146 GetObject16( hStdMnArrow, sizeof(bm), &bm );
147 arrow_bitmap_width = bm.bmWidth;
148 arrow_bitmap_height = bm.bmHeight;
149
150 if (!(MENU_DefSysMenu = MENU_CopySysMenu()))
151 {
152 fprintf( stderr, "Unable to create default system menu\n" );
153 return FALSE;
154 }
155 return TRUE;
156 }
157
158
159 /***********************************************************************
160 * MENU_GetDefSysMenu
161 *
162 * Return the default system menu.
163 */
164 HMENU MENU_GetDefSysMenu(void)
165 {
166 return MENU_DefSysMenu;
167 }
168
169
170 /***********************************************************************
171 * MENU_HasSysMenu
172 *
173 * Check whether the window owning the menu bar has a system menu.
174 */
175 static BOOL MENU_HasSysMenu( POPUPMENU *menu )
176 {
177 WND *wndPtr;
178
179 if (menu->wFlags & MF_POPUP) return FALSE;
180 if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE;
181 return (wndPtr->dwStyle & WS_SYSMENU) != 0;
182 }
183
184
185 /***********************************************************************
186 * MENU_IsInSysMenu
187 *
188 * Check whether the point (in screen coords) is in the system menu
189 * of the window owning the given menu.
190 */
191 static BOOL MENU_IsInSysMenu( POPUPMENU *menu, POINT16 pt )
192 {
193 WND *wndPtr;
194
195 if (menu->wFlags & MF_POPUP) return FALSE;
196 if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE;
197 if (!(wndPtr->dwStyle & WS_SYSMENU)) return FALSE;
198 if ((pt.x < wndPtr->rectClient.left) ||
199 (pt.x >= wndPtr->rectClient.left+SYSMETRICS_CXSIZE+SYSMETRICS_CXBORDER))
200 return FALSE;
201 if ((pt.y >= wndPtr->rectClient.top - menu->Height) ||
202 (pt.y < wndPtr->rectClient.top - menu->Height -
203 SYSMETRICS_CYSIZE - SYSMETRICS_CYBORDER)) return FALSE;
204 return TRUE;
205 }
206
207
208 /***********************************************************************
209 * MENU_FindItem
210 *
211 * Find a menu item. Return a pointer on the item, and modifies *hmenu
212 * in case the item was in a sub-menu.
213 */
214 static MENUITEM *MENU_FindItem( HMENU *hmenu, UINT *nPos, UINT wFlags )
215 {
216 POPUPMENU *menu;
217 int i;
218
219 if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR(*hmenu))) return NULL;
220 if (wFlags & MF_BYPOSITION)
221 {
222 if (*nPos >= menu->nItems) return NULL;
223 return &menu->items[*nPos];
224 }
225 else
226 {
227 MENUITEM *item = menu->items;
228 for (i = 0; i < menu->nItems; i++, item++)
229 {
230 if (item->item_id == *nPos)
231 {
232 *nPos = i;
233 return item;
234 }
235 else if (item->item_flags & MF_POPUP)
236 {
237 HMENU hsubmenu = (HMENU)item->item_id;
238 MENUITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
239 if (subitem)
240 {
241 *hmenu = hsubmenu;
242 return subitem;
243 }
244 }
245 }
246 }
247 return NULL;
248 }
249
250
251 /***********************************************************************
252 * MENU_FindItemByCoords
253 *
254 * Find the item at the specified coordinates (screen coords).
255 */
256 static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu, int x, int y, UINT *pos )
257 {
258 MENUITEM *item;
259 WND *wndPtr;
260 int i;
261
262 if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return NULL;
263 x -= wndPtr->rectWindow.left;
264 y -= wndPtr->rectWindow.top;
265 item = menu->items;
266 for (i = 0; i < menu->nItems; i++, item++)
267 {
268 if ((x >= item->rect.left) && (x < item->rect.right) &&
269 (y >= item->rect.top) && (y < item->rect.bottom))
270 {
271 if (pos) *pos = i;
272 return item;
273 }
274 }
275 return NULL;
276 }
277
278
279 /***********************************************************************
280 * MENU_FindItemByKey
281 *
282 * Find the menu item selected by a key press.
283 * Return item id, -1 if none, -2 if we should close the menu.
284 */
285 static UINT MENU_FindItemByKey( HWND hwndOwner, HMENU hmenu, UINT key )
286 {
287 POPUPMENU *menu;
288 MENUITEM *item;
289 int i;
290 LONG menuchar;
291
292 if (!IsMenu( hmenu )) hmenu = WIN_FindWndPtr(hwndOwner)->hSysMenu;
293 if (!hmenu) return -1;
294
295 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
296 item = menu->items;
297 key = toupper(key);
298 for (i = 0; i < menu->nItems; i++, item++)
299 {
300 if (IS_STRING_ITEM(item->item_flags))
301 {
302 char *p = strchr( item->text, '&' );
303 if (p && (p[1] != '&') && (toupper(p[1]) == key)) return i;
304 }
305 }
306 menuchar = SendMessage32A( hwndOwner, WM_MENUCHAR,
307 MAKEWPARAM( key, menu->wFlags ), hmenu );
308 if (HIWORD(menuchar) == 2) return LOWORD(menuchar);
309 if (HIWORD(menuchar) == 1) return -2;
310 return -1;
311 }
312
313
314 /***********************************************************************
315 * MENU_CalcItemSize
316 *
317 * Calculate the size of the menu item and store it in lpitem->rect.
318 */
319 static void MENU_CalcItemSize( HDC hdc, MENUITEM *lpitem, HWND hwndOwner,
320 int orgX, int orgY, BOOL menuBar )
321 {
322 DWORD dwSize;
323 char *p;
324
325 SetRect16( &lpitem->rect, orgX, orgY, orgX, orgY );
326
327 if (lpitem->item_flags & MF_OWNERDRAW)
328 {
329 MEASUREITEMSTRUCT16 *mis;
330 if (!(mis = SEGPTR_NEW(MEASUREITEMSTRUCT16))) return;
331 mis->CtlType = ODT_MENU;
332 mis->itemID = lpitem->item_id;
333 mis->itemData = (DWORD)lpitem->text;
334 mis->itemHeight = 16;
335 mis->itemWidth = 30;
336 SendMessage16( hwndOwner, WM_MEASUREITEM, 0, (LPARAM)SEGPTR_GET(mis) );
337 lpitem->rect.bottom += mis->itemHeight;
338 lpitem->rect.right += mis->itemWidth;
339 dprintf_menu( stddeb, "DrawMenuItem: MeasureItem %04x %dx%d!\n",
340 lpitem->item_id, mis->itemWidth, mis->itemHeight );
341 SEGPTR_FREE(mis);
342 return;
343 }
344
345 if (lpitem->item_flags & MF_SEPARATOR)
346 {
347 lpitem->rect.bottom += SEPARATOR_HEIGHT;
348 return;
349 }
350
351 if (!menuBar)
352 {
353 lpitem->rect.right += 2 * check_bitmap_width;
354 if (lpitem->item_flags & MF_POPUP)
355 lpitem->rect.right += arrow_bitmap_width;
356 }
357
358 if (lpitem->item_flags & MF_BITMAP)
359 {
360 BITMAP16 bm;
361 if (GetObject16( (HBITMAP16)(UINT32)lpitem->text, sizeof(bm), &bm ))
362 {
363 lpitem->rect.right += bm.bmWidth;
364 lpitem->rect.bottom += bm.bmHeight;
365 }
366 return;
367 }
368
369 /* If we get here, then it must be a text item */
370
371 if (IS_STRING_ITEM( lpitem->item_flags ))
372 {
373 dwSize = GetTextExtent( hdc, lpitem->text, strlen(lpitem->text) );
374 lpitem->rect.right += LOWORD(dwSize);
375 lpitem->rect.bottom += MAX( HIWORD(dwSize), SYSMETRICS_CYMENU );
376 lpitem->xTab = 0;
377
378 if (menuBar) lpitem->rect.right += MENU_BAR_ITEMS_SPACE;
379 else if ((p = strchr( lpitem->text, '\t' )) != NULL)
380 {
381 /* Item contains a tab (only meaningful in popup menus) */
382 lpitem->xTab = check_bitmap_width + MENU_TAB_SPACE +
383 LOWORD( GetTextExtent( hdc, lpitem->text,
384 (int)(p - lpitem->text) ));
385 lpitem->rect.right += MENU_TAB_SPACE;
386 }
387 else
388 {
389 if (strchr( lpitem->text, '\b' ))
390 lpitem->rect.right += MENU_TAB_SPACE;
391 lpitem->xTab = lpitem->rect.right - check_bitmap_width
392 - arrow_bitmap_width;
393 }
394 }
395 }
396
397
398 /***********************************************************************
399 * MENU_PopupMenuCalcSize
400 *
401 * Calculate the size of a popup menu.
402 */
403 static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND hwndOwner )
404 {
405 MENUITEM *lpitem;
406 HDC hdc;
407 int start, i;
408 int orgX, orgY, maxX, maxTab, maxTabWidth;
409
410 lppop->Width = lppop->Height = 0;
411 if (lppop->nItems == 0) return;
412 hdc = GetDC( 0 );
413 maxX = start = 0;
414 while (start < lppop->nItems)
415 {
416 lpitem = &lppop->items[start];
417 orgX = maxX;
418 orgY = 0;
419 maxTab = maxTabWidth = 0;
420
421 /* Parse items until column break or end of menu */
422 for (i = start; i < lppop->nItems; i++, lpitem++)
423 {
424 if ((i != start) &&
425 (lpitem->item_flags & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
426 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, FALSE );
427 if (lpitem->item_flags & MF_MENUBARBREAK) orgX++;
428 maxX = MAX( maxX, lpitem->rect.right );
429 orgY = lpitem->rect.bottom;
430 if (IS_STRING_ITEM(lpitem->item_flags) && lpitem->xTab)
431 {
432 maxTab = MAX( maxTab, lpitem->xTab );
433 maxTabWidth = MAX(maxTabWidth,lpitem->rect.right-lpitem->xTab);
434 }
435 }
436
437 /* Finish the column (set all items to the largest width found) */
438 maxX = MAX( maxX, maxTab + maxTabWidth );
439 for (lpitem = &lppop->items[start]; start < i; start++, lpitem++)
440 {
441 lpitem->rect.right = maxX;
442 if (IS_STRING_ITEM(lpitem->item_flags) && lpitem->xTab)
443 lpitem->xTab = maxTab;
444 }
445 lppop->Height = MAX( lppop->Height, orgY );
446 }
447
448 lppop->Width = maxX;
449 ReleaseDC( 0, hdc );
450 }
451
452
453 /***********************************************************************
454 * MENU_MenuBarCalcSize
455 *
456 * Calculate the size of the menu bar.
457 */
458 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT16 lprect, LPPOPUPMENU lppop,
459 HWND hwndOwner )
460 {
461 MENUITEM *lpitem;
462 int start, i, orgX, orgY, maxY, helpPos;
463
464 if ((lprect == NULL) || (lppop == NULL)) return;
465 if (lppop->nItems == 0) return;
466 dprintf_menu(stddeb,"MENU_MenuBarCalcSize left=%d top=%d right=%d bottom=%d\n",
467 lprect->left, lprect->top, lprect->right, lprect->bottom);
468 lppop->Width = lprect->right - lprect->left;
469 lppop->Height = 0;
470 maxY = lprect->top;
471 start = 0;
472 helpPos = -1;
473 while (start < lppop->nItems)
474 {
475 lpitem = &lppop->items[start];
476 orgX = lprect->left;
477 orgY = maxY;
478
479 /* Parse items until line break or end of menu */
480 for (i = start; i < lppop->nItems; i++, lpitem++)
481 {
482 if ((helpPos == -1) && (lpitem->item_flags & MF_HELP)) helpPos = i;
483 if ((i != start) &&
484 (lpitem->item_flags & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
485 MENU_CalcItemSize( hdc, lpitem, hwndOwner, orgX, orgY, TRUE );
486 if (lpitem->rect.right > lprect->right)
487 {
488 if (i != start) break;
489 else lpitem->rect.right = lprect->right;
490 }
491 maxY = MAX( maxY, lpitem->rect.bottom );
492 orgX = lpitem->rect.right;
493 }
494
495 /* Finish the line (set all items to the largest height found) */
496 while (start < i) lppop->items[start++].rect.bottom = maxY;
497 }
498
499 lprect->bottom = maxY;
500 lppop->Height = lprect->bottom - lprect->top;
501
502 /* Flush right all items between the MF_HELP and the last item */
503 /* (if several lines, only move the last line) */
504 if (helpPos != -1)
505 {
506 lpitem = &lppop->items[lppop->nItems-1];
507 orgY = lpitem->rect.top;
508 orgX = lprect->right;
509 for (i = lppop->nItems - 1; i >= helpPos; i--, lpitem--)
510 {
511 if (lpitem->rect.top != orgY) break; /* Other line */
512 if (lpitem->rect.right >= orgX) break; /* Too far right already */
513 lpitem->rect.left += orgX - lpitem->rect.right;
514 lpitem->rect.right = orgX;
515 orgX = lpitem->rect.left;
516 }
517 }
518 }
519
520
521 /***********************************************************************
522 * MENU_DrawMenuItem
523 *
524 * Draw a single menu item.
525 */
526 static void MENU_DrawMenuItem( HWND hwnd, HDC hdc, MENUITEM *lpitem,
527 UINT height, BOOL menuBar )
528 {
529 RECT16 rect;
530
531 if (lpitem->item_flags & MF_OWNERDRAW)
532 {
533 DRAWITEMSTRUCT32 dis;
534
535 dprintf_menu( stddeb, "DrawMenuItem: Ownerdraw!\n" );
536 dis.CtlType = ODT_MENU;
537 dis.itemID = lpitem->item_id;
538 dis.itemData = (DWORD)lpitem->text;
539 dis.itemState = 0;
540 if (lpitem->item_flags & MF_CHECKED) dis.itemState |= ODS_CHECKED;
541 if (lpitem->item_flags & MF_GRAYED) dis.itemState |= ODS_GRAYED;
542 if (lpitem->item_flags & MF_HILITE) dis.itemState |= ODS_SELECTED;
543 dis.itemAction = ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS;
544 dis.hwndItem = hwnd;
545 dis.hDC = hdc;
546 CONV_RECT16TO32( &lpitem->rect, &dis.rcItem );
547 SendMessage32A( hwnd, WM_DRAWITEM, 0, (LPARAM)&dis );
548 return;
549 }
550
551 if (menuBar && (lpitem->item_flags & MF_SEPARATOR)) return;
552 rect = lpitem->rect;
553
554 /* Draw the background */
555
556 if (lpitem->item_flags & MF_HILITE)
557 FillRect16( hdc, &rect, sysColorObjects.hbrushHighlight );
558 else FillRect16( hdc, &rect, sysColorObjects.hbrushMenu );
559 SetBkMode( hdc, TRANSPARENT );
560
561 /* Draw the separator bar (if any) */
562
563 if (!menuBar && (lpitem->item_flags & MF_MENUBARBREAK))
564 {
565 SelectObject( hdc, sysColorObjects.hpenWindowFrame );
566 MoveTo( hdc, rect.left, 0 );
567 LineTo( hdc, rect.left, height );
568 }
569 if (lpitem->item_flags & MF_SEPARATOR)
570 {
571 SelectObject( hdc, sysColorObjects.hpenWindowFrame );
572 MoveTo( hdc, rect.left, rect.top + SEPARATOR_HEIGHT/2 );
573 LineTo( hdc, rect.right, rect.top + SEPARATOR_HEIGHT/2 );
574 return;
575 }
576
577 /* Setup colors */
578
579 if (lpitem->item_flags & MF_HILITE)
580 {
581 if (lpitem->item_flags & MF_GRAYED)
582 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
583 else
584 SetTextColor( hdc, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
585 SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
586 }
587 else
588 {
589 if (lpitem->item_flags & MF_GRAYED)
590 SetTextColor( hdc, GetSysColor( COLOR_GRAYTEXT ) );
591 else
592 SetTextColor( hdc, GetSysColor( COLOR_MENUTEXT ) );
593 SetBkColor( hdc, GetSysColor( COLOR_MENU ) );
594 }
595
596 if (!menuBar)
597 {
598 /* Draw the check mark */
599
600 if (lpitem->item_flags & MF_CHECKED)
601 {
602 GRAPH_DrawBitmap(hdc, lpitem->hCheckBit ? lpitem->hCheckBit :
603 hStdCheck, rect.left,
604 (rect.top+rect.bottom-check_bitmap_height) / 2,
605 0, 0, check_bitmap_width, check_bitmap_height );
606 }
607 else if (lpitem->hUnCheckBit != 0) /* Not checked */
608 {
609 GRAPH_DrawBitmap(hdc, lpitem->hUnCheckBit, rect.left,
610 (rect.top+rect.bottom-check_bitmap_height) / 2,
611 0, 0, check_bitmap_width, check_bitmap_height );
612 }
613
614 /* Draw the popup-menu arrow */
615
616 if (lpitem->item_flags & MF_POPUP)
617 {
618 GRAPH_DrawBitmap( hdc, hStdMnArrow,
619 rect.right-arrow_bitmap_width-1,
620 (rect.top+rect.bottom-arrow_bitmap_height) / 2,
621 0, 0, arrow_bitmap_width, arrow_bitmap_height );
622 }
623
624 rect.left += check_bitmap_width;
625 rect.right -= arrow_bitmap_width;
626 }
627
628 /* Draw the item text or bitmap */
629
630 if (lpitem->item_flags & MF_BITMAP)
631 {
632 GRAPH_DrawBitmap( hdc, (HBITMAP16)(UINT32)lpitem->text,
633 rect.left, rect.top, 0, 0,
634 rect.right-rect.left, rect.bottom-rect.top );
635 return;
636 }
637 /* No bitmap - process text if present */
638 else if (IS_STRING_ITEM(lpitem->item_flags))
639 {
640 register int i;
641
642 if (menuBar)
643 {
644 rect.left += MENU_BAR_ITEMS_SPACE / 2;
645 rect.right -= MENU_BAR_ITEMS_SPACE / 2;
646 i = strlen( lpitem->text );
647 }
648 else
649 {
650 for (i = 0; lpitem->text[i]; i++)
651 if ((lpitem->text[i] == '\t') || (lpitem->text[i] == '\b'))
652 break;
653 }
654
655 DrawText16( hdc, lpitem->text, i, &rect,
656 DT_LEFT | DT_VCENTER | DT_SINGLELINE );
657
658 if (lpitem->text[i]) /* There's a tab or flush-right char */
659 {
660 if (lpitem->text[i] == '\t')
661 {
662 rect.left = lpitem->xTab;
663 DrawText16( hdc, lpitem->text + i + 1, -1, &rect,
664 DT_LEFT | DT_VCENTER | DT_SINGLELINE );
665 }
666 else DrawText16( hdc, lpitem->text + i + 1, -1, &rect,
667 DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
668 }
669 }
670 }
671
672
673 /***********************************************************************
674 * MENU_DrawPopupMenu
675 *
676 * Paint a popup menu.
677 */
678 static void MENU_DrawPopupMenu( HWND hwnd, HDC hdc, HMENU hmenu )
679 {
680 POPUPMENU *menu;
681 MENUITEM *item;
682 RECT16 rect;
683 int i;
684
685 GetClientRect16( hwnd, &rect );
686 FillRect16( hdc, &rect, sysColorObjects.hbrushMenu );
687 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
688 if (!menu || !menu->nItems) return;
689 for (i = menu->nItems, item = menu->items; i > 0; i--, item++)
690 MENU_DrawMenuItem( hwnd, hdc, item, menu->Height, FALSE );
691 }
692
693
694 /***********************************************************************
695 * MENU_DrawMenuBar
696 *
697 * Paint a menu bar. Returns the height of the menu bar.
698 */
699 UINT MENU_DrawMenuBar(HDC hDC, LPRECT16 lprect, HWND hwnd, BOOL suppress_draw)
700 {
701 LPPOPUPMENU lppop;
702 int i;
703 WND *wndPtr = WIN_FindWndPtr( hwnd );
704
705 lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR( (HMENU)wndPtr->wIDmenu );
706 if (lppop == NULL || lprect == NULL) return SYSMETRICS_CYMENU;
707 dprintf_menu(stddeb,"MENU_DrawMenuBar(%04x, %p, %p); !\n",
708 hDC, lprect, lppop);
709 if (lppop->Height == 0) MENU_MenuBarCalcSize(hDC, lprect, lppop, hwnd);
710 lprect->bottom = lprect->top + lppop->Height;
711 if (suppress_draw) return lppop->Height;
712
713 FillRect16(hDC, lprect, sysColorObjects.hbrushMenu );
714 SelectObject( hDC, sysColorObjects.hpenWindowFrame );
715 MoveTo( hDC, lprect->left, lprect->bottom );
716 LineTo( hDC, lprect->right, lprect->bottom );
717
718 if (lppop->nItems == 0) return SYSMETRICS_CYMENU;
719 for (i = 0; i < lppop->nItems; i++)
720 {
721 MENU_DrawMenuItem( hwnd, hDC, &lppop->items[i], lppop->Height, TRUE );
722 }
723 return lppop->Height;
724 }
725
726
727 /***********************************************************************
728 * MENU_SwitchTPWndTo
729 */
730 static BOOL MENU_SwitchTPWndTo( HTASK hTask)
731 {
732 /* This is supposed to be called when popup is hidden */
733
734 TDB* task = (TDB*)GlobalLock16(hTask);
735
736 if( !task ) return 0;
737
738 /* if this task got as far as menu tracking it must have a queue */
739
740 pTopPWnd->hInstance = task->hInstance;
741 pTopPWnd->hmemTaskQ = task->hQueue;
742 return 1;
743 }
744
745 /***********************************************************************
746 * MENU_ShowPopup
747 *
748 * Display a popup menu.
749 */
750 static BOOL MENU_ShowPopup(HWND hwndOwner, HMENU hmenu, UINT id, int x, int y)
751 {
752 POPUPMENU *menu;
753 WND *wndPtr = NULL;
754 BOOL skip_init = 0;
755
756 if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
757 if (menu->FocusedItem != NO_SELECTED_ITEM)
758 {
759 menu->items[menu->FocusedItem].item_flags &= ~(MF_HILITE|MF_MOUSESELECT);
760 menu->FocusedItem = NO_SELECTED_ITEM;
761 }
762 SendMessage16( hwndOwner, WM_INITMENUPOPUP, (WPARAM)hmenu,
763 MAKELONG( id, (menu->wFlags & MF_SYSMENU) ? 1 : 0 ));
764 MENU_PopupMenuCalcSize( menu, hwndOwner );
765
766 wndPtr = WIN_FindWndPtr( hwndOwner );
767 if (!wndPtr) return FALSE;
768
769 if (!pTopPWnd)
770 {
771 pTopPWnd = WIN_FindWndPtr(CreateWindow16( POPUPMENU_CLASS_ATOM, NULL,
772 WS_POPUP | WS_BORDER, x, y,
773 menu->Width + 2*SYSMETRICS_CXBORDER,
774 menu->Height + 2*SYSMETRICS_CYBORDER,
775 0, 0, wndPtr->hInstance,
776 (LPVOID)(HMENU32)hmenu ));
777 if (!pTopPWnd) return FALSE;
778 skip_init = TRUE;
779 }
780
781 if( uSubPWndLevel )
782 {
783 /* create new window for the submenu */
784 HWND hWnd = CreateWindow16( POPUPMENU_CLASS_ATOM, NULL,
785 WS_POPUP | WS_BORDER, x, y,
786 menu->Width + 2*SYSMETRICS_CXBORDER,
787 menu->Height + 2*SYSMETRICS_CYBORDER,
788 menu->hWnd, 0, wndPtr->hInstance,
789 (LPVOID)(HMENU32)hmenu );
790 if( !hWnd ) return FALSE;
791 menu->hWnd = hWnd;
792 }
793 else
794 {
795 if( !skip_init )
796 {
797 MENU_SwitchTPWndTo(GetCurrentTask());
798 SendMessage16( pTopPWnd->hwndSelf, WM_USER, (WPARAM)hmenu, 0L);
799 }
800 menu->hWnd = pTopPWnd->hwndSelf;
801 }
802
803 uSubPWndLevel++;
804
805 SetWindowPos(menu->hWnd, 0, x, y, menu->Width + 2*SYSMETRICS_CXBORDER,
806 menu->Height + 2*SYSMETRICS_CYBORDER,
807 SWP_NOACTIVATE | SWP_NOZORDER );
808
809 /* Display the window */
810
811 SetWindowPos( menu->hWnd, HWND_TOP, 0, 0, 0, 0,
812 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
813 UpdateWindow( menu->hWnd );
814 return TRUE;
815 }
816
817
818 /***********************************************************************
819 * MENU_SelectItem
820 */
821 static void MENU_SelectItem( HWND hwndOwner, HMENU hmenu, UINT wIndex,
822 BOOL sendMenuSelect )
823 {
824 LPPOPUPMENU lppop;
825 HDC hdc;
826
827 lppop = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
828 if (!lppop->nItems) return;
829 if ((wIndex != NO_SELECTED_ITEM) &&
830 (wIndex != SYSMENU_SELECTED) &&
831 (lppop->items[wIndex].item_flags & MF_SEPARATOR))
832 wIndex = NO_SELECTED_ITEM;
833 if (lppop->FocusedItem == wIndex) return;
834 if (lppop->wFlags & MF_POPUP) hdc = GetDC( lppop->hWnd );
835 else hdc = GetDCEx( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW);
836
837 /* Clear previous highlighted item */
838 if (lppop->FocusedItem != NO_SELECTED_ITEM)
839 {
840 if (lppop->FocusedItem == SYSMENU_SELECTED)
841 NC_DrawSysButton( lppop->hWnd, hdc, FALSE );
842 else
843 {
844 lppop->items[lppop->FocusedItem].item_flags &=~(MF_HILITE|MF_MOUSESELECT);
845 MENU_DrawMenuItem(lppop->hWnd,hdc,&lppop->items[lppop->FocusedItem],
846 lppop->Height, !(lppop->wFlags & MF_POPUP) );
847 }
848 }
849
850 /* Highlight new item (if any) */
851 lppop->FocusedItem = wIndex;
852 if (lppop->FocusedItem != NO_SELECTED_ITEM)
853 {
854 if (lppop->FocusedItem == SYSMENU_SELECTED)
855 {
856 NC_DrawSysButton( lppop->hWnd, hdc, TRUE );
857 if (sendMenuSelect)
858 SendMessage16( hwndOwner, WM_MENUSELECT,
859 WIN_FindWndPtr(lppop->hWnd)->hSysMenu,
860 MAKELONG(lppop->wFlags | MF_MOUSESELECT, hmenu));
861 }
862 else
863 {
864 lppop->items[lppop->FocusedItem].item_flags |= MF_HILITE;
865 MENU_DrawMenuItem( lppop->hWnd, hdc, &lppop->items[lppop->FocusedItem],
866 lppop->Height, !(lppop->wFlags & MF_POPUP) );
867 if (sendMenuSelect)
868 SendMessage16( hwndOwner, WM_MENUSELECT,
869 lppop->items[lppop->FocusedItem].item_id,
870 MAKELONG( lppop->items[lppop->FocusedItem].item_flags | MF_MOUSESELECT, hmenu));
871 }
872 }
873 else if (sendMenuSelect)
874 SendMessage16( hwndOwner, WM_MENUSELECT, hmenu,
875 MAKELONG( lppop->wFlags | MF_MOUSESELECT, hmenu ) );
876
877 ReleaseDC( lppop->hWnd, hdc );
878 }
879
880
881 /***********************************************************************
882 * MENU_SelectNextItem
883 */
884 static void MENU_SelectNextItem( HWND hwndOwner, HMENU hmenu )
885 {
886 int i;
887 POPUPMENU *menu;
888
889 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
890 if (!menu->items) return;
891 if ((menu->FocusedItem != NO_SELECTED_ITEM) &&
892 (menu->FocusedItem != SYSMENU_SELECTED))
893 {
894 for (i = menu->FocusedItem+1; i < menu->nItems; i++)
895 {
896 if (!(menu->items[i].item_flags & MF_SEPARATOR))
897 {
898 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
899 return;
900 }
901 }
902 if (MENU_HasSysMenu( menu ))
903 {
904 MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
905 return;
906 }
907 }
908 for (i = 0; i < menu->nItems; i++)
909 {
910 if (!(menu->items[i].item_flags & MF_SEPARATOR))
911 {
912 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
913 return;
914 }
915 }
916 if (MENU_HasSysMenu( menu ))
917 MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
918 }
919
920
921 /***********************************************************************
922 * MENU_SelectPrevItem
923 */
924 static void MENU_SelectPrevItem( HWND hwndOwner, HMENU hmenu )
925 {
926 int i;
927 POPUPMENU *menu;
928
929 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
930 if (!menu->items) return;
931 if ((menu->FocusedItem != NO_SELECTED_ITEM) &&
932 (menu->FocusedItem != SYSMENU_SELECTED))
933 {
934 for (i = menu->FocusedItem - 1; i >= 0; i--)
935 {
936 if (!(menu->items[i].item_flags & MF_SEPARATOR))
937 {
938 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
939 return;
940 }
941 }
942 if (MENU_HasSysMenu( menu ))
943 {
944 MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
945 return;
946 }
947 }
948 for (i = menu->nItems - 1; i > 0; i--)
949 {
950 if (!(menu->items[i].item_flags & MF_SEPARATOR))
951 {
952 MENU_SelectItem( hwndOwner, hmenu, i, TRUE );
953 return;
954 }
955 }
956 if (MENU_HasSysMenu( menu ))
957 MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE );
958 }
959
960
961 /**********************************************************************
962 * MENU_SetItemData
963 *
964 * Set an item flags, id and text ptr.
965 */
966 static BOOL MENU_SetItemData( MENUITEM *item, UINT flags, UINT id, LPCSTR str )
967 {
968 LPSTR prevText = IS_STRING_ITEM(item->item_flags) ? item->text : NULL;
969
970 if (IS_STRING_ITEM(flags))
971 {
972 if (!str)
973 {
974 flags |= MF_SEPARATOR;
975 item->text = NULL;
976 }
977 else
978 {
979 LPSTR text;
980 /* Item beginning with a backspace is a help item */
981 if (*str == '\b')
982 {
983 flags |= MF_HELP;
984 str++;
985 }
986 if (!(text = HEAP_strdupA( SystemHeap, 0, str ))) return FALSE;
987 item->text = text;
988 }
989 }
990 else if ((flags & MF_BITMAP) || (flags & MF_OWNERDRAW))
991 item->text = (LPSTR)str;
992 else item->text = NULL;
993
994 item->item_flags = flags & ~(MF_HILITE | MF_MOUSESELECT);
995 item->item_id = id;
996 SetRectEmpty16( &item->rect );
997 if (prevText) HeapFree( SystemHeap, 0, prevText );
998 return TRUE;
999 }
1000
1001
1002 /**********************************************************************
1003 * MENU_InsertItem
1004 *
1005 * Insert a new item into a menu.
1006 */
1007 static MENUITEM *MENU_InsertItem( HMENU hMenu, UINT pos, UINT flags )
1008 {
1009 MENUITEM *newItems;
1010 POPUPMENU *menu;
1011
1012 if (!(menu = (POPUPMENU *)USER_HEAP_LIN_ADDR(hMenu)))
1013 {
1014 dprintf_menu( stddeb, "MENU_InsertItem: %04x not a menu handle\n",
1015 hMenu );
1016 return NULL;
1017 }
1018
1019 /* Find where to insert new item */
1020
1021 if ((flags & MF_BYPOSITION) &&
1022 ((pos == (UINT)-1) || (pos == menu->nItems)))
1023 {
1024 /* Special case: append to menu */
1025 /* Some programs specify the menu length to do that */
1026 pos = menu->nItems;
1027 }
1028 else
1029 {
1030 if (!MENU_FindItem( &hMenu, &pos, flags ))
1031 {
1032 dprintf_menu( stddeb, "MENU_InsertItem: item %x not found\n",
1033 pos );
1034 return NULL;
1035 }
1036 if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu)))
1037 {
1038 dprintf_menu(stddeb,"MENU_InsertItem: %04x not a menu handle\n",
1039 hMenu);
1040 return NULL;
1041 }
1042 }
1043
1044 /* Create new items array */
1045
1046 newItems = HeapAlloc( SystemHeap, 0, sizeof(MENUITEM) * (menu->nItems+1) );
1047 if (!newItems)
1048 {
1049 dprintf_menu( stddeb, "MENU_InsertItem: allocation failed\n" );
1050 return NULL;
1051 }
1052 if (menu->nItems > 0)
1053 {
1054 /* Copy the old array into the new */
1055 if (pos > 0) memcpy( newItems, menu->items, pos * sizeof(MENUITEM) );
1056 if (pos < menu->nItems) memcpy( &newItems[pos+1], &menu->items[pos],
1057 (menu->nItems-pos)*sizeof(MENUITEM) );
1058 HeapFree( SystemHeap, 0, menu->items );
1059 }
1060 menu->items = newItems;
1061 menu->nItems++;
1062 memset( &newItems[pos], 0, sizeof(*newItems) );
1063 return &newItems[pos];
1064 }
1065
1066
1067 /**********************************************************************
1068 * MENU_ParseResource
1069 *
1070 * Parse a standard menu resource and add items to the menu.
1071 * Return a pointer to the end of the resource.
1072 */
1073 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu, BOOL unicode )
1074 {
1075 WORD flags, id = 0;
1076 LPCSTR str;
1077
1078 do
1079 {
1080 flags = GET_WORD(res);
1081 res += sizeof(WORD);
1082 if (!(flags & MF_POPUP))
1083 {
1084 id = GET_WORD(res);
1085 res += sizeof(WORD);
1086 }
1087 if (!IS_STRING_ITEM(flags))
1088 fprintf( stderr, "MENU_ParseResource: not a string item %04x\n",
1089 flags );
1090 str = res;
1091 if (!unicode) res += strlen(str) + 1;
1092 else res += (lstrlen32W((LPCWSTR)str) + 1) * sizeof(WCHAR);
1093 if (flags & MF_POPUP)
1094 {
1095 HMENU hSubMenu = CreatePopupMenu();
1096 if (!hSubMenu) return NULL;
1097 if (!(res = MENU_ParseResource( res, hSubMenu, unicode )))
1098 return NULL;
1099 if (!unicode) AppendMenu32A( hMenu, flags, (UINT)hSubMenu, str );
1100 else AppendMenu32W( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
1101 }
1102 else /* Not a popup */
1103 {
1104 if (!unicode) AppendMenu32A( hMenu, flags, id, *str ? str : NULL );
1105 else AppendMenu32W( hMenu, flags, id,
1106 *(LPCWSTR)str ? (LPCWSTR)str : NULL );
1107 }
1108 } while (!(flags & MF_END));
1109 return res;
1110 }
1111
1112
1113 /***********************************************************************
1114 * MENU_GetSubPopup
1115 *
1116 * Return the handle of the selected sub-popup menu (if any).
1117 */
1118 static HMENU MENU_GetSubPopup( HMENU hmenu )
1119 {
1120 POPUPMENU *menu;
1121 MENUITEM *item;
1122
1123 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1124 if (menu->FocusedItem == NO_SELECTED_ITEM) return 0;
1125 else if (menu->FocusedItem == SYSMENU_SELECTED)
1126 return WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1127
1128 item = &menu->items[menu->FocusedItem];
1129 if (!(item->item_flags & MF_POPUP) || !(item->item_flags & MF_MOUSESELECT))
1130 return 0;
1131 return (HMENU)item->item_id;
1132 }
1133
1134
1135 /***********************************************************************
1136 * MENU_HideSubPopups
1137 *
1138 * Hide the sub-popup menus of this menu.
1139 */
1140 static void MENU_HideSubPopups( HWND hwndOwner, HMENU hmenu,
1141 BOOL sendMenuSelect )
1142 {
1143 MENUITEM *item;
1144 POPUPMENU *menu, *submenu;
1145 HMENU hsubmenu;
1146
1147 if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return;
1148 if (menu->FocusedItem == NO_SELECTED_ITEM) return;
1149 if (menu->FocusedItem == SYSMENU_SELECTED)
1150 {
1151 hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1152 }
1153 else
1154 {
1155 item = &menu->items[menu->FocusedItem];
1156 if (!(item->item_flags & MF_POPUP) ||
1157 !(item->item_flags & MF_MOUSESELECT)) return;
1158 item->item_flags &= ~MF_MOUSESELECT;
1159 hsubmenu = (HMENU)item->item_id;
1160 }
1161 submenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hsubmenu );
1162 MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE );
1163 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect );
1164 if (submenu->hWnd == pTopPWnd->hwndSelf )
1165 {
1166 ShowWindow( submenu->hWnd, SW_HIDE );
1167 uSubPWndLevel = 0;
1168 }
1169 else
1170 {
1171 DestroyWindow( submenu->hWnd );
1172 submenu->hWnd = 0;
1173 }
1174 }
1175
1176
1177 /***********************************************************************
1178 * MENU_ShowSubPopup
1179 *
1180 * Display the sub-menu of the selected item of this menu.
1181 * Return the handle of the submenu, or hmenu if no submenu to display.
1182 */
1183 static HMENU MENU_ShowSubPopup( HWND hwndOwner, HMENU hmenu, BOOL selectFirst )
1184 {
1185 POPUPMENU *menu;
1186 MENUITEM *item;
1187 WND *wndPtr;
1188
1189 if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return hmenu;
1190 if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return hmenu;
1191 if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu;
1192 if (menu->FocusedItem == SYSMENU_SELECTED)
1193 {
1194 MENU_ShowPopup(hwndOwner, wndPtr->hSysMenu, 0, wndPtr->rectClient.left,
1195 wndPtr->rectClient.top - menu->Height - 2*SYSMETRICS_CYBORDER);
1196 if (selectFirst) MENU_SelectNextItem( hwndOwner, wndPtr->hSysMenu );
1197 return wndPtr->hSysMenu;
1198 }
1199 item = &menu->items[menu->FocusedItem];
1200 if (!(item->item_flags & MF_POPUP) ||
1201 (item->item_flags & (MF_GRAYED | MF_DISABLED))) return hmenu;
1202 item->item_flags |= MF_MOUSESELECT;
1203 if (menu->wFlags & MF_POPUP)
1204 {
1205 MENU_ShowPopup( hwndOwner, (HMENU)item->item_id, menu->FocusedItem,
1206 wndPtr->rectWindow.left + item->rect.right-arrow_bitmap_width,
1207 wndPtr->rectWindow.top + item->rect.top );
1208 }
1209 else
1210 {
1211 MENU_ShowPopup( hwndOwner, (HMENU)item->item_id, menu->FocusedItem,
1212 wndPtr->rectWindow.left + item->rect.left,
1213 wndPtr->rectWindow.top + item->rect.bottom );
1214 }
1215 if (selectFirst) MENU_SelectNextItem( hwndOwner, (HMENU)item->item_id );
1216 return (HMENU)item->item_id;
1217 }
1218
1219
1220 /***********************************************************************
1221 * MENU_FindMenuByCoords
1222 *
1223 * Find the menu containing a given point (in screen coords).
1224 */
1225 static HMENU MENU_FindMenuByCoords( HMENU hmenu, POINT16 pt )
1226 {
1227 POPUPMENU *menu;
1228 HWND hwnd;
1229
1230 if (!(hwnd = WindowFromPoint16( pt ))) return 0;
1231 while (hmenu)
1232 {
1233 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1234 if (menu->hWnd == hwnd)
1235 {
1236 if (!(menu->wFlags & MF_POPUP))
1237 {
1238 /* Make sure it's in the menu bar (or in system menu) */
1239 WND *wndPtr = WIN_FindWndPtr( menu->hWnd );
1240 if ((pt.x < wndPtr->rectClient.left) ||
1241 (pt.x >= wndPtr->rectClient.right) ||
1242 (pt.y >= wndPtr->rectClient.top)) return 0;
1243 if (pt.y < wndPtr->rectClient.top - menu->Height)
1244 {
1245 if (!MENU_IsInSysMenu( menu, pt )) return 0;
1246 }
1247 /* else it's in the menu bar */
1248 }
1249 return hmenu;
1250 }
1251 hmenu = MENU_GetSubPopup( hmenu );
1252 }
1253 return 0;
1254 }
1255
1256
1257 /***********************************************************************
1258 * MENU_ExecFocusedItem
1259 *
1260 * Execute a menu item (for instance when user pressed Enter).
1261 * Return TRUE if we can go on with menu tracking.
1262 */
1263 static BOOL MENU_ExecFocusedItem( HWND hwndOwner, HMENU hmenu,
1264 HMENU *hmenuCurrent )
1265 {
1266 MENUITEM *item;
1267 POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1268 if (!menu || !menu->nItems || (menu->FocusedItem == NO_SELECTED_ITEM) ||
1269 (menu->FocusedItem == SYSMENU_SELECTED)) return TRUE;
1270 item = &menu->items[menu->FocusedItem];
1271 if (!(item->item_flags & MF_POPUP))
1272 {
1273 if (!(item->item_flags & (MF_GRAYED | MF_DISABLED)))
1274 {
1275 PostMessage( hwndOwner, (menu->wFlags & MF_SYSMENU) ?
1276 WM_SYSCOMMAND : WM_COMMAND, item->item_id, 0 );
1277 return FALSE;
1278 }
1279 else return TRUE;
1280 }
1281 else
1282 {
1283 *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1284 return TRUE;
1285 }
1286 }
1287
1288
1289 /***********************************************************************
1290 * MENU_ButtonDown
1291 *
1292 * Handle a button-down event in a menu. Point is in screen coords.
1293 * hmenuCurrent is the top-most visible popup.
1294 * Return TRUE if we can go on with menu tracking.
1295 */
1296 static BOOL MENU_ButtonDown( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1297 POINT16 pt )
1298 {
1299 POPUPMENU *menu;
1300 MENUITEM *item;
1301 UINT id;
1302
1303 if (!hmenu) return FALSE; /* Outside all menus */
1304 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1305 item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1306 if (!item) /* Maybe in system menu */
1307 {
1308 if (!MENU_IsInSysMenu( menu, pt )) return FALSE;
1309 id = SYSMENU_SELECTED;
1310 }
1311
1312 if (menu->FocusedItem == id)
1313 {
1314 if (id == SYSMENU_SELECTED) return FALSE;
1315 if (item->item_flags & MF_POPUP)
1316 {
1317 if (item->item_flags & MF_MOUSESELECT)
1318 {
1319 if (menu->wFlags & MF_POPUP)
1320 {
1321 MENU_HideSubPopups( hwndOwner, hmenu, TRUE );
1322 *hmenuCurrent = hmenu;
1323 }
1324 else return FALSE;
1325 }
1326 else *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1327 }
1328 }
1329 else
1330 {
1331 MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1332 MENU_SelectItem( hwndOwner, hmenu, id, TRUE );
1333 *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1334 }
1335 return TRUE;
1336 }
1337
1338
1339 /***********************************************************************
1340 * MENU_ButtonUp
1341 *
1342 * Handle a button-up event in a menu. Point is in screen coords.
1343 * hmenuCurrent is the top-most visible popup.
1344 * Return TRUE if we can go on with menu tracking.
1345 */
1346 static BOOL MENU_ButtonUp( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1347 POINT16 pt )
1348 {
1349 POPUPMENU *menu;
1350 MENUITEM *item;
1351 HMENU hsubmenu = 0;
1352 UINT id;
1353
1354 if (!hmenu) return FALSE; /* Outside all menus */
1355 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1356 item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1357 if (!item) /* Maybe in system menu */
1358 {
1359 if (!MENU_IsInSysMenu( menu, pt )) return FALSE;
1360 id = SYSMENU_SELECTED;
1361 hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu;
1362 }
1363
1364 if (menu->FocusedItem != id) return FALSE;
1365
1366 if (id != SYSMENU_SELECTED)
1367 {
1368 if (!(item->item_flags & MF_POPUP))
1369 {
1370 return MENU_ExecFocusedItem( hwndOwner, hmenu, hmenuCurrent );
1371 }
1372 hsubmenu = (HMENU)item->item_id;
1373 }
1374 /* Select first item of sub-popup */
1375 MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, FALSE );
1376 MENU_SelectNextItem( hwndOwner, hsubmenu );
1377 return TRUE;
1378 }
1379
1380
1381 /***********************************************************************
1382 * MENU_MouseMove
1383 *
1384 * Handle a motion event in a menu. Point is in screen coords.
1385 * hmenuCurrent is the top-most visible popup.
1386 * Return TRUE if we can go on with menu tracking.
1387 */
1388 static BOOL MENU_MouseMove( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent,
1389 POINT16 pt )
1390 {
1391 MENUITEM *item;
1392 POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1393 UINT id = NO_SELECTED_ITEM;
1394
1395 if (hmenu)
1396 {
1397 item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id );
1398 if (!item) /* Maybe in system menu */
1399 {
1400 if (!MENU_IsInSysMenu( menu, pt ))
1401 id = NO_SELECTED_ITEM; /* Outside all items */
1402 else id = SYSMENU_SELECTED;
1403 }
1404 }
1405 if (id == NO_SELECTED_ITEM)
1406 {
1407 MENU_SelectItem( hwndOwner, *hmenuCurrent, NO_SELECTED_ITEM, TRUE );
1408 }
1409 else if (menu->FocusedItem != id)
1410 {
1411 MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1412 MENU_SelectItem( hwndOwner, hmenu, id, TRUE );
1413 *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE );
1414 }
1415 return TRUE;
1416 }
1417
1418
1419 /***********************************************************************
1420 * MENU_KeyLeft
1421 *
1422 * Handle a VK_LEFT key event in a menu.
1423 * hmenuCurrent is the top-most visible popup.
1424 */
1425 static void MENU_KeyLeft( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent )
1426 {
1427 POPUPMENU *menu;
1428 HMENU hmenutmp, hmenuprev;
1429
1430 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1431 hmenuprev = hmenutmp = hmenu;
1432 while (hmenutmp != *hmenuCurrent)
1433 {
1434 hmenutmp = MENU_GetSubPopup( hmenuprev );
1435 if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp;
1436 }
1437 MENU_HideSubPopups( hwndOwner, hmenuprev, TRUE );
1438
1439 if ((hmenuprev == hmenu) && !(menu->wFlags & MF_POPUP))
1440 {
1441 /* Select previous item on the menu bar */
1442 MENU_SelectPrevItem( hwndOwner, hmenu );
1443 if (*hmenuCurrent != hmenu)
1444 {
1445 /* A popup menu was displayed -> display the next one */
1446 *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1447 }
1448 }
1449 else *hmenuCurrent = hmenuprev;
1450 }
1451
1452
1453 /***********************************************************************
1454 * MENU_KeyRight
1455 *
1456 * Handle a VK_RIGHT key event in a menu.
1457 * hmenuCurrent is the top-most visible popup.
1458 */
1459 static void MENU_KeyRight( HWND hwndOwner, HMENU hmenu, HMENU *hmenuCurrent )
1460 {
1461 POPUPMENU *menu;
1462 HMENU hmenutmp;
1463
1464 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
1465
1466 if ((menu->wFlags & MF_POPUP) || (*hmenuCurrent != hmenu))
1467 {
1468 /* If already displaying a popup, try to display sub-popup */
1469 hmenutmp = MENU_ShowSubPopup( hwndOwner, *hmenuCurrent, TRUE );
1470 if (hmenutmp != *hmenuCurrent) /* Sub-popup displayed */
1471 {
1472 *hmenuCurrent = hmenutmp;
1473 return;
1474 }
1475 }
1476
1477 /* If on menu-bar, go to next item */
1478 if (!(menu->wFlags & MF_POPUP))
1479 {
1480 MENU_HideSubPopups( hwndOwner, hmenu, FALSE );
1481 MENU_SelectNextItem( hwndOwner, hmenu );
1482 if (*hmenuCurrent != hmenu)
1483 {
1484 /* A popup menu was displayed -> display the next one */
1485 *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE );
1486 }
1487 }
1488 else if (*hmenuCurrent != hmenu) /* Hide last level popup */
1489 {
1490 HMENU hmenuprev;
1491 hmenuprev = hmenutmp = hmenu;
1492 while (hmenutmp != *hmenuCurrent)
1493 {
1494 hmenutmp = MENU_GetSubPopup( hmenuprev );
1495 if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp;
1496 }
1497 MENU_HideSubPopups( hwndOwner, hmenuprev, TRUE );
1498 *hmenuCurrent = hmenuprev;
1499 }
1500 }
1501
1502
1503 /***********************************************************************
1504 * MENU_TrackMenu
1505 *
1506 * Menu tracking code.
1507 * If 'x' and 'y' are not 0, we simulate a button-down event at (x,y)
1508 * before beginning tracking. This is to help menu-bar tracking.
1509 */
1510 static BOOL MENU_TrackMenu( HMENU hmenu, UINT wFlags, int x, int y,
1511 HWND hwnd, const RECT16 *lprect )
1512 {
1513 MSG16 *msg;
1514 HLOCAL16 hMsg;
1515 POPUPMENU *menu;
1516 HMENU hmenuCurrent = hmenu;
1517 BOOL fClosed = FALSE, fRemove;
1518 UINT pos;
1519
1520 fEndMenuCalled = FALSE;
1521 if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
1522 if (x && y)
1523 {
1524 POINT16 pt = { x, y };
1525 MENU_ButtonDown( hwnd, hmenu, &hmenuCurrent, pt );
1526 }
1527 SetCapture( hwnd );
1528 hMsg = USER_HEAP_ALLOC( sizeof(MSG16) );
1529 msg = (MSG16 *)USER_HEAP_LIN_ADDR( hMsg );
1530 while (!fClosed)
1531 {
1532 if (!MSG_InternalGetMessage( (SEGPTR)USER_HEAP_SEG_ADDR(hMsg), 0,
1533 hwnd, MSGF_MENU, 0, TRUE ))
1534 break;
1535
1536 fRemove = FALSE;
1537 if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
1538 {
1539 /* Find the sub-popup for this mouse event (if any) */
1540 HMENU hsubmenu = MENU_FindMenuByCoords( hmenu, msg->pt );
1541
1542 switch(msg->message)
1543 {
1544 case WM_RBUTTONDOWN:
1545 case WM_NCRBUTTONDOWN:
1546 if (!(wFlags & TPM_RIGHTBUTTON)) break;
1547 /* fall through */
1548 case WM_LBUTTONDOWN:
1549 case WM_NCLBUTTONDOWN:
1550 fClosed = !MENU_ButtonDown( hwnd, hsubmenu,
1551 &hmenuCurrent, msg->pt );
1552 break;
1553
1554 case WM_RBUTTONUP:
1555 case WM_NCRBUTTONUP:
1556 if (!(wFlags & TPM_RIGHTBUTTON)) break;
1557 /* fall through */
1558 case WM_LBUTTONUP:
1559 case WM_NCLBUTTONUP:
1560 /* If outside all menus but inside lprect, ignore it */
1561 if (!hsubmenu && lprect && PtInRect16(lprect, msg->pt)) break;
1562 fClosed = !MENU_ButtonUp( hwnd, hsubmenu,
1563 &hmenuCurrent, msg->pt );
1564 fRemove = TRUE; /* Remove event even if outside menu */
1565 break;
1566
1567 case WM_MOUSEMOVE:
1568 case WM_NCMOUSEMOVE:
1569 if ((msg->wParam & MK_LBUTTON) ||
1570 ((wFlags & TPM_RIGHTBUTTON) && (msg->wParam & MK_RBUTTON)))
1571 {
1572 fClosed = !MENU_MouseMove( hwnd, hsubmenu,
1573 &hmenuCurrent, msg->pt );
1574 }
1575 break;
1576 }
1577 }
1578 else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
1579 {
1580 fRemove = TRUE; /* Keyboard messages are always removed */
1581 switch(msg->message)
1582 {
1583 case WM_KEYDOWN:
1584 switch(msg->wParam)
1585 {
1586 case VK_HOME:
1587 MENU_SelectItem( hwnd, hmenuCurrent, NO_SELECTED_ITEM, FALSE );
1588 MENU_SelectNextItem( hwnd, hmenuCurrent );
1589 break;
1590
1591 case VK_END:
1592 MENU_SelectItem( hwnd, hmenuCurrent, NO_SELECTED_ITEM, FALSE );
1593 MENU_SelectPrevItem( hwnd, hmenuCurrent );
1594 break;
1595
1596 case VK_UP:
1597 MENU_SelectPrevItem( hwnd, hmenuCurrent );
1598 break;
1599
1600 case VK_DOWN:
1601 /* If on menu bar, pull-down the menu */
1602 if (!(menu->wFlags & MF_POPUP) && (hmenuCurrent == hmenu))
1603 hmenuCurrent = MENU_ShowSubPopup( hwnd, hmenu, TRUE );
1604 else
1605 MENU_SelectNextItem( hwnd, hmenuCurrent );
1606 break;
1607
1608 case VK_LEFT:
1609 MENU_KeyLeft( hwnd, hmenu, &hmenuCurrent );
1610 break;
1611
1612 case VK_RIGHT:
1613 MENU_KeyRight( hwnd, hmenu, &hmenuCurrent );
1614 break;
1615
1616 case VK_SPACE:
1617 case VK_RETURN:
1618 fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent,
1619 &hmenuCurrent );
1620 break;
1621
1622 case VK_ESCAPE:
1623 fClosed = TRUE;
1624 break;
1625
1626 default:
1627 break;
1628 }
1629 break; /* WM_KEYDOWN */
1630
1631 case WM_SYSKEYDOWN:
1632 switch(msg->wParam)
1633 {
1634 case VK_MENU:
1635 fClosed = TRUE;
1636 break;
1637
1638 }
1639 break; /* WM_SYSKEYDOWN */
1640
1641 case WM_CHAR:
1642 {
1643 /* Hack to avoid control chars. */
1644 /* We will find a better way real soon... */
1645 if ((msg->wParam <= 32) || (msg->wParam >= 127)) break;
1646 pos = MENU_FindItemByKey( hwnd, hmenuCurrent, msg->wParam );
1647 if (pos == (UINT)-2) fClosed = TRUE;
1648 else if (pos == (UINT)-1) MessageBeep(0);
1649 else
1650 {
1651 MENU_SelectItem( hwnd, hmenuCurrent, pos, TRUE );
1652 fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent,
1653 &hmenuCurrent );
1654
1655 }
1656 }
1657 break; /* WM_CHAR */
1658 } /* switch(msg->message) */
1659 }
1660 else
1661 {
1662 DispatchMessage( msg );
1663 }
1664 if (fEndMenuCalled) fClosed = TRUE;
1665 if (!fClosed) fRemove = TRUE;
1666
1667 if (fRemove) /* Remove the message from the queue */
1668 PeekMessage16( msg, 0, msg->message, msg->message, PM_REMOVE );
1669 }
1670 USER_HEAP_FREE( hMsg );
1671 ReleaseCapture();
1672 MENU_HideSubPopups( hwnd, hmenu, FALSE );
1673 if (menu->wFlags & MF_POPUP)
1674 {
1675 ShowWindow( menu->hWnd, SW_HIDE );
1676 uSubPWndLevel = 0;
1677 }
1678 MENU_SelectItem( hwnd, hmenu, NO_SELECTED_ITEM, FALSE );
1679 SendMessage16( hwnd, WM_MENUSELECT, 0, MAKELONG( 0xffff, 0 ) );
1680 fEndMenuCalled = FALSE;
1681 return TRUE;
1682 }
1683
1684
1685 /***********************************************************************
1686 * MENU_TrackMouseMenuBar
1687 *
1688 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
1689 */
1690 void MENU_TrackMouseMenuBar( HWND hwnd, POINT16 pt )
1691 {
1692 WND *wndPtr = WIN_FindWndPtr( hwnd );
1693 HideCaret(0);
1694 SendMessage16( hwnd, WM_ENTERMENULOOP, 0, 0 );
1695 SendMessage16( hwnd, WM_INITMENU, wndPtr->wIDmenu, 0 );
1696 MENU_TrackMenu( (HMENU)wndPtr->wIDmenu, TPM_LEFTALIGN | TPM_LEFTBUTTON,
1697 pt.x, pt.y, hwnd, NULL );
1698 SendMessage16( hwnd, WM_EXITMENULOOP, 0, 0 );
1699 ShowCaret(0);
1700 }
1701
1702
1703 /***********************************************************************
1704 * MENU_TrackKbdMenuBar
1705 *
1706 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
1707 */
1708 void MENU_TrackKbdMenuBar( WND* wndPtr, UINT wParam, INT vkey)
1709 {
1710 UINT uItem = NO_SELECTED_ITEM;
1711 HMENU hTrackMenu;
1712
1713 /* find window that has a menu
1714 */
1715
1716 if( !(wndPtr->dwStyle & WS_CHILD) )
1717 {
1718 wndPtr = WIN_FindWndPtr( GetActiveWindow() );
1719 if( !wndPtr ) return;
1720 }
1721 else
1722 while( wndPtr->dwStyle & WS_CHILD &&
1723 !(wndPtr->dwStyle & WS_SYSMENU) )
1724 if( !(wndPtr = wndPtr->parent) ) return;
1725
1726 if( wndPtr->dwStyle & WS_CHILD || !wndPtr->wIDmenu )
1727 if( !(wndPtr->dwStyle & WS_SYSMENU) )
1728 return;
1729
1730 hTrackMenu = ( IsMenu( wndPtr->wIDmenu ) )? wndPtr->wIDmenu:
1731 wndPtr->hSysMenu;
1732
1733 HideCaret(0);
1734 SendMessage16( wndPtr->hwndSelf, WM_ENTERMENULOOP, 0, 0 );
1735 SendMessage16( wndPtr->hwndSelf, WM_INITMENU, wndPtr->wIDmenu, 0 );
1736
1737 /* find suitable menu entry
1738 */
1739
1740 if( vkey == VK_SPACE )
1741 uItem = SYSMENU_SELECTED;
1742 else if( vkey )
1743 {
1744 uItem = MENU_FindItemByKey( wndPtr->hwndSelf, wndPtr->wIDmenu, vkey );
1745 if( uItem >= 0xFFFE )
1746 {
1747 if( uItem == 0xFFFF )
1748 MessageBeep(0);
1749 SendMessage16( wndPtr->hwndSelf, WM_EXITMENULOOP, 0, 0 );
1750 ShowCaret(0);
1751 return;
1752 }
1753 }
1754
1755 MENU_SelectItem( wndPtr->hwndSelf, hTrackMenu, uItem, TRUE );
1756 if( uItem == NO_SELECTED_ITEM )
1757 MENU_SelectNextItem( wndPtr->hwndSelf, hTrackMenu );
1758 else
1759 PostMessage( wndPtr->hwndSelf, WM_KEYDOWN, VK_DOWN, 0L );
1760
1761 MENU_TrackMenu( hTrackMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON,
1762 0, 0, wndPtr->hwndSelf, NULL );
1763
1764 SendMessage16( wndPtr->hwndSelf, WM_EXITMENULOOP, 0, 0 );
1765 ShowCaret(0);
1766 }
1767
1768
1769 /**********************************************************************
1770 * TrackPopupMenu16 (USER.416)
1771 */
1772 BOOL16 TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1773 INT16 nReserved, HWND16 hWnd, const RECT16 *lpRect )
1774 {
1775 BOOL ret = FALSE;
1776
1777 HideCaret(0);
1778 if (MENU_ShowPopup( hWnd, hMenu, 0, x, y ))
1779 ret = MENU_TrackMenu( hMenu, wFlags, 0, 0, hWnd, lpRect );
1780 ShowCaret(0);
1781 return ret;
1782 }
1783
1784
1785 /**********************************************************************
1786 * TrackPopupMenu32 (USER32.548)
1787 */
1788 BOOL32 TrackPopupMenu32( HMENU32 hMenu, UINT32 wFlags, INT32 x, INT32 y,
1789 INT32 nReserved, HWND32 hWnd, const RECT32 *lpRect )
1790 {
1791 RECT16 r;
1792 CONV_RECT32TO16( lpRect, &r );
1793 return TrackPopupMenu16( hMenu, wFlags, x, y, nReserved, hWnd, &r );
1794 }
1795
1796
1797 /***********************************************************************
1798 * PopupMenuWndProc
1799 */
1800 LRESULT PopupMenuWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
1801 {
1802 switch(message)
1803 {
1804 case WM_CREATE:
1805 {
1806 CREATESTRUCT16 *cs = (CREATESTRUCT16*)PTR_SEG_TO_LIN(lParam);
1807 SetWindowLong32A( hwnd, 0, (LONG)cs->lpCreateParams );
1808 return 0;
1809 }
1810
1811 case WM_MOUSEACTIVATE: /* We don't want to be activated */
1812 return MA_NOACTIVATE;
1813
1814 case WM_PAINT:
1815 {
1816 PAINTSTRUCT16 ps;
1817 BeginPaint16( hwnd, &ps );
1818 MENU_DrawPopupMenu( hwnd, ps.hdc,
1819 (HMENU)GetWindowLong32A( hwnd, 0 ) );
1820 EndPaint16( hwnd, &ps );
1821 return 0;
1822 }
1823
1824 case WM_DESTROY:
1825 /* zero out global pointer in case system popup
1826 * was destroyed by AppExit
1827 */
1828
1829 if( hwnd == pTopPWnd->hwndSelf )
1830 pTopPWnd = 0;
1831 else
1832 uSubPWndLevel--;
1833 break;
1834
1835 case WM_USER:
1836 if (wParam) SetWindowLong32A( hwnd, 0, (HMENU)wParam );
1837 break;
1838 default:
1839 return DefWindowProc16(hwnd, message, wParam, lParam);
1840 }
1841 return 0;
1842 }
1843
1844
1845 /***********************************************************************
1846 * MENU_GetMenuBarHeight
1847 *
1848 * Compute the size of the menu bar height. Used by NC_HandleNCCalcSize().
1849 */
1850 UINT MENU_GetMenuBarHeight( HWND hwnd, UINT menubarWidth, int orgX, int orgY )
1851 {
1852 HDC hdc;
1853 RECT16 rectBar;
1854 WND *wndPtr;
1855 LPPOPUPMENU lppop;
1856
1857 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
1858 if (!(lppop = (LPPOPUPMENU)USER_HEAP_LIN_ADDR((HMENU)wndPtr->wIDmenu)))
1859 return 0;
1860 hdc = GetDC( hwnd );
1861 SetRect16(&rectBar, orgX, orgY, orgX+menubarWidth, orgY+SYSMETRICS_CYMENU);
1862 MENU_MenuBarCalcSize( hdc, &rectBar, lppop, hwnd );
1863 ReleaseDC( hwnd, hdc );
1864 return lppop->Height;
1865 }
1866
1867
1868 /*******************************************************************
1869 * ChangeMenu16 (USER.153)
1870 */
1871 BOOL16 ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
1872 UINT16 id, UINT16 flags )
1873 {
1874 dprintf_menu( stddeb,"ChangeMenu16: menu=%04x pos=%d data=%08lx id=%04x flags=%04x\n",
1875 hMenu, pos, (DWORD)data, id, flags );
1876 if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND,
1877 id, data );
1878 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
1879 /* for MF_DELETE. We should check the parameters for all others */
1880 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
1881 if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1882 if (flags & MF_CHANGE) return ModifyMenu16( hMenu, pos, flags & ~MF_CHANGE,
1883 id, data );
1884 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1885 flags & MF_BYPOSITION ? pos : id,
1886 flags & ~MF_REMOVE );
1887 /* Default: MF_INSERT */
1888 return InsertMenu16( hMenu, pos, flags, id, data );
1889 }
1890
1891
1892 /*******************************************************************
1893 * ChangeMenu32A (USER32.22)
1894 */
1895 BOOL32 ChangeMenu32A( HMENU32 hMenu, UINT32 pos, LPCSTR data,
1896 UINT32 id, UINT32 flags )
1897 {
1898 dprintf_menu( stddeb,"ChangeMenu32A: menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
1899 hMenu, pos, (DWORD)data, id, flags );
1900 if (flags & MF_APPEND) return AppendMenu32A( hMenu, flags & ~MF_APPEND,
1901 id, data );
1902 if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1903 if (flags & MF_CHANGE) return ModifyMenu32A(hMenu, pos, flags & ~MF_CHANGE,
1904 id, data );
1905 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1906 flags & MF_BYPOSITION ? pos : id,
1907 flags & ~MF_REMOVE );
1908 /* Default: MF_INSERT */
1909 return InsertMenu32A( hMenu, pos, flags, id, data );
1910 }
1911
1912
1913 /*******************************************************************
1914 * ChangeMenu32W (USER32.23)
1915 */
1916 BOOL32 ChangeMenu32W( HMENU32 hMenu, UINT32 pos, LPCWSTR data,
1917 UINT32 id, UINT32 flags )
1918 {
1919 dprintf_menu( stddeb,"ChangeMenu32W: menu=%08x pos=%d data=%08lx id=%08x flags=%08x\n",
1920 hMenu, pos, (DWORD)data, id, flags );
1921 if (flags & MF_APPEND) return AppendMenu32W( hMenu, flags & ~MF_APPEND,
1922 id, data );
1923 if (flags & MF_DELETE) return DeleteMenu( hMenu, pos, flags & ~MF_DELETE );
1924 if (flags & MF_CHANGE) return ModifyMenu32W(hMenu, pos, flags & ~MF_CHANGE,
1925 id, data );
1926 if (flags & MF_REMOVE) return RemoveMenu( hMenu,
1927 flags & MF_BYPOSITION ? pos : id,
1928 flags & ~MF_REMOVE );
1929 /* Default: MF_INSERT */
1930 return InsertMenu32W( hMenu, pos, flags, id, data );
1931 }
1932
1933
1934 /*******************************************************************
1935 * CheckMenuItem (USER.154)
1936 */
1937 INT CheckMenuItem( HMENU hMenu, UINT id, UINT flags )
1938 {
1939 MENUITEM *item;
1940 INT ret;
1941
1942 dprintf_menu( stddeb,"CheckMenuItem: %04x %04x %04x\n", hMenu, id, flags );
1943 if (!(item = MENU_FindItem( &hMenu, &id, flags ))) return -1;
1944 ret = item->item_flags & MF_CHECKED;
1945 if (flags & MF_CHECKED) item->item_flags |= MF_CHECKED;
1946 else item->item_flags &= ~MF_CHECKED;
1947 return ret;
1948 }
1949
1950
1951 /**********************************************************************
1952 * EnableMenuItem [USER.155]
1953 */
1954 BOOL EnableMenuItem(HMENU hMenu, UINT wItemID, UINT wFlags)
1955 {
1956 MENUITEM *item;
1957 dprintf_menu(stddeb,"EnableMenuItem (%04x, %04X, %04X) !\n",
1958 hMenu, wItemID, wFlags);
1959 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return FALSE;
1960
1961 /* We can't have MF_GRAYED and MF_DISABLED together */
1962 if (wFlags & MF_GRAYED)
1963 {
1964 item->item_flags = (item->item_flags & ~MF_DISABLED) | MF_GRAYED;
1965 }
1966 else if (wFlags & MF_DISABLED)
1967 {
1968 item->item_flags = (item->item_flags & ~MF_GRAYED) | MF_DISABLED;
1969 }
1970 else /* MF_ENABLED */
1971 {
1972 item->item_flags &= ~(MF_GRAYED | MF_DISABLED);
1973 }
1974 return TRUE;
1975 }
1976
1977
1978 /*******************************************************************
1979 * GetMenuString (USER.161)
1980 */
1981 int GetMenuString( HMENU hMenu, UINT wItemID,
1982 LPSTR str, short nMaxSiz, UINT wFlags )
1983 {
1984 MENUITEM *item;
1985
1986 dprintf_menu( stddeb, "GetMenuString: menu=%04x item=%04x ptr=%p len=%d flags=%04x\n",
1987 hMenu, wItemID, str, nMaxSiz, wFlags );
1988 if (!str || !nMaxSiz) return 0;
1989 str[0] = '\0';
1990 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return 0;
1991 if (!IS_STRING_ITEM(item->item_flags)) return 0;
1992 lstrcpyn32A( str, item->text, nMaxSiz );
1993 dprintf_menu( stddeb, "GetMenuString: returning '%s'\n", str );
1994 return strlen(str);
1995 }
1996
1997
1998 /**********************************************************************
1999 * HiliteMenuItem [USER.162]
2000 */
2001 BOOL HiliteMenuItem(HWND hWnd, HMENU hMenu, UINT wItemID, UINT wHilite)
2002 {
2003 LPPOPUPMENU menu;
2004 dprintf_menu(stddeb,"HiliteMenuItem(%04x, %04x, %04x, %04x);\n",
2005 hWnd, hMenu, wItemID, wHilite);
2006 if (!MENU_FindItem( &hMenu, &wItemID, wHilite )) return FALSE;
2007 if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE;
2008 if (menu->FocusedItem == wItemID) return TRUE;
2009 MENU_HideSubPopups( hWnd, hMenu, FALSE );
2010 MENU_SelectItem( hWnd, hMenu, wItemID, TRUE );
2011 return TRUE;
2012 }
2013
2014
2015 /**********************************************************************
2016 * GetMenuState [USER.250]
2017 */
2018 UINT GetMenuState(HMENU hMenu, UINT wItemID, UINT wFlags)
2019 {
2020 MENUITEM *item;
2021 dprintf_menu(stddeb,"GetMenuState(%04x, %04x, %04x);\n",
2022 hMenu, wItemID, wFlags);
2023 if (!(item = MENU_FindItem( &hMenu, &wItemID, wFlags ))) return -1;
2024 if (item->item_flags & MF_POPUP)
2025 {
2026 POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( (HMENU)item->item_id );
2027 if (!menu) return -1;
2028 else return (menu->nItems << 8) | (menu->wFlags & 0xff);
2029 }
2030 else return item->item_flags;
2031 }
2032
2033
2034 /**********************************************************************
2035 * GetMenuItemCount [USER.263]
2036 */
2037 INT GetMenuItemCount(HMENU hMenu)
2038 {
2039 LPPOPUPMENU menu;
2040 dprintf_menu(stddeb,"GetMenuItemCount(%04x);\n", hMenu);
2041 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2042 if (menu == NULL) return (UINT)-1;
2043 dprintf_menu(stddeb,"GetMenuItemCount(%04x) return %d \n",
2044 hMenu, menu->nItems);
2045 return menu->nItems;
2046 }
2047
2048
2049 /**********************************************************************
2050 * GetMenuItemID [USER.264]
2051 */
2052 UINT GetMenuItemID(HMENU hMenu, int nPos)
2053 {
2054 LPPOPUPMENU menu;
2055
2056 dprintf_menu(stddeb,"GetMenuItemID(%04x, %d);\n", hMenu, nPos);
2057 if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return -1;
2058 if ((nPos < 0) || (nPos >= menu->nItems)) return -1;
2059 if (menu->items[nPos].item_flags & MF_POPUP) return -1;
2060 return menu->items[nPos].item_id;
2061 }
2062
2063
2064 /*******************************************************************
2065 * InsertMenu16 (USER.410)
2066 */
2067 BOOL16 InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2068 UINT16 id, SEGPTR data )
2069 {
2070 if (IS_STRING_ITEM(flags) && data)
2071 return InsertMenu32A( hMenu, (INT32)(INT16)pos, flags, id,
2072 (LPSTR)PTR_SEG_TO_LIN(data) );
2073 return InsertMenu32A( hMenu, (INT32)(INT16)pos, flags, id, (LPSTR)data );
2074 }
2075
2076
2077 /*******************************************************************
2078 * InsertMenu32A (USER32.321)
2079 */
2080 BOOL32 InsertMenu32A( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2081 UINT32 id, LPCSTR str )
2082 {
2083 MENUITEM *item;
2084
2085 if (IS_STRING_ITEM(flags) && str)
2086 dprintf_menu( stddeb, "InsertMenu: %04x %d %04x %04x '%s'\n",
2087 hMenu, pos, flags, id, str );
2088 else dprintf_menu( stddeb, "InsertMenu: %04x %d %04x %04x %08lx\n",
2089 hMenu, pos, flags, id, (DWORD)str );
2090
2091 if (!(item = MENU_InsertItem( hMenu, pos, flags ))) return FALSE;
2092
2093 if (!(MENU_SetItemData( item, flags, id, str )))
2094 {
2095 RemoveMenu( hMenu, pos, flags );
2096 return FALSE;
2097 }
2098
2099 if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */
2100 ((POPUPMENU *)USER_HEAP_LIN_ADDR((HMENU)id))->wFlags |= MF_POPUP;
2101
2102 item->hCheckBit = hStdCheck;
2103 item->hUnCheckBit = 0;
2104 return TRUE;
2105 }
2106
2107
2108 /*******************************************************************
2109 * InsertMenu32W (USER32.324)
2110 */
2111 BOOL32 InsertMenu32W( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2112 UINT32 id, LPCWSTR str )
2113 {
2114 BOOL32 ret;
2115
2116 if (IS_STRING_ITEM(flags) && str)
2117 {
2118 LPSTR newstr = STRING32_DupUniToAnsi( str );
2119 ret = InsertMenu32A( hMenu, pos, flags, id, newstr );
2120 free( newstr );
2121 return ret;
2122 }
2123 else return InsertMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
2124 }
2125
2126
2127 /*******************************************************************
2128 * AppendMenu16 (USER.411)
2129 */
2130 BOOL16 AppendMenu16( HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data )
2131 {
2132 return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
2133 }
2134
2135
2136 /*******************************************************************
2137 * AppendMenu32A (USER32.4)
2138 */
2139 BOOL32 AppendMenu32A( HMENU32 hMenu, UINT32 flags, UINT32 id, LPCSTR data )
2140 {
2141 return InsertMenu32A( hMenu, -1, flags | MF_BYPOSITION, id, data );
2142 }
2143
2144
2145 /*******************************************************************
2146 * AppendMenu32W (USER32.5)
2147 */
2148 BOOL32 AppendMenu32W( HMENU32 hMenu, UINT32 flags, UINT32 id, LPCWSTR data )
2149 {
2150 return InsertMenu32W( hMenu, -1, flags | MF_BYPOSITION, id, data );
2151 }
2152
2153
2154 /**********************************************************************
2155 * RemoveMenu [USER.412]
2156 */
2157 BOOL RemoveMenu(HMENU hMenu, UINT nPos, UINT wFlags)
2158 {
2159 LPPOPUPMENU menu;
2160 MENUITEM *item;
2161
2162 dprintf_menu(stddeb,"RemoveMenu (%04x, %04x, %04x)\n",hMenu, nPos, wFlags);
2163 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
2164 if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE;
2165
2166 /* Remove item */
2167
2168 if (IS_STRING_ITEM(item->item_flags) && item->text)
2169 HeapFree( SystemHeap, 0, item->text );
2170 if (--menu->nItems == 0)
2171 {
2172 HeapFree( SystemHeap, 0, menu->items );
2173 menu->items = NULL;
2174 }
2175 else
2176 {
2177 while(nPos < menu->nItems)
2178 {
2179 *item = *(item+1);
2180 item++;
2181 nPos++;
2182 }
2183 menu->items = HeapReAlloc( SystemHeap, 0, menu->items,
2184 menu->nItems * sizeof(MENUITEM) );
2185 }
2186 return TRUE;
2187 }
2188
2189
2190 /**********************************************************************
2191 * DeleteMenu [USER.413]
2192 */
2193 BOOL DeleteMenu(HMENU hMenu, UINT nPos, UINT wFlags)
2194 {
2195 MENUITEM *item = MENU_FindItem( &hMenu, &nPos, wFlags );
2196 if (!item) return FALSE;
2197 if (item->item_flags & MF_POPUP) DestroyMenu( (HMENU)item->item_id );
2198 /* nPos is now the position of the item */
2199 RemoveMenu( hMenu, nPos, wFlags | MF_BYPOSITION );
2200 return TRUE;
2201 }
2202
2203
2204 /*******************************************************************
2205 * ModifyMenu16 (USER.414)
2206 */
2207 BOOL16 ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2208 UINT16 id, SEGPTR data )
2209 {
2210 if (IS_STRING_ITEM(flags))
2211 return ModifyMenu32A( hMenu, (INT32)(INT16)pos, flags, id,
2212 (LPSTR)PTR_SEG_TO_LIN(data) );
2213 return ModifyMenu32A( hMenu, (INT32)(INT16)pos, flags, id, (LPSTR)data );
2214 }
2215
2216
2217 /*******************************************************************
2218 * ModifyMenu32A (USER32.396)
2219 */
2220 BOOL32 ModifyMenu32A( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2221 UINT32 id, LPCSTR str )
2222 {
2223 MENUITEM *item;
2224 HMENU hMenu16 = hMenu;
2225 UINT16 pos16 = pos;
2226
2227 if (IS_STRING_ITEM(flags))
2228 {
2229 dprintf_menu( stddeb, "ModifyMenu: %04x %d %04x %04x '%s'\n",
2230 hMenu, pos, flags, id, str ? str : "#NULL#" );
2231 if (!str) return FALSE;
2232 }
2233 else
2234 {
2235 dprintf_menu( stddeb, "ModifyMenu: %04x %d %04x %04x %08lx\n",
2236 hMenu, pos, flags, id, (DWORD)str );
2237 }
2238
2239 if (!(item = MENU_FindItem( &hMenu16, &pos16, flags ))) return FALSE;
2240 return MENU_SetItemData( item, flags, id, str );
2241 }
2242
2243
2244 /*******************************************************************
2245 * ModifyMenu32W (USER32.397)
2246 */
2247 BOOL32 ModifyMenu32W( HMENU32 hMenu, UINT32 pos, UINT32 flags,
2248 UINT32 id, LPCWSTR str )
2249 {
2250 BOOL32 ret;
2251
2252 if (IS_STRING_ITEM(flags) && str)
2253 {
2254 LPSTR newstr = STRING32_DupUniToAnsi( str );
2255 ret = ModifyMenu32A( hMenu, pos, flags, id, newstr );
2256 free( newstr );
2257 return ret;
2258 }
2259 else return ModifyMenu32A( hMenu, pos, flags, id, (LPCSTR)str );
2260 }
2261
2262
2263 /**********************************************************************
2264 * CreatePopupMenu [USER.415]
2265 */
2266 HMENU CreatePopupMenu()
2267 {
2268 HMENU hmenu;
2269 POPUPMENU *menu;
2270
2271 if (!(hmenu = CreateMenu())) return 0;
2272 menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu );
2273 menu->wFlags |= MF_POPUP;
2274 return hmenu;
2275 }
2276
2277
2278 /**********************************************************************
2279 * GetMenuCheckMarkDimensions [USER.417]
2280 */
2281 DWORD GetMenuCheckMarkDimensions()
2282 {
2283 return MAKELONG( check_bitmap_width, check_bitmap_height );
2284 }
2285
2286
2287 /**********************************************************************
2288 * SetMenuItemBitmaps [USER.418]
2289 */
2290 BOOL SetMenuItemBitmaps(HMENU hMenu, UINT nPos, UINT wFlags,
2291 HBITMAP hNewUnCheck, HBITMAP hNewCheck)
2292 {
2293 MENUITEM *item;
2294 dprintf_menu(stddeb,"SetMenuItemBitmaps(%04x, %04x, %04x, %04x, %04x)\n",
2295 hMenu, nPos, wFlags, hNewCheck, hNewUnCheck);
2296 if (!(item = MENU_FindItem( &hMenu, &nPos, wFlags ))) return FALSE;
2297
2298 if (!hNewCheck && !hNewUnCheck)
2299 {
2300 /* If both are NULL, restore default bitmaps */
2301 item->hCheckBit = hStdCheck;
2302 item->hUnCheckBit = 0;
2303 item->item_flags &= ~MF_USECHECKBITMAPS;
2304 }
2305 else /* Install new bitmaps */
2306 {
2307 item->hCheckBit = hNewCheck;
2308 item->hUnCheckBit = hNewUnCheck;
2309 item->item_flags |= MF_USECHECKBITMAPS;
2310 }
2311 return TRUE;
2312 }
2313
2314
2315 /**********************************************************************
2316 * CreateMenu [USER.151]
2317 */
2318 HMENU CreateMenu()
2319 {
2320 HMENU hMenu;
2321 LPPOPUPMENU menu;
2322 dprintf_menu(stddeb,"CreateMenu !\n");
2323 if (!(hMenu = USER_HEAP_ALLOC( sizeof(POPUPMENU) )))
2324 return 0;
2325 menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2326 menu->wFlags = 0;
2327 menu->wMagic = MENU_MAGIC;
2328 menu->hTaskQ = 0;
2329 menu->Width = 0;
2330 menu->Height = 0;
2331 menu->nItems = 0;
2332 menu->hWnd = 0;
2333 menu->items = NULL;
2334 menu->FocusedItem = NO_SELECTED_ITEM;
2335 dprintf_menu(stddeb,"CreateMenu // return %04x\n", hMenu);
2336 return hMenu;
2337 }
2338
2339
2340 /**********************************************************************
2341 * DestroyMenu [USER.152]
2342 */
2343 BOOL DestroyMenu(HMENU hMenu)
2344 {
2345 LPPOPUPMENU lppop;
2346 dprintf_menu(stddeb,"DestroyMenu (%04x) !\n", hMenu);
2347
2348 if (hMenu == 0) return FALSE;
2349 /* Silently ignore attempts to destroy default system menu */
2350 if (hMenu == MENU_DefSysMenu) return TRUE;
2351 lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2352 if (!lppop || (lppop->wMagic != MENU_MAGIC)) return FALSE;
2353 lppop->wMagic = 0; /* Mark it as destroyed */
2354 if ((lppop->wFlags & MF_POPUP) && lppop->hWnd && lppop->hWnd != pTopPWnd->hwndSelf )
2355 DestroyWindow( lppop->hWnd );
2356
2357 if (lppop->items)
2358 {
2359 int i;
2360 MENUITEM *item = lppop->items;
2361 for (i = lppop->nItems; i > 0; i--, item++)
2362 {
2363 if (item->item_flags & MF_POPUP)
2364 DestroyMenu( (HMENU)item->item_id );
2365 if (IS_STRING_ITEM(item->item_flags) && item->text)
2366 HeapFree( SystemHeap, 0, item->text );
2367 }
2368 HeapFree( SystemHeap, 0, lppop->items );
2369 }
2370 USER_HEAP_FREE( hMenu );
2371 dprintf_menu(stddeb,"DestroyMenu (%04x) // End !\n", hMenu);
2372 return TRUE;
2373 }
2374
2375 /**********************************************************************
2376 * GetSystemMenu [USER.156]
2377 */
2378 HMENU GetSystemMenu(HWND hWnd, BOOL bRevert)
2379 {
2380 WND *wndPtr = WIN_FindWndPtr( hWnd );
2381 if (!wndPtr) return 0;
2382
2383 if (!wndPtr->hSysMenu || (wndPtr->hSysMenu == MENU_DefSysMenu))
2384 {
2385 wndPtr->hSysMenu = MENU_CopySysMenu();
2386 return wndPtr->hSysMenu;
2387 }
2388 if (!bRevert) return wndPtr->hSysMenu;
2389 if (wndPtr->hSysMenu) DestroyMenu(wndPtr->hSysMenu);
2390 wndPtr->hSysMenu = MENU_CopySysMenu();
2391 return wndPtr->hSysMenu;
2392 }
2393
2394
2395 /*******************************************************************
2396 * SetSystemMenu (USER.280)
2397 */
2398 BOOL SetSystemMenu( HWND hwnd, HMENU hMenu )
2399 {
2400 WND *wndPtr;
2401
2402 if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
2403 if (wndPtr->hSysMenu && (wndPtr->hSysMenu != MENU_DefSysMenu))
2404 DestroyMenu( wndPtr->hSysMenu );
2405 wndPtr->hSysMenu = hMenu;
2406 return TRUE;
2407 }
2408
2409
2410 /**********************************************************************
2411 * GetMenu [USER.157]
2412 */
2413 HMENU GetMenu(HWND hWnd)
2414 {
2415 WND * wndPtr = WIN_FindWndPtr(hWnd);
2416 if (wndPtr == NULL) return 0;
2417 return (HMENU)wndPtr->wIDmenu;
2418 }
2419
2420
2421 /**********************************************************************
2422 * SetMenu [USER.158]
2423 */
2424 BOOL SetMenu(HWND hWnd, HMENU hMenu)
2425 {
2426 LPPOPUPMENU lpmenu;
2427 WND * wndPtr = WIN_FindWndPtr(hWnd);
2428 if (wndPtr == NULL) {
2429 fprintf(stderr,"SetMenu(%04x, %04x) // Bad window handle !\n",
2430 hWnd, hMenu);
2431 return FALSE;
2432 }
2433 dprintf_menu(stddeb,"SetMenu(%04x, %04x);\n", hWnd, hMenu);
2434 if (GetCapture() == hWnd) ReleaseCapture();
2435 wndPtr->wIDmenu = (UINT)hMenu;
2436 if (hMenu != 0)
2437 {
2438 lpmenu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
2439 if (lpmenu == NULL) {
2440 fprintf(stderr,"SetMenu(%04x, %04x) // Bad menu handle !\n",
2441 hWnd, hMenu);
2442 return FALSE;
2443 }
2444 lpmenu->hWnd = hWnd;
2445 lpmenu->wFlags &= ~MF_POPUP; /* Can't be a popup */
2446 lpmenu->Height = 0; /* Make sure we recalculate the size */
2447 }
2448 if (IsWindowVisible(hWnd))
2449 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2450 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2451 return TRUE;
2452 }
2453
2454
2455
2456 /**********************************************************************
2457 * GetSubMenu [USER.159]
2458 */
2459 HMENU GetSubMenu(HMENU hMenu, short nPos)
2460 {
2461 LPPOPUPMENU lppop;
2462
2463 dprintf_menu(stddeb,"GetSubMenu (%04x, %04X) !\n", hMenu, nPos);
2464 if (!(lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return 0;
2465 if ((UINT)nPos >= lppop->nItems) return 0;
2466 if (!(lppop->items[nPos].item_flags & MF_POPUP)) return 0;
2467 return (HMENU)lppop->items[nPos].item_id;
2468 }
2469
2470
2471 /**********************************************************************
2472 * DrawMenuBar [USER.160]
2473 */
2474 void DrawMenuBar(HWND hWnd)
2475 {
2476 WND *wndPtr;
2477 LPPOPUPMENU lppop;
2478 dprintf_menu(stddeb,"DrawMenuBar (%04x)\n", hWnd);
2479 wndPtr = WIN_FindWndPtr(hWnd);
2480 if (wndPtr != NULL && (wndPtr->dwStyle & WS_CHILD) == 0 &&
2481 wndPtr->wIDmenu != 0) {
2482 dprintf_menu(stddeb,"DrawMenuBar wIDmenu=%04X \n",
2483 wndPtr->wIDmenu);
2484 lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR((HMENU)wndPtr->wIDmenu);
2485 if (lppop == NULL) return;
2486
2487 lppop->Height = 0; /* Make sure we call MENU_MenuBarCalcSize */
2488 SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
2489 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
2490 }
2491 }
2492
2493
2494 /***********************************************************************
2495 * EndMenu (USER.187)
2496 */
2497 void EndMenu(void)
2498 {
2499 /* FIXME: this won't work when we have multiple tasks... */
2500 fEndMenuCalled = TRUE;
2501 }
2502
2503
2504 /***********************************************************************
2505 * LookupMenuHandle (USER.217)
2506 */
2507 HMENU LookupMenuHandle( HMENU hmenu, INT id )
2508 {
2509 if (!MENU_FindItem( &hmenu, &id, MF_BYCOMMAND )) return 0;
2510 else return hmenu;
2511 }
2512
2513
2514 /**********************************************************************
2515 * LoadMenu (USER.150)
2516 */
2517 HMENU16 LoadMenu16( HINSTANCE16 instance, SEGPTR name )
2518 {
2519 HRSRC16 hRsrc;
2520 HGLOBAL16 handle;
2521 HMENU16 hMenu;
2522
2523 if (HIWORD(name))
2524 {
2525 char *str = (char *)PTR_SEG_TO_LIN( name );
2526 dprintf_menu( stddeb, "LoadMenu(%04x,'%s')\n", instance, str );
2527 if (str[0] == '#') name = (SEGPTR)atoi( str + 1 );
2528 }
2529 else
2530 dprintf_resource(stddeb,"LoadMenu(%04x,%04x)\n",instance,LOWORD(name));
2531
2532 if (!name) return 0;
2533
2534 /* check for Win32 module */
2535 instance = GetExePtr( instance );
2536 if (MODULE_GetPtr(instance)->flags & NE_FFLAGS_WIN32)
2537 return LoadMenu32A(instance,PTR_SEG_TO_LIN(name));
2538
2539 if (!(hRsrc = FindResource16( instance, name, RT_MENU ))) return 0;
2540 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
2541 hMenu = LoadMenuIndirect16(LockResource16(handle));
2542 FreeResource16( handle );
2543 return hMenu;
2544 }
2545
2546
2547 /*****************************************************************
2548 * LoadMenu32A (USER32.370)
2549 */
2550 HMENU32 LoadMenu32A( HINSTANCE32 instance, LPCSTR name )
2551 {
2552 HRSRC32 hrsrc = FindResource32A( instance, name, (LPSTR)RT_MENU );
2553 if (!hrsrc) return 0;
2554 return LoadMenuIndirect32A( (LPCVOID)LoadResource32( instance, hrsrc ));
2555 }
2556
2557
2558 /*****************************************************************
2559 * LoadMenu32W (USER32.372)
2560 */
2561 HMENU32 LoadMenu32W( HINSTANCE32 instance, LPCWSTR name )
2562 {
2563 HRSRC32 hrsrc = FindResource32W( instance, name, (LPWSTR)RT_MENU );
2564 if (!hrsrc) return 0;
2565 return LoadMenuIndirect32W( (LPCVOID)LoadResource32( instance, hrsrc ));
2566 }
2567
2568
2569 /**********************************************************************
2570 * LoadMenuIndirect16 (USER.220)
2571 */
2572 HMENU16 LoadMenuIndirect16( LPCVOID template )
2573 {
2574 HMENU hMenu;
2575 WORD version, offset;
2576 LPCSTR p = (LPCSTR)template;
2577
2578 dprintf_menu(stddeb,"LoadMenuIndirect32A: %p\n", template );
2579 version = GET_WORD(p);
2580 p += sizeof(WORD);
2581 if (version)
2582 {
2583 fprintf( stderr, "LoadMenuIndirect16: version must be 0 for Win16\n" );
2584 return 0;
2585 }
2586 offset = GET_WORD(p);
2587 p += sizeof(WORD) + offset;
2588 if (!(hMenu = CreateMenu())) return 0;
2589 if (!MENU_ParseResource( p, hMenu, FALSE ))
2590 {
2591 DestroyMenu( hMenu );
2592 return 0;
2593 }
2594 return hMenu;
2595 }
2596
2597
2598 /**********************************************************************
2599 * LoadMenuIndirect32A (USER32.370)
2600 */
2601 HMENU32 LoadMenuIndirect32A( LPCVOID template )
2602 {
2603 HMENU hMenu;
2604 WORD version, offset;
2605 LPCSTR p = (LPCSTR)template;
2606
2607 dprintf_menu(stddeb,"LoadMenuIndirect32A: %p\n", template );
2608 version = GET_WORD(p);
2609 p += sizeof(WORD);
2610 if (version)
2611 {
2612 fprintf( stderr, "LoadMenuIndirect32A: version %d not supported.\n",
2613 version );
2614 return 0;
2615 }
2616 offset = GET_WORD(p);
2617 p += sizeof(WORD) + offset;
2618 if (!(hMenu = CreateMenu())) return 0;
2619 if (!MENU_ParseResource( p, hMenu, TRUE ))
2620 {
2621 DestroyMenu( hMenu );
2622 return 0;
2623 }
2624 return hMenu;
2625 }
2626
2627
2628 /**********************************************************************
2629 * LoadMenuIndirect32W (USER32.371)
2630 */
2631 HMENU32 LoadMenuIndirect32W( LPCVOID template )
2632 {
2633 /* FIXME: is there anything different between A and W? */
2634 return LoadMenuIndirect32A( template );
2635 }
2636
2637
2638 /**********************************************************************
2639 * IsMenu (USER.358)
2640 */
2641 BOOL IsMenu( HMENU hmenu )
2642 {
2643 LPPOPUPMENU menu;
2644 if (!(menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE;
2645 return (menu->wMagic == MENU_MAGIC);
2646 }
Maarten's multimedia branch