ReactOS 0.4.15-dev-6068-g8061a6f
menu.c File Reference
#include <win32k.h>
Include dependency graph for menu.c:

Go to the source code of this file.

Classes

struct  MTRACKER
 

Macros

#define MM_SETMENUHANDLE   (WM_USER + 0)
 
#define MM_GETMENUHANDLE   (WM_USER + 1)
 
#define TF_ENDMENU   0x10000
 
#define TF_SUSPENDPOPUP   0x20000
 
#define TF_SKIPREMOVE   0x40000
 
#define MAXMENUDEPTH   30
 
#define MNS_STYLE_MASK   (MNS_NOCHECK|MNS_MODELESS|MNS_DRAGDROP|MNS_AUTODISMISS|MNS_NOTIFYBYPOS|MNS_CHECKORBMP)
 
#define MENUITEMINFO_TYPE_MASK
 
#define TYPE_MASK   (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)
 
#define STATE_MASK   (~TYPE_MASK)
 
#define MENUITEMINFO_STATE_MASK   (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT))
 
#define MII_STATE_MASK   (MFS_GRAYED|MFS_CHECKED|MFS_HILITE|MFS_DEFAULT)
 
#define IS_SYSTEM_MENU(MenuInfo)    (!((MenuInfo)->fFlags & MNF_POPUP) && ((MenuInfo)->fFlags & MNF_SYSMENU))
 
#define IS_BITMAP_ITEM(flags)   (MF_BITMAP == MENU_ITEM_TYPE(flags))
 
#define IS_MAGIC_BITMAP(id)   ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))
 
#define IS_STRING_ITEM(flags)   (MF_STRING == MENU_ITEM_TYPE(flags))
 
#define MAX_MENU_ITEMS   (0x4000)
 
#define MAX_GOINTOSUBMENU   (0x10)
 
#define MENU_COL_SPACE   4
 
#define MENU_ITEM_HBMP_SPACE   (5)
 
#define MENU_BAR_ITEMS_SPACE   (12)
 
#define SEPARATOR_HEIGHT   (5)
 
#define MENU_TAB_SPACE   (8)
 
#define TPM_INTERNAL   0xF0000000
 
#define TPM_BUTTONDOWN   0x40000000 /* menu was clicked before tracking */
 
#define TPM_POPUPMENU   0x20000000 /* menu is a popup menu */
 
#define ITEM_PREV   -1
 
#define ITEM_NEXT   1
 
#define UpdateMenuItemState(state, change)
 
#define FreeMenuText(Menu, MenuItem)
 
#define SHOW_DEBUGRECT   0
 

Functions

 DBG_DEFAULT_CHANNEL (UserMenu)
 
BOOL FASTCALL UITOOLS95_DrawFrameMenu (HDC dc, LPRECT r, UINT uFlags)
 
PMENU FASTCALL IntGetMenuObject (HMENU hMenu)
 
PMENU FASTCALL VerifyMenu (PMENU pMenu)
 
BOOL FASTCALL IntIsMenu (HMENU Menu)
 
PMENU WINAPI IntGetMenu (HWND hWnd)
 
PMENU get_win_sys_menu (HWND hwnd)
 
BOOL IntDestroyMenu (PMENU pMenu, BOOL bRecurse)
 
BOOLEAN UserDestroyMenuObject (PVOID Object)
 
BOOL FASTCALL IntDestroyMenuObject (PMENU Menu, BOOL bRecurse)
 
BOOL MenuInit (VOID)
 
int FASTCALL MENU_depth (PMENU pmenu, int depth)
 
static UINT MENU_GetStartOfNextColumn (PMENU menu)
 
static UINT MENU_GetStartOfPrevColumn (PMENU menu)
 
PITEM FASTCALL MENU_FindItem (PMENU *pmenu, UINT *nPos, UINT wFlags)
 
static UINT FASTCALL MENU_FindSubMenu (PMENU *menu, PMENU SubTarget)
 
BOOL FASTCALL IntRemoveMenuItem (PMENU pMenu, UINT nPos, UINT wFlags, BOOL bRecurse)
 
ITEMMENU_InsertItem (PMENU menu, UINT pos, UINT flags, PMENU *submenu, UINT *npos)
 
BOOL FASTCALL IntInsertMenuItem (_In_ PMENU MenuObject, UINT uItem, BOOL fByPosition, PROSMENUITEMINFO ItemInfo, PUNICODE_STRING lpstr)
 
PMENU FASTCALL IntCreateMenu (_Out_ PHANDLE Handle, _In_ BOOL IsMenuBar, _In_ PDESKTOP Desktop, _In_ PPROCESSINFO ppi)
 
BOOL FASTCALL IntCloneMenuItems (PMENU Destination, PMENU Source)
 
PMENU FASTCALL IntCloneMenu (PMENU Source)
 
BOOL FASTCALL IntSetMenuFlagRtoL (PMENU Menu)
 
BOOL FASTCALL IntSetMenuContextHelpId (PMENU Menu, DWORD dwContextHelpId)
 
BOOL FASTCALL IntGetMenuInfo (PMENU Menu, PROSMENUINFO lpmi)
 
BOOL FASTCALL IntSetMenuInfo (PMENU Menu, PROSMENUINFO lpmi)
 
BOOL FASTCALL IntGetMenuItemInfo (PMENU Menu, PITEM MenuItem, PROSMENUITEMINFO lpmii)
 
BOOL FASTCALL IntSetMenuItemInfo (PMENU MenuObject, PITEM MenuItem, PROSMENUITEMINFO lpmii, PUNICODE_STRING lpstr)
 
UINT FASTCALL IntEnableMenuItem (PMENU MenuObject, UINT uIDEnableItem, UINT uEnable)
 
DWORD FASTCALL IntCheckMenuItem (PMENU MenuObject, UINT uIDCheckItem, UINT uCheck)
 
BOOL FASTCALL UserSetMenuDefaultItem (PMENU MenuObject, UINT uItem, UINT fByPos)
 
UINT FASTCALL IntGetMenuDefaultItem (PMENU MenuObject, UINT fByPos, UINT gmdiFlags, DWORD *gismc)
 
PMENU FASTCALL co_IntGetSubMenu (PMENU pMenu, int nPos)
 
void FASTCALL MENU_InitSysMenuPopup (PMENU menu, DWORD style, DWORD clsStyle, LONG HitTest)
 
static void FASTCALL MENU_DrawPopupGlyph (HDC dc, LPRECT r, INT_PTR popupMagic, BOOL inactive, BOOL hilite)
 
VOID FASTCALL MENU_AdjustMenuItemRect (PMENU menu, PRECTL rect)
 
static ITEMMENU_FindItemByCoords (MENU *menu, POINT pt, UINT *pos)
 
INT FASTCALL IntMenuItemFromPoint (PWND pWnd, HMENU hMenu, POINT ptScreen)
 
static UINT FASTCALL MENU_FindItemByKey (PWND WndOwner, PMENU menu, WCHAR Key, BOOL ForceMenuChar)
 
static void FASTCALL MENU_GetBitmapItemSize (PITEM lpitem, SIZE *size, PWND WndOwner)
 
static void FASTCALL MENU_DrawBitmapItem (HDC hdc, PITEM lpitem, const RECT *rect, PMENU Menu, PWND WndOwner, UINT odaction, BOOL MenuBar)
 
LONG IntGetDialogBaseUnits (VOID)
 
static void FASTCALL MENU_CalcItemSize (HDC hdc, PITEM lpitem, PMENU Menu, PWND pwndOwner, INT orgX, INT orgY, BOOL menuBar, BOOL textandbmp)
 
static UINT MENU_GetMaxPopupHeight (PMENU lppop)
 
static void FASTCALL MENU_PopupMenuCalcSize (PMENU Menu, PWND WndOwner)
 
static void MENU_MenuBarCalcSize (HDC hdc, LPRECT lprect, PMENU lppop, PWND pwndOwner)
 
static void MENU_DrawScrollArrows (PMENU lppop, HDC hdc)
 
static void FASTCALL MENU_DrawMenuItem (PWND Wnd, PMENU Menu, PWND WndOwner, HDC hdc, PITEM lpitem, UINT Height, BOOL menuBar, UINT odaction)
 
static void FASTCALL MENU_DrawPopupMenu (PWND wnd, HDC hdc, PMENU menu)
 
PWND MENU_IsMenuActive (VOID)
 
void MENU_EndMenu (PWND pwnd)
 
DWORD WINAPI IntDrawMenuBarTemp (PWND pWnd, HDC hDC, LPRECT Rect, PMENU pMenu, HFONT Font)
 
UINT MENU_DrawMenuBar (HDC hDC, LPRECT lprect, PWND pWnd, BOOL suppress_draw)
 
static BOOL MENU_InitPopup (PWND pWndOwner, PMENU menu, UINT flags)
 
static BOOL RECTL_Intersect (const RECT *pRect, INT x, INT y, UINT width, UINT height)
 
static BOOL MENU_MoveRect (UINT flags, INT *x, INT *y, INT width, INT height, const RECT *pExclude, PMONITOR monitor)
 
static BOOL FASTCALL MENU_ShowPopup (PWND pwndOwner, PMENU menu, UINT id, UINT flags, INT x, INT y, const RECT *pExclude)
 
void MENU_EnsureMenuItemVisible (PMENU lppop, UINT wIndex, HDC hdc)
 
static void FASTCALL MENU_SelectItem (PWND pwndOwner, PMENU menu, UINT wIndex, BOOL sendMenuSelect, PMENU topmenu)
 
static void FASTCALL MENU_MoveSelection (PWND pwndOwner, PMENU menu, INT offset)
 
static void FASTCALL MENU_HideSubPopups (PWND pWndOwner, PMENU Menu, BOOL SendMenuSelect, UINT wFlags)
 
static PMENU FASTCALL MENU_ShowSubPopup (PWND WndOwner, PMENU Menu, BOOL SelectFirst, UINT Flags)
 
static INT FASTCALL MENU_ExecFocusedItem (MTRACKER *pmt, PMENU Menu, UINT Flags)
 
static void FASTCALL MENU_SwitchTracking (MTRACKER *pmt, PMENU PtMenu, UINT Index, UINT wFlags)
 
static BOOL FASTCALL MENU_ButtonDown (MTRACKER *pmt, PMENU PtMenu, UINT Flags)
 
static INT FASTCALL MENU_ButtonUp (MTRACKER *pmt, PMENU PtMenu, UINT Flags)
 
static PMENU FASTCALL MENU_PtMenu (PMENU menu, POINT pt)
 
static BOOL FASTCALL MENU_MouseMove (MTRACKER *pmt, PMENU PtMenu, UINT Flags)
 
static PMENU MENU_GetSubPopup (PMENU menu)
 
static LRESULT FASTCALL MENU_DoNextMenu (MTRACKER *pmt, UINT Vk, UINT wFlags)
 
static BOOL FASTCALL MENU_SuspendPopup (MTRACKER *pmt, UINT uMsg)
 
static BOOL FASTCALL MENU_KeyEscape (MTRACKER *pmt, UINT Flags)
 
static void FASTCALL MENU_KeyLeft (MTRACKER *pmt, UINT Flags, UINT msg)
 
static void FASTCALL MENU_KeyRight (MTRACKER *pmt, UINT Flags, UINT msg)
 
static INT FASTCALL MENU_TrackMenu (PMENU pmenu, UINT wFlags, INT x, INT y, PWND pwnd)
 
static BOOL FASTCALL MENU_InitTracking (PWND pWnd, PMENU Menu, BOOL bPopup, UINT wFlags)
 
static BOOL FASTCALL MENU_ExitTracking (PWND pWnd, BOOL bPopup, UINT wFlags)
 
VOID MENU_TrackMouseMenuBar (PWND pWnd, ULONG ht, POINT pt)
 
VOID MENU_TrackKbdMenuBar (PWND pwnd, UINT wParam, WCHAR wChar)
 
BOOL WINAPI IntTrackPopupMenuEx (PMENU menu, UINT wFlags, int x, int y, PWND pWnd, LPTPMPARAMS lpTpm)
 
BOOL WINAPI PopupMenuWndProc (PWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
 
BOOL FASTCALL IntHiliteMenuItem (PWND WindowObject, PMENU MenuObject, UINT uItemHilite, UINT uHilite)
 
BOOLEAN APIENTRY intGetTitleBarInfo (PWND pWindowObject, PTITLEBARINFO bti)
 
DWORD FASTCALL UserInsertMenuItem (PMENU Menu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW UnsafeItemInfo, PUNICODE_STRING lpstr)
 
UINT FASTCALL IntGetMenuState (HMENU hMenu, UINT uId, UINT uFlags)
 
HMENU FASTCALL IntGetSubMenu (HMENU hMenu, int nPos)
 
UINT FASTCALL IntFindSubMenu (HMENU *hMenu, HMENU hSubTarget)
 
HMENU FASTCALL UserCreateMenu (PDESKTOP Desktop, BOOL PopupMenu)
 
BOOL FASTCALL IntMenuItemInfo (PMENU Menu, UINT Item, BOOL ByPosition, PROSMENUITEMINFO ItemInfo, BOOL SetOrGet, PUNICODE_STRING lpstr)
 
BOOL FASTCALL UserMenuItemInfo (PMENU Menu, UINT Item, BOOL ByPosition, PROSMENUITEMINFO UnsafeItemInfo, BOOL SetOrGet, PUNICODE_STRING lpstr)
 
BOOL FASTCALL UserMenuInfo (PMENU Menu, PROSMENUINFO UnsafeMenuInfo, BOOL SetOrGet)
 
BOOL FASTCALL IntGetMenuItemRect (PWND pWnd, PMENU Menu, UINT uItem, PRECTL Rect)
 
PMENU FASTCALL MENU_GetSystemMenu (PWND Window, PMENU Popup)
 
PMENU FASTCALL IntGetSystemMenu (PWND Window, BOOL bRevert)
 
BOOL FASTCALL IntSetSystemMenu (PWND Window, PMENU Menu)
 
BOOL FASTCALL IntSetMenu (PWND Wnd, HMENU Menu, BOOL *Changed)
 
DWORD APIENTRY NtUserCalcMenuBar (HWND hwnd, DWORD leftBorder, DWORD rightBorder, DWORD top, LPRECT prc)
 
DWORD APIENTRY NtUserCheckMenuItem (HMENU hMenu, UINT uIDCheckItem, UINT uCheck)
 
BOOL APIENTRY NtUserDeleteMenu (HMENU hMenu, UINT uPosition, UINT uFlags)
 
HMENU APIENTRY NtUserGetSystemMenu (HWND hWnd, BOOL bRevert)
 
BOOL APIENTRY NtUserSetSystemMenu (HWND hWnd, HMENU hMenu)
 
BOOLEAN APIENTRY NtUserGetTitleBarInfo (HWND hwnd, PTITLEBARINFO bti)
 
BOOL FASTCALL UserDestroyMenu (HMENU hMenu)
 
BOOL APIENTRY NtUserDestroyMenu (HMENU hMenu)
 
UINT APIENTRY NtUserEnableMenuItem (HMENU hMenu, UINT uIDEnableItem, UINT uEnable)
 
BOOL APIENTRY NtUserEndMenu (VOID)
 
BOOL APIENTRY NtUserGetMenuBarInfo (HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi)
 
UINT APIENTRY NtUserGetMenuIndex (HMENU hMenu, HMENU hSubMenu)
 
BOOL APIENTRY NtUserGetMenuItemRect (HWND hWnd, HMENU hMenu, UINT uItem, PRECTL lprcItem)
 
BOOL APIENTRY NtUserHiliteMenuItem (HWND hWnd, HMENU hMenu, UINT uItemHilite, UINT uHilite)
 
DWORD APIENTRY NtUserDrawMenuBarTemp (HWND hWnd, HDC hDC, PRECT pRect, HMENU hMenu, HFONT hFont)
 
int APIENTRY NtUserMenuItemFromPoint (HWND hWnd, HMENU hMenu, DWORD X, DWORD Y)
 
DWORD APIENTRY NtUserPaintMenuBar (HWND hWnd, HDC hDC, ULONG leftBorder, ULONG rightBorder, ULONG top, BOOL bActive)
 
BOOL APIENTRY NtUserRemoveMenu (HMENU hMenu, UINT uPosition, UINT uFlags)
 
BOOL APIENTRY NtUserSetMenu (HWND hWnd, HMENU Menu, BOOL Repaint)
 
BOOL APIENTRY NtUserSetMenuContextHelpId (HMENU hMenu, DWORD dwContextHelpId)
 
BOOL APIENTRY NtUserSetMenuDefaultItem (HMENU hMenu, UINT uItem, UINT fByPos)
 
BOOL APIENTRY NtUserSetMenuFlagRtoL (HMENU hMenu)
 
BOOL APIENTRY NtUserThunkedMenuInfo (HMENU hMenu, LPCMENUINFO lpcmi)
 
BOOL APIENTRY NtUserThunkedMenuItemInfo (HMENU hMenu, UINT uItem, BOOL fByPosition, BOOL bInsert, LPMENUITEMINFOW lpmii, PUNICODE_STRING lpszCaption)
 
BOOL APIENTRY NtUserTrackPopupMenuEx (HMENU hMenu, UINT fuFlags, int x, int y, HWND hWnd, LPTPMPARAMS lptpm)
 

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) { \
DesktopHeapFree(((PMENU)Menu)->head.rpdesk, (MenuItem)->lpstr.Buffer); \
} \
}
struct outqueuenode * head
Definition: adnsresfilter.c:66
#define MENU_ITEM_TYPE(flags)
Definition: menu.h:6
static LPCSTR lpstr
Definition: font.c:51
#define MF_STRING
Definition: winuser.h:138

Definition at line 185 of file menu.c.

◆ IS_BITMAP_ITEM

#define IS_BITMAP_ITEM (   flags)    (MF_BITMAP == MENU_ITEM_TYPE(flags))

Definition at line 63 of file menu.c.

◆ IS_MAGIC_BITMAP

#define IS_MAGIC_BITMAP (   id)    ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))

Definition at line 65 of file menu.c.

◆ IS_STRING_ITEM

#define IS_STRING_ITEM (   flags)    (MF_STRING == MENU_ITEM_TYPE(flags))

Definition at line 66 of file menu.c.

◆ IS_SYSTEM_MENU

#define IS_SYSTEM_MENU (   MenuInfo)     (!((MenuInfo)->fFlags & MNF_POPUP) && ((MenuInfo)->fFlags & MNF_SYSMENU))

Definition at line 60 of file menu.c.

◆ ITEM_NEXT

#define ITEM_NEXT   1

Definition at line 95 of file menu.c.

◆ ITEM_PREV

#define ITEM_PREV   -1

Definition at line 94 of file menu.c.

◆ MAX_GOINTOSUBMENU

#define MAX_GOINTOSUBMENU   (0x10)

Definition at line 70 of file menu.c.

◆ MAX_MENU_ITEMS

#define MAX_MENU_ITEMS   (0x4000)

Definition at line 69 of file menu.c.

◆ MAXMENUDEPTH

#define MAXMENUDEPTH   30

Definition at line 43 of file menu.c.

◆ MENU_BAR_ITEMS_SPACE

#define MENU_BAR_ITEMS_SPACE   (12)

Definition at line 76 of file menu.c.

◆ MENU_COL_SPACE

#define MENU_COL_SPACE   4

Definition at line 73 of file menu.c.

◆ MENU_ITEM_HBMP_SPACE

#define MENU_ITEM_HBMP_SPACE   (5)

Definition at line 75 of file menu.c.

◆ MENU_TAB_SPACE

#define MENU_TAB_SPACE   (8)

Definition at line 78 of file menu.c.

◆ MENUITEMINFO_STATE_MASK

#define MENUITEMINFO_STATE_MASK   (STATE_MASK & ~(MF_BYPOSITION | MF_MOUSESELECT))

Definition at line 56 of file menu.c.

◆ MENUITEMINFO_TYPE_MASK

#define MENUITEMINFO_TYPE_MASK
Value:
MFT_RIGHTORDER | MFT_RIGHTJUSTIFY /* same as MF_HELP */ )
#define MFT_RIGHTORDER
Definition: winuser.h:740
#define MFT_SEPARATOR
Definition: winuser.h:739
#define MFT_OWNERDRAW
Definition: winuser.h:736
#define MFT_BITMAP
Definition: winuser.h:733
#define MFT_RIGHTJUSTIFY
Definition: winuser.h:738
#define MFT_STRING
Definition: winuser.h:741
#define MFT_MENUBREAK
Definition: winuser.h:735
#define MFT_RADIOCHECK
Definition: winuser.h:737
#define MFT_MENUBARBREAK
Definition: winuser.h:734

Definition at line 47 of file menu.c.

◆ MII_STATE_MASK

Definition at line 58 of file menu.c.

◆ MM_GETMENUHANDLE

#define MM_GETMENUHANDLE   (WM_USER + 1)

Definition at line 31 of file menu.c.

◆ MM_SETMENUHANDLE

#define MM_SETMENUHANDLE   (WM_USER + 0)

Definition at line 30 of file menu.c.

◆ MNS_STYLE_MASK

◆ SEPARATOR_HEIGHT

#define SEPARATOR_HEIGHT   (5)

Definition at line 77 of file menu.c.

◆ SHOW_DEBUGRECT

#define SHOW_DEBUGRECT   0

Definition at line 2848 of file menu.c.

◆ STATE_MASK

#define STATE_MASK   (~TYPE_MASK)

Definition at line 54 of file menu.c.

◆ TF_ENDMENU

#define TF_ENDMENU   0x10000

Definition at line 35 of file menu.c.

◆ TF_SKIPREMOVE

#define TF_SKIPREMOVE   0x40000

Definition at line 37 of file menu.c.

◆ TF_SUSPENDPOPUP

#define TF_SUSPENDPOPUP   0x20000

Definition at line 36 of file menu.c.

◆ TPM_BUTTONDOWN

#define TPM_BUTTONDOWN   0x40000000 /* menu was clicked before tracking */

Definition at line 91 of file menu.c.

◆ TPM_INTERNAL

#define TPM_INTERNAL   0xF0000000

Definition at line 90 of file menu.c.

◆ TPM_POPUPMENU

#define TPM_POPUPMENU   0x20000000 /* menu is a popup menu */

Definition at line 92 of file menu.c.

◆ TYPE_MASK

Definition at line 52 of file menu.c.

◆ UpdateMenuItemState

#define UpdateMenuItemState (   state,
  change 
)

Definition at line 97 of file menu.c.

Function Documentation

◆ co_IntGetSubMenu()

PMENU FASTCALL co_IntGetSubMenu ( PMENU  pMenu,
int  nPos 
)

Definition at line 1350 of file menu.c.

1353{
1354 PITEM pItem;
1355 if (!(pItem = MENU_FindItem( &pMenu, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
1356 return pItem->spSubMenu;
1357}
#define NULL
Definition: types.h:112
unsigned int UINT
Definition: ndis.h:50
struct tagMENU * spSubMenu
Definition: ntuser.h:370
PITEM FASTCALL MENU_FindItem(PMENU *pmenu, UINT *nPos, UINT wFlags)
Definition: menu.c:509
#define MF_BYPOSITION
Definition: winuser.h:203

Referenced by MENU_DoNextMenu(), and MENU_FindItemByKey().

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserMenu  )

◆ get_win_sys_menu()

PMENU get_win_sys_menu ( HWND  hwnd)

Definition at line 260 of file menu.c.

261{
262 PMENU ret = 0;
264 if (win)
265 {
266 ret = UserGetMenuObject(win->SystemMenu);
267 }
268 return ret;
269}
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
static real win[4][36]
Definition: ntuser.h:689
FORCEINLINE PMENU UserGetMenuObject(HMENU hMenu)
Definition: userfuncs.h:4
int ret
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

Referenced by MENU_DoNextMenu(), MENU_PtMenu(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().

◆ IntCheckMenuItem()

DWORD FASTCALL IntCheckMenuItem ( PMENU  MenuObject,
UINT  uIDCheckItem,
UINT  uCheck 
)

Definition at line 1261 of file menu.c.

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}
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint res
Definition: glext.h:9613
#define DWORD
Definition: nt_native.h:44
UINT fState
Definition: ntuser.h:368
#define MF_CHECKED
Definition: winuser.h:132

Referenced by NtUserCheckMenuItem().

◆ IntCloneMenu()

PMENU FASTCALL IntCloneMenu ( PMENU  Source)

Definition at line 824 of file menu.c.

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 */
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
861
862 return Menu;
863}
#define FALSE
Definition: types.h:117
struct tagMENU MENU
@ TYPE_MENU
Definition: ntuser.h:42
#define NO_SELECTED_ITEM
Definition: ntuser.h:408
struct tagMENU * PMENU
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169
ULONG fFlags
Definition: ntuser.h:413
ULONG cyMenu
Definition: ntuser.h:418
struct _WND * spwndNotify
Definition: ntuser.h:420
INT iItem
Definition: ntuser.h:414
UINT cItems
Definition: ntuser.h:416
DWORD dwContextHelpId
Definition: ntuser.h:423
BOOL TimeToHide
Definition: ntuser.h:433
DWORD_PTR dwMenuData
Definition: ntuser.h:425
HWND hWnd
Definition: ntuser.h:432
ULONG cxMenu
Definition: ntuser.h:417
ULONG cyMax
Definition: ntuser.h:424
INT iTop
Definition: ntuser.h:427
INT iMaxTop
Definition: ntuser.h:428
HBRUSH hbrBack
Definition: ntuser.h:426
ULONG cxTextAlign
Definition: ntuser.h:419
PITEM rgItems
Definition: ntuser.h:421
BOOL FASTCALL IntCloneMenuItems(PMENU Destination, PMENU Source)
Definition: menu.c:773
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
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()

BOOL FASTCALL IntCloneMenuItems ( PMENU  Destination,
PMENU  Source 
)

Definition at line 773 of file menu.c.

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}
#define TRUE
Definition: types.h:120
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
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2992
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
Definition: fontsub.cpp:36
USHORT MaximumLength
Definition: env_spec_w32.h:370
HBITMAP hbmp
Definition: ntuser.h:383
HANDLE hbmpChecked
Definition: ntuser.h:371
DWORD_PTR dwItemData
Definition: ntuser.h:375
UINT wID
Definition: ntuser.h:369
UNICODE_STRING lpstr
Definition: ntuser.h:387
UINT fType
Definition: ntuser.h:367
USHORT * Xlpstr
Definition: ntuser.h:373
HANDLE hbmpUnchecked
Definition: ntuser.h:372
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
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
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by IntCloneMenu().

◆ IntCreateMenu()

PMENU FASTCALL IntCreateMenu ( _Out_ PHANDLE  Handle,
_In_ BOOL  IsMenuBar,
_In_ PDESKTOP  Desktop,
_In_ PPROCESSINFO  ppi 
)

Definition at line 731 of file menu.c.

736{
737 PMENU Menu;
738
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}
ULONG Handle
Definition: gdb_input.c:15
#define MNF_POPUP
Definition: ntuser.h:397

Referenced by IntSetMenuItemInfo(), and UserCreateMenu().

◆ IntDestroyMenu()

BOOL IntDestroyMenu ( PMENU  pMenu,
BOOL  bRecurse 
)

Definition at line 271 of file menu.c.

272{
273 PMENU SubMenu;
274
276 if (pMenu->rgItems) /* recursively destroy submenus */
277 {
278 int i;
279 ITEM *item = pMenu->rgItems;
280 for (i = pMenu->cItems; i > 0; i--, item++)
281 {
282 SubMenu = item->spSubMenu;
283 item->spSubMenu = NULL;
284
285 /* Remove Item Text */
286 FreeMenuText(pMenu,item);
287
288 /* Remove Item Bitmap and set it for this process */
289 if (item->hbmp && !(item->fState & MFS_HBMMENUBMP))
290 {
292 item->hbmp = NULL;
293 }
294
295 /* Remove Item submenu */
296 if (bRecurse && SubMenu)//VerifyMenu(SubMenu))
297 {
298 /* Release submenu since it was referenced when inserted */
299 IntReleaseMenuObject(SubMenu);
300 IntDestroyMenuObject(SubMenu, bRecurse);
301 }
302 }
303 /* Free the Item */
304 DesktopHeapFree(pMenu->head.rpdesk, pMenu->rgItems );
305 pMenu->rgItems = NULL;
306 pMenu->cItems = 0;
307 }
308 return TRUE;
309}
#define MFS_HBMMENUBMP
Definition: ntuser.h:363
#define IntReleaseMenuObject(MenuObj)
Definition: menu.h:130
#define ASSERT(a)
Definition: mode.c:44
static ATOM item
Definition: dde.c:856
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
BOOL FASTCALL UserIsEnteredExclusive(VOID)
Definition: ntuser.c:227
struct _DESKTOP * rpdesk
Definition: ntuser.h:219
PROCDESKHEAD head
Definition: ntuser.h:412
BOOL NTAPI GreSetObjectOwner(HGDIOBJ hobj, ULONG ulOwner)
Definition: gdiobj.c:1255
BOOL FASTCALL IntDestroyMenuObject(PMENU Menu, BOOL bRecurse)
Definition: menu.c:319
#define FreeMenuText(Menu, MenuItem)
Definition: menu.c:185

Referenced by IntDestroyMenuObject().

◆ IntDestroyMenuObject()

BOOL FASTCALL IntDestroyMenuObject ( PMENU  Menu,
BOOL  bRecurse 
)

Definition at line 319 of file menu.c.

320{
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 {
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
353 TRACE("IntDestroyMenuObject %d\n",ret);
354 return ret;
355 }
356 }
357 return FALSE;
358}
#define ERR(fmt,...)
Definition: debug.h:110
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MNF_SYSSUBMENU
Definition: ntuser.h:403
ULONG NTAPI PsGetCurrentProcessSessionId(VOID)
Definition: process.c:1133
#define TRACE(s)
Definition: solgame.cpp:4
Definition: window.c:28
BOOL IntDestroyMenu(PMENU pMenu, BOOL bRecurse)
Definition: menu.c:271
BOOL FASTCALL UserMarkObjectDestroy(PVOID Object)
Definition: object.c:621
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:717

Referenced by co_UserFreeWindow(), IntDestroyMenu(), IntGetSystemMenu(), IntRemoveMenuItem(), IntSetMenuItemInfo(), IntSetSystemMenu(), MENU_GetSystemMenu(), NtUserDestroyMenu(), UserDestroyMenu(), and UserDestroyMenuObject().

◆ IntDrawMenuBarTemp()

DWORD WINAPI IntDrawMenuBarTemp ( PWND  pWnd,
HDC  hDC,
LPRECT  Rect,
PMENU  pMenu,
HFONT  Font 
)

Definition at line 2687 of file menu.c.

2688{
2689 UINT i;
2690 HFONT FontOld = NULL;
2691 BOOL flat_menu = FALSE;
2692
2693 UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
2694
2695 if (!pMenu)
2696 {
2697 pMenu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu));
2698 }
2699
2700 if (!Font)
2701 {
2702 Font = ghMenuFont;
2703 }
2704
2705 if (Rect == NULL || !pMenu)
2706 {
2708 }
2709
2710 TRACE("(%x, %x, %p, %x, %x)\n", pWnd, hDC, Rect, pMenu, Font);
2711
2712 FontOld = NtGdiSelectFont(hDC, Font);
2713
2714 if (pMenu->cyMenu == 0)
2715 {
2716 MENU_MenuBarCalcSize(hDC, Rect, pMenu, pWnd);
2717 }
2718
2719 Rect->bottom = Rect->top + pMenu->cyMenu;
2720
2721 FillRect(hDC, Rect, IntGetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU));
2722
2725 GreMoveTo(hDC, Rect->left, Rect->bottom - 1, NULL);
2726 NtGdiLineTo(hDC, Rect->right, Rect->bottom - 1);
2727
2728 if (pMenu->cItems == 0)
2729 {
2730 NtGdiSelectFont(hDC, FontOld);
2732 }
2733
2734 for (i = 0; i < pMenu->cItems; i++)
2735 {
2736 MENU_DrawMenuItem(pWnd, pMenu, pWnd, hDC, &pMenu->rgItems[i], pMenu->cyMenu, TRUE, ODA_DRAWENTIRE);
2737 }
2738
2739 NtGdiSelectFont(hDC, FontOld);
2740
2741 return pMenu->cyMenu;
2742}
static HDC hDC
Definition: 3dtext.c:33
#define UlongToHandle(ul)
Definition: basetsd.h:97
COLORREF FASTCALL IntSetDCPenColor(HDC, COLORREF)
Definition: dcutil.c:259
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
BOOL FASTCALL GreMoveTo(HDC hdc, INT x, INT y, LPPOINT pptOut)
Definition: line.c:108
DWORD FASTCALL IntGetSysColor(INT nIndex)
Definition: stockobj.c:323
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
UINT_PTR IDMenu
Definition: ntuser.h:726
static void FASTCALL MENU_DrawMenuItem(PWND Wnd, PMENU Menu, PWND WndOwner, HDC hdc, PITEM lpitem, UINT Height, BOOL menuBar, UINT odaction)
Definition: menu.c:2206
HFONT ghMenuFont
Definition: menu.c:16
static void MENU_MenuBarCalcSize(HDC hdc, LPRECT lprect, PMENU lppop, PWND pwndOwner)
Definition: menu.c:2103
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:208
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2104
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
#define COLOR_MENU
Definition: winuser.h:911
#define ODA_DRAWENTIRE
Definition: winuser.h:2532
#define SM_CYMENU
Definition: winuser.h:970
#define COLOR_3DFACE
Definition: winuser.h:923

Referenced by MENU_DrawMenuBar(), and NtUserDrawMenuBarTemp().

◆ IntEnableMenuItem()

UINT FASTCALL IntEnableMenuItem ( PMENU  MenuObject,
UINT  uIDEnableItem,
UINT  uEnable 
)

Definition at line 1219 of file menu.c.

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}
BOOL UserPaintCaption(PWND pWnd, INT Flags)
Definition: defwnd.c:398
#define SC_SIZE
Definition: winuser.h:2574
#define SC_MINIMIZE
Definition: winuser.h:2576
#define SC_CLOSE
Definition: winuser.h:2582
#define SC_MOVE
Definition: winuser.h:2575
#define SC_RESTORE
Definition: winuser.h:2588
#define SC_MAXIMIZE
Definition: winuser.h:2578
#define MF_GRAYED
Definition: winuser.h:129
#define MF_DISABLED
Definition: winuser.h:130

Referenced by MENU_InitSysMenuPopup(), and NtUserEnableMenuItem().

◆ IntFindSubMenu()

UINT FASTCALL IntFindSubMenu ( HMENU hMenu,
HMENU  hSubTarget 
)

Definition at line 5015 of file menu.c.

5016{
5017 PMENU menu, pSubTarget;
5018 UINT Pos;
5019 if (((*hMenu)==(HMENU)0xffff) ||(!(menu = UserGetMenuObject(*hMenu))))
5020 return NO_SELECTED_ITEM;
5021
5022 pSubTarget = UserGetMenuObject(hSubTarget);
5023
5024 Pos = MENU_FindSubMenu(&menu, pSubTarget );
5025
5026 *hMenu = (menu ? UserHMGetHandle(menu) : NULL);
5027
5028 return Pos;
5029}
ush Pos
Definition: deflate.h:92
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
static UINT FASTCALL MENU_FindSubMenu(PMENU *menu, PMENU SubTarget)
Definition: menu.c:566

Referenced by co_IntTranslateAccelerator().

◆ IntGetDialogBaseUnits()

LONG IntGetDialogBaseUnits ( VOID  )

Definition at line 1802 of file menu.c.

1803{
1804 static DWORD units;
1805
1806 if (!units)
1807 {
1808 HDC hdc;
1809 SIZE size;
1810
1811 if ((hdc = UserGetDCEx(NULL, NULL, DCX_CACHE)))
1812 {
1814 if (size.cx) units = MAKELONG( size.cx, size.cy );
1815 UserReleaseDC( 0, hdc, FALSE);
1816 }
1817 }
1818 return units;
1819}
GLsizeiptr size
Definition: glext.h:5919
GLfloat units
Definition: glext.h:11727
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:92
DWORD * PDWORD
Definition: pedump.c:68
#define MAKELONG(a, b)
Definition: typedefs.h:249
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
DWORD FASTCALL IntGetCharDimensions(HDC hdc, PTEXTMETRICW ptm, PDWORD height)
Definition: font.c:329
#define DCX_CACHE
Definition: winuser.h:2104

Referenced by MENU_CalcItemSize().

◆ IntGetMenu()

PMENU WINAPI IntGetMenu ( HWND  hWnd)

Definition at line 250 of file menu.c.

251{
253
254 if (!Wnd)
255 return NULL;
256
258}
HWND hWnd
Definition: settings.c:17

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 1317 of file menu.c.

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}
UINT FASTCALL IntGetMenuDefaultItem(PMENU MenuObject, UINT fByPos, UINT gmdiFlags, DWORD *gismc)
Definition: menu.c:1317
#define GMDI_USEDISABLED
Definition: winuser.h:2116
#define MFS_DISABLED
Definition: winuser.h:744
#define MFS_DEFAULT
Definition: winuser.h:743
#define GMDI_GOINTOPOPUPS
Definition: winuser.h:2115

Referenced by GetMenuDefaultItem(), and IntGetMenuDefaultItem().

◆ IntGetMenuInfo()

BOOL FASTCALL IntGetMenuInfo ( PMENU  Menu,
PROSMENUINFO  lpmi 
)

Definition at line 881 of file menu.c.

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}
DWORD dwArrowsOn
Definition: ntuser.h:429
INT iTop
Definition: menu.h:91
INT iMaxTop
Definition: menu.h:92
HMENU Self
Definition: menu.h:95
DWORD dwContextHelpID
Definition: menu.h:81
HBRUSH hbrBack
Definition: menu.h:80
UINT cItems
Definition: menu.h:86
UINT iItem
Definition: menu.h:85
DWORD dwStyle
Definition: menu.h:78
UINT cyMax
Definition: menu.h:79
HWND Wnd
Definition: menu.h:96
ULONG_PTR dwMenuData
Definition: menu.h:82
ULONG cxTextAlign
Definition: menu.h:89
ULONG fFlags
Definition: menu.h:84
BOOL TimeToHide
Definition: menu.h:97
PWND spwndNotify
Definition: menu.h:90
DWORD cbSize
Definition: menu.h:76
WORD cyMenu
Definition: menu.h:88
WORD cxMenu
Definition: menu.h:87
DWORD dwArrowsOn
Definition: menu.h:93
DWORD fMask
Definition: menu.h:77
#define MNS_STYLE_MASK
Definition: menu.c:45

Referenced by UserMenuInfo().

◆ IntGetMenuItemInfo()

BOOL FASTCALL IntGetMenuItemInfo ( PMENU  Menu,
PITEM  MenuItem,
PROSMENUITEMINFO  lpmii 
)

Definition at line 964 of file menu.c.

966{
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 {
1008 Status = MmCopyToCaller(lpmii->dwTypeData, MenuItem->lpstr.Buffer,
1009 min(lpmii->cch * sizeof(WCHAR),
1010 MenuItem->lpstr.MaximumLength));
1011 if (! NT_SUCCESS(Status))
1012 {
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}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define min(a, b)
Definition: monoChain.cc:55
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
INT cyBmp
Definition: ntuser.h:385
ULONG yItem
Definition: ntuser.h:377
ULONG dxTab
Definition: ntuser.h:380
ULONG xItem
Definition: ntuser.h:376
INT cxBmp
Definition: ntuser.h:384
ULONG cxItem
Definition: ntuser.h:378
ULONG cyItem
Definition: ntuser.h:379
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
HBITMAP hbmpItem
Definition: menu.h:114
HBITMAP hbmpUnchecked
Definition: menu.h:110
SIZE maxBmpSize
Definition: menu.h:119
HMENU hSubMenu
Definition: menu.h:108
LPWSTR dwTypeData
Definition: menu.h:112
LPWSTR lpstr
Definition: menu.h:118
HBITMAP hbmpChecked
Definition: menu.h:109
DWORD dwItemData
Definition: menu.h:111
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:37
#define MIIM_STRING
Definition: winuser.h:722
#define MIIM_ID
Definition: winuser.h:717
#define MIIM_CHECKMARKS
Definition: winuser.h:719
#define MIIM_FTYPE
Definition: winuser.h:724
#define MIIM_STATE
Definition: winuser.h:716
#define MIIM_SUBMENU
Definition: winuser.h:718
#define MIIM_BITMAP
Definition: winuser.h:723
#define MIIM_DATA
Definition: winuser.h:721
#define MIIM_TYPE
Definition: winuser.h:720

Referenced by IntMenuItemInfo(), and UserMenuItemInfo().

◆ IntGetMenuItemRect()

BOOL FASTCALL IntGetMenuItemRect ( PWND  pWnd,
PMENU  Menu,
UINT  uItem,
PRECTL  Rect 
)

Definition at line 5230 of file menu.c.

5235{
5236 LONG XMove, YMove;
5237 PITEM MenuItem;
5238 UINT I = uItem;
5239
5240 if ((MenuItem = MENU_FindItem (&Menu, &I, MF_BYPOSITION)))
5241 {
5242 Rect->left = MenuItem->xItem;
5243 Rect->top = MenuItem->yItem;
5244 Rect->right = MenuItem->cxItem; // Do this for now......
5245 Rect->bottom = MenuItem->cyItem;
5246 }
5247 else
5248 {
5249 ERR("Failed Item Lookup! %u\n", uItem);
5250 return FALSE;
5251 }
5252
5253 if (!pWnd)
5254 {
5255 HWND hWnd = Menu->hWnd;
5256 if (!(pWnd = UserGetWindowObject(hWnd))) return FALSE;
5257 }
5258
5259 if (Menu->fFlags & MNF_POPUP)
5260 {
5261 XMove = pWnd->rcClient.left;
5262 YMove = pWnd->rcClient.top;
5263 }
5264 else
5265 {
5266 XMove = pWnd->rcWindow.left;
5267 YMove = pWnd->rcWindow.top;
5268 }
5269
5270 Rect->left += XMove;
5271 Rect->top += YMove;
5272 Rect->right += XMove;
5273 Rect->bottom += YMove;
5274
5275 return TRUE;
5276}
#define I(s)
long LONG
Definition: pedump.c:60
RECT rcClient
Definition: ntuser.h:712
RECT rcWindow
Definition: ntuser.h:711
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122

Referenced by NtUserGetMenuBarInfo().

◆ IntGetMenuObject()

PMENU FASTCALL IntGetMenuObject ( HMENU  hMenu)

Definition at line 194 of file menu.c.

195{
196 PMENU Menu = UserGetMenuObject(hMenu);
197 if (Menu)
198 Menu->head.cLockObj++;
199
200 return Menu;
201}

Referenced by IntSetMenu(), NtUserCallTwoParam(), and NtUserSetSystemMenu().

◆ IntGetMenuState()

UINT FASTCALL IntGetMenuState ( HMENU  hMenu,
UINT  uId,
UINT  uFlags 
)

Definition at line 4975 of file menu.c.

4976{
4977 PMENU MenuObject;
4978 PITEM pItem;
4979
4980 if (!(MenuObject = UserGetMenuObject(hMenu)))
4981 {
4982 return (UINT)-1;
4983 }
4984
4985 if (!(pItem = MENU_FindItem( &MenuObject, &uId, uFlags ))) return -1;
4986
4987 if (pItem->spSubMenu)
4988 {
4989 return (pItem->spSubMenu->cItems << 8) | ((pItem->fState|pItem->fType|MF_POPUP) & 0xff);
4990 }
4991 else
4992 return (pItem->fType | pItem->fState);
4993}
UINT uFlags
Definition: api.c:59
#define MF_POPUP
Definition: winuser.h:136

Referenced by co_IntTranslateAccelerator(), NC_DoButton(), NC_HandleNCLButtonDblClk(), and UserDrawCaptionButton().

◆ IntGetSubMenu()

HMENU FASTCALL IntGetSubMenu ( HMENU  hMenu,
int  nPos 
)

Definition at line 4995 of file menu.c.

4996{
4997 PMENU MenuObject;
4998 PITEM pItem;
4999
5000 if (!(MenuObject = UserGetMenuObject(hMenu)))
5001 {
5002 return NULL;
5003 }
5004
5005 if (!(pItem = MENU_FindItem( &MenuObject, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
5006
5007 if (pItem->spSubMenu)
5008 {
5009 HMENU hsubmenu = UserHMGetHandle(pItem->spSubMenu);
5010 return hsubmenu;
5011 }
5012 return NULL;
5013}

Referenced by IntGetSystemMenu().

◆ IntGetSystemMenu()

PMENU FASTCALL IntGetSystemMenu ( PWND  Window,
BOOL  bRevert 
)

Definition at line 5383 of file menu.c.

5384{
5385 PMENU Menu;
5386
5387 if (bRevert)
5388 {
5389 if (Window->SystemMenu)
5390 {
5391 Menu = UserGetMenuObject(Window->SystemMenu);
5392 if (Menu && !(Menu->fFlags & MNF_SYSDESKMN))
5393 {
5395 Window->SystemMenu = NULL;
5396 }
5397 }
5398 }
5399 else
5400 {
5401 Menu = Window->SystemMenu ? UserGetMenuObject(Window->SystemMenu) : NULL;
5402 if ((!Menu || Menu->fFlags & MNF_SYSDESKMN) && Window->style & WS_SYSMENU)
5403 {
5405 Window->SystemMenu = Menu ? UserHMGetHandle(Menu) : NULL;
5406 }
5407 }
5408
5409 if (Window->SystemMenu)
5410 {
5411 HMENU hMenu = IntGetSubMenu( Window->SystemMenu, 0);
5412 /* Store the dummy sysmenu handle to facilitate the refresh */
5413 /* of the close button if the SC_CLOSE item change */
5414 Menu = UserGetMenuObject(hMenu);
5415 if (Menu)
5416 {
5417 Menu->spwndNotify = Window;
5418 Menu->fFlags |= MNF_SYSSUBMENU;
5419 }
5420 return Menu;
5421 }
5422 return NULL;
5423}
#define MNF_SYSDESKMN
Definition: ntuser.h:402
#define WS_SYSMENU
Definition: pedump.c:629
PMENU FASTCALL MENU_GetSystemMenu(PWND Window, PMENU Popup)
Definition: menu.c:5278
HMENU FASTCALL IntGetSubMenu(HMENU hMenu, int nPos)
Definition: menu.c:4995

Referenced by IntDefWindowProc(), MENU_TrackMouseMenuBar(), NC_DoButton(), NC_HandleNCLButtonDblClk(), NC_HandleNCRButtonDown(), NtUserGetMenuBarInfo(), NtUserGetSystemMenu(), and UserDrawCaptionButton().

◆ intGetTitleBarInfo()

BOOLEAN APIENTRY intGetTitleBarInfo ( PWND  pWindowObject,
PTITLEBARINFO  bti 
)

Definition at line 4804 of file menu.c.

4805{
4806
4807 DWORD dwStyle = 0;
4808 DWORD dwExStyle = 0;
4809 BOOLEAN retValue = TRUE;
4810
4811 if (bti->cbSize == sizeof(TITLEBARINFO))
4812 {
4813 RtlZeroMemory(&bti->rgstate[0],sizeof(DWORD)*(CCHILDREN_TITLEBAR+1));
4814
4816
4817 dwStyle = pWindowObject->style;
4818 dwExStyle = pWindowObject->ExStyle;
4819
4820 bti->rcTitleBar.top = 0;
4821 bti->rcTitleBar.left = 0;
4822 bti->rcTitleBar.right = pWindowObject->rcWindow.right - pWindowObject->rcWindow.left;
4823 bti->rcTitleBar.bottom = pWindowObject->rcWindow.bottom - pWindowObject->rcWindow.top;
4824
4825 /* Is it iconiced ? */
4826 if ((dwStyle & WS_ICONIC)!=WS_ICONIC)
4827 {
4828 /* Remove frame from rectangle */
4829 if (HAS_THICKFRAME( dwStyle, dwExStyle ))
4830 {
4831 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXFRAME) and UserGetSystemMetrics(SM_CYFRAME) */
4833 }
4834 else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
4835 {
4836 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXDLGFRAME) and UserGetSystemMetrics(SM_CYDLGFRAME) */
4838 }
4839 else if (HAS_THINFRAME( dwStyle, dwExStyle))
4840 {
4841 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4843 }
4844
4845 /* We have additional border information if the window
4846 * is a child (but not an MDI child) */
4847 if ( (dwStyle & WS_CHILD) &&
4848 ((dwExStyle & WS_EX_MDICHILD) == 0 ) )
4849 {
4850 if (dwExStyle & WS_EX_CLIENTEDGE)
4851 {
4852 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXEDGE) and UserGetSystemMetrics(SM_CYEDGE) */
4854 }
4855
4856 if (dwExStyle & WS_EX_STATICEDGE)
4857 {
4858 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
4860 }
4861 }
4862 }
4863
4864 bti->rcTitleBar.top += pWindowObject->rcWindow.top;
4865 bti->rcTitleBar.left += pWindowObject->rcWindow.left;
4866 bti->rcTitleBar.right += pWindowObject->rcWindow.left;
4867
4868 bti->rcTitleBar.bottom = bti->rcTitleBar.top;
4869 if (dwExStyle & WS_EX_TOOLWINDOW)
4870 {
4871 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYSMCAPTION) */
4873 }
4874 else
4875 {
4876 /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYCAPTION) and UserGetSystemMetrics(SM_CXSIZE) */
4879 }
4880
4881 if (dwStyle & WS_CAPTION)
4882 {
4884 if (dwStyle & WS_SYSMENU)
4885 {
4886 if (!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX)))
4887 {
4890 }
4891 else
4892 {
4893 if (!(dwStyle & WS_MINIMIZEBOX))
4894 {
4896 }
4897 if (!(dwStyle & WS_MAXIMIZEBOX))
4898 {
4900 }
4901 }
4902
4903 if (!(dwExStyle & WS_EX_CONTEXTHELP))
4904 {
4906 }
4907 if (pWindowObject->pcls->style & CS_NOCLOSE)
4908 {
4910 }
4911 }
4912 else
4913 {
4918 }
4919 }
4920 else
4921 {
4923 }
4924 }
4925 else
4926 {
4928 retValue = FALSE;
4929 }
4930
4931 return retValue;
4932}
unsigned char BOOLEAN
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define WS_CHILD
Definition: pedump.c:617
#define WS_CAPTION
Definition: pedump.c:624
#define WS_ICONIC
Definition: pedump.c:641
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_MINIMIZEBOX
Definition: pedump.c:631
UINT style
Definition: ntuser.h:575
DWORD ExStyle
Definition: ntuser.h:699
PCLS pcls
Definition: ntuser.h:715
DWORD style
Definition: ntuser.h:701
DWORD rgstate[CCHILDREN_TITLEBAR+1]
Definition: winuser.h:3752
VOID FASTCALL RECTL_vInflateRect(_Inout_ RECTL *rect, _In_ INT dx, _In_ INT dy)
Definition: rect.c:101
#define HAS_DLGFRAME(Style, ExStyle)
Definition: window.h:9
#define HAS_THINFRAME(Style, ExStyle)
Definition: window.h:17
#define HAS_THICKFRAME(Style, ExStyle)
Definition: window.h:13
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:28
#define WS_EX_STATICEDGE
Definition: winuser.h:403
#define SM_CYEDGE
Definition: winuser.h:1003
#define SM_CXEDGE
Definition: winuser.h:1002
#define SM_CXFRAME
Definition: winuser.h:988
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define CCHILDREN_TITLEBAR
Definition: winuser.h:3747
#define SM_CXSIZE
Definition: winuser.h:985
#define SM_CYFRAME
Definition: winuser.h:990
#define SM_CYBORDER
Definition: winuser.h:959
#define STATE_SYSTEM_FOCUSABLE
Definition: winuser.h:2872
#define WS_EX_MDICHILD
Definition: winuser.h:394
#define SM_CXBORDER
Definition: winuser.h:958
#define STATE_SYSTEM_INVISIBLE
Definition: winuser.h:2867
#define SM_CXDLGFRAME
Definition: winuser.h:960
#define STATE_SYSTEM_UNAVAILABLE
Definition: winuser.h:2852
#define SM_CYSMCAPTION
Definition: winuser.h:1008
#define SM_CYDLGFRAME
Definition: winuser.h:962
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
#define WS_EX_CONTEXTHELP
Definition: winuser.h:386
#define SM_CYCAPTION
Definition: winuser.h:957
#define CS_NOCLOSE
Definition: winuser.h:649

Referenced by NtUserGetTitleBarInfo().

◆ IntHiliteMenuItem()

BOOL FASTCALL IntHiliteMenuItem ( PWND  WindowObject,
PMENU  MenuObject,
UINT  uItemHilite,
UINT  uHilite 
)

Definition at line 4778 of file menu.c.

4782{
4783 PITEM MenuItem;
4784 UINT uItem = uItemHilite;
4785
4786 if (!(MenuItem = MENU_FindItem( &MenuObject, &uItem, uHilite ))) return TRUE;
4787
4788 if (uHilite & MF_HILITE)
4789 {
4790 MenuItem->fState |= MF_HILITE;
4791 }
4792 else
4793 {
4794 MenuItem->fState &= ~MF_HILITE;
4795 }
4796 if (MenuObject->iItem == uItemHilite) return TRUE;
4797 MENU_HideSubPopups( WindowObject, MenuObject, FALSE, 0 );
4798 MENU_SelectItem( WindowObject, MenuObject, uItemHilite, TRUE, 0 );
4799
4800 return TRUE; // Always returns true!!!!
4801}
static void FASTCALL MENU_HideSubPopups(PWND pWndOwner, PMENU Menu, BOOL SendMenuSelect, UINT wFlags)
Definition: menu.c:3264
static void FASTCALL MENU_SelectItem(PWND pwndOwner, PMENU menu, UINT wIndex, BOOL sendMenuSelect, PMENU topmenu)
Definition: menu.c:3141
#define MF_HILITE
Definition: winuser.h:205

Referenced by NtUserHiliteMenuItem().

◆ IntInsertMenuItem()

BOOL FASTCALL IntInsertMenuItem ( _In_ PMENU  MenuObject,
UINT  uItem,
BOOL  fByPosition,
PROSMENUITEMINFO  ItemInfo,
PUNICODE_STRING  lpstr 
)

Definition at line 693 of file menu.c.

699{
700 PITEM MenuItem;
701 PMENU SubMenu = NULL;
702
703 NT_ASSERT(MenuObject != NULL);
704
705 if (MAX_MENU_ITEMS <= MenuObject->cItems)
706 {
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}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
int32_t INT
Definition: typedefs.h:58
BOOL FASTCALL IntSetMenuItemInfo(PMENU MenuObject, PITEM MenuItem, PROSMENUITEMINFO lpmii, PUNICODE_STRING lpstr)
Definition: menu.c:1035
BOOL FASTCALL IntRemoveMenuItem(PMENU pMenu, UINT nPos, UINT wFlags, BOOL bRecurse)
Definition: menu.c:598
ITEM * MENU_InsertItem(PMENU menu, UINT pos, UINT flags, PMENU *submenu, UINT *npos)
Definition: menu.c:641
#define MF_BYCOMMAND
Definition: winuser.h:202
#define NT_ASSERT
Definition: rtlfuncs.h:3310

Referenced by MENU_GetSystemMenu(), and UserInsertMenuItem().

◆ IntIsMenu()

BOOL FASTCALL IntIsMenu ( HMENU  Menu)

Definition at line 242 of file menu.c.

243{
244 if (UserGetMenuObject(Menu)) return TRUE;
245 return FALSE;
246}

◆ IntMenuItemFromPoint()

INT FASTCALL IntMenuItemFromPoint ( PWND  pWnd,
HMENU  hMenu,
POINT  ptScreen 
)

Definition at line 1520 of file menu.c.

1521{
1522 MENU *menu = UserGetMenuObject(hMenu);
1523 UINT pos;
1524
1525 /*FIXME: Do we have to handle hWnd here? */
1526 if (!menu) return -1;
1527 if (!MENU_FindItemByCoords(menu, ptScreen, &pos)) return -1;
1528 return pos;
1529}
static ITEM * MENU_FindItemByCoords(MENU *menu, POINT pt, UINT *pos)
Definition: menu.c:1482

Referenced by IntDefWindowProc().

◆ IntMenuItemInfo()

BOOL FASTCALL IntMenuItemInfo ( PMENU  Menu,
UINT  Item,
BOOL  ByPosition,
PROSMENUITEMINFO  ItemInfo,
BOOL  SetOrGet,
PUNICODE_STRING  lpstr 
)

Definition at line 5076 of file menu.c.

5083{
5084 PITEM MenuItem;
5085 BOOL Ret;
5086
5087 if (!(MenuItem = MENU_FindItem( &Menu, &Item, (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND) )))
5088 {
5090 return( FALSE);
5091 }
5092 if (SetOrGet)
5093 {
5094 Ret = IntSetMenuItemInfo(Menu, MenuItem, ItemInfo, lpstr);
5095 }
5096 else
5097 {
5098 Ret = IntGetMenuItemInfo(Menu, MenuItem, ItemInfo);
5099 }
5100 return( Ret);
5101}
_In_ WDFCOLLECTION _In_ WDFOBJECT Item
BOOL FASTCALL IntGetMenuItemInfo(PMENU Menu, PITEM MenuItem, PROSMENUITEMINFO lpmii)
Definition: menu.c:964
#define ERROR_MENU_ITEM_NOT_FOUND
Definition: winerror.h:937

Referenced by MENU_GetSystemMenu().

◆ IntRemoveMenuItem()

BOOL FASTCALL IntRemoveMenuItem ( PMENU  pMenu,
UINT  nPos,
UINT  wFlags,
BOOL  bRecurse 
)

Definition at line 598 of file menu.c.

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 }
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}
static __inline PVOID DesktopHeapReAlloc(IN PDESKTOP Desktop, IN PVOID lpMem, IN SIZE_T Bytes)
Definition: desktop.h:226
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531

Referenced by IntInsertMenuItem(), MENU_GetSystemMenu(), NtUserDeleteMenu(), and NtUserRemoveMenu().

◆ IntSetMenu()

BOOL FASTCALL IntSetMenu ( PWND  Wnd,
HMENU  Menu,
BOOL Changed 
)

Definition at line 5459 of file menu.c.

5463{
5464 PMENU OldMenu, NewMenu = NULL;
5465
5466 if ((Wnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
5467 {
5468 ERR("SetMenu: Window is a Child 0x%p!\n",UserHMGetHandle(Wnd));
5470 return FALSE;
5471 }
5472
5473 *Changed = (UlongToHandle(Wnd->IDMenu) != Menu);
5474 if (! *Changed)
5475 {
5476 return TRUE;
5477 }
5478
5479 if (Wnd->IDMenu)
5480 {
5481 OldMenu = IntGetMenuObject(UlongToHandle(Wnd->IDMenu));
5482 ASSERT(NULL == OldMenu || OldMenu->hWnd == UserHMGetHandle(Wnd));
5483 }
5484 else
5485 {
5486 OldMenu = NULL;
5487 }
5488
5489 if (NULL != Menu)
5490 {
5491 NewMenu = IntGetMenuObject(Menu);
5492 if (NULL == NewMenu)
5493 {
5494 if (NULL != OldMenu)
5495 {
5496 IntReleaseMenuObject(OldMenu);
5497 }
5499 return FALSE;
5500 }
5501 if (NULL != NewMenu->hWnd)
5502 {
5503 /* Can't use the same menu for two windows */
5504 if (NULL != OldMenu)
5505 {
5506 IntReleaseMenuObject(OldMenu);
5507 }
5509 return FALSE;
5510 }
5511
5512 }
5513
5514 Wnd->IDMenu = (UINT_PTR) Menu;
5515 if (NULL != NewMenu)
5516 {
5517 NewMenu->hWnd = UserHMGetHandle(Wnd);
5518 IntReleaseMenuObject(NewMenu);
5519 }
5520 if (NULL != OldMenu)
5521 {
5522 OldMenu->hWnd = NULL;
5523 IntReleaseMenuObject(OldMenu);
5524 }
5525
5526 return TRUE;
5527}
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
#define WS_POPUP
Definition: pedump.c:616
PMENU FASTCALL IntGetMenuObject(HMENU hMenu)
Definition: menu.c:194
#define ERROR_INVALID_MENU_HANDLE
Definition: winerror.h:882
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881

Referenced by IntCreateWindow(), and NtUserSetMenu().

◆ IntSetMenuContextHelpId()

BOOL FASTCALL IntSetMenuContextHelpId ( PMENU  Menu,
DWORD  dwContextHelpId 
)

Definition at line 874 of file menu.c.

875{
876 Menu->dwContextHelpId = dwContextHelpId;
877 return TRUE;
878}

Referenced by NtUserSetMenuContextHelpId().

◆ IntSetMenuFlagRtoL()

BOOL FASTCALL IntSetMenuFlagRtoL ( PMENU  Menu)

Definition at line 866 of file menu.c.

867{
868 ERR("SetMenuFlagRtoL\n");
869 Menu->fFlags |= MNF_RTOL;
870 return TRUE;
871}
#define MNF_RTOL
Definition: ntuser.h:400

Referenced by NtUserSetMenuFlagRtoL().

◆ IntSetMenuInfo()

BOOL FASTCALL IntSetMenuInfo ( PMENU  Menu,
PROSMENUINFO  lpmi 
)

Definition at line 916 of file menu.c.

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}
#define FIXME(fmt,...)
Definition: debug.h:111
BOOL FASTCALL IntSetMenuInfo(PMENU Menu, PROSMENUINFO lpmi)
Definition: menu.c:916
#define MNS_MODELESS
Definition: winuser.h:751
#define MNS_DRAGDROP
Definition: winuser.h:752
#define MNS_AUTODISMISS
Definition: winuser.h:753

Referenced by IntSetMenuInfo(), and UserMenuInfo().

◆ IntSetMenuItemInfo()

BOOL FASTCALL IntSetMenuItemInfo ( PMENU  MenuObject,
PITEM  MenuItem,
PROSMENUITEMINFO  lpmii,
PUNICODE_STRING  lpstr 
)

Definition at line 1035 of file menu.c.

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
1052 if (lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP))
1053 {
1054 ERR("IntSetMenuItemInfo: Invalid combination of fMask bits used\n");
1056 /* This does not happen on Win9x/ME */
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 {
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 {
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 {
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}
#define KeRosDumpStackFrames(Frames, Count)
Definition: gdidebug.h:11
#define MNF_SYSMENU
Definition: ntuser.h:405
static HBITMAP
Definition: button.c:44
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNICODE_STRING_MAX_CHARS
#define LOWORD(l)
Definition: pedump.c:82
unsigned short USHORT
Definition: pedump.c:61
DWORD_PTR hTaskWow
Definition: ntuser.h:218
ULONG cch
Definition: ntuser.h:374
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MAXMENUDEPTH
Definition: menu.c:43
BOOL FASTCALL UserSetMenuDefaultItem(PMENU MenuObject, UINT uItem, UINT fByPos)
Definition: menu.c:1276
#define MENUITEMINFO_TYPE_MASK
Definition: menu.c:47
#define UpdateMenuItemState(state, change)
Definition: menu.c:97
PMENU FASTCALL IntCreateMenu(_Out_ PHANDLE Handle, _In_ BOOL IsMenuBar, _In_ PDESKTOP Desktop, _In_ PPROCESSINFO ppi)
Definition: menu.c:731
int FASTCALL MENU_depth(PMENU pmenu, int depth)
Definition: menu.c:406
BOOL FASTCALL UserObjectInDestroy(HANDLE h)
Definition: object.c:703
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731
#define HBMMENU_POPUP_MINIMIZE
Definition: winuser.h:2630
#define HBMMENU_CALLBACK
Definition: winuser.h:2620
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3287

Referenced by IntInsertMenuItem(), IntMenuItemInfo(), and UserMenuItemInfo().

◆ IntSetSystemMenu()

BOOL FASTCALL IntSetSystemMenu ( PWND  Window,
PMENU  Menu 
)

Definition at line 5426 of file menu.c.

5427{
5428 PMENU OldMenu;
5429
5430 if (!(Window->style & WS_SYSMENU)) return FALSE;
5431
5432 if (Window->SystemMenu)
5433 {
5434 OldMenu = UserGetMenuObject(Window->SystemMenu);
5435 if (OldMenu)
5436 {
5437 OldMenu->fFlags &= ~MNF_SYSMENU;
5438 IntDestroyMenuObject(OldMenu, TRUE);
5439 }
5440 }
5441
5442 OldMenu = MENU_GetSystemMenu(Window, Menu);
5443 if (OldMenu)
5444 { // Use spmenuSys too!
5445 Window->SystemMenu = UserHMGetHandle(OldMenu);
5446 }
5447 else
5448 Window->SystemMenu = NULL;
5449
5450 if (Menu && Window != Menu->spwndNotify)
5451 {
5452 Menu->spwndNotify = Window;
5453 }
5454
5455 return TRUE;
5456}

Referenced by NtUserSetSystemMenu().

◆ IntTrackPopupMenuEx()

BOOL WINAPI IntTrackPopupMenuEx ( PMENU  menu,
UINT  wFlags,
int  x,
int  y,
PWND  pWnd,
LPTPMPARAMS  lpTpm 
)

Definition at line 4561 of file menu.c.

4563{
4564 BOOL ret = FALSE;
4566
4567 if (pti != pWnd->head.pti)
4568 {
4569 ERR("Must be the same pti!\n");
4570 return ret;
4571 }
4572
4573 TRACE("hmenu %p flags %04x (%d,%d) hwnd %p lpTpm %p \n", //rect %s\n",
4574 UserHMGetHandle(menu), wFlags, x, y, UserHMGetHandle(pWnd), lpTpm); //,
4575 //lpTpm ? wine_dbgstr_rect( &lpTpm->rcExclude) : "-" );
4576
4577 if (menu->hWnd && IntIsWindow(menu->hWnd))
4578 {
4580 return FALSE;
4581 }
4582
4583 if (MENU_InitPopup( pWnd, menu, wFlags ))
4584 {
4585 MENU_InitTracking(pWnd, menu, TRUE, wFlags);
4586
4587 /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
4588 if (!(wFlags & TPM_NONOTIFY))
4589 {
4591 }
4592
4593 if (menu->fFlags & MNF_SYSMENU)
4594 MENU_InitSysMenuPopup( menu, pWnd->style, pWnd->pcls->style, HTSYSMENU);
4595
4596 if (MENU_ShowPopup(pWnd, menu, 0, wFlags | TPM_POPUPMENU, x, y, lpTpm ? &lpTpm->rcExclude : NULL))
4597 ret = MENU_TrackMenu( menu, wFlags | TPM_POPUPMENU, 0, 0, pWnd);
4598 else
4599 {
4601 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
4602 co_UserSetCapture(NULL); /* release the capture */
4603 }
4604
4606
4607 if (menu->hWnd)
4608 {
4609 PWND pwndM = ValidateHwndNoErr( menu->hWnd );
4610 if (pwndM) // wine hack around this with their destroy function.
4611 {
4612 if (!(pWnd->state & WNDS_DESTROYED))
4613 co_UserDestroyWindow( pwndM ); // Fix wrong error return.
4614 }
4615 menu->hWnd = 0;
4616
4617 if (!(wFlags & TPM_NONOTIFY))
4618 {
4619 co_IntSendMessage( UserHMGetHandle(pWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(menu),
4620 MAKELPARAM(0, IS_SYSTEM_MENU(menu)) );
4621 }
4622 }
4623 }
4624 return ret;
4625}
HWND FASTCALL co_UserSetCapture(HWND hWnd)
Definition: focus.c:1458
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define WNDS_DESTROYED
Definition: ntuser.h:631
#define MSQ_STATE_MENUOWNER
Definition: ntuser.h:3707
HWND FASTCALL MsqSetStateWindow(PTHREADINFO pti, ULONG Type, HWND hWnd)
Definition: msgqueue.c:2553
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
THRDESKHEAD head
Definition: ntuser.h:690
DWORD state
Definition: ntuser.h:696
RECT rcExclude
Definition: winuser.h:3566
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2838
#define IS_SYSTEM_MENU(MenuInfo)
Definition: menu.c:60
static BOOL MENU_InitPopup(PWND pWndOwner, PMENU menu, UINT flags)
Definition: menu.c:2783
static BOOL FASTCALL MENU_ExitTracking(PWND pWnd, BOOL bPopup, UINT wFlags)
Definition: menu.c:4448
#define TPM_POPUPMENU
Definition: menu.c:92
static BOOL FASTCALL MENU_ShowPopup(PWND pwndOwner, PMENU menu, UINT id, UINT flags, INT x, INT y, const RECT *pExclude)
Definition: menu.c:2941
void FASTCALL MENU_InitSysMenuPopup(PMENU menu, DWORD style, DWORD clsStyle, LONG HitTest)
Definition: menu.c:1364
static INT FASTCALL MENU_TrackMenu(PMENU pmenu, UINT wFlags, INT x, INT y, PWND pwnd)
Definition: menu.c:4054
static BOOL FASTCALL MENU_InitTracking(PWND pWnd, PMENU Menu, BOOL bPopup, UINT wFlags)
Definition: menu.c:4388
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1446
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:176
UINT_PTR WPARAM
Definition: windef.h:207
#define ERROR_POPUP_ALREADY_ACTIVE
Definition: winerror.h:927
#define MAKELPARAM(l, h)
Definition: winuser.h:3998
#define TPM_NONOTIFY
Definition: winuser.h:2376
#define WM_INITMENUPOPUP
Definition: winuser.h:1736
#define HTSYSMENU
Definition: winuser.h:2467

Referenced by IntDefWindowProc(), and NtUserTrackPopupMenuEx().

◆ MENU_AdjustMenuItemRect()

VOID FASTCALL MENU_AdjustMenuItemRect ( PMENU  menu,
PRECTL  rect 
)

Definition at line 1464 of file menu.c.

1465{
1466 if (menu->dwArrowsOn)
1467 {
1468 UINT arrow_bitmap_height;
1469 arrow_bitmap_height = gpsi->oembmi[OBI_UPARROW].cy;
1470 rect->top += arrow_bitmap_height - menu->iTop;
1471 rect->bottom += arrow_bitmap_height - menu->iTop;
1472 }
1473}
PSERVERINFO gpsi
Definition: imm.c:18
@ OBI_UPARROW
Definition: ntuser.h:962
& rect
Definition: startmenu.cpp:1413

Referenced by MENU_DrawMenuItem(), MENU_FindItemByCoords(), MENU_ShowSubPopup(), and NtUserMenuItemFromPoint().

◆ MENU_ButtonDown()

static BOOL FASTCALL MENU_ButtonDown ( MTRACKER pmt,
PMENU  PtMenu,
UINT  Flags 
)
static

Definition at line 3552 of file menu.c.

3553{
3554 TRACE("%x PtMenu=%p\n", pmt, PtMenu);
3555
3556 if (PtMenu)
3557 {
3558 UINT id = 0;
3559 PITEM item;
3560 if (IS_SYSTEM_MENU(PtMenu))
3561 {
3562 item = PtMenu->rgItems;
3563 }
3564 else
3565 {
3566 item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &id );
3567 }
3568
3569 if (item)
3570 {
3571 if (PtMenu->iItem != id)
3572 MENU_SwitchTracking(pmt, PtMenu, id, Flags);
3573
3574 /* If the popup menu is not already "popped" */
3575 if (!(item->fState & MF_MOUSESELECT))
3576 {
3577 pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, PtMenu, FALSE, Flags);
3578 }
3579
3580 return TRUE;
3581 }
3582 /* Else the click was on the menu bar, finish the tracking */
3583 }
3584 return FALSE;
3585}
PMENU CurrentMenu
Definition: menu.c:83
PWND OwnerWnd
Definition: menu.c:85
POINT Pt
Definition: menu.c:86
static PMENU FASTCALL MENU_ShowSubPopup(PWND WndOwner, PMENU Menu, BOOL SelectFirst, UINT Flags)
Definition: menu.c:3315
static void FASTCALL MENU_SwitchTracking(MTRACKER *pmt, PMENU PtMenu, UINT Index, UINT wFlags)
Definition: menu.c:3527
#define MF_MOUSESELECT
Definition: winuser.h:145
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by MENU_TrackMenu().

◆ MENU_ButtonUp()

static INT FASTCALL MENU_ButtonUp ( MTRACKER pmt,
PMENU  PtMenu,
UINT  Flags 
)
static

Definition at line 3595 of file menu.c.

3596{
3597 TRACE("%p pmenu=%x\n", pmt, PtMenu);
3598
3599 if (PtMenu)
3600 {
3601 UINT Id = 0;
3602 ITEM *item;
3603
3604 if ( IS_SYSTEM_MENU(PtMenu) )
3605 {
3606 item = PtMenu->rgItems;
3607 }
3608 else
3609 {
3610 item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &Id );
3611 }
3612
3613 if (item && ( PtMenu->iItem == Id))
3614 {
3615 if (!(item->spSubMenu))
3616 {
3617 INT ExecutedMenuId = MENU_ExecFocusedItem( pmt, PtMenu, Flags);
3618 if (ExecutedMenuId == -1 || ExecutedMenuId == -2) return -1;
3619 return ExecutedMenuId;
3620 }
3621
3622 /* If we are dealing with the menu bar */
3623 /* and this is a click on an already "popped" item: */
3624 /* Stop the menu tracking and close the opened submenus */
3625 if (pmt->TopMenu == PtMenu && PtMenu->TimeToHide)
3626 {
3627 return 0;
3628 }
3629 }
3630 if ( IntGetMenu(PtMenu->hWnd) == PtMenu )
3631 {
3632 PtMenu->TimeToHide = TRUE;
3633 }
3634 }
3635 return -1;
3636}
DWORD Id
PMENU TopMenu
Definition: menu.c:84
static INT FASTCALL MENU_ExecFocusedItem(MTRACKER *pmt, PMENU Menu, UINT Flags)
Definition: menu.c:3472
PMENU WINAPI IntGetMenu(HWND hWnd)
Definition: menu.c:250

Referenced by MENU_TrackMenu().

◆ MENU_CalcItemSize()

static void FASTCALL MENU_CalcItemSize ( HDC  hdc,
PITEM  lpitem,
PMENU  Menu,
PWND  pwndOwner,
INT  orgX,
INT  orgY,
BOOL  menuBar,
BOOL  textandbmp 
)
static

Definition at line 1827 of file menu.c.

1829{
1830 WCHAR *p;
1831 UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
1832 UINT arrow_bitmap_width;
1833 RECT Rect;
1834 INT itemheight = 0;
1835
1836 TRACE("dc=%x owner=%x (%d,%d)\n", hdc, pwndOwner, orgX, orgY);
1837
1838 arrow_bitmap_width = gpsi->oembmi[OBI_MNARROW].cx;
1839
1841
1842 RECTL_vSetRect( &Rect, orgX, orgY, orgX, orgY );
1843
1844 if (lpitem->fType & MF_OWNERDRAW)
1845 {
1847 mis.CtlType = ODT_MENU;
1848 mis.CtlID = 0;
1849 mis.itemID = lpitem->wID;
1850 mis.itemData = lpitem->dwItemData;
1852 mis.itemWidth = 0;
1853 co_IntSendMessage( UserHMGetHandle(pwndOwner), WM_MEASUREITEM, 0, (LPARAM)&mis );
1854 /* Tests reveal that Windows ( Win95 thru WinXP) adds twice the average
1855 * width of a menufont character to the width of an owner-drawn menu.
1856 */
1857 Rect.right += mis.itemWidth + 2 * MenuCharSize.cx;
1858 if (menuBar) {
1859 /* under at least win95 you seem to be given a standard
1860 height for the menu and the height value is ignored */
1862 } else
1863 Rect.bottom += mis.itemHeight;
1864 // Or this,
1865 //lpitem->cxBmp = mis.itemWidth;
1866 //lpitem->cyBmp = mis.itemHeight;
1867 TRACE("MF_OWNERDRAW Height %d Width %d\n",mis.itemHeight,mis.itemWidth);
1868 TRACE("MF_OWNERDRAW id=%04lx size=%dx%d cx %d cy %d\n",
1869 lpitem->wID, Rect.right-Rect.left,
1870 Rect.bottom-Rect.top, MenuCharSize.cx, MenuCharSize.cy);
1871
1872 lpitem->xItem = Rect.left;
1873 lpitem->yItem = Rect.top;
1874 lpitem->cxItem = Rect.right;
1875 lpitem->cyItem = Rect.bottom;
1876
1877 return;
1878 }
1879
1880 lpitem->xItem = orgX;
1881 lpitem->yItem = orgY;
1882 lpitem->cxItem = orgX;
1883 lpitem->cyItem = orgY;
1884
1885 if (lpitem->fType & MF_SEPARATOR)
1886 {
1887 lpitem->cyItem += UserGetSystemMetrics( SM_CYMENUSIZE)/2;//SEPARATOR_HEIGHT;
1888 if( !menuBar)
1889 lpitem->cxItem += arrow_bitmap_width + MenuCharSize.cx;
1890 return;
1891 }
1892
1893 lpitem->dxTab = 0;
1894
1895 if (lpitem->hbmp)
1896 {
1897 SIZE size;
1898
1899 if (!menuBar) {
1900 MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
1901 /* Keep the size of the bitmap in callback mode to be able
1902 * to draw it correctly */
1903 lpitem->cxBmp = size.cx;
1904 lpitem->cyBmp = size.cy;
1905 Menu->cxTextAlign = max(Menu->cxTextAlign, size.cx);
1906 lpitem->cxItem += size.cx + 2;
1907 itemheight = size.cy + 2;
1908
1909 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
1910 lpitem->cxItem += 2 * check_bitmap_width;
1911 lpitem->cxItem += 4 + MenuCharSize.cx;
1912 lpitem->dxTab = lpitem->cxItem;
1913 lpitem->cxItem += arrow_bitmap_width;
1914 } else /* hbmpItem & MenuBar */ {
1915 MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
1916 lpitem->cxItem += size.cx;
1917 if( lpitem->Xlpstr) lpitem->cxItem += 2;
1918 itemheight = size.cy;
1919
1920 /* Special case: Minimize button doesn't have a space behind it. */
1921 if (lpitem->hbmp == (HBITMAP)HBMMENU_MBAR_MINIMIZE ||
1923 lpitem->cxItem -= 1;
1924 }
1925 }
1926 else if (!menuBar) {
1927 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
1928 lpitem->cxItem += check_bitmap_width;
1929 lpitem->cxItem += 4 + MenuCharSize.cx;
1930 lpitem->dxTab = lpitem->cxItem;
1931 lpitem->cxItem += arrow_bitmap_width;
1932 }
1933
1934 /* it must be a text item - unless it's the system menu */
1935 if (!(lpitem->fType & MF_SYSMENU) && lpitem->Xlpstr) {
1936 HFONT hfontOld = NULL;
1937 RECT rc;// = lpitem->Rect;
1938 LONG txtheight, txtwidth;
1939
1940 rc.left = lpitem->xItem;
1941 rc.top = lpitem->yItem;
1942 rc.right = lpitem->cxItem; // Do this for now......
1943 rc.bottom = lpitem->cyItem;
1944
1945 if ( lpitem->fState & MFS_DEFAULT ) {
1946 hfontOld = NtGdiSelectFont( hdc, ghMenuFontBold );
1947 }
1948 if (menuBar) {
1949 txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc, DT_SINGLELINE|DT_CALCRECT);
1950
1951 lpitem->cxItem += rc.right - rc.left;
1952 itemheight = max( max( itemheight, txtheight), UserGetSystemMetrics( SM_CYMENU) - 1);
1953
1954 lpitem->cxItem += 2 * MenuCharSize.cx;
1955 } else {
1956 if ((p = wcschr( lpitem->Xlpstr, '\t' )) != NULL) {
1957 RECT tmprc = rc;
1958 LONG tmpheight;
1959 int n = (int)( p - lpitem->Xlpstr);
1960 /* Item contains a tab (only meaningful in popup menus) */
1961 /* get text size before the tab */
1962 txtheight = DrawTextW( hdc, lpitem->Xlpstr, n, &rc,
1964 txtwidth = rc.right - rc.left;
1965 p += 1; /* advance past the Tab */
1966 /* get text size after the tab */
1967 tmpheight = DrawTextW( hdc, p, -1, &tmprc,
1969 lpitem->dxTab += txtwidth;
1970 txtheight = max( txtheight, tmpheight);
1971 txtwidth += MenuCharSize.cx + /* space for the tab */
1972 tmprc.right - tmprc.left; /* space for the short cut */
1973 } else {
1974 txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc,
1976 txtwidth = rc.right - rc.left;
1977 lpitem->dxTab += txtwidth;
1978 }
1979 lpitem->cxItem += 2 + txtwidth;
1980 itemheight = max( itemheight,
1981 max( txtheight + 2, MenuCharSize.cy + 4));
1982 }
1983 if (hfontOld)
1984 {
1985 NtGdiSelectFont (hdc, hfontOld);
1986 }
1987 } else if( menuBar) {
1988 itemheight = max( itemheight, UserGetSystemMetrics(SM_CYMENU)-1);
1989 }
1990 lpitem->cyItem += itemheight;
1991 TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem->xItem, lpitem->yItem, lpitem->cxItem, lpitem->cyItem);
1992}
#define wcschr
Definition: compat.h:17
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
GLdouble n
Definition: glext.h:7729
GLfloat GLfloat p
Definition: glext.h:8902
@ OBI_MNARROW
Definition: ntuser.h:966
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:16
ULONG_PTR itemData
Definition: winuser.h:3636
#define max(a, b)
Definition: svc.c:63
#define HIWORD(l)
Definition: typedefs.h:247
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
static SIZE MenuCharSize
Definition: menu.c:18
static void FASTCALL MENU_GetBitmapItemSize(PITEM lpitem, SIZE *size, PWND WndOwner)
Definition: menu.c:1590
HFONT ghMenuFontBold
Definition: menu.c:17
LONG IntGetDialogBaseUnits(VOID)
Definition: menu.c:1802
LONG_PTR LPARAM
Definition: windef.h:208
#define SM_CXMENUCHECK
Definition: winuser.h:1025
#define HBMMENU_MBAR_MINIMIZE
Definition: winuser.h:2623
#define DT_SINGLELINE
Definition: winuser.h:540
#define MF_SYSMENU
Definition: winuser.h:141
#define HBMMENU_MBAR_MINIMIZE_D
Definition: winuser.h:2626
#define MF_SEPARATOR
Definition: winuser.h:137
#define WM_MEASUREITEM
Definition: winuser.h:1636
#define MNS_NOCHECK
Definition: winuser.h:750
#define SM_CYMENUSIZE
Definition: winuser.h:1012
#define DT_CALCRECT
Definition: winuser.h:526
#define MF_OWNERDRAW
Definition: winuser.h:135
#define ODT_MENU
Definition: winuser.h:2527

Referenced by MENU_MenuBarCalcSize(), and MENU_PopupMenuCalcSize().

◆ MENU_depth()

int FASTCALL MENU_depth ( PMENU  pmenu,
int  depth 
)

Definition at line 406 of file menu.c.

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}
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546

Referenced by IntSetMenuItemInfo(), and MENU_depth().

◆ MENU_DoNextMenu()

static LRESULT FASTCALL MENU_DoNextMenu ( MTRACKER pmt,
UINT  Vk,
UINT  wFlags 
)
static

Definition at line 3739 of file menu.c.

3740{
3741 BOOL atEnd = FALSE;
3742
3743 /* When skipping left, we need to do something special after the
3744 first menu. */
3745 if (Vk == VK_LEFT && pmt->TopMenu->iItem == 0)
3746 {
3747 atEnd = TRUE;
3748 }
3749 /* When skipping right, for the non-system menu, we need to
3750 handle the last non-special menu item (ie skip any window
3751 icons such as MDI maximize, restore or close) */
3752 else if ((Vk == VK_RIGHT) && !IS_SYSTEM_MENU(pmt->TopMenu))
3753 {
3754 UINT i = pmt->TopMenu->iItem + 1;
3755 while (i < pmt->TopMenu->cItems) {
3756 if ((pmt->TopMenu->rgItems[i].wID >= SC_SIZE &&
3757 pmt->TopMenu->rgItems[i].wID <= SC_RESTORE)) {
3758 i++;
3759 } else break;
3760 }
3761 if (i == pmt->TopMenu->cItems) {
3762 atEnd = TRUE;
3763 }
3764 }
3765 /* When skipping right, we need to cater for the system menu */
3766 else if ((Vk == VK_RIGHT) && IS_SYSTEM_MENU(pmt->TopMenu))
3767 {
3768 if (pmt->TopMenu->iItem == (pmt->TopMenu->cItems - 1)) {
3769 atEnd = TRUE;
3770 }
3771 }
3772
3773 if ( atEnd )
3774 {
3775 MDINEXTMENU NextMenu;
3776 PMENU MenuTmp;
3777 PWND pwndTemp;
3778 HMENU hNewMenu;
3779 HWND hNewWnd;
3780 UINT Id = 0;
3781
3782 MenuTmp = (IS_SYSTEM_MENU(pmt->TopMenu)) ? co_IntGetSubMenu(pmt->TopMenu, 0) : pmt->TopMenu;
3783 NextMenu.hmenuIn = UserHMGetHandle(MenuTmp);
3784 NextMenu.hmenuNext = NULL;
3785 NextMenu.hwndNext = NULL;
3787
3788 TRACE("%p [%p] -> %p [%p]\n",
3789 pmt->CurrentMenu, pmt->OwnerWnd, NextMenu.hmenuNext, NextMenu.hwndNext );
3790
3791 if (NULL == NextMenu.hmenuNext || NULL == NextMenu.hwndNext)
3792 {
3793 hNewWnd = UserHMGetHandle(pmt->OwnerWnd);
3794 if (IS_SYSTEM_MENU(pmt->TopMenu))
3795 {
3796 /* switch to the menu bar */
3797
3798 if (pmt->OwnerWnd->style & WS_CHILD || !(MenuTmp = IntGetMenu(hNewWnd))) return FALSE;
3799
3800 if (Vk == VK_LEFT)
3801 {
3802 Id = MenuTmp->cItems - 1;
3803
3804 /* Skip backwards over any system predefined icons,
3805 eg. MDI close, restore etc icons */
3806 while ((Id > 0) &&
3807 (MenuTmp->rgItems[Id].wID >= SC_SIZE &&
3808 MenuTmp->rgItems[Id].wID <= SC_RESTORE)) Id--;
3809
3810 }
3811 hNewMenu = UserHMGetHandle(MenuTmp);
3812 }
3813 else if (pmt->OwnerWnd->style & WS_SYSMENU)
3814 {
3815 /* switch to the system menu */
3816 MenuTmp = get_win_sys_menu(hNewWnd);
3817 if (MenuTmp) hNewMenu = UserHMGetHandle(MenuTmp);
3818 else hNewMenu = NULL;
3819 }
3820 else
3821 return FALSE;
3822 }
3823 else /* application returned a new menu to switch to */
3824 {
3825 hNewMenu = NextMenu.hmenuNext;
3826 hNewWnd = NextMenu.hwndNext;
3827
3828 if ((MenuTmp = UserGetMenuObject(hNewMenu)) && (pwndTemp = ValidateHwndNoErr(hNewWnd)))
3829 {
3830 if ( pwndTemp->style & WS_SYSMENU && (get_win_sys_menu(hNewWnd) == MenuTmp) )
3831 {
3832 /* get the real system menu */
3833 MenuTmp = get_win_sys_menu(hNewWnd);
3834 hNewMenu = UserHMGetHandle(MenuTmp);
3835 }
3836 else if (pwndTemp->style & WS_CHILD || IntGetMenu(hNewWnd) != MenuTmp)
3837 {
3838 /* FIXME: Not sure what to do here;
3839 * perhaps try to track NewMenu as a popup? */
3840
3841 WARN(" -- got confused.\n");
3842 return FALSE;
3843 }
3844 }
3845 else return FALSE;
3846 }
3847
3848 if (hNewMenu != UserHMGetHandle(pmt->TopMenu))
3849 {
3851
3852 if (pmt->CurrentMenu != pmt->TopMenu)
3854 }
3855
3856 if (hNewWnd != UserHMGetHandle(pmt->OwnerWnd))
3857 {
3859 pmt->OwnerWnd = ValidateHwndNoErr(hNewWnd);
3862 pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
3864 pti->MessageQueue->QF_flags |= QF_CAPTURELOCKED;
3865 }
3866
3867 pmt->TopMenu = pmt->CurrentMenu = UserGetMenuObject(hNewMenu); /* all subpopups are hidden */
3868 MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, Id, TRUE, 0);
3869
3870 return TRUE;
3871 }
3872 return FALSE;
3873}
#define WARN(fmt,...)
Definition: debug.h:112
#define QF_CAPTURELOCKED
Definition: msgqueue.h:111
HMENU hmenuNext
Definition: winuser.h:3626
HMENU hmenuIn
Definition: winuser.h:3625
PMENU get_win_sys_menu(HWND hwnd)
Definition: menu.c:260
PMENU FASTCALL co_IntGetSubMenu(PMENU pMenu, int nPos)
Definition: menu.c:1350
#define WM_NEXTMENU
Definition: winuser.h:1796
#define VK_LEFT
Definition: winuser.h:2214
#define VK_RIGHT
Definition: winuser.h:2216

Referenced by MENU_KeyLeft(), and MENU_KeyRight().

◆ MENU_DrawBitmapItem()

static void FASTCALL MENU_DrawBitmapItem ( HDC  hdc,
PITEM  lpitem,
const RECT rect,
PMENU  Menu,
PWND  WndOwner,
UINT  odaction,
BOOL  MenuBar 
)
static

Definition at line 1655 of file menu.c.

1657{
1658 BITMAP bm;
1659 DWORD rop;
1660 HDC hdcMem;
1661 HBITMAP bmp;
1662 int w = rect->right - rect->left;
1663 int h = rect->bottom - rect->top;
1664 int bmp_xoffset = 0;
1665 int left, top;
1666 BOOL flat_menu;
1667 HBITMAP hbmToDraw = lpitem->hbmp;
1668 bmp = hbmToDraw;
1669
1670 UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
1671
1672 /* Check if there is a magic menu item associated with this item */
1673 if (IS_MAGIC_BITMAP(hbmToDraw))
1674 {
1675 UINT flags = 0;
1676 RECT r;
1677
1678 r = *rect;
1679 switch ((INT_PTR)hbmToDraw)
1680 {
1681 case (INT_PTR)HBMMENU_SYSTEM:
1682 if (lpitem->dwItemData)
1683 {
1684 if (ValidateHwndNoErr((HWND)lpitem->dwItemData))
1685 {
1686 ERR("Get Item Data from this Window!!!\n");
1687 }
1688
1689 ERR("Draw Bitmap\n");
1690 bmp = (HBITMAP)lpitem->dwItemData;
1691 if (!GreGetObject( bmp, sizeof(bm), &bm )) return;
1692 }
1693 else
1694 {
1695 PCURICON_OBJECT pIcon = NULL;
1696 //if (!BmpSysMenu) BmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
1697 //bmp = BmpSysMenu;
1698 //if (! GreGetObject(bmp, sizeof(bm), &bm)) return;
1699 /* only use right half of the bitmap */
1700 //bmp_xoffset = bm.bmWidth / 2;
1701 //bm.bmWidth -= bmp_xoffset;
1702 if (WndOwner)
1703 {
1704 pIcon = NC_IconForWindow(WndOwner);
1705 // FIXME: NC_IconForWindow should reference it for us */
1706 if (pIcon) UserReferenceObject(pIcon);
1707 }
1708 ERR("Draw ICON\n");
1709 if (pIcon)
1710 {
1713 LONG x = rect->left - cx/2 + 1 + (rect->bottom - rect->top)/2; // this is really what Window does
1714 LONG y = (rect->top + rect->bottom)/2 - cy/2; // center
1715 UserDrawIconEx(hdc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
1716 UserDereferenceObject(pIcon);
1717 }
1718 return;
1719 }
1720 goto got_bitmap;
1723 break;
1725 r.right += 1;
1727 break;
1729 r.right += 1;
1731 break;
1734 break;
1737 break;
1739 {
1740 DRAWITEMSTRUCT drawItem;
1741 POINT origorg;
1742 drawItem.CtlType = ODT_MENU;
1743 drawItem.CtlID = 0;
1744 drawItem.itemID = lpitem->wID;
1745 drawItem.itemAction = odaction;
1746 drawItem.itemState = (lpitem->fState & MF_CHECKED)?ODS_CHECKED:0;
1747 drawItem.itemState |= (lpitem->fState & MF_DEFAULT)?ODS_DEFAULT:0;
1748 drawItem.itemState |= (lpitem->fState & MF_DISABLED)?ODS_DISABLED:0;
1749 drawItem.itemState |= (lpitem->fState & MF_GRAYED)?ODS_GRAYED|ODS_DISABLED:0;
1750 drawItem.itemState |= (lpitem->fState & MF_HILITE)?ODS_SELECTED:0;
1751 drawItem.itemState |= (!(Menu->fFlags & MNF_UNDERLINE))?ODS_NOACCEL:0;
1752 drawItem.itemState |= (Menu->fFlags & MNF_INACTIVE)?ODS_INACTIVE:0;
1753 drawItem.hwndItem = (HWND)UserHMGetHandle(Menu);
1754 drawItem.hDC = hdc;
1755 drawItem.rcItem = *rect;
1756 drawItem.itemData = lpitem->dwItemData;
1757 /* some applications make this assumption on the DC's origin */
1758 GreSetViewportOrgEx( hdc, lpitem->xItem, lpitem->yItem, &origorg);
1759 RECTL_vOffsetRect(&drawItem.rcItem, -(LONG)lpitem->xItem, -(LONG)lpitem->yItem);
1760 co_IntSendMessage( UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM)&drawItem);
1761 GreSetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
1762 return;
1763 }
1764 break;
1765
1770 MENU_DrawPopupGlyph(hdc, &r, (INT_PTR)hbmToDraw, lpitem->fState & MF_GRAYED, lpitem->fState & MF_HILITE);
1771 return;
1772 }
1773 RECTL_vInflateRect(&r, -1, -1);
1774 if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
1776 return;
1777 }
1778
1779 if (!bmp || !GreGetObject( bmp, sizeof(bm), &bm )) return;
1780
1781 got_bitmap:
1784 /* handle fontsize > bitmap_height */
1785 top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
1786 left=rect->left;
1787 rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_BITMAP(hbmToDraw)) ? NOTSRCCOPY : SRCCOPY;
1788 if ((lpitem->fState & MF_HILITE) && lpitem->hbmp)
1790 if (MenuBar &&
1791 !flat_menu &&
1792 (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
1793 {
1794 ++left;
1795 ++top;
1796 }
1797 NtGdiBitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop , 0, 0);
1799}
COLORREF FASTCALL IntGdiSetBkColor(_In_ HDC hDC, _In_ COLORREF Color)
BOOL FASTCALL IntGdiDeleteDC(HDC, BOOL)
Definition: dclife.c:892
HANDLE HWND
Definition: compat.h:19
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLint left
Definition: glext.h:7726
GLbitfield flags
Definition: glext.h:7161
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define MNF_INACTIVE
Definition: ntuser.h:399
#define MNF_UNDERLINE
Definition: ntuser.h:398
if(dx< 0)
Definition: linetemp.h:194
BITMAP bmp
Definition: alphablend.c:62
static int rop(int rop, int src, int dst)
Definition: nanoxwin.c:124
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)
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
Definition: bl.h:1331
ULONG_PTR itemData
Definition: winuser.h:3083
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
int32_t INT_PTR
Definition: typedefs.h:64
HDC hdcMem
Definition: welcome.c:104
INT NTAPI GreGetObject(IN HGDIOBJ hobj, IN INT cbCount, OUT PVOID pvBuffer)
Definition: gdiobj.c:1264
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:1688
#define IS_MAGIC_BITMAP(id)
Definition: menu.c:65
static void FASTCALL MENU_DrawPopupGlyph(HDC dc, LPRECT r, INT_PTR popupMagic, BOOL inactive, BOOL hilite)
Definition: menu.c:1400
PCURICON_OBJECT FASTCALL NC_IconForWindow(PWND pWnd)
Definition: nonclient.c:703
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
#define DI_NORMAL
Definition: wingdi.h:72
#define SRCCOPY
Definition: wingdi.h:333
#define NOTSRCCOPY
Definition: wingdi.h:325
#define ODS_DISABLED
Definition: winuser.h:2537
#define ODS_SELECTED
Definition: winuser.h:2535
#define HBMMENU_SYSTEM
Definition: winuser.h:2621
#define HBMMENU_MBAR_RESTORE
Definition: winuser.h:2622
#define ODS_CHECKED
Definition: winuser.h:2538
#define HBMMENU_POPUP_RESTORE
Definition: winuser.h:2628
BOOL WINAPI DrawFrameControl(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
#define DFCS_CAPTIONMIN
Definition: winuser.h:481
#define DFCS_CAPTIONCLOSE
Definition: winuser.h:480
#define COLOR_HIGHLIGHT
Definition: winuser.h:920
#define DFCS_INACTIVE
Definition: winuser.h:502
#define SM_CYSMICON
Definition: winuser.h:1007
#define WM_DRAWITEM
Definition: winuser.h:1635
#define DFC_CAPTION
Definition: winuser.h:473
#define MF_DEFAULT
Definition: winuser.h:140
#define SM_CXSMICON
Definition: winuser.h:1006
#define HBMMENU_POPUP_CLOSE
Definition: winuser.h:2627
#define DFCS_CAPTIONRESTORE
Definition: winuser.h:483
#define HBMMENU_MBAR_CLOSE
Definition: winuser.h:2624
#define ODS_GRAYED
Definition: winuser.h:2536
#define HBMMENU_MBAR_CLOSE_D
Definition: winuser.h:2625
#define HBMMENU_POPUP_MAXIMIZE
Definition: winuser.h:2629
#define DFCS_PUSHED
Definition: winuser.h:503

Referenced by MENU_DrawMenuItem().

◆ MENU_DrawMenuBar()

UINT MENU_DrawMenuBar ( HDC  hDC,
LPRECT  lprect,
PWND  pWnd,
BOOL  suppress_draw 
)

Definition at line 2744 of file menu.c.

2745{
2746 HFONT hfontOld = 0;
2748
2749 if (lppop == NULL)
2750 {
2751 // No menu. Do not reserve any space
2752 return 0;
2753 }
2754
2755 if (lprect == NULL)
2756 {
2758 }
2759
2760 if (suppress_draw)
2761 {
2762 hfontOld = NtGdiSelectFont(hDC, ghMenuFont);
2763
2764 MENU_MenuBarCalcSize(hDC, lprect, lppop, pWnd);
2765
2766 lprect->bottom = lprect->top + lppop->cyMenu;
2767
2768 if (hfontOld) NtGdiSelectFont( hDC, hfontOld);
2769
2770 return lppop->cyMenu;
2771 }
2772 else
2773 {
2774 return IntDrawMenuBarTemp(pWnd, hDC, lprect, lppop, NULL);
2775 }
2776}
DWORD WINAPI IntDrawMenuBarTemp(PWND pWnd, HDC hDC, LPRECT Rect, PMENU pMenu, HFONT Font)
Definition: menu.c:2687

Referenced by NC_DoNCPaint(), NC_HandleNCCalcSize(), NtUserCalcMenuBar(), NtUserPaintMenuBar(), and UserDrawCaptionBar().

◆ MENU_DrawMenuItem()

static void FASTCALL MENU_DrawMenuItem ( PWND  Wnd,
PMENU  Menu,
PWND  WndOwner,
HDC  hdc,
PITEM  lpitem,
UINT  Height,
BOOL  menuBar,
UINT  odaction 
)
static

Definition at line 2206 of file menu.c.

2208{
2209 RECT rect;
2210 PWCHAR Text;
2211 BOOL flat_menu = FALSE;
2212 int bkgnd;
2213 UINT arrow_bitmap_width = 0;
2214 //RECT bmprc;
2215
2216 if (!menuBar) {
2217 arrow_bitmap_width = gpsi->oembmi[OBI_MNARROW].cx;
2218 }
2219
2220 if (lpitem->fType & MF_SYSMENU)
2221 {
2222 if (!(Wnd->style & WS_MINIMIZE))
2223 {
2224 NC_GetInsideRect(Wnd, &rect);
2226 }
2227 return;
2228 }
2229
2230 UserSystemParametersInfo (SPI_GETFLATMENU, 0, &flat_menu, 0);
2231 bkgnd = (menuBar && flat_menu) ? COLOR_MENUBAR : COLOR_MENU;
2232
2233 /* Setup colors */
2234
2235 if (lpitem->fState & MF_HILITE)
2236 {
2237 if(menuBar && !flat_menu) {
2240 } else {
2241 if (lpitem->fState & MF_GRAYED)
2243 else
2246 }
2247 }
2248 else
2249 {
2250 if (lpitem->fState & MF_GRAYED)
2252 else
2254 IntGdiSetBkColor( hdc, IntGetSysColor( bkgnd ) );
2255 }
2256
2257 //TRACE("rect=%s\n", wine_dbgstr_rect( &lpitem->Rect));
2258 //rect = lpitem->Rect;
2259 rect.left = lpitem->xItem;
2260 rect.top = lpitem->yItem;
2261 rect.right = lpitem->cxItem; // Do this for now......
2262 rect.bottom = lpitem->cyItem;
2263
2265
2266 if (lpitem->fType & MF_OWNERDRAW)
2267 {
2268 /*
2269 ** Experimentation under Windows reveals that an owner-drawn
2270 ** menu is given the rectangle which includes the space it requested
2271 ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
2272 ** and a popup-menu arrow. This is the value of lpitem->rect.
2273 ** Windows will leave all drawing to the application except for
2274 ** the popup-menu arrow. Windows always draws that itself, after
2275 ** the menu owner has finished drawing.
2276 */
2277 DRAWITEMSTRUCT dis;
2278 COLORREF old_bk, old_text;
2279
2280 dis.CtlType = ODT_MENU;
2281 dis.CtlID = 0;
2282 dis.itemID = lpitem->wID;
2283 dis.itemData = (DWORD)lpitem->dwItemData;
2284 dis.itemState = 0;
2285 if (lpitem->fState & MF_CHECKED) dis.itemState |= ODS_CHECKED;
2286 if (lpitem->fState & MF_DEFAULT) dis.itemState |= ODS_DEFAULT;
2287 if (lpitem->fState & MF_DISABLED) dis.itemState |= ODS_DISABLED;
2288 if (lpitem->fState & MF_GRAYED) dis.itemState |= ODS_GRAYED | ODS_DISABLED;
2289 if (lpitem->fState & MF_HILITE) dis.itemState |= ODS_SELECTED;
2290 if (!(Menu->fFlags & MNF_UNDERLINE)) dis.itemState |= ODS_NOACCEL;
2291 if (Menu->fFlags & MNF_INACTIVE) dis.itemState |= ODS_INACTIVE;
2292 dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
2293 dis.hwndItem = (HWND) UserHMGetHandle(Menu);
2294 dis.hDC = hdc;
2295 dis.rcItem = rect;
2296 TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
2297 "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", Wnd,
2298 dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
2299 dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
2300 dis.rcItem.bottom);
2301 TRACE("Ownerdraw: Width %d Height %d\n", dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top);
2302 old_bk = GreGetBkColor(hdc);
2303 old_text = GreGetTextColor(hdc);
2304 co_IntSendMessage(UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM) &dis);
2305 IntGdiSetBkColor(hdc, old_bk);
2306 IntGdiSetTextColor(hdc, old_text);
2307 /* Draw the popup-menu arrow */
2308 if (!menuBar && lpitem->spSubMenu)
2309 {
2310 RECT rectTemp;
2311 RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
2312 rectTemp.left = rectTemp.right - UserGetSystemMetrics(SM_CXMENUCHECK);
2314 }
2315 return;
2316 }
2317
2318 if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
2319
2320 if (lpitem->fState & MF_HILITE)
2321 {
2322 if (flat_menu)
2323 {
2324 RECTL_vInflateRect (&rect, -1, -1);
2325 FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENUHILIGHT));
2326 RECTL_vInflateRect (&rect, 1, 1);
2328 }
2329 else
2330 {
2331 if (menuBar)
2332 {
2335 }
2336 else
2337 {
2339 }
2340 }
2341 }
2342 else
2343 FillRect( hdc, &rect, IntGetSysColorBrush(bkgnd) );
2344
2346
2347 /* vertical separator */
2348 if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
2349 {
2350 HPEN oldPen;
2351 RECT rc = rect;
2352
2353 rc.left -= 3;//MENU_COL_SPACE / 2 + 1; == 3!!
2354 rc.top = 3;
2355 rc.bottom = Height - 3;
2356 if (flat_menu)
2357 {
2358 oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
2360 GreMoveTo( hdc, rc.left, rc.top, NULL );
2361 NtGdiLineTo( hdc, rc.left, rc.bottom );
2362 NtGdiSelectPen( hdc, oldPen );
2363 }
2364 else
2366 }
2367
2368 /* horizontal separator */
2369 if (lpitem->fType & MF_SEPARATOR)
2370 {
2371 HPEN oldPen;
2372 RECT rc = rect;
2373
2374 rc.left++;
2375 rc.right--;
2376 rc.top = (rc.top + rc.bottom) / 2 - 1;
2377 if (flat_menu)
2378 {
2379 oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
2381 GreMoveTo( hdc, rc.left, rc.top, NULL );
2382 NtGdiLineTo( hdc, rc.right, rc.top );
2383 NtGdiSelectPen( hdc, oldPen );
2384 }
2385 else
2386 DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
2387 return;
2388 }
2389#if 0
2390 /* helper lines for debugging */
2391 /* This is a very good test tool when hacking menus! (JT) 07/16/2006 */
2395 GreMoveTo(hdc, rect.left, (rect.top + rect.bottom) / 2, NULL);
2396 NtGdiLineTo(hdc, rect.right, (rect.top + rect.bottom) / 2);
2397#endif
2398#if 0 // breaks mdi menu bar icons.
2399 if (lpitem->hbmp) {
2400 /* calculate the bitmap rectangle in coordinates relative
2401 * to the item rectangle */
2402 if( menuBar) {
2403 if( lpitem->hbmp == HBMMENU_CALLBACK)
2404 bmprc.left = 3;
2405 else
2406 bmprc.left = lpitem->Xlpstr ? MenuCharSize.cx : 0;
2407 }
2408 else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)
2409 bmprc.left = 4;
2410 else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)
2411 bmprc.left = 2;
2412 else
2413 bmprc.left = 4 + UserGetSystemMetrics(SM_CXMENUCHECK);
2414
2415 bmprc.right = bmprc.left + lpitem->cxBmp;
2416
2417 if( menuBar && !(lpitem->hbmp == HBMMENU_CALLBACK))
2418 bmprc.top = 0;
2419 else
2420 bmprc.top = (rect.bottom - rect.top - lpitem->cyBmp) / 2;
2421
2422 bmprc.bottom = bmprc.top + lpitem->cyBmp;
2423 }
2424#endif
2425 if (!menuBar)
2426 {
2427 HBITMAP bm;
2428 INT y = rect.top + rect.bottom;
2429 RECT rc = rect;
2430 BOOL checked = FALSE;
2431 UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
2432 UINT check_bitmap_height = UserGetSystemMetrics( SM_CYMENUCHECK );
2433 /* Draw the check mark
2434 *
2435 * FIXME:
2436 * Custom checkmark bitmaps are monochrome but not always 1bpp.
2437 */
2438 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)) {
2439 bm = (lpitem->fState & MF_CHECKED) ? lpitem->hbmpChecked :
2440 lpitem->hbmpUnchecked;
2441 if (bm) /* we have a custom bitmap */
2442 {
2444
2446 NtGdiBitBlt( hdc, rc.left, (y - check_bitmap_height) / 2,
2447 check_bitmap_width, check_bitmap_height,
2448 hdcMem, 0, 0, SRCCOPY, 0,0);
2450 checked = TRUE;
2451 }
2452 else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
2453 {
2454 RECT r;
2455 r = rect;
2456 r.right = r.left + check_bitmap_width;
2458 (lpitem->fType & MFT_RADIOCHECK) ?
2460 checked = TRUE;
2461 }
2462 }
2463 if ( lpitem->hbmp )//&& !( checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
2464 {
2465 RECT bmpRect = rect;
2466 if (!((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP) && !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
2467 bmpRect.left += check_bitmap_width + 2;
2468 if (!(checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
2469 {
2470 bmpRect.right = bmpRect.left + lpitem->cxBmp;
2471 MENU_DrawBitmapItem(hdc, lpitem, &bmpRect, Menu, WndOwner, odaction, menuBar);
2472 }
2473 }
2474 /* Draw the popup-menu arrow */
2475 if (lpitem->spSubMenu)
2476 {
2477 RECT rectTemp;
2478 RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
2479 rectTemp.left = rectTemp.right - check_bitmap_width;
2481 }
2482 rect.left += 4;
2483 if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
2484 rect.left += check_bitmap_width;
2485 rect.right -= arrow_bitmap_width;
2486 }
2487 else if( lpitem->hbmp)
2488 { /* Draw the bitmap */
2489 MENU_DrawBitmapItem(hdc, lpitem, &rect/*bmprc*/, Menu, WndOwner, odaction, menuBar);
2490 }
2491
2492 /* process text if present */
2493 if (lpitem->Xlpstr)
2494 {
2495 int i = 0;
2496 HFONT hfontOld = 0;
2497
2498 UINT uFormat = menuBar ?
2501
2502 if (((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP))
2503 rect.left += max(0, (int)(Menu->cxTextAlign - UserGetSystemMetrics(SM_CXMENUCHECK)));
2504 else
2505 rect.left += Menu->cxTextAlign;
2506
2507 if ( lpitem->fState & MFS_DEFAULT )
2508 {
2509 hfontOld = NtGdiSelectFont(hdc, ghMenuFontBold);
2510 }
2511
2512 if (menuBar) {
2513 if( lpitem->hbmp)
2514 rect.left += lpitem->cxBmp;
2515 if( !(lpitem->hbmp == HBMMENU_CALLBACK))
2516 rect.left += MenuCharSize.cx;
2517 rect.right -= MenuCharSize.cx;
2518 }
2519
2520 Text = lpitem->Xlpstr;
2521 if(Text)
2522 {
2523 for (i = 0; Text[i]; i++)
2524 if (Text[i] == L'\t' || Text[i] == L'\b')
2525 break;
2526 }
2527
2528 if (menuBar &&
2529 !flat_menu &&
2530 (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
2531 {
2532 RECTL_vOffsetRect(&rect, +1, +1);
2533 }
2534
2535 if (!menuBar)
2536 --rect.bottom;
2537
2538 if(lpitem->fState & MF_GRAYED)
2539 {
2540 if (!(lpitem->fState & MF_HILITE) )
2541 {
2542 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
2544 DrawTextW( hdc, Text, i, &rect, uFormat );
2545 --rect.left; --rect.top; --rect.right; --rect.bottom;
2546 }
2548 }
2549 DrawTextW( hdc, Text, i, &rect, uFormat);
2550
2551 /* paint the shortcut text */
2552 if (!menuBar && L'\0' != Text[i]) /* There's a tab or flush-right char */
2553 {
2554 if (L'\t' == Text[i])
2555 {
2556 rect.left = lpitem->dxTab;
2557 uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
2558 }
2559 else
2560 {
2561 rect.right = lpitem->dxTab;
2562 uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
2563 }
2564
2565 if (lpitem->fState & MF_GRAYED)
2566 {
2567 if (!(lpitem->fState & MF_HILITE) )
2568 {
2569 ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
2571 DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat);
2572 --rect.left; --rect.top; --rect.right; --rect.bottom;
2573 }
2575 }
2576 DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat );
2577 }
2578
2579 if (!menuBar)
2580 ++rect.bottom;
2581
2582 if (menuBar &&
2583 !flat_menu &&
2584 (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
2585 {
2586 RECTL_vOffsetRect(&rect, -1, -1);
2587 }
2588
2589 if (hfontOld)
2590 {
2591 NtGdiSelectFont (hdc, hfontOld);
2592 }
2593 }
2594}
char * Text
Definition: combotst.c:136
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
COLORREF FASTCALL GreGetBkColor(HDC)
Definition: dcutil.c:50
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode)
Definition: dcutil.c:124
COLORREF FASTCALL GreGetTextColor(HDC)
Definition: dcutil.c:80
#define L(x)
Definition: ntvdm.h:50
#define WS_MINIMIZE
Definition: pedump.c:622
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint16_t * PWCHAR
Definition: typedefs.h:56
_In_ HFONT _Out_ PUINT Height
Definition: font.h:125
BOOL FASTCALL UITOOLS95_DrawFrameMenu(HDC dc, LPRECT r, UINT uFlags)
Definition: draw.c:959
VOID FASTCALL MENU_AdjustMenuItemRect(PMENU menu, PRECTL rect)
Definition: menu.c:1464
static void FASTCALL MENU_DrawBitmapItem(HDC hdc, PITEM lpitem, const RECT *rect, PMENU Menu, PWND WndOwner, UINT odaction, BOOL MenuBar)
Definition: menu.c:1655
BOOL UserDrawSysMenuButton(PWND pWnd, HDC hDC, LPRECT Rect, BOOL Down)
Definition: nonclient.c:734
void FASTCALL NC_GetInsideRect(PWND Wnd, RECT *rect)
Definition: nonclient.c:71
DWORD COLORREF
Definition: windef.h:300
#define TRANSPARENT
Definition: wingdi.h:950
#define BLACK_BRUSH
Definition: wingdi.h:896
#define DFCS_MENUCHECK
Definition: winuser.h:486
int WINAPI FrameRect(_In_ HDC, _In_ LPCRECT, _In_ HBRUSH)
#define BDR_SUNKENOUTER
Definition: winuser.h:443
#define COLOR_GRAYTEXT
Definition: winuser.h:926
#define COLOR_WINDOWFRAME
Definition: winuser.h:913
#define DT_CENTER
Definition: winuser.h:527
#define MF_MENUBARBREAK
Definition: winuser.h:133
#define BF_LEFT
Definition: winuser.h:454
#define DFCS_MENUARROW
Definition: winuser.h:485
#define EDGE_ETCHED
Definition: winuser.h:452
#define MNS_CHECKORBMP
Definition: winuser.h:755
#define DT_LEFT
Definition: winuser.h:534
#define SM_CYMENUCHECK
Definition: winuser.h:1026
BOOL WINAPI DrawEdge(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
#define BF_TOP
Definition: winuser.h:455
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:921
#define COLOR_BTNSHADOW
Definition: winuser.h:924
#define DT_VCENTER
Definition: winuser.h:543
#define DT_RIGHT
Definition: winuser.h:538
#define COLOR_MENUTEXT
Definition: winuser.h:914
#define DFCS_MENUBULLET
Definition: winuser.h:487
#define COLOR_BTNHIGHLIGHT
Definition: winuser.h:929
#define BF_RECT
Definition: winuser.h:462

Referenced by IntDrawMenuBarTemp(), MENU_DrawPopupMenu(), MENU_SelectItem(), and MENU_ShowSubPopup().

◆ MENU_DrawPopupGlyph()

static void FASTCALL MENU_DrawPopupGlyph ( HDC  dc,
LPRECT  r,
INT_PTR  popupMagic,
BOOL  inactive,
BOOL  hilite 
)
static

Definition at line 1400 of file menu.c.

1401{
1402 LOGFONTW lf;
1403 HFONT hFont, hOldFont;
1404 COLORREF clrsave;
1405 INT bkmode;
1406 WCHAR symbol;
1407 switch (popupMagic)
1408 {
1410 symbol = '2';
1411 break;
1413 symbol = '0';
1414 break;
1416 symbol = '1';
1417 break;
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;
1431 RtlCopyMemory(lf.lfFaceName, L"Marlett", sizeof(L"Marlett"));
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 */
1439 if (inactive)
1440 {
1441 /* draw shadow */
1442 if (!hilite)
1443 {
1445 GreTextOutW(dc, r->left + 1, r->top + 1, &symbol, 1);
1446 }
1447 }
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);
1456}
HFONT hFont
Definition: main.c:53
int FASTCALL GreGetBkMode(HDC)
Definition: dcutil.c:35
static const WCHAR dc[]
LONG lfHeight
Definition: dimm.idl:59
LONG lfWeight
Definition: dimm.idl:63
WCHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:72
LONG lfWidth
Definition: dimm.idl:60
BYTE lfCharSet
Definition: dimm.idl:67
HFONT FASTCALL GreCreateFontIndirectW(LOGFONTW *lplf)
Definition: font.c:23
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOL FASTCALL GreTextOutW(HDC hdc, int nXStart, int nYStart, LPCWSTR lpString, int cchString)
Definition: text.c:61
#define DEFAULT_CHARSET
Definition: wingdi.h:384
#define FW_NORMAL
Definition: wingdi.h:373

Referenced by MENU_DrawBitmapItem().

◆ MENU_DrawPopupMenu()

static void FASTCALL MENU_DrawPopupMenu ( PWND  wnd,
HDC  hdc,
PMENU  menu 
)
static

Definition at line 2601 of file menu.c.

2602{
2603 HBRUSH hPrevBrush = 0, brush = IntGetSysColorBrush(COLOR_MENU);
2604 RECT rect;
2605
2606 TRACE("DPM wnd=%p dc=%p menu=%p\n", wnd, hdc, menu);
2607
2608 IntGetClientRect( wnd, &rect );
2609
2610 if (menu && menu->hbrBack) brush = menu->hbrBack;
2611 if((hPrevBrush = NtGdiSelectBrush( hdc, brush ))
2613 {
2614 HPEN hPrevPen;
2615
2616 /* FIXME: Maybe we don't have to fill the background manually */
2617 FillRect(hdc, &rect, brush);
2618
2620 if ( hPrevPen )
2621 {
2622 TRACE("hmenu %p Style %08x\n", UserHMGetHandle(menu), (menu->fFlags & MNS_STYLE_MASK));
2623 /* draw menu items */
2624 if (menu && menu->cItems)
2625 {
2626 ITEM *item;
2627 UINT u;
2628
2629 item = menu->rgItems;
2630 for( u = menu->cItems; u > 0; u--, item++)
2631 {
2632 MENU_DrawMenuItem(wnd, menu, menu->spwndNotify, hdc, item,
2633 menu->cyMenu, FALSE, ODA_DRAWENTIRE);
2634 }
2635 /* draw scroll arrows */
2636 if (menu->dwArrowsOn)
2637 {
2639 }
2640 }
2641 }
2642 else
2643 {
2644 NtGdiSelectBrush( hdc, hPrevBrush );
2645 }
2646 }
2647}
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)
static void MENU_DrawScrollArrows(PMENU lppop, HDC hdc)
Definition: menu.c:2178
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:93
#define NULL_PEN
Definition: wingdi.h:904

Referenced by PopupMenuWndProc().

◆ MENU_DrawScrollArrows()

static void MENU_DrawScrollArrows ( PMENU  lppop,
HDC  hdc 
)
static

Definition at line 2178 of file menu.c.

2179{
2180 UINT arrow_bitmap_height;
2181 RECT rect;
2182 UINT Flags = 0;
2183
2184 arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
2185
2186 rect.left = 0;
2187 rect.top = 0;
2188 rect.right = lppop->cxMenu;
2189 rect.bottom = arrow_bitmap_height;
2192
2193 rect.top = lppop->cyMenu - arrow_bitmap_height;
2194 rect.bottom = lppop->cyMenu;
2196 if (!(lppop->iTop < lppop->iMaxTop - (MENU_GetMaxPopupHeight(lppop) - 2 * arrow_bitmap_height)))
2199}
@ OBI_DNARROW
Definition: ntuser.h:964
#define DFCS_MENUARROWUP
Definition: undocuser.h:158
#define DFCS_MENUARROWDOWN
Definition: undocuser.h:159
static UINT MENU_GetMaxPopupHeight(PMENU lppop)
Definition: menu.c:1998

Referenced by MENU_DrawPopupMenu(), and MENU_EnsureMenuItemVisible().

◆ MENU_EndMenu()

void MENU_EndMenu ( PWND  pwnd)

Definition at line 2664 of file menu.c.

2665{
2666 PMENU menu = NULL;
2668 if ( menu && ( UserHMGetHandle(pwnd) == menu->hWnd || pwnd == menu->spwndNotify ) )
2669 {
2671 {
2673
2674 if (fInEndMenu)
2675 {
2676 ERR("Already in End loop\n");
2677 return;
2678 }
2679
2680 fInEndMenu = TRUE;
2682 }
2683 }
2684}
static HMENU top_popup_hmenu
Definition: menu.c:23
static HWND top_popup
Definition: menu.c:22
BOOL fInsideMenuLoop
Definition: menu.c:25
BOOL fInEndMenu
Definition: menu.c:26
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1346
#define WM_CANCELMODE
Definition: winuser.h:1625

Referenced by IntDefWindowProc().

◆ MENU_EnsureMenuItemVisible()

void MENU_EnsureMenuItemVisible ( PMENU  lppop,
UINT  wIndex,
HDC  hdc 
)

Definition at line 3099 of file menu.c.

3100{
3102 if (lppop->dwArrowsOn)
3103 {
3104 ITEM *item = &lppop->rgItems[wIndex];
3105 UINT nMaxHeight = MENU_GetMaxPopupHeight(lppop);
3106 UINT nOldPos = lppop->iTop;
3107 RECT rc;
3108 UINT arrow_bitmap_height;
3109 PWND pWnd = ValidateHwndNoErr(lppop->hWnd);
3110
3111 IntGetClientRect(pWnd, &rc);
3112
3113 arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
3114
3115 rc.top += arrow_bitmap_height;
3116 rc.bottom -= arrow_bitmap_height;
3117
3118 nMaxHeight -= UserGetSystemMetrics(SM_CYBORDER) + 2 * arrow_bitmap_height;
3119 UserRefObjectCo(pWnd, &Ref);
3120 if (item->cyItem > lppop->iTop + nMaxHeight)
3121 {
3122 lppop->iTop = item->cyItem - nMaxHeight;
3123 IntScrollWindow(pWnd, 0, nOldPos - lppop->iTop, &rc, &rc);
3124 MENU_DrawScrollArrows(lppop, hdc);
3125 //ERR("Scroll Down iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
3126 }
3127 else if (item->yItem < lppop->