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