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