#include <win32k.h>
Include dependency graph for menu.c:
Go to the source code of this file.
Classes | |
| struct | MTRACKER |
Variables | |
| HFONT | ghMenuFont = NULL |
| HFONT | ghMenuFontBold = NULL |
| static SIZE | MenuCharSize |
| static HWND | top_popup = NULL |
| static HMENU | top_popup_hmenu = NULL |
| BOOL | fInsideMenuLoop = FALSE |
| BOOL | fInEndMenu = FALSE |
Macro Definition Documentation
◆ FreeMenuText
| #define FreeMenuText | ( | Menu, | |
| MenuItem | |||
| ) |
Value:
{ \
if((MENU_ITEM_TYPE((MenuItem)->fType) == MF_STRING) && \
(MenuItem)->lpstr.Length) { \
} \
}
Definition: ntuser.h:416
◆ IS_MAGIC_BITMAP
◆ IS_STRING_ITEM
| #define IS_STRING_ITEM | ( | flags | ) | (MF_STRING == MENU_ITEM_TYPE(flags)) |
◆ IS_SYSTEM_MENU
| #define IS_SYSTEM_MENU | ( | MenuInfo | ) | (!!((MenuInfo)->fFlags & MNF_SYSMENU)) |
◆ ITEM_NEXT
◆ ITEM_PREV
◆ MAX_GOINTOSUBMENU
◆ MAX_MENU_ITEMS
◆ MAXMENUDEPTH
◆ MENU_BAR_ITEMS_SPACE
◆ MENU_COL_SPACE
◆ MENU_ITEM_HBMP_SPACE
◆ MENU_TAB_SPACE
◆ MENUITEMINFO_STATE_MASK
| #define MENUITEMINFO_STATE_MASK (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT)) |
◆ MENUITEMINFO_TYPE_MASK
| #define MENUITEMINFO_TYPE_MASK |
Value:
◆ MII_STATE_MASK
| #define MII_STATE_MASK (MFS_GRAYED|MFS_CHECKED|MFS_HILITE|MFS_DEFAULT) |
◆ MM_GETMENUHANDLE
◆ MM_SETMENUHANDLE
◆ MNS_STYLE_MASK
| #define MNS_STYLE_MASK (MNS_NOCHECK|MNS_MODELESS|MNS_DRAGDROP|MNS_AUTODISMISS|MNS_NOTIFYBYPOS|MNS_CHECKORBMP) |
◆ SEPARATOR_HEIGHT
◆ SHOW_DEBUGRECT
◆ STATE_MASK
◆ TF_ENDMENU
◆ TF_SKIPREMOVE
◆ TF_SUSPENDPOPUP
◆ TPM_BUTTONDOWN
◆ TPM_INTERNAL
◆ TPM_POPUPMENU
◆ TYPE_MASK
| #define TYPE_MASK (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU) |
◆ UpdateMenuItemState
◆ VALID_TPM_FLAGS
| #define VALID_TPM_FLAGS |
Value:
( \
TPM_LAYOUTRTL | TPM_NOANIMATION | TPM_VERNEGANIMATION | TPM_VERPOSANIMATION | \
TPM_HORNEGANIMATION | TPM_HORPOSANIMATION | TPM_RETURNCMD | \
)
Function Documentation
◆ co_IntGetSubMenu()
Definition at line 1348 of file menu.c.
Referenced by MENU_DoNextMenu(), and MENU_FindItemByKey().
◆ DBG_DEFAULT_CHANNEL()
| DBG_DEFAULT_CHANNEL | ( | UserMenu | ) |
◆ get_win_sys_menu()
Definition at line 258 of file menu.c.
Referenced by MENU_DoNextMenu(), MENU_PtMenu(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().
◆ IntCheckMenuItem()
Definition at line 1259 of file menu.c.
Referenced by NtUserCheckMenuItem().
◆ IntCloneMenu()
Definition at line 822 of file menu.c.
823{
824 HANDLE hMenu;
825 PMENU Menu;
826
829
830 /* A menu is valid process wide. We can pass to the object manager any thread ptr */
832 Source->head.rpdesk,
834 &hMenu,
835 TYPE_MENU,
837 if(!Menu)
839
847 Menu->cyMenu = 0;
848 Menu->cxMenu = 0;
849 Menu->cItems = 0;
850 Menu->iTop = 0;
851 Menu->iMaxTop = 0;
852 Menu->cxTextAlign = 0;
854
857
859
860 return Menu;
861}
struct tagMENU MENU
struct tagMENU * PMENU
Definition: nsiface.idl:2307
Definition: win32.h:254
PVOID FASTCALL UserCreateObject(PUSER_HANDLE_TABLE ht, PDESKTOP pDesktop, PTHREADINFO pti, HANDLE *h, HANDLE_TYPE type, ULONG size)
Definition: object.c:568
Referenced by MENU_GetSystemMenu().
◆ IntCloneMenuItems()
Definition at line 771 of file menu.c.
772{
775
778
781
783
784 Destination->rgItems = NewMenuItem;
785
786 MenuItem = Source->rgItems;
788 {
789 NewMenuItem->fType = MenuItem->fType;
790 NewMenuItem->fState = MenuItem->fState;
791 NewMenuItem->wID = MenuItem->wID;
792 NewMenuItem->spSubMenu = MenuItem->spSubMenu;
793 NewMenuItem->hbmpChecked = MenuItem->hbmpChecked;
794 NewMenuItem->hbmpUnchecked = MenuItem->hbmpUnchecked;
795 NewMenuItem->dwItemData = MenuItem->dwItemData;
796 if (MenuItem->lpstr.Length)
797 {
800 NewMenuItem->lpstr.Buffer = DesktopHeapAlloc(Destination->head.rpdesk, MenuItem->lpstr.MaximumLength);
802 {
804 break;
805 }
809 }
810 else
811 {
814 }
815 NewMenuItem->hbmp = MenuItem->hbmp;
817 }
819}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
Definition: fontsub.cpp:36
static __inline PVOID DesktopHeapAlloc(IN PDESKTOP Desktop, IN SIZE_T Bytes)
Definition: desktop.h:204
static __inline BOOL DesktopHeapFree(IN PDESKTOP Desktop, IN PVOID lpMem)
Definition: desktop.h:215
Referenced by IntCloneMenu().
◆ IntCreateMenu()
| PMENU FASTCALL IntCreateMenu | ( | _Out_ PHANDLE | Handle, |
| _In_ BOOL | IsMenuBar, | ||
| _In_ PDESKTOP | Desktop, | ||
| _In_ PPROCESSINFO | ppi | ||
| ) |
Definition at line 729 of file menu.c.
734{
735 PMENU Menu;
736
738 Desktop,
739 ppi->ptiList,
740 Handle,
741 TYPE_MENU,
743 if(!Menu)
744 {
745 *Handle = 0;
747 }
748
759 Menu->iTop = 0;
760 Menu->iMaxTop = 0;
761 Menu->cxTextAlign = 0;
763
766
767 return Menu;
768}
Definition: globals.h:228
Referenced by IntSetMenuItemInfo(), and UserCreateMenu().
◆ IntDestroyMenu()
Definition at line 269 of file menu.c.
270{
271 PMENU SubMenu;
272
275 {
279 {
280 SubMenu = item->spSubMenu;
282
283 /* Remove Item Text */
285
286 /* Remove Item Bitmap and set it for this process */
288 {
291 }
292
293 /* Remove Item submenu */
294 if (bRecurse && SubMenu)//VerifyMenu(SubMenu))
295 {
296 /* Release submenu since it was referenced when inserted */
297 IntReleaseMenuObject(SubMenu);
298 IntDestroyMenuObject(SubMenu, bRecurse);
299 }
300 }
301 /* Free the Item */
304 pMenu->cItems = 0;
305 }
307}
Definition: interpreter.c:37
Referenced by IntDestroyMenuObject().
◆ IntDestroyMenuObject()
Definition at line 317 of file menu.c.
318{
320 if (Menu)
321 {
323
325 {
328 {
331 {
332 //Window->IDMenu = 0; Only in Win9x!! wine win test_SetMenu test...
333
334 /* DestroyMenu should not destroy system menu popup owner */
336 {
337 // Should we check it to see if it has Class?
339 //co_UserDestroyWindow( Window );
340 //Menu->hWnd = 0;
341 }
342 }
343 }
344
346
347 /* Remove all menu items */
348 IntDestroyMenu( Menu, bRecurse);
349
353 }
354 }
356}
ULONG NTAPI PsGetCurrentProcessSessionId(VOID)
Definition: process.c:1133
Definition: window.c:28
Referenced by co_UserFreeWindow(), IntDestroyMenu(), IntGetSystemMenu(), IntRemoveMenuItem(), IntSetMenuItemInfo(), IntSetSystemMenu(), MENU_GetSystemMenu(), NtUserDestroyMenu(), UserDestroyMenu(), and UserDestroyMenuObject().
◆ IntDrawMenuBarTemp()
Definition at line 2685 of file menu.c.
2686{
2690
2691 UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
2692
2693 if (!pMenu)
2694 {
2696 }
2697
2699 {
2701 }
2702
2704 {
2706 }
2707
2709
2711
2713 {
2715 }
2716
2718
2720
2725
2727 {
2730 }
2731
2733 {
2734 MENU_DrawMenuItem(pWnd, pMenu, pWnd, hDC, &pMenu->rgItems[i], pMenu->cyMenu, TRUE, ODA_DRAWENTIRE);
2735 }
2736
2738
2740}
Definition: gdiplusheaders.h:874
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiGetStockObject(_In_ INT iObject)
__kernel_entry W32KAPI HPEN APIENTRY NtGdiSelectPen(_In_ HDC hdc, _In_ HPEN hpen)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiLineTo(_In_ HDC hdc, _In_ INT x, _In_ INT y)
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
Definition: gdiplustypes.h:668
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2116
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
Referenced by MENU_DrawMenuBar(), and NtUserDrawMenuBarTemp().
◆ IntEnableMenuItem()
Definition at line 1217 of file menu.c.
1218{
1219 PITEM MenuItem;
1221
1223
1225
1227
1228 /* If the close item in the system menu change update the close button */
1230 {
1232 {
1240 {
1241 //RECTL rc = MenuObject->spwndNotify->rcWindow;
1242
1243 /* Refresh the frame to reflect the change */
1244 //IntMapWindowPoints(0, MenuObject->spwndNotify, (POINT *)&rc, 2);
1245 //rc.bottom = 0;
1246 //co_UserRedrawWindow(MenuObject->spwndNotify, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
1247
1248 // Allow UxTheme!
1250 }
1251 default:
1252 break;
1253 }
1254 }
1256}
Referenced by MENU_InitSysMenuPopup(), and NtUserEnableMenuItem().
◆ IntFindSubMenu()
Definition at line 5041 of file menu.c.
5042{
5043 PMENU menu, pSubTarget;
5047
5048 pSubTarget = UserGetMenuObject(hSubTarget);
5049
5051
5053
5055}
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
Referenced by co_IntTranslateAccelerator().
◆ IntGetDialogBaseUnits()
Definition at line 1800 of file menu.c.
1801{
1803
1805 {
1808
1810 {
1814 }
1815 }
1817}
Definition: kdterminal.h:26
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
DWORD FASTCALL IntGetCharDimensions(_In_ HDC hdc, _Out_opt_ PTEXTMETRICW ptm, _Out_opt_ PDWORD height)
Definition: font.c:335
Referenced by MENU_CalcItemSize().
◆ IntGetMenu()
Definition at line 248 of file menu.c.
249{
251
252 if (!Wnd)
254
256}
Referenced by MENU_ButtonUp(), MENU_DoNextMenu(), MENU_PtMenu(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().
◆ IntGetMenuDefaultItem()
| UINT FASTCALL IntGetMenuDefaultItem | ( | PMENU | MenuObject, |
| UINT | fByPos, | ||
| UINT | gmdiFlags, | ||
| DWORD * | gismc | ||
| ) |
Definition at line 1315 of file menu.c.
1316{
1319
1320 /* empty menu */
1321 if (!MenuItem) return -1;
1322
1324 {
1325 i++; MenuItem++;
1327 }
1328
1329 /* default: don't return disabled items */
1331
1332 /* search rekursiv when needed */
1334 {
1336 (*gismc)++;
1338 (*gismc)--;
1340
1341 /* when item not found in submenu, return the popup item */
1342 }
1344}
Referenced by GetMenuDefaultItem(), and IntGetMenuDefaultItem().
◆ IntGetMenuInfo()
| BOOL FASTCALL IntGetMenuInfo | ( | PMENU | Menu, |
| PROSMENUINFO | lpmi | ||
| ) |
Definition at line 879 of file menu.c.
Referenced by UserMenuInfo().
◆ IntGetMenuItemInfo()
| BOOL FASTCALL IntGetMenuItemInfo | ( | PMENU | Menu, |
| PITEM | MenuItem, | ||
| PROSMENUITEMINFO | lpmii | ||
| ) |
Definition at line 962 of file menu.c.
964{
966
968 {
970 }
972 {
974 }
976 {
979 }
981 {
983 }
985 {
987 }
989 {
991 }
993 {
995 }
996
999 {
1001 {
1003 }
1004 else
1005 {
1010 {
1013 }
1014 }
1015 }
1016
1018 {
1027 }
1028
1030}
Definition: menu.h:101
Referenced by IntMenuItemInfo(), and UserMenuItemInfo().
◆ IntGetMenuItemRect()
Definition at line 5256 of file menu.c.
5261{
5262 LONG XMove, YMove;
5263 PITEM MenuItem;
5265
5267 {
5272 }
5273 else
5274 {
5277 }
5278
5279 if (!pWnd)
5280 {
5283 }
5284
5286 {
5289 }
5290 else
5291 {
5294 }
5295
5296 Rect->left += XMove;
5297 Rect->top += YMove;
5298 Rect->right += XMove;
5299 Rect->bottom += YMove;
5300
5302}
#define I(s)
Referenced by NtUserGetMenuBarInfo().
◆ IntGetMenuObject()
Definition at line 192 of file menu.c.
Referenced by IntSetMenu(), NtUserCallTwoParam(), and NtUserSetSystemMenu().
◆ IntGetMenuState()
Definition at line 5001 of file menu.c.
5002{
5003 PMENU MenuObject;
5004 PITEM pItem;
5005
5007 {
5009 }
5010
5012
5014 {
5016 }
5017 else
5019}
Referenced by co_IntTranslateAccelerator(), NC_DoButton(), NC_HandleNCLButtonDblClk(), and UserDrawCaptionButton().
◆ IntGetSubMenu()
Definition at line 5021 of file menu.c.
5022{
5023 PMENU MenuObject;
5024 PITEM pItem;
5025
5027 {
5029 }
5030
5032
5034 {
5036 return hsubmenu;
5037 }
5039}
Referenced by IntGetSystemMenu().
◆ IntGetSystemMenu()
Definition at line 5409 of file menu.c.
5410{
5411 PMENU Menu;
5412
5413 if (bRevert)
5414 {
5416 {
5419 {
5422 }
5423 }
5424 }
5425 else
5426 {
5429 {
5432 }
5433 }
5434
5436 {
5438 /* Store the dummy sysmenu handle to facilitate the refresh */
5439 /* of the close button if the SC_CLOSE item change */
5440 Menu = UserGetMenuObject(hMenu);
5441 if (Menu)
5442 {
5445 }
5446 return Menu;
5447 }
5449}
Referenced by co_UserTrackSystemMenu(), IntDefWindowProc(), MENU_TrackMouseMenuBar(), NC_DoButton(), NC_HandleNCLButtonDblClk(), NC_HandleNCRButtonDown(), NtUserGetMenuBarInfo(), NtUserGetSystemMenu(), and UserDrawCaptionButton().
◆ intGetTitleBarInfo()
| BOOLEAN APIENTRY intGetTitleBarInfo | ( | PWND | pWindowObject, |
| PTITLEBARINFO | bti | ||
| ) |
Definition at line 4830 of file menu.c.
4831{
4832
4833 DWORD dwStyle = 0;
4834 DWORD dwExStyle = 0;
4836
4838 {
4840
4842
4843 dwStyle = pWindowObject->style;
4844 dwExStyle = pWindowObject->ExStyle;
4845
4850
4851 /* Is it iconiced ? */
4853 {
4854 /* Remove frame from rectangle */
4856 {
4857 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXFRAME) and UserGetSystemMetrics(SM_CYFRAME) */
4858 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME) );
4859 }
4861 {
4862 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXDLGFRAME) and UserGetSystemMetrics(SM_CYDLGFRAME) */
4863 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
4864 }
4866 {
4867 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4868 RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER) );
4869 }
4870
4871 /* We have additional border information if the window
4872 * is a child (but not an MDI child) */
4874 ((dwExStyle & WS_EX_MDICHILD) == 0 ) )
4875 {
4877 {
4878 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXEDGE) and UserGetSystemMetrics(SM_CYEDGE) */
4879 RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
4880 }
4881
4883 {
4884 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4885 RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
4886 }
4887 }
4888 }
4889
4893
4896 {
4897 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYSMCAPTION) */
4899 }
4900 else
4901 {
4902 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYCAPTION) and UserGetSystemMetrics(SM_CXSIZE) */
4905 }
4906
4908 {
4911 {
4913 {
4916 }
4917 else
4918 {
4920 {
4922 }
4924 {
4926 }
4927 }
4928
4930 {
4932 }
4934 {
4936 }
4937 }
4938 else
4939 {
4944 }
4945 }
4946 else
4947 {
4949 }
4950 }
4951 else
4952 {
4954 retValue = FALSE;
4955 }
4956
4957 return retValue;
4958}
Definition: winuser.h:3861
VOID FASTCALL RECTL_vInflateRect(_Inout_ RECTL *rect, _In_ INT dx, _In_ INT dy)
Definition: rect.c:101
Referenced by NtUserGetTitleBarInfo().
◆ IntHiliteMenuItem()
| BOOL FASTCALL IntHiliteMenuItem | ( | PWND | WindowObject, |
| PMENU | MenuObject, | ||
| UINT | uItemHilite, | ||
| UINT | uHilite | ||
| ) |
◆ IntInsertMenuItem()
| BOOL FASTCALL IntInsertMenuItem | ( | _In_ PMENU | MenuObject, |
| UINT | uItem, | ||
| BOOL | fByPosition, | ||
| PROSMENUITEMINFO | ItemInfo, | ||
| PUNICODE_STRING | lpstr | ||
| ) |
Definition at line 691 of file menu.c.
697{
698 PITEM MenuItem;
700
702
703 if (MAX_MENU_ITEMS <= MenuObject->cItems)
704 {
707 }
708
709 SubMenu = MenuObject;
710
711 if(!(MenuItem = MENU_InsertItem( SubMenu, uItem, fByPosition ? MF_BYPOSITION : MF_BYCOMMAND, &SubMenu, &uItem ))) return FALSE;
712
714 {
717 }
718
719 /* Force size recalculation! */
720 SubMenu->cyMenu = 0;
722
724
726}
Referenced by MENU_GetSystemMenu(), and UserInsertMenuItem().
◆ IntIsMenu()
◆ IntMenuItemFromPoint()
Definition at line 1518 of file menu.c.
1519{
1522
1523 /*FIXME: Do we have to handle hWnd here? */
1524 if (!menu) return -1;
1527}
Referenced by IntDefWindowProc().
◆ IntMenuItemInfo()
| BOOL FASTCALL IntMenuItemInfo | ( | PMENU | Menu, |
| UINT | Item, | ||
| BOOL | ByPosition, | ||
| PROSMENUITEMINFO | ItemInfo, | ||
| BOOL | SetOrGet, | ||
| PUNICODE_STRING | lpstr | ||
| ) |
Definition at line 5102 of file menu.c.
5109{
5110 PITEM MenuItem;
5111 BOOL Ret;
5112
5114 {
5117 }
5118 if (SetOrGet)
5119 {
5121 }
5122 else
5123 {
5124 Ret = IntGetMenuItemInfo(Menu, MenuItem, ItemInfo);
5125 }
5126 return Ret;
5127}
Referenced by MENU_GetSystemMenu().
◆ IntRemoveMenuItem()
Definition at line 596 of file menu.c.
597{
599 PITEM newItems;
600
603
604 /* Remove item */
605
608 {
610 }
613 {
616 }
617 else
618 {
619 while (nPos < pMenu->cItems)
620 {
622 item++;
623 nPos++;
624 }
625 newItems = DesktopHeapReAlloc(pMenu->head.rpdesk, pMenu->rgItems, pMenu->cItems * sizeof(ITEM));
626 if (newItems)
627 {
628 pMenu->rgItems = newItems;
629 }
630 }
632}
static __inline PVOID DesktopHeapReAlloc(IN PDESKTOP Desktop, IN PVOID lpMem, IN SIZE_T Bytes)
Definition: desktop.h:226
Referenced by IntInsertMenuItem(), MENU_GetSystemMenu(), NtUserDeleteMenu(), and NtUserRemoveMenu().
◆ IntSetMenu()
Definition at line 5485 of file menu.c.
5489{
5491
5493 {
5497 }
5498
5500 if (! *Changed)
5501 {
5503 }
5504
5506 {
5509 }
5510 else
5511 {
5512 OldMenu = NULL;
5513 }
5514
5516 {
5517 NewMenu = IntGetMenuObject(Menu);
5519 {
5521 {
5522 IntReleaseMenuObject(OldMenu);
5523 }
5526 }
5528 {
5529 /* Can't use the same menu for two windows */
5531 {
5532 IntReleaseMenuObject(OldMenu);
5533 }
5536 }
5537
5538 }
5539
5542 {
5544 IntReleaseMenuObject(NewMenu);
5545 }
5547 {
5549 IntReleaseMenuObject(OldMenu);
5550 }
5551
5553}
Referenced by IntCreateWindow(), and NtUserSetMenu().
◆ IntSetMenuContextHelpId()
Definition at line 872 of file menu.c.
Referenced by NtUserSetMenuContextHelpId().
◆ IntSetMenuFlagRtoL()
◆ IntSetMenuInfo()
| BOOL FASTCALL IntSetMenuInfo | ( | PMENU | Menu, |
| PROSMENUINFO | lpmi | ||
| ) |
Definition at line 914 of file menu.c.
915{
927 {
931 {
933 {
935 }
936 }
937 }
939 {
948
951 }
953 {
957 }
959}
Referenced by IntSetMenuInfo(), and UserMenuInfo().
◆ IntSetMenuItemInfo()
| BOOL FASTCALL IntSetMenuItemInfo | ( | PMENU | MenuObject, |
| PITEM | MenuItem, | ||
| PROSMENUITEMINFO | lpmii, | ||
| PUNICODE_STRING | lpstr | ||
| ) |
Definition at line 1033 of file menu.c.
1034{
1035 PMENU SubMenuObject;
1037
1038 if(!MenuItem || !MenuObject || !lpmii)
1039 {
1041 }
1043 {
1044 MenuItem->fType &= ~MENUITEMINFO_TYPE_MASK;
1046 }
1048 {
1049 #if 0
1051 {
1054 /* This does not happen on Win9x/ME */
1057 }
1058 #endif
1059 /*
1060 * Delete the menu item type when changing type from
1061 * MF_STRING.
1062 */
1065 {
1066 FreeMenuText(MenuObject,MenuItem);
1069 }
1071 {
1074 else
1075 { /* Win 9x/Me stuff */
1077 }
1078 lpmii->dwTypeData = 0;
1079 }
1080 }
1082 {
1086 else
1087 MenuItem->fState &= ~MFS_HBMMENUBMP;
1088 }
1090 {
1093 }
1095 {
1097 }
1099 {
1101 }
1103 {
1104 /* Remove MFS_DEFAULT flag from all other menu items if this item
1105 has the MFS_DEFAULT state */
1107 UserSetMenuDefaultItem(MenuObject, -1, 0);
1108 /* Update the menu item state flags */
1110 }
1111
1113 {
1115 {
1118 {
1121 if (MenuObject == SubMenuObject)
1122 {
1123 HANDLE hMenu;
1125 SubMenuObject = IntCreateMenu(&hMenu,
1126 FALSE,
1131 circref = TRUE;
1132 }
1134 {
1138 }
1139 /* Make sure the submenu is marked as a popup menu */
1141 // Now fix the test_subpopup_locked_by_menu tests....
1143 MenuItem->spSubMenu = SubMenuObject;
1144 UserReferenceObject(SubMenuObject);
1145 }
1146 else
1147 {
1150 }
1151 }
1152 else
1153 { // If submenu just dereference it.
1156 }
1157 }
1158
1161 {
1162 /* free the string when used */
1163 FreeMenuText(MenuObject,MenuItem);
1166
1168 {
1170
1172 {
1174 }
1175
1178
1179 MenuItem->lpstr.Buffer = DesktopHeapAlloc( MenuObject->head.rpdesk, Source.Length + sizeof(WCHAR));
1181 {
1186
1189 }
1190 }
1191 }
1192
1194 !MenuItem->Xlpstr &&
1195 !lpmii->dwTypeData &&
1197 !MenuItem->hbmp)
1199
1201 {
1210 }
1211
1213}
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNICODE_STRING_MAX_CHARS
Definition: env_spec_w32.h:368
Referenced by IntInsertMenuItem(), IntMenuItemInfo(), and UserMenuItemInfo().
◆ IntSetSystemMenu()
Definition at line 5452 of file menu.c.
5453{
5454 PMENU OldMenu;
5455
5457
5459 {
5461 if (OldMenu)
5462 {
5463 OldMenu->fFlags &= ~MNF_SYSMENU;
5465 }
5466 }
5467
5469 if (OldMenu)
5470 { // Use spmenuSys too!
5472 }
5473 else
5475
5477 {
5479 }
5480
5482}
Referenced by NtUserSetSystemMenu().
◆ IntTrackPopupMenuEx()
| BOOL FASTCALL IntTrackPopupMenuEx | ( | _Inout_ PMENU | menu, |
| _In_ UINT | wFlags, | ||
| _In_ INT | x, | ||
| _In_ INT | y, | ||
| _In_ PWND | pWnd, | ||
| _In_opt_ const TPMPARAMS * | lpTpm | ||
| ) |
Definition at line 4575 of file menu.c.
4582{
4585
4586 if (lpTpm && lpTpm->cbSize != sizeof(*lpTpm))
4587 {
4591 }
4592
4593 if (pti != pWnd->head.pti)
4594 {
4597 }
4598
4601 //lpTpm ? wine_dbgstr_rect( &lpTpm->rcExclude) : "-" );
4602
4604 {
4607 }
4608
4610 {
4612
4613 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
4615 {
4616 co_IntSendMessage( UserHMGetHandle(pWnd), WM_INITMENUPOPUP, (WPARAM) UserHMGetHandle(menu), MAKELPARAM(0, IS_SYSTEM_MENU(menu)));
4617 }
4618
4621
4622 if (MENU_ShowPopup(pWnd, menu, 0, wFlags | TPM_POPUPMENU, x, y, lpTpm ? &lpTpm->rcExclude : NULL))
4624 else
4625 {
4627 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4629 }
4630
4632
4633 if (menu->hWnd)
4634 {
4636 if (pwndM) // wine hack around this with their destroy function.
4637 {
4640 }
4641 menu->hWnd = 0;
4642
4644 {
4647 }
4648 }
4649 }
4651}
HWND FASTCALL MsqSetStateWindow(PTHREADINFO pti, ULONG Type, HWND hWnd)
Definition: msgqueue.c:2507
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
Definition: win32.h:84
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1495
Referenced by co_UserTrackSystemMenu(), IntDefWindowProc(), and NtUserTrackPopupMenuEx().
◆ MENU_AdjustMenuItemRect()
Definition at line 1462 of file menu.c.
Referenced by MENU_DrawMenuItem(), MENU_FindItemByCoords(), MENU_ShowSubPopup(), and NtUserMenuItemFromPoint().
◆ MENU_ButtonDown()
Definition at line 3558 of file menu.c.
3559{
3561
3562 if (PtMenu)
3563 {
3566
3567 // Special check for the icon system menu
3569 {
3571 }
3572 else
3573 {
3575 }
3576
3578 {
3581
3582 /* If the popup menu is not already "popped" */
3584 {
3586 }
3587
3589 }
3590 /* Else the click was on the menu bar, finish the tracking */
3591 }
3593}
Referenced by MENU_TrackMenu().
◆ MENU_ButtonUp()
Definition at line 3603 of file menu.c.
3604{
3606
3607 if (PtMenu)
3608 {
3611
3612 // Special check for the icon system menu
3614 {
3616 }
3617 else
3618 {
3620 }
3621
3623 {
3625 {
3627 if (ExecutedMenuId == -1 || ExecutedMenuId == -2) return -1;
3628 return ExecutedMenuId;
3629 }
3630
3631 /* If we are dealing with the menu bar */
3632 /* and this is a click on an already "popped" item: */
3633 /* Stop the menu tracking and close the opened submenus */
3635 {
3636 return 0;
3637 }
3638 }
3640 {
3642 }
3643 }
3644 return -1;
3645}
Referenced by MENU_TrackMenu().
◆ MENU_CalcItemSize()
|
static |
Definition at line 1825 of file menu.c.
1827{
1830 UINT arrow_bitmap_width;
1832 INT itemheight = 0;
1833
1835
1837
1839
1841
1843 {
1844 MEASUREITEMSTRUCT mis;
1846 mis.CtlID = 0;
1850 mis.itemWidth = 0;
1852 /* Tests reveal that Windows ( Win95 thru WinXP) adds twice the average
1853 * width of a menufont character to the width of an owner-drawn menu.
1854 */
1856 if (menuBar) {
1857 /* under at least win95 you seem to be given a standard
1858 height for the menu and the height value is ignored */
1860 } else
1862 // Or this,
1863 //lpitem->cxBmp = mis.itemWidth;
1864 //lpitem->cyBmp = mis.itemHeight;
1869
1874
1875 return;
1876 }
1877
1878 lpitem->xItem = orgX;
1879 lpitem->yItem = orgY;
1880 lpitem->cxItem = orgX;
1881 lpitem->cyItem = orgY;
1882
1884 {
1886 if( !menuBar)
1888 return;
1889 }
1890
1891 lpitem->dxTab = 0;
1892
1894 {
1896
1897 if (!menuBar) {
1899 /* Keep the size of the bitmap in callback mode to be able
1900 * to draw it correctly */
1905 itemheight = size.cy + 2;
1906
1908 lpitem->cxItem += 2 * check_bitmap_width;
1911 lpitem->cxItem += arrow_bitmap_width;
1912 } else /* hbmpItem & MenuBar */ {
1916 itemheight = size.cy;
1917
1918 /* Special case: Minimize button doesn't have a space behind it. */
1921 lpitem->cxItem -= 1;
1922 }
1923 }
1924 else if (!menuBar) {
1926 lpitem->cxItem += check_bitmap_width;
1929 lpitem->cxItem += arrow_bitmap_width;
1930 }
1931
1932 /* it must be a text item - unless it's the system menu */
1936 LONG txtheight, txtwidth;
1937
1942
1945 }
1946 if (menuBar) {
1948
1951
1953 } else {
1955 RECT tmprc = rc;
1956 LONG tmpheight;
1958 /* Item contains a tab (only meaningful in popup menus) */
1959 /* get text size before the tab */
1964 /* get text size after the tab */
1967 lpitem->dxTab += txtwidth;
1968 txtheight = max( txtheight, tmpheight);
1971 } else {
1975 lpitem->dxTab += txtwidth;
1976 }
1977 lpitem->cxItem += 2 + txtwidth;
1978 itemheight = max( itemheight,
1980 }
1981 if (hfontOld)
1982 {
1984 }
1985 } else if( menuBar) {
1987 }
1988 lpitem->cyItem += itemheight;
1990}
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:16
Definition: winuser.h:3742
Definition: windef.h:305
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
Referenced by MENU_MenuBarCalcSize(), and MENU_PopupMenuCalcSize().
◆ MENU_depth()
Definition at line 404 of file menu.c.
405{
408 int subdepth;
409
411
412 depth++;
415 subdepth = depth;
417 {
419 {
421 if( bdepth > subdepth) subdepth = bdepth;
422 }
425 }
426 return subdepth;
427}
Referenced by IntSetMenuItemInfo(), and MENU_depth().
◆ MENU_DoNextMenu()
Definition at line 3735 of file menu.c.
3736{
3738
3739 /* When skipping left, we need to do something special after the
3740 first menu. */
3742 {
3743 atEnd = TRUE;
3744 }
3745 /* When skipping right, for the non-system menu, we need to
3746 handle the last non-special menu item (ie skip any window
3747 icons such as MDI maximize, restore or close) */
3749 {
3751 while (i < pmt->TopMenu->cItems) {
3754 i++;
3755 } else break;
3756 }
3758 atEnd = TRUE;
3759 }
3760 }
3761 /* When skipping right, we need to cater for the system menu */
3763 {
3765 atEnd = TRUE;
3766 }
3767 }
3768
3769 if ( atEnd )
3770 {
3771 MDINEXTMENU NextMenu;
3772 PMENU MenuTmp;
3773 PWND pwndTemp;
3774 HMENU hNewMenu;
3775 HWND hNewWnd;
3777
3783
3786
3788 {
3791 {
3792 /* switch to the menu bar */
3793
3795
3797 {
3799
3800 /* Skip backwards over any system predefined icons,
3801 eg. MDI close, restore etc icons */
3805
3806 }
3807 hNewMenu = UserHMGetHandle(MenuTmp);
3808 }
3810 {
3811 /* switch to the system menu */
3812 MenuTmp = get_win_sys_menu(hNewWnd);
3815 }
3816 else
3818 }
3819 else /* application returned a new menu to switch to */
3820 {
3821 hNewMenu = NextMenu.hmenuNext;
3822 hNewWnd = NextMenu.hwndNext;
3823
3825 {
3827 {
3828 /* get the real system menu */
3829 MenuTmp = get_win_sys_menu(hNewWnd);
3830 hNewMenu = UserHMGetHandle(MenuTmp);
3831 }
3833 {
3834 /* FIXME: Not sure what to do here;
3835 * perhaps try to track NewMenu as a popup? */
3836
3839 }
3840 }
3842 }
3843
3845 {
3847
3850 }
3851
3853 {
3858 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
3861 }
3862
3865
3867 }
3869}
Definition: winuser.h:3736
Referenced by MENU_KeyLeft(), and MENU_KeyRight().
◆ MENU_DrawBitmapItem()
|
static |
Definition at line 1653 of file menu.c.
1655{
1656 BITMAP bm;
1662 int bmp_xoffset = 0;
1664 BOOL flat_menu;
1666 bmp = hbmToDraw;
1667
1668 UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
1669
1670 /* Check if there is a magic menu item associated with this item */
1672 {
1675
1678 {
1681 {
1683 {
1685 }
1686
1690 }
1691 else
1692 {
1694 //if (!BmpSysMenu) BmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
1695 //bmp = BmpSysMenu;
1696 //if (! GreGetObject(bmp, sizeof(bm), &bm)) return;
1697 /* only use right half of the bitmap */
1698 //bmp_xoffset = bm.bmWidth / 2;
1699 //bm.bmWidth -= bmp_xoffset;
1700 if (WndOwner)
1701 {
1702 pIcon = NC_IconForWindow(WndOwner);
1703 // FIXME: NC_IconForWindow should reference it for us */
1705 }
1707 if (pIcon)
1708 {
1711 LONG x = rect->left - cx/2 + 1 + (rect->bottom - rect->top)/2; // this is really what Window does
1714 UserDereferenceObject(pIcon);
1715 }
1716 return;
1717 }
1718 goto got_bitmap;
1721 break;
1723 r.right += 1;
1725 break;
1727 r.right += 1;
1729 break;
1732 break;
1735 break;
1737 {
1738 DRAWITEMSTRUCT drawItem;
1739 POINT origorg;
1741 drawItem.CtlID = 0;
1743 drawItem.itemAction = odaction;
1755 /* some applications make this assumption on the DC's origin */
1760 return;
1761 }
1762 break;
1763
1768 MENU_DrawPopupGlyph(hdc, &r, (INT_PTR)hbmToDraw, lpitem->fState & MF_GRAYED, lpitem->fState & MF_HILITE);
1769 return;
1770 }
1774 return;
1775 }
1776
1778
1779 got_bitmap:
1782 /* handle fontsize > bitmap_height */
1788 if (MenuBar &&
1789 !flat_menu &&
1791 {
1792 ++left;
1793 ++top;
1794 }
1797}
COLORREF FASTCALL IntGdiSetBkColor(_In_ HDC hDC, _In_ COLORREF Color)
BOOL FASTCALL GreSetViewportOrgEx(HDC hDC, int X, int Y, LPPOINT Point)
Definition: coord.c:915
__kernel_entry W32KAPI HDC APIENTRY NtGdiCreateCompatibleDC(_In_opt_ HDC hdc)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbm)
Definition: cursoricon.h:10
Definition: winuser.h:3186
Definition: polytest.cpp:47
INT NTAPI GreGetObject(IN HGDIOBJ hobj, IN INT cbCount, OUT PVOID pvBuffer)
Definition: gdiobj.c:1270
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
BOOL UserDrawIconEx(HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
Definition: cursoricon.c:1689
BOOL WINAPI DrawFrameControl(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
Referenced by MENU_DrawMenuItem().
◆ MENU_DrawMenuBar()
Definition at line 2742 of file menu.c.
2743{
2744 HFONT hfontOld = 0;
2746
2748 {
2749 // No menu. Do not reserve any space
2750 return 0;
2751 }
2752
2754 {
2756 }
2757
2758 if (suppress_draw)
2759 {
2761
2763
2765
2767
2769 }
2770 else
2771 {
2773 }
2774}
Referenced by NC_DoNCPaint(), NC_HandleNCCalcSize(), NtUserCalcMenuBar(), NtUserPaintMenuBar(), and UserDrawCaptionBar().
◆ MENU_DrawMenuItem()
|
static |
Definition at line 2204 of file menu.c.
2206{
2210 int bkgnd;
2211 UINT arrow_bitmap_width = 0;
2212 //RECT bmprc;
2213
2214 if (!menuBar) {
2216 }
2217
2219 {
2221 {
2224 }
2225 return;
2226 }
2227
2228 UserSystemParametersInfo (SPI_GETFLATMENU, 0, &flat_menu, 0);
2229 bkgnd = (menuBar && flat_menu) ? COLOR_MENUBAR : COLOR_MENU;
2230
2231 /* Setup colors */
2232
2234 {
2235 if(menuBar && !flat_menu) {
2238 } else {
2241 else
2244 }
2245 }
2246 else
2247 {
2250 else
2253 }
2254
2255 //TRACE("rect=%s\n", wine_dbgstr_rect( &lpitem->Rect));
2256 //rect = lpitem->Rect;
2261
2263
2265 {
2266 /*
2267 ** Experimentation under Windows reveals that an owner-drawn
2268 ** menu is given the rectangle which includes the space it requested
2269 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
2270 ** and a popup-menu arrow. This is the value of lpitem->rect.
2271 ** Windows will leave all drawing to the application except for
2272 ** the popup-menu arrow. Windows always draws that itself, after
2273 ** the menu owner has finished drawing.
2274 */
2275 DRAWITEMSTRUCT dis;
2276 COLORREF old_bk, old_text;
2277
2279 dis.CtlID = 0;
2282 dis.itemState = 0;
2295 "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", Wnd,
2299 TRACE("Ownerdraw: Width %d Height %d\n", dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top);
2305 /* Draw the popup-menu arrow */
2307 {
2308 RECT rectTemp;
2312 }
2313 return;
2314 }
2315
2317
2319 {
2320 if (flat_menu)
2321 {
2326 }
2327 else
2328 {
2329 if (menuBar)
2330 {
2333 }
2334 else
2335 {
2337 }
2338 }
2339 }
2340 else
2342
2344
2345 /* vertical separator */
2347 {
2348 HPEN oldPen;
2350
2352 rc.top = 3;
2354 if (flat_menu)
2355 {
2361 }
2362 else
2364 }
2365
2366 /* horizontal separator */
2368 {
2369 HPEN oldPen;
2371
2372 rc.left++;
2373 rc.right--;
2375 if (flat_menu)
2376 {
2382 }
2383 else
2385 return;
2386 }
2387#if 0
2388 /* helper lines for debugging */
2389 /* This is a very good test tool when hacking menus! (JT) 07/16/2006 */
2395#endif
2396#if 0 // breaks mdi menu bar icons.
2398 /* calculate the bitmap rectangle in coordinates relative
2399 * to the item rectangle */
2400 if( menuBar) {
2402 bmprc.left = 3;
2403 else
2405 }
2407 bmprc.left = 4;
2409 bmprc.left = 2;
2410 else
2412
2413 bmprc.right = bmprc.left + lpitem->cxBmp;
2414
2416 bmprc.top = 0;
2417 else
2419
2420 bmprc.bottom = bmprc.top + lpitem->cyBmp;
2421 }
2422#endif
2423 if (!menuBar)
2424 {
2425 HBITMAP bm;
2431 /* Draw the check mark
2432 *
2433 * FIXME:
2434 * Custom checkmark bitmaps are monochrome but not always 1bpp.
2435 */
2438 lpitem->hbmpUnchecked;
2440 {
2442
2445 check_bitmap_width, check_bitmap_height,
2448 checked = TRUE;
2449 }
2451 {
2458 checked = TRUE;
2459 }
2460 }
2462 {
2464 if (!((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP) && !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
2465 bmpRect.left += check_bitmap_width + 2;
2467 {
2470 }
2471 }
2472 /* Draw the popup-menu arrow */
2474 {
2475 RECT rectTemp;
2479 }
2480 rect.left += 4;
2482 rect.left += check_bitmap_width;
2483 rect.right -= arrow_bitmap_width;
2484 }
2486 { /* Draw the bitmap */
2488 }
2489
2490 /* process text if present */
2492 {
2494 HFONT hfontOld = 0;
2495
2496 UINT uFormat = menuBar ?
2499
2502 else
2504
2506 {
2508 }
2509
2510 if (menuBar) {
2516 }
2517
2520 {
2523 break;
2524 }
2525
2526 if (menuBar &&
2527 !flat_menu &&
2529 {
2531 }
2532
2533 if (!menuBar)
2534 --rect.bottom;
2535
2537 {
2539 {
2544 }
2546 }
2548
2549 /* paint the shortcut text */
2551 {
2553 {
2556 }
2557 else
2558 {
2561 }
2562
2564 {
2566 {
2571 }
2573 }
2575 }
2576
2577 if (!menuBar)
2578 ++rect.bottom;
2579
2580 if (menuBar &&
2581 !flat_menu &&
2583 {
2585 }
2586
2587 if (hfontOld)
2588 {
2590 }
2591 }
2592}
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
BOOL UserDrawSysMenuButton(PWND pWnd, HDC hDC, LPRECT Rect, BOOL Down)
Definition: nonclient.c:767
int WINAPI FrameRect(_In_ HDC, _In_ LPCRECT, _In_ HBRUSH)
BOOL WINAPI DrawEdge(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
Referenced by IntDrawMenuBarTemp(), MENU_DrawPopupMenu(), MENU_SelectItem(), and MENU_ShowSubPopup().
◆ MENU_DrawPopupGlyph()
|
static |
Definition at line 1398 of file menu.c.
1399{
1400 LOGFONTW lf;
1402 COLORREF clrsave;
1403 INT bkmode;
1404 WCHAR symbol;
1405 switch (popupMagic)
1406 {
1408 symbol = '2';
1409 break;
1411 symbol = '0';
1412 break;
1414 symbol = '1';
1415 break;
1417 symbol = 'r';
1418 break;
1419 default:
1421 return;
1422 }
1426 lf.lfWidth = 0;
1431 /* save font and text color */
1435 /* set color and drawing mode */
1437 if (inactive)
1438 {
1439 /* draw shadow */
1440 if (!hilite)
1441 {
1444 }
1445 }
1446 IntGdiSetTextColor(dc, IntGetSysColor(inactive ? COLOR_GRAYTEXT : (hilite ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)));
1447 /* draw selected symbol */
1449 /* restore previous settings */
1454}
Definition: dimm.idl:58
HFONT FASTCALL GreCreateFontIndirectW(_In_ const LOGFONTW *lplf)
Definition: font.c:28
BOOL FASTCALL GreTextOutW(_In_ HDC hdc, _In_ INT nXStart, _In_ INT nYStart, _In_reads_(cchString) PCWCH lpString, _In_ INT cchString)
Definition: text.c:60
Referenced by MENU_DrawBitmapItem().
◆ MENU_DrawPopupMenu()
Definition at line 2599 of file menu.c.
2600{
2603
2605
2607
2611 {
2612 HPEN hPrevPen;
2613
2614 /* FIXME: Maybe we don't have to fill the background manually */
2616
2618 if ( hPrevPen )
2619 {
2621 /* draw menu items */
2623 {
2626
2629 {
2632 }
2633 /* draw scroll arrows */
2635 {
2637 }
2638 }
2639 }
2640 else
2641 {
2643 }
2644 }
2645}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:92
Referenced by PopupMenuWndProc().
◆ MENU_DrawScrollArrows()
Definition at line 2176 of file menu.c.
2177{
2178 UINT arrow_bitmap_height;
2181
2183
2184 rect.left = 0;
2185 rect.top = 0;
2187 rect.bottom = arrow_bitmap_height;
2190
2194 if (!(lppop->iTop < lppop->iMaxTop - (MENU_GetMaxPopupHeight(lppop) - 2 * arrow_bitmap_height)))
2197}
Referenced by MENU_DrawPopupMenu(), and MENU_EnsureMenuItemVisible().
◆ MENU_EndMenu()
Definition at line 2662 of file menu.c.
2663{
2667 {
2669 {
2671
2673 {
2675 return;
2676 }
2677
2680 }
2681 }
2682}
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1395
Referenced by IntDefWindowProc().
◆ MENU_EnsureMenuItemVisible()
Definition at line 3102 of file menu.c.
3103{
3104 USER_REFERENCE_ENTRY Ref;
3106 {
3110 RECT rc;
3111 UINT arrow_bitmap_height;
3113
3114 IntGetClientRect(pWnd, &rc);
3115
3117
3118 rc.top += arrow_bitmap_height;
3119 rc.bottom -= arrow_bitmap_height;
3120
3122 UserRefObjectCo(pWnd, &Ref);
3124 {
3128 //ERR("Scroll Down iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
3129 }
3131 {
3135 //ERR("Scroll Up iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
3136 }
3137 UserDerefObjectCo(pWnd);
3138 }
3139}
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
BOOL FASTCALL IntScrollWindow(PWND, int, int, CONST RECT *, CONST RECT *)
Definition: scrollex.c:458
Definition: object.h:4
Referenced by MENU_SelectItem().
◆ MENU_ExecFocusedItem()
Definition at line 3478 of file menu.c.
3479{
3481
3483
3485 {
3486 return -1;
3487 }
3488
3490
3492
3494 {
3496 {
3497 /* If TPM_RETURNCMD is set you return the id, but
3498 do not send a message to the owner */
3500 {
3502 {
3505 }
3506 else
3507 {
3508 DWORD dwStyle = ((Menu->fFlags & MNS_STYLE_MASK) | ( pmt->TopMenu ? (pmt->TopMenu->fFlags & MNS_STYLE_MASK) : 0) );
3509
3511 UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_MENUCOMMAND, Menu->iItem, (LPARAM)UserHMGetHandle(Menu));
3512 else
3514 }
3515 }
3517 }
3518 }
3519 else
3520 {
3522 return -2;
3523 }
3524
3525 return -1;
3526}
Referenced by MENU_ButtonUp(), and MENU_TrackMenu().
◆ MENU_ExitTracking()
Definition at line 4464 of file menu.c.
4465{
4467
4469
4472
4473 co_UserShowCaret(0);
4474
4475 top_popup = 0;
4477
4479}
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:178
Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().
◆ MENU_FindItem()
Definition at line 507 of file menu.c.
508{
509 MENU *menu = *pmenu;
511 UINT fallback_pos = 0;
513
515
517 {
521 }
522 else
523 {
526 {
528 {
531 if (subitem)
532 {
533 *pmenu = psubmenu;
534 return subitem;
535 }
537 {
538 /* fallback to this item if nothing else found */
539 fallback_pos = i;
540 fallback = item;
541 }
542 }
544 {
545 *nPos = i;
547 }
548 }
549 }
550
551 if (fallback)
552 *nPos = fallback_pos;
553
554 return fallback;
555}
Referenced by CheckMenuItem(), CheckMenuRadioItem(), co_IntGetSubMenu(), co_IntTranslateAccelerator(), GetMenuItemID(), GetMenuItemInfo_common(), GetMenuState(), GetMenuStringA(), GetMenuStringW(), GetSubMenu(), IntCheckMenuItem(), IntEnableMenuItem(), IntGetMenuItemRect(), IntGetMenuState(), IntGetSubMenu(), IntHiliteMenuItem(), IntMenuItemInfo(), IntRemoveMenuItem(), MENU_FindItem(), MENU_InsertItem(), NtUserGetMenuItemRect(), and UserMenuItemInfo().
◆ MENU_FindItemByCoords()
Definition at line 1480 of file menu.c.
1481{
1487
1489
1493
1496 else
1501 {
1502 //rect = item->rect;
1507
1510 {
1513 }
1514 }
1516}
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52
Referenced by IntMenuItemFromPoint(), MENU_ButtonDown(), MENU_ButtonUp(), and MENU_MouseMove().
◆ MENU_FindItemByKey()
|
static |
Definition at line 1535 of file menu.c.
1537{
1538 LRESULT MenuChar;
1540
1542
1545 if (menu)
1546 {
1548
1549 if ( !ForceMenuChar )
1550 {
1553
1555 {
1558 {
1560 do
1561 {
1565 }
1568 }
1569 }
1570 }
1571
1574
1579 }
1581}
Definition: find_test.cpp:52
Referenced by MENU_TrackKbdMenuBar(), and MENU_TrackMenu().
◆ MENU_FindSubMenu()
Definition at line 564 of file menu.c.
565{
568
571 {
573 continue;
574 else
575 {
577 {
579 }
580 else
581 {
585 {
586 *menu = pSubMenu;
588 }
589 }
590 }
591 }
593}
Referenced by IntFindSubMenu(), MENU_FindSubMenu(), and MENU_SelectItem().
◆ MENU_GetBitmapItemSize()
Definition at line 1588 of file menu.c.
1589{
1590 BITMAP bm;
1592
1594
1595 /* check if there is a magic menu item associated with this item */
1597 {
1599 {
1601 {
1602 MEASUREITEMSTRUCT measItem;
1604 measItem.CtlID = 0;
1607 measItem.itemHeight = lpitem->cyItem - lpitem->yItem; //lpitem->Rect.bottom - lpitem->Rect.top;
1613 return;
1614 }
1615 break;
1616
1619 {
1621 break;
1622 }
1623 /* fall through */
1633 /* FIXME: Why we need to subtract these magic values? */
1634 /* to make them smaller than the menu bar? */
1637 return;
1638 }
1639 }
1640
1642 {
1643 size->cx = bm.bmWidth;
1644 size->cy = bm.bmHeight;
1645 }
1646}
Referenced by MENU_CalcItemSize().
◆ MENU_GetMaxPopupHeight()
Definition at line 1996 of file menu.c.
1997{
1999 {
2000 //ERR("MGMaxPH cyMax %d\n",lppop->cyMax);
2002 }
2003 //ERR("MGMaxPH SyMax %d\n",UserGetSystemMetrics(SM_CYSCREEN) - UserGetSystemMetrics(SM_CYBORDER));
2005}
Referenced by MENU_DrawScrollArrows(), MENU_EnsureMenuItemVisible(), and MENU_PopupMenuCalcSize().
◆ MENU_GetStartOfNextColumn()
Definition at line 437 of file menu.c.
Referenced by MENU_KeyRight().
◆ MENU_GetStartOfPrevColumn()
Definition at line 467 of file menu.c.
469{
471 PITEM pItem;
472
473 if( !menu )
475
478
479 pItem = menu->rgItems;
481
482 /* Find the start of the column */
483
487
490
493 break;
494 }
495
497
499}
Referenced by MENU_KeyLeft().
◆ MENU_GetSubPopup()
Definition at line 3716 of file menu.c.
3717{
3719
3721
3724 {
3726 }
3727 return 0;
3728}
Referenced by MENU_KeyEscape(), and MENU_KeyLeft().
◆ MENU_GetSystemMenu()
Definition at line 5304 of file menu.c.
5305{
5308 ROSMENUITEMINFO ItemInfoSet = {0};
5309 ROSMENUITEMINFO ItemInfo = {0};
5310 UNICODE_STRING MenuName;
5311
5314 {
5316 }
5317 SysMenu = UserGetMenuObject(hSysMenu);
5319 {
5320 UserDestroyMenu(hSysMenu);
5322 }
5323
5324 SysMenu->fFlags |= MNF_SYSMENU;
5326
5328 {
5329 //hNewMenu = co_IntLoadSysMenuTemplate();
5331 {
5334 }
5335 else
5336 {
5339 //ERR("%wZ\n",&MenuName);
5340 }
5341 if (!hNewMenu)
5342 {
5346 }
5347 Menu = UserGetMenuObject(hNewMenu);
5348 if (!Menu)
5349 {
5352 }
5353
5354 // Do the rest in here.
5355
5357
5368
5369 NewMenu = IntCloneMenu(Menu);
5371 {
5375 }
5376
5377 IntReleaseMenuObject(NewMenu);
5379
5381 }
5382 else
5383 {
5384 NewMenu = Popup;
5385 }
5386 if (NewMenu)
5387 {
5389
5392
5398 ItemInfo.cch = 0;
5401
5402 return SysMenu;
5403 }
5406}
HMENU APIENTRY co_IntCallLoadMenu(HINSTANCE hModule, PUNICODE_STRING pMenuName)
Definition: callback.c:903
struct tagMENUITEMINFOW MENUITEMINFOW
Referenced by IntGetSystemMenu(), and IntSetSystemMenu().
◆ MENU_HideSubPopups()
|
static |
Definition at line 3267 of file menu.c.
3269{
3271
3273 {
3275
3277 {
3282 }
3283 else
3284 return;
3285
3287 {
3288 PWND pWnd;
3295 {
3296 co_UserDestroyWindow(pWnd);
3297 }
3298
3299 /* Native returns handle to destroyed window */
3301 {
3302 co_IntSendMessage( UserHMGetHandle(pWndOwner), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(Item->spSubMenu),
3304 }
3306 // Call WM_UNINITMENUPOPUP FIRST before destroy!!
3307 // Fixes todo_wine User32 test menu.c line 2239 GetMenuBarInfo callback....
3308 //
3311 }
3312 }
3313}
Referenced by IntHiliteMenuItem(), MENU_DoNextMenu(), MENU_HideSubPopups(), MENU_KeyEscape(), MENU_KeyLeft(), MENU_KeyRight(), MENU_SwitchTracking(), and MENU_TrackMenu().
◆ MENU_InitPopup()
Definition at line 2781 of file menu.c.
2782{
2783 PWND pWndCreated;
2784 PPOPUPMENU pPopupMenu;
2785 CREATESTRUCTW Cs;
2786 LARGE_STRING WindowName;
2787 UNICODE_STRING ClassName;
2789
2791
2792 menu->spwndNotify = pWndOwner;
2793
2795 ex_style |= WS_EX_LAYOUTRTL;
2796
2798 ClassName.Length = 0;
2799
2803 Cs.dwExStyle = ex_style;
2809
2810 /* NOTE: In Windows, top menu popup is not owned. */
2812
2814
2815 //
2816 // Setup pop up menu structure.
2817 //
2819
2820 pPopupMenu = ((PMENUWND)pWndCreated)->ppopupmenu;
2821
2823 pPopupMenu->spwndNotify = pWndOwner; // Same as MenuInfo.spwndNotify(which could be wrong) or menu->hwndOwner
2824 //pPopupMenu->spmenu = menu; Should be set up already from WM_CREATE!
2825
2831
2834 else
2836
2839 {
2841 }
2843}
struct _MENUWND * PMENUWND
Definition: ntuser.h:90
Definition: winuser.h:3056
Definition: ntuser.h:442
PWND FASTCALL co_UserCreateWindowEx(CREATESTRUCTW *Cs, PUNICODE_STRING ClassName, PLARGE_STRING WindowName, PVOID acbiBuffer, DWORD dwVer)
Definition: window.c:2180
Referenced by IntTrackPopupMenuEx(), and MENU_ShowSubPopup().
◆ MENU_InitSysMenuPopup()
Definition at line 1362 of file menu.c.
1363{
1364 BOOL gray;
1365 UINT DefItem;
1366
1377 gray = (clsStyle & CS_NOCLOSE) != 0;
1378
1379 /* The menu item must keep its state if it's disabled */
1380 if(gray)
1382
1383 /* Set default menu item */
1385 else if(HitTest == HTCAPTION) DefItem = ((style & (WS_MAXIMIZE | WS_MINIMIZE)) ? SC_RESTORE : SC_MAXIMIZE);
1387
1389}
Referenced by IntDefWindowProc(), IntTrackPopupMenuEx(), and MENU_ShowSubPopup().
◆ MENU_InitTracking()
Definition at line 4404 of file menu.c.
4405{
4406 HWND capture_win;
4408
4410
4411 co_UserHideCaret(0);
4412
4413 /* This makes the menus of applications built with Delphi work.
4414 * It also enables menus to be displayed in more than one window,
4415 * but there are some bugs left that need to be fixed in this case.
4416 */
4417 if (!bPopup)
4418 {
4420 }
4421
4425 }
4426
4429
4430 /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
4432 {
4434 }
4435
4436 //
4437 // Capture is set before calling WM_INITMENU and after WM_ENTERMENULOOP, see msg_menu.
4438 //
4443
4444 co_IntSendMessage( UserHMGetHandle(pWnd), WM_SETCURSOR, (WPARAM)UserHMGetHandle(pWnd), HTCAPTION );
4445
4447 {
4449 /* If an app changed/recreated menu bar entries in WM_INITMENU
4450 * menu sizes will be recalculated once the menu created/shown.
4451 */
4452 }
4453
4454 IntNotifyWinEvent( EVENT_SYSTEM_MENUSTART,
4455 pWnd,
4457 CHILDID_SELF, 0);
4459}
Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().
◆ MENU_InsertItem()
Definition at line 639 of file menu.c.
640{
641 ITEM *newItems;
642
643 /* Find where to insert new item */
644
648 } else {
650 {
651 if (submenu) *submenu = menu;
654 }
655 }
656
657 /* Make sure that MDI system buttons stay on the right side.
658 * Note: XP treats only bitmap handles 1 - 6 as "magic" ones
659 * regardless of their id.
660 */
664 pos--;
665
667
668 /* Create new items array */
669
671 if (!newItems)
672 {
675 }
677 {
678 /* Copy the old array into the new one */
680 if (pos < menu->cItems) RtlCopyMemory( &newItems[pos+1], &menu->rgItems[pos], (menu->cItems-pos)*sizeof(ITEM) );
682 }
683 menu->rgItems = newItems;
684 menu->cItems++;
688}
Referenced by IntInsertMenuItem().
◆ MENU_IsMenuActive()
Definition at line 2650 of file menu.c.
Referenced by IntDefWindowProc().
◆ MENU_KeyEscape()
Definition at line 3913 of file menu.c.
3914{
3916
3918 {
3920 {
3921 PMENU MenuPrev, MenuTmp;
3922
3923 MenuPrev = MenuTmp = pmt->TopMenu;
3924
3925 /* close topmost popup */
3927 {
3928 MenuPrev = MenuTmp;
3929 MenuTmp = MENU_GetSubPopup(MenuPrev);
3930 }
3931
3933 pmt->CurrentMenu = MenuPrev;
3935 }
3936 }
3937
3939}
BOOL WINAPI EndMenu(void)
Referenced by MENU_TrackMenu().
◆ MENU_KeyLeft()
Definition at line 3946 of file menu.c.
3947{
3948 PMENU MenuTmp, MenuPrev;
3949 UINT PrevCol;
3950
3951 MenuPrev = MenuTmp = pmt->TopMenu;
3952
3953 /* Try to move 1 column left (if possible) */
3955 {
3957 return;
3958 }
3959
3960 /* close topmost popup */
3962 {
3963 MenuPrev = MenuTmp;
3964 MenuTmp = MENU_GetSubPopup(MenuPrev);
3965 }
3966
3968 pmt->CurrentMenu = MenuPrev;
3969
3971 {
3972 /* move menu bar selection if no more popups are left */
3973
3976
3978 {
3979 /* A sublevel menu was displayed - display the next one
3980 * unless there is another displacement coming up */
3981
3985 }
3986 }
3987}
Referenced by MENU_TrackMenu().
◆ MENU_KeyRight()
Definition at line 3994 of file menu.c.
3995{
3996 PMENU menutmp;
3997 UINT NextCol;
3998
4001
4003 {
4004 /* If already displaying a popup, try to display sub-popup */
4005
4006 menutmp = pmt->CurrentMenu;
4008
4009 /* if subpopup was displayed then we are done */
4011 }
4012
4013 /* Check to see if there's another column */
4015 {
4018 return;
4019 }
4020
4022 {
4024 {
4027 }
4028 else
4029 {
4030 menutmp = NULL;
4031 }
4032
4033 /* try to move to the next item */
4036
4038 {
4041 }
4042 }
4043}
Referenced by MENU_TrackMenu().
◆ MENU_MenuBarCalcSize()
Definition at line 2101 of file menu.c.
2102{
2103 ITEM *lpitem;
2105 int orgX, orgY, maxY;
2106
2109 //TRACE("lprect %p %s\n", lprect, wine_dbgstr_rect( lprect));
2111 lppop->cyMenu = 0;
2112 maxY = lprect->top;
2113 start = 0;
2114 helpPos = ~0U;
2115 lppop->cxTextAlign = 0;
2116 while (start < lppop->cItems)
2117 {
2119 orgX = lprect->left;
2120 orgY = maxY;
2121
2122 /* Parse items until line break or end of menu */
2124 {
2128
2130 //debug_print_menuitem (" item: ", lpitem, "");
2131 //MENU_CalcItemSize( hdc, lpitem, pwndOwner, orgX, orgY, TRUE, lppop );
2133
2135 {
2138 }
2139 maxY = max( maxY, lpitem->cyItem );
2140 orgX = lpitem->cxItem;
2141 }
2142
2143 /* Finish the line (set all items to the largest height found) */
2144
2145/* FIXME: Is this really needed? */ /*NO! it is not needed, why make the
2146 HBMMENU_MBAR_CLOSE, MINIMIZE & RESTORE, look the same size as the menu bar! */
2147#if 0
2149#endif
2151 }
2152
2153 lprect->bottom = maxY + 1;
2155
2156 /* Flush right all items between the MF_RIGHTJUSTIFY and */
2157 /* the last item (if several lines, only move the last line) */
2160 orgY = lpitem->yItem;
2161 orgX = lprect->right;
2163 if (lpitem->yItem != orgY) break; /* Other line */
2164 if (lpitem->cxItem >= orgX) break; /* Too far right already */
2165 lpitem->xItem += orgX - lpitem->cxItem;
2166 lpitem->cxItem = orgX;
2167 orgX = lpitem->xItem;
2168 }
2169}
Referenced by IntDrawMenuBarTemp(), and MENU_DrawMenuBar().
◆ MENU_MouseMove()
Definition at line 3692 of file menu.c.
3693{
3695
3696 if ( PtMenu )
3698
3700 {
3702 }
3704 {
3707 }
3709}
Referenced by MENU_TrackMenu().
◆ MENU_MoveRect()
|
static |
Definition at line 2888 of file menu.c.
2889{
2890 /* Figure out if we should move vertical or horizontal */
2892 {
2893 /* Move in the vertical direction: TPM_BOTTOMALIGN means drop it above, otherways drop it below */
2895 {
2897 {
2900 }
2901 }
2902 else
2903 {
2905 {
2908 }
2909 }
2910 }
2911 else
2912 {
2913 /* Move in the horizontal direction: TPM_RIGHTALIGN means drop it to the left, otherways go right */
2915 {
2917 {
2920 }
2921 }
2922 else
2923 {
2925 {
2928 }
2929 }
2930 }
2932}
Referenced by MENU_ShowPopup().
◆ MENU_MoveSelection()
Definition at line 3231 of file menu.c.
3232{
3234
3236
3238
3240 {
3242 return;
3243 else
3247 {
3249 return;
3250 }
3251 }
3252
3256 {
3258 return;
3259 }
3260}
Referenced by MENU_KeyLeft(), MENU_KeyRight(), MENU_ShowSubPopup(), MENU_TrackKbdMenuBar(), and MENU_TrackMenu().
◆ MENU_PopupMenuCalcSize()
Definition at line 2012 of file menu.c.
2013{
2014 PITEM lpitem;
2017 int orgX, orgY, maxX, maxTab, maxTabWidth, maxHeight;
2019
2022
2024
2026
2027 start = 0;
2028 maxX = 0;
2029
2030 Menu->cxTextAlign = 0;
2031
2032 while (start < Menu->cItems)
2033 {
2035 orgX = maxX;
2037 orgX += MENU_COL_SPACE;
2038 orgY = 0;
2039
2040 maxTab = maxTabWidth = 0;
2041 /* Parse items until column break or end of menu */
2043 {
2046
2049 orgY = lpitem->cyItem;
2051 {
2054 }
2056 }
2057
2058 /* Finish the column (set all items to the largest width found) */
2059 maxX = max( maxX, maxTab + maxTabWidth );
2061 {
2062 lpitem->cxItem = maxX;
2064 lpitem->dxTab = maxTab;
2065 }
2067 }
2068
2069 Menu->cxMenu = maxX;
2070 /* if none of the items have both text and bitmap then
2071 * the text and bitmaps are all aligned on the left. If there is at
2072 * least one item with both text and bitmap then bitmaps are
2073 * on the left and texts left aligned with the right hand side
2074 * of the bitmaps */
2076
2077 /* Adjust popup height if it exceeds maximum */
2078 maxHeight = MENU_GetMaxPopupHeight(Menu);
2081 {
2082 Menu->cyMenu = maxHeight;
2083 Menu->dwArrowsOn = 1;
2084 }
2085 else
2086 {
2087 Menu->dwArrowsOn = 0;
2088 }
2090}
Referenced by MENU_ShowPopup().
◆ MENU_PtMenu()
Definition at line 3652 of file menu.c.
3653{
3654 PITEM pItem;
3656
3658
3659 /* try subpopup first (if any) */
3661 {
3662 pItem = menu->rgItems;
3665 {
3667 }
3668 }
3669
3670 /* check the current window (avoiding WM_HITTEST) */
3672 {
3676 {
3678 }
3683 }
3685}
Referenced by MENU_PtMenu(), and MENU_TrackMenu().
◆ MENU_SelectItem()
|
static |
Definition at line 3144 of file menu.c.
3146{
3148 PWND pWnd;
3149
3150 TRACE("M_SI: owner=%p menu=%p index=0x%04x select=0x%04x\n", pwndOwner, menu, wIndex, sendMenuSelect);
3151
3153
3155
3156 if (!pWnd) return;
3157
3159
3162 else
3164
3167 //pPopupMenu->fIsTrackPopup set pPopupMenu->spwndPopupMenu;
3169 }
3170
3172
3173 /* Clear previous highlighted item */
3175 {
3179 ODA_SELECT);
3180 }
3181
3182 /* Highlight new item (if any) */
3183 menu->iItem = wIndex;
3185 {
3187 {
3192 }
3193 if (sendMenuSelect)
3194 {
3200
3201 co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(menu));
3202 }
3203 }
3204 else if (sendMenuSelect)
3205 {
3206 if (topmenu)
3207 {
3211 {
3216
3217 co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(topmenu));
3218 }
3219 }
3220 }
3222}
Definition: dhcpd.h:62
Referenced by IntHiliteMenuItem(), MENU_DoNextMenu(), MENU_HideSubPopups(), MENU_KeyLeft(), MENU_KeyRight(), MENU_MouseMove(), MENU_MoveSelection(), MENU_SwitchTracking(), MENU_TrackKbdMenuBar(), and MENU_TrackMenu().
◆ MENU_ShowPopup()
|
static |
Definition at line 2939 of file menu.c.
2941{
2943 POINT ptx;
2944 PMONITOR monitor;
2945 PWND pWnd;
2946 USER_REFERENCE_ENTRY Ref;
2948
2951
2953 {
2956 }
2957
2958#if SHOW_DEBUGRECT
2959 if (pExclude)
2960 DebugRect(pExclude, RGB(255, 0, 0));
2961#endif
2962
2963 menu->dwArrowsOn = 0;
2964 MENU_PopupMenuCalcSize(menu, pwndOwner);
2965
2966 /* adjust popup menu pos so that it fits within the desktop */
2967
2970
2973
2978
2983
2984 /* FIXME: should use item rect */
2987#if SHOW_DEBUGRECT
2989#endif
2990 monitor = UserMonitorFromPoint( ptx, MONITOR_DEFAULTTONEAREST );
2991
2992 /* We are off the right side of the screen */
2994 {
2995 /* Position menu at right edge of the screen */
2997 }
2998
2999 /* We are off the left side of the screen */
3000 if (x < monitor->rcMonitor.left)
3001 {
3002 /* Position menu at left edge of the screen */
3003 x = 0;
3004
3007 }
3008
3009 /* Same here, but then the top */
3010 if (y < monitor->rcMonitor.top)
3011 {
3013
3016 }
3017
3018 /* And the bottom */
3020 {
3023 else
3024 {
3029 else
3031 }
3032 }
3033
3034 if (pExclude)
3035 {
3036 RECT Cleaned;
3037
3040 {
3041 UINT flag_mods[] = {
3042 0, /* First try the 'normal' way */
3045 TPM_BOTTOMALIGN | TPM_RIGHTALIGN | TPM_VERTICAL, /* Then the other side again (still swapped hor/ver) */
3046 };
3047
3050 {
3053
3054 /* Try to move a bit around */
3057 {
3058 x = tx;
3060 break;
3061 }
3062 }
3063 /* If none worked, we go with the original x/y */
3064 }
3065 }
3066
3067#if SHOW_DEBUGRECT
3068 {
3070 DebugRect(&rr, RGB(0, 255, 0));
3071 }
3072#endif
3073
3075
3076 if (!pWnd)
3077 {
3080 }
3081
3085 }
3086
3087 /* Display the window */
3088 UserRefObjectCo(pWnd, &Ref);
3089 co_WinPosSetWindowPos( pWnd, HWND_TOPMOST, x, y, width, height, SWP_SHOWWINDOW | SWP_NOACTIVATE);
3090
3092
3094 UserDerefObjectCo(pWnd);
3095
3097}
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1792
Definition: winsplp.h:754
VOID FASTCALL co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:519
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
PMONITOR FASTCALL UserMonitorFromPoint(IN POINT pt, IN DWORD dwFlags)
Definition: monitor.c:481
Referenced by IntTrackPopupMenuEx(), and MENU_ShowSubPopup().
◆ MENU_ShowSubPopup()
|
static |
Definition at line 3321 of file menu.c.
3322{
3325 HDC Dc;
3326 PWND pWnd;
3327
3329
3330 if (!Menu) return Menu;
3331
3333
3336 return Menu;
3337
3338 /* message must be sent before using item,
3339 because nearly everything may be changed by the application ! */
3340
3341 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
3343 {
3347 }
3348
3350 //Rect = ItemInfo.Rect;
3355
3357
3358 /* Grab the rect of our (entire) parent menu, so we can try to not overlap it */
3360 {
3362 {
3364 ParentRect = Rect;
3365 }
3366
3367 /* Ensure we can slightly overlap our parent */
3369 }
3370 else
3371 {
3372 /* Inside the menu bar, we do not want to grab the entire window... */
3373 ParentRect = Rect;
3374 if (pWnd)
3376 }
3377
3378 /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
3380 {
3383
3385
3389
3391 }
3392
3394 {
3399 }
3401
3403 {
3405
3407 /* Ensure we do not overlap this */
3408 ParentRect = Rect;
3413 }
3414 else
3415 {
3418 {
3419 RECT rc;
3424
3425 MENU_AdjustMenuItemRect(Menu, &rc);
3426
3427 /* The first item in the popup menu has to be at the
3428 same y position as the focused menu item */
3431 else
3433
3435 }
3436 else
3437 {
3440 else
3445 }
3446 }
3447
3448 /* Next menu does not need to be shown vertical anymore */
3450 Flags &= (~TPM_VERTICAL);
3451
3452
3453
3454 /* use default alignment for submenus */
3456
3458
3461 if (SelectFirst)
3462 {
3464 }
3466}
Referenced by MENU_ButtonDown(), MENU_ExecFocusedItem(), MENU_KeyLeft(), MENU_KeyRight(), MENU_MouseMove(), and MENU_TrackMenu().
◆ MENU_SuspendPopup()
Definition at line 3877 of file menu.c.
3878{
3880
3882
3885
3886 switch( uMsg )
3887 {
3891 {
3896 {
3899 }
3900 }
3901 break;
3902 }
3903 /* failures go through this */
3904 pmt->TrackFlags &= ~TF_SUSPENDPOPUP;
3906}
BOOL APIENTRY co_IntGetPeekMessage(PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg, BOOL bGMSG)
Definition: message.c:1226
Referenced by MENU_KeyLeft(), and MENU_KeyRight().
◆ MENU_SwitchTracking()
|
static |
Definition at line 3533 of file menu.c.
3534{
3536
3539 {
3540 /* both are top level menus (system and menu-bar) */
3543 pmt->TopMenu = PtMenu;
3544 }
3545 else
3546 {
3548 }
3549
3551}
Referenced by MENU_ButtonDown(), and MENU_MouseMove().
◆ MENU_TrackKbdMenuBar()
Definition at line 4516 of file menu.c.
4517{
4519 PMENU TrackMenu;
4521
4523
4524 /* find window that has a menu */
4525
4528
4529 /* check if we have to track a system menu */
4530
4533 {
4536 uItem = 0;
4538 }
4539
4541
4543
4544 /* fetch the window menu again, it may have changed */
4545 TrackMenu = (wParam & HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pwnd) ) : IntGetMenu( UserHMGetHandle(pwnd) );
4546
4547 if( wChar && wChar != ' ' )
4548 {
4551 {
4552 if( uItem == (UINT)(-1) ) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
4553 /* schedule end of menu tracking */
4555 goto track_menu;
4556 }
4557 }
4558
4560
4562 {
4565 else
4567 }
4568
4569track_menu:
4572}
PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type)
Referenced by DefWndHandleSysCommand().
◆ MENU_TrackMenu()
Definition at line 4050 of file menu.c.
4052{
4054 BOOL fRemove;
4055 INT executedMenuId = -1;
4056 MTRACKER mt;
4057 HWND capture_win;
4058 PMENU pmMouse;
4061 PWND pWnd;
4063
4065 {
4067 }
4068
4069 mt.TrackFlags = 0;
4070 mt.CurrentMenu = pmenu;
4071 mt.TopMenu = pmenu;
4072 mt.OwnerWnd = pwnd;
4075
4078
4079 pti->MessageQueue->QF_flags &= ~QF_ACTIVATIONCHANGE;
4080
4082 {
4083 /* Get the result in order to start the tracking or not */
4085 fInsideMenuLoop = fRemove;
4086 }
4087
4089
4091 {
4093 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4095 return 0;
4096 }
4097
4098 capture_win = IntGetCapture();
4099
4101 {
4104 break;
4105
4106 /* we have to keep the message in the queue until it's
4107 * clear that menu loop is not over yet. */
4108
4109 for (;;)
4110 {
4112 {
4114 /* remove the message from the queue */
4116 }
4117 else
4118 {
4119 /* ReactOS Checks */
4122 //pti->MessageQueue->QF_flags & QF_ACTIVATIONCHANGE || // See CORE-17338
4124 {
4126 break;
4127 }
4128
4129 if (!enterIdleSent)
4130 {
4132 enterIdleSent = TRUE;
4134 }
4136 }
4137 }
4138
4140
4141 /* check if EndMenu() tried to cancel us, by posting this message */
4143 {
4144 /* we are now out of the loop */
4146
4147 /* remove the message from the queue */
4149
4150 /* break out of internal loop, ala ESCAPE */
4151 break;
4152 }
4153
4155
4156 if ( (msg.hwnd == mt.CurrentMenu->hWnd) || ((msg.message!=WM_TIMER) && (msg.message!=WM_SYSTIMER)) )
4157 enterIdleSent=FALSE;
4158
4159 fRemove = FALSE;
4161 {
4162 /*
4163 * Use the mouse coordinates in lParam instead of those in the MSG
4164 * struct to properly handle synthetic messages. They are already
4165 * in screen coordinates.
4166 */
4169
4170 /* Find a menu for this mouse event */
4172
4174 {
4175 /* no WM_NC... messages in captured state */
4176
4180 {
4182 break;
4183 }
4184 /* fall through */
4187 {
4188 /* If the message belongs to the menu, removes it from the queue */
4189 /* Else, end menu tracking */
4191 /* Don't remove WM_LBUTTONDBLCLK to allow the closing of a window or program */
4193 fRemove = FALSE;
4194 else
4196
4197 fInsideMenuLoop = fRemove;
4200 break;
4201 }
4202
4205 /* fall through */
4207 /* Check if a menu was selected by the mouse */
4208 if (pmMouse)
4209 {
4211 /* Exit system menu if system icon is clicked a second time */
4213 {
4214 fRemove = TRUE;
4216 }
4217 else
4218 {
4219 /* End the loop if executedMenuId is an item ID */
4220 /* or if the job was done (executedMenuId = 0). */
4222 fRemove = (executedMenuId != -1);
4223 fInsideMenuLoop = !fRemove;
4224 firstClick = FALSE;
4225 }
4226 }
4227 /* No menu was selected by the mouse */
4228 /* if the function was called by TrackPopupMenu, continue
4229 with the menu tracking. If not, stop it */
4230 else
4232
4233 break;
4234
4236 /* the selected menu item must be changed every time */
4237 /* the mouse moves. */
4238
4239 if (pmMouse)
4241
4242 } /* switch(msg.message) - mouse */
4243 }
4245 {
4248 {
4252 {
4256 break;
4257
4261 MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, VK_HOME == msg.wParam ? ITEM_NEXT : ITEM_PREV);
4262 break;
4263
4268 else /* otherwise try to move selection */
4269 MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, (msg.wParam == VK_UP)? ITEM_PREV : ITEM_NEXT );
4270 break;
4271
4274 break;
4275
4278 break;
4279
4282 break;
4283
4285 {
4286 HELPINFO hi;
4290 hi.iCtrlId = 0;
4291 else
4297 break;
4298 }
4299
4300 default:
4302 break;
4303 }
4304 break; /* WM_KEYDOWN */
4305
4308 {
4310 BOOL fEndMenu;
4311
4313 {
4315 fEndMenu = (executedMenuId != -2);
4316 fInsideMenuLoop = !fEndMenu;
4317 break;
4318 }
4319
4320 /* Hack to avoid control chars. */
4321 /* We will find a better way real soon... */
4323
4325
4327 else if (pos == (UINT)-1) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
4328 else
4329 {
4332 fEndMenu = (executedMenuId != -2);
4333 fInsideMenuLoop = !fEndMenu;
4334 }
4335 }
4336 break;
4337 } /* switch(msg.message) - kbd */
4338 }
4339 else
4340 {
4343 continue;
4344 }
4345
4347
4348 /* finally remove message from the queue */
4349
4353 }
4354
4356 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4358
4359 /* If dropdown is still painted and the close box is clicked on
4360 then the menu will be destroyed as part of the DispatchMessage above.
4361 This will then invalidate the menu handle in mt.hTopMenu. We should
4362 check for this first. */
4364 {
4366 {
4368
4370 {
4372 if (pwndTM)
4373 {
4375
4376 co_UserDestroyWindow(pwndTM);
4377 }
4379
4381 {
4382 co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(mt.TopMenu),
4384 }
4385 }
4388 }
4389
4390 /* Reset the variable for hiding menu */
4392 }
4393
4395 /* The return value is only used by TrackPopupMenu */
4397 if (executedMenuId == -1) executedMenuId = 0;
4398 return executedMenuId;
4399}
Definition: winuser.h:3413
BOOL FASTCALL IntTranslateKbdMessage(LPMSG lpMsg, UINT flags)
Definition: keyboard.c:1276
BOOL FASTCALL co_IntWaitMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax)
Definition: message.c:1180
struct tagHELPINFO HELPINFO
Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().
◆ MENU_TrackMouseMenuBar()
Definition at line 4486 of file menu.c.
4487{
4488 PMENU pMenu = (ht == HTSYSMENU) ? IntGetSystemMenu(pWnd, FALSE) : IntGetMenu( UserHMGetHandle(pWnd) ); // See 74276 and CORE-12801
4490
4492
4495 {
4496 /* map point to parent client coordinates */
4499 {
4501 }
4502
4504 /* fetch the window menu again, it may have changed */
4505 pMenu = (ht == HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pWnd) ) : IntGetMenu( UserHMGetHandle(pWnd) );
4508 }
4509}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
Referenced by DefWndHandleSysCommand().
◆ MenuInit()
Definition at line 359 of file menu.c.
360{
361 NONCLIENTMETRICSW ncm;
362
363 /* get the menu font */
365 {
366 ncm.cbSize = sizeof(ncm);
368 {
371 }
372
375 {
378 }
382 {
387 }
388
391
392 co_IntSetupOBM();
393 }
394
396}
Referenced by ClientThreadSetupHelper(), and co_IntInitializeDesktopGraphics().
◆ NtUserCalcMenuBar()
| DWORD APIENTRY NtUserCalcMenuBar | ( | HWND | hwnd, |
| DWORD | leftBorder, | ||
| DWORD | rightBorder, | ||
| DWORD | top, | ||
| LPRECT | prc | ||
| ) |
◆ NtUserCheckMenuItem()
Definition at line 5609 of file menu.c.
5613{
5614 PMENU Menu;
5616
5618 UserEnterExclusive();
5619
5620 Menu = UserGetMenuObject(hMenu);
5621 if (Menu)
5622 {
5623 Ret = IntCheckMenuItem(Menu, uIDCheckItem, uCheck);
5624 }
5625
5626 UserLeave();
5628 return Ret;
5629}
Referenced by CheckMenuItem().
◆ NtUserDeleteMenu()
Definition at line 5635 of file menu.c.
5639{
5640 PMENU Menu;
5642
5644 UserEnterExclusive();
5645
5646 Menu = UserGetMenuObject(hMenu);
5647 if (Menu)
5648 {
5650 }
5651
5652 UserLeave();
5654 return Ret;
5655}
Referenced by DeleteMenu().
◆ NtUserDestroyMenu()
Definition at line 5842 of file menu.c.
5844{
5845 PMENU Menu;
5847
5849 UserEnterExclusive();
5850
5852 {
5854 }
5856 {
5859 }
5861
5862Exit:
5863 UserLeave();
5865 return Ret;
5866}
Referenced by DestroyMenu(), and WIN_CreateWindowEx().
◆ NtUserDrawMenuBarTemp()
Definition at line 6248 of file menu.c.
6254{
6255 PMENU Menu;
6259 DWORD Ret = 0;
6260
6262 UserEnterExclusive();
6263
6265 {
6268 }
6269
6271 {
6274 }
6275
6276 _SEH2_TRY
6277 {
6280 }
6282 {
6284 }
6285 _SEH2_END;
6286
6288 {
6291 }
6292
6294
6295Exit:
6296 UserLeave();
6298 return Ret;
6299}
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
◆ NtUserEnableMenuItem()
Definition at line 5872 of file menu.c.
5876{
5877 PMENU Menu;
5879
5881 UserEnterExclusive();
5882
5883 Menu = UserGetMenuObject(hMenu);
5884 if (Menu)
5885 {
5886 Ret = IntEnableMenuItem(Menu, uIDEnableItem, uEnable);
5887 }
5888
5889 UserLeave();
5891 return Ret;
5892}
Referenced by EnableMenuItem().
◆ NtUserEndMenu()
Definition at line 5898 of file menu.c.
5899{
5900 //PWND pWnd;
5902 UserEnterExclusive();
5903 /* if ( gptiCurrent->pMenuState &&
5904 gptiCurrent->pMenuState->pGlobalPopupMenu )
5905 {
5906 pWnd = IntGetMSWND(gptiCurrent->pMenuState);
5907 if (pWnd)
5908 {
5909 UserPostMessage( UserHMGetHandle(pWnd), WM_CANCELMODE, 0, 0);
5910 }
5911 else
5912 gptiCurrent->pMenuState->fInsideMenuLoop = FALSE;
5913 }*/
5915 {
5918 }
5919 UserLeave();
5922}
◆ NtUserGetMenuBarInfo()
Definition at line 5928 of file menu.c.
5933{
5934 PWND pWnd;
5935 HMENU hMenu;
5936 MENUBARINFO kmbi;
5938 PPOPUPMENU pPopupMenu;
5939 USER_REFERENCE_ENTRY Ref;
5942
5944 UserEnterShared();
5945
5947 {
5950 }
5951
5952 UserRefObjectCo(pWnd, &Ref);
5953
5959
5960 switch (idObject)
5961 {
5966 {
5970 }
5971 // Windows does this! Wine checks for Atom and uses GetWindowLongPtrW.
5973 pPopupMenu = ((PMENUWND)pWnd)->ppopupmenu;
5975 {
5977 {
5978 ERR("Window Pop Up hMenu %p not the same as Get hMenu %p!\n", UserHMGetHandle(pPopupMenu->spmenu), hMenu);
5979 }
5980 }
5981 break;
5987 break;
5992 hMenu = UserHMGetHandle(Menu);
5993 break;
5994 default:
5996 }
5997
5998 if (!hMenu)
6000
6001 _SEH2_TRY
6002 {
6005 }
6007 {
6008 kmbi.cbSize = 0;
6009 }
6010 _SEH2_END
6011
6013 {
6016 }
6017
6018 if (!Menu)
6019 {
6020 Menu = UserGetMenuObject(hMenu);
6021 if (!Menu)
6023 }
6024
6027
6028 if (idItem == 0)
6029 {
6034 }
6035 else
6036 {
6039 }
6040
6041 kmbi.hMenu = hMenu;
6044 if (idItem)
6045 {
6048 {
6050 }
6051 }
6052 else
6053 {
6055 }
6056
6057 _SEH2_TRY
6058 {
6061 }
6063 {
6065 }
6066 _SEH2_END
6067
6069 {
6071 Ret = FALSE;
6073 }
6074
6075 Ret = TRUE;
6076
6077Cleanup:
6079 UserLeave();
6081 return Ret;
6082}
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
Definition: winuser.h:3827
◆ NtUserGetMenuIndex()
Definition at line 6088 of file menu.c.
6091{
6092 PMENU Menu, SubMenu;
6093 PITEM MenuItem;
6095 UINT Ret = 0xFFFFFFFF;
6096
6098 UserEnterShared();
6099
6101 !(SubMenu = UserGetMenuObject(hSubMenu)) )
6103
6104 MenuItem = Menu->rgItems;
6106 {
6108 {
6109 Ret = MenuItem->wID;
6110 break;
6111 }
6112 }
6113
6114Exit:
6115 UserLeave();
6117 return Ret;
6118}
Referenced by GetMenuIndex().
◆ NtUserGetMenuItemRect()
Definition at line 6124 of file menu.c.
6129{
6130 PWND ReferenceWnd;
6131 LONG XMove, YMove;
6133 PMENU Menu;
6134 PITEM MenuItem;
6137
6139 UserEnterShared();
6140
6142 {
6144 }
6145
6147 {
6152 }
6153 else
6155
6157 {
6159 }
6160
6163
6166
6168 {
6171 }
6172 else
6173 {
6176 }
6177
6178 Rect.left += XMove;
6179 Rect.top += YMove;
6180 Rect.right += XMove;
6181 Rect.bottom += YMove;
6182
6183 _SEH2_TRY
6184 {
6186 }
6188 {
6190 }
6191 _SEH2_END
6192
6194 {
6197 }
6198 Ret = TRUE;
6199
6200Exit:
6201 UserLeave();
6203 return Ret;
6204}
Definition: polytest.cpp:52
◆ NtUserGetSystemMenu()
Definition at line 5685 of file menu.c.
5686{
5688 PMENU Menu;
5690
5692 UserEnterExclusive();
5693
5695 {
5697 }
5698
5700 {
5702 }
5703
5704 Ret = UserHMGetHandle(Menu);
5705
5706Exit:
5707 UserLeave();
5709 return Ret;
5710}
Referenced by GetSystemMenu().
◆ NtUserGetTitleBarInfo()
| BOOLEAN APIENTRY NtUserGetTitleBarInfo | ( | HWND | hwnd, |
| PTITLEBARINFO | bti | ||
| ) |
Definition at line 5759 of file menu.c.
5762{
5763 PWND WindowObject;
5764 TITLEBARINFO bartitleinfo;
5766
5768 UserEnterExclusive();
5769
5770 /* Validate the window handle */
5772 {
5775 }
5776
5777 /* Copy user mode buffer to local buffer */
5778 _SEH2_TRY
5779 {
5782 }
5784 {
5787 }
5788 _SEH2_END
5789
5790 /* Get the tile bar info */
5791 retValue = intGetTitleBarInfo(WindowObject, &bartitleinfo);
5792 if (!retValue)
5793 {
5794 // intGetTitleBarInfo() set LastError.
5796 }
5797
5798 /* Copy local buffer back to user mode buffer */
5799 _SEH2_TRY
5800 {
5803 }
5805 {
5807 retValue = FALSE;
5808 }
5809 _SEH2_END;
5810
5811Exit:
5812 UserLeave();
5814 return retValue;
5815}
Referenced by GetTitleBarInfo(), and START_TEST().
◆ NtUserHiliteMenuItem()
◆ NtUserMenuItemFromPoint()
Definition at line 6305 of file menu.c.
6310{
6311 PMENU Menu;
6315 int Ret = -1;
6316
6318 UserEnterExclusive();
6319
6321 {
6323 }
6324
6326 {
6328 }
6329
6332
6335 {
6337
6342
6344
6346 {
6347 break;
6348 }
6349 }
6350
6352
6353Exit:
6354 UserLeave();
6356 return Ret;
6357}
Definition: rawriter_test.cpp:12
#define Y(I)
◆ NtUserPaintMenuBar()
| DWORD APIENTRY NtUserPaintMenuBar | ( | HWND | hWnd, |
| HDC | hDC, | ||
| ULONG | leftBorder, | ||
| ULONG | rightBorder, | ||
| ULONG | top, | ||
| BOOL | bActive | ||
| ) |
◆ NtUserRemoveMenu()
Definition at line 6398 of file menu.c.
6402{
6403 PMENU Menu;
6405
6407 UserEnterExclusive();
6408
6409 Menu = UserGetMenuObject(hMenu);
6410 if (Menu)
6411 {
6413 }
6414
6415 UserLeave();
6417 return Ret;
6418}
Referenced by RemoveMenu().
◆ NtUserSetMenu()
Definition at line 6424 of file menu.c.
6428{
6430 BOOL Changed;
6432
6434 UserEnterExclusive();
6435
6437 {
6439 }
6440
6442 {
6444 }
6445
6446 // Not minimized and please repaint!!!
6448 {
6449 USER_REFERENCE_ENTRY Ref;
6451 co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
6453 }
6454
6455 Ret = TRUE;
6456
6457Exit:
6458 UserLeave();
6460 return Ret;
6461}
Referenced by SetMenu().
◆ NtUserSetMenuContextHelpId()
Definition at line 6467 of file menu.c.
6470{
6471 PMENU Menu;
6473
6475 UserEnterExclusive();
6476
6477 Menu = UserGetMenuObject(hMenu);
6478 if (Menu)
6479 {
6480 Ret = IntSetMenuContextHelpId(Menu, dwContextHelpId);
6481 }
6482
6483 UserLeave();
6485 return Ret;
6486}
Referenced by SetMenuContextHelpId().
◆ NtUserSetMenuDefaultItem()
Definition at line 6492 of file menu.c.
6496{
6497 PMENU Menu;
6499
6501 UserEnterExclusive();
6502
6503 Menu = UserGetMenuObject(hMenu);
6504 if (Menu)
6505 {
6506 Ret = UserSetMenuDefaultItem(Menu, uItem, fByPos);
6507 }
6508
6509 UserLeave();
6511 return Ret;
6512}
Referenced by SetMenuDefaultItem().
◆ NtUserSetMenuFlagRtoL()
Definition at line 6518 of file menu.c.
6520{
6521 PMENU Menu;
6523
6525 UserEnterExclusive();
6526
6527 Menu = UserGetMenuObject(hMenu);
6528 if (Menu)
6529 {
6530 Ret = IntSetMenuFlagRtoL(Menu);
6531 }
6532
6533 UserLeave();
6535 return Ret;
6536}
◆ NtUserSetSystemMenu()
Definition at line 5720 of file menu.c.
5721{
5724 PMENU Menu;
5725
5727 UserEnterExclusive();
5728
5730 {
5732 }
5733
5734 if (hMenu)
5735 {
5736 /*
5737 * Assign new menu handle and Up the Lock Count.
5738 */
5740 {
5742 }
5743
5745 }
5746 else
5748
5749Exit:
5750 UserLeave();
5753}
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by SetSystemMenu().
◆ NtUserThunkedMenuInfo()
| BOOL APIENTRY NtUserThunkedMenuInfo | ( | HMENU | hMenu, |
| LPCMENUINFO | lpcmi | ||
| ) |
Definition at line 6542 of file menu.c.
6545{
6546 PMENU Menu;
6548
6550 UserEnterExclusive();
6551
6552 Menu = UserGetMenuObject(hMenu);
6553 if (Menu)
6554 {
6556 }
6557
6558 UserLeave();
6560 return Ret;
6561}
Definition: menu.h:74
Referenced by SetMenuInfo().
◆ NtUserThunkedMenuItemInfo()
| BOOL APIENTRY NtUserThunkedMenuItemInfo | ( | HMENU | hMenu, |
| UINT | uItem, | ||
| BOOL | fByPosition, | ||
| BOOL | bInsert, | ||
| LPMENUITEMINFOW | lpmii, | ||
| PUNICODE_STRING | lpszCaption | ||
| ) |
Definition at line 6567 of file menu.c.
6574{
6575 PMENU Menu;
6577 UNICODE_STRING lstrCaption = { 0 };
6579
6581
6582 UserEnterExclusive();
6583
6585 {
6587 }
6588
6589 /* Check if we got a Caption */
6591 {
6592 /* Copy the string to kernel mode */
6594 UserMode,
6595 lpszCaption);
6597 {
6601 }
6602 }
6603
6605 {
6606 Ret = UserInsertMenuItem(Menu, uItem, fByPosition, lpmii, &lstrCaption);
6607 }
6608 else
6609 {
6611 }
6612
6613Cleanup:
6614 UserLeave();
6615
6617 {
6619 }
6620
6622 return Ret;
6623}
static __inline NTSTATUS ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest, IN KPROCESSOR_MODE CurrentMode, IN const UNICODE_STRING *UnsafeSrc)
Definition: probe.h:142
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:239
Referenced by AppendMenuA(), AppendMenuW(), CheckMenuRadioItem(), InsertMenuA(), InsertMenuItemA(), InsertMenuItemW(), InsertMenuW(), ModifyMenuA(), ModifyMenuW(), SetMenuItemInfoA(), and SetMenuItemInfoW().
◆ NtUserTrackPopupMenuEx()
| BOOL NTAPI NtUserTrackPopupMenuEx | ( | _In_ HMENU | hMenu, |
| _In_ UINT | fuFlags, | ||
| _In_ INT | x, | ||
| _In_ INT | y, | ||
| _In_ HWND | hWnd, | ||
| _In_opt_ LPTPMPARAMS | lptpm | ||
| ) |
Definition at line 6634 of file menu.c.
6641{
6642 PMENU menu;
6643 PWND pWnd;
6644 TPMPARAMS tpm;
6646 USER_REFERENCE_ENTRY WndRef, MenuRef;
6647
6649
6651 {
6654 goto Exit0;
6655 }
6656
6657 UserEnterExclusive();
6658
6659 /* Parameter check */
6661 {
6665 }
6666
6668 {
6671 }
6672
6673 if (lptpm)
6674 {
6675 _SEH2_TRY
6676 {
6678 tpm = *lptpm;
6679 }
6681 {
6683 }
6684 _SEH2_END
6685 }
6686
6687 UserRefObjectCo(pWnd, &WndRef);
6688 UserRefObjectCo(menu, &MenuRef);
6690 UserDerefObjectCo(menu);
6691 UserDerefObjectCo(pWnd);
6692
6693Exit:
6694 UserLeave();
6695
6696Exit0:
6698 return Ret;
6699}
Definition: winuser.h:3676
Referenced by TrackPopupMenu().
◆ PopupMenuWndProc()
| BOOL WINAPI PopupMenuWndProc | ( | PWND | Wnd, |
| UINT | Message, | ||
| WPARAM | wParam, | ||
| LPARAM | lParam, | ||
| LRESULT * | lResult | ||
| ) |
Definition at line 4657 of file menu.c.
4663{
4664 PPOPUPMENU pPopupMenu;
4665
4666 *lResult = 0;
4667
4669
4670 if (Wnd)
4671 {
4673 {
4675 {
4678 }
4682 {
4684 }
4686 pPopupMenu->spwndPopupMenu = Wnd;
4687 ((PMENUWND)Wnd)->ppopupmenu = pPopupMenu;
4689 *lResult = 1;
4691 }
4692 else
4693 {
4695 {
4698 }
4699 pPopupMenu = ((PMENUWND)Wnd)->ppopupmenu;
4700 }
4701 }
4702
4704 {
4706 {
4710 {
4712 }
4713 break;
4714 }
4715
4717 *lResult = MA_NOACTIVATE;
4718 break;
4719
4721 {
4722 PAINTSTRUCT ps;
4723 IntBeginPaint(Wnd, &ps);
4725 IntEndPaint(Wnd, &ps);
4726 break;
4727 }
4728
4730 {
4732 break;
4733 }
4734
4736 *lResult = 1;
4737 break;
4738
4740 /* zero out global pointer in case resident popup window was destroyed. */
4741 if (pPopupMenu)
4742 {
4744 {
4747 }
4748 }
4749 else
4750 {
4752 }
4753 break;
4754
4756 {
4758 {
4760 }
4762 ((PMENUWND)Wnd)->ppopupmenu = 0;
4764 break;
4765 }
4766
4769 {
4771 if (!pmenu)
4772 {
4774 break;
4775 }
4776 UserReferenceObject(pmenu);
4778 {
4780 }
4781 pPopupMenu->spmenu = pmenu;
4782 break;
4783 }
4784
4787 *lResult = (LRESULT)(pPopupMenu ? (pPopupMenu->spmenu ? UserHMGetHandle(pPopupMenu->spmenu) : NULL) : NULL);
4788 break;
4789
4790 default:
4792 {
4794 }
4797 break;
4798 }
4799
4801}
LRESULT FASTCALL IntDefWindowProc(PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)
Definition: defwnd.c:638
Definition: winuser.h:3206
Referenced by co_IntSendMessageTimeoutSingle(), co_IntSendMessageWithCallBack(), IntDispatchMessage(), and NtUserMessageCall().
◆ RECTL_Intersect()
◆ UITOOLS95_DrawFrameMenu()
Definition at line 959 of file draw.c.
960{
961 LOGFONTW lf;
964 RECT myr;
965 INT cxy;
968 {
971 break;
972
975 break;
976
979 break;
980
983 break;
984
987 break;
988
992 break;
993
994 default:
997 }
998 /* acquire ressources only if valid menu */
1000 lf.lfHeight = cxy;
1001 lf.lfWidth = 0;
1006 /* save font */
1008
1011 {
1012#if 0
1014 {
1015 /* draw shadow */
1018 }
1019#endif
1020 IntGdiSetTextColor(dc, IntGetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
1021 }
1022 /* draw selected symbol */
1024 /* restore previous settings */
1028}
Definition: Symbol.h:9
int FASTCALL UITOOLS_MakeSquareRect(LPRECT src, LPRECT dst)
Definition: draw.c:566
Referenced by DrawFrameControl(), MENU_DrawMenuItem(), MENU_DrawScrollArrows(), and RealDrawFrameControl().
◆ UserCreateMenu()
Definition at line 5058 of file menu.c.
5059{
5060 PWINSTATION_OBJECT WinStaObject;
5062 PMENU Menu;
5065
5067 {
5068 /*
5069 * gpepCSRSS does not have a Win32WindowStation
5070 */
5071
5073 UserMode,
5074 0,
5075 &WinStaObject,
5076 0);
5077
5079 {
5081 CurrentProcess->Win32WindowStation);
5084 }
5087 {
5089 }
5090 ObDereferenceObject(WinStaObject);
5091 }
5092 else
5093 {
5095 }
5096
5099}
NTSTATUS FASTCALL IntValidateWindowStationHandle(HWINSTA WindowStation, KPROCESSOR_MODE AccessMode, ACCESS_MASK DesiredAccess, PWINSTATION_OBJECT *Object, POBJECT_HANDLE_INFORMATION pObjectHandleInfo)
Definition: winsta.c:232
Definition: pstypes.h:1262
Definition: winsta.h:16
Referenced by MENU_GetSystemMenu(), and NtUserCallNoParam().
◆ UserDestroyMenu()
Definition at line 5820 of file menu.c.
Referenced by MENU_GetSystemMenu().
◆ UserDestroyMenuObject()
◆ UserInsertMenuItem()
| DWORD FASTCALL UserInsertMenuItem | ( | PMENU | Menu, |
| UINT | uItem, | ||
| BOOL | fByPosition, | ||
| LPCMENUITEMINFOW | UnsafeItemInfo, | ||
| PUNICODE_STRING | lpstr | ||
| ) |
Definition at line 4961 of file menu.c.
4967{
4969 ROSMENUITEMINFO ItemInfo;
4970
4971 /* Try to copy the whole MENUITEMINFOW structure */
4974 {
4977 {
4980 }
4982 }
4983
4984 /* Try to copy without last field (not present in older versions) */
4987 {
4989 {
4992 }
4995 }
4996
4999}
Definition: winuser.h:3361
Referenced by NtUserThunkedMenuItemInfo().
◆ UserMenuInfo()
| BOOL FASTCALL UserMenuInfo | ( | PMENU | Menu, |
| PROSMENUINFO | UnsafeMenuInfo, | ||
| BOOL | SetOrGet | ||
| ) |
Definition at line 5204 of file menu.c.
5208{
5209 BOOL Res;
5213
5216 {
5219 }
5221 {
5224 }
5227 {
5230 }
5231
5232 if(SetOrGet)
5233 {
5234 /* Set MenuInfo */
5236 }
5237 else
5238 {
5239 /* Get MenuInfo */
5241 if (Res)
5242 {
5245 {
5248 }
5249 }
5250 }
5251
5252 return Res;
5253}
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
Referenced by NtUserThunkedMenuInfo().
◆ UserMenuItemInfo()
| BOOL FASTCALL UserMenuItemInfo | ( | PMENU | Menu, |
| UINT | Item, | ||
| BOOL | ByPosition, | ||
| PROSMENUITEMINFO | UnsafeItemInfo, | ||
| BOOL | SetOrGet, | ||
| PUNICODE_STRING | lpstr | ||
| ) |
Definition at line 5130 of file menu.c.
5137{
5138 PITEM MenuItem;
5139 ROSMENUITEMINFO ItemInfo;
5142 BOOL Ret;
5143
5146 {
5149 }
5153 {
5156 }
5159 {
5162 }
5163 /* If this is a pre-0x0500 _WIN32_WINNT MENUITEMINFOW, you can't
5164 set/get hbmpItem */
5167 {
5170 }
5171
5173 {
5174 /* workaround for Word 95: pretend that SC_TASKLIST item exists. */
5177
5180 }
5181
5182 if (SetOrGet)
5183 {
5185 }
5186 else
5187 {
5188 Ret = IntGetMenuItemInfo(Menu, MenuItem, &ItemInfo);
5189 if (Ret)
5190 {
5193 {
5196 }
5197 }
5198 }
5199
5200 return Ret;
5201}
Referenced by NtUserThunkedMenuItemInfo().
◆ UserSetMenuDefaultItem()
Definition at line 1274 of file menu.c.
1275{
1278
1280
1281 /* reset all default-item flags */
1283 {
1284 MenuItem->fState &= ~MFS_DEFAULT;
1285 }
1286
1287 /* no default item */
1289 {
1291 }
1292 MenuItem = MenuObject->rgItems;
1293 if ( fByPos )
1294 {
1298 }
1299 else
1300 {
1302 {
1304 {
1307 }
1308 }
1309
1310 }
1312}
Referenced by co_UserTrackSystemMenu(), IntSetMenuItemInfo(), MENU_GetSystemMenu(), MENU_InitSysMenuPopup(), and NtUserSetMenuDefaultItem().
◆ VerifyMenu()
Definition at line 201 of file menu.c.
202{
203 HMENU hMenu;
204 PITEM pItem;
208
210
211 _SEH2_TRY
212 {
213 hMenu = UserHMGetHandle(pMenu);
214 pItem = pMenu->rgItems;
215 if (pItem)
216 {
219 }
220 }
222 {
226 }
227 _SEH2_END
228
230 {
232 pMenu = NULL;
233 }
235 return pMenu;
236}
Referenced by MENU_FindItemByKey(), MENU_HideSubPopups(), MENU_TrackKbdMenuBar(), MENU_TrackMenu(), and MENU_TrackMouseMenuBar().
Variable Documentation
◆ fInEndMenu
Definition at line 26 of file menu.c.
Referenced by MENU_EndMenu(), and MENU_InitTracking().
◆ fInsideMenuLoop
Definition at line 25 of file menu.c.
Referenced by MENU_EndMenu(), MENU_InitTracking(), MENU_TrackMenu(), and NtUserEndMenu().
◆ ghMenuFont
Definition at line 16 of file menu.c.
Referenced by IntDrawMenuBarTemp(), MENU_DrawMenuBar(), MENU_DrawPopupMenu(), MENU_PopupMenuCalcSize(), MENU_SelectItem(), MENU_ShowSubPopup(), and MenuInit().
◆ ghMenuFontBold
Definition at line 17 of file menu.c.
Referenced by MENU_CalcItemSize(), MENU_DrawMenuItem(), and MenuInit().
◆ MenuCharSize
|
static |
Definition at line 18 of file menu.c.
Referenced by MENU_CalcItemSize(), and MENU_DrawMenuItem().
◆ top_popup
Definition at line 22 of file menu.c.
Referenced by MENU_EndMenu(), MENU_ExitTracking(), MENU_HideSubPopups(), MENU_InitTracking(), MENU_IsMenuActive(), MENU_SelectItem(), MENU_ShowPopup(), NtUserEndMenu(), and PopupMenuWndProc().
◆ top_popup_hmenu
Definition at line 23 of file menu.c.
Referenced by MENU_EndMenu(), MENU_ExitTracking(), MENU_HideSubPopups(), MENU_InitTracking(), MENU_SelectItem(), MENU_ShowPopup(), NtUserGetMenuBarInfo(), and PopupMenuWndProc().
