projects / reactos.git / blob
? search:


1e29d1d178b6324343c4d7fb03f83ad0f5cb6faa
[reactos.git] / win32ss / user / ntuser / menu.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Menus
5 * FILE: win32ss/user/ntuser/menu.c
6 * PROGRAMER: Thomas Weidenmueller (w3seek@users.sourceforge.net)
7 */
8
9 #include <win32k.h>
10 DBG_DEFAULT_CHANNEL(UserMenu);
11
12 /* INTERNAL ******************************************************************/
13
14 HFONT ghMenuFont = NULL;
15 HFONT ghMenuFontBold = NULL;
16 static SIZE MenuCharSize;
17
18 /* Use global popup window because there's no way 2 menus can
19 * be tracked at the same time. */
20 static HWND top_popup = NULL;
21 static HMENU top_popup_hmenu = NULL;
22
23 BOOL fInsideMenuLoop = FALSE;
24 BOOL fInEndMenu = FALSE;
25
26 /* internal popup menu window messages */
27
28 #define MM_SETMENUHANDLE (WM_USER + 0)
29 #define MM_GETMENUHANDLE (WM_USER + 1)
30
31 /* internal flags for menu tracking */
32
33 #define TF_ENDMENU 0x10000
34 #define TF_SUSPENDPOPUP 0x20000
35 #define TF_SKIPREMOVE 0x40000
36
37
38 /* maximum allowed depth of any branch in the menu tree.
39 * This value is slightly larger than in windows (25) to
40 * stay on the safe side. */
41 #define MAXMENUDEPTH 30
42
43 #define MNS_STYLE_MASK (MNS_NOCHECK|MNS_MODELESS|MNS_DRAGDROP|MNS_AUTODISMISS|MNS_NOTIFYBYPOS|MNS_CHECKORBMP)
44
45 #define MENUITEMINFO_TYPE_MASK \
46 (MFT_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
47 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
48 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY /* same as MF_HELP */ )
49
50 #define TYPE_MASK (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)
51
52 #define STATE_MASK (~TYPE_MASK)
53
54 #define MENUITEMINFO_STATE_MASK (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT))
55
56 #define MII_STATE_MASK (MFS_GRAYED|MFS_CHECKED|MFS_HILITE|MFS_DEFAULT)
57
58 #define IS_SYSTEM_MENU(MenuInfo) \
59 (!((MenuInfo)->fFlags & MNF_POPUP) && ((MenuInfo)->fFlags & MNF_SYSMENU))
60
61 #define IS_BITMAP_ITEM(flags) (MF_BITMAP == MENU_ITEM_TYPE(flags))
62
63 #define IS_MAGIC_BITMAP(id) ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))
64 #define IS_STRING_ITEM(flags) (MF_STRING == MENU_ITEM_TYPE(flags))
65
66 /* Maximum number of menu items a menu can contain */
67 #define MAX_MENU_ITEMS (0x4000)
68 #define MAX_GOINTOSUBMENU (0x10)
69
70 /* Space between 2 columns */
71 #define MENU_COL_SPACE 4
72
73 /* top and bottom margins for popup menus */
74 #define MENU_TOP_MARGIN 2 //3
75 #define MENU_BOTTOM_MARGIN 2
76
77 #define MENU_ITEM_HBMP_SPACE (5)
78 #define MENU_BAR_ITEMS_SPACE (12)
79 #define SEPARATOR_HEIGHT (5)
80 #define MENU_TAB_SPACE (8)
81
82 typedef struct
83 {
84 UINT TrackFlags;
85 PMENU CurrentMenu; /* current submenu (can be equal to hTopMenu)*/
86 PMENU TopMenu; /* initial menu */
87 PWND OwnerWnd; /* where notifications are sent */
88 POINT Pt;
89 } MTRACKER;
90
91 /* Internal MenuTrackMenu() flags */
92 #define TPM_INTERNAL 0xF0000000
93 #define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */
94 #define TPM_POPUPMENU 0x20000000 /* menu is a popup menu */
95
96 #define ITEM_PREV -1
97 #define ITEM_NEXT 1
98
99 #define UpdateMenuItemState(state, change) \
100 {\
101 if((change) & MF_GRAYED) { \
102 (state) |= MF_GRAYED; \
103 } else { \
104 (state) &= ~MF_GRAYED; \
105 } /* Separate the two for test_menu_resource_layout.*/ \
106 if((change) & MF_DISABLED) { \
107 (state) |= MF_DISABLED; \
108 } else { \
109 (state) &= ~MF_DISABLED; \
110 } \
111 if((change) & MFS_CHECKED) { \
112 (state) |= MFS_CHECKED; \
113 } else { \
114 (state) &= ~MFS_CHECKED; \
115 } \
116 if((change) & MFS_HILITE) { \
117 (state) |= MFS_HILITE; \
118 } else { \
119 (state) &= ~MFS_HILITE; \
120 } \
121 if((change) & MFS_DEFAULT) { \
122 (state) |= MFS_DEFAULT; \
123 } else { \
124 (state) &= ~MFS_DEFAULT; \
125 } \
126 if((change) & MF_MOUSESELECT) { \
127 (state) |= MF_MOUSESELECT; \
128 } else { \
129 (state) &= ~MF_MOUSESELECT; \
130 } \
131 }
132
133 #if 0
134 void FASTCALL
135 DumpMenuItemList(PMENU Menu, PITEM MenuItem)
136 {
137 UINT cnt = 0, i = Menu->cItems;
138 while(i)
139 {
140 if(MenuItem->lpstr.Length)
141 DbgPrint(" %d. %wZ\n", ++cnt, &MenuItem->lpstr);
142 else
143 DbgPrint(" %d. NO TEXT dwTypeData==%d\n", ++cnt, (DWORD)MenuItem->lpstr.Buffer);
144 DbgPrint(" fType=");
145 if(MFT_BITMAP & MenuItem->fType)
146 DbgPrint("MFT_BITMAP ");
147 if(MFT_MENUBARBREAK & MenuItem->fType)
148 DbgPrint("MFT_MENUBARBREAK ");
149 if(MFT_MENUBREAK & MenuItem->fType)
150 DbgPrint("MFT_MENUBREAK ");
151 if(MFT_OWNERDRAW & MenuItem->fType)
152 DbgPrint("MFT_OWNERDRAW ");
153 if(MFT_RADIOCHECK & MenuItem->fType)
154 DbgPrint("MFT_RADIOCHECK ");
155 if(MFT_RIGHTJUSTIFY & MenuItem->fType)
156 DbgPrint("MFT_RIGHTJUSTIFY ");
157 if(MFT_SEPARATOR & MenuItem->fType)
158 DbgPrint("MFT_SEPARATOR ");
159 if(MFT_STRING & MenuItem->fType)
160 DbgPrint("MFT_STRING ");
161 DbgPrint("\n fState=");
162 if(MFS_DISABLED & MenuItem->fState)
163 DbgPrint("MFS_DISABLED ");
164 else
165 DbgPrint("MFS_ENABLED ");
166 if(MFS_CHECKED & MenuItem->fState)
167 DbgPrint("MFS_CHECKED ");
168 else
169 DbgPrint("MFS_UNCHECKED ");
170 if(MFS_HILITE & MenuItem->fState)
171 DbgPrint("MFS_HILITE ");
172 else
173 DbgPrint("MFS_UNHILITE ");
174 if(MFS_DEFAULT & MenuItem->fState)
175 DbgPrint("MFS_DEFAULT ");
176 if(MFS_GRAYED & MenuItem->fState)
177 DbgPrint("MFS_GRAYED ");
178 DbgPrint("\n wId=%d\n", MenuItem->wID);
179 MenuItem++;
180 i--;
181 }
182 DbgPrint("Entries: %d\n", cnt);
183 return;
184 }
185 #endif
186
187 #define FreeMenuText(Menu,MenuItem) \
188 { \
189 if((MENU_ITEM_TYPE((MenuItem)->fType) == MF_STRING) && \
190 (MenuItem)->lpstr.Length) { \
191 DesktopHeapFree(((PMENU)Menu)->head.rpdesk, (MenuItem)->lpstr.Buffer); \
192 } \
193 }
194
195 PMENU FASTCALL
196 IntGetMenuObject(HMENU hMenu)
197 {
198 PMENU Menu = UserGetMenuObject(hMenu);
199 if (Menu)
200 Menu->head.cLockObj++;
201
202 return Menu;
203 }
204
205 PMENU FASTCALL VerifyMenu(PMENU pMenu)
206 {
207 HMENU hMenu;
208 PITEM pItem;
209 ULONG Error;
210 UINT i;
211 if (!pMenu) return NULL;
212
213 Error = EngGetLastError();
214
215 _SEH2_TRY
216 {
217 hMenu = UserHMGetHandle(pMenu);
218 pItem = pMenu->rgItems;
219 if (pItem)
220 {
221 i = pItem[0].wID;
222 pItem[0].wID = i;
223 }
224 }
225 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
226 {
227 ERR("Run away LOOP!\n");
228 EngSetLastError(Error);
229 _SEH2_YIELD(return NULL);
230 }
231 _SEH2_END
232
233 if ( UserObjectInDestroy(hMenu))
234 {
235 ERR("Menu is marked for destruction!\n");
236 pMenu = NULL;
237 }
238 EngSetLastError(Error);
239 return pMenu;
240 }
241
242 BOOL
243 FASTCALL
244 IntIsMenu(HMENU Menu)
245 {
246 if (UserGetMenuObject(Menu)) return TRUE;
247 return FALSE;
248 }
249
250
251 PMENU WINAPI
252 IntGetMenu(HWND hWnd)
253 {
254 PWND Wnd = ValidateHwndNoErr(hWnd);
255
256 if (!Wnd)
257 return NULL;
258
259 return UserGetMenuObject(UlongToHandle(Wnd->IDMenu));
260 }
261
262 PMENU get_win_sys_menu( HWND hwnd )
263 {
264 PMENU ret = 0;
265 WND *win = ValidateHwndNoErr( hwnd );
266 if (win)
267 {
268 ret = UserGetMenuObject(win->SystemMenu);
269 }
270 return ret;
271 }
272
273 BOOL IntDestroyMenu( PMENU pMenu, BOOL bRecurse)
274 {
275 PMENU SubMenu;
276
277 if (pMenu->rgItems) /* recursively destroy submenus */
278 {
279 int i;
280 ITEM *item = pMenu->rgItems;
281 for (i = pMenu->cItems; i > 0; i--, item++)
282 {
283 SubMenu = item->spSubMenu;
284 item->spSubMenu = NULL;
285
286 /* Remove Item Text */
287 FreeMenuText(pMenu,item);
288
289 /* Remove Item Bitmap and set it for this process */
290 if (item->hbmp && !(item->fState & MFS_HBMMENUBMP))
291 {
292 GreSetObjectOwner(item->hbmp, GDI_OBJ_HMGR_POWNED);
293 item->hbmp = NULL;
294 }
295
296 /* Remove Item submenu */
297 if (bRecurse && SubMenu)//VerifyMenu(SubMenu))
298 {
299 /* Release submenu since it was referenced when inserted */
300 IntReleaseMenuObject(SubMenu);
301 IntDestroyMenuObject(SubMenu, bRecurse);
302 }
303 }
304 /* Free the Item */
305 DesktopHeapFree(pMenu->head.rpdesk, pMenu->rgItems );
306 pMenu->rgItems = NULL;
307 pMenu->cItems = 0;
308 }
309 return TRUE;
310 }
311
312 /* Callback for the object manager */
313 BOOLEAN
314 UserDestroyMenuObject(PVOID Object)
315 {
316 return IntDestroyMenuObject(Object, TRUE);
317 }
318
319 BOOL FASTCALL
320 IntDestroyMenuObject(PMENU Menu, BOOL bRecurse)
321 {
322 if (Menu)
323 {
324 PWND Window;
325
326 if (PsGetCurrentProcessSessionId() == Menu->head.rpdesk->rpwinstaParent->dwSessionId)
327 {
328 BOOL ret;
329 if (Menu->hWnd)
330 {
331 Window = ValidateHwndNoErr(Menu->hWnd);
332 if (Window)
333 {
334 //Window->IDMenu = 0; Only in Win9x!! wine win test_SetMenu test...
335
336 /* DestroyMenu should not destroy system menu popup owner */
337 if ((Menu->fFlags & (MNF_POPUP | MNF_SYSSUBMENU)) == MNF_POPUP)
338 {
339 // Should we check it to see if it has Class?
340 ERR("FIXME Pop up menu window thing'ie\n");
341 //co_UserDestroyWindow( Window );
342 //Menu->hWnd = 0;
343 }
344 }
345 }
346
347 if (!UserMarkObjectDestroy(Menu)) return TRUE;
348
349 /* Remove all menu items */
350 IntDestroyMenu( Menu, bRecurse);
351
352 ret = UserDeleteObject(Menu->head.h, TYPE_MENU);
353 TRACE("IntDestroyMenuObject %d\n",ret);
354 return ret;
355 }
356 }
357 return FALSE;
358 }
359
360 BOOL
361 MenuInit(VOID)
362 {
363 NONCLIENTMETRICSW ncm;
364
365 /* get the menu font */
366 if (!ghMenuFont || !ghMenuFontBold)
367 {
368 ncm.cbSize = sizeof(ncm);
369 if(!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0))
370 {
371 ERR("MenuInit(): SystemParametersInfo(SPI_GETNONCLIENTMETRICS) failed!\n");
372 return FALSE;
373 }
374
375 ghMenuFont = GreCreateFontIndirectW(&ncm.lfMenuFont);
376 if (ghMenuFont == NULL)
377 {
378 ERR("MenuInit(): CreateFontIndirectW(hMenuFont) failed!\n");
379 return FALSE;
380 }
381 ncm.lfMenuFont.lfWeight = max(ncm.lfMenuFont.lfWeight + 300, 1000);
382 ghMenuFontBold = GreCreateFontIndirectW(&ncm.lfMenuFont);
383 if (ghMenuFontBold == NULL)
384 {
385 ERR("MenuInit(): CreateFontIndirectW(hMenuFontBold) failed!\n");
386 GreDeleteObject(ghMenuFont);
387 ghMenuFont = NULL;
388 return FALSE;
389 }
390
391 GreSetObjectOwner(ghMenuFont, GDI_OBJ_HMGR_PUBLIC);
392 GreSetObjectOwner(ghMenuFontBold, GDI_OBJ_HMGR_PUBLIC);
393
394 co_IntSetupOBM();
395 }
396
397 return TRUE;
398 }
399
400
401 /**********************************************************************
402 * MENU_depth
403 *
404 * detect if there are loops in the menu tree (or the depth is too large)
405 */
406 int FASTCALL MENU_depth( PMENU pmenu, int depth)
407 {
408 UINT i;
409 ITEM *item;
410 int subdepth;
411
412 if (!pmenu) return depth;
413
414 depth++;
415 if( depth > MAXMENUDEPTH) return depth;
416 item = pmenu->rgItems;
417 subdepth = depth;
418 for( i = 0; i < pmenu->cItems && subdepth <= MAXMENUDEPTH; i++, item++)
419 {
420 if( item->spSubMenu)//VerifyMenu(item->spSubMenu))
421 {
422 int bdepth = MENU_depth( item->spSubMenu, depth);
423 if( bdepth > subdepth) subdepth = bdepth;
424 }
425 if( subdepth > MAXMENUDEPTH)
426 TRACE("<- hmenu %p\n", item->spSubMenu);
427 }
428 return subdepth;
429 }
430
431
432 /******************************************************************************
433 *
434 * UINT MenuGetStartOfNextColumn(
435 * PMENU Menu)
436 *
437 *****************************************************************************/
438
439 static UINT MENU_GetStartOfNextColumn(
440 PMENU menu )
441 {
442 PITEM pItem;
443 UINT i;
444
445 if(!menu)
446 return NO_SELECTED_ITEM;
447
448 i = menu->iItem + 1;
449 if( i == NO_SELECTED_ITEM )
450 return i;
451
452 pItem = menu->rgItems;
453 if (!pItem) return NO_SELECTED_ITEM;
454
455 for( ; i < menu->cItems; ++i ) {
456 if (pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
457 return i;
458 }
459
460 return NO_SELECTED_ITEM;
461 }
462
463 /******************************************************************************
464 *
465 * UINT MenuGetStartOfPrevColumn(
466 * PMENU Menu)
467 *
468 *****************************************************************************/
469 static UINT MENU_GetStartOfPrevColumn(
470 PMENU menu )
471 {
472 UINT i;
473 PITEM pItem;
474
475 if( !menu )
476 return NO_SELECTED_ITEM;
477
478 if( menu->iItem == 0 || menu->iItem == NO_SELECTED_ITEM )
479 return NO_SELECTED_ITEM;
480
481 pItem = menu->rgItems;
482 if (!pItem) return NO_SELECTED_ITEM;
483
484 /* Find the start of the column */
485
486 for(i = menu->iItem; i != 0 &&
487 !(pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK));
488 --i); /* empty */
489
490 if(i == 0)
491 return NO_SELECTED_ITEM;
492
493 for(--i; i != 0; --i) {
494 if (pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
495 break;
496 }
497
498 TRACE("ret %d.\n", i );
499
500 return i;
501 }
502
503 /***********************************************************************
504 * MENU_FindItem
505 *
506 * Find a menu item. Return a pointer on the item, and modifies *hmenu
507 * in case the item was in a sub-menu.
508 */
509 PITEM FASTCALL MENU_FindItem( PMENU *pmenu, UINT *nPos, UINT wFlags )
510 {
511 MENU *menu = *pmenu;
512 ITEM *fallback = NULL;
513 UINT fallback_pos = 0;
514 UINT i;
515
516 if (!menu) return NULL;
517
518 if (wFlags & MF_BYPOSITION)
519 {
520 if (!menu->cItems) return NULL;
521 if (*nPos >= menu->cItems) return NULL;
522 return &menu->rgItems[*nPos];
523 }
524 else
525 {
526 PITEM item = menu->rgItems;
527 for (i = 0; i < menu->cItems; i++, item++)
528 {
529 if (item->spSubMenu)
530 {
531 PMENU psubmenu = item->spSubMenu;//VerifyMenu(item->spSubMenu);
532 PITEM subitem = MENU_FindItem( &psubmenu, nPos, wFlags );
533 if (subitem)
534 {
535 *pmenu = psubmenu;
536 return subitem;
537 }
538 else if (item->wID == *nPos)
539 {
540 /* fallback to this item if nothing else found */
541 fallback_pos = i;
542 fallback = item;
543 }
544 }
545 else if (item->wID == *nPos)
546 {
547 *nPos = i;
548 return item;
549 }
550 }
551 }
552
553 if (fallback)
554 *nPos = fallback_pos;
555
556 return fallback;
557 }
558
559 /***********************************************************************
560 * MenuFindSubMenu
561 *
562 * Find a Sub menu. Return the position of the submenu, and modifies
563 * *hmenu in case it is found in another sub-menu.
564 * If the submenu cannot be found, NO_SELECTED_ITEM is returned.
565 */
566 static UINT FASTCALL MENU_FindSubMenu(PMENU *menu, PMENU SubTarget )
567 {
568 UINT i;
569 PITEM item;
570
571 item = ((PMENU)*menu)->rgItems;
572 for (i = 0; i < ((PMENU)*menu)->cItems; i++, item++)
573 {
574 if (!item->spSubMenu)
575 continue;
576 else
577 {
578 if (item->spSubMenu == SubTarget)
579 {
580 return i;
581 }
582 else
583 {
584 PMENU pSubMenu = item->spSubMenu;
585 UINT pos = MENU_FindSubMenu( &pSubMenu, SubTarget );
586 if (pos != NO_SELECTED_ITEM)
587 {
588 *menu = pSubMenu;
589 return pos;
590 }
591 }
592 }
593 }
594 return NO_SELECTED_ITEM;
595 }
596
597 BOOL FASTCALL
598 IntRemoveMenuItem( PMENU pMenu, UINT nPos, UINT wFlags, BOOL bRecurse )
599 {
600 PITEM item;
601 PITEM newItems;
602
603 TRACE("(menu=%p pos=%04x flags=%04x)\n",pMenu, nPos, wFlags);
604 if (!(item = MENU_FindItem( &pMenu, &nPos, wFlags ))) return FALSE;
605
606 /* Remove item */
607
608 FreeMenuText(pMenu,item);
609 if (bRecurse && item->spSubMenu)
610 {
611 IntDestroyMenuObject(item->spSubMenu, bRecurse);
612 }
613 ////// Use cAlloced with inc's of 8's....
614 if (--pMenu->cItems == 0)
615 {
616 DesktopHeapFree(pMenu->head.rpdesk, pMenu->rgItems );
617 pMenu->rgItems = NULL;
618 }
619 else
620 {
621 while (nPos < pMenu->cItems)
622 {
623 *item = *(item+1);
624 item++;
625 nPos++;
626 }
627 newItems = DesktopHeapReAlloc(pMenu->head.rpdesk, pMenu->rgItems, pMenu->cItems * sizeof(ITEM));
628 if (newItems)
629 {
630 pMenu->rgItems = newItems;
631 }
632 }
633 return TRUE;
634 }
635
636 /**********************************************************************
637 * MENU_InsertItem
638 *
639 * Insert (allocate) a new item into a menu.
640 */
641 ITEM *MENU_InsertItem( PMENU menu, UINT pos, UINT flags, PMENU *submenu, UINT *npos )
642 {
643 ITEM *newItems;
644
645 /* Find where to insert new item */
646
647 if (flags & MF_BYPOSITION) {
648 if (pos > menu->cItems)
649 pos = menu->cItems;
650 } else {
651 if (!MENU_FindItem( &menu, &pos, flags ))
652 {
653 if (submenu) *submenu = menu;
654 if (npos) *npos = pos;
655 pos = menu->cItems;
656 }
657 }
658
659 /* Make sure that MDI system buttons stay on the right side.
660 * Note: XP treats only bitmap handles 1 - 6 as "magic" ones
661 * regardless of their id.
662 */
663 while ( pos > 0 &&
664 (INT_PTR)menu->rgItems[pos - 1].hbmp >= (INT_PTR)HBMMENU_SYSTEM &&
665 (INT_PTR)menu->rgItems[pos - 1].hbmp <= (INT_PTR)HBMMENU_MBAR_CLOSE_D)
666 pos--;
667
668 TRACE("inserting at %u flags %x\n", pos, flags);
669
670 /* Create new items array */
671
672 newItems = DesktopHeapAlloc(menu->head.rpdesk, sizeof(ITEM) * (menu->cItems+1) );
673 if (!newItems)
674 {
675 WARN("allocation failed\n" );
676 return NULL;
677 }
678 if (menu->cItems > 0)
679 {
680 /* Copy the old array into the new one */
681 if (pos > 0) RtlCopyMemory( newItems, menu->rgItems, pos * sizeof(ITEM) );
682 if (pos < menu->cItems) RtlCopyMemory( &newItems[pos+1], &menu->rgItems[pos], (menu->cItems-pos)*sizeof(ITEM) );
683 DesktopHeapFree(menu->head.rpdesk, menu->rgItems );
684 }
685 menu->rgItems = newItems;
686 menu->cItems++;
687 RtlZeroMemory( &newItems[pos], sizeof(*newItems) );
688 menu->cyMenu = 0; /* force size recalculate */
689 return &newItems[pos];
690 }
691
692 BOOL FASTCALL
693 IntInsertMenuItem(
694 _In_ PMENU MenuObject,
695 UINT uItem,
696 BOOL fByPosition,
697 PROSMENUITEMINFO ItemInfo,
698 PUNICODE_STRING lpstr)
699 {
700 PITEM MenuItem;
701 PMENU SubMenu = NULL;
702
703 NT_ASSERT(MenuObject != NULL);
704
705 if (MAX_MENU_ITEMS <= MenuObject->cItems)
706 {
707 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
708 return FALSE;
709 }
710
711 SubMenu = MenuObject;
712
713 if(!(MenuItem = MENU_InsertItem( SubMenu, uItem, fByPosition ? MF_BYPOSITION : MF_BYCOMMAND, &SubMenu, &uItem ))) return FALSE;
714
715 if(!IntSetMenuItemInfo(SubMenu, MenuItem, ItemInfo, lpstr))
716 {
717 IntRemoveMenuItem(SubMenu, uItem, fByPosition ? MF_BYPOSITION : MF_BYCOMMAND, FALSE);
718 return FALSE;
719 }
720
721 /* Force size recalculation! */
722 SubMenu->cyMenu = 0;
723 MenuItem->hbmpChecked = MenuItem->hbmpUnchecked = 0;
724
725 TRACE("IntInsertMenuItemToList = %u %i\n", uItem, (BOOL)((INT)uItem >= 0));
726
727 return TRUE;
728 }
729
730 PMENU FASTCALL
731 IntCreateMenu(
732 _Out_ PHANDLE Handle,
733 _In_ BOOL IsMenuBar,
734 _In_ PDESKTOP Desktop,
735 _In_ PPROCESSINFO ppi)
736 {
737 PMENU Menu;
738
739 Menu = (PMENU)UserCreateObject( gHandleTable,
740 Desktop,
741 ppi->ptiList,
742 Handle,
743 TYPE_MENU,
744 sizeof(MENU));
745 if(!Menu)
746 {
747 *Handle = 0;
748 return NULL;
749 }
750
751 Menu->cyMax = 0; /* Default */
752 Menu->hbrBack = NULL; /* No brush */
753 Menu->dwContextHelpId = 0; /* Default */
754 Menu->dwMenuData = 0; /* Default */
755 Menu->iItem = NO_SELECTED_ITEM; // Focused item
756 Menu->fFlags = (IsMenuBar ? 0 : MNF_POPUP);
757 Menu->spwndNotify = NULL;
758 Menu->cyMenu = 0; // Height
759 Menu->cxMenu = 0; // Width
760 Menu->cItems = 0; // Item count
761 Menu->iTop = 0;
762 Menu->iMaxTop = 0;
763 Menu->cxTextAlign = 0;
764 Menu->rgItems = NULL;
765
766 Menu->hWnd = NULL;
767 Menu->TimeToHide = FALSE;
768
769 return Menu;
770 }
771
772 BOOL FASTCALL
773 IntCloneMenuItems(PMENU Destination, PMENU Source)
774 {
775 PITEM MenuItem, NewMenuItem = NULL;
776 UINT i;
777
778 if(!Source->cItems)
779 return FALSE;
780
781 NewMenuItem = DesktopHeapAlloc(Destination->head.rpdesk, Source->cItems * sizeof(ITEM));
782 if(!NewMenuItem) return FALSE;
783
784 RtlZeroMemory(NewMenuItem, Source->cItems * sizeof(ITEM));
785
786 Destination->rgItems = NewMenuItem;
787
788 MenuItem = Source->rgItems;
789 for (i = 0; i < Source->cItems; i++, MenuItem++, NewMenuItem++)
790 {
791 NewMenuItem->fType = MenuItem->fType;
792 NewMenuItem->fState = MenuItem->fState;
793 NewMenuItem->wID = MenuItem->wID;
794 NewMenuItem->spSubMenu = MenuItem->spSubMenu;
795 NewMenuItem->hbmpChecked = MenuItem->hbmpChecked;
796 NewMenuItem->hbmpUnchecked = MenuItem->hbmpUnchecked;
797 NewMenuItem->dwItemData = MenuItem->dwItemData;
798 if (MenuItem->lpstr.Length)
799 {
800 NewMenuItem->lpstr.Length = 0;
801 NewMenuItem->lpstr.MaximumLength = MenuItem->lpstr.MaximumLength;
802 NewMenuItem->lpstr.Buffer = DesktopHeapAlloc(Destination->head.rpdesk, MenuItem->lpstr.MaximumLength);
803 if (!NewMenuItem->lpstr.Buffer)
804 {
805 DesktopHeapFree(Destination->head.rpdesk, NewMenuItem);
806 break;
807 }
808 RtlCopyUnicodeString(&NewMenuItem->lpstr, &MenuItem->lpstr);
809 NewMenuItem->lpstr.Buffer[MenuItem->lpstr.Length / sizeof(WCHAR)] = 0;
810 NewMenuItem->Xlpstr = NewMenuItem->lpstr.Buffer;
811 }
812 else
813 {
814 NewMenuItem->lpstr.Buffer = MenuItem->lpstr.Buffer;
815 NewMenuItem->Xlpstr = NewMenuItem->lpstr.Buffer;
816 }
817 NewMenuItem->hbmp = MenuItem->hbmp;
818 Destination->cItems = i + 1;
819 }
820 return TRUE;
821 }
822
823 PMENU FASTCALL
824 IntCloneMenu(PMENU Source)
825 {
826 HANDLE hMenu;
827 PMENU Menu;
828
829 if(!Source)
830 return NULL;
831
832 /* A menu is valid process wide. We can pass to the object manager any thread ptr */
833 Menu = (PMENU)UserCreateObject( gHandleTable,
834 Source->head.rpdesk,
835 ((PPROCESSINFO)Source->head.hTaskWow)->ptiList,
836 &hMenu,
837 TYPE_MENU,
838 sizeof(MENU));
839 if(!Menu)
840 return NULL;
841
842 Menu->fFlags = Source->fFlags;
843 Menu->cyMax = Source->cyMax;
844 Menu->hbrBack = Source->hbrBack;
845 Menu->dwContextHelpId = Source->dwContextHelpId;
846 Menu->dwMenuData = Source->dwMenuData;
847 Menu->iItem = NO_SELECTED_ITEM;
848 Menu->spwndNotify = NULL;
849 Menu->cyMenu = 0;
850 Menu->cxMenu = 0;
851 Menu->cItems = 0;
852 Menu->iTop = 0;
853 Menu->iMaxTop = 0;
854 Menu->cxTextAlign = 0;
855 Menu->rgItems = NULL;
856
857 Menu->hWnd = NULL;
858 Menu->TimeToHide = FALSE;
859
860 IntCloneMenuItems(Menu, Source);
861
862 return Menu;
863 }
864
865 BOOL FASTCALL
866 IntSetMenuFlagRtoL(PMENU Menu)
867 {
868 ERR("SetMenuFlagRtoL\n");
869 Menu->fFlags |= MNF_RTOL;
870 return TRUE;
871 }
872
873 BOOL FASTCALL
874 IntSetMenuContextHelpId(PMENU Menu, DWORD dwContextHelpId)
875 {
876 Menu->dwContextHelpId = dwContextHelpId;
877 return TRUE;
878 }
879
880 BOOL FASTCALL
881 IntGetMenuInfo(PMENU Menu, PROSMENUINFO lpmi)
882 {
883 if(lpmi->fMask & MIM_BACKGROUND)
884 lpmi->hbrBack = Menu->hbrBack;
885 if(lpmi->fMask & MIM_HELPID)
886 lpmi->dwContextHelpID = Menu->dwContextHelpId;
887 if(lpmi->fMask & MIM_MAXHEIGHT)
888 lpmi->cyMax = Menu->cyMax;
889 if(lpmi->fMask & MIM_MENUDATA)
890 lpmi->dwMenuData = Menu->dwMenuData;
891 if(lpmi->fMask & MIM_STYLE)
892 lpmi->dwStyle = Menu->fFlags & MNS_STYLE_MASK;
893
894 if (sizeof(MENUINFO) < lpmi->cbSize)
895 {
896 lpmi->cItems = Menu->cItems;
897
898 lpmi->iItem = Menu->iItem;
899 lpmi->cxMenu = Menu->cxMenu;
900 lpmi->cyMenu = Menu->cyMenu;
901 lpmi->spwndNotify = Menu->spwndNotify;
902 lpmi->cxTextAlign = Menu->cxTextAlign;
903 lpmi->iTop = Menu->iTop;
904 lpmi->iMaxTop = Menu->iMaxTop;
905 lpmi->dwArrowsOn = Menu->dwArrowsOn;
906
907 lpmi->fFlags = Menu->fFlags;
908 lpmi->Self = Menu->head.h;
909 lpmi->TimeToHide = Menu->TimeToHide;
910 lpmi->Wnd = Menu->hWnd;
911 }
912 return TRUE;
913 }
914
915 BOOL FASTCALL
916 IntSetMenuInfo(PMENU Menu, PROSMENUINFO lpmi)
917 {
918 if(lpmi->fMask & MIM_BACKGROUND)
919 Menu->hbrBack = lpmi->hbrBack;
920 if(lpmi->fMask & MIM_HELPID)
921 Menu->dwContextHelpId = lpmi->dwContextHelpID;
922 if(lpmi->fMask & MIM_MAXHEIGHT)
923 Menu->cyMax = lpmi->cyMax;
924 if(lpmi->fMask & MIM_MENUDATA)
925 Menu->dwMenuData = lpmi->dwMenuData;
926 if(lpmi->fMask & MIM_STYLE)
927 Menu->fFlags ^= (Menu->fFlags ^ lpmi->dwStyle) & MNS_STYLE_MASK;
928 if(lpmi->fMask & MIM_APPLYTOSUBMENUS)
929 {
930 int i;
931 PITEM item = Menu->rgItems;
932 for ( i = Menu->cItems; i; i--, item++)
933 {
934 if ( item->spSubMenu )
935 {
936 IntSetMenuInfo( item->spSubMenu, lpmi);
937 }
938 }
939 }
940 if (sizeof(MENUINFO) < lpmi->cbSize)
941 {
942 Menu->iItem = lpmi->iItem;
943 Menu->cyMenu = lpmi->cyMenu;
944 Menu->cxMenu = lpmi->cxMenu;
945 Menu->spwndNotify = lpmi->spwndNotify;
946 Menu->cxTextAlign = lpmi->cxTextAlign;
947 Menu->iTop = lpmi->iTop;
948 Menu->iMaxTop = lpmi->iMaxTop;
949 Menu->dwArrowsOn = lpmi->dwArrowsOn;
950
951 Menu->TimeToHide = lpmi->TimeToHide;
952 Menu->hWnd = lpmi->Wnd;
953 }
954 if ( lpmi->fMask & MIM_STYLE)
955 {
956 if (lpmi->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented wine\n");
957 if (lpmi->dwStyle & MNS_DRAGDROP) FIXME("MNS_DRAGDROP unimplemented wine\n");
958 if (lpmi->dwStyle & MNS_MODELESS) FIXME("MNS_MODELESS unimplemented wine\n");
959 }
960 return TRUE;
961 }
962
963 BOOL FASTCALL
964 IntGetMenuItemInfo(PMENU Menu, /* UNUSED PARAM!! */
965 PITEM MenuItem, PROSMENUITEMINFO lpmii)
966 {
967 NTSTATUS Status;
968
969 if(lpmii->fMask & (MIIM_FTYPE | MIIM_TYPE))
970 {
971 lpmii->fType = MenuItem->fType;
972 }
973 if(lpmii->fMask & MIIM_BITMAP)
974 {
975 lpmii->hbmpItem = MenuItem->hbmp;
976 }
977 if(lpmii->fMask & MIIM_CHECKMARKS)
978 {
979 lpmii->hbmpChecked = MenuItem->hbmpChecked;
980 lpmii->hbmpUnchecked = MenuItem->hbmpUnchecked;
981 }
982 if(lpmii->fMask & MIIM_DATA)
983 {
984 lpmii->dwItemData = MenuItem->dwItemData;
985 }
986 if(lpmii->fMask & MIIM_ID)
987 {
988 lpmii->wID = MenuItem->wID;
989 }
990 if(lpmii->fMask & MIIM_STATE)
991 {
992 lpmii->fState = MenuItem->fState;
993 }
994 if(lpmii->fMask & MIIM_SUBMENU)
995 {
996 lpmii->hSubMenu = MenuItem->spSubMenu ? MenuItem->spSubMenu->head.h : NULL;
997 }
998
999 if ((lpmii->fMask & MIIM_STRING) ||
1000 ((lpmii->fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(lpmii->fType) == MF_STRING)))
1001 {
1002 if (lpmii->dwTypeData == NULL)
1003 {
1004 lpmii->cch = MenuItem->lpstr.Length / sizeof(WCHAR);
1005 }
1006 else
1007 { //// lpmii->lpstr can be read in user mode!!!!
1008 Status = MmCopyToCaller(lpmii->dwTypeData, MenuItem->lpstr.Buffer,
1009 min(lpmii->cch * sizeof(WCHAR),
1010 MenuItem->lpstr.MaximumLength));
1011 if (! NT_SUCCESS(Status))
1012 {
1013 SetLastNtError(Status);
1014 return FALSE;
1015 }
1016 }
1017 }
1018
1019 if (sizeof(ROSMENUITEMINFO) == lpmii->cbSize)
1020 {
1021 lpmii->Rect.left = MenuItem->xItem;
1022 lpmii->Rect.top = MenuItem->yItem;
1023 lpmii->Rect.right = MenuItem->cxItem; // Do this for now......
1024 lpmii->Rect.bottom = MenuItem->cyItem;
1025 lpmii->dxTab = MenuItem->dxTab;
1026 lpmii->lpstr = MenuItem->lpstr.Buffer;
1027 lpmii->maxBmpSize.cx = MenuItem->cxBmp;
1028 lpmii->maxBmpSize.cy = MenuItem->cyBmp;
1029 }
1030
1031 return TRUE;
1032 }
1033
1034 BOOL FASTCALL
1035 IntSetMenuItemInfo(PMENU MenuObject, PITEM MenuItem, PROSMENUITEMINFO lpmii, PUNICODE_STRING lpstr)
1036 {
1037 PMENU SubMenuObject;
1038 BOOL circref = FALSE;
1039
1040 if(!MenuItem || !MenuObject || !lpmii)
1041 {
1042 return FALSE;
1043 }
1044 if ( lpmii->fMask & MIIM_FTYPE )
1045 {
1046 MenuItem->fType &= ~MENUITEMINFO_TYPE_MASK;
1047 MenuItem->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
1048 }
1049 if (lpmii->fMask & MIIM_TYPE)
1050 {
1051 #if 0 //// Done in User32.
1052 if (lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP))
1053 {
1054 ERR("IntSetMenuItemInfo: Invalid combination of fMask bits used\n");
1055 KeRosDumpStackFrames(NULL, 20);
1056 /* This does not happen on Win9x/ME */
1057 SetLastNtError( ERROR_INVALID_PARAMETER);
1058 return FALSE;
1059 }
1060 #endif
1061 /*
1062 * Delete the menu item type when changing type from
1063 * MF_STRING.
1064 */
1065 if (MenuItem->fType != lpmii->fType &&
1066 MENU_ITEM_TYPE(MenuItem->fType) == MFT_STRING)
1067 {
1068 FreeMenuText(MenuObject,MenuItem);
1069 RtlInitUnicodeString(&MenuItem->lpstr, NULL);
1070 MenuItem->Xlpstr = NULL;
1071 }
1072 if(lpmii->fType & MFT_BITMAP)
1073 {
1074 if(lpmii->hbmpItem)
1075 MenuItem->hbmp = lpmii->hbmpItem;
1076 else
1077 { /* Win 9x/Me stuff */
1078 MenuItem->hbmp = (HBITMAP)((ULONG_PTR)(LOWORD(lpmii->dwTypeData)));
1079 }
1080 lpmii->dwTypeData = 0;
1081 }
1082 }
1083 if(lpmii->fMask & MIIM_BITMAP)
1084 {
1085 MenuItem->hbmp = lpmii->hbmpItem;
1086 if (MenuItem->hbmp <= HBMMENU_POPUP_MINIMIZE && MenuItem->hbmp >= HBMMENU_CALLBACK)
1087 MenuItem->fState |= MFS_HBMMENUBMP;
1088 else
1089 MenuItem->fState &= ~MFS_HBMMENUBMP;
1090 }
1091 if(lpmii->fMask & MIIM_CHECKMARKS)
1092 {
1093 MenuItem->hbmpChecked = lpmii->hbmpChecked;
1094 MenuItem->hbmpUnchecked = lpmii->hbmpUnchecked;
1095 }
1096 if(lpmii->fMask & MIIM_DATA)
1097 {
1098 MenuItem->dwItemData = lpmii->dwItemData;
1099 }
1100 if(lpmii->fMask & MIIM_ID)
1101 {
1102 MenuItem->wID = lpmii->wID;
1103 }
1104 if(lpmii->fMask & MIIM_STATE)
1105 {
1106 /* Remove MFS_DEFAULT flag from all other menu items if this item
1107 has the MFS_DEFAULT state */
1108 if(lpmii->fState & MFS_DEFAULT)
1109 UserSetMenuDefaultItem(MenuObject, -1, 0);
1110 /* Update the menu item state flags */
1111 UpdateMenuItemState(MenuItem->fState, lpmii->fState);
1112 }
1113
1114 if(lpmii->fMask & MIIM_SUBMENU)
1115 {
1116 if (lpmii->hSubMenu)
1117 {
1118 SubMenuObject = UserGetMenuObject(lpmii->hSubMenu);
1119 if ( SubMenuObject && !(UserObjectInDestroy(lpmii->hSubMenu)) )
1120 {
1121 //// wine Bug 12171 : Adding Popup Menu to itself! Could create endless loops.
1122 //// CORE-7967.
1123 if (MenuObject == SubMenuObject)
1124 {
1125 HANDLE hMenu;
1126 ERR("Pop Up Menu Double Trouble!\n");
1127 SubMenuObject = IntCreateMenu(&hMenu,
1128 FALSE,
1129 MenuObject->head.rpdesk,
1130 (PPROCESSINFO)MenuObject->head.hTaskWow); // It will be marked.
1131 if (!SubMenuObject) return FALSE;
1132 IntReleaseMenuObject(SubMenuObject); // This will be referenced again after insertion.
1133 circref = TRUE;
1134 }
1135 if ( MENU_depth( SubMenuObject, 0) > MAXMENUDEPTH )
1136 {
1137 ERR( "Loop detected in menu hierarchy or maximum menu depth exceeded!\n");
1138 if (circref) IntDestroyMenuObject(SubMenuObject, FALSE);
1139 return FALSE;
1140 }
1141 /* Make sure the submenu is marked as a popup menu */
1142 SubMenuObject->fFlags |= MNF_POPUP;
1143 // Now fix the test_subpopup_locked_by_menu tests....
1144 if (MenuItem->spSubMenu) IntReleaseMenuObject(MenuItem->spSubMenu);
1145 MenuItem->spSubMenu = SubMenuObject;
1146 UserReferenceObject(SubMenuObject);
1147 }
1148 else
1149 {
1150 EngSetLastError( ERROR_INVALID_PARAMETER);
1151 return FALSE;
1152 }
1153 }
1154 else
1155 { // If submenu just dereference it.
1156 if (MenuItem->spSubMenu) IntReleaseMenuObject(MenuItem->spSubMenu);
1157 MenuItem->spSubMenu = NULL;
1158 }
1159 }
1160
1161 if ((lpmii->fMask & MIIM_STRING) ||
1162 ((lpmii->fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(lpmii->fType) == MF_STRING)))
1163 {
1164 /* free the string when used */
1165 FreeMenuText(MenuObject,MenuItem);
1166 RtlInitUnicodeString(&MenuItem->lpstr, NULL);
1167 MenuItem->Xlpstr = NULL;
1168
1169 if(lpmii->dwTypeData && lpmii->cch && lpstr && lpstr->Buffer)
1170 {
1171 UNICODE_STRING Source;
1172
1173 if (!NT_VERIFY(lpmii->cch <= UNICODE_STRING_MAX_CHARS))
1174 {
1175 return FALSE;
1176 }
1177
1178 Source.Length = Source.MaximumLength = (USHORT)(lpmii->cch * sizeof(WCHAR));
1179 Source.Buffer = lpmii->dwTypeData;
1180
1181 MenuItem->lpstr.Buffer = DesktopHeapAlloc( MenuObject->head.rpdesk, Source.Length + sizeof(WCHAR));
1182 if(MenuItem->lpstr.Buffer != NULL)
1183 {
1184 MenuItem->lpstr.Length = 0;
1185 MenuItem->lpstr.MaximumLength = Source.Length + sizeof(WCHAR);
1186 RtlCopyUnicodeString(&MenuItem->lpstr, &Source);
1187 MenuItem->lpstr.Buffer[MenuItem->lpstr.Length / sizeof(WCHAR)] = 0;
1188
1189 MenuItem->cch = MenuItem->lpstr.Length / sizeof(WCHAR);
1190 MenuItem->Xlpstr = (USHORT*)MenuItem->lpstr.Buffer;
1191 }
1192 }
1193 }
1194
1195 if( !(MenuObject->fFlags & MNF_SYSMENU) &&
1196 !MenuItem->Xlpstr &&
1197 !lpmii->dwTypeData &&
1198 !(MenuItem->fType & MFT_OWNERDRAW) &&
1199 !MenuItem->hbmp)
1200 MenuItem->fType |= MFT_SEPARATOR;
1201
1202 if (sizeof(ROSMENUITEMINFO) == lpmii->cbSize)
1203 {
1204 MenuItem->xItem = lpmii->Rect.left;
1205 MenuItem->yItem = lpmii->Rect.top;
1206 MenuItem->cxItem = lpmii->Rect.right; // Do this for now......
1207 MenuItem->cyItem = lpmii->Rect.bottom;
1208 MenuItem->dxTab = lpmii->dxTab;
1209 lpmii->lpstr = MenuItem->lpstr.Buffer; /* Send back new allocated string or zero */
1210 MenuItem->cxBmp = lpmii->maxBmpSize.cx;
1211 MenuItem->cyBmp = lpmii->maxBmpSize.cy;
1212 }
1213
1214 return TRUE;
1215 }
1216
1217
1218 UINT FASTCALL
1219 IntEnableMenuItem(PMENU MenuObject, UINT uIDEnableItem, UINT uEnable)
1220 {
1221 PITEM MenuItem;
1222 UINT res;
1223
1224 if (!(MenuItem = MENU_FindItem( &MenuObject, &uIDEnableItem, uEnable ))) return (UINT)-1;
1225
1226 res = MenuItem->fState & (MF_GRAYED | MF_DISABLED);
1227
1228 MenuItem->fState ^= (res ^ uEnable) & (MF_GRAYED | MF_DISABLED);
1229
1230 /* If the close item in the system menu change update the close button */
1231 if (res != uEnable)
1232 {
1233 switch (MenuItem->wID) // More than just close.
1234 {
1235 case SC_CLOSE:
1236 case SC_MAXIMIZE:
1237 case SC_MINIMIZE:
1238 case SC_MOVE:
1239 case SC_RESTORE:
1240 case SC_SIZE:
1241 if (MenuObject->fFlags & MNF_SYSSUBMENU && MenuObject->spwndNotify != 0)
1242 {
1243 //RECTL rc = MenuObject->spwndNotify->rcWindow;
1244
1245 /* Refresh the frame to reflect the change */
1246 //IntMapWindowPoints(0, MenuObject->spwndNotify, (POINT *)&rc, 2);
1247 //rc.bottom = 0;
1248 //co_UserRedrawWindow(MenuObject->spwndNotify, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
1249
1250 // Allow UxTheme!
1251 UserPaintCaption(MenuObject->spwndNotify, DC_BUTTONS);
1252 }
1253 default:
1254 break;
1255 }
1256 }
1257 return res;
1258 }
1259
1260 DWORD FASTCALL
1261 IntCheckMenuItem(PMENU MenuObject, UINT uIDCheckItem, UINT uCheck)
1262 {
1263 PITEM MenuItem;
1264 DWORD res;
1265
1266 if (!(MenuItem = MENU_FindItem( &MenuObject, &uIDCheckItem, uCheck ))) return -1;
1267
1268 res = (DWORD)(MenuItem->fState & MF_CHECKED);
1269
1270 MenuItem->fState ^= (res ^ uCheck) & MF_CHECKED;
1271
1272 return res;
1273 }
1274
1275 BOOL FASTCALL
1276 UserSetMenuDefaultItem(PMENU MenuObject, UINT uItem, UINT fByPos)
1277 {
1278 UINT i;
1279 PITEM MenuItem = MenuObject->rgItems;
1280
1281 if (!MenuItem) return FALSE;
1282
1283 /* reset all default-item flags */
1284 for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
1285 {
1286 MenuItem->fState &= ~MFS_DEFAULT;
1287 }
1288
1289 /* no default item */
1290 if(uItem == (UINT)-1)
1291 {
1292 return TRUE;
1293 }
1294 MenuItem = MenuObject->rgItems;
1295 if ( fByPos )
1296 {
1297 if ( uItem >= MenuObject->cItems ) return FALSE;
1298 MenuItem[uItem].fState |= MFS_DEFAULT;
1299 return TRUE;
1300 }
1301 else
1302 {
1303 for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
1304 {
1305 if (MenuItem->wID == uItem)
1306 {
1307 MenuItem->fState |= MFS_DEFAULT;
1308 return TRUE;
1309 }
1310 }
1311
1312 }
1313 return FALSE;
1314 }
1315
1316 UINT FASTCALL
1317 IntGetMenuDefaultItem(PMENU MenuObject, UINT fByPos, UINT gmdiFlags, DWORD *gismc)
1318 {
1319 UINT i = 0;
1320 PITEM MenuItem = MenuObject->rgItems;
1321
1322 /* empty menu */
1323 if (!MenuItem) return -1;
1324
1325 while ( !( MenuItem->fState & MFS_DEFAULT ) )
1326 {
1327 i++; MenuItem++;
1328 if (i >= MenuObject->cItems ) return -1;
1329 }
1330
1331 /* default: don't return disabled items */
1332 if ( (!(GMDI_USEDISABLED & gmdiFlags)) && (MenuItem->fState & MFS_DISABLED )) return -1;
1333
1334 /* search rekursiv when needed */
1335 if ( (gmdiFlags & GMDI_GOINTOPOPUPS) && MenuItem->spSubMenu )
1336 {
1337 UINT ret;
1338 (*gismc)++;
1339 ret = IntGetMenuDefaultItem( MenuItem->spSubMenu, fByPos, gmdiFlags, gismc );
1340 (*gismc)--;
1341 if ( -1 != ret ) return ret;
1342
1343 /* when item not found in submenu, return the popup item */
1344 }
1345 return ( fByPos ) ? i : MenuItem->wID;
1346 }
1347
1348 PMENU
1349 FASTCALL
1350 co_IntGetSubMenu(
1351 PMENU pMenu,
1352 int nPos)
1353 {
1354 PITEM pItem;
1355 if (!(pItem = MENU_FindItem( &pMenu, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
1356 return pItem->spSubMenu;
1357 }
1358
1359 /***********************************************************************
1360 * MenuInitSysMenuPopup
1361 *
1362 * Grey the appropriate items in System menu.
1363 */
1364 void FASTCALL MENU_InitSysMenuPopup(PMENU menu, DWORD style, DWORD clsStyle, LONG HitTest )
1365 {
1366 BOOL gray;
1367 UINT DefItem;
1368
1369 gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
1370 IntEnableMenuItem( menu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
1371 gray = ((style & WS_MAXIMIZE) != 0);
1372 IntEnableMenuItem( menu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
1373 gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
1374 IntEnableMenuItem( menu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
1375 gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
1376 IntEnableMenuItem( menu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
1377 gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
1378 IntEnableMenuItem( menu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
1379 gray = (clsStyle & CS_NOCLOSE) != 0;
1380
1381 /* The menu item must keep its state if it's disabled */
1382 if(gray)
1383 IntEnableMenuItem( menu, SC_CLOSE, MF_GRAYED);
1384
1385 /* Set default menu item */
1386 if(style & WS_MINIMIZE) DefItem = SC_RESTORE;
1387 else if(HitTest == HTCAPTION) DefItem = ((style & (WS_MAXIMIZE | WS_MINIMIZE)) ? SC_RESTORE : SC_MAXIMIZE);
1388 else DefItem = SC_CLOSE;
1389
1390 UserSetMenuDefaultItem(menu, DefItem, MF_BYCOMMAND);
1391 }
1392
1393
1394 /***********************************************************************
1395 * MenuDrawPopupGlyph
1396 *
1397 * Draws popup magic glyphs (can be found in system menu).
1398 */
1399 static void FASTCALL
1400 MENU_DrawPopupGlyph(HDC dc, LPRECT r, INT_PTR popupMagic, BOOL inactive, BOOL hilite)
1401 {
1402 LOGFONTW lf;
1403 HFONT hFont, hOldFont;
1404 COLORREF clrsave;
1405 INT bkmode;
1406 WCHAR symbol;
1407 switch (popupMagic)
1408 {
1409 case (INT_PTR) HBMMENU_POPUP_RESTORE:
1410 symbol = '2';
1411 break;
1412 case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
1413 symbol = '0';
1414 break;
1415 case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
1416 symbol = '1';
1417 break;
1418 case (INT_PTR) HBMMENU_POPUP_CLOSE:
1419 symbol = 'r';
1420 break;
1421 default:
1422 ERR("Invalid popup magic bitmap %d\n", (int)popupMagic);
1423 return;
1424 }
1425 RtlZeroMemory(&lf, sizeof(LOGFONTW));
1426 RECTL_vInflateRect(r, -2, -2);
1427 lf.lfHeight = r->bottom - r->top;
1428 lf.lfWidth = 0;
1429 lf.lfWeight = FW_NORMAL;
1430 lf.lfCharSet = DEFAULT_CHARSET;
1431 RtlCopyMemory(lf.lfFaceName, L"Marlett", sizeof(L"Marlett"));
1432 hFont = GreCreateFontIndirectW(&lf);
1433 /* save font and text color */
1434 hOldFont = NtGdiSelectFont(dc, hFont);
1435 clrsave = GreGetTextColor(dc);
1436 bkmode = GreGetBkMode(dc);
1437 /* set color and drawing mode */
1438 IntGdiSetBkMode(dc, TRANSPARENT);
1439 if (inactive)
1440 {
1441 /* draw shadow */
1442 if (!hilite)
1443 {
1444 IntGdiSetTextColor(dc, IntGetSysColor(COLOR_HIGHLIGHTTEXT));
1445 GreTextOutW(dc, r->left + 1, r->top + 1, &symbol, 1);
1446 }
1447 }
1448 IntGdiSetTextColor(dc, IntGetSysColor(inactive ? COLOR_GRAYTEXT : (hilite ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)));
1449 /* draw selected symbol */
1450 GreTextOutW(dc, r->left, r->top, &symbol, 1);
1451 /* restore previous settings */
1452 IntGdiSetTextColor(dc, clrsave);
1453 NtGdiSelectFont(dc, hOldFont);
1454 IntGdiSetBkMode(dc, bkmode);
1455 GreDeleteObject(hFont);
1456 }
1457
1458 /***********************************************************************
1459 * MENU_AdjustMenuItemRect
1460 *
1461 * Adjust menu item rectangle according to scrolling state.
1462 */
1463 VOID FASTCALL
1464 MENU_AdjustMenuItemRect(PMENU menu, PRECTL rect)
1465 {
1466 if (menu->dwArrowsOn)
1467 {
1468 UINT arrow_bitmap_height;
1469 arrow_bitmap_height = gpsi->oembmi[OBI_UPARROW].cy; ///// Menu up arrow! OBM_UPARROW
1470 rect->top += arrow_bitmap_height - menu->iTop;
1471 rect->bottom += arrow_bitmap_height - menu->iTop;
1472 }
1473 }
1474
1475 /***********************************************************************
1476 * MENU_FindItemByCoords
1477 *
1478 * Find the item at the specified coordinates (screen coords). Does
1479 * not work for child windows and therefore should not be called for
1480 * an arbitrary system menu.
1481 */
1482 static ITEM *MENU_FindItemByCoords( MENU *menu, POINT pt, UINT *pos )
1483 {
1484 ITEM *item;
1485 UINT i;
1486 RECT rect;
1487 PWND pWnd = ValidateHwndNoErr(menu->hWnd);
1488
1489 if (!IntGetWindowRect(pWnd, &rect)) return NULL;
1490 if (pWnd->ExStyle & WS_EX_LAYOUTRTL)
1491 pt.x = rect.right - 1 - pt.x;
1492 else
1493 pt.x -= rect.left;
1494 pt.y -= rect.top;
1495 item = menu->rgItems;
1496 for (i = 0; i < menu->cItems; i++, item++)
1497 {
1498 //rect = item->rect;
1499 rect.left = item->xItem;
1500 rect.top = item->yItem;
1501 rect.right = item->cxItem; // Do this for now......
1502 rect.bottom = item->cyItem;
1503
1504 MENU_AdjustMenuItemRect(menu, &rect);
1505 if (RECTL_bPointInRect(&rect, pt.x, pt.y))
1506 {
1507 if (pos) *pos = i;
1508 return item;
1509 }
1510 }
1511 return NULL;
1512 }
1513
1514 INT FASTCALL IntMenuItemFromPoint(PWND pWnd, HMENU hMenu, POINT ptScreen)
1515 {
1516 MENU *menu = UserGetMenuObject(hMenu);
1517 UINT pos;
1518
1519 /*FIXME: Do we have to handle hWnd here? */
1520 if (!menu) return -1;
1521 if (!MENU_FindItemByCoords(menu, ptScreen, &pos)) return -1;
1522 return pos;
1523 }
1524
1525 /***********************************************************************
1526 * MenuFindItemByKey
1527 *
1528 * Find the menu item selected by a key press.
1529 * Return item id, -1 if none, -2 if we should close the menu.
1530 */
1531 static UINT FASTCALL MENU_FindItemByKey(PWND WndOwner, PMENU menu,
1532 WCHAR Key, BOOL ForceMenuChar)
1533 {
1534 LRESULT MenuChar;
1535 WORD Flags = 0;
1536
1537 TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)Key, Key, menu );
1538
1539 if (!menu || !VerifyMenu(menu))
1540 menu = co_IntGetSubMenu( UserGetMenuObject(WndOwner->SystemMenu), 0 );
1541 if (menu)
1542 {
1543 ITEM *item = menu->rgItems;
1544
1545 if ( !ForceMenuChar )
1546 {
1547 UINT i;
1548 BOOL cjk = UserGetSystemMetrics( SM_DBCSENABLED );
1549
1550 for (i = 0; i < menu->cItems; i++, item++)
1551 {
1552 LPWSTR text = item->Xlpstr;
1553 if( text)
1554 {
1555 const WCHAR *p = text - 2;
1556 do
1557 {
1558 const WCHAR *q = p + 2;
1559 p = wcschr (q, '&');
1560 if (!p && cjk) p = wcschr (q, '\036'); /* Japanese Win16 */
1561 }
1562 while (p != NULL && p [1] == '&');
1563 if (p && (towupper(p[1]) == towupper(Key))) return i;
1564 }
1565 }
1566 }
1567
1568 Flags |= menu->fFlags & MNF_POPUP ? MF_POPUP : 0;
1569 Flags |= menu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0;
1570
1571 MenuChar = co_IntSendMessage( UserHMGetHandle(WndOwner), WM_MENUCHAR,
1572 MAKEWPARAM(Key, Flags), (LPARAM) UserHMGetHandle(menu));
1573 if (HIWORD(MenuChar) == MNC_EXECUTE) return LOWORD(MenuChar);
1574 if (HIWORD(MenuChar) == MNC_CLOSE) return (UINT)(-2);
1575 }
1576 return (UINT)(-1);
1577 }
1578
1579 /***********************************************************************
1580 * MenuGetBitmapItemSize
1581 *
1582 * Get the size of a bitmap item.
1583 */
1584 static void FASTCALL MENU_GetBitmapItemSize(PITEM lpitem, SIZE *size, PWND WndOwner)
1585 {
1586 BITMAP bm;
1587 HBITMAP bmp = lpitem->hbmp;
1588
1589 size->cx = size->cy = 0;
1590
1591 /* check if there is a magic menu item associated with this item */
1592 if (IS_MAGIC_BITMAP(bmp))
1593 {
1594 switch((INT_PTR) bmp)
1595 {
1596 case (INT_PTR)HBMMENU_CALLBACK:
1597 {
1598 MEASUREITEMSTRUCT measItem;
1599 measItem.CtlType = ODT_MENU;
1600 measItem.CtlID = 0;
1601 measItem.itemID = lpitem->wID;
1602 measItem.itemWidth = lpitem->cxItem - lpitem->xItem; //lpitem->Rect.right - lpitem->Rect.left;
1603 measItem.itemHeight = lpitem->cyItem - lpitem->yItem; //lpitem->Rect.bottom - lpitem->Rect.top;
1604 measItem.itemData = lpitem->dwItemData;
1605 co_IntSendMessage( UserHMGetHandle(WndOwner), WM_MEASUREITEM, 0, (LPARAM)&measItem);
1606 size->cx = measItem.itemWidth;
1607 size->cy = measItem.itemHeight;
1608 TRACE("HBMMENU_CALLBACK Height %d Width %d\n",measItem.itemHeight,measItem.itemWidth);
1609 return;
1610 }
1611 break;
1612
1613 case (INT_PTR) HBMMENU_SYSTEM:
1614 if (lpitem->dwItemData)
1615 {
1616 bmp = (HBITMAP) lpitem->dwItemData;
1617 break;
1618 }
1619 /* fall through */
1620 case (INT_PTR) HBMMENU_MBAR_RESTORE:
1621 case (INT_PTR) HBMMENU_MBAR_MINIMIZE:
1622 case (INT_PTR) HBMMENU_MBAR_CLOSE:
1623 case (INT_PTR) HBMMENU_MBAR_MINIMIZE_D:
1624 case (INT_PTR) HBMMENU_MBAR_CLOSE_D:
1625 case (INT_PTR) HBMMENU_POPUP_CLOSE:
1626 case (INT_PTR) HBMMENU_POPUP_RESTORE:
1627 case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
1628 case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
1629 /* FIXME: Why we need to subtract these magic values? */
1630 /* to make them smaller than the menu bar? */
1631 size->cx = UserGetSystemMetrics(SM_CXSIZE) - 2;
1632 size->cy = UserGetSystemMetrics(SM_CYSIZE) - 4;
1633 return;
1634 }
1635 }
1636
1637 if (GreGetObject(bmp, sizeof(BITMAP), &bm))
1638 {
1639 size->cx = bm.bmWidth;
1640 size->cy = bm.bmHeight;
1641 }
1642 }
1643
1644 /***********************************************************************
1645 * MenuDrawBitmapItem
1646 *
1647 * Draw a bitmap item.
1648 */
1649 static void FASTCALL MENU_DrawBitmapItem(HDC hdc, PITEM lpitem, const RECT *rect,
1650 PMENU Menu, PWND WndOwner, UINT odaction, BOOL MenuBar)
1651 {
1652 BITMAP bm;
1653 DWORD rop;
1654 HDC hdcMem;
1655 HBITMAP bmp;
1656 int w = rect->right - rect->left;
1657 int h = rect->bottom - rect->top;
1658 int bmp_xoffset = 0;
1659 int left, top;
1660 HBITMAP hbmToDraw = lpitem->hbmp;
1661 bmp = hbmToDraw;
1662
1663 /* Check if there is a magic menu item associated with this item */
1664 if (IS_MAGIC_BITMAP(hbmToDraw))
1665 {
1666 UINT flags = 0;
1667 RECT r;
1668
1669 r = *rect;
1670 switch ((INT_PTR)hbmToDraw)
1671 {
1672 case (INT_PTR)HBMMENU_SYSTEM:
1673 if (lpitem->dwItemData)
1674 {
1675 if (ValidateHwndNoErr((HWND)lpitem->dwItemData))
1676 {
1677 ERR("Get Item Data from this Window!!!\n");
1678 }
1679
1680 ERR("Draw Bitmap\n");
1681 bmp = (HBITMAP)lpitem->dwItemData;
1682 if (!GreGetObject( bmp, sizeof(bm), &bm )) return;
1683 }
1684 else
1685 {
1686 PCURICON_OBJECT pIcon = NULL;
1687 //if (!BmpSysMenu) BmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
1688 //bmp = BmpSysMenu;
1689 //if (! GreGetObject(bmp, sizeof(bm), &bm)) return;
1690 /* only use right half of the bitmap */
1691 //bmp_xoffset = bm.bmWidth / 2;
1692 //bm.bmWidth -= bmp_xoffset;
1693 if (WndOwner)
1694 {
1695 pIcon = NC_IconForWindow(WndOwner);
1696 // FIXME: NC_IconForWindow should reference it for us */
1697 if (pIcon) UserReferenceObject(pIcon);
1698 }
1699 ERR("Draw ICON\n");
1700 if (pIcon)
1701 {
1702 LONG cx = UserGetSystemMetrics(SM_CXSMICON);
1703 LONG cy = UserGetSystemMetrics(SM_CYSMICON);
1704 LONG x = rect->left - cx/2 + 1 + (rect->bottom - rect->top)/2; // this is really what Window does
1705 LONG y = (rect->top + rect->bottom)/2 - cy/2; // center
1706 UserDrawIconEx(hdc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
1707 UserDereferenceObject(pIcon);
1708 }
1709 return;
1710 }
1711 goto got_bitmap;
1712 case (INT_PTR)HBMMENU_MBAR_RESTORE:
1713 flags = DFCS_CAPTIONRESTORE;
1714 break;
1715 case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
1716 r.right += 1;
1717 flags = DFCS_CAPTIONMIN;
1718 break;
1719 case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
1720 r.right += 1;
1721 flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
1722 break;
1723 case (INT_PTR)HBMMENU_MBAR_CLOSE:
1724 flags = DFCS_CAPTIONCLOSE;
1725 break;
1726 case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
1727 flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
1728 break;
1729 case (INT_PTR)HBMMENU_CALLBACK:
1730 {
1731 DRAWITEMSTRUCT drawItem;
1732 POINT origorg;
1733 drawItem.CtlType = ODT_MENU;
1734 drawItem.CtlID = 0;
1735 drawItem.itemID = lpitem->wID;
1736 drawItem.itemAction = odaction;
1737 drawItem.itemState = (lpitem->fState & MF_CHECKED)?ODS_CHECKED:0;
1738 drawItem.itemState |= (lpitem->fState & MF_DEFAULT)?ODS_DEFAULT:0;
1739 drawItem.itemState |= (lpitem->fState & MF_DISABLED)?ODS_DISABLED:0;
1740 drawItem.itemState |= (lpitem->fState & MF_GRAYED)?ODS_GRAYED|ODS_DISABLED:0;
1741 drawItem.itemState |= (lpitem->fState & MF_HILITE)?ODS_SELECTED:0;
1742 drawItem.itemState |= (!(Menu->fFlags & MNF_UNDERLINE))?ODS_NOACCEL:0;
1743 drawItem.itemState |= (Menu->fFlags & MNF_INACTIVE)?ODS_INACTIVE:0;
1744 drawItem.hwndItem = (HWND)UserHMGetHandle(Menu);
1745 drawItem.hDC = hdc;
1746 drawItem.rcItem = *rect;
1747 drawItem.itemData = lpitem->dwItemData;
1748 /* some applications make this assumption on the DC's origin */
1749 GreSetViewportOrgEx( hdc, lpitem->xItem, lpitem->yItem, &origorg);
1750 RECTL_vOffsetRect( &drawItem.rcItem, - lpitem->xItem, - lpitem->yItem);
1751 co_IntSendMessage( UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM)&drawItem);
1752 GreSetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1753 return;
1754 }
1755 break;
1756
1757 case (INT_PTR) HBMMENU_POPUP_CLOSE:
1758 case (INT_PTR) HBMMENU_POPUP_RESTORE:
1759 case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
1760 case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
1761 MENU_DrawPopupGlyph(hdc, &r, (INT_PTR)hbmToDraw, lpitem->fState & MF_GRAYED, lpitem->fState & MF_HILITE);
1762 return;
1763 }
1764 RECTL_vInflateRect(&r, -1, -1);
1765 if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
1766 DrawFrameControl(hdc, &r, DFC_CAPTION, flags);
1767 return;
1768 }
1769
1770 if (!bmp || !GreGetObject( bmp, sizeof(bm), &bm )) return;
1771
1772 got_bitmap:
1773 hdcMem = NtGdiCreateCompatibleDC( hdc );
1774 NtGdiSelectBitmap( hdcMem, bmp );
1775 /* handle fontsize > bitmap_height */
1776 top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
1777 left=rect->left;
1778 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_BITMAP(hbmToDraw)) ? NOTSRCCOPY : SRCCOPY;
1779 if ((lpitem->fState & MF_HILITE) && lpitem->hbmp)
1780 IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_HIGHLIGHT));
1781 NtGdiBitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop , 0, 0);
1782 IntGdiDeleteDC( hdcMem, FALSE );
1783 }
1784
1785 LONG
1786 IntGetDialogBaseUnits(VOID)
1787 {
1788 static DWORD units;
1789
1790 if (!units)
1791 {
1792 HDC hdc;
1793 SIZE size;
1794
1795 if ((hdc = UserGetDCEx(NULL, NULL, DCX_CACHE)))
1796 {
1797 size.cx = IntGetCharDimensions( hdc, NULL, (PDWORD)&size.cy );
1798 if (size.cx) units = MAKELONG( size.cx, size.cy );
1799 UserReleaseDC( 0, hdc, FALSE);
1800 }
1801 }
1802 return units;
1803 }
1804
1805
1806 /***********************************************************************
1807 * MenuCalcItemSize
1808 *
1809 * Calculate the size of the menu item and store it in lpitem->rect.
1810 */
1811 static void FASTCALL MENU_CalcItemSize( HDC hdc, PITEM lpitem, PMENU Menu, PWND pwndOwner,
1812 INT orgX, INT orgY, BOOL menuBar, BOOL textandbmp)
1813 {
1814 WCHAR *p;
1815 UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
1816 UINT arrow_bitmap_width;
1817 RECT Rect;
1818 INT itemheight = 0;
1819
1820 TRACE("dc=%x owner=%x (%d,%d)\n", hdc, pwndOwner, orgX, orgY);
1821
1822 arrow_bitmap_width = gpsi->oembmi[OBI_MNARROW].cx;
1823
1824 MenuCharSize.cx = IntGetCharDimensions( hdc, NULL, (PDWORD)&MenuCharSize.cy );
1825
1826 RECTL_vSetRect( &Rect, orgX, orgY, orgX, orgY );
1827
1828 if (lpitem->fType & MF_OWNERDRAW)
1829 {
1830 MEASUREITEMSTRUCT mis;
1831 mis.CtlType = ODT_MENU;
1832 mis.CtlID = 0;
1833 mis.itemID = lpitem->wID;
1834 mis.itemData = lpitem->dwItemData;
1835 mis.itemHeight = HIWORD( IntGetDialogBaseUnits());
1836 mis.itemWidth = 0;
1837 co_IntSendMessage( UserHMGetHandle(pwndOwner), WM_MEASUREITEM, 0, (LPARAM)&mis );
1838 /* Tests reveal that Windows ( Win95 thru WinXP) adds twice the average
1839 * width of a menufont character to the width of an owner-drawn menu.
1840 */
1841 Rect.right += mis.itemWidth + 2 * MenuCharSize.cx;
1842 if (menuBar) {
1843 /* under at least win95 you seem to be given a standard
1844 height for the menu and the height value is ignored */
1845 Rect.bottom += UserGetSystemMetrics(SM_CYMENUSIZE);
1846 } else
1847 Rect.bottom += mis.itemHeight;
1848 // Or this,
1849 //lpitem->cxBmp = mis.itemWidth;
1850 //lpitem->cyBmp = mis.itemHeight;
1851 TRACE("MF_OWNERDRAW Height %d Width %d\n",mis.itemHeight,mis.itemWidth);
1852 TRACE("MF_OWNERDRAW id=%04lx size=%dx%d cx %d cy %d\n",
1853 lpitem->wID, Rect.right-Rect.left,
1854 Rect.bottom-Rect.top, MenuCharSize.cx, MenuCharSize.cy);
1855
1856 lpitem->xItem = Rect.left;
1857 lpitem->yItem = Rect.top;
1858 lpitem->cxItem = Rect.right;
1859 lpitem->cyItem = Rect.bottom;
1860
1861 return;
1862 }
1863
1864 lpitem->xItem = orgX;
1865 lpitem->yItem = orgY;
1866 lpitem->cxItem = orgX;
1867 lpitem->cyItem = orgY;
1868
1869 if (lpitem->fType & MF_SEPARATOR)
1870 {
1871 lpitem->cyItem += UserGetSystemMetrics( SM_CYMENUSIZE)/2;//SEPARATOR_HEIGHT;
1872 if( !menuBar)
1873 lpitem->cxItem += arrow_bitmap_width + MenuCharSize.cx;
1874 return;
1875 }
1876
1877 lpitem->dxTab = 0;
1878
1879 if (lpitem->hbmp)
1880 {
1881 SIZE size;
1882
1883 if (!menuBar) {
1884 MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
1885 /* Keep the size of the bitmap in callback mode to be able
1886 * to draw it correctly */
1887 lpitem->cxBmp = size.cx;
1888 lpitem->cyBmp = size.cy;
1889 Menu->cxTextAlign = max(Menu->cxTextAlign, size.cx);
1890 lpitem->cxItem += size.cx + 2;
1891 itemheight = size.cy + 2;
1892
1893 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
1894 lpitem->cxItem += 2 * check_bitmap_width;
1895 lpitem->cxItem += 4 + MenuCharSize.cx;
1896 lpitem->dxTab = lpitem->cxItem;
1897 lpitem->cxItem += arrow_bitmap_width;
1898 } else /* hbmpItem & MenuBar */ {
1899 MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
1900 lpitem->cxItem += size.cx;
1901 if( lpitem->Xlpstr) lpitem->cxItem += 2;
1902 itemheight = size.cy;
1903
1904 /* Special case: Minimize button doesn't have a space behind it. */
1905 if (lpitem->hbmp == (HBITMAP)HBMMENU_MBAR_MINIMIZE ||
1906 lpitem->hbmp == (HBITMAP)HBMMENU_MBAR_MINIMIZE_D)
1907 lpitem->cxItem -= 1;
1908 }
1909 }
1910 else if (!menuBar) {
1911 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
1912 lpitem->cxItem += check_bitmap_width;
1913 lpitem->cxItem += 4 + MenuCharSize.cx;
1914 lpitem->dxTab = lpitem->cxItem;
1915 lpitem->cxItem += arrow_bitmap_width;
1916 }
1917
1918 /* it must be a text item - unless it's the system menu */
1919 if (!(lpitem->fType & MF_SYSMENU) && lpitem->Xlpstr) {
1920 HFONT hfontOld = NULL;
1921 RECT rc;// = lpitem->Rect;
1922 LONG txtheight, txtwidth;
1923
1924 rc.left = lpitem->xItem;
1925 rc.top = lpitem->yItem;
1926 rc.right = lpitem->cxItem; // Do this for now......
1927 rc.bottom = lpitem->cyItem;
1928
1929 if ( lpitem->fState & MFS_DEFAULT ) {
1930 hfontOld = NtGdiSelectFont( hdc, ghMenuFontBold );
1931 }
1932 if (menuBar) {
1933 txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc, DT_SINGLELINE|DT_CALCRECT);
1934
1935 lpitem->cxItem += rc.right - rc.left;
1936 itemheight = max( max( itemheight, txtheight), UserGetSystemMetrics( SM_CYMENU) - 1);
1937
1938 lpitem->cxItem += 2 * MenuCharSize.cx;
1939 } else {
1940 if ((p = wcschr( lpitem->Xlpstr, '\t' )) != NULL) {
1941 RECT tmprc = rc;
1942 LONG tmpheight;
1943 int n = (int)( p - lpitem->Xlpstr);
1944 /* Item contains a tab (only meaningful in popup menus) */
1945 /* get text size before the tab */
1946 txtheight = DrawTextW( hdc, lpitem->Xlpstr, n, &rc,
1947 DT_SINGLELINE|DT_CALCRECT);
1948 txtwidth = rc.right - rc.left;
1949 p += 1; /* advance past the Tab */
1950 /* get text size after the tab */
1951 tmpheight = DrawTextW( hdc, p, -1, &tmprc,
1952 DT_SINGLELINE|DT_CALCRECT);
1953 lpitem->dxTab += txtwidth;
1954 txtheight = max( txtheight, tmpheight);
1955 txtwidth += MenuCharSize.cx + /* space for the tab */
1956 tmprc.right - tmprc.left; /* space for the short cut */
1957 } else {
1958 txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc,
1959 DT_SINGLELINE|DT_CALCRECT);
1960 txtwidth = rc.right - rc.left;
1961 lpitem->dxTab += txtwidth;
1962 }
1963 lpitem->cxItem += 2 + txtwidth;
1964 itemheight = max( itemheight,
1965 max( txtheight + 2, MenuCharSize.cy + 4));
1966 }
1967 if (hfontOld)
1968 {
1969 NtGdiSelectFont (hdc, hfontOld);
1970 }
1971 } else if( menuBar) {
1972 itemheight = max( itemheight, UserGetSystemMetrics(SM_CYMENU)-1);
1973 }
1974 lpitem->cyItem += itemheight;
1975 TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem->xItem, lpitem->yItem, lpitem->cxItem, lpitem->cyItem);
1976 }
1977
1978 /***********************************************************************
1979 * MENU_GetMaxPopupHeight
1980 */
1981 static UINT
1982 MENU_GetMaxPopupHeight(PMENU lppop)
1983 {
1984 if (lppop->cyMax)
1985 {
1986 //ERR("MGMaxPH cyMax %d\n",lppop->cyMax);
1987 return lppop->cyMax;
1988 }
1989 //ERR("MGMaxPH SyMax %d\n",UserGetSystemMetrics(SM_CYSCREEN) - UserGetSystemMetrics(SM_CYBORDER));
1990 return UserGetSystemMetrics(SM_CYSCREEN) - UserGetSystemMetrics(SM_CYBORDER);
1991 }
1992
1993 /***********************************************************************
1994 * MenuPopupMenuCalcSize
1995 *
1996 * Calculate the size of a popup menu.
1997 */
1998 static void FASTCALL MENU_PopupMenuCalcSize(PMENU Menu, PWND WndOwner)
1999 {
2000 PITEM lpitem;
2001 HDC hdc;
2002 int start, i;
2003 int orgX, orgY, maxX, maxTab, maxTabWidth, maxHeight;
2004 BOOL textandbmp = FALSE;
2005
2006 Menu->cxMenu = Menu->cyMenu = 0;
2007 if (Menu->cItems == 0) return;
2008
2009 hdc = UserGetDCEx(NULL, NULL, DCX_CACHE);
2010
2011 NtGdiSelectFont( hdc, ghMenuFont );
2012
2013 start = 0;
2014 maxX = 2 + 1;
2015
2016 Menu->cxTextAlign = 0;
2017
2018 while (start < Menu->cItems)
2019 {
2020 lpitem = &Menu->rgItems[start];
2021 orgX = maxX;
2022 if( lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))
2023 orgX += MENU_COL_SPACE;
2024 orgY = MENU_TOP_MARGIN;
2025
2026 maxTab = maxTabWidth = 0;
2027 /* Parse items until column break or end of menu */
2028 for (i = start; i < Menu->cItems; i++, lpitem++)
2029 {
2030 if (i != start &&
2031 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
2032
2033 MENU_CalcItemSize(hdc, lpitem, Menu, WndOwner, orgX, orgY, FALSE, textandbmp);
2034 maxX = max(maxX, lpitem->cxItem);
2035 orgY = lpitem->cyItem;
2036 if (IS_STRING_ITEM(lpitem->fType) && lpitem->dxTab )
2037 {
2038 maxTab = max( maxTab, lpitem->dxTab );
2039 maxTabWidth = max(maxTabWidth, lpitem->cxItem - lpitem->dxTab);
2040 }
2041 if( lpitem->Xlpstr && lpitem->hbmp) textandbmp = TRUE;
2042 }
2043
2044 /* Finish the column (set all items to the largest width found) */
2045 maxX = max( maxX, maxTab + maxTabWidth );
2046 for (lpitem = &Menu->rgItems[start]; start < i; start++, lpitem++)
2047 {
2048 lpitem->cxItem = maxX;
2049 if (IS_STRING_ITEM(lpitem->fType) && lpitem->dxTab)
2050 lpitem->dxTab = maxTab;
2051 }
2052 Menu->cyMenu = max(Menu->cyMenu, orgY);
2053 }
2054
2055 Menu->cxMenu = maxX;
2056 /* if none of the items have both text and bitmap then
2057 * the text and bitmaps are all aligned on the left. If there is at
2058 * least one item with both text and bitmap then bitmaps are
2059 * on the left and texts left aligned with the right hand side
2060 * of the bitmaps */
2061 if( !textandbmp) Menu->cxTextAlign = 0;
2062
2063 /* space for 3d border */
2064 Menu->cyMenu += MENU_BOTTOM_MARGIN;
2065 Menu->cxMenu += 2;
2066
2067 /* Adjust popup height if it exceeds maximum */
2068 maxHeight = MENU_GetMaxPopupHeight(Menu);
2069 Menu->iMaxTop = Menu->cyMenu - MENU_TOP_MARGIN;
2070 if (Menu->cyMenu >= maxHeight)
2071 {
2072 Menu->cyMenu = maxHeight;
2073 Menu->dwArrowsOn = 1;
2074 }
2075 else
2076 {
2077 Menu->dwArrowsOn = 0;
2078 }
2079 UserReleaseDC( 0, hdc, FALSE );
2080 }
2081
2082 /***********************************************************************
2083 * MENU_MenuBarCalcSize
2084 *
2085 * FIXME: Word 6 implements its own MDI and its own 'close window' bitmap
2086 * height is off by 1 pixel which causes lengthy window relocations when
2087 * active document window is maximized/restored.
2088 *
2089 * Calculate the size of the menu bar.
2090 */
2091 static void MENU_MenuBarCalcSize( HDC hdc, LPRECT lprect, PMENU lppop, PWND pwndOwner )
2092 {
2093 ITEM *lpitem;
2094 UINT start, i, helpPos;
2095 int orgX, orgY, maxY;
2096
2097 if ((lprect == NULL) || (lppop == NULL)) return;
2098 if (lppop->cItems == 0) return;
2099 //TRACE("lprect %p %s\n", lprect, wine_dbgstr_rect( lprect));
2100 lppop->cxMenu = lprect->right - lprect->left;
2101 lppop->cyMenu = 0;
2102 maxY = lprect->top+1;
2103 start = 0;
2104 helpPos = ~0U;
2105 lppop->cxTextAlign = 0;
2106 while (start < lppop->cItems)
2107 {
2108 lpitem = &lppop->rgItems[start];
2109 orgX = lprect->left;
2110 orgY = maxY;
2111
2112 /* Parse items until line break or end of menu */
2113 for (i = start; i < lppop->cItems; i++, lpitem++)
2114 {
2115 if ((helpPos == ~0U) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
2116 if ((i != start) &&
2117 (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
2118
2119 TRACE("calling MENU_CalcItemSize org=(%d, %d)\n", orgX, orgY );
2120 //debug_print_menuitem (" item: ", lpitem, "");
2121 //MENU_CalcItemSize( hdc, lpitem, pwndOwner, orgX, orgY, TRUE, lppop );
2122 MENU_CalcItemSize(hdc, lpitem, lppop, pwndOwner, orgX, orgY, TRUE, FALSE);
2123
2124 if (lpitem->cxItem > lprect->right)
2125 {
2126 if (i != start) break;
2127 else lpitem->cxItem = lprect->right;
2128 }
2129 maxY = max( maxY, lpitem->cyItem );
2130 orgX = lpitem->cxItem;
2131 }
2132
2133 /* Finish the line (set all items to the largest height found) */
2134
2135 /* FIXME: Is this really needed? */ /*NO! it is not needed, why make the
2136 HBMMENU_MBAR_CLOSE, MINIMIZE & RESTORE, look the same size as the menu bar! */
2137 #if 0
2138 while (start < i) lppop->rgItems[start++].cyItem = maxY;
2139 #endif
2140 start = i; /* This works! */
2141 }
2142
2143 lprect->bottom = maxY;
2144 lppop->cyMenu = lprect->bottom - lprect->top;
2145
2146 /* Flush right all items between the MF_RIGHTJUSTIFY and */
2147 /* the last item (if several lines, only move the last line) */
2148 if (helpPos == ~0U) return;
2149 lpitem = &lppop->rgItems[lppop->cItems-1];
2150 orgY = lpitem->yItem;
2151 orgX = lprect->right;
2152 for (i = lppop->cItems - 1; i >= helpPos; i--, lpitem--) {
2153 if (lpitem->yItem != orgY) break; /* Other line */
2154 if (lpitem->cxItem >= orgX) break; /* Too far right already */
2155 lpitem->xItem += orgX - lpitem->cxItem;
2156 lpitem->cxItem = orgX;
2157 orgX = lpitem->xItem;
2158 }
2159 }
2160
2161 /***********************************************************************
2162 * MENU_DrawScrollArrows
2163 *
2164 * Draw scroll arrows.
2165 */
2166 static void MENU_DrawScrollArrows(PMENU lppop, HDC hdc)
2167 {
2168 UINT arrow_bitmap_width, arrow_bitmap_height;
2169 RECT rect, dfcrc;
2170 UINT Flags = 0;
2171
2172 arrow_bitmap_width = gpsi->oembmi[OBI_DNARROW].cx;
2173 arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
2174
2175 rect.left = 0;
2176 rect.top = 0;
2177 rect.right = lppop->cxMenu;
2178 rect.bottom = arrow_bitmap_height;
2179 FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENU));
2180 dfcrc.left = (lppop->cxMenu - arrow_bitmap_width) / 2;
2181 dfcrc.top = 0;
2182 dfcrc.right = arrow_bitmap_width;
2183 dfcrc.bottom = arrow_bitmap_height;
2184 DrawFrameControl(hdc, &dfcrc, DFC_MENU, (lppop->iTop ? 0 : DFCS_INACTIVE)|DFCS_MENUARROWUP);
2185
2186 rect.top = lppop->cyMenu - arrow_bitmap_height;
2187 rect.bottom = lppop->cyMenu;
2188 FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENU));
2189 if (!(lppop->iTop < lppop->iMaxTop - (MENU_GetMaxPopupHeight(lppop) - 2 * arrow_bitmap_height)))
2190 Flags = DFCS_INACTIVE;
2191 dfcrc.left = (lppop->cxMenu - arrow_bitmap_width) / 2;
2192 dfcrc.top = lppop->cyMenu - arrow_bitmap_height;
2193 dfcrc.right = arrow_bitmap_width;
2194 dfcrc.bottom = lppop->cyMenu;
2195 DrawFrameControl(hdc, &dfcrc, DFC_MENU, Flags|DFCS_MENUARROWDOWN);
2196 }
2197
2198 /***********************************************************************
2199 * MenuDrawMenuItem
2200 *
2201 * Draw a single menu item.
2202 */
2203 static void FASTCALL MENU_DrawMenuItem(PWND Wnd, PMENU Menu, PWND WndOwner, HDC hdc,
2204 PITEM lpitem, UINT Height, BOOL menuBar, UINT odaction)
2205 {
2206 RECT rect;
2207 PWCHAR Text;
2208 BOOL flat_menu = FALSE;
2209 int bkgnd;
2210 UINT arrow_bitmap_width = 0;
2211 //RECT bmprc;
2212
2213 if (!menuBar) {
2214 arrow_bitmap_width = gpsi->oembmi[OBI_MNARROW].cx;
2215 }
2216
2217 if (lpitem->fType & MF_SYSMENU)
2218 {
2219 if (!(Wnd->style & WS_MINIMIZE))
2220 {
2221 NC_GetInsideRect(Wnd, &rect);
2222 UserDrawSysMenuButton(Wnd, hdc, &rect, lpitem->fState & (MF_HILITE | MF_MOUSESELECT));
2223 }
2224 return;
2225 }
2226
2227 UserSystemParametersInfo (SPI_GETFLATMENU, 0, &flat_menu, 0);
2228 bkgnd = (menuBar && flat_menu) ? COLOR_MENUBAR : COLOR_MENU;
2229
2230 /* Setup colors */
2231
2232 if (lpitem->fState & MF_HILITE)
2233 {
2234 if(menuBar && !flat_menu) {
2235 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_MENUTEXT));
2236 IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_MENU));
2237 } else {
2238 if (lpitem->fState & MF_GRAYED)
2239 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_GRAYTEXT));
2240 else
2241 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_HIGHLIGHTTEXT));
2242 IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_HIGHLIGHT));
2243 }
2244 }
2245 else
2246 {
2247 if (lpitem->fState & MF_GRAYED)
2248 IntGdiSetTextColor( hdc, IntGetSysColor( COLOR_GRAYTEXT ) );
2249 else
2250 IntGdiSetTextColor( hdc, IntGetSysColor( COLOR_MENUTEXT ) );
2251 IntGdiSetBkColor( hdc, IntGetSysColor( bkgnd ) );
2252 }
2253
2254 //TRACE("rect=%s\n", wine_dbgstr_rect( &lpitem->Rect));
2255 //rect = lpitem->Rect;
2256 rect.left = lpitem->xItem;
2257 rect.top = lpitem->yItem;
2258 rect.right = lpitem->cxItem; // Do this for now......
2259 rect.bottom = lpitem->cyItem;
2260
2261 MENU_AdjustMenuItemRect(Menu, &rect);
2262
2263 if (lpitem->fType & MF_OWNERDRAW)
2264 {
2265 /*
2266 ** Experimentation under Windows reveals that an owner-drawn
2267 ** menu is given the rectangle which includes the space it requested
2268 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
2269 ** and a popup-menu arrow. This is the value of lpitem->rect.
2270 ** Windows will leave all drawing to the application except for
2271 ** the popup-menu arrow. Windows always draws that itself, after
2272 ** the menu owner has finished drawing.
2273 */
2274 DRAWITEMSTRUCT dis;
2275 COLORREF old_bk, old_text;
2276
2277 dis.CtlType = ODT_MENU;
2278 dis.CtlID = 0;
2279 dis.itemID = lpitem->wID;
2280 dis.itemData = (DWORD)lpitem->dwItemData;
2281 dis.itemState = 0;
2282 if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
2283 if (lpitem->fState & MF_DEFAULT) dis.itemState |= ODS_DEFAULT;
2284 if (lpitem->fState & MF_DISABLED) dis.itemState |= ODS_DISABLED;
2285 if (lpitem->fState & MF_GRAYED) dis.itemState |= ODS_GRAYED | ODS_DISABLED;
2286 if (lpitem->fState & MF_HILITE) dis.itemState |= ODS_SELECTED;
2287 if (!(Menu->fFlags & MNF_UNDERLINE)) dis.itemState |= ODS_NOACCEL;
2288 if (Menu->fFlags & MNF_INACTIVE) dis.itemState |= ODS_INACTIVE;
2289 dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
2290 dis.hwndItem = (HWND) UserHMGetHandle(Menu);
2291 dis.hDC = hdc;
2292 dis.rcItem = rect;
2293 TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
2294 "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", Wnd,
2295 dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
2296 dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
2297 dis.rcItem.bottom);
2298 TRACE("Ownerdraw: Width %d Height %d\n", dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top);
2299 old_bk = GreGetBkColor(hdc);
2300 old_text = GreGetTextColor(hdc);
2301 co_IntSendMessage(UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM) &dis);
2302 IntGdiSetBkColor(hdc, old_bk);
2303 IntGdiSetTextColor(hdc, old_text);
2304 /* Draw the popup-menu arrow */
2305 if (!menuBar && lpitem->spSubMenu)
2306 {
2307 RECT rectTemp;
2308 RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
2309 rectTemp.left = rectTemp.right - UserGetSystemMetrics(SM_CXMENUCHECK);
2310 DrawFrameControl(hdc, &rectTemp, DFC_MENU, DFCS_MENUARROW);
2311 }
2312 return;
2313 }
2314
2315 if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
2316
2317 if (lpitem->fState & MF_HILITE)
2318 {
2319 if (flat_menu)
2320 {
2321 RECTL_vInflateRect (&rect, -1, -1);
2322 FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENUHILIGHT));
2323 RECTL_vInflateRect (&rect, 1, 1);
2324 FrameRect(hdc, &rect, IntGetSysColorBrush(COLOR_HIGHLIGHT));
2325 }
2326 else
2327 {
2328 if(menuBar)
2329 DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
2330 else
2331 FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_HIGHLIGHT));
2332 }
2333 }
2334 else
2335 FillRect( hdc, &rect, IntGetSysColorBrush(bkgnd) );
2336
2337 IntGdiSetBkMode( hdc, TRANSPARENT );
2338
2339 /* vertical separator */
2340 if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
2341 {
2342 HPEN oldPen;
2343 RECT rc = rect;
2344
2345 rc.left -= 3;//MENU_COL_SPACE / 2 + 1; == 3!!
2346 rc.top = 3;
2347 rc.bottom = Height - 3;
2348 if (flat_menu)
2349 {
2350 oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
2351 IntSetDCPenColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
2352 GreMoveTo( hdc, rc.left, rc.top, NULL );
2353 NtGdiLineTo( hdc, rc.left, rc.bottom );
2354 NtGdiSelectPen( hdc, oldPen );
2355 }
2356 else
2357 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
2358 }
2359
2360 /* horizontal separator */
2361 if (lpitem->fType & MF_SEPARATOR)
2362 {
2363 HPEN oldPen;
2364 RECT rc = rect;
2365
2366 rc.left++;
2367 rc.right--;
2368 rc.top = ( rc.top + rc.bottom) / 2;
2369 if (flat_menu)
2370 {
2371 oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
2372 IntSetDCPenColor( hdc, IntGetSysColor(COLOR_BTNSHADOW));
2373 GreMoveTo( hdc, rc.left, rc.top, NULL );
2374 NtGdiLineTo( hdc, rc.right, rc.top );
2375 NtGdiSelectPen( hdc, oldPen );
2376 }
2377 else
2378 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
2379 return;
2380 }
2381 #if 0
2382 /* helper lines for debugging */
2383 /* This is a very good test tool when hacking menus! (JT) 07/16/2006 */
2384 FrameRect(hdc, &rect, NtGdiGetStockObject(BLACK_BRUSH));
2385 NtGdiSelectPen(hdc, NtGdiGetStockObject(DC_PEN));
2386 IntSetDCPenColor(hdc, IntGetSysColor(COLOR_WINDOWFRAME));
2387 GreMoveTo(hdc, rect.left, (rect.top + rect.bottom) / 2, NULL);
2388 NtGdiLineTo(hdc, rect.right, (rect.top + rect.bottom) / 2);
2389 #endif
2390 #if 0 // breaks mdi menu bar icons.
2391 if (lpitem->hbmp) {
2392 /* calculate the bitmap rectangle in coordinates relative
2393 * to the item rectangle */
2394 if( menuBar) {
2395 if( lpitem->hbmp == HBMMENU_CALLBACK)
2396 bmprc.left = 3;
2397 else
2398 bmprc.left = lpitem->Xlpstr ? MenuCharSize.cx : 0;
2399 }
2400 else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)
2401 bmprc.left = 4;
2402 else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)
2403 bmprc.left = 2;
2404 else
2405 bmprc.left = 4 + UserGetSystemMetrics(SM_CXMENUCHECK);
2406
2407 bmprc.right = bmprc.left + lpitem->cxBmp;
2408
2409 if( menuBar && !(lpitem->hbmp == HBMMENU_CALLBACK))
2410 bmprc.top = 0;
2411 else
2412 bmprc.top = (rect.bottom - rect.top - lpitem->cyBmp) / 2;
2413
2414 bmprc.bottom = bmprc.top + lpitem->cyBmp;
2415 }
2416 #endif
2417 if (!menuBar)
2418 {
2419 HBITMAP bm;
2420 INT y = rect.top + rect.bottom;
2421 RECT rc = rect;
2422 BOOL checked = FALSE;
2423 UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
2424 UINT check_bitmap_height = UserGetSystemMetrics( SM_CYMENUCHECK );
2425 /* Draw the check mark
2426 *
2427 * FIXME:
2428 * Custom checkmark bitmaps are monochrome but not always 1bpp.
2429 */
2430 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)) {
2431 bm = (lpitem->fState & MF_CHECKED) ? lpitem->hbmpChecked :
2432 lpitem->hbmpUnchecked;
2433 if (bm) /* we have a custom bitmap */
2434 {
2435 HDC hdcMem = NtGdiCreateCompatibleDC( hdc );
2436
2437 NtGdiSelectBitmap( hdcMem, bm );
2438 NtGdiBitBlt( hdc, rc.left, (y - check_bitmap_height) / 2,
2439 check_bitmap_width, check_bitmap_height,
2440 hdcMem, 0, 0, SRCCOPY, 0,0);
2441 IntGdiDeleteDC( hdcMem, FALSE );
2442 checked = TRUE;
2443 }
2444 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
2445 {
2446 RECT r;
2447 r = rect;
2448 r.right = r.left + check_bitmap_width;
2449 DrawFrameControl( hdc, &r, DFC_MENU,
2450 (lpitem->fType & MFT_RADIOCHECK) ?
2451 DFCS_MENUBULLET : DFCS_MENUCHECK);
2452 checked = TRUE;
2453 }
2454 }
2455 if ( lpitem->hbmp )//&& !( checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
2456 {
2457 RECT bmpRect = rect;
2458 if (!((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP) && !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
2459 bmpRect.left += check_bitmap_width + 2;
2460 if (!(checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
2461 {
2462 bmpRect.right = bmpRect.left + lpitem->cxBmp;
2463 MENU_DrawBitmapItem(hdc, lpitem, &bmpRect, Menu, WndOwner, odaction, menuBar);
2464 }
2465 }
2466 /* Draw the popup-menu arrow */
2467 if (lpitem->spSubMenu)
2468 {
2469 RECT rectTemp;
2470 RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
2471 rectTemp.left = rectTemp.right - check_bitmap_width;
2472 DrawFrameControl(hdc, &rectTemp, DFC_MENU, DFCS_MENUARROW);
2473 }
2474 rect.left += 4;
2475 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
2476 rect.left += check_bitmap_width;
2477 rect.right -= arrow_bitmap_width;
2478 }
2479 else if( lpitem->hbmp)
2480 { /* Draw the bitmap */
2481 MENU_DrawBitmapItem(hdc, lpitem, &rect/*bmprc*/, Menu, WndOwner, odaction, menuBar);
2482 }
2483
2484 /* process text if present */
2485 if (lpitem->Xlpstr)
2486 {
2487 int i = 0;
2488 HFONT hfontOld = 0;
2489
2490 UINT uFormat = menuBar ?
2491 DT_CENTER | DT_VCENTER | DT_SINGLELINE :
2492 DT_LEFT | DT_VCENTER | DT_SINGLELINE;
2493
2494 if (((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP))
2495 rect.left += max(0, (int)(Menu->cxTextAlign - UserGetSystemMetrics(SM_CXMENUCHECK)));
2496 else
2497 rect.left += Menu->cxTextAlign;
2498
2499 if ( lpitem->fState & MFS_DEFAULT )
2500 {
2501 hfontOld = NtGdiSelectFont(hdc, ghMenuFontBold);
2502 }
2503
2504 if (menuBar) {
2505 if( lpitem->hbmp)
2506 rect.left += lpitem->cxBmp;
2507 if( !(lpitem->hbmp == HBMMENU_CALLBACK))
2508 rect.left += MenuCharSize.cx;
2509 rect.right -= MenuCharSize.cx;
2510 }
2511
2512 Text = lpitem->Xlpstr;
2513 if(Text)
2514 {
2515 for (i = 0; Text[i]; i++)
2516 if (Text[i] == L'\t' || Text[i] == L'\b')
2517 break;
2518 }
2519
2520 if(lpitem->fState & MF_GRAYED)
2521 {
2522 if (!(lpitem->fState & MF_HILITE) )
2523 {
2524 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
2525 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNHIGHLIGHT));
2526 DrawTextW( hdc, Text, i, &rect, uFormat );
2527 --rect.left; --rect.top; --rect.right; --rect.bottom;
2528 }
2529 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
2530 }
2531 DrawTextW( hdc, Text, i, &rect, uFormat);
2532
2533 /* paint the shortcut text */
2534 if (!menuBar && L'\0' != Text[i]) /* There's a tab or flush-right char */
2535 {
2536 if (L'\t' == Text[i])
2537 {
2538 rect.left = lpitem->dxTab;
2539 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
2540 }
2541 else
2542 {
2543 rect.right = lpitem->dxTab;
2544 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
2545 }
2546
2547 if (lpitem->fState & MF_GRAYED)
2548 {
2549 if (!(lpitem->fState & MF_HILITE) )
2550 {
2551 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
2552 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNHIGHLIGHT));
2553 DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat);
2554 --rect.left; --rect.top; --rect.right; --rect.bottom;
2555 }
2556 IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
2557 }
2558 DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat );
2559 }
2560
2561 if (hfontOld)
2562 {
2563 NtGdiSelectFont (hdc, hfontOld);
2564 }
2565 }
2566 }
2567
2568 /***********************************************************************
2569 * MenuDrawPopupMenu
2570 *
2571 * Paint a popup menu.
2572 */
2573 static void FASTCALL MENU_DrawPopupMenu(PWND wnd, HDC hdc, PMENU menu )
2574 {
2575 HBRUSH hPrevBrush = 0, brush = IntGetSysColorBrush(COLOR_MENU);
2576 RECT rect;
2577
2578 TRACE("DPM wnd=%p dc=%p menu=%p\n", wnd, hdc, menu);
2579
2580 IntGetClientRect( wnd, &rect );
2581
2582 if (menu && menu->hbrBack) brush = menu->hbrBack;
2583 if((hPrevBrush = NtGdiSelectBrush( hdc, brush ))
2584 && (NtGdiSelectFont( hdc, ghMenuFont)))
2585 {
2586 HPEN hPrevPen;
2587
2588 NtGdiRectangle( hdc, rect.left, rect.top, rect.right, rect.bottom );
2589
2590 hPrevPen = NtGdiSelectPen( hdc, NtGdiGetStockObject( NULL_PEN ) );
2591 if ( hPrevPen )
2592 {
2593 BOOL flat_menu = FALSE;
2594
2595 UserSystemParametersInfo (SPI_GETFLATMENU, 0, &flat_menu, 0);
2596 if (flat_menu)
2597 FrameRect(hdc, &rect, IntGetSysColorBrush(COLOR_BTNSHADOW));
2598 else
2599 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT);
2600
2601 TRACE("hmenu %p Style %08x\n", UserHMGetHandle(menu), (menu->fFlags & MNS_STYLE_MASK));
2602 /* draw menu items */
2603 if (menu && menu->cItems)
2604 {
2605 ITEM *item;
2606 UINT u;
2607
2608 item = menu->rgItems;
2609 for( u = menu->cItems; u > 0; u--, item++)
2610 {
2611 MENU_DrawMenuItem(wnd, menu, menu->spwndNotify, hdc, item,
2612 menu->cyMenu, FALSE, ODA_DRAWENTIRE);
2613 }
2614 /* draw scroll arrows */
2615 if (menu->dwArrowsOn)
2616 {
2617 MENU_DrawScrollArrows(menu, hdc);
2618 }
2619 }
2620 }
2621 else
2622 {
2623 NtGdiSelectBrush( hdc, hPrevBrush );
2624 }
2625 }
2626 }
2627
2628 /**********************************************************************
2629 * MENU_IsMenuActive
2630 */
2631 PWND MENU_IsMenuActive(VOID)
2632 {
2633 return ValidateHwndNoErr(top_popup);
2634 }
2635
2636 /**********************************************************************
2637 * MENU_EndMenu
2638 *
2639 * Calls EndMenu() if the hwnd parameter belongs to the menu owner
2640 *
2641 * Does the (menu stuff) of the default window handling of WM_CANCELMODE
2642 */
2643 void MENU_EndMenu( PWND pwnd )
2644 {
2645 PMENU menu = NULL;
2646 menu = UserGetMenuObject(top_popup_hmenu);
2647 if ( menu && ( UserHMGetHandle(pwnd) == menu->hWnd || pwnd == menu->spwndNotify ) )
2648 {
2649 if (fInsideMenuLoop && top_popup)
2650 {
2651 fInsideMenuLoop = FALSE;
2652
2653 if (fInEndMenu)
2654 {
2655 ERR("Already in End loop\n");
2656 return;
2657 }
2658
2659 fInEndMenu = TRUE;
2660 UserPostMessage( top_popup, WM_CANCELMODE, 0, 0);
2661 }
2662 }
2663 }
2664
2665 DWORD WINAPI
2666 IntDrawMenuBarTemp(PWND pWnd, HDC hDC, LPRECT Rect, PMENU pMenu, HFONT Font)
2667 {
2668 UINT i;
2669 HFONT FontOld = NULL;
2670 BOOL flat_menu = FALSE;
2671
2672 UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
2673
2674 if (!pMenu)
2675 {
2676 pMenu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu));
2677 }
2678
2679 if (!Font)
2680 {
2681 Font = ghMenuFont;
2682 }
2683
2684 if (Rect == NULL || !pMenu)
2685 {
2686 return UserGetSystemMetrics(SM_CYMENU);
2687 }
2688
2689 TRACE("(%x, %x, %p, %x, %x)\n", pWnd, hDC, Rect, pMenu, Font);
2690
2691 FontOld = NtGdiSelectFont(hDC, Font);
2692
2693 if (pMenu->cyMenu == 0)
2694 {
2695 MENU_MenuBarCalcSize(hDC, Rect, pMenu, pWnd);
2696 }
2697
2698 Rect->bottom = Rect->top + pMenu->cyMenu;
2699
2700 FillRect(hDC, Rect, IntGetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU));
2701
2702 NtGdiSelectPen(hDC, NtGdiGetStockObject(DC_PEN));
2703 IntSetDCPenColor(hDC, IntGetSysColor(COLOR_3DFACE));
2704 GreMoveTo(hDC, Rect->left, Rect->bottom - 1, NULL);
2705 NtGdiLineTo(hDC, Rect->right, Rect->bottom - 1);
2706
2707 if (pMenu->cItems == 0)
2708 {
2709 NtGdiSelectFont(hDC, FontOld);
2710 return UserGetSystemMetrics(SM_CYMENU);
2711 }
2712
2713 for (i = 0; i < pMenu->cItems; i++)
2714 {
2715 MENU_DrawMenuItem(pWnd, pMenu, pWnd, hDC, &pMenu->rgItems[i], pMenu->cyMenu, TRUE, ODA_DRAWENTIRE);
2716 }
2717
2718 NtGdiSelectFont(hDC, FontOld);
2719
2720 return pMenu->cyMenu;
2721 }
2722
2723 UINT MENU_DrawMenuBar( HDC hDC, LPRECT lprect, PWND pWnd, BOOL suppress_draw )
2724 {
2725 HFONT hfontOld = 0;
2726 PMENU lppop = UserGetMenuObject(UlongToHandle(pWnd->IDMenu));
2727
2728 if (lppop == NULL)
2729 {
2730 // No menu. Do not reserve any space
2731 return 0;
2732 }
2733
2734 if (lprect == NULL)
2735 {
2736 return UserGetSystemMetrics(SM_CYMENU);
2737 }
2738
2739 if (suppress_draw)
2740 {
2741 hfontOld = NtGdiSelectFont(hDC, ghMenuFont);
2742
2743 MENU_MenuBarCalcSize(hDC, lprect, lppop, pWnd);
2744
2745 lprect->bottom = lprect->top + lppop->cyMenu;
2746
2747 if (hfontOld) NtGdiSelectFont( hDC, hfontOld);
2748
2749 return lppop->cyMenu;
2750 }
2751 else
2752 {
2753 return IntDrawMenuBarTemp(pWnd, hDC, lprect, lppop, NULL);
2754 }
2755 }
2756
2757 /***********************************************************************
2758 * MENU_InitPopup
2759 *
2760 * Popup menu initialization before WM_ENTERMENULOOP.
2761 */
2762 static BOOL MENU_InitPopup( PWND pWndOwner, PMENU menu, UINT flags )
2763 {
2764 PWND pWndCreated;
2765 PPOPUPMENU pPopupMenu;
2766 CREATESTRUCTW Cs;
2767 LARGE_STRING WindowName;
2768 UNICODE_STRING ClassName;
2769 DWORD ex_style = WS_EX_TOOLWINDOW;
2770
2771 TRACE("owner=%p hmenu=%p\n", pWndOwner, menu);
2772
2773 menu->spwndNotify = pWndOwner;
2774
2775 if (flags & TPM_LAYOUTRTL || pWndOwner->ExStyle & WS_EX_LAYOUTRTL)
2776 ex_style = WS_EX_LAYOUTRTL;
2777
2778 ClassName.Buffer = WC_MENU;
2779 ClassName.Length = 0;
2780
2781 RtlZeroMemory(&WindowName, sizeof(WindowName));
2782 RtlZeroMemory(&Cs, sizeof(Cs));
2783 Cs.style = WS_POPUP;
2784 Cs.dwExStyle = ex_style;
2785 Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
2786 Cs.lpszName = (LPCWSTR) &WindowName;
2787 Cs.lpszClass = (LPCWSTR) &ClassName;
2788 Cs.lpCreateParams = UserHMGetHandle(menu);
2789 Cs.hwndParent = UserHMGetHandle(pWndOwner);
2790
2791 /* NOTE: In Windows, top menu popup is not owned. */
2792 pWndCreated = co_UserCreateWindowEx( &Cs, &ClassName, &WindowName, NULL);
2793
2794 if( !pWndCreated ) return FALSE;
2795
2796 //
2797 // Setup pop up menu structure.
2798 //
2799 menu->hWnd = UserHMGetHandle(pWndCreated);
2800
2801 pPopupMenu = ((PMENUWND)pWndCreated)->ppopupmenu;
2802
2803 pPopupMenu->spwndActivePopup = pWndCreated; // top_popup = MenuInfo.Wnd or menu->hWnd
2804 pPopupMenu->spwndNotify = pWndOwner; // Same as MenuInfo.spwndNotify(which could be wrong) or menu->hwndOwner
2805 //pPopupMenu->spmenu = menu; Should be set up already from WM_CREATE!
2806
2807 pPopupMenu->fIsTrackPopup = !!(flags & TPM_POPUPMENU);
2808 pPopupMenu->fIsSysMenu = !!(flags & TPM_SYSTEM_MENU);
2809 pPopupMenu->fNoNotify = !!(flags & TPM_NONOTIFY);
2810 pPopupMenu->fRightButton = !!(flags & TPM_RIGHTBUTTON);
2811 pPopupMenu->fSynchronous = !!(flags & TPM_RETURNCMD);
2812
2813 if (pPopupMenu->fRightButton)
2814 pPopupMenu->fFirstClick = !!(UserGetKeyState(VK_RBUTTON) & 0x8000);
2815 else
2816 pPopupMenu->fFirstClick = !!(UserGetKeyState(VK_LBUTTON) & 0x8000);
2817
2818 if (gpsi->aiSysMet[SM_MENUDROPALIGNMENT] ||
2819 menu->fFlags & MNF_RTOL)
2820 {
2821 pPopupMenu->fDroppedLeft = TRUE;
2822 }
2823 return TRUE;
2824 }
2825
2826 /***********************************************************************
2827 * MenuShowPopup
2828 *
2829 * Display a popup menu.
2830 */
2831 static BOOL FASTCALL MENU_ShowPopup(PWND pwndOwner, PMENU menu, UINT id, UINT flags,
2832 INT x, INT y, INT xanchor, INT yanchor )
2833 {
2834 UINT width, height;
2835 POINT pt;
2836 PMONITOR monitor;
2837 PWND pWnd;
2838 USER_REFERENCE_ENTRY Ref;
2839
2840 TRACE("owner=%p menu=%p id=0x%04x x=0x%04x y=0x%04x xa=0x%04x ya=0x%04x\n",
2841 pwndOwner, menu, id, x, y, xanchor, yanchor);
2842
2843 if (menu->iItem != NO_SELECTED_ITEM)
2844 {
2845 menu->rgItems[menu->iItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
2846 menu->iItem = NO_SELECTED_ITEM;
2847 }
2848
2849 menu->dwArrowsOn = 0;
2850 MENU_PopupMenuCalcSize(menu, pwndOwner);
2851
2852 /* adjust popup menu pos so that it fits within the desktop */
2853
2854 width = menu->cxMenu + UserGetSystemMetrics(SM_CXBORDER);
2855 height = menu->cyMenu + UserGetSystemMetrics(SM_CYBORDER);
2856
2857 /* FIXME: should use item rect */
2858 pt.x = x;
2859 pt.y = y;
2860 monitor = UserMonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
2861
2862 if (flags & TPM_LAYOUTRTL)
2863 flags ^= TPM_RIGHTALIGN;
2864
2865 if( flags & TPM_RIGHTALIGN ) x -= width;
2866 if( flags & TPM_CENTERALIGN ) x -= width / 2;
2867
2868 if( flags & TPM_BOTTOMALIGN ) y -= height;
2869 if( flags & TPM_VCENTERALIGN ) y -= height / 2;
2870
2871 if( x + width > monitor->rcMonitor.right)
2872 {
2873 if( xanchor && x >= width - xanchor )
2874 x -= width - xanchor;
2875
2876 if( x + width > monitor->rcMonitor.right)
2877 x = monitor->rcMonitor.right - width;
2878 }
2879 if( x < monitor->rcMonitor.left ) x = monitor->rcMonitor.left;
2880
2881 if( y + height > monitor->rcMonitor.bottom)
2882 {
2883 if( yanchor && y >= height + yanchor )
2884 y -= height + yanchor;
2885
2886 if( y + height > monitor->rcMonitor.bottom)
2887 y = monitor->rcMonitor.bottom - height;
2888 }
2889 if( y < monitor->rcMonitor.top ) y = monitor->rcMonitor.top;
2890
2891 pWnd = ValidateHwndNoErr( menu->hWnd );
2892
2893 if (!pWnd)
2894 {
2895 ERR("menu->hWnd bad hwnd %p\n",menu->hWnd);
2896 return FALSE;
2897 }
2898
2899 if (!top_popup) {
2900 top_popup = menu->hWnd;
2901 top_popup_hmenu = UserHMGetHandle(menu);
2902 }
2903
2904 /* Display the window */
2905 UserRefObjectCo(pWnd, &Ref);
2906 co_WinPosSetWindowPos( pWnd, HWND_TOPMOST, x, y, width, height, SWP_SHOWWINDOW | SWP_NOACTIVATE);
2907
2908 co_IntUpdateWindows(pWnd, RDW_ALLCHILDREN, FALSE);
2909
2910 IntNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPSTART, pWnd, OBJID_CLIENT, CHILDID_SELF, 0);
2911 UserDerefObjectCo(pWnd);
2912
2913 return TRUE;
2914 }
2915
2916 /***********************************************************************
2917 * MENU_EnsureMenuItemVisible
2918 */
2919 void MENU_EnsureMenuItemVisible(PMENU lppop, UINT wIndex, HDC hdc)
2920 {
2921 USER_REFERENCE_ENTRY Ref;
2922 if (lppop->dwArrowsOn)
2923 {
2924 ITEM *item = &lppop->rgItems[wIndex];
2925 UINT nMaxHeight = MENU_GetMaxPopupHeight(lppop);
2926 UINT nOldPos = lppop->iTop;
2927 RECT rc;
2928 UINT arrow_bitmap_height;
2929 PWND pWnd = ValidateHwndNoErr(lppop->hWnd);
2930
2931 IntGetClientRect(pWnd, &rc);
2932
2933 arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
2934
2935 rc.top += arrow_bitmap_height;
2936 rc.bottom -= arrow_bitmap_height + MENU_BOTTOM_MARGIN;
2937
2938 nMaxHeight -= UserGetSystemMetrics(SM_CYBORDER) + 2 * arrow_bitmap_height;
2939 UserRefObjectCo(pWnd, &Ref);
2940 if (item->cyItem > lppop->iTop + nMaxHeight)
2941 {
2942 lppop->iTop = item->cyItem - nMaxHeight;
2943 IntScrollWindow(pWnd, 0, nOldPos - lppop->iTop, &rc, &rc);
2944 MENU_DrawScrollArrows(lppop, hdc);
2945 //ERR("Scroll Down iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
2946 }
2947 else if (item->yItem - MENU_TOP_MARGIN < lppop->iTop)
2948 {
2949 lppop->iTop = item->yItem - MENU_TOP_MARGIN;
2950 IntScrollWindow(pWnd, 0, nOldPos - lppop->iTop, &rc, &rc);
2951 MENU_DrawScrollArrows(lppop, hdc);
2952 //ERR("Scroll Up iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
2953 }
2954 UserDerefObjectCo(pWnd);
2955 }
2956 }
2957
2958 /***********************************************************************
2959 * MenuSelectItem
2960 */
2961 static void FASTCALL MENU_SelectItem(PWND pwndOwner, PMENU menu, UINT wIndex,
2962 BOOL sendMenuSelect, PMENU topmenu)
2963 {
2964 HDC hdc;
2965 PWND pWnd;
2966
2967 TRACE("M_SI: owner=%p menu=%p index=0x%04x select=0x%04x\n", pwndOwner, menu, wIndex, sendMenuSelect);
2968
2969 if (!menu || !menu->cItems) return;
2970
2971 pWnd = ValidateHwndNoErr(menu->hWnd);
2972
2973 if (!pWnd) return;
2974
2975 if (menu->iItem == wIndex) return;
2976
2977 if (menu->fFlags & MNF_POPUP)
2978 hdc = UserGetDCEx(pWnd, 0, DCX_USESTYLE);
2979 else
2980 hdc = UserGetDCEx(pWnd, 0, DCX_CACHE | DCX_WINDOW);
2981
2982 if (!top_popup) {
2983 top_popup = menu->hWnd; //pPopupMenu->spwndActivePopup or
2984 //pPopupMenu->fIsTrackPopup set pPopupMenu->spwndPopupMenu;
2985 top_popup_hmenu = UserHMGetHandle(menu); //pPopupMenu->spmenu
2986 }
2987
2988 NtGdiSelectFont( hdc, ghMenuFont );
2989
2990 /* Clear previous highlighted item */
2991 if (menu->iItem != NO_SELECTED_ITEM)
2992 {
2993 menu->rgItems[menu->iItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
2994 MENU_DrawMenuItem(pWnd, menu, pwndOwner, hdc, &menu->rgItems[menu->iItem],
2995 menu->cyMenu, !(menu->fFlags & MNF_POPUP),
2996 ODA_SELECT);
2997 }
2998
2999 /* Highlight new item (if any) */
3000 menu->iItem = wIndex;
3001 if (menu->iItem != NO_SELECTED_ITEM)
3002 {
3003 if (!(menu->rgItems[wIndex].fType & MF_SEPARATOR))
3004 {
3005 menu->rgItems[wIndex].fState |= MF_HILITE;
3006 MENU_EnsureMenuItemVisible(menu, wIndex, hdc);
3007 MENU_DrawMenuItem(pWnd, menu, pwndOwner, hdc,
3008 &menu->rgItems[wIndex], menu->cyMenu, !(menu->fFlags & MNF_POPUP), ODA_SELECT);
3009 }
3010 if (sendMenuSelect)
3011 {
3012 ITEM *ip = &menu->rgItems[menu->iItem];
3013 WPARAM wParam = MAKEWPARAM( ip->spSubMenu ? wIndex : ip->wID,
3014 ip->fType | ip->fState |
3015 (ip->spSubMenu ? MF_POPUP : 0) |
3016 (menu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0 ) );
3017
3018 co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(menu));
3019 }
3020 }
3021 else if (sendMenuSelect)
3022 {
3023 if (topmenu)
3024 {
3025 int pos;
3026 pos = MENU_FindSubMenu(&topmenu, menu);
3027 if (pos != NO_SELECTED_ITEM)
3028 {
3029 ITEM *ip = &topmenu->rgItems[pos];
3030 WPARAM wParam = MAKEWPARAM( Pos, ip->fType | ip->fState |
3031 (ip->spSubMenu ? MF_POPUP : 0) |
3032 (topmenu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0 ) );
3033
3034 co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(topmenu));
3035 }
3036 }
3037 }
3038 UserReleaseDC(pWnd, hdc, FALSE);
3039 }
3040
3041 /***********************************************************************
3042 * MenuMoveSelection
3043 *
3044 * Moves currently selected item according to the Offset parameter.
3045 * If there is no selection then it should select the last item if
3046 * Offset is ITEM_PREV or the first item if Offset is ITEM_NEXT.
3047 */
3048 static void FASTCALL MENU_MoveSelection(PWND pwndOwner, PMENU menu, INT offset)
3049 {
3050 INT i;
3051
3052 TRACE("pwnd=%x menu=%x off=0x%04x\n", pwndOwner, menu, offset);
3053
3054 if ((!menu) || (!menu->rgItems)) return;
3055
3056 if ( menu->iItem != NO_SELECTED_ITEM )
3057 {
3058 if ( menu->cItems == 1 )
3059 return;
3060 else
3061 for (i = menu->iItem + offset ; i >= 0 && i < menu->cItems
3062 ; i += offset)
3063 if (!(menu->rgItems[i].fType & MF_SEPARATOR))
3064 {
3065 MENU_SelectItem( pwndOwner, menu, i, TRUE, 0 );
3066 return;
3067 }
3068 }
3069
3070 for ( i = (offset > 0) ? 0 : menu->cItems - 1;
3071 i >= 0 && i < menu->cItems ; i += offset)
3072 if (!(menu->rgItems[i].fType & MF_SEPARATOR))
3073 {
3074 MENU_SelectItem( pwndOwner, menu, i, TRUE, 0 );
3075 return;
3076 }
3077 }
3078
3079 /***********************************************************************
3080 * MenuHideSubPopups
3081 *
3082 * Hide the sub-popup menus of this menu.
3083 */
3084 static void FASTCALL MENU_HideSubPopups(PWND pWndOwner, PMENU Menu,
3085 BOOL SendMenuSelect, UINT wFlags)
3086 {
3087 TRACE("owner=%x menu=%x 0x%04x\n", pWndOwner, Menu, SendMenuSelect);
3088
3089 if ( Menu && top_popup )
3090 {
3091 PITEM Item;
3092
3093 if (Menu->iItem != NO_SELECTED_ITEM)
3094 {
3095 Item = &Menu->rgItems[Menu->iItem];
3096 if (!(Item->spSubMenu) ||
3097 !(Item->fState & MF_MOUSESELECT)) return;
3098 Item->fState &= ~MF_MOUSESELECT;
3099 }
3100 else
3101 return;
3102
3103 if (Item->spSubMenu)
3104 {
3105 PWND pWnd;
3106 if (!VerifyMenu(Item->spSubMenu)) return;
3107 pWnd = ValidateHwndNoErr(Item->spSubMenu->hWnd);
3108 MENU_HideSubPopups(pWndOwner, Item->spSubMenu, FALSE, wFlags);
3109 MENU_SelectItem(pWndOwner, Item->spSubMenu, NO_SELECTED_ITEM, SendMenuSelect, NULL);
3110 TRACE("M_HSP top p hm %p pWndOwner IDMenu %p\n",top_popup_hmenu,pWndOwner->IDMenu);
3111 co_UserDestroyWindow(pWnd);
3112
3113 /* Native returns handle to destroyed window */
3114 if (!(wFlags & TPM_NONOTIFY))
3115 {
3116 co_IntSendMessage( UserHMGetHandle(pWndOwner), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(Item->spSubMenu),
3117 MAKELPARAM(0, IS_SYSTEM_MENU(Item->spSubMenu)) );
3118 }
3119 ////
3120 // Call WM_UNINITMENUPOPUP FIRST before destroy!!
3121 // Fixes todo_wine User32 test menu.c line 2239 GetMenuBarInfo callback....
3122 //
3123 Item->spSubMenu->hWnd = NULL;
3124 ////
3125 }
3126 }
3127 }
3128
3129 /***********************************************************************
3130 * MenuShowSubPopup
3131 *
3132 * Display the sub-menu of the selected item of this menu.
3133 * Return the handle of the submenu, or menu if no submenu to display.
3134 */
3135 static PMENU FASTCALL MENU_ShowSubPopup(PWND WndOwner, PMENU Menu, BOOL SelectFirst, UINT Flags)
3136 {
3137 RECT Rect;
3138 ITEM *Item;
3139 HDC Dc;
3140 PWND pWnd;
3141
3142 TRACE("owner=%x menu=%p 0x%04x\n", WndOwner, Menu, SelectFirst);
3143
3144 if (!Menu) return Menu;
3145
3146 if (Menu->iItem == NO_SELECTED_ITEM) return Menu;
3147
3148 Item = &Menu->rgItems[Menu->iItem];
3149 if (!(Item->spSubMenu) || (Item->fState & (MF_GRAYED | MF_DISABLED)))
3150 return Menu;
3151
3152 /* message must be sent before using item,
3153 because nearly everything may be changed by the application ! */
3154
3155 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3156 if (!(Flags & TPM_NONOTIFY))
3157 {
3158 co_IntSendMessage(UserHMGetHandle(WndOwner), WM_INITMENUPOPUP,
3159 (WPARAM) UserHMGetHandle(Item->spSubMenu),
3160 MAKELPARAM(Menu->iItem, IS_SYSTEM_MENU(Menu)));
3161 }
3162
3163 Item = &Menu->rgItems[Menu->iItem];
3164 //Rect = ItemInfo.Rect;
3165 Rect.left = Item->xItem;
3166 Rect.top = Item->yItem;
3167 Rect.right = Item->cxItem; // Do this for now......
3168 Rect.bottom = Item->cyItem;
3169
3170 pWnd = ValidateHwndNoErr(Menu->hWnd);
3171
3172 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
3173 if (!(Item->fState & MF_HILITE))
3174 {
3175 if (Menu->fFlags & MNF_POPUP) Dc = UserGetDCEx(pWnd, NULL, DCX_USESTYLE);
3176 else Dc = UserGetDCEx(pWnd, 0, DCX_CACHE | DCX_WINDOW);
3177
3178 NtGdiSelectFont(Dc, ghMenuFont);
3179
3180 Item->fState |= MF_HILITE;
3181 MENU_DrawMenuItem(pWnd, Menu, WndOwner, Dc, Item, Menu->cyMenu,
3182 !(Menu->fFlags & MNF_POPUP), ODA_DRAWENTIRE);
3183
3184 UserReleaseDC(pWnd, Dc, FALSE);
3185 }
3186
3187 if (!Item->yItem && !Item->xItem && !Item->cyItem && !Item->cxItem)
3188 {
3189 Item->xItem = Rect.left;
3190 Item->yItem = Rect.top;
3191 Item->cxItem = Rect.right; // Do this for now......
3192 Item->cyItem = Rect.bottom;
3193 }
3194 Item->fState |= MF_MOUSESELECT;
3195
3196 if (IS_SYSTEM_MENU(Menu))
3197 {
3198 MENU_InitSysMenuPopup(Item->spSubMenu, pWnd->style, pWnd->pcls->style, HTSYSMENU);
3199
3200 NC_GetSysPopupPos(pWnd, &Rect);
3201 if (Flags & TPM_LAYOUTRTL) Rect.left = Rect.right;
3202 Rect.top = Rect.bottom;
3203 Rect.right = UserGetSystemMetrics(SM_CXSIZE);
3204 Rect.bottom = UserGetSystemMetrics(SM_CYSIZE);
3205 }
3206 else
3207 {
3208 IntGetWindowRect(pWnd, &Rect);
3209 if (Menu->fFlags & MNF_POPUP)
3210 {
3211 RECT rc;
3212 rc.left = Item->xItem;
3213 rc.top = Item->yItem;
3214 rc.right = Item->cxItem; // Do this for now......
3215 rc.bottom = Item->cyItem;
3216
3217 MENU_AdjustMenuItemRect(Menu, &rc);
3218
3219 /* The first item in the popup menu has to be at the
3220 same y position as the focused menu item */
3221 if(Flags & TPM_LAYOUTRTL)
3222 Rect.left += UserGetSystemMetrics(SM_CXBORDER);
3223 else
3224 Rect.left += rc.right /*ItemInfo.Rect.right*/ - UserGetSystemMetrics(SM_CXBORDER);
3225 Rect.top += rc.top - MENU_TOP_MARGIN;//3;
3226 Rect.right = rc.left - rc.right + UserGetSystemMetrics(SM_CXBORDER);
3227 Rect.bottom = rc.top - rc.bottom - MENU_TOP_MARGIN - MENU_BOTTOM_MARGIN/*2*/
3228 - UserGetSystemMetrics(SM_CYBORDER);
3229 }
3230 else
3231 {
3232 if(Flags & TPM_LAYOUTRTL)
3233 Rect.left += Rect.right - Item->xItem; //ItemInfo.Rect.left;
3234 else
3235 Rect.left += Item->xItem; //ItemInfo.Rect.left;
3236 Rect.top += Item->cyItem; //ItemInfo.Rect.bottom;
3237 Rect.right = Item->cxItem - Item->xItem; //ItemInfo.Rect.right - ItemInfo.Rect.left;
3238 Rect.bottom = Item->cyItem - Item->yItem; //ItemInfo.Rect.bottom - ItemInfo.Rect.top;
3239 }
3240 }
3241
3242 /* use default alignment for submenus */
3243 Flags &= ~(TPM_CENTERALIGN | TPM_RIGHTALIGN | TPM_VCENTERALIGN | TPM_BOTTOMALIGN);
3244
3245 MENU_InitPopup( WndOwner, Item->spSubMenu, Flags );
3246
3247 MENU_ShowPopup( WndOwner, Item->spSubMenu, Menu->iItem, Flags,
3248 Rect.left, Rect.top, Rect.right, Rect.bottom );
3249 if (SelectFirst)
3250 {
3251 MENU_MoveSelection(WndOwner, Item->spSubMenu, ITEM_NEXT);
3252 }
3253 return Item->spSubMenu;
3254 }
3255
3256 /***********************************************************************
3257 * MenuExecFocusedItem
3258 *
3259 * Execute a menu item (for instance when user pressed Enter).
3260 * Return the wID of the executed item. Otherwise, -1 indicating
3261 * that no menu item was executed, -2 if a popup is shown;
3262 * Have to receive the flags for the TrackPopupMenu options to avoid
3263 * sending unwanted message.
3264 *
3265 */
3266 static INT FASTCALL MENU_ExecFocusedItem(MTRACKER *pmt, PMENU Menu, UINT Flags)
3267 {
3268 PITEM Item;
3269
3270 TRACE("%p menu=%p\n", pmt, Menu);
3271
3272 if (!Menu || !Menu->cItems || Menu->iItem == NO_SELECTED_ITEM)
3273 {
3274 return -1;
3275 }
3276
3277 Item = &Menu->rgItems[Menu->iItem];
3278
3279 TRACE("%p %08x %p\n", Menu, Item->wID, Item->spSubMenu);
3280
3281 if (!(Item->spSubMenu))
3282 {
3283 if (!(Item->fState & (MF_GRAYED | MF_DISABLED)) && !(Item->fType & MF_SEPARATOR))
3284 {
3285 /* If TPM_RETURNCMD is set you return the id, but
3286 do not send a message to the owner */
3287 if (!(Flags & TPM_RETURNCMD))
3288 {
3289 if (Menu->fFlags & MNF_SYSMENU)
3290 {
3291 UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_SYSCOMMAND, Item->wID,
3292 MAKELPARAM((SHORT) pmt->Pt.x, (SHORT) pmt->Pt.y));
3293 }
3294 else
3295 {
3296 DWORD dwStyle = ((Menu->fFlags & MNS_STYLE_MASK) | ( pmt->TopMenu ? (pmt->TopMenu->fFlags & MNS_STYLE_MASK) : 0) );
3297
3298 if (dwStyle & MNS_NOTIFYBYPOS)
3299 UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_MENUCOMMAND, Menu->iItem, (LPARAM)UserHMGetHandle(Menu));
3300 else
3301 UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_COMMAND, Item->wID, 0);
3302 }
3303 }
3304 return Item->wID;
3305 }
3306 }
3307 else
3308 {
3309 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, Menu, TRUE, Flags);
3310 return -2;
3311 }
3312
3313 return -1;
3314 }
3315
3316 /***********************************************************************
3317 * MenuSwitchTracking
3318 *
3319 * Helper function for menu navigation routines.
3320 */
3321 static void FASTCALL MENU_SwitchTracking(MTRACKER* pmt, PMENU PtMenu, UINT Index, UINT wFlags)
3322 {
3323 TRACE("%x menu=%x 0x%04x\n", pmt, PtMenu, Index);
3324
3325 if ( pmt->TopMenu != PtMenu &&
3326 !((PtMenu->fFlags | pmt->TopMenu->fFlags) & MNF_POPUP) )
3327 {
3328 /* both are top level menus (system and menu-bar) */
3329 MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, wFlags);
3330 MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, NO_SELECTED_ITEM, FALSE, NULL);
3331 pmt->TopMenu = PtMenu;
3332 }
3333 else
3334 {
3335 MENU_HideSubPopups(pmt->OwnerWnd, PtMenu, FALSE, wFlags);
3336 }
3337
3338 MENU_SelectItem(pmt->OwnerWnd, PtMenu, Index, TRUE, NULL);
3339 }
3340
3341 /***********************************************************************
3342 * MenuButtonDown
3343 *
3344 * Return TRUE if we can go on with menu tracking.
3345 */
3346 static BOOL FASTCALL MENU_ButtonDown(MTRACKER* pmt, PMENU PtMenu, UINT Flags)
3347 {
3348 TRACE("%x PtMenu=%p\n", pmt, PtMenu);
3349
3350 if (PtMenu)
3351 {
3352 UINT id = 0;
3353 PITEM item;
3354 if (IS_SYSTEM_MENU(PtMenu))
3355 {
3356 item = PtMenu->rgItems;
3357 }
3358 else
3359 {
3360 item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &id );
3361 }
3362
3363 if (item)
3364 {
3365 if (PtMenu->iItem != id)
3366 MENU_SwitchTracking(pmt, PtMenu, id, Flags);
3367
3368 /* If the popup menu is not already "popped" */
3369 if (!(item->fState & MF_MOUSESELECT))
3370 {
3371 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, PtMenu, FALSE, Flags);
3372 }
3373
3374 return TRUE;
3375 }
3376 /* Else the click was on the menu bar, finish the tracking */
3377 }
3378 return FALSE;
3379 }
3380
3381 /***********************************************************************
3382 * MenuButtonUp
3383 *
3384 * Return the value of MenuExecFocusedItem if
3385 * the selected item was not a popup. Else open the popup.
3386 * A -1 return value indicates that we go on with menu tracking.
3387 *
3388 */
3389 static INT FASTCALL MENU_ButtonUp(MTRACKER *pmt, PMENU PtMenu, UINT Flags)
3390 {
3391 TRACE("%p pmenu=%x\n", pmt, PtMenu);
3392
3393 if (PtMenu)
3394 {
3395 UINT Id = 0;
3396 ITEM *item;
3397
3398 if ( IS_SYSTEM_MENU(PtMenu) )
3399 {
3400 item = PtMenu->rgItems;
3401 }
3402 else
3403 {
3404 item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &Id );
3405 }
3406
3407 if (item && ( PtMenu->iItem == Id))
3408 {
3409 if (!(item->spSubMenu))
3410 {
3411 INT ExecutedMenuId = MENU_ExecFocusedItem( pmt, PtMenu, Flags);
3412 if (ExecutedMenuId == -1 || ExecutedMenuId == -2) return -1;
3413 return ExecutedMenuId;
3414 }
3415
3416 /* If we are dealing with the menu bar */
3417 /* and this is a click on an already "popped" item: */
3418 /* Stop the menu tracking and close the opened submenus */
3419 if (pmt->TopMenu == PtMenu && PtMenu->TimeToHide)
3420 {
3421 return 0;
3422 }
3423 }
3424 if ( IntGetMenu(PtMenu->hWnd) == PtMenu )
3425 {
3426 PtMenu->TimeToHide = TRUE;
3427 }
3428 }
3429 return -1;
3430 }
3431
3432 /***********************************************************************
3433 * MenuPtMenu
3434 *
3435 * Walks menu chain trying to find a menu pt maps to.
3436 */
3437 static PMENU FASTCALL MENU_PtMenu(PMENU menu, POINT pt)
3438 {
3439 PITEM pItem;
3440 PMENU ret = NULL;
3441
3442 if (!menu) return NULL;
3443
3444 /* try subpopup first (if any) */
3445 if (menu->iItem != NO_SELECTED_ITEM)
3446 {
3447 pItem = menu->rgItems;
3448 if ( pItem ) pItem = &pItem[menu->iItem];
3449 if ( pItem && pItem->spSubMenu && pItem->fState & MF_MOUSESELECT)
3450 {
3451 ret = MENU_PtMenu( pItem->spSubMenu, pt);
3452 }
3453 }
3454
3455 /* check the current window (avoiding WM_HITTEST) */
3456 if (!ret)
3457 {
3458 PWND pWnd = ValidateHwndNoErr(menu->hWnd);
3459 INT ht = GetNCHitEx(pWnd, pt);
3460 if ( menu->fFlags & MNF_POPUP )
3461 {
3462 if (ht != HTNOWHERE && ht != HTERROR) ret = menu;
3463 }
3464 else if (ht == HTSYSMENU)
3465 ret = get_win_sys_menu(menu->hWnd);
3466 else if (ht == HTMENU)
3467 ret = IntGetMenu( menu->hWnd );
3468 }
3469 return ret;
3470 }
3471
3472 /***********************************************************************
3473 * MenuMouseMove
3474 *
3475 * Return TRUE if we can go on with menu tracking.
3476 */
3477 static BOOL FASTCALL MENU_MouseMove(MTRACKER *pmt, PMENU PtMenu, UINT Flags)
3478 {
3479 UINT Index = NO_SELECTED_ITEM;
3480
3481 if ( PtMenu )
3482 {
3483 if (IS_SYSTEM_MENU(PtMenu))
3484 {
3485 Index = 0;
3486 //// ReactOS only HACK: CORE-2338
3487 // Windows tracks mouse moves to the system menu but does not open it.
3488 // Only keyboard tracking can do that.
3489 //
3490 TRACE("SystemMenu\n");
3491 return TRUE; // Stay inside the Loop!
3492 }
3493 else
3494 MENU_FindItemByCoords( PtMenu, pmt->Pt, &Index );
3495 }
3496
3497 if (Index == NO_SELECTED_ITEM)
3498 {
3499 MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, NO_SELECTED_ITEM, TRUE, pmt->TopMenu);
3500 }
3501 else if (PtMenu->iItem != Index)
3502 {
3503 MENU_SwitchTracking(pmt, PtMenu, Index, Flags);
3504 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, PtMenu, FALSE, Flags);
3505 }
3506 return TRUE;
3507 }
3508
3509 /***********************************************************************
3510 * MenuGetSubPopup
3511 *
3512 * Return the handle of the selected sub-popup menu (if any).
3513 */
3514 static PMENU MENU_GetSubPopup( PMENU menu )
3515 {
3516 ITEM *item;
3517
3518 if ((!menu) || (menu->iItem == NO_SELECTED_ITEM)) return 0;
3519
3520 item = &menu->rgItems[menu->iItem];
3521 if (item && (item->spSubMenu) && (item->fState & MF_MOUSESELECT))
3522 {
3523 return item->spSubMenu;
3524 }
3525 return 0;
3526 }
3527
3528 /***********************************************************************
3529 * MenuDoNextMenu
3530 *
3531 * NOTE: WM_NEXTMENU documented in Win32 is a bit different.
3532 */
3533 static LRESULT FASTCALL MENU_DoNextMenu(MTRACKER* pmt, UINT Vk, UINT wFlags)
3534 {
3535 BOOL atEnd = FALSE;
3536
3537 /* When skipping left, we need to do something special after the
3538 first menu. */
3539 if (Vk == VK_LEFT && pmt->TopMenu->iItem == 0)
3540 {
3541 atEnd = TRUE;
3542 }
3543 /* When skipping right, for the non-system menu, we need to
3544 handle the last non-special menu item (ie skip any window
3545 icons such as MDI maximize, restore or close) */
3546 else if ((Vk == VK_RIGHT) && !IS_SYSTEM_MENU(pmt->TopMenu))
3547 {
3548 UINT i = pmt->TopMenu->iItem + 1;
3549 while (i < pmt->TopMenu->cItems) {
3550 if ((pmt->TopMenu->rgItems[i].wID >= SC_SIZE &&
3551 pmt->TopMenu->rgItems[i].wID <= SC_RESTORE)) {
3552 i++;
3553 } else break;
3554 }
3555 if (i == pmt->TopMenu->cItems) {
3556 atEnd = TRUE;
3557 }
3558 }
3559 /* When skipping right, we need to cater for the system menu */
3560 else if ((Vk == VK_RIGHT) && IS_SYSTEM_MENU(pmt->TopMenu))
3561 {
3562 if (pmt->TopMenu->iItem == (pmt->TopMenu->cItems - 1)) {
3563 atEnd = TRUE;
3564 }
3565 }
3566
3567 if ( atEnd )
3568 {
3569 MDINEXTMENU NextMenu;
3570 PMENU MenuTmp;
3571 PWND pwndTemp;
3572 HMENU hNewMenu;
3573 HWND hNewWnd;
3574 UINT Id = 0;
3575
3576 MenuTmp = (IS_SYSTEM_MENU(pmt->TopMenu)) ? co_IntGetSubMenu(pmt->TopMenu, 0) : pmt->TopMenu;
3577 NextMenu.hmenuIn = UserHMGetHandle(MenuTmp);
3578 NextMenu.hmenuNext = NULL;
3579 NextMenu.hwndNext = NULL;
3580 co_IntSendMessage(UserHMGetHandle(pmt->OwnerWnd), WM_NEXTMENU, Vk, (LPARAM) &NextMenu);
3581
3582 TRACE("%p [%p] -> %p [%p]\n",
3583 pmt->CurrentMenu, pmt->OwnerWnd, NextMenu.hmenuNext, NextMenu.hwndNext );
3584
3585 if (NULL == NextMenu.hmenuNext || NULL == NextMenu.hwndNext)
3586 {
3587 hNewWnd = UserHMGetHandle(pmt->OwnerWnd);
3588 if (IS_SYSTEM_MENU(pmt->TopMenu))
3589 {
3590 /* switch to the menu bar */
3591
3592 if (pmt->OwnerWnd->style & WS_CHILD || !(MenuTmp = IntGetMenu(hNewWnd))) return FALSE;
3593
3594 if (Vk == VK_LEFT)
3595 {
3596 Id = MenuTmp->cItems - 1;
3597
3598 /* Skip backwards over any system predefined icons,
3599 eg. MDI close, restore etc icons */
3600 while ((Id > 0) &&
3601 (MenuTmp->rgItems[Id].wID >= SC_SIZE &&
3602 MenuTmp->rgItems[Id].wID <= SC_RESTORE)) Id--;
3603
3604 }
3605 hNewMenu = UserHMGetHandle(MenuTmp);
3606 }
3607 else if (pmt->OwnerWnd->style & WS_SYSMENU)
3608 {
3609 /* switch to the system menu */
3610 MenuTmp = get_win_sys_menu(hNewWnd);
3611 if (MenuTmp) hNewMenu = UserHMGetHandle(MenuTmp);
3612 }
3613 else
3614 return FALSE;
3615 }
3616 else /* application returned a new menu to switch to */
3617 {
3618 hNewMenu = NextMenu.hmenuNext;
3619 hNewWnd = NextMenu.hwndNext;
3620
3621 if ((MenuTmp = UserGetMenuObject(hNewMenu)) && (pwndTemp = ValidateHwndNoErr(hNewWnd)))
3622 {
3623 if ( pwndTemp->style & WS_SYSMENU && (get_win_sys_menu(hNewWnd) == MenuTmp) )
3624 {
3625 /* get the real system menu */
3626 MenuTmp = get_win_sys_menu(hNewWnd);
3627 hNewMenu = UserHMGetHandle(MenuTmp);
3628 }
3629 else if (pwndTemp->style & WS_CHILD || IntGetMenu(hNewWnd) != MenuTmp)
3630 {
3631 /* FIXME: Not sure what to do here;
3632 * perhaps try to track NewMenu as a popup? */
3633
3634 WARN(" -- got confused.\n");
3635 return FALSE;
3636 }
3637 }
3638 else return FALSE;
3639 }
3640
3641 if (hNewMenu != UserHMGetHandle(pmt->TopMenu))
3642 {
3643 MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, NO_SELECTED_ITEM, FALSE, 0 );
3644
3645 if (pmt->CurrentMenu != pmt->TopMenu)
3646 MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, wFlags);
3647 }
3648
3649 if (hNewWnd != UserHMGetHandle(pmt->OwnerWnd))
3650 {
3651 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
3652 pmt->OwnerWnd = ValidateHwndNoErr(hNewWnd);
3653 ///// Use thread pms!!!!
3654 MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, hNewWnd);
3655 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
3656 co_UserSetCapture(UserHMGetHandle(pmt->OwnerWnd));
3657 pti->MessageQueue->QF_flags |= QF_CAPTURELOCKED;
3658 }
3659
3660 pmt->TopMenu = pmt->CurrentMenu = UserGetMenuObject(hNewMenu); /* all subpopups are hidden */
3661 MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, Id, TRUE, 0);
3662
3663 return TRUE;
3664 }
3665 return FALSE;
3666 }
3667
3668 /***********************************************************************
3669 * MenuSuspendPopup
3670 *
3671 * The idea is not to show the popup if the next input message is
3672 * going to hide it anyway.
3673 */
3674 static BOOL FASTCALL MENU_SuspendPopup(MTRACKER* pmt, UINT uMsg)
3675 {
3676 MSG msg;
3677
3678 msg.hwnd = UserHMGetHandle(pmt->OwnerWnd); ////// ? silly wine'isms?
3679
3680 co_IntGetPeekMessage( &msg, 0, uMsg, uMsg, PM_NOYIELD | PM_REMOVE, FALSE);
3681 pmt->TrackFlags |= TF_SKIPREMOVE;
3682
3683 switch( uMsg )
3684 {
3685 case WM_KEYDOWN:
3686 co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE, FALSE);
3687 if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
3688 {
3689 co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE, FALSE);
3690 co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE, FALSE);
3691 if( msg.message == WM_KEYDOWN &&
3692 (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
3693 {
3694 pmt->TrackFlags |= TF_SUSPENDPOPUP;
3695 return TRUE;
3696 }
3697 }
3698 break;
3699 }
3700 /* failures go through this */
3701 pmt->TrackFlags &= ~TF_SUSPENDPOPUP;
3702 return FALSE;
3703 }
3704
3705 /***********************************************************************
3706 * MenuKeyEscape
3707 *
3708 * Handle a VK_ESCAPE key event in a menu.
3709 */
3710 static BOOL FASTCALL MENU_KeyEscape(MTRACKER *pmt, UINT Flags)
3711 {
3712 BOOL EndMenu = TRUE;
3713
3714 if (pmt->CurrentMenu != pmt->TopMenu)
3715 {
3716 if (pmt->CurrentMenu && (pmt->CurrentMenu->fFlags & MNF_POPUP))
3717 {
3718 PMENU MenuPrev, MenuTmp;
3719
3720 MenuPrev = MenuTmp = pmt->TopMenu;
3721
3722 /* close topmost popup */
3723 while (MenuTmp != pmt->CurrentMenu)
3724 {
3725 MenuPrev = MenuTmp;
3726 MenuTmp = MENU_GetSubPopup(MenuPrev);
3727 }
3728
3729 MENU_HideSubPopups(pmt->OwnerWnd, MenuPrev, TRUE, Flags);
3730 pmt->CurrentMenu = MenuPrev;
3731 EndMenu = FALSE;
3732 }
3733 }
3734
3735 return EndMenu;
3736 }
3737
3738 /***********************************************************************
3739 * MenuKeyLeft
3740 *
3741 * Handle a VK_LEFT key event in a menu.
3742 */
3743 static void FASTCALL MENU_KeyLeft(MTRACKER* pmt, UINT Flags, UINT msg)
3744 {
3745 PMENU MenuTmp, MenuPrev;
3746 UINT PrevCol;
3747
3748 MenuPrev = MenuTmp = pmt->TopMenu;
3749
3750 /* Try to move 1 column left (if possible) */
3751 if ( (PrevCol = MENU_GetStartOfPrevColumn(pmt->CurrentMenu)) != NO_SELECTED_ITEM)
3752 {
3753 MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, PrevCol, TRUE, 0);
3754 return;
3755 }
3756
3757 /* close topmost popup */
3758 while (MenuTmp != pmt->CurrentMenu)
3759 {
3760 MenuPrev = MenuTmp;
3761 MenuTmp = MENU_GetSubPopup(MenuPrev);
3762 }
3763
3764 MENU_HideSubPopups(pmt->OwnerWnd, MenuPrev, TRUE, Flags);
3765 pmt->CurrentMenu = MenuPrev;
3766
3767 if ((MenuPrev == pmt->TopMenu) && !(pmt->TopMenu->fFlags & MNF_POPUP))
3768 {
3769 /* move menu bar selection if no more popups are left */
3770
3771 if (!MENU_DoNextMenu(pmt, VK_LEFT, Flags))
3772 MENU_MoveSelection(pmt->OwnerWnd, pmt->TopMenu, ITEM_PREV);
3773
3774 if (MenuPrev != MenuTmp || pmt->TrackFlags & TF_SUSPENDPOPUP)
3775 {
3776 /* A sublevel menu was displayed - display the next one
3777 * unless there is another displacement coming up */
3778
3779 if (!MENU_SuspendPopup(pmt, msg))
3780 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, pmt->TopMenu,
3781 TRUE, Flags);
3782 }
3783 }
3784 }
3785
3786 /***********************************************************************
3787 * MenuKeyRight
3788 *
3789 * Handle a VK_RIGHT key event in a menu.
3790 */
3791 static void FASTCALL MENU_KeyRight(MTRACKER *pmt, UINT Flags, UINT msg)
3792 {
3793 PMENU menutmp;
3794 UINT NextCol;
3795
3796 TRACE("MenuKeyRight called, cur %p, top %p.\n",
3797 pmt->CurrentMenu, pmt->TopMenu);
3798
3799 if ((pmt->TopMenu->fFlags & MNF_POPUP) || (pmt->CurrentMenu != pmt->TopMenu))
3800 {
3801 /* If already displaying a popup, try to display sub-popup */
3802
3803 menutmp = pmt->CurrentMenu;
3804 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, menutmp, TRUE, Flags);
3805
3806 /* if subpopup was displayed then we are done */
3807 if (menutmp != pmt->CurrentMenu) return;
3808 }
3809
3810 /* Check to see if there's another column */
3811 if ( (NextCol = MENU_GetStartOfNextColumn(pmt->CurrentMenu)) != NO_SELECTED_ITEM)
3812 {
3813 TRACE("Going to %d.\n", NextCol);
3814 MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, NextCol, TRUE, 0);
3815 return;
3816 }
3817
3818 if (!(pmt->TopMenu->fFlags & MNF_POPUP)) /* menu bar tracking */
3819 {
3820 if (pmt->CurrentMenu != pmt->TopMenu)
3821 {
3822 MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, Flags);
3823 menutmp = pmt->CurrentMenu = pmt->TopMenu;
3824 }
3825 else
3826 {
3827 menutmp = NULL;
3828 }
3829
3830 /* try to move to the next item */
3831 if ( !MENU_DoNextMenu(pmt, VK_RIGHT, Flags))
3832 MENU_MoveSelection(pmt->OwnerWnd, pmt->TopMenu, ITEM_NEXT);
3833
3834 if ( menutmp || pmt->TrackFlags & TF_SUSPENDPOPUP )
3835 {
3836 if ( !MENU_SuspendPopup(pmt, msg) )
3837 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, pmt->TopMenu, TRUE, Flags);
3838 }
3839 }
3840 }
3841
3842 /***********************************************************************
3843 * MenuTrackMenu
3844 *
3845 * Menu tracking code.
3846 */
3847 static INT FASTCALL MENU_TrackMenu(PMENU pmenu, UINT wFlags, INT x, INT y,
3848 PWND pwnd, const RECT *lprect )
3849 {
3850 MSG msg;
3851 BOOL fRemove;
3852 INT executedMenuId = -1;
3853 MTRACKER mt;
3854 HWND capture_win;
3855 PMENU pmMouse;
3856 BOOL enterIdleSent = FALSE;
3857 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
3858
3859 if (pti != pwnd->head.pti)
3860 {
3861 ERR("Not the same PTI!!!!\n");
3862 }
3863
3864 mt.TrackFlags = 0;
3865 mt.CurrentMenu = pmenu;
3866 mt.TopMenu = pmenu;
3867 mt.OwnerWnd = pwnd;
3868 mt.Pt.x = x;
3869 mt.Pt.y = y;
3870
3871 TRACE("MTM : hmenu=%p flags=0x%08x (%d,%d) hwnd=%x (%ld,%ld)-(%ld,%ld)\n",
3872 UserHMGetHandle(pmenu), wFlags, x, y, UserHMGetHandle(pwnd), lprect ? lprect->left : 0, lprect ? lprect->top : 0,
3873 lprect ? lprect->right : 0, lprect ? lprect->bottom : 0);
3874
3875 pti->MessageQueue->QF_flags &= ~QF_ACTIVATIONCHANGE;
3876
3877 if (wFlags & TPM_BUTTONDOWN)
3878 {
3879 /* Get the result in order to start the tracking or not */
3880 fRemove = MENU_ButtonDown( &mt, pmenu, wFlags );
3881 fInsideMenuLoop = fRemove;
3882 }
3883
3884 if (wFlags & TF_ENDMENU) fInsideMenuLoop = FALSE;
3885
3886 if (wFlags & TPM_POPUPMENU && pmenu->cItems == 0) // Tracking empty popup menu...
3887 {
3888 MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
3889 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
3890 co_UserSetCapture(NULL); /* release the capture */
3891 return 0;
3892 }
3893
3894 capture_win = IntGetCapture();
3895
3896 while (fInsideMenuLoop)
3897 {
3898 BOOL ErrorExit = FALSE;
3899 if (!VerifyMenu( mt.CurrentMenu )) /* sometimes happens if I do a window manager close */
3900 break;
3901
3902 /* we have to keep the message in the queue until it's
3903 * clear that menu loop is not over yet. */
3904
3905 for (;;)
3906 {
3907 if (co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOREMOVE, FALSE ))
3908 {
3909 if (!IntCallMsgFilter( &msg, MSGF_MENU )) break;
3910 /* remove the message from the queue */
3911 co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
3912 }
3913 else
3914 {
3915 /* ReactOS Checks */
3916 if (!VerifyWnd(mt.OwnerWnd) ||
3917 !ValidateHwndNoErr(mt.CurrentMenu->hWnd) ||
3918 pti->MessageQueue->QF_flags & QF_ACTIVATIONCHANGE ||
3919 capture_win != IntGetCapture() ) // Should not happen, but this is ReactOS...
3920 {
3921 ErrorExit = TRUE; // Do not wait on dead windows, now win test_capture_4 works.
3922 break;
3923 }
3924
3925 if (!enterIdleSent)
3926 {
3927 HWND win = mt.CurrentMenu->fFlags & MNF_POPUP ? mt.CurrentMenu->hWnd : NULL;
3928 enterIdleSent = TRUE;
3929 co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_ENTERIDLE, MSGF_MENU, (LPARAM) win);
3930 }
3931 co_IntWaitMessage(NULL, 0, 0);
3932 }
3933 }
3934
3935 if (ErrorExit) break; // Gracefully dropout.
3936
3937 /* check if EndMenu() tried to cancel us, by posting this message */
3938 if (msg.message == WM_CANCELMODE)
3939 {
3940 /* we are now out of the loop */
3941 fInsideMenuLoop = FALSE;
3942
3943 /* remove the message from the queue */
3944 co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
3945
3946 /* break out of internal loop, ala ESCAPE */
3947 break;
3948 }
3949
3950 mt.Pt = msg.pt;
3951
3952 if ( (msg.hwnd == mt.CurrentMenu->hWnd) || ((msg.message!=WM_TIMER) && (msg.message!=WM_SYSTIMER)) )
3953 enterIdleSent=FALSE;
3954
3955 fRemove = FALSE;
3956 if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
3957 {
3958 /*
3959 * Use the mouse coordinates in lParam instead of those in the MSG
3960 * struct to properly handle synthetic messages. They are already
3961 * in screen coordinates.
3962 */
3963 mt.Pt.x = (short)LOWORD(msg.lParam);
3964 mt.Pt.y = (short)HIWORD(msg.lParam);
3965
3966 /* Find a menu for this mouse event */
3967 pmMouse = MENU_PtMenu( mt.TopMenu, mt.Pt );
3968
3969 switch(msg.message)
3970 {
3971 /* no WM_NC... messages in captured state */
3972
3973 case WM_RBUTTONDBLCLK:
3974 case WM_RBUTTONDOWN:
3975 if (!(wFlags & TPM_RIGHTBUTTON))
3976 {
3977 if ( msg.message == WM_RBUTTONDBLCLK ) fInsideMenuLoop = FALSE; // Must exit or loop forever!
3978 break;
3979 }
3980 /* fall through */
3981 case WM_LBUTTONDBLCLK:
3982 case WM_LBUTTONDOWN:
3983 /* If the message belongs to the menu, removes it from the queue */
3984 /* Else, end menu tracking */
3985 fRemove = MENU_ButtonDown(&mt, pmMouse, wFlags);
3986 fInsideMenuLoop = fRemove;
3987 if ( msg.message == WM_LBUTTONDBLCLK ||
3988 msg.message == WM_RBUTTONDBLCLK ) fInsideMenuLoop = FALSE; // Must exit or loop forever!
3989 break;
3990
3991 case WM_RBUTTONUP:
3992 if (!(wFlags & TPM_RIGHTBUTTON)) break;
3993 /* fall through */
3994 case WM_LBUTTONUP:
3995 /* Check if a menu was selected by the mouse */
3996 if (pmMouse)
3997 {
3998 executedMenuId = MENU_ButtonUp( &mt, pmMouse, wFlags);
3999
4000 /* End the loop if executedMenuId is an item ID */
4001 /* or if the job was done (executedMenuId = 0). */
4002 fRemove = (executedMenuId != -1);
4003 fInsideMenuLoop = !fRemove;
4004 }
4005 /* No menu was selected by the mouse */
4006 /* if the function was called by TrackPopupMenu, continue
4007 with the menu tracking. If not, stop it */
4008 else
4009 fInsideMenuLoop = ((wFlags & TPM_POPUPMENU) ? TRUE : FALSE);
4010
4011 break;
4012
4013 case WM_MOUSEMOVE:
4014 /* the selected menu item must be changed every time */
4015 /* the mouse moves. */
4016
4017 if (pmMouse)
4018 fInsideMenuLoop |= MENU_MouseMove( &mt, pmMouse, wFlags );
4019
4020 } /* switch(msg.message) - mouse */
4021 }
4022 else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
4023 {
4024 fRemove = TRUE; /* Keyboard messages are always removed */
4025 switch(msg.message)
4026 {
4027 case WM_KEYDOWN:
4028 case WM_SYSKEYDOWN:
4029 switch(msg.wParam)
4030 {
4031 case VK_MENU:
4032 case VK_F10:
4033 fInsideMenuLoop = FALSE;
4034 break;
4035
4036 case VK_HOME:
4037 case VK_END:
4038 MENU_SelectItem(mt.OwnerWnd, mt.CurrentMenu, NO_SELECTED_ITEM, FALSE, 0 );
4039 MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, VK_HOME == msg.wParam ? ITEM_NEXT : ITEM_PREV);
4040 break;
4041
4042 case VK_UP:
4043 case VK_DOWN: /* If on menu bar, pull-down the menu */
4044 if (!(mt.CurrentMenu->fFlags & MNF_POPUP))
4045 mt.CurrentMenu = MENU_ShowSubPopup(mt.OwnerWnd, mt.TopMenu, TRUE, wFlags);
4046 else /* otherwise try to move selection */
4047 MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, (msg.wParam == VK_UP)? ITEM_PREV : ITEM_NEXT );
4048 break;
4049
4050 case VK_LEFT:
4051 MENU_KeyLeft( &mt, wFlags, msg.message );
4052 break;
4053
4054 case VK_RIGHT:
4055 MENU_KeyRight( &mt, wFlags, msg.message );
4056 break;
4057
4058 case VK_ESCAPE:
4059 fInsideMenuLoop = !MENU_KeyEscape(&mt, wFlags);
4060 break;
4061
4062 case VK_F1:
4063 {
4064 HELPINFO hi;
4065 hi.cbSize = sizeof(HELPINFO);
4066 hi.iContextType = HELPINFO_MENUITEM;
4067 if (mt.CurrentMenu->iItem == NO_SELECTED_ITEM)
4068 hi.iCtrlId = 0;
4069 else
4070 hi.iCtrlId = pmenu->rgItems[mt.CurrentMenu->iItem].wID;
4071 hi.hItemHandle = UserHMGetHandle(mt.CurrentMenu);
4072 hi.dwContextId = pmenu->dwContextHelpId;
4073 hi.MousePos = msg.pt;
4074 co_IntSendMessage( UserHMGetHandle(pwnd), WM_HELP, 0, (LPARAM)&hi);
4075 break;
4076 }
4077
4078 default:
4079 IntTranslateKbdMessage(&msg, 0);
4080 break;
4081 }
4082 break; /* WM_KEYDOWN */
4083
4084 case WM_CHAR:
4085 case WM_SYSCHAR:
4086 {
4087 UINT pos;
4088 BOOL fEndMenu;
4089
4090 if (msg.wParam == L'\r' || msg.wParam == L' ')
4091 {
4092 executedMenuId = MENU_ExecFocusedItem(&mt, mt.CurrentMenu, wFlags);
4093 fEndMenu = (executedMenuId != -2);
4094 fInsideMenuLoop = !fEndMenu;
4095 break;
4096 }
4097
4098 /* Hack to avoid control chars. */
4099 /* We will find a better way real soon... */
4100 if (msg.wParam < 32) break;
4101
4102 pos = MENU_FindItemByKey(mt.OwnerWnd, mt.CurrentMenu, LOWORD(msg.wParam), FALSE);
4103
4104 if (pos == (UINT)-2) fInsideMenuLoop = FALSE;
4105 else if (pos == (UINT)-1) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
4106 else
4107 {
4108 MENU_SelectItem(mt.OwnerWnd, mt.CurrentMenu, pos, TRUE, 0);
4109 executedMenuId = MENU_ExecFocusedItem(&mt, mt.CurrentMenu, wFlags);
4110 fEndMenu = (executedMenuId != -2);
4111 fInsideMenuLoop = !fEndMenu;
4112 }
4113 }
4114 break;
4115 } /* switch(msg.message) - kbd */
4116 }
4117 else
4118 {
4119 co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
4120 IntDispatchMessage( &msg );
4121 continue;
4122 }
4123
4124 if (fInsideMenuLoop) fRemove = TRUE;
4125
4126 /* finally remove message from the queue */
4127
4128 if (fRemove && !(mt.TrackFlags & TF_SKIPREMOVE) )
4129 co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
4130 else mt.TrackFlags &= ~TF_SKIPREMOVE;
4131 }
4132
4133 MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
4134 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4135 co_UserSetCapture(NULL); /* release the capture */
4136
4137 /* If dropdown is still painted and the close box is clicked on
4138 then the menu will be destroyed as part of the DispatchMessage above.
4139 This will then invalidate the menu handle in mt.hTopMenu. We should
4140 check for this first. */
4141 if ( VerifyMenu( mt.TopMenu ) )
4142 {
4143 if (VerifyWnd(mt.OwnerWnd))
4144 {
4145 MENU_HideSubPopups(mt.OwnerWnd, mt.TopMenu, FALSE, wFlags);
4146
4147 if (mt.TopMenu->fFlags & MNF_POPUP)
4148 {
4149 PWND pwndTM = ValidateHwndNoErr(mt.TopMenu->hWnd);
4150 if (pwndTM)
4151 {
4152 IntNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPEND, pwndTM, OBJID_CLIENT, CHILDID_SELF, 0);
4153
4154 co_UserDestroyWindow(pwndTM);
4155 }
4156 mt.TopMenu->hWnd = NULL;
4157
4158 if (!(wFlags & TPM_NONOTIFY))
4159 {
4160 co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(mt.TopMenu),
4161 MAKELPARAM(0, IS_SYSTEM_MENU(mt.TopMenu)) );
4162 }
4163 }
4164 MENU_SelectItem( mt.OwnerWnd, mt.TopMenu, NO_SELECTED_ITEM, FALSE, 0 );
4165 co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_MENUSELECT, MAKEWPARAM(0, 0xffff), 0 );
4166 }
4167
4168 /* Reset the variable for hiding menu */
4169 mt.TopMenu->TimeToHide = FALSE;
4170 }
4171
4172 EngSetLastError( ERROR_SUCCESS );
4173 /* The return value is only used by TrackPopupMenu */
4174 if (!(wFlags & TPM_RETURNCMD)) return TRUE;
4175 if (executedMenuId == -1) executedMenuId = 0;
4176 return executedMenuId;
4177 }
4178
4179 /***********************************************************************
4180 * MenuInitTracking
4181 */
4182 static BOOL FASTCALL MENU_InitTracking(PWND pWnd, PMENU Menu, BOOL bPopup, UINT wFlags)
4183 {
4184 HWND capture_win;
4185 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
4186
4187 TRACE("hwnd=%p hmenu=%p\n", UserHMGetHandle(pWnd), UserHMGetHandle(Menu));
4188
4189 co_UserHideCaret(0);
4190
4191 /* This makes the menus of applications built with Delphi work.
4192 * It also enables menus to be displayed in more than one window,
4193 * but there are some bugs left that need to be fixed in this case.
4194 */
4195 if (!bPopup)
4196 {
4197 Menu->hWnd = UserHMGetHandle(pWnd);
4198 }
4199
4200 if (!top_popup) {
4201 top_popup = Menu->hWnd;
4202 top_popup_hmenu = UserHMGetHandle(Menu);
4203 }
4204
4205 fInsideMenuLoop = TRUE;
4206 fInEndMenu = FALSE;
4207
4208 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
4209 if (!(wFlags & TPM_NONOTIFY))
4210 {
4211 co_IntSendMessage( UserHMGetHandle(pWnd), WM_ENTERMENULOOP, bPopup, 0 );
4212 }
4213
4214 //
4215 // Capture is set before calling WM_INITMENU and after WM_ENTERMENULOOP, see msg_menu.
4216 //
4217 capture_win = (wFlags & TPM_POPUPMENU) ? Menu->hWnd : UserHMGetHandle(pWnd);
4218 MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, capture_win); // 1
4219 co_UserSetCapture(capture_win); // 2
4220 pti->MessageQueue->QF_flags |= QF_CAPTURELOCKED; // Set the Q bits so noone can change this!
4221
4222 co_IntSendMessage( UserHMGetHandle(pWnd), WM_SETCURSOR, (WPARAM)UserHMGetHandle(pWnd), HTCAPTION );
4223
4224 if (!(wFlags & TPM_NONOTIFY))
4225 {
4226 co_IntSendMessage( UserHMGetHandle(pWnd), WM_INITMENU, (WPARAM)UserHMGetHandle(Menu), 0 );
4227 /* If an app changed/recreated menu bar entries in WM_INITMENU
4228 * menu sizes will be recalculated once the menu created/shown.
4229 */
4230 }
4231
4232 IntNotifyWinEvent( EVENT_SYSTEM_MENUSTART,
4233 pWnd,
4234 Menu->fFlags & MNF_SYSMENU ? OBJID_SYSMENU : OBJID_MENU,
4235 CHILDID_SELF, 0);
4236 return TRUE;
4237 }
4238
4239 /***********************************************************************
4240 * MenuExitTracking
4241 */
4242 static BOOL FASTCALL MENU_ExitTracking(PWND pWnd, BOOL bPopup, UINT wFlags)
4243 {
4244 TRACE("Exit Track hwnd=%p bPopup %d\n", UserHMGetHandle(pWnd), bPopup);
4245
4246 IntNotifyWinEvent( EVENT_SYSTEM_MENUEND, pWnd, OBJID_WINDOW, CHILDID_SELF, 0);
4247
4248 if (!(wFlags & TPM_NONOTIFY))
4249 co_IntSendMessage( UserHMGetHandle(pWnd), WM_EXITMENULOOP, bPopup, 0 );
4250
4251 co_UserShowCaret(0);
4252
4253 top_popup = 0;
4254 top_popup_hmenu = NULL;
4255
4256 return TRUE;
4257 }
4258
4259 /***********************************************************************
4260 * MenuTrackMouseMenuBar
4261 *
4262 * Menu-bar tracking upon a mouse event. Called from NC_HandleSysCommand().
4263 */
4264 VOID MENU_TrackMouseMenuBar( PWND pWnd, ULONG ht, POINT pt)
4265 {
4266 PMENU pMenu = (ht == HTSYSMENU) ? IntGetSystemMenu(pWnd, FALSE) : IntGetMenu( UserHMGetHandle(pWnd) ); // See 74276 and CORE-12801
4267 UINT wFlags = TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON;
4268
4269 TRACE("wnd=%p ht=0x%04x (%ld,%ld)\n", pWnd, ht, pt.x, pt.y);
4270
4271 if (pWnd->ExStyle & WS_EX_LAYOUTRTL) wFlags |= TPM_LAYOUTRTL;
4272 if (VerifyMenu(pMenu))
4273 {
4274 /* map point to parent client coordinates */
4275 PWND Parent = UserGetAncestor(pWnd, GA_PARENT );
4276 if (Parent != UserGetDesktopWindow())
4277 {
4278 IntScreenToClient(Parent, &pt);
4279 }
4280
4281 MENU_InitTracking(pWnd, pMenu, FALSE, wFlags);
4282 /* fetch the window menu again, it may have changed */
4283 pMenu = (ht == HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pWnd) ) : IntGetMenu( UserHMGetHandle(pWnd) );
4284 MENU_TrackMenu(pMenu, wFlags, pt.x, pt.y, pWnd, NULL);
4285 MENU_ExitTracking(pWnd, FALSE, wFlags);
4286 }
4287 }
4288
4289 /***********************************************************************
4290 * MenuTrackKbdMenuBar
4291 *
4292 * Menu-bar tracking upon a keyboard event. Called from NC_HandleSysCommand().
4293 */
4294 VOID MENU_TrackKbdMenuBar(PWND pwnd, UINT wParam, WCHAR wChar)
4295 {
4296 UINT uItem = NO_SELECTED_ITEM;
4297 PMENU TrackMenu;
4298 UINT wFlags = TPM_LEFTALIGN | TPM_LEFTBUTTON;
4299
4300 TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", UserHMGetHandle(pwnd), wParam, wChar);
4301
4302 /* find window that has a menu */
4303
4304 while (!( (pwnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD ) )
4305 if (!(pwnd = UserGetAncestor( pwnd, GA_PARENT ))) return;
4306
4307 /* check if we have to track a system menu */
4308
4309 TrackMenu = IntGetMenu( UserHMGetHandle(pwnd) );
4310 if (!TrackMenu || (pwnd->style & WS_MINIMIZE) != 0 || wChar == ' ' )
4311 {
4312 if (!(pwnd->style & WS_SYSMENU)) return;
4313 TrackMenu = get_win_sys_menu( UserHMGetHandle(pwnd) );
4314 uItem = 0;
4315 wParam |= HTSYSMENU; /* prevent item lookup */
4316 }
4317
4318 if (!VerifyMenu( TrackMenu )) return;
4319
4320 MENU_InitTracking( pwnd, TrackMenu, FALSE, wFlags );
4321
4322 /* fetch the window menu again, it may have changed */
4323 TrackMenu = (wParam & HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pwnd) ) : IntGetMenu( UserHMGetHandle(pwnd) );
4324
4325 if( wChar && wChar != ' ' )
4326 {
4327 uItem = MENU_FindItemByKey( pwnd, TrackMenu, wChar, (wParam & HTSYSMENU) );
4328 if ( uItem >= (UINT)(-2) )
4329 {
4330 if( uItem == (UINT)(-1) ) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
4331 /* schedule end of menu tracking */
4332 wFlags |= TF_ENDMENU;
4333 goto track_menu;
4334 }
4335 }
4336
4337 MENU_SelectItem( pwnd, TrackMenu, uItem, TRUE, 0 );
4338
4339 if (!(wParam & HTSYSMENU) || wChar == ' ')
4340 {
4341 if( uItem == NO_SELECTED_ITEM )
4342 MENU_MoveSelection( pwnd, TrackMenu, ITEM_NEXT );
4343 else
4344 UserPostMessage( UserHMGetHandle(pwnd), WM_KEYDOWN, VK_RETURN, 0 );
4345 }
4346
4347 track_menu:
4348 MENU_TrackMenu( TrackMenu, wFlags, 0, 0, pwnd, NULL );
4349 MENU_ExitTracking( pwnd, FALSE, wFlags);
4350 }
4351
4352 /**********************************************************************
4353 * TrackPopupMenuEx (USER32.@)
4354 */
4355 BOOL WINAPI IntTrackPopupMenuEx( PMENU menu, UINT wFlags, int x, int y,
4356 PWND pWnd, LPTPMPARAMS lpTpm)
4357 {
4358 BOOL ret = FALSE;
4359 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
4360
4361 if (pti != pWnd->head.pti)
4362 {
4363 ERR("Must be the same pti!\n");
4364 return ret;
4365 }
4366
4367 TRACE("hmenu %p flags %04x (%d,%d) hwnd %p lpTpm %p \n", //rect %s\n",
4368 UserHMGetHandle(menu), wFlags, x, y, UserHMGetHandle(pWnd), lpTpm); //,
4369 //lpTpm ? wine_dbgstr_rect( &lpTpm->rcExclude) : "-" );
4370
4371 if (menu->hWnd && IntIsWindow(menu->hWnd))
4372 {
4373 EngSetLastError( ERROR_POPUP_ALREADY_ACTIVE );
4374 return FALSE;
4375 }
4376
4377 if (MENU_InitPopup( pWnd, menu, wFlags ))
4378 {
4379 MENU_InitTracking(pWnd, menu, TRUE, wFlags);
4380
4381 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
4382 if (!(wFlags & TPM_NONOTIFY))
4383 {
4384 co_IntSendMessage( UserHMGetHandle(pWnd), WM_INITMENUPOPUP, (WPARAM) UserHMGetHandle(menu), 0);
4385 }
4386
4387 if (menu->fFlags & MNF_SYSMENU)
4388 MENU_InitSysMenuPopup( menu, pWnd->style, pWnd->pcls->style, HTSYSMENU);
4389
4390 if (MENU_ShowPopup(pWnd, menu, 0, wFlags, x, y, 0, 0 ))
4391 ret = MENU_TrackMenu( menu, wFlags | TPM_POPUPMENU, 0, 0, pWnd,
4392 lpTpm ? &lpTpm->rcExclude : NULL);
4393 else
4394 {
4395 MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
4396 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4397 co_UserSetCapture(NULL); /* release the capture */
4398 }
4399
4400 MENU_ExitTracking(pWnd, TRUE, wFlags);
4401
4402 if (menu->hWnd)
4403 {
4404 PWND pwndM = ValidateHwndNoErr( menu->hWnd );
4405 if (pwndM) // wine hack around this with their destroy function.
4406 {
4407 if (!(pWnd->state & WNDS_DESTROYED))
4408 co_UserDestroyWindow( pwndM ); // Fix wrong error return.
4409 }
4410 menu->hWnd = 0;
4411
4412 if (!(wFlags & TPM_NONOTIFY))
4413 {
4414 co_IntSendMessage( UserHMGetHandle(pWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(menu),
4415 MAKELPARAM(0, IS_SYSTEM_MENU(menu)) );
4416 }
4417 }
4418 }
4419 return ret;
4420 }
4421
4422 //
4423 // Menu Class Proc.
4424 //
4425 BOOL WINAPI
4426 PopupMenuWndProc(
4427 PWND Wnd,
4428 UINT Message,
4429 WPARAM wParam,
4430 LPARAM lParam,
4431 LRESULT *lResult)
4432 {
4433 PPOPUPMENU pPopupMenu;
4434
4435 *lResult = 0;
4436
4437 TRACE("PMWP : pwnd=%x msg=%d wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);
4438
4439 if (Wnd)
4440 {
4441 if (!Wnd->fnid)
4442 {
4443 if (Message != WM_NCCREATE)
4444 {
4445 *lResult = IntDefWindowProc(Wnd, Message, wParam, lParam, FALSE);
4446 return TRUE;
4447 }
4448 Wnd->fnid = FNID_MENU;
4449 pPopupMenu = DesktopHeapAlloc( Wnd->head.rpdesk, sizeof(POPUPMENU) );
4450 if (pPopupMenu == NULL)
4451 {
4452 return TRUE;
4453 }
4454 pPopupMenu->posSelectedItem = NO_SELECTED_ITEM;
4455 pPopupMenu->spwndPopupMenu = Wnd;
4456 ((PMENUWND)Wnd)->ppopupmenu = pPopupMenu;
4457 TRACE("Pop Up Menu is Setup! Msg %d\n",Message);
4458 *lResult = 1;
4459 return TRUE;
4460 }
4461 else
4462 {
4463 if (Wnd->fnid != FNID_MENU)
4464 {
4465 ERR("Wrong window class for Menu! fnid %x\n",Wnd->fnid);
4466 return TRUE;
4467 }
4468 pPopupMenu = ((PMENUWND)Wnd)->ppopupmenu;
4469 }
4470 }
4471
4472 switch(Message)
4473 {
4474 case WM_CREATE:
4475 {
4476 CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam;
4477 pPopupMenu->spmenu = UserGetMenuObject(cs->lpCreateParams);
4478 break;
4479 }
4480
4481 case WM_MOUSEACTIVATE: /* We don't want to be activated */
4482 *lResult = MA_NOACTIVATE;
4483 break;
4484
4485 case WM_PAINT:
4486 {
4487 PAINTSTRUCT ps;
4488 IntBeginPaint(Wnd, &ps);
4489 MENU_DrawPopupMenu(Wnd, ps.hdc, pPopupMenu->spmenu);
4490 IntEndPaint(Wnd, &ps);
4491 break;
4492 }
4493
4494 case WM_PRINTCLIENT:
4495 {
4496 MENU_DrawPopupMenu( Wnd, (HDC)wParam, pPopupMenu->spmenu);
4497 break;
4498 }
4499
4500 case WM_ERASEBKGND:
4501 *lResult = 1;
4502 break;
4503
4504 case WM_DESTROY:
4505 /* zero out global pointer in case resident popup window was destroyed. */
4506 if (pPopupMenu)
4507 {
4508 if (UserHMGetHandle(Wnd) == top_popup)
4509 {
4510 top_popup = NULL;
4511 top_popup_hmenu = NULL;
4512 }
4513 }
4514 else
4515 {
4516 ERR("No Window Pop Up!\n");
4517 }
4518 break;
4519
4520 case WM_NCDESTROY:
4521 {
4522 DesktopHeapFree(Wnd->head.rpdesk, pPopupMenu );
4523 ((PMENUWND)Wnd)->ppopupmenu = 0;
4524 Wnd->fnid = FNID_DESTROY;
4525 break;
4526 }
4527
4528 case MM_SETMENUHANDLE: // wine'isms
4529 case MN_SETHMENU:
4530 {
4531 PMENU pmenu = UserGetMenuObject((HMENU)wParam);
4532 if (!pmenu)
4533 {
4534 ERR("Bad Menu Handle\n");
4535 break;
4536 }
4537 pPopupMenu->spmenu = pmenu;
4538 break;
4539 }
4540
4541 case MM_GETMENUHANDLE: // wine'isms
4542 case MN_GETHMENU:
4543 *lResult = (LRESULT)(pPopupMenu ? (pPopupMenu->spmenu ? UserHMGetHandle(pPopupMenu->spmenu) : NULL) : NULL);
4544 break;
4545
4546 default:
4547 if (Message > MN_GETHMENU && Message < MN_GETHMENU+19)
4548 {
4549 ERR("Someone is passing unknown menu messages %d\n",Message);
4550 }
4551 TRACE("PMWP to IDWP %d\n",Message);
4552 *lResult = IntDefWindowProc(Wnd, Message, wParam, lParam, FALSE);
4553 break;
4554 }
4555
4556 return TRUE;
4557 }
4558
4559 BOOL FASTCALL
4560 IntHiliteMenuItem(PWND WindowObject,
4561 PMENU MenuObject,
4562 UINT uItemHilite,
4563 UINT uHilite)
4564 {
4565 PITEM MenuItem;
4566 UINT uItem = uItemHilite;
4567
4568 if (!(MenuItem = MENU_FindItem( &MenuObject, &uItem, uHilite ))) return TRUE;
4569
4570 if (uHilite & MF_HILITE)
4571 {
4572 MenuItem->fState |= MF_HILITE;
4573 }
4574 else
4575 {
4576 MenuItem->fState &= ~MF_HILITE;
4577 }
4578 if (MenuObject->iItem == uItemHilite) return TRUE;
4579 MENU_HideSubPopups( WindowObject, MenuObject, FALSE, 0 );
4580 MENU_SelectItem( WindowObject, MenuObject, uItemHilite, TRUE, 0 );
4581
4582 return TRUE; // Always returns true!!!!
4583 }
4584
4585 BOOLEAN APIENTRY
4586 intGetTitleBarInfo(PWND pWindowObject, PTITLEBARINFO bti)
4587 {
4588
4589 DWORD dwStyle = 0;
4590 DWORD dwExStyle = 0;
4591 BOOLEAN retValue = TRUE;
4592
4593 if (bti->cbSize == sizeof(TITLEBARINFO))
4594 {
4595 RtlZeroMemory(&bti->rgstate[0],sizeof(DWORD)*(CCHILDREN_TITLEBAR+1));
4596
4597 bti->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
4598
4599 dwStyle = pWindowObject->style;
4600 dwExStyle = pWindowObject->ExStyle;
4601
4602 bti->rcTitleBar.top = 0;
4603 bti->rcTitleBar.left = 0;
4604 bti->rcTitleBar.right = pWindowObject->rcWindow.right - pWindowObject->rcWindow.left;
4605 bti->rcTitleBar.bottom = pWindowObject->rcWindow.bottom - pWindowObject->rcWindow.top;
4606
4607 /* Is it iconiced ? */
4608 if ((dwStyle & WS_ICONIC)!=WS_ICONIC)
4609 {
4610 /* Remove frame from rectangle */
4611 if (HAS_THICKFRAME( dwStyle, dwExStyle ))
4612 {
4613 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXFRAME) and UserGetSystemMetrics(SM_CYFRAME) */
4614 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME) );
4615 }
4616 else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
4617 {
4618 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXDLGFRAME) and UserGetSystemMetrics(SM_CYDLGFRAME) */
4619 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
4620 }
4621 else if (HAS_THINFRAME( dwStyle, dwExStyle))
4622 {
4623 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4624 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER) );
4625 }
4626
4627 /* We have additional border information if the window
4628 * is a child (but not an MDI child) */
4629 if ( (dwStyle & WS_CHILD) &&
4630 ((dwExStyle & WS_EX_MDICHILD) == 0 ) )
4631 {
4632 if (dwExStyle & WS_EX_CLIENTEDGE)
4633 {
4634 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXEDGE) and UserGetSystemMetrics(SM_CYEDGE) */
4635 RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
4636 }
4637
4638 if (dwExStyle & WS_EX_STATICEDGE)
4639 {
4640 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4641 RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
4642 }
4643 }
4644 }
4645
4646 bti->rcTitleBar.top += pWindowObject->rcWindow.top;
4647 bti->rcTitleBar.left += pWindowObject->rcWindow.left;
4648 bti->rcTitleBar.right += pWindowObject->rcWindow.left;
4649
4650 bti->rcTitleBar.bottom = bti->rcTitleBar.top;
4651 if (dwExStyle & WS_EX_TOOLWINDOW)
4652 {
4653 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYSMCAPTION) */
4654 bti->rcTitleBar.bottom += UserGetSystemMetrics(SM_CYSMCAPTION);
4655 }
4656 else
4657 {
4658 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYCAPTION) and UserGetSystemMetrics(SM_CXSIZE) */
4659 bti->rcTitleBar.bottom += UserGetSystemMetrics(SM_CYCAPTION);
4660 bti->rcTitleBar.left += UserGetSystemMetrics(SM_CXSIZE);
4661 }
4662
4663 if (dwStyle & WS_CAPTION)
4664 {
4665 bti->rgstate[1] = STATE_SYSTEM_INVISIBLE;
4666 if (dwStyle & WS_SYSMENU)
4667 {
4668 if (!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX)))
4669 {
4670 bti->rgstate[2] = STATE_SYSTEM_INVISIBLE;
4671 bti->rgstate[3] = STATE_SYSTEM_INVISIBLE;
4672 }
4673 else
4674 {
4675 if (!(dwStyle & WS_MINIMIZEBOX))
4676 {
4677 bti->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
4678 }
4679 if (!(dwStyle & WS_MAXIMIZEBOX))
4680 {
4681 bti->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
4682 }
4683 }
4684
4685 if (!(dwExStyle & WS_EX_CONTEXTHELP))
4686 {
4687 bti->rgstate[4] = STATE_SYSTEM_INVISIBLE;
4688 }
4689 if (pWindowObject->pcls->style & CS_NOCLOSE)
4690 {
4691 bti->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
4692 }
4693 }
4694 else
4695 {
4696 bti->rgstate[2] = STATE_SYSTEM_INVISIBLE;
4697 bti->rgstate[3] = STATE_SYSTEM_INVISIBLE;
4698 bti->rgstate[4] = STATE_SYSTEM_INVISIBLE;
4699 bti->rgstate[5] = STATE_SYSTEM_INVISIBLE;
4700 }
4701 }
4702 else
4703 {
4704 bti->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
4705 }
4706 }
4707 else
4708 {
4709 EngSetLastError(ERROR_INVALID_PARAMETER);
4710 retValue = FALSE;
4711 }
4712
4713 return retValue;
4714 }
4715
4716 DWORD FASTCALL
4717 UserInsertMenuItem(
4718 PMENU Menu,
4719 UINT uItem,
4720 BOOL fByPosition,
4721 LPCMENUITEMINFOW UnsafeItemInfo,
4722 PUNICODE_STRING lpstr)
4723 {
4724 NTSTATUS Status;
4725 ROSMENUITEMINFO ItemInfo;
4726
4727 /* Try to copy the whole MENUITEMINFOW structure */
4728 Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, sizeof(MENUITEMINFOW));
4729 if (NT_SUCCESS(Status))
4730 {
4731 if (sizeof(MENUITEMINFOW) != ItemInfo.cbSize
4732 && FIELD_OFFSET(MENUITEMINFOW, hbmpItem) != ItemInfo.cbSize)
4733 {
4734 EngSetLastError(ERROR_INVALID_PARAMETER);
4735 return FALSE;
4736 }
4737 return IntInsertMenuItem(Menu, uItem, fByPosition, &ItemInfo, lpstr);
4738 }
4739
4740 /* Try to copy without last field (not present in older versions) */
4741 Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, FIELD_OFFSET(MENUITEMINFOW, hbmpItem));
4742 if (NT_SUCCESS(Status))
4743 {
4744 if (FIELD_OFFSET(MENUITEMINFOW, hbmpItem) != ItemInfo.cbSize)
4745 {
4746 EngSetLastError(ERROR_INVALID_PARAMETER);
4747 return FALSE;
4748 }
4749 ItemInfo.hbmpItem = (HBITMAP)0;
4750 return IntInsertMenuItem(Menu, uItem, fByPosition, &ItemInfo, lpstr);
4751 }
4752
4753 SetLastNtError(Status);
4754 return FALSE;
4755 }
4756
4757 UINT FASTCALL IntGetMenuState( HMENU hMenu, UINT uId, UINT uFlags)
4758 {
4759 PMENU MenuObject;
4760 PITEM pItem;
4761
4762 if (!(MenuObject = UserGetMenuObject(hMenu)))
4763 {
4764 return (UINT)-1;
4765 }
4766
4767 if (!(pItem = MENU_FindItem( &MenuObject, &uId, uFlags ))) return -1;
4768
4769 if (pItem->spSubMenu)
4770 {
4771 return (pItem->spSubMenu->cItems << 8) | ((pItem->fState|pItem->fType|MF_POPUP) & 0xff);
4772 }
4773 else
4774 return (pItem->fType | pItem->fState);
4775 }
4776
4777 HMENU FASTCALL IntGetSubMenu( HMENU hMenu, int nPos)
4778 {
4779 PMENU MenuObject;
4780 PITEM pItem;
4781
4782 if (!(MenuObject = UserGetMenuObject(hMenu)))
4783 {
4784 return NULL;
4785 }
4786
4787 if (!(pItem = MENU_FindItem( &MenuObject, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
4788
4789 if (pItem->spSubMenu)
4790 {
4791 HMENU hsubmenu = UserHMGetHandle(pItem->spSubMenu);
4792 return hsubmenu;
4793 }
4794 return NULL;
4795 }
4796
4797 UINT FASTCALL IntFindSubMenu(HMENU *hMenu, HMENU hSubTarget )
4798 {
4799 PMENU menu, pSubTarget;
4800 UINT Pos;
4801 if (((*hMenu)==(HMENU)0xffff) ||(!(menu = UserGetMenuObject(*hMenu))))
4802 return NO_SELECTED_ITEM;
4803
4804 pSubTarget = UserGetMenuObject(hSubTarget);
4805
4806 Pos = MENU_FindSubMenu(&menu, pSubTarget );
4807
4808 *hMenu = (menu ? UserHMGetHandle(menu) : NULL);
4809
4810 return Pos;
4811 }
4812
4813
4814 HMENU FASTCALL UserCreateMenu(PDESKTOP Desktop, BOOL PopupMenu)
4815 {
4816 PWINSTATION_OBJECT WinStaObject;
4817 HANDLE Handle;
4818 PMENU Menu;
4819 NTSTATUS Status;
4820 PEPROCESS CurrentProcess = PsGetCurrentProcess();
4821
4822 if (gpepCSRSS != CurrentProcess)
4823 {
4824 /*
4825 * gpepCSRSS does not have a Win32WindowStation
4826 */
4827
4828 Status = IntValidateWindowStationHandle(CurrentProcess->Win32WindowStation,
4829 UserMode,
4830 0,
4831 &WinStaObject,
4832 0);
4833
4834 if (!NT_SUCCESS(Status))
4835 {
4836 ERR("Validation of window station handle (%p) failed\n",
4837 CurrentProcess->Win32WindowStation);
4838 SetLastNtError(Status);
4839 return (HMENU)0;
4840 }
4841 Menu = IntCreateMenu(&Handle, !PopupMenu, Desktop, GetW32ProcessInfo());
4842 if (Menu && Menu->head.rpdesk->rpwinstaParent != WinStaObject)
4843 {
4844 ERR("Desktop Window Station does not match Process one!\n");
4845 }
4846 ObDereferenceObject(WinStaObject);
4847 }
4848 else
4849 {
4850 Menu = IntCreateMenu(&Handle, !PopupMenu, GetW32ThreadInfo()->rpdesk, GetW32ProcessInfo());
4851 }
4852
4853 if (Menu) UserDereferenceObject(Menu);
4854 return (HMENU)Handle;
4855 }
4856
4857 BOOL FASTCALL
4858 IntMenuItemInfo(
4859 PMENU Menu,
4860 UINT Item,
4861 BOOL ByPosition,
4862 PROSMENUITEMINFO ItemInfo,
4863 BOOL SetOrGet,
4864 PUNICODE_STRING lpstr)
4865 {
4866 PITEM MenuItem;
4867 BOOL Ret;
4868
4869 if (!(MenuItem = MENU_FindItem( &Menu, &Item, (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND) )))
4870 {
4871 EngSetLastError(ERROR_MENU_ITEM_NOT_FOUND);
4872 return( FALSE);
4873 }
4874 if (SetOrGet)
4875 {
4876 Ret = IntSetMenuItemInfo(Menu, MenuItem, ItemInfo, lpstr);
4877 }
4878 else
4879 {
4880 Ret = IntGetMenuItemInfo(Menu, MenuItem, ItemInfo);
4881 }
4882 return( Ret);
4883 }
4884
4885 BOOL FASTCALL
4886 UserMenuItemInfo(
4887 PMENU Menu,
4888 UINT Item,
4889 BOOL ByPosition,
4890 PROSMENUITEMINFO UnsafeItemInfo,
4891 BOOL SetOrGet,
4892 PUNICODE_STRING lpstr)
4893 {
4894 PITEM MenuItem;
4895 ROSMENUITEMINFO ItemInfo;
4896 NTSTATUS Status;
4897 UINT Size;
4898 BOOL Ret;
4899
4900 Status = MmCopyFromCaller(&Size, &UnsafeItemInfo->cbSize, sizeof(UINT));
4901 if (! NT_SUCCESS(Status))
4902 {
4903 SetLastNtError(Status);
4904 return( FALSE);
4905 }
4906 if ( Size != sizeof(MENUITEMINFOW) &&
4907 Size != FIELD_OFFSET(MENUITEMINFOW, hbmpItem) &&
4908 Size != sizeof(ROSMENUITEMINFO) )
4909 {
4910 EngSetLastError(ERROR_INVALID_PARAMETER);
4911 return( FALSE);
4912 }
4913 Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, Size);
4914 if (! NT_SUCCESS(Status))
4915 {
4916 SetLastNtError(Status);
4917 return( FALSE);
4918 }
4919 /* If this is a pre-0x0500 _WIN32_WINNT MENUITEMINFOW, you can't
4920 set/get hbmpItem */
4921 if (FIELD_OFFSET(MENUITEMINFOW, hbmpItem) == Size
4922 && 0 != (ItemInfo.fMask & MIIM_BITMAP))
4923 {
4924 EngSetLastError(ERROR_INVALID_PARAMETER);
4925 return( FALSE);
4926 }
4927
4928 if (!(MenuItem = MENU_FindItem( &Menu, &Item, (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND) )))
4929 {
4930 /* workaround for Word 95: pretend that SC_TASKLIST item exists. */
4931 if ( SetOrGet && Item == SC_TASKLIST && !ByPosition )
4932 return TRUE;
4933
4934 EngSetLastError(ERROR_MENU_ITEM_NOT_FOUND);
4935 return( FALSE);
4936 }
4937
4938 if (SetOrGet)
4939 {
4940 Ret = IntSetMenuItemInfo(Menu, MenuItem, &ItemInfo, lpstr);
4941 }
4942 else
4943 {
4944 Ret = IntGetMenuItemInfo(Menu, MenuItem, &ItemInfo);
4945 if (Ret)
4946 {
4947 Status = MmCopyToCaller(UnsafeItemInfo, &ItemInfo, Size);
4948 if (! NT_SUCCESS(Status))
4949 {
4950 SetLastNtError(Status);
4951 return( FALSE);
4952 }
4953 }
4954 }
4955
4956 return( Ret);
4957 }
4958
4959 BOOL FASTCALL
4960 UserMenuInfo(
4961 PMENU Menu,
4962 PROSMENUINFO UnsafeMenuInfo,
4963 BOOL SetOrGet)
4964 {
4965 BOOL Res;
4966 DWORD Size;
4967 NTSTATUS Status;
4968 ROSMENUINFO MenuInfo;
4969
4970 Status = MmCopyFromCaller(&Size, &UnsafeMenuInfo->cbSize, sizeof(DWORD));
4971 if (! NT_SUCCESS(Status))
4972 {
4973 SetLastNtError(Status);
4974 return( FALSE);
4975 }
4976 if ( Size < sizeof(MENUINFO) || Size > sizeof(ROSMENUINFO) )
4977 {
4978 EngSetLastError(ERROR_INVALID_PARAMETER);
4979 return( FALSE);
4980 }
4981 Status = MmCopyFromCaller(&MenuInfo, UnsafeMenuInfo, Size);
4982 if (! NT_SUCCESS(Status))
4983 {
4984 SetLastNtError(Status);
4985 return( FALSE);
4986 }
4987
4988 if(SetOrGet)
4989 {
4990 /* Set MenuInfo */
4991 Res = IntSetMenuInfo(Menu, &MenuInfo);
4992 }
4993 else
4994 {
4995 /* Get MenuInfo */
4996 Res = IntGetMenuInfo(Menu, &MenuInfo);
4997 if (Res)
4998 {
4999 Status = MmCopyToCaller(UnsafeMenuInfo, &MenuInfo, Size);
5000 if (! NT_SUCCESS(Status))
5001 {
5002 SetLastNtError(Status);
5003 return( FALSE);
5004 }
5005 }
5006 }
5007
5008 return( Res);
5009 }
5010
5011 BOOL FASTCALL
5012 IntGetMenuItemRect(
5013 PWND pWnd,
5014 PMENU Menu,
5015 UINT uItem,
5016 PRECTL Rect)
5017 {
5018 LONG XMove, YMove;
5019 PITEM MenuItem;
5020 UINT I = uItem;
5021
5022 if ((MenuItem = MENU_FindItem (&Menu, &I, MF_BYPOSITION)))
5023 {
5024 Rect->left = MenuItem->xItem;
5025 Rect->top = MenuItem->yItem;
5026 Rect->right = MenuItem->cxItem; // Do this for now......
5027 Rect->bottom = MenuItem->cyItem;
5028 }
5029 else
5030 {
5031 ERR("Failed Item Lookup! %u\n", uItem);
5032 return FALSE;
5033 }
5034
5035 if (!pWnd)
5036 {
5037 HWND hWnd = Menu->hWnd;
5038 if (!(pWnd = UserGetWindowObject(hWnd))) return FALSE;
5039 }
5040
5041 if (Menu->fFlags & MNF_POPUP)
5042 {
5043 XMove = pWnd->rcClient.left;
5044 YMove = pWnd->rcClient.top;
5045 }
5046 else
5047 {
5048 XMove = pWnd->rcWindow.left;
5049 YMove = pWnd->rcWindow.top;
5050 }
5051
5052 Rect->left += XMove;
5053 Rect->top += YMove;
5054 Rect->right += XMove;
5055 Rect->bottom += YMove;
5056
5057 return TRUE;
5058 }
5059
5060 PMENU FASTCALL MENU_GetSystemMenu(PWND Window, PMENU Popup)
5061 {
5062 PMENU Menu, NewMenu = NULL, SysMenu = NULL;
5063 HMENU hSysMenu, hNewMenu = NULL;
5064 ROSMENUITEMINFO ItemInfoSet = {0};
5065 ROSMENUITEMINFO ItemInfo = {0};
5066 UNICODE_STRING MenuName;
5067
5068 hSysMenu = UserCreateMenu(Window->head.rpdesk, FALSE);
5069 if (NULL == hSysMenu)
5070 {
5071 return NULL;
5072 }
5073 SysMenu = UserGetMenuObject(hSysMenu);
5074 if (NULL == SysMenu)
5075 {
5076 UserDestroyMenu(hSysMenu);
5077 return NULL;
5078 }
5079
5080 SysMenu->fFlags |= MNF_SYSMENU;
5081 SysMenu->hWnd = UserHMGetHandle(Window);
5082
5083 if (!Popup)
5084 {
5085 //hNewMenu = co_IntLoadSysMenuTemplate();
5086 if ( Window->ExStyle & WS_EX_MDICHILD )
5087 {
5088 RtlInitUnicodeString( &MenuName, L"SYSMENUMDI");
5089 hNewMenu = co_IntCallLoadMenu( hModClient, &MenuName);
5090 }
5091 else
5092 {
5093 RtlInitUnicodeString( &MenuName, L"SYSMENU");
5094 hNewMenu = co_IntCallLoadMenu( hModClient, &MenuName);
5095 //ERR("%wZ\n",&MenuName);
5096 }
5097 if (!hNewMenu)
5098 {
5099 ERR("No Menu!!\n");
5100 IntDestroyMenuObject(SysMenu, FALSE);
5101 return NULL;
5102 }
5103 Menu = UserGetMenuObject(hNewMenu);
5104 if (!Menu)
5105 {
5106 IntDestroyMenuObject(SysMenu, FALSE);
5107 return NULL;
5108 }
5109
5110 // Do the rest in here.
5111
5112 Menu->fFlags |= MNS_CHECKORBMP | MNF_SYSMENU | MNF_POPUP;
5113
5114 ItemInfoSet.cbSize = sizeof( MENUITEMINFOW);
5115 ItemInfoSet.fMask = MIIM_BITMAP;
5116 ItemInfoSet.hbmpItem = HBMMENU_POPUP_CLOSE;
5117 IntMenuItemInfo(Menu, SC_CLOSE, FALSE, &ItemInfoSet, TRUE, NULL);
5118 ItemInfoSet.hbmpItem = HBMMENU_POPUP_RESTORE;
5119 IntMenuItemInfo(Menu, SC_RESTORE, FALSE, &ItemInfoSet, TRUE, NULL);
5120 ItemInfoSet.hbmpItem = HBMMENU_POPUP_MAXIMIZE;
5121 IntMenuItemInfo(Menu, SC_MAXIMIZE, FALSE, &ItemInfoSet, TRUE, NULL);
5122 ItemInfoSet.hbmpItem = HBMMENU_POPUP_MINIMIZE;
5123 IntMenuItemInfo(Menu, SC_MINIMIZE, FALSE, &ItemInfoSet, TRUE, NULL);
5124
5125 NewMenu = IntCloneMenu(Menu);
5126 if (NewMenu == NULL)
5127 {
5128 IntDestroyMenuObject(Menu, FALSE);
5129 IntDestroyMenuObject(SysMenu, FALSE);
5130 return NULL;
5131 }
5132
5133 IntReleaseMenuObject(NewMenu);
5134 UserSetMenuDefaultItem(NewMenu, SC_CLOSE, FALSE);
5135
5136 IntDestroyMenuObject(Menu, FALSE);
5137 }
5138 else
5139 {
5140 NewMenu = Popup;
5141 }
5142 if (NewMenu)
5143 {
5144 NewMenu->fFlags |= MNF_SYSMENU | MNF_POPUP;
5145
5146 if (Window->pcls->style & CS_NOCLOSE)
5147 IntRemoveMenuItem(NewMenu, SC_CLOSE, MF_BYCOMMAND, TRUE);
5148
5149 ItemInfo.cbSize = sizeof(MENUITEMINFOW);
5150 ItemInfo.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_SUBMENU;
5151 ItemInfo.fType = MF_POPUP;
5152 ItemInfo.fState = MFS_ENABLED;
5153 ItemInfo.dwTypeData = NULL;
5154 ItemInfo.cch = 0;
5155 ItemInfo.hSubMenu = UserHMGetHandle(NewMenu);
5156 IntInsertMenuItem(SysMenu, (UINT) -1, TRUE, &ItemInfo, NULL);
5157
5158 return SysMenu;
5159 }
5160 ERR("failed to load system menu!\n");
5161 return NULL;
5162 }
5163
5164 PMENU FASTCALL
5165 IntGetSystemMenu(PWND Window, BOOL bRevert)
5166 {
5167 PMENU Menu;
5168
5169 if (bRevert)
5170 {
5171 if (Window->SystemMenu)
5172 {
5173 Menu = UserGetMenuObject(Window->SystemMenu);
5174 if (Menu && !(Menu->fFlags & MNF_SYSDESKMN))
5175 {
5176 IntDestroyMenuObject(Menu, TRUE);
5177 Window->SystemMenu = NULL;
5178 }
5179 }
5180 }
5181 else
5182 {
5183 Menu = Window->SystemMenu ? UserGetMenuObject(Window->SystemMenu) : NULL;
5184 if ((!Window->SystemMenu || Menu->fFlags & MNF_SYSDESKMN) && Window->style & WS_SYSMENU)
5185 {
5186 Menu = MENU_GetSystemMenu(Window, NULL);
5187 Window->SystemMenu = Menu ? UserHMGetHandle(Menu) : NULL;
5188 }
5189 }
5190
5191 if (Window->SystemMenu)
5192 {
5193 HMENU hMenu = IntGetSubMenu( Window->SystemMenu, 0);
5194 /* Store the dummy sysmenu handle to facilitate the refresh */
5195 /* of the close button if the SC_CLOSE item change */
5196 Menu = UserGetMenuObject(hMenu);
5197 if (Menu)
5198 {
5199 Menu->spwndNotify = Window;
5200 Menu->fFlags |= MNF_SYSSUBMENU;
5201 }
5202 return Menu;
5203 }
5204 return NULL;
5205 }
5206
5207 BOOL FASTCALL
5208 IntSetSystemMenu(PWND Window, PMENU Menu)
5209 {
5210 PMENU OldMenu;
5211
5212 if (!(Window->style & WS_SYSMENU)) return FALSE;
5213
5214 if (Window->SystemMenu)
5215 {
5216 OldMenu = UserGetMenuObject(Window->SystemMenu);
5217 if (OldMenu)
5218 {
5219 OldMenu->fFlags &= ~MNF_SYSMENU;
5220 IntDestroyMenuObject(OldMenu, TRUE);
5221 }
5222 }
5223
5224 OldMenu = MENU_GetSystemMenu(Window, Menu);
5225 if (OldMenu)
5226 { // Use spmenuSys too!
5227 Window->SystemMenu = UserHMGetHandle(OldMenu);
5228 }
5229 else
5230 Window->SystemMenu = NULL;
5231
5232 if (Menu && Window != Menu->spwndNotify)
5233 {
5234 Menu->spwndNotify = Window;
5235 }
5236
5237 return TRUE;
5238 }
5239
5240 BOOL FASTCALL
5241 IntSetMenu(
5242 PWND Wnd,
5243 HMENU Menu,
5244 BOOL *Changed)
5245 {
5246 PMENU OldMenu, NewMenu = NULL;
5247
5248 if ((Wnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
5249 {
5250 ERR("SetMenu: Window is a Child 0x%p!\n",UserHMGetHandle(Wnd));
5251 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
5252 return FALSE;
5253 }
5254
5255 *Changed = (UlongToHandle(Wnd->IDMenu) != Menu);
5256 if (! *Changed)
5257 {
5258 return TRUE;
5259 }
5260
5261 if (Wnd->IDMenu)
5262 {
5263 OldMenu = IntGetMenuObject(UlongToHandle(Wnd->IDMenu));
5264 ASSERT(NULL == OldMenu || OldMenu->hWnd == UserHMGetHandle(Wnd));
5265 }
5266 else
5267 {
5268 OldMenu = NULL;
5269 }
5270
5271 if (NULL != Menu)
5272 {
5273 NewMenu = IntGetMenuObject(Menu);
5274 if (NULL == NewMenu)
5275 {
5276 if (NULL != OldMenu)
5277 {
5278 IntReleaseMenuObject(OldMenu);
5279 }
5280 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
5281 return FALSE;
5282 }
5283 if (NULL != NewMenu->hWnd)
5284 {
5285 /* Can't use the same menu for two windows */
5286 if (NULL != OldMenu)
5287 {
5288 IntReleaseMenuObject(OldMenu);
5289 }
5290 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
5291 return FALSE;
5292 }
5293
5294 }
5295
5296 Wnd->IDMenu = (UINT_PTR) Menu;
5297 if (NULL != NewMenu)
5298 {
5299 NewMenu->hWnd = UserHMGetHandle(Wnd);
5300 IntReleaseMenuObject(NewMenu);
5301 }
5302 if (NULL != OldMenu)
5303 {
5304 OldMenu->hWnd = NULL;
5305 IntReleaseMenuObject(OldMenu);
5306 }
5307
5308 return TRUE;
5309 }
5310
5311
5312 /* FUNCTIONS *****************************************************************/
5313
5314 /*
5315 * @implemented
5316 */
5317 /* http://www.cyber-ta.org/releases/malware-analysis/public/SOURCES/b47155634ccb2c30630da7e3666d3d07/b47155634ccb2c30630da7e3666d3d07.trace.html#NtUserGetIconSize */
5318 DWORD
5319 APIENTRY
5320 NtUserCalcMenuBar(
5321 HWND hwnd,
5322 DWORD leftBorder,
5323 DWORD rightBorder,
5324 DWORD top,
5325 LPRECT prc )
5326 {
5327 HDC hdc;
5328 PWND Window;
5329 RECT Rect;
5330 DWORD ret;
5331
5332 UserEnterExclusive();
5333
5334 if(!(Window = UserGetWindowObject(hwnd)))
5335 {
5336 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
5337 UserLeave();
5338 return 0;
5339 }
5340
5341 hdc = UserGetDCEx(NULL, NULL, DCX_CACHE);
5342 if (!hdc)
5343 {
5344 UserLeave();
5345 return 0;
5346 }
5347
5348 Rect.left = leftBorder;
5349 Rect.right = Window->rcWindow.right - Window->rcWindow.left - rightBorder;
5350 Rect.top = top;
5351 Rect.bottom = 0;
5352
5353 ret = MENU_DrawMenuBar(hdc, &Rect, Window, TRUE);
5354
5355 UserReleaseDC( 0, hdc, FALSE );
5356
5357 UserLeave();
5358
5359 return ret;
5360 }
5361
5362 /*
5363 * @implemented
5364 */
5365 DWORD APIENTRY
5366 NtUserCheckMenuItem(
5367 HMENU hMenu,
5368 UINT uIDCheckItem,
5369 UINT uCheck)
5370 {
5371 PMENU Menu;
5372 DECLARE_RETURN(DWORD);
5373
5374 TRACE("Enter NtUserCheckMenuItem\n");
5375 UserEnterExclusive();
5376
5377 if(!(Menu = UserGetMenuObject(hMenu)))
5378 {
5379 RETURN( (DWORD)-1);
5380 }
5381
5382 RETURN( IntCheckMenuItem(Menu, uIDCheckItem, uCheck));
5383
5384 CLEANUP:
5385 TRACE("Leave NtUserCheckMenuItem, ret=%lu\n",_ret_);
5386 UserLeave();
5387 END_CLEANUP;
5388 }
5389
5390 /*
5391 * @implemented
5392 */
5393 BOOL APIENTRY
5394 NtUserDeleteMenu(
5395 HMENU hMenu,
5396 UINT uPosition,
5397 UINT uFlags)
5398 {
5399 PMENU Menu;
5400 DECLARE_RETURN(BOOL);
5401
5402 TRACE("Enter NtUserDeleteMenu\n");
5403 UserEnterExclusive();
5404
5405 if(!(Menu = UserGetMenuObject(hMenu)))
5406 {
5407 RETURN( FALSE);
5408 }
5409
5410 RETURN( IntRemoveMenuItem(Menu, uPosition, uFlags, TRUE));
5411
5412 CLEANUP:
5413 TRACE("Leave NtUserDeleteMenu, ret=%i\n",_ret_);
5414 UserLeave();
5415 END_CLEANUP;
5416 }
5417
5418 /*
5419 * NtUserGetSystemMenu
5420 *
5421 * The NtUserGetSystemMenu function allows the application to access the
5422 * window menu (also known as the system menu or the control menu) for
5423 * copying and modifying.
5424 *
5425 * Parameters
5426 * hWnd
5427 * Handle to the window that will own a copy of the window menu.
5428 * bRevert
5429 * Specifies the action to be taken. If this parameter is FALSE,
5430 * NtUserGetSystemMenu returns a handle to the copy of the window menu
5431 * currently in use. The copy is initially identical to the window menu
5432 * but it can be modified.
5433 * If this parameter is TRUE, GetSystemMenu resets the window menu back
5434 * to the default state. The previous window menu, if any, is destroyed.
5435 *
5436 * Return Value
5437 * If the bRevert parameter is FALSE, the return value is a handle to a
5438 * copy of the window menu. If the bRevert parameter is TRUE, the return
5439 * value is NULL.
5440 *
5441 * Status
5442 * @implemented
5443 */
5444
5445 HMENU APIENTRY
5446 NtUserGetSystemMenu(HWND hWnd, BOOL bRevert)
5447 {
5448 PWND Window;
5449 PMENU Menu;
5450 DECLARE_RETURN(HMENU);
5451
5452 TRACE("Enter NtUserGetSystemMenu\n");
5453 UserEnterShared();
5454
5455 if (!(Window = UserGetWindowObject(hWnd)))
5456 {
5457 RETURN(NULL);
5458 }
5459
5460 if (!(Menu = IntGetSystemMenu(Window, bRevert)))
5461 {
5462 RETURN(NULL);
5463 }
5464
5465 RETURN(Menu->head.h);
5466
5467 CLEANUP:
5468 TRACE("Leave NtUserGetSystemMenu, ret=%p\n", _ret_);
5469 UserLeave();
5470 END_CLEANUP;
5471 }
5472
5473 /*
5474 * NtUserSetSystemMenu
5475 *
5476 * Status
5477 * @implemented
5478 */
5479
5480 BOOL APIENTRY
5481 NtUserSetSystemMenu(HWND hWnd, HMENU hMenu)
5482 {
5483 BOOL Result = FALSE;
5484 PWND Window;
5485 PMENU Menu;
5486 DECLARE_RETURN(BOOL);
5487
5488 TRACE("Enter NtUserSetSystemMenu\n");
5489 UserEnterExclusive();
5490
5491 if (!(Window = UserGetWindowObject(hWnd)))
5492 {
5493 RETURN( FALSE);
5494 }
5495
5496 if (hMenu)
5497 {
5498 /*
5499 * Assign new menu handle and Up the Lock Count.
5500 */
5501 if (!(Menu = IntGetMenuObject(hMenu)))
5502 {
5503 RETURN( FALSE);
5504 }
5505
5506 Result = IntSetSystemMenu(Window, Menu);
5507 }
5508 else
5509 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
5510
5511 RETURN( Result);
5512
5513 CLEANUP:
5514 TRACE("Leave NtUserSetSystemMenu, ret=%i\n",_ret_);
5515 UserLeave();
5516 END_CLEANUP;
5517 }
5518
5519 /*
5520 * @implemented
5521 */
5522 BOOLEAN APIENTRY
5523 NtUserGetTitleBarInfo(
5524 HWND hwnd,
5525 PTITLEBARINFO bti)
5526 {
5527 PWND WindowObject;
5528 TITLEBARINFO bartitleinfo;
5529 DECLARE_RETURN(BOOLEAN);
5530 BOOLEAN retValue = TRUE;
5531
5532 TRACE("Enter NtUserGetTitleBarInfo\n");
5533 UserEnterExclusive();
5534
5535 /* Vaildate the windows handle */
5536 if (!(WindowObject = UserGetWindowObject(hwnd)))
5537 {
5538 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
5539 retValue = FALSE;
5540 }
5541
5542 _SEH2_TRY
5543 {
5544 /* Copy our usermode buffer bti to local buffer bartitleinfo */
5545 ProbeForRead(bti, sizeof(TITLEBARINFO), 1);
5546 RtlCopyMemory(&bartitleinfo, bti, sizeof(TITLEBARINFO));
5547 }
5548 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
5549 {
5550 /* Fail copy the data */
5551 EngSetLastError(ERROR_INVALID_PARAMETER);
5552 retValue = FALSE;
5553 }
5554 _SEH2_END
5555
5556 /* Get the tile bar info */
5557 if (retValue)
5558 {
5559 retValue = intGetTitleBarInfo(WindowObject, &bartitleinfo);
5560 if (retValue)
5561 {
5562 _SEH2_TRY
5563 {
5564 /* Copy our buffer to user mode buffer bti */
5565 ProbeForWrite(bti, sizeof(TITLEBARINFO), 1);
5566 RtlCopyMemory(bti, &bartitleinfo, sizeof(TITLEBARINFO));
5567 }
5568 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
5569 {
5570 /* Fail copy the data */
5571 EngSetLastError(ERROR_INVALID_PARAMETER);
5572 retValue = FALSE;
5573 }
5574 _SEH2_END
5575 }
5576 }
5577
5578 RETURN( retValue );
5579
5580 CLEANUP:
5581 TRACE("Leave NtUserGetTitleBarInfo, ret=%u\n",_ret_);
5582 UserLeave();
5583 END_CLEANUP;
5584 }
5585
5586 /*
5587 * @implemented
5588 */
5589 BOOL FASTCALL UserDestroyMenu(HMENU hMenu)
5590 {
5591 PMENU Menu;
5592 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
5593
5594 if(!(Menu = UserGetMenuObject(hMenu)))
5595 {
5596 return FALSE;
5597 }
5598
5599 if (Menu->head.rpdesk != pti->rpdesk)
5600 {
5601 EngSetLastError(ERROR_ACCESS_DENIED);
5602 return FALSE;
5603 }
5604 return IntDestroyMenuObject(Menu, FALSE);
5605 }
5606
5607 /*
5608 * @implemented
5609 */
5610 BOOL APIENTRY
5611 NtUserDestroyMenu(
5612 HMENU hMenu)
5613 {
5614 PMENU Menu;
5615 DECLARE_RETURN(BOOL);
5616
5617 TRACE("Enter NtUserDestroyMenu\n");
5618 UserEnterExclusive();
5619
5620 if(!(Menu = UserGetMenuObject(hMenu)))
5621 {
5622 RETURN( FALSE);
5623 }
5624 if (Menu->head.rpdesk != gptiCurrent->rpdesk)
5625 {
5626 EngSetLastError(ERROR_ACCESS_DENIED);
5627 RETURN( FALSE);
5628 }
5629 RETURN( IntDestroyMenuObject(Menu, TRUE));
5630
5631 CLEANUP:
5632 TRACE("Leave NtUserDestroyMenu, ret=%i\n",_ret_);
5633 UserLeave();
5634 END_CLEANUP;
5635 }
5636
5637 /*
5638 * @implemented
5639 */
5640 UINT APIENTRY
5641 NtUserEnableMenuItem(
5642 HMENU hMenu,
5643 UINT uIDEnableItem,
5644 UINT uEnable)
5645 {
5646 PMENU Menu;
5647 DECLARE_RETURN(UINT);
5648
5649 TRACE("Enter NtUserEnableMenuItem\n");
5650 UserEnterExclusive();
5651
5652 if(!(Menu = UserGetMenuObject(hMenu)))
5653 {
5654 RETURN(-1);
5655 }
5656
5657 RETURN( IntEnableMenuItem(Menu, uIDEnableItem, uEnable));
5658
5659 CLEANUP:
5660 TRACE("Leave NtUserEnableMenuItem, ret=%u\n",_ret_);
5661 UserLeave();
5662 END_CLEANUP;
5663 }
5664
5665 /*
5666 * @implemented
5667 */
5668 BOOL APIENTRY
5669 NtUserEndMenu(VOID)
5670 {
5671 //PWND pWnd;
5672 TRACE("Enter NtUserEndMenu\n");
5673 UserEnterExclusive();
5674 /* if ( gptiCurrent->pMenuState &&
5675 gptiCurrent->pMenuState->pGlobalPopupMenu )
5676 {
5677 pWnd = IntGetMSWND(gptiCurrent->pMenuState);
5678 if (pWnd)
5679 {
5680 UserPostMessage( UserHMGetHandle(pWnd), WM_CANCELMODE, 0, 0);
5681 }
5682 else
5683 gptiCurrent->pMenuState->fInsideMenuLoop = FALSE;
5684 }*/
5685 if (fInsideMenuLoop && top_popup)
5686 {
5687 fInsideMenuLoop = FALSE;
5688 UserPostMessage( top_popup, WM_CANCELMODE, 0, 0);
5689 }
5690 UserLeave();
5691 TRACE("Leave NtUserEndMenu\n");
5692 return TRUE;
5693 }
5694
5695 /*
5696 * @implemented
5697 */
5698 BOOL APIENTRY
5699 NtUserGetMenuBarInfo(
5700 HWND hwnd,
5701 LONG idObject,
5702 LONG idItem,
5703 PMENUBARINFO pmbi)
5704 {
5705 PWND pWnd;
5706 HMENU hMenu;
5707 MENUBARINFO kmbi;
5708 BOOL Ret;
5709 PPOPUPMENU pPopupMenu;
5710 USER_REFERENCE_ENTRY Ref;
5711 NTSTATUS Status = STATUS_SUCCESS;
5712 PMENU Menu = NULL;
5713 DECLARE_RETURN(BOOL);
5714
5715 TRACE("Enter NtUserGetMenuBarInfo\n");
5716 UserEnterShared();
5717
5718 if (!(pWnd = UserGetWindowObject(hwnd)))
5719 {
5720 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
5721 RETURN(FALSE);
5722 }
5723
5724 UserRefObjectCo(pWnd, &Ref);
5725
5726 RECTL_vSetEmptyRect(&kmbi.rcBar);
5727 kmbi.hMenu = NULL;
5728 kmbi.hwndMenu = NULL;
5729 kmbi.fBarFocused = FALSE;
5730 kmbi.fFocused = FALSE;
5731
5732 switch (idObject)
5733 {
5734 case OBJID_CLIENT:
5735 if (!pWnd->pcls->fnid)
5736 RETURN(FALSE);
5737 if (pWnd->pcls->fnid != FNID_MENU)
5738 {
5739 WARN("called on invalid window: %u\n", pWnd->pcls->fnid);
5740 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
5741 RETURN(FALSE);
5742 }
5743 // Windows does this! Wine checks for Atom and uses GetWindowLongPtrW.
5744 hMenu = (HMENU)co_IntSendMessage(hwnd, MN_GETHMENU, 0, 0);
5745 pPopupMenu = ((PMENUWND)pWnd)->ppopupmenu;
5746 if (pPopupMenu && pPopupMenu->spmenu)
5747 {
5748 if (UserHMGetHandle(pPopupMenu->spmenu) != hMenu)
5749 {
5750 ERR("Window Pop Up hMenu %p not the same as Get hMenu %p!\n",pPopupMenu->spmenu->head.h,hMenu);
5751 }
5752 }
5753 break;
5754 case OBJID_MENU:
5755 if (pWnd->style & WS_CHILD) RETURN(FALSE);
5756 hMenu = UlongToHandle(pWnd->IDMenu);
5757 TRACE("GMBI: OBJID_MENU hMenu %p\n",hMenu);
5758 break;
5759 case OBJID_SYSMENU:
5760 if (!(pWnd->style & WS_SYSMENU)) RETURN(FALSE);
5761 Menu = IntGetSystemMenu(pWnd, FALSE);
5762 hMenu = UserHMGetHandle(Menu);
5763 break;
5764 default:
5765 RETURN(FALSE);
5766 }
5767
5768 if (!hMenu)
5769 RETURN(FALSE);
5770
5771 _SEH2_TRY
5772 {
5773 ProbeForRead(pmbi, sizeof(MENUBARINFO), 1);
5774 kmbi.cbSize = pmbi->cbSize;
5775 }
5776 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
5777 {
5778 kmbi.cbSize = 0;
5779 }
5780 _SEH2_END
5781
5782 if (kmbi.cbSize != sizeof(MENUBARINFO))
5783 {
5784 EngSetLastError(ERROR_INVALID_PARAMETER);
5785 RETURN(FALSE);
5786 }
5787
5788 if (!Menu) Menu = UserGetMenuObject(hMenu);
5789 if (!Menu)
5790 RETURN(FALSE);
5791
5792 if ((idItem < 0) || ((ULONG)idItem > Menu->cItems))
5793 RETURN(FALSE);
5794
5795 if (idItem == 0)
5796 {
5797 Ret = IntGetMenuItemRect(pWnd, Menu, 0, &kmbi.rcBar);
5798 kmbi.rcBar.right = kmbi.rcBar.left + Menu->cxMenu;
5799 kmbi.rcBar.bottom = kmbi.rcBar.top + Menu->cyMenu;
5800 TRACE("idItem a 0 %d\n",Ret);
5801 }
5802 else
5803 {
5804 Ret = IntGetMenuItemRect(pWnd, Menu, idItem-1, &kmbi.rcBar);
5805 TRACE("idItem b %d %d\n", idItem-1, Ret);
5806 }
5807
5808 kmbi.hMenu = hMenu;
5809 kmbi.fBarFocused = top_popup_hmenu == hMenu;
5810 TRACE("GMBI: top p hm %p hMenu %p\n",top_popup_hmenu, hMenu);
5811 if (idItem)
5812 {
5813 kmbi.fFocused = Menu->iItem == idItem-1;
5814 if (kmbi.fFocused && (Menu->rgItems[idItem - 1].spSubMenu))
5815 {
5816 kmbi.hwndMenu = Menu->rgItems[idItem - 1].spSubMenu->hWnd;
5817 }
5818 }
5819 else
5820 {
5821 kmbi.fFocused = kmbi.fBarFocused;
5822 }
5823
5824 _SEH2_TRY
5825 {
5826 ProbeForWrite(pmbi, sizeof(MENUBARINFO), 1);
5827 RtlCopyMemory(pmbi, &kmbi, sizeof(MENUBARINFO));
5828 }
5829 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
5830 {
5831 Status = _SEH2_GetExceptionCode();
5832 }
5833 _SEH2_END
5834
5835 if (!NT_SUCCESS(Status))
5836 {
5837 SetLastNtError(Status);
5838 RETURN(FALSE);
5839 }
5840
5841 RETURN(TRUE);
5842
5843 CLEANUP:
5844 if (pWnd) UserDerefObjectCo(pWnd);
5845 TRACE("Leave NtUserGetMenuBarInfo, ret=%i\n",_ret_);
5846 UserLeave();
5847 END_CLEANUP;
5848 }
5849
5850 /*
5851 * @implemented
5852 */
5853 UINT APIENTRY
5854 NtUserGetMenuIndex(
5855 HMENU hMenu,
5856 HMENU hSubMenu)
5857 {
5858 PMENU Menu, SubMenu;
5859 PITEM MenuItem;
5860 UINT i;
5861 DECLARE_RETURN(UINT);
5862
5863 TRACE("Enter NtUserGetMenuIndex\n");
5864 UserEnterShared();
5865
5866 if ( !(Menu = UserGetMenuObject(hMenu)) ||
5867 !(SubMenu = UserGetMenuObject(hSubMenu)) )
5868 RETURN(0xFFFFFFFF);
5869
5870 MenuItem = Menu->rgItems;
5871 for (i = 0; i < Menu->cItems; i++, MenuItem++)
5872 {
5873 if (MenuItem->spSubMenu == SubMenu)
5874 RETURN(MenuItem->wID);
5875 }
5876 RETURN(0xFFFFFFFF);
5877
5878 CLEANUP:
5879 TRACE("Leave NtUserGetMenuIndex, ret=%u\n",_ret_);
5880 UserLeave();
5881 END_CLEANUP;
5882 }
5883
5884 /*
5885 * @implemented
5886 */
5887 BOOL APIENTRY
5888 NtUserGetMenuItemRect(
5889 HWND hWnd,
5890 HMENU hMenu,
5891 UINT uItem,
5892 PRECTL lprcItem)
5893 {
5894 PWND ReferenceWnd;
5895 LONG XMove, YMove;
5896 RECTL Rect;
5897 PMENU Menu;
5898 PITEM MenuItem;
5899 NTSTATUS Status = STATUS_SUCCESS;
5900 DECLARE_RETURN(BOOL);
5901
5902 TRACE("Enter NtUserGetMenuItemRect\n");
5903 UserEnterShared();
5904
5905 if (!(Menu = UserGetMenuObject(hMenu)))
5906 {
5907 RETURN(FALSE);
5908 }
5909
5910 if ((MenuItem = MENU_FindItem (&Menu, &uItem, MF_BYPOSITION)))
5911 {
5912 Rect.left = MenuItem->xItem;
5913 Rect.top = MenuItem->yItem;
5914 Rect.right = MenuItem->cxItem; // Do this for now......
5915 Rect.bottom = MenuItem->cyItem;
5916 }
5917 else
5918 RETURN(FALSE);
5919
5920 if(!hWnd)
5921 {
5922 hWnd = Menu->hWnd;
5923 }
5924
5925 if (lprcItem == NULL) RETURN( FALSE);
5926
5927 if (!(ReferenceWnd = UserGetWindowObject(hWnd))) RETURN( FALSE);
5928
5929 if (Menu->fFlags & MNF_POPUP)
5930 {
5931 XMove = ReferenceWnd->rcClient.left;
5932 YMove = ReferenceWnd->rcClient.top;
5933 }
5934 else
5935 {
5936 XMove = ReferenceWnd->rcWindow.left;
5937 YMove = ReferenceWnd->rcWindow.top;
5938 }
5939
5940 Rect.left += XMove;
5941 Rect.top += YMove;
5942 Rect.right += XMove;
5943 Rect.bottom += YMove;
5944
5945 _SEH2_TRY
5946 {
5947 RtlCopyMemory(lprcItem, &Rect, sizeof(RECTL));
5948 }
5949 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
5950 {
5951 Status = _SEH2_GetExceptionCode();
5952 }
5953 _SEH2_END
5954
5955 if (!NT_SUCCESS(Status))
5956 {
5957 SetLastNtError(Status);
5958 RETURN(FALSE);
5959 }
5960 RETURN(TRUE);
5961
5962 CLEANUP:
5963 TRACE("Leave NtUserGetMenuItemRect, ret=%i\n",_ret_);
5964 UserLeave();
5965 END_CLEANUP;
5966 }
5967
5968 /*
5969 * @implemented
5970 */
5971 BOOL APIENTRY
5972 NtUserHiliteMenuItem(
5973 HWND hWnd,
5974 HMENU hMenu,
5975 UINT uItemHilite,
5976 UINT uHilite)
5977 {
5978 PMENU Menu;
5979 PWND Window;
5980 DECLARE_RETURN(BOOLEAN);
5981
5982 TRACE("Enter NtUserHiliteMenuItem\n");
5983 UserEnterExclusive();
5984
5985 if(!(Window = UserGetWindowObject(hWnd)))
5986 {
5987 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
5988 RETURN(FALSE);
5989 }
5990
5991 if(!(Menu = UserGetMenuObject(hMenu)))
5992 {
5993 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
5994 RETURN(FALSE);
5995 }
5996
5997 RETURN( IntHiliteMenuItem(Window, Menu, uItemHilite, uHilite));
5998
5999 CLEANUP:
6000 TRACE("Leave NtUserHiliteMenuItem, ret=%u\n",_ret_);
6001 UserLeave();
6002 END_CLEANUP;
6003 }
6004
6005 /*
6006 * @implemented
6007 */
6008 DWORD
6009 APIENTRY
6010 NtUserDrawMenuBarTemp(
6011 HWND hWnd,
6012 HDC hDC,
6013 PRECT pRect,
6014 HMENU hMenu,
6015 HFONT hFont)
6016 {
6017 PMENU Menu;
6018 PWND Window;
6019 RECT Rect;
6020 NTSTATUS Status = STATUS_SUCCESS;
6021 DECLARE_RETURN(DWORD);
6022
6023 ERR("Enter NtUserDrawMenuBarTemp\n");
6024 UserEnterExclusive();
6025
6026 if(!(Window = UserGetWindowObject(hWnd)))
6027 {
6028 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
6029 RETURN(0);
6030 }
6031
6032 if(!(Menu = UserGetMenuObject(hMenu)))
6033 {
6034 EngSetLastError(ERROR_INVALID_MENU_HANDLE);
6035 RETURN(0);
6036 }
6037
6038 _SEH2_TRY
6039 {
6040 ProbeForRead(pRect, sizeof(RECT), sizeof(ULONG));
6041 RtlCopyMemory(&Rect, pRect, sizeof(RECT));
6042 }
6043 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
6044 {
6045 Status = _SEH2_GetExceptionCode();
6046 }
6047 _SEH2_END;
6048
6049 if (Status != STATUS_SUCCESS)
6050 {
6051 SetLastNtError(Status);
6052 RETURN(0);
6053 }
6054
6055 RETURN( IntDrawMenuBarTemp(Window, hDC, &Rect, Menu, hFont));
6056
6057 CLEANUP:
6058 ERR("Leave NtUserDrawMenuBarTemp, ret=%u\n",_ret_);
6059 UserLeave();
6060 END_CLEANUP;
6061 }
6062
6063 /*
6064 * @implemented
6065 */
6066 int APIENTRY
6067 NtUserMenuItemFromPoint(
6068 HWND hWnd,
6069 HMENU hMenu,
6070 DWORD X,
6071 DWORD Y)
6072 {
6073 PMENU Menu;
6074 PWND Window = NULL;
6075 PITEM mi;
6076 ULONG i;
6077 DECLARE_RETURN(int);
6078
6079 TRACE("Enter NtUserMenuItemFromPoint\n");
6080 UserEnterExclusive();
6081
6082 if (!(Menu = UserGetMenuObject(hMenu)))
6083 {
6084 RETURN( -1);
6085 }
6086
6087 if (!(Window = UserGetWindowObject(Menu->hWnd)))
6088 {
6089 RETURN( -1);
6090 }
6091
6092 X -= Window->rcWindow.left;
6093 Y -= Window->rcWindow.top;
6094
6095 mi = Menu->rgItems;
6096 for (i = 0; i < Menu->cItems; i++, mi++)
6097 {
6098 RECTL Rect;
6099
6100 Rect.left = mi->xItem;
6101 Rect.top = mi->yItem;
6102 Rect.right = mi->cxItem;
6103 Rect.bottom = mi->cyItem;
6104
6105 MENU_AdjustMenuItemRect(Menu, &Rect);
6106
6107 if (RECTL_bPointInRect(&Rect, X, Y))
6108 {
6109 break;
6110 }
6111 }
6112
6113 RETURN( (mi ? i : NO_SELECTED_ITEM));
6114
6115 CLEANUP:
6116 TRACE("Leave NtUserMenuItemFromPoint, ret=%i\n",_ret_);
6117 UserLeave();
6118 END_CLEANUP;
6119 }
6120
6121
6122 DWORD
6123 APIENTRY
6124 NtUserPaintMenuBar(
6125 HWND hWnd,
6126 HDC hDC,
6127 ULONG leftBorder,
6128 ULONG rightBorder,
6129 ULONG top,
6130 BOOL bActive)
6131 {
6132 PWND Window;
6133 RECT Rect;
6134 DWORD ret;
6135
6136 UserEnterExclusive();
6137
6138 if(!(Window = UserGetWindowObject(hWnd)))
6139 {
6140 EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
6141 UserLeave();
6142 return 0;
6143 }
6144
6145 Rect.left = leftBorder;
6146 Rect.right = Window->rcWindow.right - Window->rcWindow.left - rightBorder;
6147 Rect.top = top;
6148 Rect.bottom = 0;
6149
6150 ret = MENU_DrawMenuBar(hDC, &Rect, Window, FALSE);
6151
6152 UserLeave();
6153
6154 return ret;
6155 }
6156
6157 /*
6158 * @implemented
6159 */
6160 BOOL APIENTRY
6161 NtUserRemoveMenu(
6162 HMENU hMenu,
6163 UINT uPosition,
6164 UINT uFlags)
6165 {
6166 PMENU Menu;
6167 DECLARE_RETURN(BOOL);
6168
6169 TRACE("Enter NtUserRemoveMenu\n");
6170 UserEnterExclusive();
6171
6172 if(!(Menu = UserGetMenuObject(hMenu)))
6173 {
6174 RETURN( FALSE);
6175 }
6176
6177 RETURN(IntRemoveMenuItem(Menu, uPosition, uFlags, FALSE));
6178
6179 CLEANUP:
6180 TRACE("Leave NtUserRemoveMenu, ret=%i\n",_ret_);
6181 UserLeave();
6182 END_CLEANUP;
6183
6184 }
6185
6186 /*
6187 * @implemented
6188 */
6189 BOOL APIENTRY
6190 NtUserSetMenu(
6191 HWND hWnd,
6192 HMENU Menu,
6193 BOOL Repaint)
6194 {
6195 PWND Window;
6196 BOOL Changed;
6197 DECLARE_RETURN(BOOL);
6198
6199 TRACE("Enter NtUserSetMenu\n");
6200 UserEnterExclusive();
6201
6202 if (!(Window = UserGetWindowObject(hWnd)))
6203 {
6204 RETURN( FALSE);
6205 }
6206
6207 if (!IntSetMenu(Window, Menu, &Changed))
6208 {
6209 RETURN( FALSE);
6210 }
6211
6212 // Not minimized and please repaint!!!
6213 if (!(Window->style & WS_MINIMIZE) && (Repaint || Changed))
6214 {
6215 USER_REFERENCE_ENTRY Ref;
6216 UserRefObjectCo(Window, &Ref);
6217 co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
6218 UserDerefObjectCo(Window);
6219 }
6220
6221 RETURN( TRUE);
6222
6223 CLEANUP:
6224 TRACE("Leave NtUserSetMenu, ret=%i\n",_ret_);
6225 UserLeave();
6226 END_CLEANUP;
6227 }
6228
6229 /*
6230 * @implemented
6231 */
6232 BOOL APIENTRY
6233 NtUserSetMenuContextHelpId(
6234 HMENU hMenu,
6235 DWORD dwContextHelpId)
6236 {
6237 PMENU Menu;
6238 DECLARE_RETURN(BOOL);
6239
6240 TRACE("Enter NtUserSetMenuContextHelpId\n");
6241 UserEnterExclusive();
6242
6243 if(!(Menu = UserGetMenuObject(hMenu)))
6244 {
6245 RETURN( FALSE);
6246 }
6247
6248 RETURN(IntSetMenuContextHelpId(Menu, dwContextHelpId));
6249
6250 CLEANUP:
6251 TRACE("Leave NtUserSetMenuContextHelpId, ret=%i\n",_ret_);
6252 UserLeave();
6253 END_CLEANUP;
6254 }
6255
6256 /*
6257 * @implemented
6258 */
6259 BOOL APIENTRY
6260 NtUserSetMenuDefaultItem(
6261 HMENU hMenu,
6262 UINT uItem,
6263 UINT fByPos)
6264 {
6265 PMENU Menu;
6266 DECLARE_RETURN(BOOL);
6267
6268 TRACE("Enter NtUserSetMenuDefaultItem\n");
6269 UserEnterExclusive();
6270
6271 if(!(Menu = UserGetMenuObject(hMenu)))
6272 {
6273 RETURN( FALSE);
6274 }
6275
6276 RETURN( UserSetMenuDefaultItem(Menu, uItem, fByPos));
6277
6278 CLEANUP:
6279 TRACE("Leave NtUserSetMenuDefaultItem, ret=%i\n",_ret_);
6280 UserLeave();
6281 END_CLEANUP;
6282 }
6283
6284 /*
6285 * @implemented
6286 */
6287 BOOL APIENTRY
6288 NtUserSetMenuFlagRtoL(
6289 HMENU hMenu)
6290 {
6291 PMENU Menu;
6292 DECLARE_RETURN(BOOL);
6293
6294 TRACE("Enter NtUserSetMenuFlagRtoL\n");
6295 UserEnterExclusive();
6296
6297 if(!(Menu = UserGetMenuObject(hMenu)))
6298 {
6299 RETURN( FALSE);
6300 }
6301
6302 RETURN(IntSetMenuFlagRtoL(Menu));
6303
6304 CLEANUP:
6305 TRACE("Leave NtUserSetMenuFlagRtoL, ret=%i\n",_ret_);
6306 UserLeave();
6307 END_CLEANUP;
6308 }
6309
6310 /*
6311 * @implemented
6312 */
6313 BOOL APIENTRY
6314 NtUserThunkedMenuInfo(
6315 HMENU hMenu,
6316 LPCMENUINFO lpcmi)
6317 {
6318 PMENU Menu;
6319 DECLARE_RETURN(BOOL);
6320
6321 TRACE("Enter NtUserThunkedMenuInfo\n");
6322 UserEnterExclusive();
6323
6324 if (!(Menu = UserGetMenuObject(hMenu)))
6325 {
6326 RETURN(FALSE);
6327 }
6328
6329 RETURN(UserMenuInfo(Menu, (PROSMENUINFO)lpcmi, TRUE));
6330
6331 CLEANUP:
6332 TRACE("Leave NtUserThunkedMenuInfo, ret=%i\n",_ret_);
6333 UserLeave();
6334 END_CLEANUP;
6335 }
6336
6337 /*
6338 * @implemented
6339 */
6340 BOOL APIENTRY
6341 NtUserThunkedMenuItemInfo(
6342 HMENU hMenu,
6343 UINT uItem,
6344 BOOL fByPosition,
6345 BOOL bInsert,
6346 LPMENUITEMINFOW lpmii,
6347 PUNICODE_STRING lpszCaption)
6348 {
6349 PMENU Menu;
6350 NTSTATUS Status;
6351 UNICODE_STRING lstrCaption;
6352 DECLARE_RETURN(BOOL);
6353
6354 TRACE("Enter NtUserThunkedMenuItemInfo\n");
6355 UserEnterExclusive();
6356
6357 /* lpszCaption may be NULL, check for it and call RtlInitUnicodeString()
6358 if bInsert == TRUE call UserInsertMenuItem() else UserSetMenuItemInfo() */
6359
6360 RtlInitEmptyUnicodeString(&lstrCaption, NULL, 0);
6361
6362 if (!(Menu = UserGetMenuObject(hMenu)))
6363 {
6364 RETURN(FALSE);
6365 }
6366
6367 /* Check if we got a Caption */
6368 if (lpszCaption && lpszCaption->Buffer)
6369 {
6370 /* Copy the string to kernel mode */
6371 Status = ProbeAndCaptureUnicodeString( &lstrCaption,
6372 UserMode,
6373 lpszCaption);
6374 if (!NT_SUCCESS(Status))
6375 {
6376 ERR("Failed to capture MenuItem Caption (status 0x%08x)\n",Status);
6377 SetLastNtError(Status);
6378 RETURN(FALSE);
6379 }
6380 }
6381
6382 if (bInsert) RETURN( UserInsertMenuItem(Menu, uItem, fByPosition, lpmii, &lstrCaption));
6383
6384 RETURN( UserMenuItemInfo(Menu, uItem, fByPosition, (PROSMENUITEMINFO)lpmii, TRUE, &lstrCaption));
6385
6386 CLEANUP:
6387 if (lstrCaption.Buffer)
6388 {
6389 ReleaseCapturedUnicodeString(&lstrCaption, UserMode);
6390 }
6391
6392 TRACE("Leave NtUserThunkedMenuItemInfo, ret=%i\n",_ret_);
6393 UserLeave();
6394 END_CLEANUP;
6395 }
6396
6397 /*
6398 * @implemented
6399 */
6400 BOOL APIENTRY
6401 NtUserTrackPopupMenuEx(
6402 HMENU hMenu,
6403 UINT fuFlags,
6404 int x,
6405 int y,
6406 HWND hWnd,
6407 LPTPMPARAMS lptpm)
6408 {
6409 PMENU menu;
6410 PWND pWnd;
6411 TPMPARAMS tpm;
6412 BOOL Ret = FALSE;
6413 USER_REFERENCE_ENTRY Ref;
6414
6415 TRACE("Enter NtUserTrackPopupMenuEx\n");
6416 UserEnterExclusive();
6417 /* Parameter check */
6418 if (!(menu = UserGetMenuObject( hMenu )))
6419 {
6420 ERR("TPME : Invalid Menu handle.\n");
6421 EngSetLastError( ERROR_INVALID_MENU_HANDLE );
6422 goto Exit;
6423 }
6424
6425 if (!(pWnd = UserGetWindowObject(hWnd)))
6426 {
6427 ERR("TPME : Invalid Window handle.\n");
6428 goto Exit;
6429 }
6430
6431 if (lptpm)
6432 {
6433 _SEH2_TRY
6434 {
6435 ProbeForRead(lptpm, sizeof(TPMPARAMS), sizeof(ULONG));
6436 tpm = *lptpm;
6437 }
6438 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
6439 {
6440 _SEH2_YIELD(goto Exit);
6441 }
6442 _SEH2_END
6443 }
6444 UserRefObjectCo(pWnd, &Ref);
6445 Ret = IntTrackPopupMenuEx(menu, fuFlags, x, y, pWnd, lptpm ? &tpm : NULL);
6446 UserDerefObjectCo(pWnd);
6447
6448 Exit:
6449 TRACE("Leave NtUserTrackPopupMenuEx, ret=%i\n",Ret);
6450 UserLeave();
6451 return Ret;
6452 }
6453
6454 /* EOF */
A free Windows-compatible Operating System