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_SYSMENU))
#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)
ITEM *	MENU_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 ITEM *	MENU_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); \
  } \
}

Definition at line 183 of file menu.c.

IS_MAGIC_BITMAP

#define IS_MAGIC_BITMAP

(

id

)

((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))

Definition at line 63 of file menu.c.

IS_STRING_ITEM

#define IS_STRING_ITEM

(

flags

)

(MF_STRING == MENU_ITEM_TYPE(flags))

Definition at line 64 of file menu.c.

IS_SYSTEM_MENU

#define IS_SYSTEM_MENU

(

MenuInfo

)

(!!((MenuInfo)->fFlags & MNF_SYSMENU))

Definition at line 60 of file menu.c.

ITEM_NEXT

#define ITEM_NEXT   1

Definition at line 93 of file menu.c.

ITEM_PREV

#define ITEM_PREV   -1

Definition at line 92 of file menu.c.

MAX_GOINTOSUBMENU

#define MAX_GOINTOSUBMENU   (0x10)

Definition at line 68 of file menu.c.

MAX_MENU_ITEMS

#define MAX_MENU_ITEMS   (0x4000)

Definition at line 67 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 74 of file menu.c.

MENU_COL_SPACE

#define MENU_COL_SPACE   4

Definition at line 71 of file menu.c.

MENU_ITEM_HBMP_SPACE

#define MENU_ITEM_HBMP_SPACE   (5)

Definition at line 73 of file menu.c.

MENU_TAB_SPACE

#define MENU_TAB_SPACE   (8)

Definition at line 76 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_STRING | MFT_BITMAP | MFT_OWNERDRAW | MFT_SEPARATOR | \
                 MFT_MENUBARBREAK | MFT_MENUBREAK | MFT_RADIOCHECK | \
                 MFT_RIGHTORDER | MFT_RIGHTJUSTIFY /* same as MF_HELP */ )

Definition at line 47 of file menu.c.

MII_STATE_MASK

#define MII_STATE_MASK   (MFS_GRAYED|MFS_CHECKED|MFS_HILITE|MFS_DEFAULT)

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

#define MNS_STYLE_MASK   (MNS_NOCHECK|MNS_MODELESS|MNS_DRAGDROP|MNS_AUTODISMISS|MNS_NOTIFYBYPOS|MNS_CHECKORBMP)

Definition at line 45 of file menu.c.

SEPARATOR_HEIGHT

#define SEPARATOR_HEIGHT   (5)

Definition at line 75 of file menu.c.

SHOW_DEBUGRECT

#define SHOW_DEBUGRECT   0

Definition at line 2846 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 89 of file menu.c.

TPM_INTERNAL

#define TPM_INTERNAL   0xF0000000

Definition at line 88 of file menu.c.

TPM_POPUPMENU

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

Definition at line 90 of file menu.c.

TYPE_MASK

#define TYPE_MASK   (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)

Definition at line 52 of file menu.c.

UpdateMenuItemState

#define UpdateMenuItemState	(		state,
			change
	)

Definition at line 95 of file menu.c.

Function Documentation

co_IntGetSubMenu()

PMENU FASTCALL co_IntGetSubMenu	(	PMENU	pMenu,
		int	nPos
	)

Definition at line 1348 of file menu.c.

{
  PITEM pItem;
  if (!(pItem = MENU_FindItem( &pMenu, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
  return pItem->spSubMenu;
}

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

{
   PMENU ret = 0;
   WND *win = ValidateHwndNoErr( hwnd );        
   if (win)
   {
      ret = UserGetMenuObject(win->SystemMenu);
   }
   return ret;
}

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

IntCheckMenuItem()

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

Definition at line 1259 of file menu.c.

{
   PITEM MenuItem;
   DWORD res;
 
   if (!(MenuItem = MENU_FindItem( &MenuObject, &uIDCheckItem, uCheck ))) return -1;
 
   res = (DWORD)(MenuItem->fState & MF_CHECKED);
 
   MenuItem->fState ^= (res ^ uCheck) & MF_CHECKED;
 
   return res;
}

Referenced by NtUserCheckMenuItem().

IntCloneMenu()

PMENU FASTCALL IntCloneMenu

(

PMENU

Source

)

Definition at line 822 of file menu.c.

{
   HANDLE hMenu;
   PMENU Menu;
 
   if(!Source)
      return NULL;
 
   /* A menu is valid process wide. We can pass to the object manager any thread ptr */
   Menu = (PMENU)UserCreateObject( gHandleTable,
                                   Source->head.rpdesk,
                                   ((PPROCESSINFO)Source->head.hTaskWow)->ptiList,
                                   &hMenu,
                                   TYPE_MENU,
                                   sizeof(MENU));
   if(!Menu)
      return NULL;
 
   Menu->fFlags = Source->fFlags;
   Menu->cyMax = Source->cyMax;
   Menu->hbrBack = Source->hbrBack;
   Menu->dwContextHelpId = Source->dwContextHelpId;
   Menu->dwMenuData = Source->dwMenuData;
   Menu->iItem = NO_SELECTED_ITEM;
   Menu->spwndNotify = NULL;
   Menu->cyMenu = 0;
   Menu->cxMenu = 0;
   Menu->cItems = 0;
   Menu->iTop = 0;
   Menu->iMaxTop = 0;
   Menu->cxTextAlign = 0;
   Menu->rgItems = NULL;
 
   Menu->hWnd = NULL;
   Menu->TimeToHide = FALSE;
 
   IntCloneMenuItems(Menu, Source);
 
   return Menu;
}

Referenced by MENU_GetSystemMenu().

IntCloneMenuItems()

BOOL FASTCALL IntCloneMenuItems	(	PMENU	Destination,
		PMENU	Source
	)

Definition at line 771 of file menu.c.

{
   PITEM MenuItem, NewMenuItem = NULL;
   UINT i;
 
   if(!Source->cItems)
      return FALSE;
 
   NewMenuItem = DesktopHeapAlloc(Destination->head.rpdesk, Source->cItems * sizeof(ITEM));
   if(!NewMenuItem) return FALSE;
 
   RtlZeroMemory(NewMenuItem, Source->cItems * sizeof(ITEM));
 
   Destination->rgItems = NewMenuItem;
 
   MenuItem = Source->rgItems;
   for (i = 0; i < Source->cItems; i++, MenuItem++, NewMenuItem++)
   {
      NewMenuItem->fType = MenuItem->fType;
      NewMenuItem->fState = MenuItem->fState;
      NewMenuItem->wID = MenuItem->wID;
      NewMenuItem->spSubMenu = MenuItem->spSubMenu;
      NewMenuItem->hbmpChecked = MenuItem->hbmpChecked;
      NewMenuItem->hbmpUnchecked = MenuItem->hbmpUnchecked;
      NewMenuItem->dwItemData = MenuItem->dwItemData;
      if (MenuItem->lpstr.Length)
      {
         NewMenuItem->lpstr.Length = 0;
         NewMenuItem->lpstr.MaximumLength = MenuItem->lpstr.MaximumLength;
         NewMenuItem->lpstr.Buffer = DesktopHeapAlloc(Destination->head.rpdesk, MenuItem->lpstr.MaximumLength);
         if (!NewMenuItem->lpstr.Buffer)
         {
             DesktopHeapFree(Destination->head.rpdesk, NewMenuItem);
             break;
         }
         RtlCopyUnicodeString(&NewMenuItem->lpstr, &MenuItem->lpstr);
         NewMenuItem->lpstr.Buffer[MenuItem->lpstr.Length / sizeof(WCHAR)] = 0;
         NewMenuItem->Xlpstr = NewMenuItem->lpstr.Buffer;
      }
      else
      {
         NewMenuItem->lpstr.Buffer = MenuItem->lpstr.Buffer;
         NewMenuItem->Xlpstr = NewMenuItem->lpstr.Buffer;
      }
      NewMenuItem->hbmp = MenuItem->hbmp;
      Destination->cItems = i + 1;
   }
   return TRUE;
}

Referenced by IntCloneMenu().

IntCreateMenu()

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

Definition at line 729 of file menu.c.

{
   PMENU Menu;
 
   Menu = (PMENU)UserCreateObject( gHandleTable,
                                          Desktop,
                                          ppi->ptiList,
                                          Handle,
                                          TYPE_MENU,
                                          sizeof(MENU));
   if(!Menu)
   {
      *Handle = 0;
      return NULL;
   }
 
   Menu->cyMax = 0; /* Default */
   Menu->hbrBack = NULL; /* No brush */
   Menu->dwContextHelpId = 0; /* Default */
   Menu->dwMenuData = 0; /* Default */
   Menu->iItem = NO_SELECTED_ITEM; // Focused item
   Menu->fFlags = (IsMenuBar ? 0 : MNF_POPUP);
   Menu->spwndNotify = NULL;
   Menu->cyMenu = 0; // Height
   Menu->cxMenu = 0; // Width
   Menu->cItems = 0; // Item count
   Menu->iTop = 0;
   Menu->iMaxTop = 0;
   Menu->cxTextAlign = 0;
   Menu->rgItems = NULL;
 
   Menu->hWnd = NULL;
   Menu->TimeToHide = FALSE;
 
   return Menu;
}

Referenced by IntSetMenuItemInfo(), and UserCreateMenu().

IntDestroyMenu()

BOOL IntDestroyMenu	(	PMENU	pMenu,
		BOOL	bRecurse
	)

Definition at line 269 of file menu.c.

{
    PMENU SubMenu;
 
    ASSERT(UserIsEnteredExclusive());
    if (pMenu->rgItems) /* recursively destroy submenus */
    {
       int i;
       ITEM *item = pMenu->rgItems;
       for (i = pMenu->cItems; i > 0; i--, item++)
       {
           SubMenu = item->spSubMenu;
           item->spSubMenu = NULL;
 
           /* Remove Item Text */
           FreeMenuText(pMenu,item);
 
           /* Remove Item Bitmap and set it for this process */
           if (item->hbmp && !(item->fState & MFS_HBMMENUBMP))
           {
              GreSetObjectOwner(item->hbmp, GDI_OBJ_HMGR_POWNED);
              item->hbmp = NULL;
           }
 
           /* Remove Item submenu */
           if (bRecurse && SubMenu)//VerifyMenu(SubMenu))
           {
              /* Release submenu since it was referenced when inserted */
              IntReleaseMenuObject(SubMenu);
              IntDestroyMenuObject(SubMenu, bRecurse);
           }
       }
       /* Free the Item */
       DesktopHeapFree(pMenu->head.rpdesk, pMenu->rgItems );
       pMenu->rgItems = NULL;
       pMenu->cItems = 0;
    }
    return TRUE;
}

Referenced by IntDestroyMenuObject().

IntDestroyMenuObject()

BOOL FASTCALL IntDestroyMenuObject	(	PMENU	Menu,
		BOOL	bRecurse
	)

Definition at line 317 of file menu.c.

{
   ASSERT(UserIsEnteredExclusive());
   if (Menu)
   {
      PWND Window;
 
      if (PsGetCurrentProcessSessionId() == Menu->head.rpdesk->rpwinstaParent->dwSessionId)
      {
         BOOL ret;
         if (Menu->hWnd)
         {
            Window = ValidateHwndNoErr(Menu->hWnd);
            if (Window)
            {
               //Window->IDMenu = 0; Only in Win9x!! wine win test_SetMenu test...
 
               /* DestroyMenu should not destroy system menu popup owner */
               if ((Menu->fFlags & (MNF_POPUP | MNF_SYSSUBMENU)) == MNF_POPUP)
               {
                  // Should we check it to see if it has Class?
                  ERR("FIXME Pop up menu window thing'ie\n");
                  //co_UserDestroyWindow( Window );
                  //Menu->hWnd = 0;
               }
            }
         }
 
         if (!UserMarkObjectDestroy(Menu)) return TRUE;
 
         /* Remove all menu items */
         IntDestroyMenu( Menu, bRecurse);
 
         ret = UserDeleteObject(UserHMGetHandle(Menu), TYPE_MENU);
         TRACE("IntDestroyMenuObject %d\n",ret);
         return ret;
      }
   }
   return FALSE;
}

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

{
  UINT i;
  HFONT FontOld = NULL;
  BOOL flat_menu = FALSE;
 
  UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
 
  if (!pMenu)
  {
      pMenu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu));
  }
 
  if (!Font)
  {
      Font = ghMenuFont;
  }
 
  if (Rect == NULL || !pMenu)
  {
      return UserGetSystemMetrics(SM_CYMENU);
  }
 
  TRACE("(%x, %x, %p, %x, %x)\n", pWnd, hDC, Rect, pMenu, Font);
 
  FontOld = NtGdiSelectFont(hDC, Font);
 
  if (pMenu->cyMenu == 0)
  {
      MENU_MenuBarCalcSize(hDC, Rect, pMenu, pWnd);
  }
 
  Rect->bottom = Rect->top + pMenu->cyMenu;
 
  FillRect(hDC, Rect, IntGetSysColorBrush(flat_menu ? COLOR_MENUBAR : COLOR_MENU));
 
  NtGdiSelectPen(hDC, NtGdiGetStockObject(DC_PEN));
  IntSetDCPenColor(hDC, IntGetSysColor(COLOR_3DFACE));
  GreMoveTo(hDC, Rect->left, Rect->bottom - 1, NULL);
  NtGdiLineTo(hDC, Rect->right, Rect->bottom - 1);
 
  if (pMenu->cItems == 0)
  {
      NtGdiSelectFont(hDC, FontOld);
      return UserGetSystemMetrics(SM_CYMENU);
  }
 
  for (i = 0; i < pMenu->cItems; i++)
  {
      MENU_DrawMenuItem(pWnd, pMenu, pWnd, hDC, &pMenu->rgItems[i], pMenu->cyMenu, TRUE, ODA_DRAWENTIRE);
  }
 
  NtGdiSelectFont(hDC, FontOld);
 
  return pMenu->cyMenu;
}

Referenced by MENU_DrawMenuBar(), and NtUserDrawMenuBarTemp().

IntEnableMenuItem()

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

Definition at line 1217 of file menu.c.

{
   PITEM MenuItem;
   UINT res;
 
   if (!(MenuItem = MENU_FindItem( &MenuObject, &uIDEnableItem, uEnable ))) return (UINT)-1;
 
   res = MenuItem->fState & (MF_GRAYED | MF_DISABLED);
 
   MenuItem->fState ^= (res ^ uEnable) & (MF_GRAYED | MF_DISABLED);
 
   /* If the close item in the system menu change update the close button */
   if (res != uEnable)
   {
      switch (MenuItem->wID) // More than just close.
      {
        case SC_CLOSE:
        case SC_MAXIMIZE:
        case SC_MINIMIZE:
        case SC_MOVE:
        case SC_RESTORE:
        case SC_SIZE:
    if (MenuObject->fFlags & MNF_SYSSUBMENU && MenuObject->spwndNotify != 0)
    {
            //RECTL rc = MenuObject->spwndNotify->rcWindow;
 
            /* Refresh the frame to reflect the change */
            //IntMapWindowPoints(0, MenuObject->spwndNotify, (POINT *)&rc, 2);
            //rc.bottom = 0;
            //co_UserRedrawWindow(MenuObject->spwndNotify, &rc, 0, RDW_FRAME | RDW_INVALIDATE | RDW_NOCHILDREN);
 
            // Allow UxTheme!
            UserPaintCaption(MenuObject->spwndNotify, DC_BUTTONS);
    }
    default:
           break;
      }
   }
   return res;
}

Referenced by MENU_InitSysMenuPopup(), and NtUserEnableMenuItem().

IntFindSubMenu()

UINT FASTCALL IntFindSubMenu	(	HMENU *	hMenu,
		HMENU	hSubTarget
	)

Definition at line 5031 of file menu.c.

{
    PMENU menu, pSubTarget;
    UINT Pos;
    if (((*hMenu)==(HMENU)0xffff) ||(!(menu = UserGetMenuObject(*hMenu))))
        return NO_SELECTED_ITEM;
 
    pSubTarget = UserGetMenuObject(hSubTarget);
 
    Pos = MENU_FindSubMenu(&menu, pSubTarget );
 
    *hMenu = (menu ? UserHMGetHandle(menu) : NULL);
 
    return Pos;
}

Referenced by co_IntTranslateAccelerator().

IntGetDialogBaseUnits()

LONG IntGetDialogBaseUnits

(

VOID

)

Definition at line 1800 of file menu.c.

{
    static DWORD units;
 
    if (!units)
    {
        HDC hdc;
        SIZE size;
 
        if ((hdc = UserGetDCEx(NULL, NULL, DCX_CACHE)))
        {
            size.cx = IntGetCharDimensions( hdc, NULL, (PDWORD)&size.cy );
            if (size.cx) units = MAKELONG( size.cx, size.cy );
            UserReleaseDC( 0, hdc, FALSE);
        }
    }
    return units;
}

Referenced by MENU_CalcItemSize().

IntGetMenu()

PMENU WINAPI IntGetMenu

(

HWND

hWnd

)

Definition at line 248 of file menu.c.

{
       PWND Wnd = ValidateHwndNoErr(hWnd);
 
       if (!Wnd)
               return NULL;
 
       return UserGetMenuObject(UlongToHandle(Wnd->IDMenu));
}

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

IntGetMenuDefaultItem()

UINT FASTCALL IntGetMenuDefaultItem	(	PMENU	MenuObject,
		UINT	fByPos,
		UINT	gmdiFlags,
		DWORD *	gismc
	)

Definition at line 1315 of file menu.c.

{
   UINT i = 0;
   PITEM MenuItem = MenuObject->rgItems;
 
   /* empty menu */
   if (!MenuItem) return -1;
 
   while ( !( MenuItem->fState & MFS_DEFAULT ) )
   {
      i++; MenuItem++;
      if  (i >= MenuObject->cItems ) return -1;
   }
 
   /* default: don't return disabled items */
   if ( (!(GMDI_USEDISABLED & gmdiFlags)) && (MenuItem->fState & MFS_DISABLED )) return -1;
 
   /* search rekursiv when needed */
   if ( (gmdiFlags & GMDI_GOINTOPOPUPS) && MenuItem->spSubMenu )
   {
      UINT ret;
      (*gismc)++;
      ret = IntGetMenuDefaultItem( MenuItem->spSubMenu, fByPos, gmdiFlags, gismc );
      (*gismc)--;
      if ( -1 != ret ) return ret;
 
      /* when item not found in submenu, return the popup item */
   }
   return ( fByPos ) ? i : MenuItem->wID;
}

Referenced by GetMenuDefaultItem(), and IntGetMenuDefaultItem().

IntGetMenuInfo()

BOOL FASTCALL IntGetMenuInfo	(	PMENU	Menu,
		PROSMENUINFO	lpmi
	)

Definition at line 879 of file menu.c.

{
   if(lpmi->fMask & MIM_BACKGROUND)
      lpmi->hbrBack = Menu->hbrBack;
   if(lpmi->fMask & MIM_HELPID)
      lpmi->dwContextHelpID = Menu->dwContextHelpId;
   if(lpmi->fMask & MIM_MAXHEIGHT)
      lpmi->cyMax = Menu->cyMax;
   if(lpmi->fMask & MIM_MENUDATA)
      lpmi->dwMenuData = Menu->dwMenuData;
   if(lpmi->fMask & MIM_STYLE)
      lpmi->dwStyle = Menu->fFlags & MNS_STYLE_MASK;
 
   if (sizeof(MENUINFO) < lpmi->cbSize)
   {
     lpmi->cItems = Menu->cItems;
 
     lpmi->iItem = Menu->iItem;
     lpmi->cxMenu = Menu->cxMenu;
     lpmi->cyMenu = Menu->cyMenu;
     lpmi->spwndNotify = Menu->spwndNotify;
     lpmi->cxTextAlign = Menu->cxTextAlign;
     lpmi->iTop = Menu->iTop;
     lpmi->iMaxTop = Menu->iMaxTop;
     lpmi->dwArrowsOn = Menu->dwArrowsOn;
 
     lpmi->fFlags = Menu->fFlags;
     lpmi->Self = UserHMGetHandle(Menu);
     lpmi->TimeToHide = Menu->TimeToHide;
     lpmi->Wnd = Menu->hWnd;
   }
   return TRUE;
}

Referenced by UserMenuInfo().

IntGetMenuItemInfo()

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

Definition at line 962 of file menu.c.

{
   NTSTATUS Status;
 
   if(lpmii->fMask & (MIIM_FTYPE | MIIM_TYPE))
   {
      lpmii->fType = MenuItem->fType;
   }
   if(lpmii->fMask & MIIM_BITMAP)
   {
      lpmii->hbmpItem = MenuItem->hbmp;
   }
   if(lpmii->fMask & MIIM_CHECKMARKS)
   {
      lpmii->hbmpChecked = MenuItem->hbmpChecked;
      lpmii->hbmpUnchecked = MenuItem->hbmpUnchecked;
   }
   if(lpmii->fMask & MIIM_DATA)
   {
      lpmii->dwItemData = MenuItem->dwItemData;
   }
   if(lpmii->fMask & MIIM_ID)
   {
      lpmii->wID = MenuItem->wID;
   }
   if(lpmii->fMask & MIIM_STATE)
   {
      lpmii->fState = MenuItem->fState;
   }
   if(lpmii->fMask & MIIM_SUBMENU)
   {
      lpmii->hSubMenu = (MenuItem->spSubMenu ? UserHMGetHandle(MenuItem->spSubMenu) : NULL);
   }
 
   if ((lpmii->fMask & MIIM_STRING) ||
      ((lpmii->fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(lpmii->fType) == MF_STRING)))
   {
      if (lpmii->dwTypeData == NULL)
      {
         lpmii->cch = MenuItem->lpstr.Length / sizeof(WCHAR);
      }
      else
      {  
         Status = MmCopyToCaller(lpmii->dwTypeData, MenuItem->lpstr.Buffer,
                                 min(lpmii->cch * sizeof(WCHAR),
                                     MenuItem->lpstr.MaximumLength));
         if (! NT_SUCCESS(Status))
         {
            SetLastNtError(Status);
            return FALSE;
         }
      }
   }
 
   if (sizeof(ROSMENUITEMINFO) == lpmii->cbSize)
   {
      lpmii->Rect.left   = MenuItem->xItem;
      lpmii->Rect.top    = MenuItem->yItem;
      lpmii->Rect.right  = MenuItem->cxItem; // Do this for now......
      lpmii->Rect.bottom = MenuItem->cyItem;
      lpmii->dxTab = MenuItem->dxTab;
      lpmii->lpstr = MenuItem->lpstr.Buffer;
      lpmii->maxBmpSize.cx = MenuItem->cxBmp;
      lpmii->maxBmpSize.cy = MenuItem->cyBmp;
   }
 
   return TRUE;
}

Referenced by IntMenuItemInfo(), and UserMenuItemInfo().

IntGetMenuItemRect()

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

Definition at line 5246 of file menu.c.

{
   LONG XMove, YMove;
   PITEM MenuItem;
   UINT I = uItem;
 
   if ((MenuItem = MENU_FindItem (&Menu, &I, MF_BYPOSITION)))
   {
      Rect->left   = MenuItem->xItem;
      Rect->top    = MenuItem->yItem;
      Rect->right  = MenuItem->cxItem; // Do this for now......
      Rect->bottom = MenuItem->cyItem;
   }
   else
   {
      ERR("Failed Item Lookup! %u\n", uItem);
      return FALSE;
   }
 
   if (!pWnd)
   {
      HWND hWnd = Menu->hWnd;
      if (!(pWnd = UserGetWindowObject(hWnd))) return FALSE;
   }
 
   if (Menu->fFlags & MNF_POPUP)
   {
     XMove = pWnd->rcClient.left;
     YMove = pWnd->rcClient.top;
   }
   else
   {
     XMove = pWnd->rcWindow.left;
     YMove = pWnd->rcWindow.top;
   }
 
   Rect->left   += XMove;
   Rect->top    += YMove;
   Rect->right  += XMove;
   Rect->bottom += YMove;
 
   return TRUE;
}

Referenced by NtUserGetMenuBarInfo().

IntGetMenuObject()

PMENU FASTCALL IntGetMenuObject

(

HMENU

hMenu

)

Definition at line 192 of file menu.c.

{
   PMENU Menu = UserGetMenuObject(hMenu);
   if (Menu)
      Menu->head.cLockObj++;
 
   return Menu;
}

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

IntGetMenuState()

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

Definition at line 4991 of file menu.c.

{
   PMENU MenuObject;
   PITEM pItem;
 
   if (!(MenuObject = UserGetMenuObject(hMenu)))
   {
      return (UINT)-1;
   }
 
   if (!(pItem = MENU_FindItem( &MenuObject, &uId, uFlags ))) return -1;
 
   if (pItem->spSubMenu)
   {
      return (pItem->spSubMenu->cItems << 8) | ((pItem->fState|pItem->fType|MF_POPUP) & 0xff);
   }
   else
      return (pItem->fType | pItem->fState);
}

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

IntGetSubMenu()

HMENU FASTCALL IntGetSubMenu	(	HMENU	hMenu,
		int	nPos
	)

Definition at line 5011 of file menu.c.

{
   PMENU MenuObject;
   PITEM pItem;
 
   if (!(MenuObject = UserGetMenuObject(hMenu)))
   {
      return NULL;
   }
 
   if (!(pItem = MENU_FindItem( &MenuObject, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;
 
   if (pItem->spSubMenu)
   {
      HMENU hsubmenu = UserHMGetHandle(pItem->spSubMenu);
      return hsubmenu;
   }
   return NULL;
}

Referenced by IntGetSystemMenu().

IntGetSystemMenu()

PMENU FASTCALL IntGetSystemMenu	(	PWND	Window,
		BOOL	bRevert
	)

Definition at line 5399 of file menu.c.

{
   PMENU Menu;
 
   if (bRevert)
   {
      if (Window->SystemMenu)
      {
         Menu = UserGetMenuObject(Window->SystemMenu);
         if (Menu && !(Menu->fFlags & MNF_SYSDESKMN))
         {
            IntDestroyMenuObject(Menu, TRUE);
            Window->SystemMenu = NULL;
         }
      }
   }
   else
   {
      Menu = Window->SystemMenu ? UserGetMenuObject(Window->SystemMenu) : NULL;
      if ((!Menu || Menu->fFlags & MNF_SYSDESKMN) && Window->style & WS_SYSMENU)
      {
         Menu = MENU_GetSystemMenu(Window, NULL);
         Window->SystemMenu = Menu ? UserHMGetHandle(Menu) : NULL;
      }
   }
 
   if (Window->SystemMenu)
   {
      HMENU hMenu = IntGetSubMenu( Window->SystemMenu, 0);
      /* Store the dummy sysmenu handle to facilitate the refresh */
      /* of the close button if the SC_CLOSE item change */
      Menu = UserGetMenuObject(hMenu);
      if (Menu)
      {
         Menu->spwndNotify = Window;
         Menu->fFlags |= MNF_SYSSUBMENU;
      }
      return Menu;
   }
   return NULL;
}

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

{
 
    DWORD dwStyle = 0;
    DWORD dwExStyle = 0;
    BOOLEAN retValue = TRUE;
 
    if (bti->cbSize == sizeof(TITLEBARINFO))
    {
        RtlZeroMemory(&bti->rgstate[0],sizeof(DWORD)*(CCHILDREN_TITLEBAR+1));
 
        bti->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
 
        dwStyle = pWindowObject->style;
        dwExStyle = pWindowObject->ExStyle;
 
        bti->rcTitleBar.top  = 0;
        bti->rcTitleBar.left = 0;
        bti->rcTitleBar.right  = pWindowObject->rcWindow.right - pWindowObject->rcWindow.left;
        bti->rcTitleBar.bottom = pWindowObject->rcWindow.bottom - pWindowObject->rcWindow.top;
 
        /* Is it iconiced ? */
        if ((dwStyle & WS_ICONIC)!=WS_ICONIC)
        {
            /* Remove frame from rectangle */
            if (HAS_THICKFRAME( dwStyle, dwExStyle ))
            {
                /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXFRAME) and UserGetSystemMetrics(SM_CYFRAME) */
                RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME) );
            }
            else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
            {
                /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXDLGFRAME) and UserGetSystemMetrics(SM_CYDLGFRAME) */
                RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
            }
            else if (HAS_THINFRAME( dwStyle, dwExStyle))
            {
                /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
                RECTL_vInflateRect( &bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER) );
            }
 
            /* We have additional border information if the window
             * is a child (but not an MDI child) */
            if ( (dwStyle & WS_CHILD)  &&
                 ((dwExStyle & WS_EX_MDICHILD) == 0 ) )
            {
                if (dwExStyle & WS_EX_CLIENTEDGE)
                {
                    /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXEDGE) and UserGetSystemMetrics(SM_CYEDGE) */
                    RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
                }
 
                if (dwExStyle & WS_EX_STATICEDGE)
                {
                    /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CXBORDER) and UserGetSystemMetrics(SM_CYBORDER) */
                    RECTL_vInflateRect (&bti->rcTitleBar, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
                }
            }
        }
 
        bti->rcTitleBar.top += pWindowObject->rcWindow.top;
        bti->rcTitleBar.left += pWindowObject->rcWindow.left;
        bti->rcTitleBar.right += pWindowObject->rcWindow.left;
 
        bti->rcTitleBar.bottom = bti->rcTitleBar.top;
        if (dwExStyle & WS_EX_TOOLWINDOW)
        {
            /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYSMCAPTION) */
            bti->rcTitleBar.bottom += UserGetSystemMetrics(SM_CYSMCAPTION);
        }
        else
        {
            /* FIXME: Note this value should exists in pWindowObject for UserGetSystemMetrics(SM_CYCAPTION) and UserGetSystemMetrics(SM_CXSIZE) */
            bti->rcTitleBar.bottom += UserGetSystemMetrics(SM_CYCAPTION);
            bti->rcTitleBar.left += UserGetSystemMetrics(SM_CXSIZE);
        }
 
        if (dwStyle & WS_CAPTION)
        {
            bti->rgstate[1] = STATE_SYSTEM_INVISIBLE;
            if (dwStyle & WS_SYSMENU)
            {
                if (!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX)))
                {
                    bti->rgstate[2] = STATE_SYSTEM_INVISIBLE;
                    bti->rgstate[3] = STATE_SYSTEM_INVISIBLE;
                }
                else
                {
                    if (!(dwStyle & WS_MINIMIZEBOX))
                    {
                        bti->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
                    }
                    if (!(dwStyle & WS_MAXIMIZEBOX))
                    {
                        bti->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
                    }
                }
 
                if (!(dwExStyle & WS_EX_CONTEXTHELP))
                {
                    bti->rgstate[4] = STATE_SYSTEM_INVISIBLE;
                }
                if (pWindowObject->pcls->style & CS_NOCLOSE)
                {
                    bti->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
                }
            }
            else
            {
                bti->rgstate[2] = STATE_SYSTEM_INVISIBLE;
                bti->rgstate[3] = STATE_SYSTEM_INVISIBLE;
                bti->rgstate[4] = STATE_SYSTEM_INVISIBLE;
                bti->rgstate[5] = STATE_SYSTEM_INVISIBLE;
            }
        }
        else
        {
            bti->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
        }
    }
    else
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        retValue = FALSE;
    }
 
    return retValue;
}

Referenced by NtUserGetTitleBarInfo().

IntHiliteMenuItem()

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

Definition at line 4794 of file menu.c.

{
   PITEM MenuItem;
   UINT uItem = uItemHilite;
 
   if (!(MenuItem = MENU_FindItem( &MenuObject, &uItem, uHilite ))) return TRUE;
 
   if (uHilite & MF_HILITE)
   {
      MenuItem->fState |= MF_HILITE;
   }
   else
   {
      MenuItem->fState &= ~MF_HILITE;
   }
   if (MenuObject->iItem == uItemHilite) return TRUE;
   MENU_HideSubPopups( WindowObject, MenuObject, FALSE, 0 );
   MENU_SelectItem( WindowObject, MenuObject, uItemHilite, TRUE, 0 );
 
   return TRUE; // Always returns true!!!!
}

Referenced by NtUserHiliteMenuItem().

IntInsertMenuItem()

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

Definition at line 691 of file menu.c.

{
   PITEM MenuItem;
   PMENU SubMenu = NULL;
 
   NT_ASSERT(MenuObject != NULL);
 
   if (MAX_MENU_ITEMS <= MenuObject->cItems)
   {
      EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
   }
 
   SubMenu = MenuObject;
 
   if(!(MenuItem = MENU_InsertItem( SubMenu, uItem, fByPosition ? MF_BYPOSITION : MF_BYCOMMAND, &SubMenu, &uItem ))) return FALSE;
 
   if(!IntSetMenuItemInfo(SubMenu, MenuItem, ItemInfo, lpstr))
   {
      IntRemoveMenuItem(SubMenu, uItem, fByPosition ? MF_BYPOSITION : MF_BYCOMMAND, FALSE);
      return FALSE;
   }
 
   /* Force size recalculation! */
   SubMenu->cyMenu = 0;
   MenuItem->hbmpChecked = MenuItem->hbmpUnchecked = 0;
 
   TRACE("IntInsertMenuItemToList = %u %i\n", uItem, (BOOL)((INT)uItem >= 0));
 
   return TRUE;
}

Referenced by MENU_GetSystemMenu(), and UserInsertMenuItem().

IntIsMenu()

BOOL FASTCALL IntIsMenu

(

HMENU

Menu

)

Definition at line 240 of file menu.c.

{
  if (UserGetMenuObject(Menu)) return TRUE;
  return FALSE;
}

IntMenuItemFromPoint()

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

Definition at line 1518 of file menu.c.

{
    MENU *menu = UserGetMenuObject(hMenu);
    UINT pos;
 
    /*FIXME: Do we have to handle hWnd here? */
    if (!menu) return -1;
    if (!MENU_FindItemByCoords(menu, ptScreen, &pos)) return -1;
    return pos;
}

Referenced by IntDefWindowProc().

IntMenuItemInfo()

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

Definition at line 5092 of file menu.c.

{
   PITEM MenuItem;
   BOOL Ret;
 
   if (!(MenuItem = MENU_FindItem( &Menu, &Item, (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND) )))
   {
      EngSetLastError(ERROR_MENU_ITEM_NOT_FOUND);
      return FALSE;
   }
   if (SetOrGet)
   {
      Ret = IntSetMenuItemInfo(Menu, MenuItem, ItemInfo, lpstr);
   }
   else
   {
      Ret = IntGetMenuItemInfo(Menu, MenuItem, ItemInfo);
   }
   return Ret;
}

Referenced by MENU_GetSystemMenu().

IntRemoveMenuItem()

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

Definition at line 596 of file menu.c.

{
    PITEM item;
    PITEM newItems;
 
    TRACE("(menu=%p pos=%04x flags=%04x)\n",pMenu, nPos, wFlags);
    if (!(item = MENU_FindItem( &pMenu, &nPos, wFlags ))) return FALSE;
 
    /* Remove item */
 
    FreeMenuText(pMenu,item);
    if (bRecurse && item->spSubMenu)
    {
       IntDestroyMenuObject(item->spSubMenu, bRecurse);
    }
    if (--pMenu->cItems == 0)
    {
        DesktopHeapFree(pMenu->head.rpdesk, pMenu->rgItems );
        pMenu->rgItems = NULL;
    }
    else
    {
        while (nPos < pMenu->cItems)
        {
            *item = *(item+1);
            item++;
            nPos++;
        }
        newItems = DesktopHeapReAlloc(pMenu->head.rpdesk, pMenu->rgItems, pMenu->cItems * sizeof(ITEM));
        if (newItems)
        {
            pMenu->rgItems = newItems;
        }
    }
    return TRUE;
}

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

IntSetMenu()

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

Definition at line 5475 of file menu.c.

{
   PMENU OldMenu, NewMenu = NULL;
 
   if ((Wnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
   {
      ERR("SetMenu: Window is a Child 0x%p!\n",UserHMGetHandle(Wnd));
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      return FALSE;
   }
 
   *Changed = (UlongToHandle(Wnd->IDMenu) != Menu);
   if (! *Changed)
   {
      return TRUE;
   }
 
   if (Wnd->IDMenu)
   {
      OldMenu = IntGetMenuObject(UlongToHandle(Wnd->IDMenu));
      ASSERT(NULL == OldMenu || OldMenu->hWnd == UserHMGetHandle(Wnd));
   }
   else
   {
      OldMenu = NULL;
   }
 
   if (NULL != Menu)
   {
      NewMenu = IntGetMenuObject(Menu);
      if (NULL == NewMenu)
      {
         if (NULL != OldMenu)
         {
            IntReleaseMenuObject(OldMenu);
         }
         EngSetLastError(ERROR_INVALID_MENU_HANDLE);
         return FALSE;
      }
      if (NULL != NewMenu->hWnd)
      {
         /* Can't use the same menu for two windows */
         if (NULL != OldMenu)
         {
            IntReleaseMenuObject(OldMenu);
         }
         EngSetLastError(ERROR_INVALID_MENU_HANDLE);
         return FALSE;
      }
 
   }
 
   Wnd->IDMenu = (UINT_PTR) Menu;
   if (NULL != NewMenu)
   {
      NewMenu->hWnd = UserHMGetHandle(Wnd);
      IntReleaseMenuObject(NewMenu);
   }
   if (NULL != OldMenu)
   {
      OldMenu->hWnd = NULL;
      IntReleaseMenuObject(OldMenu);
   }
 
   return TRUE;
}

Referenced by IntCreateWindow(), and NtUserSetMenu().

IntSetMenuContextHelpId()

BOOL FASTCALL IntSetMenuContextHelpId	(	PMENU	Menu,
		DWORD	dwContextHelpId
	)

Definition at line 872 of file menu.c.

{
   Menu->dwContextHelpId = dwContextHelpId;
   return TRUE;
}

Referenced by NtUserSetMenuContextHelpId().

IntSetMenuFlagRtoL()

BOOL FASTCALL IntSetMenuFlagRtoL

(

PMENU

Menu

)

Definition at line 864 of file menu.c.

{
   ERR("SetMenuFlagRtoL\n");
   Menu->fFlags |= MNF_RTOL;
   return TRUE;
}

Referenced by NtUserSetMenuFlagRtoL().

IntSetMenuInfo()

BOOL FASTCALL IntSetMenuInfo	(	PMENU	Menu,
		PROSMENUINFO	lpmi
	)

Definition at line 914 of file menu.c.

{
   if(lpmi->fMask & MIM_BACKGROUND)
      Menu->hbrBack = lpmi->hbrBack;
   if(lpmi->fMask & MIM_HELPID)
      Menu->dwContextHelpId = lpmi->dwContextHelpID;
   if(lpmi->fMask & MIM_MAXHEIGHT)
      Menu->cyMax = lpmi->cyMax;
   if(lpmi->fMask & MIM_MENUDATA)
      Menu->dwMenuData = lpmi->dwMenuData;
   if(lpmi->fMask & MIM_STYLE)
      Menu->fFlags ^= (Menu->fFlags ^ lpmi->dwStyle) & MNS_STYLE_MASK;
   if(lpmi->fMask & MIM_APPLYTOSUBMENUS)
   {
      int i;
      PITEM item = Menu->rgItems;
      for ( i = Menu->cItems; i; i--, item++)
      {
         if ( item->spSubMenu )
         {
            IntSetMenuInfo( item->spSubMenu, lpmi);
         }
      }
   }
   if (sizeof(MENUINFO) < lpmi->cbSize)
   {
      Menu->iItem = lpmi->iItem;
      Menu->cyMenu = lpmi->cyMenu;
      Menu->cxMenu = lpmi->cxMenu;
      Menu->spwndNotify = lpmi->spwndNotify;
      Menu->cxTextAlign = lpmi->cxTextAlign;
      Menu->iTop = lpmi->iTop;
      Menu->iMaxTop = lpmi->iMaxTop;
      Menu->dwArrowsOn = lpmi->dwArrowsOn;
 
      Menu->TimeToHide = lpmi->TimeToHide;
      Menu->hWnd = lpmi->Wnd;
   }
   if ( lpmi->fMask & MIM_STYLE)
   {
      if (lpmi->dwStyle & MNS_AUTODISMISS) FIXME("MNS_AUTODISMISS unimplemented wine\n");
      if (lpmi->dwStyle & MNS_DRAGDROP)    FIXME("MNS_DRAGDROP unimplemented wine\n");
      if (lpmi->dwStyle & MNS_MODELESS)    FIXME("MNS_MODELESS unimplemented wine\n");
   }
   return TRUE;
}

Referenced by IntSetMenuInfo(), and UserMenuInfo().

IntSetMenuItemInfo()

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

Definition at line 1033 of file menu.c.

{
   PMENU SubMenuObject;
   BOOL circref = FALSE;
 
   if(!MenuItem || !MenuObject || !lpmii)
   {
      return FALSE;
   }
   if ( lpmii->fMask & MIIM_FTYPE )
   {
      MenuItem->fType &= ~MENUITEMINFO_TYPE_MASK;
      MenuItem->fType |= lpmii->fType & MENUITEMINFO_TYPE_MASK;
   }
   if (lpmii->fMask & MIIM_TYPE)
   {
      #if 0 
      if (lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP))
      {
         ERR("IntSetMenuItemInfo: Invalid combination of fMask bits used\n");
         KeRosDumpStackFrames(NULL, 20);
         /* This does not happen on Win9x/ME */
         SetLastNtError( ERROR_INVALID_PARAMETER);
         return FALSE;
      }
      #endif
      /*
       * Delete the menu item type when changing type from
       * MF_STRING.
       */
      if (MenuItem->fType != lpmii->fType &&
            MENU_ITEM_TYPE(MenuItem->fType) == MFT_STRING)
      {
         FreeMenuText(MenuObject,MenuItem);
         RtlInitUnicodeString(&MenuItem->lpstr, NULL);
         MenuItem->Xlpstr = NULL;
      }
      if(lpmii->fType & MFT_BITMAP)
      {
         if(lpmii->hbmpItem)
           MenuItem->hbmp = lpmii->hbmpItem;
         else
         { /* Win 9x/Me stuff */
           MenuItem->hbmp = (HBITMAP)((ULONG_PTR)(LOWORD(lpmii->dwTypeData)));
         }
         lpmii->dwTypeData = 0;
      }
   }
   if(lpmii->fMask & MIIM_BITMAP)
   {
      MenuItem->hbmp = lpmii->hbmpItem;
      if (MenuItem->hbmp <= HBMMENU_POPUP_MINIMIZE && MenuItem->hbmp >= HBMMENU_CALLBACK)
         MenuItem->fState |= MFS_HBMMENUBMP;
      else
         MenuItem->fState &= ~MFS_HBMMENUBMP;
   }
   if(lpmii->fMask & MIIM_CHECKMARKS)
   {
      MenuItem->hbmpChecked = lpmii->hbmpChecked;
      MenuItem->hbmpUnchecked = lpmii->hbmpUnchecked;
   }
   if(lpmii->fMask & MIIM_DATA)
   {
      MenuItem->dwItemData = lpmii->dwItemData;
   }
   if(lpmii->fMask & MIIM_ID)
   {
      MenuItem->wID = lpmii->wID;
   }
   if(lpmii->fMask & MIIM_STATE)
   {
      /* Remove MFS_DEFAULT flag from all other menu items if this item
         has the MFS_DEFAULT state */
      if(lpmii->fState & MFS_DEFAULT)
         UserSetMenuDefaultItem(MenuObject, -1, 0);
      /* Update the menu item state flags */
      UpdateMenuItemState(MenuItem->fState, lpmii->fState);
   }
 
   if(lpmii->fMask & MIIM_SUBMENU)
   {
      if (lpmii->hSubMenu)
      {
         SubMenuObject = UserGetMenuObject(lpmii->hSubMenu);
         if ( SubMenuObject && !(UserObjectInDestroy(lpmii->hSubMenu)) )
         {
            if (MenuObject == SubMenuObject)
            {
               HANDLE hMenu;
               ERR("Pop Up Menu Double Trouble!\n");
               SubMenuObject = IntCreateMenu(&hMenu,
                   FALSE,
                   MenuObject->head.rpdesk,
                   (PPROCESSINFO)MenuObject->head.hTaskWow); // It will be marked.
               if (!SubMenuObject) return FALSE;
               IntReleaseMenuObject(SubMenuObject); // This will be referenced again after insertion.
               circref = TRUE;
            }
            if ( MENU_depth( SubMenuObject, 0) > MAXMENUDEPTH )
            {
               ERR( "Loop detected in menu hierarchy or maximum menu depth exceeded!\n");
               if (circref) IntDestroyMenuObject(SubMenuObject, FALSE);
               return FALSE;
            }
            /* Make sure the submenu is marked as a popup menu */
            SubMenuObject->fFlags |= MNF_POPUP;
            // Now fix the test_subpopup_locked_by_menu tests....
            if (MenuItem->spSubMenu) IntReleaseMenuObject(MenuItem->spSubMenu);
            MenuItem->spSubMenu = SubMenuObject;
            UserReferenceObject(SubMenuObject);
         }
         else
         {
            EngSetLastError( ERROR_INVALID_PARAMETER);
            return FALSE;
         }
      }
      else
      {  // If submenu just dereference it.
         if (MenuItem->spSubMenu) IntReleaseMenuObject(MenuItem->spSubMenu);
         MenuItem->spSubMenu = NULL;
      }
   }
 
   if ((lpmii->fMask & MIIM_STRING) ||
      ((lpmii->fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(lpmii->fType) == MF_STRING)))
   {
      /* free the string when used */
      FreeMenuText(MenuObject,MenuItem);
      RtlInitUnicodeString(&MenuItem->lpstr, NULL);
      MenuItem->Xlpstr = NULL;
 
      if(lpmii->dwTypeData && lpmii->cch && lpstr && lpstr->Buffer)
      {
         UNICODE_STRING Source;
 
         if (!NT_VERIFY(lpmii->cch <= UNICODE_STRING_MAX_CHARS))
         {
             return FALSE;
         }
 
         Source.Length = Source.MaximumLength = (USHORT)(lpmii->cch * sizeof(WCHAR));
         Source.Buffer = lpmii->dwTypeData;
 
         MenuItem->lpstr.Buffer = DesktopHeapAlloc( MenuObject->head.rpdesk, Source.Length + sizeof(WCHAR));
         if(MenuItem->lpstr.Buffer != NULL)
         {
            MenuItem->lpstr.Length = 0;
            MenuItem->lpstr.MaximumLength = Source.Length + sizeof(WCHAR);
            RtlCopyUnicodeString(&MenuItem->lpstr, &Source);
            MenuItem->lpstr.Buffer[MenuItem->lpstr.Length / sizeof(WCHAR)] = 0;
 
            MenuItem->cch = MenuItem->lpstr.Length / sizeof(WCHAR);
            MenuItem->Xlpstr = (USHORT*)MenuItem->lpstr.Buffer;
         }
      }
   }
 
   if( !(MenuObject->fFlags & MNF_SYSMENU) &&
       !MenuItem->Xlpstr &&
       !lpmii->dwTypeData &&
       !(MenuItem->fType & MFT_OWNERDRAW) &&
       !MenuItem->hbmp)
      MenuItem->fType |= MFT_SEPARATOR;
 
   if (sizeof(ROSMENUITEMINFO) == lpmii->cbSize)
   {
      MenuItem->xItem  = lpmii->Rect.left;
      MenuItem->yItem  = lpmii->Rect.top;
      MenuItem->cxItem = lpmii->Rect.right; // Do this for now......
      MenuItem->cyItem = lpmii->Rect.bottom;
      MenuItem->dxTab = lpmii->dxTab;
      lpmii->lpstr = MenuItem->lpstr.Buffer; /* Send back new allocated string or zero */
      MenuItem->cxBmp = lpmii->maxBmpSize.cx;
      MenuItem->cyBmp = lpmii->maxBmpSize.cy;
   }
 
   return TRUE;
}

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

IntSetSystemMenu()

BOOL FASTCALL IntSetSystemMenu	(	PWND	Window,
		PMENU	Menu
	)

Definition at line 5442 of file menu.c.

{
   PMENU OldMenu;
 
   if (!(Window->style & WS_SYSMENU)) return FALSE;
 
   if (Window->SystemMenu)
   {
      OldMenu = UserGetMenuObject(Window->SystemMenu);
      if (OldMenu)
      {
          OldMenu->fFlags &= ~MNF_SYSMENU;
          IntDestroyMenuObject(OldMenu, TRUE);
      }
   }
 
   OldMenu = MENU_GetSystemMenu(Window, Menu);
   if (OldMenu)
   {  // Use spmenuSys too!
      Window->SystemMenu = UserHMGetHandle(OldMenu);
   }
   else
      Window->SystemMenu = NULL;
 
   if (Menu && Window != Menu->spwndNotify)
   {
      Menu->spwndNotify = Window;
   }
 
   return TRUE;
}

Referenced by NtUserSetSystemMenu().

IntTrackPopupMenuEx()

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

Definition at line 4577 of file menu.c.

{
    BOOL ret = FALSE;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    if (pti != pWnd->head.pti)
    {
       ERR("Must be the same pti!\n");
       return ret;
    }
 
    TRACE("hmenu %p flags %04x (%d,%d) hwnd %p lpTpm %p \n", //rect %s\n",
            UserHMGetHandle(menu), wFlags, x, y, UserHMGetHandle(pWnd), lpTpm); //,
            //lpTpm ? wine_dbgstr_rect( &lpTpm->rcExclude) : "-" );
 
    if (menu->hWnd && IntIsWindow(menu->hWnd))
    {
        EngSetLastError( ERROR_POPUP_ALREADY_ACTIVE );
        return FALSE;
    }
 
    if (MENU_InitPopup( pWnd, menu, wFlags ))
    {
       MENU_InitTracking(pWnd, menu, TRUE, wFlags);
 
       /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
       if (!(wFlags & TPM_NONOTIFY))
       {
          co_IntSendMessage( UserHMGetHandle(pWnd), WM_INITMENUPOPUP, (WPARAM) UserHMGetHandle(menu), MAKELPARAM(0, IS_SYSTEM_MENU(menu)));
       }
 
       if (menu->fFlags & MNF_SYSMENU)
          MENU_InitSysMenuPopup( menu, pWnd->style, pWnd->pcls->style, HTSYSMENU);
 
       if (MENU_ShowPopup(pWnd, menu, 0, wFlags | TPM_POPUPMENU, x, y, lpTpm ? &lpTpm->rcExclude : NULL))
          ret = MENU_TrackMenu( menu, wFlags | TPM_POPUPMENU, 0, 0, pWnd);
       else
       {
          MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
          pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
          co_UserSetCapture(NULL); /* release the capture */
       }
 
       MENU_ExitTracking(pWnd, TRUE, wFlags);
 
       if (menu->hWnd)
       {
          PWND pwndM = ValidateHwndNoErr( menu->hWnd );
          if (pwndM) // wine hack around this with their destroy function.
          {
             if (!(pWnd->state & WNDS_DESTROYED))
                co_UserDestroyWindow( pwndM ); // Fix wrong error return.
          }
          menu->hWnd = 0;
 
          if (!(wFlags & TPM_NONOTIFY))
          {
             co_IntSendMessage( UserHMGetHandle(pWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(menu),
                                            MAKELPARAM(0, IS_SYSTEM_MENU(menu) ? MF_SYSMENU : 0));
          }
       }
    }
    return ret;
}

Referenced by IntDefWindowProc(), and NtUserTrackPopupMenuEx().

MENU_AdjustMenuItemRect()

VOID FASTCALL MENU_AdjustMenuItemRect	(	PMENU	menu,
		PRECTL	rect
	)

Definition at line 1462 of file menu.c.

{
    if (menu->dwArrowsOn)
    {
        UINT arrow_bitmap_height;
        arrow_bitmap_height = gpsi->oembmi[OBI_UPARROW].cy; 
        rect->top += arrow_bitmap_height - menu->iTop;
        rect->bottom += arrow_bitmap_height - menu->iTop;
    }
}

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

{
  TRACE("%x PtMenu=%p\n", pmt, PtMenu);
 
  if (PtMenu)
  {
      UINT id = 0;
      PITEM item;
      
      // Special check for the icon system menu
      if (IS_SYSTEM_MENU(PtMenu) && !(PtMenu->fFlags & MNF_POPUP))
      {
         item = PtMenu->rgItems;
      }
      else
      {
         item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &id );
      }
 
      if (item)
      {
          if (PtMenu->iItem != id)
              MENU_SwitchTracking(pmt, PtMenu, id, Flags);
 
          /* If the popup menu is not already "popped" */
          if (!(item->fState & MF_MOUSESELECT))
          {
              pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, PtMenu, FALSE, Flags);
          }
 
          return TRUE;
      }
      /* Else the click was on the menu bar, finish the tracking */
  }
  return FALSE;
}

Referenced by MENU_TrackMenu().

MENU_ButtonUp()

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

static

Definition at line 3603 of file menu.c.

{
  TRACE("%p pmenu=%x\n", pmt, PtMenu);
 
  if (PtMenu)
  {
      UINT Id = 0;
      ITEM *item;
      
      // Special check for the icon system menu
      if (IS_SYSTEM_MENU(PtMenu) && !(PtMenu->fFlags & MNF_POPUP))
      {
          item = PtMenu->rgItems;
      }
      else
      {
          item = MENU_FindItemByCoords( PtMenu, pmt->Pt, &Id );
      }
 
      if (item && ( PtMenu->iItem == Id))
      {
          if (!(item->spSubMenu))
          {
              INT ExecutedMenuId = MENU_ExecFocusedItem( pmt, PtMenu, Flags);
              if (ExecutedMenuId == -1 || ExecutedMenuId == -2) return -1;
              return ExecutedMenuId;
          }
 
          /* If we are dealing with the menu bar                  */
          /* and this is a click on an already "popped" item:     */
          /* Stop the menu tracking and close the opened submenus */
          if (pmt->TopMenu == PtMenu && PtMenu->TimeToHide)
          {
              return 0;
          }
      }
      if ( IntGetMenu(PtMenu->hWnd) == PtMenu )
      {
          PtMenu->TimeToHide = TRUE;
      }
  }
  return -1;
}

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

{
    WCHAR *p;
    UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
    UINT arrow_bitmap_width;
    RECT Rect;
    INT itemheight = 0;
 
    TRACE("dc=%x owner=%x (%d,%d)\n", hdc, pwndOwner, orgX, orgY);
 
    arrow_bitmap_width = gpsi->oembmi[OBI_MNARROW].cx;
 
    MenuCharSize.cx = IntGetCharDimensions( hdc, NULL, (PDWORD)&MenuCharSize.cy );
 
    RECTL_vSetRect( &Rect, orgX, orgY, orgX, orgY );
 
    if (lpitem->fType & MF_OWNERDRAW)
    {
        MEASUREITEMSTRUCT mis;
        mis.CtlType    = ODT_MENU;
        mis.CtlID      = 0;
        mis.itemID     = lpitem->wID;
        mis.itemData   = lpitem->dwItemData;
        mis.itemHeight = HIWORD( IntGetDialogBaseUnits());
        mis.itemWidth  = 0;
        co_IntSendMessage( UserHMGetHandle(pwndOwner), WM_MEASUREITEM, 0, (LPARAM)&mis );
        /* Tests reveal that Windows ( Win95 thru WinXP) adds twice the average
         * width of a menufont character to the width of an owner-drawn menu. 
         */
        Rect.right += mis.itemWidth + 2 * MenuCharSize.cx;
        if (menuBar) {
            /* under at least win95 you seem to be given a standard
               height for the menu and the height value is ignored */
            Rect.bottom += UserGetSystemMetrics(SM_CYMENUSIZE);
        } else
            Rect.bottom += mis.itemHeight;
        // Or this,
        //lpitem->cxBmp = mis.itemWidth;
        //lpitem->cyBmp = mis.itemHeight;
        TRACE("MF_OWNERDRAW Height %d Width %d\n",mis.itemHeight,mis.itemWidth);
        TRACE("MF_OWNERDRAW id=%04lx size=%dx%d cx %d cy %d\n",
                lpitem->wID, Rect.right-Rect.left,
                 Rect.bottom-Rect.top, MenuCharSize.cx, MenuCharSize.cy);
 
        lpitem->xItem = Rect.left;
        lpitem->yItem = Rect.top;
        lpitem->cxItem = Rect.right;
        lpitem->cyItem = Rect.bottom;
 
        return;
    }
 
    lpitem->xItem  = orgX;
    lpitem->yItem  = orgY; 
    lpitem->cxItem = orgX;
    lpitem->cyItem = orgY;
 
    if (lpitem->fType & MF_SEPARATOR)
    {
        lpitem->cyItem += UserGetSystemMetrics( SM_CYMENUSIZE)/2;//SEPARATOR_HEIGHT;
        if( !menuBar)
            lpitem->cxItem += arrow_bitmap_width + MenuCharSize.cx;
        return;
    }
 
    lpitem->dxTab = 0;
 
    if (lpitem->hbmp)
    {
        SIZE size;
 
        if (!menuBar) {
            MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
            /* Keep the size of the bitmap in callback mode to be able
             * to draw it correctly */
            lpitem->cxBmp = size.cx;
            lpitem->cyBmp = size.cy;
            Menu->cxTextAlign = max(Menu->cxTextAlign, size.cx);
            lpitem->cxItem += size.cx + 2;
            itemheight = size.cy + 2;
 
            if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
                lpitem->cxItem += 2 * check_bitmap_width;
            lpitem->cxItem += 4 + MenuCharSize.cx;
            lpitem->dxTab = lpitem->cxItem;
            lpitem->cxItem += arrow_bitmap_width;
        } else /* hbmpItem & MenuBar */ {
            MENU_GetBitmapItemSize(lpitem, &size, pwndOwner );
            lpitem->cxItem  += size.cx;
            if( lpitem->Xlpstr) lpitem->cxItem  += 2;
            itemheight = size.cy;
 
            /* Special case: Minimize button doesn't have a space behind it. */
            if (lpitem->hbmp == (HBITMAP)HBMMENU_MBAR_MINIMIZE ||
                lpitem->hbmp == (HBITMAP)HBMMENU_MBAR_MINIMIZE_D)
            lpitem->cxItem -= 1;
        }
    }
    else if (!menuBar) {
        if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
             lpitem->cxItem += check_bitmap_width;
        lpitem->cxItem += 4 + MenuCharSize.cx;
        lpitem->dxTab = lpitem->cxItem;
        lpitem->cxItem += arrow_bitmap_width;
    }
 
    /* it must be a text item - unless it's the system menu */
    if (!(lpitem->fType & MF_SYSMENU) && lpitem->Xlpstr) {
        HFONT hfontOld = NULL;
        RECT rc;// = lpitem->Rect;
        LONG txtheight, txtwidth;
 
        rc.left   = lpitem->xItem;
        rc.top    = lpitem->yItem; 
        rc.right  = lpitem->cxItem; // Do this for now......
        rc.bottom = lpitem->cyItem;
 
        if ( lpitem->fState & MFS_DEFAULT ) {
            hfontOld = NtGdiSelectFont( hdc, ghMenuFontBold );
        }
        if (menuBar) {
            txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc, DT_SINGLELINE|DT_CALCRECT); 
 
            lpitem->cxItem  += rc.right - rc.left;
            itemheight = max( max( itemheight, txtheight), UserGetSystemMetrics( SM_CYMENU) - 1);
 
            lpitem->cxItem +=  2 * MenuCharSize.cx;
        } else {
            if ((p = wcschr( lpitem->Xlpstr, '\t' )) != NULL) {
                RECT tmprc = rc;
                LONG tmpheight;
                int n = (int)( p - lpitem->Xlpstr);
                /* Item contains a tab (only meaningful in popup menus) */
                /* get text size before the tab */
                txtheight = DrawTextW( hdc, lpitem->Xlpstr, n, &rc,
                        DT_SINGLELINE|DT_CALCRECT);
                txtwidth = rc.right - rc.left;
                p += 1; /* advance past the Tab */
                /* get text size after the tab */
                tmpheight = DrawTextW( hdc, p, -1, &tmprc,
                        DT_SINGLELINE|DT_CALCRECT);
                lpitem->dxTab += txtwidth;
                txtheight = max( txtheight, tmpheight);
                txtwidth += MenuCharSize.cx + /* space for the tab */
                    tmprc.right - tmprc.left; /* space for the short cut */
            } else {
                txtheight = DrawTextW( hdc, lpitem->Xlpstr, -1, &rc,
                        DT_SINGLELINE|DT_CALCRECT);
                txtwidth = rc.right - rc.left;
                lpitem->dxTab += txtwidth;
            }
            lpitem->cxItem  += 2 + txtwidth;
            itemheight = max( itemheight,
                    max( txtheight + 2, MenuCharSize.cy + 4));
        }
        if (hfontOld)
        {
           NtGdiSelectFont (hdc, hfontOld);
        }
    } else if( menuBar) {
        itemheight = max( itemheight, UserGetSystemMetrics(SM_CYMENU)-1);
    }
    lpitem->cyItem += itemheight;
    TRACE("(%ld,%ld)-(%ld,%ld)\n", lpitem->xItem, lpitem->yItem, lpitem->cxItem, lpitem->cyItem);
}

Referenced by MENU_MenuBarCalcSize(), and MENU_PopupMenuCalcSize().

MENU_depth()

int FASTCALL MENU_depth	(	PMENU	pmenu,
		int	depth
	)

Definition at line 404 of file menu.c.

{
    UINT i;
    ITEM *item;
    int subdepth;
 
    if (!pmenu) return depth;
 
    depth++;
    if( depth > MAXMENUDEPTH) return depth;
    item = pmenu->rgItems;
    subdepth = depth;
    for( i = 0; i < pmenu->cItems && subdepth <= MAXMENUDEPTH; i++, item++)
    {
        if( item->spSubMenu)//VerifyMenu(item->spSubMenu))
        {
            int bdepth = MENU_depth( item->spSubMenu, depth);
            if( bdepth > subdepth) subdepth = bdepth;
        }
        if( subdepth > MAXMENUDEPTH)
            TRACE("<- hmenu %p\n", item->spSubMenu);
    }
    return subdepth;
}

Referenced by IntSetMenuItemInfo(), and MENU_depth().

MENU_DoNextMenu()

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

static

Definition at line 3735 of file menu.c.

{
    BOOL atEnd = FALSE;
 
    /* When skipping left, we need to do something special after the
       first menu.                                                  */
    if (Vk == VK_LEFT && pmt->TopMenu->iItem == 0)
    {
        atEnd = TRUE;
    }
    /* When skipping right, for the non-system menu, we need to
       handle the last non-special menu item (ie skip any window
       icons such as MDI maximize, restore or close)             */
    else if ((Vk == VK_RIGHT) && !IS_SYSTEM_MENU(pmt->TopMenu))
    {
        UINT i = pmt->TopMenu->iItem + 1;
        while (i < pmt->TopMenu->cItems) {
            if ((pmt->TopMenu->rgItems[i].wID >= SC_SIZE &&
                 pmt->TopMenu->rgItems[i].wID <= SC_RESTORE)) {
                i++;
            } else break;
        }
        if (i == pmt->TopMenu->cItems) {
            atEnd = TRUE;
        }
    }
    /* When skipping right, we need to cater for the system menu */
    else if ((Vk == VK_RIGHT) && IS_SYSTEM_MENU(pmt->TopMenu))
    {
        if (pmt->TopMenu->iItem == (pmt->TopMenu->cItems - 1)) {
            atEnd = TRUE;
        }
    }
 
   if ( atEnd )
   {
      MDINEXTMENU NextMenu;
      PMENU MenuTmp;
      PWND pwndTemp;
      HMENU hNewMenu;
      HWND hNewWnd;
      UINT Id = 0;
 
      MenuTmp = (IS_SYSTEM_MENU(pmt->TopMenu)) ? co_IntGetSubMenu(pmt->TopMenu, 0) : pmt->TopMenu;
      NextMenu.hmenuIn = UserHMGetHandle(MenuTmp);
      NextMenu.hmenuNext = NULL;
      NextMenu.hwndNext = NULL;
      co_IntSendMessage(UserHMGetHandle(pmt->OwnerWnd), WM_NEXTMENU, Vk, (LPARAM) &NextMenu);
 
      TRACE("%p [%p] -> %p [%p]\n",
             pmt->CurrentMenu, pmt->OwnerWnd, NextMenu.hmenuNext, NextMenu.hwndNext );
 
      if (NULL == NextMenu.hmenuNext || NULL == NextMenu.hwndNext)
      {
          hNewWnd = UserHMGetHandle(pmt->OwnerWnd);
          if (IS_SYSTEM_MENU(pmt->TopMenu))
          {
              /* switch to the menu bar */
 
              if (pmt->OwnerWnd->style & WS_CHILD || !(MenuTmp = IntGetMenu(hNewWnd))) return FALSE;
 
              if (Vk == VK_LEFT)
              {
                  Id = MenuTmp->cItems - 1;
   
                  /* Skip backwards over any system predefined icons,
                     eg. MDI close, restore etc icons                 */
                   while ((Id > 0) &&
                          (MenuTmp->rgItems[Id].wID >= SC_SIZE &&
                           MenuTmp->rgItems[Id].wID <= SC_RESTORE)) Id--;
 
              }
              hNewMenu = UserHMGetHandle(MenuTmp);
          }
          else if (pmt->OwnerWnd->style & WS_SYSMENU)
          {
              /* switch to the system menu */
              MenuTmp = get_win_sys_menu(hNewWnd);
              if (MenuTmp) hNewMenu = UserHMGetHandle(MenuTmp);
              else hNewMenu = NULL;
          }
          else
              return FALSE;
      }
      else    /* application returned a new menu to switch to */
      {
          hNewMenu = NextMenu.hmenuNext;
          hNewWnd = NextMenu.hwndNext;
 
          if ((MenuTmp = UserGetMenuObject(hNewMenu)) && (pwndTemp = ValidateHwndNoErr(hNewWnd)))
          {
              if ( pwndTemp->style & WS_SYSMENU && (get_win_sys_menu(hNewWnd) == MenuTmp) )
              {
                  /* get the real system menu */
                  MenuTmp = get_win_sys_menu(hNewWnd);
                  hNewMenu = UserHMGetHandle(MenuTmp);
              }
              else if (pwndTemp->style & WS_CHILD || IntGetMenu(hNewWnd) != MenuTmp)
              {
                  /* FIXME: Not sure what to do here;
                   * perhaps try to track NewMenu as a popup? */
 
                  WARN(" -- got confused.\n");
                  return FALSE;
              }
          }
          else return FALSE;
      }
 
      if (hNewMenu != UserHMGetHandle(pmt->TopMenu))
      {
          MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, NO_SELECTED_ITEM, FALSE, 0 );
 
          if (pmt->CurrentMenu != pmt->TopMenu)
              MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, wFlags);
      }
 
      if (hNewWnd != UserHMGetHandle(pmt->OwnerWnd))
      {
          PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
          pmt->OwnerWnd = ValidateHwndNoErr(hNewWnd);
          MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, hNewWnd);
          pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
          co_UserSetCapture(UserHMGetHandle(pmt->OwnerWnd));
          pti->MessageQueue->QF_flags |= QF_CAPTURELOCKED;
      }
 
      pmt->TopMenu = pmt->CurrentMenu = UserGetMenuObject(hNewMenu); /* all subpopups are hidden */
      MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, Id, TRUE, 0);
 
      return TRUE;
   }
   return FALSE;
}

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

{
    BITMAP bm;
    DWORD rop;
    HDC hdcMem;
    HBITMAP bmp;
    int w = rect->right - rect->left;
    int h = rect->bottom - rect->top;
    int bmp_xoffset = 0;
    int left, top;
    BOOL flat_menu;
    HBITMAP hbmToDraw = lpitem->hbmp;
    bmp = hbmToDraw;
 
    UserSystemParametersInfo(SPI_GETFLATMENU, 0, &flat_menu, 0);
 
    /* Check if there is a magic menu item associated with this item */
    if (IS_MAGIC_BITMAP(hbmToDraw))
    {
        UINT flags = 0;
        RECT r;
 
      r = *rect;
      switch ((INT_PTR)hbmToDraw)
      {
        case (INT_PTR)HBMMENU_SYSTEM:
            if (lpitem->dwItemData)
            {
                if (ValidateHwndNoErr((HWND)lpitem->dwItemData))
                {
                   ERR("Get Item Data from this Window!!!\n");
                }
 
                ERR("Draw Bitmap\n");
                bmp = (HBITMAP)lpitem->dwItemData;
                if (!GreGetObject( bmp, sizeof(bm), &bm )) return;
            }
            else
            {
                PCURICON_OBJECT pIcon = NULL;
                //if (!BmpSysMenu) BmpSysMenu = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE));
                //bmp = BmpSysMenu;
                //if (! GreGetObject(bmp, sizeof(bm), &bm)) return;
                /* only use right half of the bitmap */
                //bmp_xoffset = bm.bmWidth / 2;
                //bm.bmWidth -= bmp_xoffset;
                if (WndOwner)
                {
                    pIcon = NC_IconForWindow(WndOwner);
                    // FIXME: NC_IconForWindow should reference it for us */
                    if (pIcon) UserReferenceObject(pIcon);
                }
                ERR("Draw ICON\n");
                if (pIcon)
                {
                   LONG cx = UserGetSystemMetrics(SM_CXSMICON);
                   LONG cy = UserGetSystemMetrics(SM_CYSMICON);
                   LONG x = rect->left - cx/2 + 1 + (rect->bottom - rect->top)/2; // this is really what Window does
                   LONG y = (rect->top + rect->bottom)/2 - cy/2; // center
                   UserDrawIconEx(hdc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
                   UserDereferenceObject(pIcon);
                 }
                 return;
            }
            goto got_bitmap;
        case (INT_PTR)HBMMENU_MBAR_RESTORE:
            flags = DFCS_CAPTIONRESTORE;
            break;
        case (INT_PTR)HBMMENU_MBAR_MINIMIZE:
            r.right += 1;
            flags = DFCS_CAPTIONMIN;
            break;
        case (INT_PTR)HBMMENU_MBAR_MINIMIZE_D:
            r.right += 1;
            flags = DFCS_CAPTIONMIN | DFCS_INACTIVE;
            break;
        case (INT_PTR)HBMMENU_MBAR_CLOSE:
            flags = DFCS_CAPTIONCLOSE;
            break;
        case (INT_PTR)HBMMENU_MBAR_CLOSE_D:
            flags = DFCS_CAPTIONCLOSE | DFCS_INACTIVE;
            break;
        case (INT_PTR)HBMMENU_CALLBACK:
            {
                DRAWITEMSTRUCT drawItem;
                POINT origorg;
                drawItem.CtlType = ODT_MENU;
                drawItem.CtlID = 0;
                drawItem.itemID = lpitem->wID;
                drawItem.itemAction = odaction;
                drawItem.itemState = (lpitem->fState & MF_CHECKED)?ODS_CHECKED:0;
                drawItem.itemState |= (lpitem->fState & MF_DEFAULT)?ODS_DEFAULT:0;
                drawItem.itemState |= (lpitem->fState & MF_DISABLED)?ODS_DISABLED:0;
                drawItem.itemState |= (lpitem->fState & MF_GRAYED)?ODS_GRAYED|ODS_DISABLED:0;
                drawItem.itemState |= (lpitem->fState & MF_HILITE)?ODS_SELECTED:0;
                drawItem.itemState |= (!(Menu->fFlags & MNF_UNDERLINE))?ODS_NOACCEL:0;
                drawItem.itemState |= (Menu->fFlags & MNF_INACTIVE)?ODS_INACTIVE:0;
                drawItem.hwndItem = (HWND)UserHMGetHandle(Menu);
                drawItem.hDC = hdc;
                drawItem.rcItem = *rect;
                drawItem.itemData = lpitem->dwItemData;
                /* some applications make this assumption on the DC's origin */
                GreSetViewportOrgEx( hdc, lpitem->xItem, lpitem->yItem, &origorg);
                RECTL_vOffsetRect(&drawItem.rcItem, -(LONG)lpitem->xItem, -(LONG)lpitem->yItem);
                co_IntSendMessage( UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM)&drawItem);
                GreSetViewportOrgEx( hdc, origorg.x, origorg.y, NULL);
                return;
            }
            break;
 
          case (INT_PTR) HBMMENU_POPUP_CLOSE:
          case (INT_PTR) HBMMENU_POPUP_RESTORE:
          case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
          case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
            MENU_DrawPopupGlyph(hdc, &r, (INT_PTR)hbmToDraw, lpitem->fState & MF_GRAYED, lpitem->fState & MF_HILITE);
            return;
      }
      RECTL_vInflateRect(&r, -1, -1);
      if (lpitem->fState & MF_HILITE) flags |= DFCS_PUSHED;
      DrawFrameControl(hdc, &r, DFC_CAPTION, flags);
      return;
    }
 
    if (!bmp || !GreGetObject( bmp, sizeof(bm), &bm )) return;
 
 got_bitmap:
    hdcMem = NtGdiCreateCompatibleDC( hdc );
    NtGdiSelectBitmap( hdcMem, bmp );
    /* handle fontsize > bitmap_height */
    top = (h>bm.bmHeight) ? rect->top+(h-bm.bmHeight)/2 : rect->top;
    left=rect->left;
    rop=((lpitem->fState & MF_HILITE) && !IS_MAGIC_BITMAP(hbmToDraw)) ? NOTSRCCOPY : SRCCOPY;
    if ((lpitem->fState & MF_HILITE) && lpitem->hbmp)
        IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_HIGHLIGHT));
    if (MenuBar &&
        !flat_menu &&
        (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
    {
        ++left;
        ++top;
    }
    NtGdiBitBlt( hdc, left, top, w, h, hdcMem, bmp_xoffset, 0, rop , 0, 0);
    IntGdiDeleteDC( hdcMem, FALSE );
}

Referenced by MENU_DrawMenuItem().

MENU_DrawMenuBar()

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

Definition at line 2742 of file menu.c.

{
    HFONT hfontOld = 0;
    PMENU lppop = UserGetMenuObject(UlongToHandle(pWnd->IDMenu));
 
    if (lppop == NULL)
    {
        // No menu. Do not reserve any space
        return 0;
    }
 
    if (lprect == NULL)
    {
        return UserGetSystemMetrics(SM_CYMENU);
    }
 
    if (suppress_draw)
    {
       hfontOld = NtGdiSelectFont(hDC, ghMenuFont);
 
       MENU_MenuBarCalcSize(hDC, lprect, lppop, pWnd);
 
       lprect->bottom = lprect->top + lppop->cyMenu;
 
       if (hfontOld) NtGdiSelectFont( hDC, hfontOld);
 
       return lppop->cyMenu;
    }   
    else
    {
       return IntDrawMenuBarTemp(pWnd, hDC, lprect, lppop, NULL);
    }
}

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

{
    RECT rect;
    PWCHAR Text;
    BOOL flat_menu = FALSE;
    int bkgnd;
    UINT arrow_bitmap_width = 0;
    //RECT bmprc;
 
    if (!menuBar) {
        arrow_bitmap_width  = gpsi->oembmi[OBI_MNARROW].cx; 
    }
 
    if (lpitem->fType & MF_SYSMENU)
    {
        if (!(Wnd->style & WS_MINIMIZE))
        {
          NC_GetInsideRect(Wnd, &rect);
          UserDrawSysMenuButton(Wnd, hdc, &rect, lpitem->fState & (MF_HILITE | MF_MOUSESELECT));
    }
        return;
    }
 
    UserSystemParametersInfo (SPI_GETFLATMENU, 0, &flat_menu, 0);
    bkgnd = (menuBar && flat_menu) ? COLOR_MENUBAR : COLOR_MENU;
  
    /* Setup colors */
 
    if (lpitem->fState & MF_HILITE)
    {
        if(menuBar && !flat_menu) {
            IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_MENUTEXT));
            IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_MENU));
        } else {
            if (lpitem->fState & MF_GRAYED)
                IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_GRAYTEXT));
            else
                IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_HIGHLIGHTTEXT));
            IntGdiSetBkColor(hdc, IntGetSysColor(COLOR_HIGHLIGHT));
        }
    }
    else
    {
        if (lpitem->fState & MF_GRAYED)
            IntGdiSetTextColor( hdc, IntGetSysColor( COLOR_GRAYTEXT ) );
        else
            IntGdiSetTextColor( hdc, IntGetSysColor( COLOR_MENUTEXT ) );
        IntGdiSetBkColor( hdc, IntGetSysColor( bkgnd ) );
    }
 
    //TRACE("rect=%s\n", wine_dbgstr_rect( &lpitem->Rect));
    //rect = lpitem->Rect;
    rect.left   = lpitem->xItem;
    rect.top    = lpitem->yItem; 
    rect.right  = lpitem->cxItem; // Do this for now......
    rect.bottom = lpitem->cyItem;
 
    MENU_AdjustMenuItemRect(Menu, &rect);
 
    if (lpitem->fType & MF_OWNERDRAW)
    {
        /*
        ** Experimentation under Windows reveals that an owner-drawn
        ** menu is given the rectangle which includes the space it requested
        ** in its response to WM_MEASUREITEM _plus_ width for a checkmark
        ** and a popup-menu arrow.  This is the value of lpitem->rect.
        ** Windows will leave all drawing to the application except for
        ** the popup-menu arrow.  Windows always draws that itself, after
        ** the menu owner has finished drawing.
        */
        DRAWITEMSTRUCT dis;
        COLORREF old_bk, old_text;
 
        dis.CtlType   = ODT_MENU;
        dis.CtlID     = 0;
        dis.itemID    = lpitem->wID;
        dis.itemData  = (DWORD)lpitem->dwItemData;
        dis.itemState = 0;
        if (lpitem->fState & MF_CHECKED)  dis.itemState |= ODS_CHECKED;
        if (lpitem->fState & MF_DEFAULT)  dis.itemState |= ODS_DEFAULT;
        if (lpitem->fState & MF_DISABLED) dis.itemState |= ODS_DISABLED;
        if (lpitem->fState & MF_GRAYED)   dis.itemState |= ODS_GRAYED | ODS_DISABLED;
        if (lpitem->fState & MF_HILITE)   dis.itemState |= ODS_SELECTED;
        if (!(Menu->fFlags & MNF_UNDERLINE)) dis.itemState |= ODS_NOACCEL;
        if (Menu->fFlags & MNF_INACTIVE) dis.itemState |= ODS_INACTIVE;
        dis.itemAction = odaction; /* ODA_DRAWENTIRE | ODA_SELECT | ODA_FOCUS; */
        dis.hwndItem   = (HWND) UserHMGetHandle(Menu);
        dis.hDC        = hdc;
        dis.rcItem     = rect;
        TRACE("Ownerdraw: owner=%p itemID=%d, itemState=%d, itemAction=%d, "
            "hwndItem=%p, hdc=%p, rcItem={%ld,%ld,%ld,%ld}\n", Wnd,
            dis.itemID, dis.itemState, dis.itemAction, dis.hwndItem,
            dis.hDC, dis.rcItem.left, dis.rcItem.top, dis.rcItem.right,
            dis.rcItem.bottom);
        TRACE("Ownerdraw: Width %d Height %d\n", dis.rcItem.right-dis.rcItem.left, dis.rcItem.bottom-dis.rcItem.top);
        old_bk = GreGetBkColor(hdc);
        old_text = GreGetTextColor(hdc);
        co_IntSendMessage(UserHMGetHandle(WndOwner), WM_DRAWITEM, 0, (LPARAM) &dis);
        IntGdiSetBkColor(hdc, old_bk);
        IntGdiSetTextColor(hdc, old_text);
        /* Draw the popup-menu arrow */
        if (!menuBar && lpitem->spSubMenu)
        {
            RECT rectTemp;
            RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
            rectTemp.left = rectTemp.right - UserGetSystemMetrics(SM_CXMENUCHECK);
            UITOOLS95_DrawFrameMenu(hdc, &rectTemp, DFCS_MENUARROW);
        }
        return;
    }
 
    if (menuBar && (lpitem->fType & MF_SEPARATOR)) return;
 
    if (lpitem->fState & MF_HILITE)
    {
        if (flat_menu)
        {
            RECTL_vInflateRect (&rect, -1, -1);
            FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENUHILIGHT));
            RECTL_vInflateRect (&rect, 1, 1);
            FrameRect(hdc, &rect, IntGetSysColorBrush(COLOR_HIGHLIGHT));
        }
        else
        {
            if (menuBar)
            {
                FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENU));
                DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
            }
            else
            {
                FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_HIGHLIGHT));
            }
        }
    }
    else
        FillRect( hdc, &rect, IntGetSysColorBrush(bkgnd) );
 
    IntGdiSetBkMode( hdc, TRANSPARENT );
 
    /* vertical separator */
    if (!menuBar && (lpitem->fType & MF_MENUBARBREAK))
    {
        HPEN oldPen;
        RECT rc = rect;
 
        rc.left -= 3;//MENU_COL_SPACE / 2 + 1; == 3!!
        rc.top = 3;
        rc.bottom = Height - 3;
        if (flat_menu)
        {
            oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
            IntSetDCPenColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
            GreMoveTo( hdc, rc.left, rc.top, NULL );
            NtGdiLineTo( hdc, rc.left, rc.bottom );
            NtGdiSelectPen( hdc, oldPen );
        }
        else
            DrawEdge (hdc, &rc, EDGE_ETCHED, BF_LEFT);
    }
 
    /* horizontal separator */
    if (lpitem->fType & MF_SEPARATOR)
    {
        HPEN oldPen;
        RECT rc = rect;
 
        rc.left++;
        rc.right--;
        rc.top = (rc.top + rc.bottom) / 2 - 1;
        if (flat_menu)
        {
            oldPen = NtGdiSelectPen( hdc, NtGdiGetStockObject(DC_PEN) );
            IntSetDCPenColor( hdc, IntGetSysColor(COLOR_BTNSHADOW));
            GreMoveTo( hdc, rc.left, rc.top, NULL );
            NtGdiLineTo( hdc, rc.right, rc.top );
            NtGdiSelectPen( hdc, oldPen );
        }
        else
            DrawEdge (hdc, &rc, EDGE_ETCHED, BF_TOP);
        return;
    }
#if 0
    /* helper lines for debugging */
    /* This is a very good test tool when hacking menus! (JT) 07/16/2006 */
    FrameRect(hdc, &rect, NtGdiGetStockObject(BLACK_BRUSH));
    NtGdiSelectPen(hdc, NtGdiGetStockObject(DC_PEN));
    IntSetDCPenColor(hdc, IntGetSysColor(COLOR_WINDOWFRAME));
    GreMoveTo(hdc, rect.left, (rect.top + rect.bottom) / 2, NULL);
    NtGdiLineTo(hdc, rect.right, (rect.top + rect.bottom) / 2);
#endif
#if 0 // breaks mdi menu bar icons.
    if (lpitem->hbmp) {
        /* calculate the bitmap rectangle in coordinates relative
         * to the item rectangle */
        if( menuBar) {
            if( lpitem->hbmp == HBMMENU_CALLBACK)
                bmprc.left = 3;
            else 
                bmprc.left = lpitem->Xlpstr ? MenuCharSize.cx : 0;          
        }
        else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)
            bmprc.left = 4;
        else if ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)
            bmprc.left = 2;
        else
            bmprc.left = 4 + UserGetSystemMetrics(SM_CXMENUCHECK);
 
        bmprc.right =  bmprc.left + lpitem->cxBmp;
 
        if( menuBar && !(lpitem->hbmp == HBMMENU_CALLBACK))
            bmprc.top = 0;
        else
            bmprc.top = (rect.bottom - rect.top - lpitem->cyBmp) / 2; 
 
        bmprc.bottom =  bmprc.top + lpitem->cyBmp;
    }
#endif
    if (!menuBar)
    {
        HBITMAP bm;
        INT y = rect.top + rect.bottom;
        RECT rc = rect;
        BOOL checked = FALSE;
        UINT check_bitmap_width = UserGetSystemMetrics( SM_CXMENUCHECK );
        UINT check_bitmap_height = UserGetSystemMetrics( SM_CYMENUCHECK );
        /* Draw the check mark
         *
         * FIXME:
         * Custom checkmark bitmaps are monochrome but not always 1bpp.
         */
        if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK)) {
            bm = (lpitem->fState & MF_CHECKED) ? lpitem->hbmpChecked : 
                lpitem->hbmpUnchecked;
            if (bm)  /* we have a custom bitmap */
            {
                HDC hdcMem = NtGdiCreateCompatibleDC( hdc );
 
                NtGdiSelectBitmap( hdcMem, bm );
                NtGdiBitBlt( hdc, rc.left, (y - check_bitmap_height) / 2,
                        check_bitmap_width, check_bitmap_height,
                        hdcMem, 0, 0, SRCCOPY, 0,0);
                IntGdiDeleteDC( hdcMem, FALSE );
                checked = TRUE;
            }
            else if (lpitem->fState & MF_CHECKED) /* standard bitmaps */
            {
                RECT r;
                r = rect;
                r.right = r.left + check_bitmap_width;
                UITOOLS95_DrawFrameMenu(hdc, &r,
                                        (lpitem->fType & MFT_RADIOCHECK) ?
                                        DFCS_MENUBULLET : DFCS_MENUCHECK);
                checked = TRUE;
            }
        }
        if ( lpitem->hbmp )//&& !( checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
        {
            RECT bmpRect = rect;
            if (!((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP) && !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
                bmpRect.left += check_bitmap_width + 2;
            if (!(checked && ((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP)))
            {
                bmpRect.right = bmpRect.left + lpitem->cxBmp;
                MENU_DrawBitmapItem(hdc, lpitem, &bmpRect, Menu, WndOwner, odaction, menuBar);
            }
        }
        /* Draw the popup-menu arrow */
        if (lpitem->spSubMenu)
        {
            RECT rectTemp;
            RtlCopyMemory(&rectTemp, &rect, sizeof(RECT));
            rectTemp.left = rectTemp.right - check_bitmap_width;
            UITOOLS95_DrawFrameMenu(hdc, &rectTemp, DFCS_MENUARROW);
        }
        rect.left += 4;
        if( !((Menu->fFlags & MNS_STYLE_MASK) & MNS_NOCHECK))
            rect.left += check_bitmap_width;
        rect.right -= arrow_bitmap_width;
    }
    else if( lpitem->hbmp)
    { /* Draw the bitmap */
        MENU_DrawBitmapItem(hdc, lpitem, &rect/*bmprc*/, Menu, WndOwner, odaction, menuBar);
    }
 
    /* process text if present */
    if (lpitem->Xlpstr)
    {
        int i = 0;
        HFONT hfontOld = 0;
 
        UINT uFormat = menuBar ?
                       DT_CENTER | DT_VCENTER | DT_SINGLELINE :
                       DT_LEFT | DT_VCENTER | DT_SINGLELINE;
 
        if (((Menu->fFlags & MNS_STYLE_MASK) & MNS_CHECKORBMP))
             rect.left += max(0, (int)(Menu->cxTextAlign - UserGetSystemMetrics(SM_CXMENUCHECK)));
        else
             rect.left += Menu->cxTextAlign;
 
        if ( lpitem->fState & MFS_DEFAULT )
        {
            hfontOld = NtGdiSelectFont(hdc, ghMenuFontBold);            
        }
 
        if (menuBar) {
            if( lpitem->hbmp)
              rect.left += lpitem->cxBmp;
            if( !(lpitem->hbmp == HBMMENU_CALLBACK)) 
              rect.left += MenuCharSize.cx;
            rect.right -= MenuCharSize.cx;
        }
 
        Text = lpitem->Xlpstr;
        if(Text)
        {
            for (i = 0; Text[i]; i++)
                if (Text[i] == L'\t' || Text[i] == L'\b')
                    break;
        }
 
        if (menuBar &&
            !flat_menu &&
            (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
        {
            RECTL_vOffsetRect(&rect, +1, +1);
        }
 
        if (!menuBar)
            --rect.bottom;
 
        if(lpitem->fState & MF_GRAYED)
        {
            if (!(lpitem->fState & MF_HILITE) )
            {
                ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
                IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNHIGHLIGHT));
                DrawTextW( hdc, Text, i, &rect, uFormat );
                --rect.left; --rect.top; --rect.right; --rect.bottom;
            }
            IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
        }
        DrawTextW( hdc, Text, i, &rect, uFormat);
 
        /* paint the shortcut text */
        if (!menuBar && L'\0' != Text[i])  /* There's a tab or flush-right char */
        {
            if (L'\t' == Text[i])
            {
                rect.left = lpitem->dxTab;
                uFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
            }
            else
            {
                rect.right = lpitem->dxTab;
                uFormat = DT_RIGHT | DT_VCENTER | DT_SINGLELINE;
            }
 
            if (lpitem->fState & MF_GRAYED)
            {
                if (!(lpitem->fState & MF_HILITE) )
                {
                    ++rect.left; ++rect.top; ++rect.right; ++rect.bottom;
                    IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNHIGHLIGHT));
                    DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat);
                    --rect.left; --rect.top; --rect.right; --rect.bottom;
                }
                IntGdiSetTextColor(hdc, IntGetSysColor(COLOR_BTNSHADOW));
            }
            DrawTextW( hdc, Text + i + 1, -1, &rect, uFormat );
        }
 
        if (!menuBar)
            ++rect.bottom;
 
        if (menuBar &&
            !flat_menu &&
            (lpitem->fState & (MF_HILITE | MF_GRAYED)) == MF_HILITE)
        {
            RECTL_vOffsetRect(&rect, -1, -1);
        }
 
        if (hfontOld)
        {
           NtGdiSelectFont (hdc, hfontOld);
        }
    }
}

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

{
  LOGFONTW lf;
  HFONT hFont, hOldFont;
  COLORREF clrsave;
  INT bkmode;
  WCHAR symbol;
  switch (popupMagic)
  {
  case (INT_PTR) HBMMENU_POPUP_RESTORE:
    symbol = '2';
    break;
  case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
    symbol = '0';
    break;
  case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
    symbol = '1';
    break;
  case (INT_PTR) HBMMENU_POPUP_CLOSE:
    symbol = 'r';
    break;
  default:
    ERR("Invalid popup magic bitmap %d\n", (int)popupMagic);
    return;
  }
  RtlZeroMemory(&lf, sizeof(LOGFONTW));
  RECTL_vInflateRect(r, -2, -2);
  lf.lfHeight = r->bottom - r->top;
  lf.lfWidth = 0;
  lf.lfWeight = FW_NORMAL;
  lf.lfCharSet = DEFAULT_CHARSET;
  RtlCopyMemory(lf.lfFaceName, L"Marlett", sizeof(L"Marlett"));
  hFont = GreCreateFontIndirectW(&lf);
  /* save font and text color */
  hOldFont = NtGdiSelectFont(dc, hFont);
  clrsave = GreGetTextColor(dc);
  bkmode = GreGetBkMode(dc);
  /* set color and drawing mode */
  IntGdiSetBkMode(dc, TRANSPARENT);
  if (inactive)
  {
    /* draw shadow */
    if (!hilite)
    {
      IntGdiSetTextColor(dc, IntGetSysColor(COLOR_HIGHLIGHTTEXT));
      GreTextOutW(dc, r->left + 1, r->top + 1, &symbol, 1);
    }
  }
  IntGdiSetTextColor(dc, IntGetSysColor(inactive ? COLOR_GRAYTEXT : (hilite ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)));
  /* draw selected symbol */
  GreTextOutW(dc, r->left, r->top, &symbol, 1);
  /* restore previous settings */
  IntGdiSetTextColor(dc, clrsave);
  NtGdiSelectFont(dc, hOldFont);
  IntGdiSetBkMode(dc, bkmode);
  GreDeleteObject(hFont);
}

Referenced by MENU_DrawBitmapItem().

MENU_DrawPopupMenu()

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

static

Definition at line 2599 of file menu.c.

{
    HBRUSH hPrevBrush = 0, brush = IntGetSysColorBrush(COLOR_MENU);
    RECT rect;
 
    TRACE("DPM wnd=%p dc=%p menu=%p\n", wnd, hdc, menu);
 
    IntGetClientRect( wnd, &rect );
 
    if (menu && menu->hbrBack) brush = menu->hbrBack;
    if((hPrevBrush = NtGdiSelectBrush( hdc, brush ))
        && (NtGdiSelectFont( hdc, ghMenuFont)))
    {
        HPEN hPrevPen;
 
        /* FIXME: Maybe we don't have to fill the background manually */
        FillRect(hdc, &rect, brush);
 
        hPrevPen = NtGdiSelectPen( hdc, NtGdiGetStockObject( NULL_PEN ) );
        if ( hPrevPen )
        {
            TRACE("hmenu %p Style %08x\n", UserHMGetHandle(menu), (menu->fFlags & MNS_STYLE_MASK));
            /* draw menu items */
            if (menu && menu->cItems)
            {
                ITEM *item;
                UINT u;
 
                item = menu->rgItems;
                for( u = menu->cItems; u > 0; u--, item++)
                {
                    MENU_DrawMenuItem(wnd, menu, menu->spwndNotify, hdc, item,
                                         menu->cyMenu, FALSE, ODA_DRAWENTIRE);
                }
                /* draw scroll arrows */
                if (menu->dwArrowsOn)
                {
                   MENU_DrawScrollArrows(menu, hdc);
                }
            }
        }
        else
        {
            NtGdiSelectBrush( hdc, hPrevBrush );
        }
    }
}

Referenced by PopupMenuWndProc().

MENU_DrawScrollArrows()

static void MENU_DrawScrollArrows ( PMENU  lppop, HDC  hdc  )

static

Definition at line 2176 of file menu.c.

{
    UINT arrow_bitmap_height;
    RECT rect;
    UINT Flags = 0;
 
    arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
 
    rect.left = 0;
    rect.top = 0;
    rect.right = lppop->cxMenu;
    rect.bottom = arrow_bitmap_height;
    FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENU));
    UITOOLS95_DrawFrameMenu(hdc, &rect, (lppop->iTop ? 0 : DFCS_INACTIVE) | DFCS_MENUARROWUP);
 
    rect.top = lppop->cyMenu - arrow_bitmap_height;
    rect.bottom = lppop->cyMenu;
    FillRect(hdc, &rect, IntGetSysColorBrush(COLOR_MENU));
    if (!(lppop->iTop < lppop->iMaxTop - (MENU_GetMaxPopupHeight(lppop) - 2 * arrow_bitmap_height)))
       Flags = DFCS_INACTIVE;
    UITOOLS95_DrawFrameMenu(hdc, &rect, Flags | DFCS_MENUARROWDOWN);
}

Referenced by MENU_DrawPopupMenu(), and MENU_EnsureMenuItemVisible().

MENU_EndMenu()

void MENU_EndMenu

(

PWND

pwnd

)

Definition at line 2662 of file menu.c.

{
    PMENU menu = NULL;
    menu = UserGetMenuObject(top_popup_hmenu);
    if ( menu && ( UserHMGetHandle(pwnd) == menu->hWnd || pwnd == menu->spwndNotify ) )
    {
       if (fInsideMenuLoop && top_popup)
       {
          fInsideMenuLoop = FALSE;
 
          if (fInEndMenu)
          {
             ERR("Already in End loop\n");
             return;
          }
 
          fInEndMenu = TRUE;
          UserPostMessage( top_popup, WM_CANCELMODE, 0, 0);
       }
    }
}

Referenced by IntDefWindowProc().

MENU_EnsureMenuItemVisible()

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

Definition at line 3102 of file menu.c.

{
    USER_REFERENCE_ENTRY Ref;
    if (lppop->dwArrowsOn)
    {
        ITEM *item = &lppop->rgItems[wIndex];
        UINT nMaxHeight = MENU_GetMaxPopupHeight(lppop);
        UINT nOldPos = lppop->iTop;
        RECT rc;
        UINT arrow_bitmap_height;
        PWND pWnd = ValidateHwndNoErr(lppop->hWnd);
 
        IntGetClientRect(pWnd, &rc);
 
        arrow_bitmap_height = gpsi->oembmi[OBI_DNARROW].cy;
 
        rc.top += arrow_bitmap_height;
        rc.bottom -= arrow_bitmap_height;
 
        nMaxHeight -= UserGetSystemMetrics(SM_CYBORDER) + 2 * arrow_bitmap_height;
        UserRefObjectCo(pWnd, &Ref);
        if (item->cyItem > lppop->iTop + nMaxHeight)
        {
            lppop->iTop = item->cyItem - nMaxHeight;
            IntScrollWindow(pWnd, 0, nOldPos - lppop->iTop, &rc, &rc);
            MENU_DrawScrollArrows(lppop, hdc);
            //ERR("Scroll Down iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
        }
        else if (item->yItem < lppop->iTop)
        {
            lppop->iTop = item->yItem;
            IntScrollWindow(pWnd, 0, nOldPos - lppop->iTop, &rc, &rc);
            MENU_DrawScrollArrows(lppop, hdc);
            //ERR("Scroll Up   iTop %d iMaxTop %d nMaxHeight %d\n",lppop->iTop,lppop->iMaxTop,nMaxHeight);
        }
        UserDerefObjectCo(pWnd);
    }
}

Referenced by MENU_SelectItem().

MENU_ExecFocusedItem()

static INT FASTCALL MENU_ExecFocusedItem ( MTRACKER *  pmt, PMENU  Menu, UINT  Flags  )

static

Definition at line 3478 of file menu.c.

{
  PITEM Item;
 
  TRACE("%p menu=%p\n", pmt, Menu);
 
  if (!Menu || !Menu->cItems || Menu->iItem == NO_SELECTED_ITEM)
  {
      return -1;
  }
 
  Item = &Menu->rgItems[Menu->iItem];
 
  TRACE("%p %08x %p\n", Menu, Item->wID, Item->spSubMenu);
 
  if (!(Item->spSubMenu))
  {
      if (!(Item->fState & (MF_GRAYED | MF_DISABLED)) && !(Item->fType & MF_SEPARATOR))
      {
          /* If TPM_RETURNCMD is set you return the id, but
            do not send a message to the owner */
          if (!(Flags & TPM_RETURNCMD))
          {
              if (Menu->fFlags & MNF_SYSMENU)
              {
                  UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_SYSCOMMAND, Item->wID,
                               MAKELPARAM((SHORT) pmt->Pt.x, (SHORT) pmt->Pt.y));
              }
              else
              {
                  DWORD dwStyle = ((Menu->fFlags & MNS_STYLE_MASK) | ( pmt->TopMenu ? (pmt->TopMenu->fFlags & MNS_STYLE_MASK) : 0) );
 
                  if (dwStyle & MNS_NOTIFYBYPOS)
                      UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_MENUCOMMAND, Menu->iItem, (LPARAM)UserHMGetHandle(Menu));
                  else
                      UserPostMessage(UserHMGetHandle(pmt->OwnerWnd), WM_COMMAND, Item->wID, 0);
              }
          }
          return Item->wID;
      }
  }
  else
  {
      pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, Menu, TRUE, Flags);
      return -2;
  }
 
  return -1;
}

Referenced by MENU_ButtonUp(), and MENU_TrackMenu().

MENU_ExitTracking()

static BOOL FASTCALL MENU_ExitTracking ( PWND  pWnd, BOOL  bPopup, UINT  wFlags  )

static

Definition at line 4464 of file menu.c.

{
    TRACE("Exit Track hwnd=%p bPopup %d\n", UserHMGetHandle(pWnd), bPopup);
 
    IntNotifyWinEvent( EVENT_SYSTEM_MENUEND, pWnd, OBJID_WINDOW, CHILDID_SELF, 0);
 
    if (!(wFlags & TPM_NONOTIFY))
       co_IntSendMessage( UserHMGetHandle(pWnd), WM_EXITMENULOOP, bPopup, 0 );
 
    co_UserShowCaret(0);
 
    top_popup = 0;
    top_popup_hmenu = NULL;
 
    return TRUE;
}

Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().

MENU_FindItem()

PITEM FASTCALL MENU_FindItem	(	PMENU *	pmenu,
		UINT *	nPos,
		UINT	wFlags
	)

Definition at line 507 of file menu.c.

{
    MENU *menu = *pmenu;
    ITEM *fallback = NULL;
    UINT fallback_pos = 0;
    UINT i;
 
    if (!menu) return NULL;
 
    if (wFlags & MF_BYPOSITION)
    {
        if (!menu->cItems) return NULL;
    if (*nPos >= menu->cItems) return NULL;
    return &menu->rgItems[*nPos];
    }
    else
    {
        PITEM item = menu->rgItems;
    for (i = 0; i < menu->cItems; i++, item++)
    {
        if (item->spSubMenu)
        {
        PMENU psubmenu = item->spSubMenu;//VerifyMenu(item->spSubMenu);
        PITEM subitem = MENU_FindItem( &psubmenu, nPos, wFlags );
        if (subitem)
        {
            *pmenu = psubmenu;
            return subitem;
        }
        else if (item->wID == *nPos)
        {
            /* fallback to this item if nothing else found */
            fallback_pos = i;
            fallback = item;
        }
        }
        else if (item->wID == *nPos)
        {
        *nPos = i;
        return item;
        }
    }
    }
 
    if (fallback)
        *nPos = fallback_pos;
 
    return fallback;
}

Referenced by CheckMenuItem(), CheckMenuRadioItem(), co_IntGetSubMenu(), co_IntTranslateAccelerator(), GetMenuItemID(), GetMenuItemInfo_common(), GetMenuState(), GetMenuStringA(), GetMenuStringW(), GetSubMenu(), IntCheckMenuItem(), IntEnableMenuItem(), IntGetMenuItemRect(), IntGetMenuState(), IntGetSubMenu(), IntHiliteMenuItem(), IntMenuItemInfo(), IntRemoveMenuItem(), MENU_FindItem(), MENU_InsertItem(), NtUserGetMenuItemRect(), and UserMenuItemInfo().

MENU_FindItemByCoords()

static ITEM * MENU_FindItemByCoords ( MENU *  menu, POINT  pt, UINT *  pos  )

static

Definition at line 1480 of file menu.c.

{
    ITEM *item;
    UINT i;
    INT cx, cy;
    RECT rect;
    PWND pWnd = ValidateHwndNoErr(menu->hWnd);
 
    if (!IntGetWindowRect(pWnd, &rect)) return NULL;
 
    cx = UserGetSystemMetrics(SM_CXDLGFRAME);
    cy = UserGetSystemMetrics(SM_CYDLGFRAME);
    RECTL_vInflateRect(&rect, -cx, -cy);
 
    if (pWnd->ExStyle & WS_EX_LAYOUTRTL)
       pt.x = rect.right - 1 - pt.x;
    else
       pt.x -= rect.left;
    pt.y -= rect.top;
    item = menu->rgItems;
    for (i = 0; i < menu->cItems; i++, item++)
    {
        //rect = item->rect;
        rect.left   = item->xItem;
        rect.top    = item->yItem; 
        rect.right  = item->cxItem; // Do this for now......
        rect.bottom = item->cyItem;
 
        MENU_AdjustMenuItemRect(menu, &rect);
    if (RECTL_bPointInRect(&rect, pt.x, pt.y))
    {
        if (pos) *pos = i;
        return item;
    }
    }
    return NULL;
}

Referenced by IntMenuItemFromPoint(), MENU_ButtonDown(), MENU_ButtonUp(), and MENU_MouseMove().

MENU_FindItemByKey()

static UINT FASTCALL MENU_FindItemByKey ( PWND  WndOwner, PMENU  menu, WCHAR  Key, BOOL  ForceMenuChar  )

static

Definition at line 1535 of file menu.c.

{
  LRESULT MenuChar;
  WORD Flags = 0;
 
  TRACE("\tlooking for '%c' (0x%02x) in [%p]\n", (char)Key, Key, menu );
 
  if (!menu || !VerifyMenu(menu))
     menu = co_IntGetSubMenu( UserGetMenuObject(WndOwner->SystemMenu), 0 );
  if (menu)
  {
     ITEM *item = menu->rgItems;
 
     if ( !ForceMenuChar )
     {
        UINT i;
        BOOL cjk = UserGetSystemMetrics( SM_DBCSENABLED );
 
        for (i = 0; i < menu->cItems; i++, item++)
        {
           LPWSTR text = item->Xlpstr;
           if( text)
           {
              const WCHAR *p = text - 2;
              do
              {
                 const WCHAR *q = p + 2;
                 p = wcschr (q, '&');
                 if (!p && cjk) p = wcschr (q, '\036'); /* Japanese Win16 */
              }
              while (p != NULL && p [1] == '&');
              if (p && (towupper(p[1]) == towupper(Key))) return i;
           }
        }
     }
 
     Flags |= menu->fFlags & MNF_POPUP ? MF_POPUP : 0;
     Flags |= menu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0;
 
     MenuChar = co_IntSendMessage( UserHMGetHandle(WndOwner), WM_MENUCHAR,
                              MAKEWPARAM(Key, Flags), (LPARAM) UserHMGetHandle(menu));
     if (HIWORD(MenuChar) == MNC_EXECUTE) return LOWORD(MenuChar);
     if (HIWORD(MenuChar) == MNC_CLOSE) return (UINT)(-2);
  }
  return (UINT)(-1);
}

Referenced by MENU_TrackKbdMenuBar(), and MENU_TrackMenu().

MENU_FindSubMenu()

static UINT FASTCALL MENU_FindSubMenu ( PMENU *  menu, PMENU  SubTarget  )

static

Definition at line 564 of file menu.c.

{
    UINT i;
    PITEM item;
 
    item = ((PMENU)*menu)->rgItems;
    for (i = 0; i < ((PMENU)*menu)->cItems; i++, item++)
    {
        if (!item->spSubMenu)
           continue;
        else
        {
           if (item->spSubMenu == SubTarget)
           {
              return i;
           }
           else 
           {
              PMENU pSubMenu = item->spSubMenu;
              UINT pos = MENU_FindSubMenu( &pSubMenu, SubTarget );
              if (pos != NO_SELECTED_ITEM)
              {
                  *menu = pSubMenu;
                  return pos;
              }
           }
        }
    }
    return NO_SELECTED_ITEM;
}

Referenced by IntFindSubMenu(), MENU_FindSubMenu(), and MENU_SelectItem().

MENU_GetBitmapItemSize()

static void FASTCALL MENU_GetBitmapItemSize ( PITEM  lpitem, SIZE *  size, PWND  WndOwner  )

static

Definition at line 1588 of file menu.c.

{
    BITMAP bm;
    HBITMAP bmp = lpitem->hbmp;
 
    size->cx = size->cy = 0;
 
    /* check if there is a magic menu item associated with this item */
    if (IS_MAGIC_BITMAP(bmp))
    {
      switch((INT_PTR) bmp)
        {
            case (INT_PTR)HBMMENU_CALLBACK:
            {
                MEASUREITEMSTRUCT measItem;
                measItem.CtlType = ODT_MENU;
                measItem.CtlID = 0;
                measItem.itemID = lpitem->wID;
                measItem.itemWidth  = lpitem->cxItem - lpitem->xItem; //lpitem->Rect.right  - lpitem->Rect.left;
                measItem.itemHeight = lpitem->cyItem - lpitem->yItem; //lpitem->Rect.bottom - lpitem->Rect.top;
                measItem.itemData = lpitem->dwItemData;
                co_IntSendMessage( UserHMGetHandle(WndOwner), WM_MEASUREITEM, 0, (LPARAM)&measItem);
                size->cx = measItem.itemWidth;
                size->cy = measItem.itemHeight;
                TRACE("HBMMENU_CALLBACK Height %d Width %d\n",measItem.itemHeight,measItem.itemWidth);
                return;
            }
            break;
 
          case (INT_PTR) HBMMENU_SYSTEM:
            if (lpitem->dwItemData)
              {
                bmp = (HBITMAP) lpitem->dwItemData;
                break;
              }
            /* fall through */
          case (INT_PTR) HBMMENU_MBAR_RESTORE:
          case (INT_PTR) HBMMENU_MBAR_MINIMIZE:
          case (INT_PTR) HBMMENU_MBAR_CLOSE:
          case (INT_PTR) HBMMENU_MBAR_MINIMIZE_D:
          case (INT_PTR) HBMMENU_MBAR_CLOSE_D:
          case (INT_PTR) HBMMENU_POPUP_CLOSE:
          case (INT_PTR) HBMMENU_POPUP_RESTORE:
          case (INT_PTR) HBMMENU_POPUP_MAXIMIZE:
          case (INT_PTR) HBMMENU_POPUP_MINIMIZE:
            /* FIXME: Why we need to subtract these magic values? */
            /* to make them smaller than the menu bar? */
            size->cx = UserGetSystemMetrics(SM_CXSIZE) - 2;
            size->cy = UserGetSystemMetrics(SM_CYSIZE) - 4;
            return;
        }
    }
 
    if (GreGetObject(bmp, sizeof(BITMAP), &bm))
    {
        size->cx = bm.bmWidth;
        size->cy = bm.bmHeight;
    }
}

Referenced by MENU_CalcItemSize().

MENU_GetMaxPopupHeight()

static UINT MENU_GetMaxPopupHeight ( PMENU  lppop )

static

Definition at line 1996 of file menu.c.

{
    if (lppop->cyMax)
    {
       //ERR("MGMaxPH cyMax %d\n",lppop->cyMax);
       return lppop->cyMax;
    }
    //ERR("MGMaxPH SyMax %d\n",UserGetSystemMetrics(SM_CYSCREEN) - UserGetSystemMetrics(SM_CYBORDER));
    return UserGetSystemMetrics(SM_CYSCREEN) - UserGetSystemMetrics(SM_CYBORDER);
}

Referenced by MENU_DrawScrollArrows(), MENU_EnsureMenuItemVisible(), and MENU_PopupMenuCalcSize().

MENU_GetStartOfNextColumn()

static UINT MENU_GetStartOfNextColumn ( PMENU  menu )

static

Definition at line 437 of file menu.c.

{
    PITEM pItem;
    UINT i;
 
    if(!menu)
    return NO_SELECTED_ITEM;
 
    i = menu->iItem + 1;
    if( i == NO_SELECTED_ITEM )
    return i;
 
    pItem = menu->rgItems;
    if (!pItem) return NO_SELECTED_ITEM;
 
    for( ; i < menu->cItems; ++i ) {
    if (pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
        return i;
    }
 
    return NO_SELECTED_ITEM;
}

Referenced by MENU_KeyRight().

MENU_GetStartOfPrevColumn()

static UINT MENU_GetStartOfPrevColumn ( PMENU  menu )

static

Definition at line 467 of file menu.c.

{
    UINT  i;
    PITEM pItem;
 
    if( !menu )
    return NO_SELECTED_ITEM;
 
    if( menu->iItem == 0 || menu->iItem == NO_SELECTED_ITEM )
    return NO_SELECTED_ITEM;
 
    pItem = menu->rgItems;
    if (!pItem) return NO_SELECTED_ITEM;
 
    /* Find the start of the column */
 
    for(i = menu->iItem; i != 0 &&
     !(pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK));
    --i); /* empty */
 
    if(i == 0)
    return NO_SELECTED_ITEM;
 
    for(--i; i != 0; --i) {
    if (pItem[i].fType & (MF_MENUBREAK | MF_MENUBARBREAK))
        break;
    }
 
    TRACE("ret %d.\n", i );
 
    return i;
}

Referenced by MENU_KeyLeft().

MENU_GetSubPopup()

static PMENU MENU_GetSubPopup ( PMENU  menu )

static

Definition at line 3716 of file menu.c.

{
    ITEM *item;
 
    if ((!menu) || (menu->iItem == NO_SELECTED_ITEM)) return 0;
 
    item = &menu->rgItems[menu->iItem];
    if (item && (item->spSubMenu) && (item->fState & MF_MOUSESELECT))
    {
       return item->spSubMenu;
    }
    return 0;
}

Referenced by MENU_KeyEscape(), and MENU_KeyLeft().

MENU_GetSystemMenu()

PMENU FASTCALL MENU_GetSystemMenu	(	PWND	Window,
		PMENU	Popup
	)

Definition at line 5294 of file menu.c.

{
   PMENU Menu, NewMenu = NULL, SysMenu = NULL;
   HMENU hSysMenu, hNewMenu = NULL;
   ROSMENUITEMINFO ItemInfoSet = {0};
   ROSMENUITEMINFO ItemInfo = {0};
   UNICODE_STRING MenuName;
 
   hSysMenu = UserCreateMenu(Window->head.rpdesk, FALSE);
   if (NULL == hSysMenu)
   {
      return NULL;
   }
   SysMenu = UserGetMenuObject(hSysMenu);
   if (NULL == SysMenu)
   {
       UserDestroyMenu(hSysMenu);
       return NULL;
   }
 
   SysMenu->fFlags |= MNF_SYSMENU;
   SysMenu->hWnd = UserHMGetHandle(Window);
 
   if (!Popup)
   {
      //hNewMenu = co_IntLoadSysMenuTemplate();
      if ( Window->ExStyle & WS_EX_MDICHILD )
      {
         RtlInitUnicodeString( &MenuName, L"SYSMENUMDI");
         hNewMenu = co_IntCallLoadMenu( hModClient, &MenuName);
      }
      else
      {
         RtlInitUnicodeString( &MenuName, L"SYSMENU");
         hNewMenu = co_IntCallLoadMenu( hModClient, &MenuName);
         //ERR("%wZ\n",&MenuName);
      }
      if (!hNewMenu)
      {
         ERR("No Menu!!\n");
         IntDestroyMenuObject(SysMenu, FALSE);
         return NULL;
      }
      Menu = UserGetMenuObject(hNewMenu);
      if (!Menu)
      {
         IntDestroyMenuObject(SysMenu, FALSE);
         return NULL;
      }
 
      // Do the rest in here.
 
      Menu->fFlags |= MNS_CHECKORBMP | MNF_SYSMENU  | MNF_POPUP;
 
      ItemInfoSet.cbSize = sizeof( MENUITEMINFOW);
      ItemInfoSet.fMask = MIIM_BITMAP;
      ItemInfoSet.hbmpItem = HBMMENU_POPUP_CLOSE;
      IntMenuItemInfo(Menu, SC_CLOSE, FALSE, &ItemInfoSet, TRUE, NULL);
      ItemInfoSet.hbmpItem = HBMMENU_POPUP_RESTORE;
      IntMenuItemInfo(Menu, SC_RESTORE, FALSE, &ItemInfoSet, TRUE, NULL);
      ItemInfoSet.hbmpItem = HBMMENU_POPUP_MAXIMIZE;
      IntMenuItemInfo(Menu, SC_MAXIMIZE, FALSE, &ItemInfoSet, TRUE, NULL);
      ItemInfoSet.hbmpItem = HBMMENU_POPUP_MINIMIZE;
      IntMenuItemInfo(Menu, SC_MINIMIZE, FALSE, &ItemInfoSet, TRUE, NULL);
 
      NewMenu = IntCloneMenu(Menu);
      if (NewMenu == NULL)
      {
         IntDestroyMenuObject(Menu, FALSE);
         IntDestroyMenuObject(SysMenu, FALSE);
         return NULL;
      }
 
      IntReleaseMenuObject(NewMenu);
      UserSetMenuDefaultItem(NewMenu, SC_CLOSE, FALSE);
 
      IntDestroyMenuObject(Menu, FALSE);
   }
   else
   {
      NewMenu = Popup;
   }
   if (NewMenu)
   {
      NewMenu->fFlags |= MNF_SYSMENU | MNF_POPUP;
 
      if (Window->pcls->style & CS_NOCLOSE)
         IntRemoveMenuItem(NewMenu, SC_CLOSE, MF_BYCOMMAND, TRUE);
 
      ItemInfo.cbSize = sizeof(MENUITEMINFOW);
      ItemInfo.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_SUBMENU;
      ItemInfo.fType = MF_POPUP;
      ItemInfo.fState = MFS_ENABLED;
      ItemInfo.dwTypeData = NULL;
      ItemInfo.cch = 0;
      ItemInfo.hSubMenu = UserHMGetHandle(NewMenu);
      IntInsertMenuItem(SysMenu, (UINT) -1, TRUE, &ItemInfo, NULL);
 
      return SysMenu;
   }
   ERR("failed to load system menu!\n");
   return NULL;
}

Referenced by IntGetSystemMenu(), and IntSetSystemMenu().

MENU_HideSubPopups()

static void FASTCALL MENU_HideSubPopups ( PWND  pWndOwner, PMENU  Menu, BOOL  SendMenuSelect, UINT  wFlags  )

static

Definition at line 3267 of file menu.c.

{
  TRACE("owner=%x menu=%x 0x%04x\n", pWndOwner, Menu, SendMenuSelect);
 
  if ( Menu && top_popup )
  {
      PITEM Item;
 
      if (Menu->iItem != NO_SELECTED_ITEM)
      {
         Item = &Menu->rgItems[Menu->iItem];
         if (!(Item->spSubMenu) ||
             !(Item->fState & MF_MOUSESELECT)) return;
         Item->fState &= ~MF_MOUSESELECT;
      }
      else
         return;
 
      if (Item->spSubMenu)
      {
          PWND pWnd;
          if (!VerifyMenu(Item->spSubMenu)) return;
          MENU_HideSubPopups(pWndOwner, Item->spSubMenu, FALSE, wFlags);
          MENU_SelectItem(pWndOwner, Item->spSubMenu, NO_SELECTED_ITEM, SendMenuSelect, NULL);
          TRACE("M_HSP top p hm %p  pWndOwner IDMenu %p\n",top_popup_hmenu,pWndOwner->IDMenu);
          pWnd = ValidateHwndNoErr(Item->spSubMenu->hWnd);
          if (pWnd != NULL)
          {
              co_UserDestroyWindow(pWnd);
          }
 
          /* Native returns handle to destroyed window */
          if (!(wFlags & TPM_NONOTIFY))
          {
             co_IntSendMessage( UserHMGetHandle(pWndOwner), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(Item->spSubMenu),
                                 MAKELPARAM(0, IS_SYSTEM_MENU(Item->spSubMenu) ? MF_SYSMENU : 0));
          }
          // Call WM_UNINITMENUPOPUP FIRST before destroy!!
          // Fixes todo_wine User32 test menu.c line 2239 GetMenuBarInfo callback....
          //
          Item->spSubMenu->hWnd = NULL;
      }
  }
}

Referenced by IntHiliteMenuItem(), MENU_DoNextMenu(), MENU_HideSubPopups(), MENU_KeyEscape(), MENU_KeyLeft(), MENU_KeyRight(), MENU_SwitchTracking(), and MENU_TrackMenu().

MENU_InitPopup()

static BOOL MENU_InitPopup ( PWND  pWndOwner, PMENU  menu, UINT  flags  )

static

Definition at line 2781 of file menu.c.

{
    PWND pWndCreated;
    PPOPUPMENU pPopupMenu;
    CREATESTRUCTW Cs;
    LARGE_STRING WindowName;
    UNICODE_STRING ClassName;
    DWORD ex_style = WS_EX_PALETTEWINDOW | WS_EX_DLGMODALFRAME;
 
    TRACE("owner=%p hmenu=%p\n", pWndOwner, menu);
 
    menu->spwndNotify = pWndOwner;
 
    if (flags & TPM_LAYOUTRTL || pWndOwner->ExStyle & WS_EX_LAYOUTRTL)
       ex_style |= WS_EX_LAYOUTRTL;
 
    ClassName.Buffer = WC_MENU;
    ClassName.Length = 0;
 
    RtlZeroMemory(&WindowName, sizeof(WindowName));
    RtlZeroMemory(&Cs, sizeof(Cs));
    Cs.style = WS_POPUP | WS_CLIPSIBLINGS | WS_BORDER;
    Cs.dwExStyle = ex_style;
    Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
    Cs.lpszName = (LPCWSTR) &WindowName;
    Cs.lpszClass = (LPCWSTR) &ClassName;
    Cs.lpCreateParams = UserHMGetHandle(menu);
    Cs.hwndParent = UserHMGetHandle(pWndOwner);
 
    /* NOTE: In Windows, top menu popup is not owned. */
    pWndCreated = co_UserCreateWindowEx( &Cs, &ClassName, &WindowName, NULL, WINVER );
 
    if( !pWndCreated ) return FALSE;
 
    //
    //  Setup pop up menu structure.
    //
    menu->hWnd = UserHMGetHandle(pWndCreated);
 
    pPopupMenu = ((PMENUWND)pWndCreated)->ppopupmenu;
 
    pPopupMenu->spwndActivePopup = pWndCreated; // top_popup = MenuInfo.Wnd or menu->hWnd
    pPopupMenu->spwndNotify = pWndOwner;        // Same as MenuInfo.spwndNotify(which could be wrong) or menu->hwndOwner
    //pPopupMenu->spmenu = menu; Should be set up already from WM_CREATE!
 
    pPopupMenu->fIsTrackPopup = !!(flags & TPM_POPUPMENU);
    pPopupMenu->fIsSysMenu    = !!(flags & TPM_SYSTEM_MENU);
    pPopupMenu->fNoNotify     = !!(flags & TPM_NONOTIFY);
    pPopupMenu->fRightButton  = !!(flags & TPM_RIGHTBUTTON);
    pPopupMenu->fSynchronous  = !!(flags & TPM_RETURNCMD);
 
    if (pPopupMenu->fRightButton)
       pPopupMenu->fFirstClick = !!(UserGetKeyState(VK_RBUTTON) & 0x8000);
    else
       pPopupMenu->fFirstClick = !!(UserGetKeyState(VK_LBUTTON) & 0x8000);
 
    if (gpsi->aiSysMet[SM_MENUDROPALIGNMENT] ||
        menu->fFlags & MNF_RTOL)
    {
       pPopupMenu->fDroppedLeft = TRUE;
    }
    return TRUE;
}

Referenced by IntTrackPopupMenuEx(), and MENU_ShowSubPopup().

MENU_InitSysMenuPopup()

void FASTCALL MENU_InitSysMenuPopup	(	PMENU	menu,
		DWORD	style,
		DWORD	clsStyle,
		LONG	HitTest
	)

Definition at line 1362 of file menu.c.

{
    BOOL gray;
    UINT DefItem;
 
    gray = !(style & WS_THICKFRAME) || (style & (WS_MAXIMIZE | WS_MINIMIZE));
    IntEnableMenuItem( menu, SC_SIZE, (gray ? MF_GRAYED : MF_ENABLED) );
    gray = ((style & (WS_MAXIMIZE | WS_MINIMIZE)) != 0);
    IntEnableMenuItem( menu, SC_MOVE, (gray ? MF_GRAYED : MF_ENABLED) );
    gray = !(style & WS_MINIMIZEBOX) || (style & WS_MINIMIZE);
    IntEnableMenuItem( menu, SC_MINIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
    gray = !(style & WS_MAXIMIZEBOX) || (style & WS_MAXIMIZE);
    IntEnableMenuItem( menu, SC_MAXIMIZE, (gray ? MF_GRAYED : MF_ENABLED) );
    gray = !(style & (WS_MAXIMIZE | WS_MINIMIZE));
    IntEnableMenuItem( menu, SC_RESTORE, (gray ? MF_GRAYED : MF_ENABLED) );
    gray = (clsStyle & CS_NOCLOSE) != 0;
 
    /* The menu item must keep its state if it's disabled */
    if(gray)
        IntEnableMenuItem( menu, SC_CLOSE, MF_GRAYED);
 
    /* Set default menu item */
    if(style & WS_MINIMIZE) DefItem = SC_RESTORE;
    else if(HitTest == HTCAPTION) DefItem = ((style & (WS_MAXIMIZE | WS_MINIMIZE)) ? SC_RESTORE : SC_MAXIMIZE);
    else DefItem = SC_CLOSE;
 
    UserSetMenuDefaultItem(menu, DefItem, MF_BYCOMMAND);
}

Referenced by IntDefWindowProc(), IntTrackPopupMenuEx(), and MENU_ShowSubPopup().

MENU_InitTracking()

static BOOL FASTCALL MENU_InitTracking ( PWND  pWnd, PMENU  Menu, BOOL  bPopup, UINT  wFlags  )

static

Definition at line 4404 of file menu.c.

{
    HWND capture_win;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    TRACE("hwnd=%p hmenu=%p\n", UserHMGetHandle(pWnd), UserHMGetHandle(Menu));
 
    co_UserHideCaret(0);
 
    /* This makes the menus of applications built with Delphi work.
     * It also enables menus to be displayed in more than one window,
     * but there are some bugs left that need to be fixed in this case.
     */
    if (!bPopup)
    {
        Menu->hWnd = UserHMGetHandle(pWnd);
    }
 
    if (!top_popup) {
       top_popup = Menu->hWnd;
       top_popup_hmenu = UserHMGetHandle(Menu);
    }
 
    fInsideMenuLoop = TRUE;
    fInEndMenu = FALSE;
 
    /* Send WM_ENTERMENULOOP and WM_INITMENU message only if TPM_NONOTIFY flag is not specified */
    if (!(wFlags & TPM_NONOTIFY))
    {
       co_IntSendMessage( UserHMGetHandle(pWnd), WM_ENTERMENULOOP, bPopup, 0 );
    }
 
    //
    // Capture is set before calling WM_INITMENU and after WM_ENTERMENULOOP, see msg_menu.
    //
    capture_win = (wFlags & TPM_POPUPMENU) ? Menu->hWnd : UserHMGetHandle(pWnd);
    MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, capture_win); // 1
    co_UserSetCapture(capture_win);                           // 2
    pti->MessageQueue->QF_flags |= QF_CAPTURELOCKED; // Set the Q bits so noone can change this!
 
    co_IntSendMessage( UserHMGetHandle(pWnd), WM_SETCURSOR, (WPARAM)UserHMGetHandle(pWnd), HTCAPTION );
 
    if (!(wFlags & TPM_NONOTIFY))
    {
       co_IntSendMessage( UserHMGetHandle(pWnd), WM_INITMENU, (WPARAM)UserHMGetHandle(Menu), 0 );
       /* If an app changed/recreated menu bar entries in WM_INITMENU
        * menu sizes will be recalculated once the menu created/shown.
        */
    }
 
    IntNotifyWinEvent( EVENT_SYSTEM_MENUSTART,
                       pWnd,
                       Menu->fFlags & MNF_SYSMENU ? OBJID_SYSMENU : OBJID_MENU,
                       CHILDID_SELF, 0);
    return TRUE;
}

Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().

MENU_InsertItem()

ITEM * MENU_InsertItem	(	PMENU	menu,
		UINT	pos,
		UINT	flags,
		PMENU *	submenu,
		UINT *	npos
	)

Definition at line 639 of file menu.c.

{
    ITEM *newItems;
 
    /* Find where to insert new item */
 
    if (flags & MF_BYPOSITION) {
        if (pos > menu->cItems)
            pos = menu->cItems;
    } else {
        if (!MENU_FindItem( &menu, &pos, flags ))
        {
            if (submenu) *submenu = menu;
            if (npos) *npos = pos;
            pos = menu->cItems;
        }
    }
 
    /* Make sure that MDI system buttons stay on the right side.
     * Note: XP treats only bitmap handles 1 - 6 as "magic" ones
     * regardless of their id.
     */
    while ( pos > 0 &&
           (INT_PTR)menu->rgItems[pos - 1].hbmp >= (INT_PTR)HBMMENU_SYSTEM &&
           (INT_PTR)menu->rgItems[pos - 1].hbmp <= (INT_PTR)HBMMENU_MBAR_CLOSE_D)
        pos--;
 
    TRACE("inserting at %u flags %x\n", pos, flags);
 
    /* Create new items array */
 
    newItems = DesktopHeapAlloc(menu->head.rpdesk, sizeof(ITEM) * (menu->cItems+1) );
    if (!newItems)
    {
        WARN("allocation failed\n" );
        return NULL;
    }
    if (menu->cItems > 0)
    {
       /* Copy the old array into the new one */
       if (pos > 0) RtlCopyMemory( newItems, menu->rgItems, pos * sizeof(ITEM) );
       if (pos < menu->cItems) RtlCopyMemory( &newItems[pos+1], &menu->rgItems[pos], (menu->cItems-pos)*sizeof(ITEM) );
       DesktopHeapFree(menu->head.rpdesk, menu->rgItems );
    }
    menu->rgItems = newItems;
    menu->cItems++;
    RtlZeroMemory( &newItems[pos], sizeof(*newItems) );
    menu->cyMenu = 0; /* force size recalculate */
    return &newItems[pos];
}

Referenced by IntInsertMenuItem().

MENU_IsMenuActive()

PWND MENU_IsMenuActive

(

VOID

)

Definition at line 2650 of file menu.c.

{
   return ValidateHwndNoErr(top_popup);
}

Referenced by IntDefWindowProc().

MENU_KeyEscape()

static BOOL FASTCALL MENU_KeyEscape ( MTRACKER *  pmt, UINT  Flags  )

static

Definition at line 3913 of file menu.c.

{
  BOOL EndMenu = TRUE;
 
  if (pmt->CurrentMenu != pmt->TopMenu)
  {
      if (pmt->CurrentMenu && (pmt->CurrentMenu->fFlags & MNF_POPUP))
      {
          PMENU MenuPrev, MenuTmp;
 
          MenuPrev = MenuTmp = pmt->TopMenu;
 
          /* close topmost popup */
          while (MenuTmp != pmt->CurrentMenu)
          {
              MenuPrev = MenuTmp;
              MenuTmp = MENU_GetSubPopup(MenuPrev);
          }
 
          MENU_HideSubPopups(pmt->OwnerWnd, MenuPrev, TRUE, Flags);
          pmt->CurrentMenu = MenuPrev;
          EndMenu = FALSE;
      }
  }
 
  return EndMenu;
}

Referenced by MENU_TrackMenu().

MENU_KeyLeft()

static void FASTCALL MENU_KeyLeft ( MTRACKER *  pmt, UINT  Flags, UINT  msg  )

static

Definition at line 3946 of file menu.c.

{
  PMENU MenuTmp, MenuPrev;
  UINT PrevCol;
 
  MenuPrev = MenuTmp = pmt->TopMenu;
 
  /* Try to move 1 column left (if possible) */
  if ( (PrevCol = MENU_GetStartOfPrevColumn(pmt->CurrentMenu)) != NO_SELECTED_ITEM)
  {
     MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, PrevCol, TRUE, 0);
     return;
  }
 
  /* close topmost popup */
  while (MenuTmp != pmt->CurrentMenu)
  {
      MenuPrev = MenuTmp;
      MenuTmp = MENU_GetSubPopup(MenuPrev);
  }
 
  MENU_HideSubPopups(pmt->OwnerWnd, MenuPrev, TRUE, Flags);
  pmt->CurrentMenu = MenuPrev;
 
  if ((MenuPrev == pmt->TopMenu) && !(pmt->TopMenu->fFlags & MNF_POPUP))
  {
      /* move menu bar selection if no more popups are left */
 
      if (!MENU_DoNextMenu(pmt, VK_LEFT, Flags))
          MENU_MoveSelection(pmt->OwnerWnd, pmt->TopMenu, ITEM_PREV);
 
      if (MenuPrev != MenuTmp || pmt->TrackFlags & TF_SUSPENDPOPUP)
      {
          /* A sublevel menu was displayed - display the next one
           * unless there is another displacement coming up */
 
          if (!MENU_SuspendPopup(pmt, msg))
              pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, pmt->TopMenu,
                                                 TRUE, Flags);
      }
  }
}

Referenced by MENU_TrackMenu().

MENU_KeyRight()

static void FASTCALL MENU_KeyRight ( MTRACKER *  pmt, UINT  Flags, UINT  msg  )

static

Definition at line 3994 of file menu.c.

{
    PMENU menutmp;
    UINT NextCol;
 
    TRACE("MenuKeyRight called, cur %p, top %p.\n",
         pmt->CurrentMenu, pmt->TopMenu);
 
    if ((pmt->TopMenu->fFlags & MNF_POPUP) || (pmt->CurrentMenu != pmt->TopMenu))
    {
      /* If already displaying a popup, try to display sub-popup */
 
      menutmp = pmt->CurrentMenu;
      pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, menutmp, TRUE, Flags);
 
      /* if subpopup was displayed then we are done */
      if (menutmp != pmt->CurrentMenu) return;
    }
 
    /* Check to see if there's another column */
    if ( (NextCol = MENU_GetStartOfNextColumn(pmt->CurrentMenu)) != NO_SELECTED_ITEM)
    {
       TRACE("Going to %d.\n", NextCol);
       MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, NextCol, TRUE, 0);
       return;
    }
 
    if (!(pmt->TopMenu->fFlags & MNF_POPUP)) /* menu bar tracking */
    {
       if (pmt->CurrentMenu != pmt->TopMenu)
       {
          MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, Flags);
          menutmp = pmt->CurrentMenu = pmt->TopMenu;
       }
       else
       {
          menutmp = NULL;
       }
 
       /* try to move to the next item */
       if ( !MENU_DoNextMenu(pmt, VK_RIGHT, Flags))
           MENU_MoveSelection(pmt->OwnerWnd, pmt->TopMenu, ITEM_NEXT);
 
       if ( menutmp || pmt->TrackFlags & TF_SUSPENDPOPUP )
       {
           if ( !MENU_SuspendPopup(pmt, msg) )
               pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, pmt->TopMenu, TRUE, Flags);
       }
    }
}

Referenced by MENU_TrackMenu().

MENU_MenuBarCalcSize()

static void MENU_MenuBarCalcSize ( HDC  hdc, LPRECT  lprect, PMENU  lppop, PWND  pwndOwner  )

static

Definition at line 2101 of file menu.c.

{
    ITEM *lpitem;
    UINT start, i, helpPos;
    int orgX, orgY, maxY;
 
    if ((lprect == NULL) || (lppop == NULL)) return;
    if (lppop->cItems == 0) return;
    //TRACE("lprect %p %s\n", lprect, wine_dbgstr_rect( lprect));
    lppop->cxMenu  = lprect->right - lprect->left;
    lppop->cyMenu = 0;
    maxY = lprect->top;
    start = 0;
    helpPos = ~0U;
    lppop->cxTextAlign = 0;
    while (start < lppop->cItems)
    {
    lpitem = &lppop->rgItems[start];
    orgX = lprect->left;
    orgY = maxY;
 
      /* Parse items until line break or end of menu */
    for (i = start; i < lppop->cItems; i++, lpitem++)
    {
        if ((helpPos == ~0U) && (lpitem->fType & MF_RIGHTJUSTIFY)) helpPos = i;
        if ((i != start) &&
        (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
 
        TRACE("calling MENU_CalcItemSize org=(%d, %d)\n", orgX, orgY );
        //debug_print_menuitem ("  item: ", lpitem, "");
        //MENU_CalcItemSize( hdc, lpitem, pwndOwner, orgX, orgY, TRUE, lppop );
            MENU_CalcItemSize(hdc, lpitem, lppop, pwndOwner, orgX, orgY, TRUE, FALSE);
 
        if (lpitem->cxItem > lprect->right)
        {
        if (i != start) break;
        else lpitem->cxItem = lprect->right;
        }
        maxY = max( maxY, lpitem->cyItem );
        orgX = lpitem->cxItem;
    }
 
      /* Finish the line (set all items to the largest height found) */
 
/* FIXME: Is this really needed? */ /*NO! it is not needed, why make the
   HBMMENU_MBAR_CLOSE, MINIMIZE & RESTORE, look the same size as the menu bar! */
#if 0
    while (start < i) lppop->rgItems[start++].cyItem = maxY;
#endif
    start = i; /* This works! */
    }
 
    lprect->bottom = maxY + 1;
    lppop->cyMenu = lprect->bottom - lprect->top;
 
    /* Flush right all items between the MF_RIGHTJUSTIFY and */
    /* the last item (if several lines, only move the last line) */
    if (helpPos == ~0U) return;
    lpitem = &lppop->rgItems[lppop->cItems-1];
    orgY = lpitem->yItem;
    orgX = lprect->right;
    for (i = lppop->cItems - 1; i >= helpPos; i--, lpitem--) {
        if (lpitem->yItem != orgY) break;   /* Other line */
        if (lpitem->cxItem >= orgX) break;  /* Too far right already */
        lpitem->xItem += orgX - lpitem->cxItem;
        lpitem->cxItem = orgX;
        orgX = lpitem->xItem;
    }
}

Referenced by IntDrawMenuBarTemp(), and MENU_DrawMenuBar().

MENU_MouseMove()

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

static

Definition at line 3692 of file menu.c.

{
  UINT Index = NO_SELECTED_ITEM;
 
  if ( PtMenu )
      MENU_FindItemByCoords( PtMenu, pmt->Pt, &Index );
 
  if (Index == NO_SELECTED_ITEM)
  {
      MENU_SelectItem(pmt->OwnerWnd, pmt->CurrentMenu, NO_SELECTED_ITEM, TRUE, pmt->TopMenu);
  }
  else if (PtMenu->iItem != Index)
  {
      MENU_SwitchTracking(pmt, PtMenu, Index, Flags);
      pmt->CurrentMenu = MENU_ShowSubPopup(pmt->OwnerWnd, PtMenu, FALSE, Flags);
  }
  return TRUE;
}

Referenced by MENU_TrackMenu().

MENU_MoveRect()

static BOOL MENU_MoveRect ( UINT  flags, INT *  x, INT *  y, INT  width, INT  height, const RECT *  pExclude, PMONITOR  monitor  )

static

Definition at line 2888 of file menu.c.

{
    /* Figure out if we should move vertical or horizontal */
    if (flags & TPM_VERTICAL)
    {
        /* Move in the vertical direction: TPM_BOTTOMALIGN means drop it above, otherways drop it below */
        if (flags & TPM_BOTTOMALIGN)
        {
            if (pExclude->top - height >= monitor->rcMonitor.top)
            {
                *y = pExclude->top - height;
                return TRUE;
            }
        }
        else
        {
            if (pExclude->bottom + height < monitor->rcMonitor.bottom)
            {
                *y = pExclude->bottom;
                return TRUE;
            }
        }
    }
    else
    {
        /* Move in the horizontal direction: TPM_RIGHTALIGN means drop it to the left, otherways go right */
        if (flags & TPM_RIGHTALIGN)
        {
            if (pExclude->left - width >= monitor->rcMonitor.left)
            {
                *x = pExclude->left - width;
                return TRUE;
            }
        }
        else
        {
            if (pExclude->right + width < monitor->rcMonitor.right)
            {
                *x = pExclude->right;
                return TRUE;
            }
        }
    }
    return FALSE;
}

Referenced by MENU_ShowPopup().

MENU_MoveSelection()

static void FASTCALL MENU_MoveSelection ( PWND  pwndOwner, PMENU  menu, INT  offset  )

static

Definition at line 3231 of file menu.c.

{
    INT i;
 
    TRACE("pwnd=%x menu=%x off=0x%04x\n", pwndOwner, menu, offset);
 
    if ((!menu) || (!menu->rgItems)) return;
 
    if ( menu->iItem != NO_SELECTED_ITEM )
    {
    if ( menu->cItems == 1 )
       return;
    else
    for (i = menu->iItem + offset ; i >= 0 && i < menu->cItems
                        ; i += offset)
        if (!(menu->rgItems[i].fType & MF_SEPARATOR))
        {
        MENU_SelectItem( pwndOwner, menu, i, TRUE, 0 );
        return;
        }
    }
 
    for ( i = (offset > 0) ? 0 : menu->cItems - 1;
          i >= 0 && i < menu->cItems ; i += offset)
    if (!(menu->rgItems[i].fType & MF_SEPARATOR))
    {
        MENU_SelectItem( pwndOwner, menu, i, TRUE, 0 );
        return;
    }
}

Referenced by MENU_KeyLeft(), MENU_KeyRight(), MENU_ShowSubPopup(), MENU_TrackKbdMenuBar(), and MENU_TrackMenu().

MENU_PopupMenuCalcSize()

static void FASTCALL MENU_PopupMenuCalcSize ( PMENU  Menu, PWND  WndOwner  )

static

Definition at line 2012 of file menu.c.

{
    PITEM lpitem;
    HDC hdc;
    int start, i;
    int orgX, orgY, maxX, maxTab, maxTabWidth, maxHeight;
    BOOL textandbmp = FALSE;
 
    Menu->cxMenu = Menu->cyMenu = 0;
    if (Menu->cItems == 0) return;
 
    hdc = UserGetDCEx(NULL, NULL, DCX_CACHE);
 
    NtGdiSelectFont( hdc, ghMenuFont );
 
    start = 0;
    maxX = 0;
 
    Menu->cxTextAlign = 0;
 
    while (start < Menu->cItems)
    {
      lpitem = &Menu->rgItems[start];
      orgX = maxX;
      if( lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))
          orgX += MENU_COL_SPACE;
      orgY = 0;
 
      maxTab = maxTabWidth = 0;
      /* Parse items until column break or end of menu */
      for (i = start; i < Menu->cItems; i++, lpitem++)
      {
          if (i != start &&
               (lpitem->fType & (MF_MENUBREAK | MF_MENUBARBREAK))) break;
 
          MENU_CalcItemSize(hdc, lpitem, Menu, WndOwner, orgX, orgY, FALSE, textandbmp);
          maxX = max(maxX, lpitem->cxItem);
          orgY = lpitem->cyItem;
          if (IS_STRING_ITEM(lpitem->fType) && lpitem->dxTab )
          {
              maxTab = max( maxTab, lpitem->dxTab );
              maxTabWidth = max(maxTabWidth, lpitem->cxItem - lpitem->dxTab);
          }
          if( lpitem->Xlpstr && lpitem->hbmp) textandbmp = TRUE;
      }
 
        /* Finish the column (set all items to the largest width found) */
      maxX = max( maxX, maxTab + maxTabWidth );
      for (lpitem = &Menu->rgItems[start]; start < i; start++, lpitem++)
      {
          lpitem->cxItem = maxX;
           if (IS_STRING_ITEM(lpitem->fType) && lpitem->dxTab)
               lpitem->dxTab = maxTab;
      }
      Menu->cyMenu = max(Menu->cyMenu, orgY);
    }
 
    Menu->cxMenu  = maxX;
    /* if none of the items have both text and bitmap then
     * the text and bitmaps are all aligned on the left. If there is at
     * least one item with both text and bitmap then bitmaps are
     * on the left and texts left aligned with the right hand side
     * of the bitmaps */
    if( !textandbmp) Menu->cxTextAlign = 0;
 
    /* Adjust popup height if it exceeds maximum */
    maxHeight = MENU_GetMaxPopupHeight(Menu);
    Menu->iMaxTop = Menu->cyMenu;
    if (Menu->cyMenu >= maxHeight)
    {
       Menu->cyMenu = maxHeight;
       Menu->dwArrowsOn = 1;
    }
    else
    {   
       Menu->dwArrowsOn = 0;
    }
    UserReleaseDC( 0, hdc, FALSE );
}

Referenced by MENU_ShowPopup().

MENU_PtMenu()

static PMENU FASTCALL MENU_PtMenu ( PMENU  menu, POINT  pt  )

static

Definition at line 3652 of file menu.c.

{
  PITEM pItem;
  PMENU ret = NULL;
 
  if (!menu) return NULL;
 
  /* try subpopup first (if any) */
  if (menu->iItem != NO_SELECTED_ITEM)
  {
     pItem = menu->rgItems;
     if ( pItem ) pItem = &pItem[menu->iItem];
     if ( pItem && pItem->spSubMenu && pItem->fState & MF_MOUSESELECT)
     {
        ret = MENU_PtMenu( pItem->spSubMenu, pt);
     }
  }
 
  /* check the current window (avoiding WM_HITTEST) */
  if (!ret)
  {
     PWND pWnd = ValidateHwndNoErr(menu->hWnd);
     INT ht = GetNCHitEx(pWnd, pt);
     if ( menu->fFlags & MNF_POPUP )
     {
        if (ht != HTNOWHERE && ht != HTERROR) ret = menu;
     }
     else if (ht == HTSYSMENU)
        ret = get_win_sys_menu(menu->hWnd);
     else if (ht == HTMENU)
        ret = IntGetMenu( menu->hWnd );
  }
  return ret;
}

Referenced by MENU_PtMenu(), and MENU_TrackMenu().

MENU_SelectItem()

static void FASTCALL MENU_SelectItem ( PWND  pwndOwner, PMENU  menu, UINT  wIndex, BOOL  sendMenuSelect, PMENU  topmenu  )

static

Definition at line 3144 of file menu.c.

{
    HDC hdc;
    PWND pWnd;
 
    TRACE("M_SI: owner=%p menu=%p index=0x%04x select=0x%04x\n", pwndOwner, menu, wIndex, sendMenuSelect);
 
    if (!menu || !menu->cItems) return;
 
    pWnd = ValidateHwndNoErr(menu->hWnd);
 
    if (!pWnd) return;
 
    if (menu->iItem == wIndex) return;
 
    if (menu->fFlags & MNF_POPUP)
       hdc = UserGetDCEx(pWnd, 0, DCX_USESTYLE);
    else
       hdc = UserGetDCEx(pWnd, 0, DCX_CACHE | DCX_WINDOW);
 
    if (!top_popup) {
        top_popup = menu->hWnd;                  //pPopupMenu->spwndActivePopup or
                                                 //pPopupMenu->fIsTrackPopup set pPopupMenu->spwndPopupMenu;
        top_popup_hmenu = UserHMGetHandle(menu); //pPopupMenu->spmenu
    }
 
    NtGdiSelectFont( hdc, ghMenuFont );
 
     /* Clear previous highlighted item */
    if (menu->iItem != NO_SELECTED_ITEM)
    {
        menu->rgItems[menu->iItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
        MENU_DrawMenuItem(pWnd, menu, pwndOwner, hdc, &menu->rgItems[menu->iItem],
                       menu->cyMenu, !(menu->fFlags & MNF_POPUP),
                       ODA_SELECT);
    }
 
    /* Highlight new item (if any) */
    menu->iItem = wIndex;
    if (menu->iItem != NO_SELECTED_ITEM)
    {
        if (!(menu->rgItems[wIndex].fType & MF_SEPARATOR))
        {
             menu->rgItems[wIndex].fState |= MF_HILITE;
             MENU_EnsureMenuItemVisible(menu, wIndex, hdc);
             MENU_DrawMenuItem(pWnd, menu, pwndOwner, hdc,
                               &menu->rgItems[wIndex], menu->cyMenu, !(menu->fFlags & MNF_POPUP), ODA_SELECT);
        }
        if (sendMenuSelect)
        {
           ITEM *ip = &menu->rgItems[menu->iItem];
           WPARAM wParam = MAKEWPARAM( ip->spSubMenu ? wIndex : ip->wID, 
                                       ip->fType | ip->fState |
                                      (ip->spSubMenu ? MF_POPUP : 0) |
                                      (menu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0 ) );
 
           co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(menu));
        }
    }
    else if (sendMenuSelect) 
    {
        if (topmenu) 
        {
            int pos;
            pos = MENU_FindSubMenu(&topmenu, menu);
            if (pos != NO_SELECTED_ITEM)
            {
               ITEM *ip = &topmenu->rgItems[pos];
               WPARAM wParam = MAKEWPARAM( Pos, ip->fType | ip->fState |
                                           (ip->spSubMenu ? MF_POPUP : 0) |
                                           (topmenu->fFlags & MNF_SYSMENU ? MF_SYSMENU : 0 ) );
 
               co_IntSendMessage(UserHMGetHandle(pwndOwner), WM_MENUSELECT, wParam, (LPARAM) UserHMGetHandle(topmenu));
            }
        }
    }
    UserReleaseDC(pWnd, hdc, FALSE);
}

Referenced by IntHiliteMenuItem(), MENU_DoNextMenu(), MENU_HideSubPopups(), MENU_KeyLeft(), MENU_KeyRight(), MENU_MouseMove(), MENU_MoveSelection(), MENU_SwitchTracking(), MENU_TrackKbdMenuBar(), and MENU_TrackMenu().

MENU_ShowPopup()

static BOOL FASTCALL MENU_ShowPopup ( PWND  pwndOwner, PMENU  menu, UINT  id, UINT  flags, INT  x, INT  y, const RECT *  pExclude  )

static

Definition at line 2939 of file menu.c.

{
    INT width, height;
    POINT ptx;
    PMONITOR monitor;
    PWND pWnd;
    USER_REFERENCE_ENTRY Ref;
    BOOL bIsPopup = (flags & TPM_POPUPMENU) != 0;
 
    TRACE("owner=%p menu=%p id=0x%04x x=0x%04x y=0x%04x\n",
          pwndOwner, menu, id, x, y);
 
    if (menu->iItem != NO_SELECTED_ITEM)
    {
        menu->rgItems[menu->iItem].fState &= ~(MF_HILITE|MF_MOUSESELECT);
        menu->iItem = NO_SELECTED_ITEM;
    }
 
#if SHOW_DEBUGRECT
    if (pExclude)
        DebugRect(pExclude, RGB(255, 0, 0));
#endif
 
    menu->dwArrowsOn = 0;
    MENU_PopupMenuCalcSize(menu, pwndOwner);
 
    /* adjust popup menu pos so that it fits within the desktop */
 
    width = menu->cxMenu + UserGetSystemMetrics(SM_CXDLGFRAME) * 2;
    height = menu->cyMenu + UserGetSystemMetrics(SM_CYDLGFRAME) * 2;
 
    if (flags & TPM_LAYOUTRTL)
        flags ^= TPM_RIGHTALIGN;
 
    if (flags & TPM_RIGHTALIGN)
        x -= width;
    if (flags & TPM_CENTERALIGN)
        x -= width / 2;
 
    if (flags & TPM_BOTTOMALIGN)
        y -= height;
    if (flags & TPM_VCENTERALIGN)
        y -= height / 2;
 
    /* FIXME: should use item rect */
    ptx.x = x;
    ptx.y = y;
#if SHOW_DEBUGRECT
    DebugPoint(x, y, RGB(0, 0, 255));
#endif
    monitor = UserMonitorFromPoint( ptx, MONITOR_DEFAULTTONEAREST );
 
    /* We are off the right side of the screen */
    if (x + width > monitor->rcMonitor.right)
    {
        /* Position menu at right edge of the screen */
        x = monitor->rcMonitor.right - width;
    }
 
    /* We are off the left side of the screen */
    if (x < monitor->rcMonitor.left)
    {
        /* Position menu at left edge of the screen */
        x = 0;
 
        if (x < monitor->rcMonitor.left || x >= monitor->rcMonitor.right || bIsPopup)
            x = monitor->rcMonitor.left;
    }
 
    /* Same here, but then the top */
    if (y < monitor->rcMonitor.top)
    {
        y += height;
 
        if (y < monitor->rcMonitor.top || y >= monitor->rcMonitor.bottom || bIsPopup)
            y = monitor->rcMonitor.top;
    }
 
    /* And the bottom */
    if (y + height > monitor->rcMonitor.bottom)
    {
        if ((y - height) < monitor->rcMonitor.top || y >= monitor->rcMonitor.bottom)
            y = monitor->rcMonitor.bottom - height;
        else
        {
            INT adjHgt = y + UserGetSystemMetrics(SM_CYMENUSIZE) +
                         2 * UserGetSystemMetrics(SM_CYDLGFRAME);
            if (adjHgt >= monitor->rcMonitor.bottom)
                y -= height;
            else
                y = adjHgt - height;
        }
    }
 
    if (pExclude)
    {
        RECT Cleaned;
 
        if (RECTL_bIntersectRect(&Cleaned, pExclude, &monitor->rcMonitor) &&
            RECTL_Intersect(&Cleaned, x, y, width, height))
        {
            UINT flag_mods[] = {
                0,                                                  /* First try the 'normal' way */
                TPM_BOTTOMALIGN | TPM_RIGHTALIGN,                   /* Then try the opposite side */
                TPM_VERTICAL,                                       /* Then swap horizontal / vertical */
                TPM_BOTTOMALIGN | TPM_RIGHTALIGN | TPM_VERTICAL,    /* Then the other side again (still swapped hor/ver) */
            };
 
            UINT n;
            for (n = 0; n < RTL_NUMBER_OF(flag_mods); ++n)
            {
                INT tx = x;
                INT ty = y;
 
                /* Try to move a bit around */
                if (MENU_MoveRect(flags ^ flag_mods[n], &tx, &ty, width, height, &Cleaned, monitor) &&
                    !RECTL_Intersect(&Cleaned, tx, ty, width, height))
                {
                    x = tx;
                    y = ty;
                    break;
                }
            }
            /* If none worked, we go with the original x/y */
        }
    }
 
#if SHOW_DEBUGRECT
    {
        RECT rr = {x, y, x + width, y + height};
        DebugRect(&rr, RGB(0, 255, 0));
    }
#endif
 
    pWnd = ValidateHwndNoErr( menu->hWnd );
 
    if (!pWnd)
    {
       ERR("menu->hWnd bad hwnd %p\n",menu->hWnd);
       return FALSE;
    }
 
    if (!top_popup) {
        top_popup = menu->hWnd;
        top_popup_hmenu = UserHMGetHandle(menu);
    }
 
    /* Display the window */
    UserRefObjectCo(pWnd, &Ref);
    co_WinPosSetWindowPos( pWnd, HWND_TOPMOST, x, y, width, height, SWP_SHOWWINDOW | SWP_NOACTIVATE);
 
    co_IntUpdateWindows(pWnd, RDW_ALLCHILDREN, FALSE);
 
    IntNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPSTART, pWnd, OBJID_CLIENT, CHILDID_SELF, 0);
    UserDerefObjectCo(pWnd);
 
    return TRUE;
}

Referenced by IntTrackPopupMenuEx(), and MENU_ShowSubPopup().

MENU_ShowSubPopup()

static PMENU FASTCALL MENU_ShowSubPopup ( PWND  WndOwner, PMENU  Menu, BOOL  SelectFirst, UINT  Flags  )

static

Definition at line 3321 of file menu.c.

{
  RECT Rect, ParentRect;
  ITEM *Item;
  HDC Dc;
  PWND pWnd;
 
  TRACE("owner=%x menu=%p 0x%04x\n", WndOwner, Menu, SelectFirst);
 
  if (!Menu) return Menu;
 
  if (Menu->iItem == NO_SELECTED_ITEM) return Menu;
  
  Item = &Menu->rgItems[Menu->iItem];
  if (!(Item->spSubMenu) || (Item->fState & (MF_GRAYED | MF_DISABLED)))
      return Menu;
 
  /* message must be sent before using item,
     because nearly everything may be changed by the application ! */
 
  /* Send WM_INITMENUPOPUP message only if TPM_NONOTIFY flag is not specified */
  if (!(Flags & TPM_NONOTIFY))
  {
      co_IntSendMessage(UserHMGetHandle(WndOwner), WM_INITMENUPOPUP,
                        (WPARAM) UserHMGetHandle(Item->spSubMenu),
                         MAKELPARAM(Menu->iItem, IS_SYSTEM_MENU(Menu)));
  }
 
  Item = &Menu->rgItems[Menu->iItem];
  //Rect = ItemInfo.Rect;
  Rect.left   = Item->xItem;
  Rect.top    = Item->yItem;
  Rect.right  = Item->cxItem; // Do this for now......
  Rect.bottom = Item->cyItem;
 
  pWnd = ValidateHwndNoErr(Menu->hWnd);
 
  /* Grab the rect of our (entire) parent menu, so we can try to not overlap it */
  if (Menu->fFlags & MNF_POPUP)
  {
    if (!IntGetWindowRect(pWnd, &ParentRect))
    {
        ERR("No pWnd\n");
        ParentRect = Rect;
    }
 
    /* Ensure we can slightly overlap our parent */
    RECTL_vInflateRect(&ParentRect, -UserGetSystemMetrics(SM_CXEDGE) * 2, 0);
  }
  else
  {
    /* Inside the menu bar, we do not want to grab the entire window... */
    ParentRect = Rect;
    if (pWnd)
        RECTL_vOffsetRect(&ParentRect, pWnd->rcWindow.left, pWnd->rcWindow.top);
  }
 
  /* correct item if modified as a reaction to WM_INITMENUPOPUP message */
  if (!(Item->fState & MF_HILITE))
  {
      if (Menu->fFlags & MNF_POPUP) Dc = UserGetDCEx(pWnd, NULL, DCX_USESTYLE);
      else Dc = UserGetDCEx(pWnd, 0, DCX_CACHE | DCX_WINDOW);
 
      NtGdiSelectFont(Dc, ghMenuFont);
 
      Item->fState |= MF_HILITE;
      MENU_DrawMenuItem(pWnd, Menu, WndOwner, Dc, Item, Menu->cyMenu,
                       !(Menu->fFlags & MNF_POPUP), ODA_DRAWENTIRE);
 
      UserReleaseDC(pWnd, Dc, FALSE);
  }
 
  if (!Item->yItem && !Item->xItem && !Item->cyItem && !Item->cxItem)
  {
      Item->xItem  = Rect.left; 
      Item->yItem  = Rect.top;  
      Item->cxItem = Rect.right; // Do this for now...... 
      Item->cyItem = Rect.bottom;
  }
  Item->fState |= MF_MOUSESELECT;
 
  if (IS_SYSTEM_MENU(Menu) && !(Menu->fFlags & MNF_POPUP))
  {
      MENU_InitSysMenuPopup(Item->spSubMenu, pWnd->style, pWnd->pcls->style, HTSYSMENU);
 
      NC_GetSysPopupPos(pWnd, &Rect);
      /* Ensure we do not overlap this */
      ParentRect = Rect;
      if (Flags & TPM_LAYOUTRTL) Rect.left = Rect.right;
      Rect.top = Rect.bottom;
      Rect.right = UserGetSystemMetrics(SM_CXSIZE);
      Rect.bottom = UserGetSystemMetrics(SM_CYSIZE);
  }
  else
  {
      IntGetWindowRect(pWnd, &Rect);
      if (Menu->fFlags & MNF_POPUP)
      {
          RECT rc;
          rc.left   = Item->xItem;
          rc.top    = Item->yItem;
          rc.right  = Item->cxItem;
          rc.bottom = Item->cyItem;
 
          MENU_AdjustMenuItemRect(Menu, &rc);
 
          /* The first item in the popup menu has to be at the
             same y position as the focused menu item */
          if(Flags & TPM_LAYOUTRTL)
             Rect.left += UserGetSystemMetrics(SM_CXDLGFRAME);
          else
             Rect.left += rc.right - UserGetSystemMetrics(SM_CXDLGFRAME);
 
          Rect.top += rc.top;
      }
      else
      {
          if(Flags & TPM_LAYOUTRTL)
              Rect.left += Rect.right - Item->xItem; //ItemInfo.Rect.left;
          else
              Rect.left += Item->xItem; //ItemInfo.Rect.left;
          Rect.top += Item->cyItem; //ItemInfo.Rect.bottom;
          Rect.right  = Item->cxItem - Item->xItem; //ItemInfo.Rect.right - ItemInfo.Rect.left;
          Rect.bottom = Item->cyItem - Item->yItem; //ItemInfo.Rect.bottom - ItemInfo.Rect.top;
      }
  }
 
  /* Next menu does not need to be shown vertical anymore */
  if (Menu->fFlags & MNF_POPUP)
      Flags &= (~TPM_VERTICAL);
 
 
 
  /* use default alignment for submenus */
  Flags &= ~(TPM_CENTERALIGN | TPM_RIGHTALIGN | TPM_VCENTERALIGN | TPM_BOTTOMALIGN);
 
  MENU_InitPopup( WndOwner, Item->spSubMenu, Flags );
 
  MENU_ShowPopup( WndOwner, Item->spSubMenu, Menu->iItem, Flags,
                Rect.left, Rect.top, &ParentRect);
  if (SelectFirst)
  {
      MENU_MoveSelection(WndOwner, Item->spSubMenu, ITEM_NEXT);
  }
  return Item->spSubMenu;
}

Referenced by MENU_ButtonDown(), MENU_ExecFocusedItem(), MENU_KeyLeft(), MENU_KeyRight(), MENU_MouseMove(), and MENU_TrackMenu().

MENU_SuspendPopup()

static BOOL FASTCALL MENU_SuspendPopup ( MTRACKER *  pmt, UINT  uMsg  )

static

Definition at line 3877 of file menu.c.

{
    MSG msg;
 
    msg.hwnd = UserHMGetHandle(pmt->OwnerWnd); 
 
    co_IntGetPeekMessage( &msg, 0, uMsg, uMsg, PM_NOYIELD | PM_REMOVE, FALSE);
    pmt->TrackFlags |= TF_SKIPREMOVE;
 
    switch( uMsg )
    {
    case WM_KEYDOWN:
        co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE, FALSE);
        if( msg.message == WM_KEYUP || msg.message == WM_PAINT )
        {
            co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE, FALSE);
            co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE, FALSE);
            if( msg.message == WM_KEYDOWN &&
                (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT))
            {
                 pmt->TrackFlags |= TF_SUSPENDPOPUP;
                 return TRUE;
            }
        }
        break;
    }
    /* failures go through this */
    pmt->TrackFlags &= ~TF_SUSPENDPOPUP;
    return FALSE;
}

Referenced by MENU_KeyLeft(), and MENU_KeyRight().

MENU_SwitchTracking()

static void FASTCALL MENU_SwitchTracking ( MTRACKER *  pmt, PMENU  PtMenu, UINT  Index, UINT  wFlags  )

static

Definition at line 3533 of file menu.c.

{
  TRACE("%x menu=%x 0x%04x\n", pmt, PtMenu, Index);
 
  if ( pmt->TopMenu != PtMenu &&
      !((PtMenu->fFlags | pmt->TopMenu->fFlags) & MNF_POPUP) )
  {
      /* both are top level menus (system and menu-bar) */
      MENU_HideSubPopups(pmt->OwnerWnd, pmt->TopMenu, FALSE, wFlags);
      MENU_SelectItem(pmt->OwnerWnd, pmt->TopMenu, NO_SELECTED_ITEM, FALSE, NULL);
      pmt->TopMenu = PtMenu;
  }
  else
  {
      MENU_HideSubPopups(pmt->OwnerWnd, PtMenu, FALSE, wFlags);
  }
 
  MENU_SelectItem(pmt->OwnerWnd, PtMenu, Index, TRUE, NULL);
}

Referenced by MENU_ButtonDown(), and MENU_MouseMove().

MENU_TrackKbdMenuBar()

VOID MENU_TrackKbdMenuBar	(	PWND	pwnd,
		UINT	wParam,
		WCHAR	wChar
	)

Definition at line 4516 of file menu.c.

{
    UINT uItem = NO_SELECTED_ITEM;
    PMENU TrackMenu;
    UINT wFlags = TPM_LEFTALIGN | TPM_LEFTBUTTON;
 
    TRACE("hwnd %p wParam 0x%04x wChar 0x%04x\n", UserHMGetHandle(pwnd), wParam, wChar);
 
    /* find window that has a menu */
 
    while (!( (pwnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD ) )
        if (!(pwnd = UserGetAncestor( pwnd, GA_PARENT ))) return;
 
    /* check if we have to track a system menu */
 
    TrackMenu = IntGetMenu( UserHMGetHandle(pwnd) );
    if (!TrackMenu || (pwnd->style & WS_MINIMIZE) != 0 || wChar == ' ' )
    {
        if (!(pwnd->style & WS_SYSMENU)) return;
        TrackMenu = get_win_sys_menu( UserHMGetHandle(pwnd) );
        uItem = 0;
        wParam |= HTSYSMENU; /* prevent item lookup */
    }
 
    if (!VerifyMenu( TrackMenu )) return;
 
    MENU_InitTracking( pwnd, TrackMenu, FALSE, wFlags );
 
    /* fetch the window menu again, it may have changed */
    TrackMenu = (wParam & HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pwnd) ) : IntGetMenu( UserHMGetHandle(pwnd) );
 
    if( wChar && wChar != ' ' )
    {
        uItem = MENU_FindItemByKey( pwnd, TrackMenu, wChar, (wParam & HTSYSMENU) );
        if ( uItem >= (UINT)(-2) )
        {
            if( uItem == (UINT)(-1) ) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
            /* schedule end of menu tracking */
            wFlags |= TF_ENDMENU;
            goto track_menu;
        }
    }
 
    MENU_SelectItem( pwnd, TrackMenu, uItem, TRUE, 0 );
 
    if (!(wParam & HTSYSMENU) || wChar == ' ')
    {
        if( uItem == NO_SELECTED_ITEM )
            MENU_MoveSelection( pwnd, TrackMenu, ITEM_NEXT );
        else
            UserPostMessage( UserHMGetHandle(pwnd), WM_KEYDOWN, VK_RETURN, 0 );
    }
 
track_menu:
    MENU_TrackMenu( TrackMenu, wFlags, 0, 0, pwnd );
    MENU_ExitTracking( pwnd, FALSE, wFlags);
}

Referenced by DefWndHandleSysCommand().

MENU_TrackMenu()

static INT FASTCALL MENU_TrackMenu ( PMENU  pmenu, UINT  wFlags, INT  x, INT  y, PWND  pwnd  )

static

Definition at line 4050 of file menu.c.

{
    MSG msg;
    BOOL fRemove;
    INT executedMenuId = -1;
    MTRACKER mt;
    HWND capture_win;
    PMENU pmMouse;
    BOOL enterIdleSent = FALSE;
    BOOL firstClick = TRUE;
    PWND pWnd;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    if (pti != pwnd->head.pti)
    {
       ERR("Not the same PTI!!!!\n");
    }
 
    mt.TrackFlags = 0;
    mt.CurrentMenu = pmenu;
    mt.TopMenu = pmenu;
    mt.OwnerWnd = pwnd;
    mt.Pt.x = x;
    mt.Pt.y = y;
 
    TRACE("MTM : hmenu=%p flags=0x%08x (%d,%d) hwnd=%x\n",
         UserHMGetHandle(pmenu), wFlags, x, y, UserHMGetHandle(pwnd));
 
    pti->MessageQueue->QF_flags &= ~QF_ACTIVATIONCHANGE;
 
    if (wFlags & TPM_BUTTONDOWN)
    {
        /* Get the result in order to start the tracking or not */
        fRemove = MENU_ButtonDown( &mt, pmenu, wFlags );
        fInsideMenuLoop = fRemove;
    }
 
    if (wFlags & TF_ENDMENU) fInsideMenuLoop = FALSE;
 
    if (wFlags & TPM_POPUPMENU && pmenu->cItems == 0) // Tracking empty popup menu...
    {
       MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
       pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
       co_UserSetCapture(NULL); /* release the capture */
       return 0;
    }
 
    capture_win = IntGetCapture();
 
    while (fInsideMenuLoop)
    {
        BOOL ErrorExit = FALSE;
        if (!VerifyMenu( mt.CurrentMenu )) /* sometimes happens if I do a window manager close */
           break;
 
        /* we have to keep the message in the queue until it's
         * clear that menu loop is not over yet. */
 
        for (;;)
        {
            if (co_IntGetPeekMessage( &msg, 0, 0, 0, PM_NOREMOVE, FALSE ))
            {
                if (!IntCallMsgFilter( &msg, MSGF_MENU )) break;
                /* remove the message from the queue */
                co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
            }
            else
            {
                /* ReactOS Checks */
                if (!VerifyWnd(mt.OwnerWnd)                            ||
                    !ValidateHwndNoErr(mt.CurrentMenu->hWnd)           ||
                     //pti->MessageQueue->QF_flags & QF_ACTIVATIONCHANGE || // See CORE-17338
                     capture_win != IntGetCapture() ) // Should not happen, but this is ReactOS...
                {
                   ErrorExit = TRUE; // Do not wait on dead windows, now win test_capture_4 works.
                   break;
                }
 
                if (!enterIdleSent)
                {
                  HWND win = mt.CurrentMenu->fFlags & MNF_POPUP ? mt.CurrentMenu->hWnd : NULL;
                  enterIdleSent = TRUE;
                  co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_ENTERIDLE, MSGF_MENU, (LPARAM) win);
                }
                co_IntWaitMessage(NULL, 0, 0);
            }
        }
 
        if (ErrorExit) break; // Gracefully dropout.
 
        /* check if EndMenu() tried to cancel us, by posting this message */
        if (msg.message == WM_CANCELMODE)
        {
            /* we are now out of the loop */
            fInsideMenuLoop = FALSE;
 
            /* remove the message from the queue */
            co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
 
            /* break out of internal loop, ala ESCAPE */
            break;
        }
 
        mt.Pt = msg.pt;
 
        if ( (msg.hwnd == mt.CurrentMenu->hWnd) || ((msg.message!=WM_TIMER) && (msg.message!=WM_SYSTIMER)) )
            enterIdleSent=FALSE;
 
        fRemove = FALSE;
        if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
        {
            /*
             * Use the mouse coordinates in lParam instead of those in the MSG
             * struct to properly handle synthetic messages. They are already
             * in screen coordinates.
             */
            mt.Pt.x = (short)LOWORD(msg.lParam);
            mt.Pt.y = (short)HIWORD(msg.lParam);
 
            /* Find a menu for this mouse event */
            pmMouse = MENU_PtMenu( mt.TopMenu, mt.Pt );
 
            switch(msg.message)
            {
                /* no WM_NC... messages in captured state */
 
                case WM_RBUTTONDBLCLK:
                case WM_RBUTTONDOWN:
                     if (!(wFlags & TPM_RIGHTBUTTON))
                     {
                        if ( msg.message == WM_RBUTTONDBLCLK ) fInsideMenuLoop = FALSE; // Must exit or loop forever!
                        break;
                     }
                    /* fall through */
                case WM_LBUTTONDBLCLK:
                case WM_LBUTTONDOWN:
                {
                    /* If the message belongs to the menu, removes it from the queue */
                    /* Else, end menu tracking */
                    pWnd = ValidateHwndNoErr(mt.TopMenu->hWnd);
                    /* Don't remove WM_LBUTTONDBLCLK to allow the closing of a window or program */
                    if (msg.message == WM_LBUTTONDBLCLK && GetNCHitEx(pWnd, mt.Pt) == HTSYSMENU)
                        fRemove = FALSE;
                    else
                        fRemove = MENU_ButtonDown(&mt, pmMouse, wFlags);
 
                    fInsideMenuLoop = fRemove;
                    if (msg.message == WM_RBUTTONDBLCLK)
                        fInsideMenuLoop = FALSE; // Must exit or loop forever
                    break;
                }
 
                case WM_RBUTTONUP:
                    if (!(wFlags & TPM_RIGHTBUTTON)) break;
                    /* fall through */
                case WM_LBUTTONUP:
                    /* Check if a menu was selected by the mouse */
                    if (pmMouse)
                    {
                        pWnd = ValidateHwndNoErr(mt.TopMenu->hWnd);
                        /* Exit system menu if system icon is clicked a second time */
                        if (!firstClick && GetNCHitEx(pWnd, mt.Pt) == HTSYSMENU)
                        {
                            fRemove = TRUE;
                            fInsideMenuLoop = FALSE;
                        }
                        else
                        {
                            /* End the loop if executedMenuId is an item ID */
                            /* or if the job was done (executedMenuId = 0). */
                            executedMenuId = MENU_ButtonUp( &mt, pmMouse, wFlags);
                            fRemove = (executedMenuId != -1);
                            fInsideMenuLoop = !fRemove;
                            firstClick = FALSE;
                        }
                    }
                    /* No menu was selected by the mouse */
                    /* if the function was called by TrackPopupMenu, continue
                       with the menu tracking. If not, stop it */
                    else
                        fInsideMenuLoop = ((wFlags & TPM_POPUPMENU) ? TRUE : FALSE);
 
                    break;
 
                case WM_MOUSEMOVE:
                    /* the selected menu item must be changed every time */
                    /* the mouse moves. */
 
                    if (pmMouse)
                        fInsideMenuLoop |= MENU_MouseMove( &mt, pmMouse, wFlags );
 
        } /* switch(msg.message) - mouse */
        }
        else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST))
        {
            fRemove = TRUE;  /* Keyboard messages are always removed */
            switch(msg.message)
            {
                case WM_KEYDOWN:
                case WM_SYSKEYDOWN:
                switch(msg.wParam)
                {
                    case VK_MENU:
                    case VK_F10:
                        fInsideMenuLoop = FALSE;
                        break;
 
                    case VK_HOME:
                    case VK_END:
                        MENU_SelectItem(mt.OwnerWnd, mt.CurrentMenu, NO_SELECTED_ITEM, FALSE, 0 );
                        MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, VK_HOME == msg.wParam ? ITEM_NEXT : ITEM_PREV);
                        break;
 
                    case VK_UP:
                    case VK_DOWN: /* If on menu bar, pull-down the menu */
                        if (!(mt.CurrentMenu->fFlags & MNF_POPUP))
                            mt.CurrentMenu = MENU_ShowSubPopup(mt.OwnerWnd, mt.TopMenu, TRUE, wFlags);
                        else      /* otherwise try to move selection */
                            MENU_MoveSelection(mt.OwnerWnd, mt.CurrentMenu, (msg.wParam == VK_UP)? ITEM_PREV : ITEM_NEXT );
                        break;
 
                    case VK_LEFT:
                        MENU_KeyLeft( &mt, wFlags, msg.message );
                        break;
 
                    case VK_RIGHT:
                        MENU_KeyRight( &mt, wFlags, msg.message );
                        break;
 
                    case VK_ESCAPE:
                        fInsideMenuLoop = !MENU_KeyEscape(&mt, wFlags);
                        break;
 
                    case VK_F1:
                    {
                        HELPINFO hi;
                        hi.cbSize = sizeof(HELPINFO);
                        hi.iContextType = HELPINFO_MENUITEM;
                        if (mt.CurrentMenu->iItem == NO_SELECTED_ITEM)
                            hi.iCtrlId = 0;
                        else
                            hi.iCtrlId = pmenu->rgItems[mt.CurrentMenu->iItem].wID;
                        hi.hItemHandle = UserHMGetHandle(mt.CurrentMenu);
                        hi.dwContextId = pmenu->dwContextHelpId;
                        hi.MousePos = msg.pt;
                        co_IntSendMessage( UserHMGetHandle(pwnd), WM_HELP, 0, (LPARAM)&hi);
                        break;
                    }
 
                    default:
                        IntTranslateKbdMessage(&msg, 0);
                        break;
                }
                break;  /* WM_KEYDOWN */
 
                case WM_CHAR:
                case WM_SYSCHAR:
                {
                    UINT pos;
                    BOOL fEndMenu;
 
                    if (msg.wParam == L'\r' || msg.wParam == L' ')
                    {
                        executedMenuId = MENU_ExecFocusedItem(&mt, mt.CurrentMenu, wFlags);
                        fEndMenu = (executedMenuId != -2);
                        fInsideMenuLoop = !fEndMenu;
                        break;
                    }
 
                    /* Hack to avoid control chars. */
                    /* We will find a better way real soon... */
                    if (msg.wParam < 32) break;
 
                    pos = MENU_FindItemByKey(mt.OwnerWnd, mt.CurrentMenu, LOWORD(msg.wParam), FALSE);
 
                    if (pos == (UINT)-2) fInsideMenuLoop = FALSE;
                    else if (pos == (UINT)-1) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
                    else
                    {
                        MENU_SelectItem(mt.OwnerWnd, mt.CurrentMenu, pos, TRUE, 0);
                        executedMenuId = MENU_ExecFocusedItem(&mt, mt.CurrentMenu, wFlags);
                        fEndMenu = (executedMenuId != -2);
                        fInsideMenuLoop = !fEndMenu;
                    }
                }
                break;
            }  /* switch(msg.message) - kbd */
        }
        else
        {
            co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
            IntDispatchMessage( &msg );
            continue;
        }
 
        if (fInsideMenuLoop) fRemove = TRUE;
 
        /* finally remove message from the queue */
 
        if (fRemove && !(mt.TrackFlags & TF_SKIPREMOVE) )
            co_IntGetPeekMessage( &msg, 0, msg.message, msg.message, PM_REMOVE, FALSE );
        else mt.TrackFlags &= ~TF_SKIPREMOVE;
    }
 
    MsqSetStateWindow(pti, MSQ_STATE_MENUOWNER, NULL);
    pti->MessageQueue->QF_flags &= ~QF_CAPTURELOCKED;
    co_UserSetCapture(NULL); /* release the capture */
 
    /* If dropdown is still painted and the close box is clicked on
       then the menu will be destroyed as part of the DispatchMessage above.
       This will then invalidate the menu handle in mt.hTopMenu. We should
       check for this first.  */
    if ( VerifyMenu( mt.TopMenu ) )
    {
       if (VerifyWnd(mt.OwnerWnd))
       {
           MENU_HideSubPopups(mt.OwnerWnd, mt.TopMenu, FALSE, wFlags);
 
           if (mt.TopMenu->fFlags & MNF_POPUP)
           {
              PWND pwndTM = ValidateHwndNoErr(mt.TopMenu->hWnd);
              if (pwndTM)
              {
                 IntNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPEND, pwndTM, OBJID_CLIENT, CHILDID_SELF, 0);
 
                 co_UserDestroyWindow(pwndTM);
              }
              mt.TopMenu->hWnd = NULL;
 
              if (!(wFlags & TPM_NONOTIFY))
              {
                 co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_UNINITMENUPOPUP, (WPARAM)UserHMGetHandle(mt.TopMenu),
                                 MAKELPARAM(0, IS_SYSTEM_MENU(mt.TopMenu) ? MF_SYSMENU : 0));
              }
            }
            MENU_SelectItem( mt.OwnerWnd, mt.TopMenu, NO_SELECTED_ITEM, FALSE, 0 );
            co_IntSendMessage( UserHMGetHandle(mt.OwnerWnd), WM_MENUSELECT, MAKEWPARAM(0, 0xffff), 0 );
       }
 
       /* Reset the variable for hiding menu */
       mt.TopMenu->TimeToHide = FALSE;
    }
 
    EngSetLastError( ERROR_SUCCESS );
    /* The return value is only used by TrackPopupMenu */
    if (!(wFlags & TPM_RETURNCMD)) return TRUE;
    if (executedMenuId == -1) executedMenuId = 0;
    return executedMenuId;
}

Referenced by IntTrackPopupMenuEx(), MENU_TrackKbdMenuBar(), and MENU_TrackMouseMenuBar().

MENU_TrackMouseMenuBar()

VOID MENU_TrackMouseMenuBar	(	PWND	pWnd,
		ULONG	ht,
		POINT	pt
	)

Definition at line 4486 of file menu.c.

{
    PMENU pMenu = (ht == HTSYSMENU) ? IntGetSystemMenu(pWnd, FALSE) : IntGetMenu( UserHMGetHandle(pWnd) ); // See 74276 and CORE-12801
    UINT wFlags = TPM_BUTTONDOWN | TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL;
 
    TRACE("wnd=%p ht=0x%04x (%ld,%ld)\n", pWnd, ht, pt.x, pt.y);
 
    if (pWnd->ExStyle & WS_EX_LAYOUTRTL) wFlags |= TPM_LAYOUTRTL;
    if (VerifyMenu(pMenu))
    {
        /* map point to parent client coordinates */
        PWND Parent = UserGetAncestor(pWnd, GA_PARENT );
        if (Parent != UserGetDesktopWindow())
        {
            IntScreenToClient(Parent, &pt);
        }
 
        MENU_InitTracking(pWnd, pMenu, FALSE, wFlags);
        /* fetch the window menu again, it may have changed */
        pMenu = (ht == HTSYSMENU) ? get_win_sys_menu( UserHMGetHandle(pWnd) ) : IntGetMenu( UserHMGetHandle(pWnd) );
        MENU_TrackMenu(pMenu, wFlags, pt.x, pt.y, pWnd);
        MENU_ExitTracking(pWnd, FALSE, wFlags);
    }
}

Referenced by DefWndHandleSysCommand().

MenuInit()

BOOL MenuInit

(

VOID

)

Definition at line 359 of file menu.c.

{
  NONCLIENTMETRICSW ncm;
 
  /* get the menu font */
  if (!ghMenuFont || !ghMenuFontBold)
  {
    ncm.cbSize = sizeof(ncm);
    if(!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0))
    {
      ERR("MenuInit(): SystemParametersInfo(SPI_GETNONCLIENTMETRICS) failed!\n");
      return FALSE;
    }
 
    ghMenuFont = GreCreateFontIndirectW(&ncm.lfMenuFont);
    if (ghMenuFont == NULL)
    {
      ERR("MenuInit(): CreateFontIndirectW(hMenuFont) failed!\n");
      return FALSE;
    }
    ncm.lfMenuFont.lfWeight = min(ncm.lfMenuFont.lfWeight + (FW_BOLD - FW_NORMAL), FW_HEAVY);
    ghMenuFontBold = GreCreateFontIndirectW(&ncm.lfMenuFont);
    if (ghMenuFontBold == NULL)
    {
      ERR("MenuInit(): CreateFontIndirectW(hMenuFontBold) failed!\n");
      GreDeleteObject(ghMenuFont);
      ghMenuFont = NULL;
      return FALSE;
    }
    
    GreSetObjectOwner(ghMenuFont, GDI_OBJ_HMGR_PUBLIC);
    GreSetObjectOwner(ghMenuFontBold, GDI_OBJ_HMGR_PUBLIC);
 
    co_IntSetupOBM();
  }
 
  return TRUE;
}

Referenced by ClientThreadSetupHelper(), and co_IntInitializeDesktopGraphics().

NtUserCalcMenuBar()

DWORD APIENTRY NtUserCalcMenuBar	(	HWND	hwnd,
		DWORD	leftBorder,
		DWORD	rightBorder,
		DWORD	top,
		LPRECT	prc
	)

Definition at line 5554 of file menu.c.

{
    HDC hdc;
    PWND Window;
    RECT Rect;
    DWORD ret;
 
    UserEnterExclusive();
 
    if(!(Window = UserGetWindowObject(hwnd)))
    {
        EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
        UserLeave();
        return 0;
    }
 
    hdc = UserGetDCEx(NULL, NULL, DCX_CACHE);
    if (!hdc)
    {
        UserLeave();
        return 0;
    }
 
    Rect.left = leftBorder;
    Rect.right = Window->rcWindow.right - Window->rcWindow.left - rightBorder;
    Rect.top = top;
    Rect.bottom = 0;
 
    ret = MENU_DrawMenuBar(hdc, &Rect, Window, TRUE);
 
    UserReleaseDC( 0, hdc, FALSE );
 
    UserLeave();
 
    return ret;
}

NtUserCheckMenuItem()

DWORD APIENTRY NtUserCheckMenuItem	(	HMENU	hMenu,
		UINT	uIDCheckItem,
		UINT	uCheck
	)

Definition at line 5600 of file menu.c.

{
   PMENU Menu;
   DWORD Ret = (DWORD)-1;
 
   TRACE("Enter NtUserCheckMenuItem\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntCheckMenuItem(Menu, uIDCheckItem, uCheck);
   }
 
   TRACE("Leave NtUserCheckMenuItem, ret=%lu\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by CheckMenuItem().

NtUserDeleteMenu()

BOOL APIENTRY NtUserDeleteMenu	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags
	)

Definition at line 5626 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserDeleteMenu\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntRemoveMenuItem(Menu, uPosition, uFlags, TRUE);
   }
 
   TRACE("Leave NtUserDeleteMenu, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by DeleteMenu().

NtUserDestroyMenu()

BOOL APIENTRY NtUserDestroyMenu

(

HMENU

hMenu

)

Definition at line 5834 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserDestroyMenu\n");
   UserEnterExclusive();
 
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      goto Exit; // Return FALSE
   }
   if (Menu->head.rpdesk != gptiCurrent->rpdesk)
   {
      EngSetLastError(ERROR_ACCESS_DENIED);
      goto Exit; // Return FALSE
   }
   Ret = IntDestroyMenuObject(Menu, TRUE);
 
Exit:
   TRACE("Leave NtUserDestroyMenu, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by DestroyMenu(), and WIN_CreateWindowEx().

NtUserDrawMenuBarTemp()

DWORD APIENTRY NtUserDrawMenuBarTemp	(	HWND	hWnd,
		HDC	hDC,
		PRECT	pRect,
		HMENU	hMenu,
		HFONT	hFont
	)

Definition at line 6240 of file menu.c.

{
   PMENU Menu;
   PWND Window;
   RECT Rect;
   NTSTATUS Status = STATUS_SUCCESS;
   DWORD Ret = 0;
 
   ERR("Enter NtUserDrawMenuBarTemp\n");
   UserEnterExclusive();
 
   if(!(Window = UserGetWindowObject(hWnd)))
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      goto Exit; // Return 0
   }
 
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      EngSetLastError(ERROR_INVALID_MENU_HANDLE);
      goto Exit; // Return 0
   }
 
   _SEH2_TRY
   {
      ProbeForRead(pRect, sizeof(RECT), sizeof(ULONG));
      RtlCopyMemory(&Rect, pRect, sizeof(RECT));
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      Status = _SEH2_GetExceptionCode();
   }
   _SEH2_END;
 
   if (Status != STATUS_SUCCESS)
   {
      SetLastNtError(Status);
      goto Exit; // Return 0
   }
 
   Ret = IntDrawMenuBarTemp(Window, hDC, &Rect, Menu, hFont);
 
Exit:
   ERR("Leave NtUserDrawMenuBarTemp, ret=%lu\n", Ret);
   UserLeave();
   return Ret;
}

NtUserEnableMenuItem()

UINT APIENTRY NtUserEnableMenuItem	(	HMENU	hMenu,
		UINT	uIDEnableItem,
		UINT	uEnable
	)

Definition at line 5864 of file menu.c.

{
   PMENU Menu;
   UINT Ret = (UINT)-1;
 
   TRACE("Enter NtUserEnableMenuItem\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntEnableMenuItem(Menu, uIDEnableItem, uEnable);
   }
 
   TRACE("Leave NtUserEnableMenuItem, ret=%u\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by EnableMenuItem().

NtUserEndMenu()

BOOL APIENTRY NtUserEndMenu

(

VOID

)

Definition at line 5890 of file menu.c.

{
   //PWND pWnd;
   TRACE("Enter NtUserEndMenu\n");
   UserEnterExclusive();
 /*  if ( gptiCurrent->pMenuState &&
        gptiCurrent->pMenuState->pGlobalPopupMenu )
   {
       pWnd = IntGetMSWND(gptiCurrent->pMenuState);
       if (pWnd)
       {
          UserPostMessage( UserHMGetHandle(pWnd), WM_CANCELMODE, 0, 0);
       }
       else
          gptiCurrent->pMenuState->fInsideMenuLoop = FALSE;
   }*/
   if (fInsideMenuLoop && top_popup)
   {
      fInsideMenuLoop = FALSE;
      UserPostMessage( top_popup, WM_CANCELMODE, 0, 0);
   }
   UserLeave();
   TRACE("Leave NtUserEndMenu\n");
   return TRUE;
}

NtUserGetMenuBarInfo()

BOOL APIENTRY NtUserGetMenuBarInfo	(	HWND	hwnd,
		LONG	idObject,
		LONG	idItem,
		PMENUBARINFO	pmbi
	)

Definition at line 5920 of file menu.c.

{
   PWND pWnd;
   HMENU hMenu;
   MENUBARINFO kmbi;
   BOOL Ret = FALSE;
   PPOPUPMENU pPopupMenu;
   USER_REFERENCE_ENTRY Ref;
   NTSTATUS Status = STATUS_SUCCESS;
   PMENU Menu = NULL;
 
   TRACE("Enter NtUserGetMenuBarInfo\n");
   UserEnterShared();
 
   if (!(pWnd = UserGetWindowObject(hwnd)))
   {
        EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
        goto Cleanup; // Return FALSE
   }
 
   UserRefObjectCo(pWnd, &Ref);
 
   RECTL_vSetEmptyRect(&kmbi.rcBar);
   kmbi.hMenu = NULL;
   kmbi.hwndMenu = NULL;
   kmbi.fBarFocused = FALSE;
   kmbi.fFocused = FALSE;
 
   switch (idObject)
   {
    case OBJID_CLIENT:
        if (!pWnd->pcls->fnid)
            goto Cleanup; // Return FALSE
        if (pWnd->pcls->fnid != FNID_MENU)
        {
            WARN("called on invalid window: %u\n", pWnd->pcls->fnid);
            EngSetLastError(ERROR_INVALID_MENU_HANDLE);
            goto Cleanup; // Return FALSE
        }
        // Windows does this! Wine checks for Atom and uses GetWindowLongPtrW.
        hMenu = (HMENU)co_IntSendMessage(hwnd, MN_GETHMENU, 0, 0);
        pPopupMenu = ((PMENUWND)pWnd)->ppopupmenu;
        if (pPopupMenu && pPopupMenu->spmenu)
        {
           if (UserHMGetHandle(pPopupMenu->spmenu) != hMenu)
           {
              ERR("Window Pop Up hMenu %p not the same as Get hMenu %p!\n", UserHMGetHandle(pPopupMenu->spmenu), hMenu);
           }
        }
        break;
    case OBJID_MENU:
        if (pWnd->style & WS_CHILD)
            goto Cleanup; // Return FALSE
        hMenu = UlongToHandle(pWnd->IDMenu);
        TRACE("GMBI: OBJID_MENU hMenu %p\n",hMenu);
        break;
    case OBJID_SYSMENU:
        if (!(pWnd->style & WS_SYSMENU))
            goto Cleanup; // Return FALSE
        Menu = IntGetSystemMenu(pWnd, FALSE);
        hMenu = UserHMGetHandle(Menu);
        break;
    default:
        goto Cleanup; // Return FALSE
   }
 
   if (!hMenu)
      goto Cleanup; // Return FALSE
 
   _SEH2_TRY
   {
       ProbeForRead(pmbi, sizeof(MENUBARINFO), 1);
       kmbi.cbSize = pmbi->cbSize;
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
       kmbi.cbSize = 0;
   }
   _SEH2_END
 
   if (kmbi.cbSize != sizeof(MENUBARINFO))
   {
       EngSetLastError(ERROR_INVALID_PARAMETER);
       goto Cleanup; // Return FALSE
   }
 
   if (!Menu)
   {
       Menu = UserGetMenuObject(hMenu);
       if (!Menu)
          goto Cleanup; // Return FALSE
   }
 
   if ((idItem < 0) || ((ULONG)idItem > Menu->cItems))
       goto Cleanup; // Return FALSE
 
   if (idItem == 0)
   {
      Ret = IntGetMenuItemRect(pWnd, Menu, 0, &kmbi.rcBar);
      kmbi.rcBar.right = kmbi.rcBar.left + Menu->cxMenu;
      kmbi.rcBar.bottom = kmbi.rcBar.top + Menu->cyMenu;
      TRACE("idItem a 0 %d\n",Ret);
   }
   else
   {
      Ret = IntGetMenuItemRect(pWnd, Menu, idItem-1, &kmbi.rcBar);
      TRACE("idItem b %d %d\n", idItem-1, Ret);
   }
 
   kmbi.hMenu = hMenu;
   kmbi.fBarFocused = top_popup_hmenu == hMenu;
   TRACE("GMBI: top p hm %p hMenu %p\n",top_popup_hmenu, hMenu);
   if (idItem)
   {
       kmbi.fFocused = Menu->iItem == idItem-1;
       if (kmbi.fFocused && (Menu->rgItems[idItem - 1].spSubMenu))
       {
          kmbi.hwndMenu = Menu->rgItems[idItem - 1].spSubMenu->hWnd;
       }
   }
   else
   {
       kmbi.fFocused = kmbi.fBarFocused;
   }
 
   _SEH2_TRY
   {
      ProbeForWrite(pmbi, sizeof(MENUBARINFO), 1);
      RtlCopyMemory(pmbi, &kmbi, sizeof(MENUBARINFO));
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      Status = _SEH2_GetExceptionCode();
   }
   _SEH2_END
 
   if (!NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      Ret = FALSE;
      goto Cleanup;
   }
 
   Ret = TRUE;
 
Cleanup:
   if (pWnd) UserDerefObjectCo(pWnd);
   TRACE("Leave NtUserGetMenuBarInfo, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

NtUserGetMenuIndex()

UINT APIENTRY NtUserGetMenuIndex	(	HMENU	hMenu,
		HMENU	hSubMenu
	)

Definition at line 6080 of file menu.c.

{
   PMENU Menu, SubMenu;
   PITEM MenuItem;
   UINT i;
   UINT Ret = 0xFFFFFFFF;
 
   TRACE("Enter NtUserGetMenuIndex\n");
   UserEnterShared();
 
   if ( !(Menu = UserGetMenuObject(hMenu)) ||
        !(SubMenu = UserGetMenuObject(hSubMenu)) )
      goto Exit; // Return 0xFFFFFFFF
 
   MenuItem = Menu->rgItems;
   for (i = 0; i < Menu->cItems; i++, MenuItem++)
   {
       if (MenuItem->spSubMenu == SubMenu)
       {
          Ret = MenuItem->wID;
          break;
       }
   }
 
Exit:
   TRACE("Leave NtUserGetMenuIndex, ret=%u\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by GetMenuIndex().

NtUserGetMenuItemRect()

BOOL APIENTRY NtUserGetMenuItemRect	(	HWND	hWnd,
		HMENU	hMenu,
		UINT	uItem,
		PRECTL	lprcItem
	)

Definition at line 6116 of file menu.c.

{
   PWND ReferenceWnd;
   LONG XMove, YMove;
   RECTL Rect;
   PMENU Menu;
   PITEM MenuItem;
   NTSTATUS Status = STATUS_SUCCESS;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserGetMenuItemRect\n");
   UserEnterShared();
 
   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      goto Exit; // Return FALSE
   }
 
   if ((MenuItem = MENU_FindItem (&Menu, &uItem, MF_BYPOSITION)))
   {
      Rect.left   = MenuItem->xItem;
      Rect.top    = MenuItem->yItem;
      Rect.right  = MenuItem->cxItem; // Do this for now......
      Rect.bottom = MenuItem->cyItem;
   }
   else
      goto Exit; // Return FALSE
 
   if(!hWnd)
   {
       hWnd = Menu->hWnd;
   }
 
   if (lprcItem == NULL)
       goto Exit; // Return FALSE
 
   if (!(ReferenceWnd = UserGetWindowObject(hWnd)))
       goto Exit; // Return FALSE
 
   if (Menu->fFlags & MNF_POPUP)
   {
     XMove = ReferenceWnd->rcClient.left;
     YMove = ReferenceWnd->rcClient.top;
   }
   else
   {
     XMove = ReferenceWnd->rcWindow.left;
     YMove = ReferenceWnd->rcWindow.top;
   }
 
   Rect.left   += XMove;
   Rect.top    += YMove;
   Rect.right  += XMove;
   Rect.bottom += YMove;
 
   _SEH2_TRY
   {
      RtlCopyMemory(lprcItem, &Rect, sizeof(RECTL));
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      Status = _SEH2_GetExceptionCode();
   }
   _SEH2_END
 
   if (!NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      goto Exit; // Return FALSE
   }
   Ret = TRUE;
 
Exit:
   TRACE("Leave NtUserGetMenuItemRect, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

NtUserGetSystemMenu()

HMENU APIENTRY NtUserGetSystemMenu	(	HWND	hWnd,
		BOOL	bRevert
	)

Definition at line 5676 of file menu.c.

{
   PWND Window;
   PMENU Menu;
   HMENU Ret = NULL;
 
   TRACE("Enter NtUserGetSystemMenu\n");
   UserEnterExclusive();
 
   if (!(Window = UserGetWindowObject(hWnd)))
   {
      goto Exit; // Return NULL
   }
 
   if (!(Menu = IntGetSystemMenu(Window, bRevert)))
   {
      goto Exit; // Return NULL
   }
 
   Ret = UserHMGetHandle(Menu);
 
Exit:
   TRACE("Leave NtUserGetSystemMenu, ret=%p\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by GetSystemMenu().

NtUserGetTitleBarInfo()

BOOLEAN APIENTRY NtUserGetTitleBarInfo	(	HWND	hwnd,
		PTITLEBARINFO	bti
	)

Definition at line 5750 of file menu.c.

{
    PWND WindowObject;
    TITLEBARINFO bartitleinfo;
    BOOLEAN retValue = TRUE;
 
    TRACE("Enter NtUserGetTitleBarInfo\n");
    UserEnterExclusive();
 
    /* Vaildate the windows handle */
    if (!(WindowObject = UserGetWindowObject(hwnd)))
    {
        EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
        retValue = FALSE;
    }
 
    _SEH2_TRY
    {
        /* Copy our usermode buffer bti to local buffer bartitleinfo */
        ProbeForRead(bti, sizeof(TITLEBARINFO), 1);
        RtlCopyMemory(&bartitleinfo, bti, sizeof(TITLEBARINFO));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Fail copy the data */
        EngSetLastError(ERROR_INVALID_PARAMETER);
        retValue = FALSE;
    }
    _SEH2_END
 
    /* Get the tile bar info */
    if (retValue)
    {
        retValue = intGetTitleBarInfo(WindowObject, &bartitleinfo);
        if (retValue)
        {
            _SEH2_TRY
            {
                /* Copy our buffer to user mode buffer bti */
                ProbeForWrite(bti, sizeof(TITLEBARINFO), 1);
                RtlCopyMemory(bti, &bartitleinfo, sizeof(TITLEBARINFO));
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                /* Fail copy the data */
                EngSetLastError(ERROR_INVALID_PARAMETER);
                retValue = FALSE;
            }
            _SEH2_END
        }
    }
 
    TRACE("Leave NtUserGetTitleBarInfo, ret=%u\n", retValue);
    UserLeave();
    return retValue;
}

Referenced by GetTitleBarInfo(), and START_TEST().

NtUserHiliteMenuItem()

BOOL APIENTRY NtUserHiliteMenuItem	(	HWND	hWnd,
		HMENU	hMenu,
		UINT	uItemHilite,
		UINT	uHilite
	)

Definition at line 6202 of file menu.c.

{
   PMENU Menu;
   PWND Window;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserHiliteMenuItem\n");
   UserEnterExclusive();
 
   if(!(Window = UserGetWindowObject(hWnd)))
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      goto Exit; // Return FALSE
   }
 
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      EngSetLastError(ERROR_INVALID_MENU_HANDLE);
      goto Exit; // Return FALSE
   }
 
   Ret = IntHiliteMenuItem(Window, Menu, uItemHilite, uHilite);
 
Exit:
   TRACE("Leave NtUserHiliteMenuItem, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

NtUserMenuItemFromPoint()

int APIENTRY NtUserMenuItemFromPoint	(	HWND	hWnd,
		HMENU	hMenu,
		DWORD	X,
		DWORD	Y
	)

Definition at line 6297 of file menu.c.

{
   PMENU Menu;
   PWND Window = NULL;
   PITEM mi;
   ULONG i;
   int Ret = -1;
 
   TRACE("Enter NtUserMenuItemFromPoint\n");
   UserEnterExclusive();
 
   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      goto Exit; // Return -1
   }
 
   if (!(Window = UserGetWindowObject(Menu->hWnd)))
   {
      goto Exit; // Return -1
   }
 
   X -= Window->rcWindow.left;
   Y -= Window->rcWindow.top;
 
   mi = Menu->rgItems;
   for (i = 0; i < Menu->cItems; i++, mi++)
   {
      RECTL Rect;
 
      Rect.left   = mi->xItem;
      Rect.top    = mi->yItem;
      Rect.right  = mi->cxItem;
      Rect.bottom = mi->cyItem;
 
      MENU_AdjustMenuItemRect(Menu, &Rect);
 
      if (RECTL_bPointInRect(&Rect, X, Y))
      {
         break;
      }
   }
 
   Ret = (mi ? i : NO_SELECTED_ITEM);
 
Exit:
   TRACE("Leave NtUserMenuItemFromPoint, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

NtUserPaintMenuBar()

DWORD APIENTRY NtUserPaintMenuBar	(	HWND	hWnd,
		HDC	hDC,
		ULONG	leftBorder,
		ULONG	rightBorder,
		ULONG	top,
		BOOL	bActive
	)

Definition at line 6354 of file menu.c.

{
   PWND Window;
   RECT Rect;
   DWORD ret;
 
   UserEnterExclusive();
 
   if(!(Window = UserGetWindowObject(hWnd)))
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      UserLeave();
      return 0;
   }
 
   Rect.left = leftBorder;
   Rect.right = Window->rcWindow.right - Window->rcWindow.left - rightBorder;
   Rect.top = top;
   Rect.bottom = 0;
 
   ret = MENU_DrawMenuBar(hDC, &Rect, Window, FALSE);
 
   UserLeave();
 
   return ret;
}

NtUserRemoveMenu()

BOOL APIENTRY NtUserRemoveMenu	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags
	)

Definition at line 6391 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserRemoveMenu\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntRemoveMenuItem(Menu, uPosition, uFlags, FALSE);
   }
 
   TRACE("Leave NtUserRemoveMenu, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by RemoveMenu().

NtUserSetMenu()

BOOL APIENTRY NtUserSetMenu	(	HWND	hWnd,
		HMENU	Menu,
		BOOL	Repaint
	)

Definition at line 6417 of file menu.c.

{
   PWND Window;
   BOOL Changed;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserSetMenu\n");
   UserEnterExclusive();
 
   if (!(Window = UserGetWindowObject(hWnd)))
   {
      goto Exit; // Return FALSE
   }
 
   if (!IntSetMenu(Window, Menu, &Changed))
   {
      goto Exit; // Return FALSE
   }
 
   // Not minimized and please repaint!!!
   if (!(Window->style & WS_MINIMIZE) && (Repaint || Changed))
   {
      USER_REFERENCE_ENTRY Ref;
      UserRefObjectCo(Window, &Ref);
      co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
      UserDerefObjectCo(Window);
   }
 
   Ret = TRUE;
 
Exit:
   TRACE("Leave NtUserSetMenu, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by SetMenu().

NtUserSetMenuContextHelpId()

BOOL APIENTRY NtUserSetMenuContextHelpId	(	HMENU	hMenu,
		DWORD	dwContextHelpId
	)

Definition at line 6460 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserSetMenuContextHelpId\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntSetMenuContextHelpId(Menu, dwContextHelpId);
   }
 
   TRACE("Leave NtUserSetMenuContextHelpId, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by SetMenuContextHelpId().

NtUserSetMenuDefaultItem()

BOOL APIENTRY NtUserSetMenuDefaultItem	(	HMENU	hMenu,
		UINT	uItem,
		UINT	fByPos
	)

Definition at line 6485 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserSetMenuDefaultItem\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = UserSetMenuDefaultItem(Menu, uItem, fByPos);
   }
 
   TRACE("Leave NtUserSetMenuDefaultItem, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by SetMenuDefaultItem().

NtUserSetMenuFlagRtoL()

BOOL APIENTRY NtUserSetMenuFlagRtoL

(

HMENU

hMenu

)

Definition at line 6511 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserSetMenuFlagRtoL\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = IntSetMenuFlagRtoL(Menu);
   }
 
   TRACE("Leave NtUserSetMenuFlagRtoL, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

NtUserSetSystemMenu()

BOOL APIENTRY NtUserSetSystemMenu	(	HWND	hWnd,
		HMENU	hMenu
	)

Definition at line 5711 of file menu.c.

{
   BOOL Result = FALSE;
   PWND Window;
   PMENU Menu;
 
   TRACE("Enter NtUserSetSystemMenu\n");
   UserEnterExclusive();
 
   if (!(Window = UserGetWindowObject(hWnd)))
   {
      goto Exit; // Return FALSE
   }
 
   if (hMenu)
   {
      /*
       * Assign new menu handle and Up the Lock Count.
       */
      if (!(Menu = IntGetMenuObject(hMenu)))
      {
         goto Exit; // Return FALSE
      }
 
      Result = IntSetSystemMenu(Window, Menu);
   }
   else
      EngSetLastError(ERROR_INVALID_MENU_HANDLE);
 
Exit:
   TRACE("Leave NtUserSetSystemMenu, ret=%i\n", Result);
   UserLeave();
   return Result;
}

Referenced by SetSystemMenu().

NtUserThunkedMenuInfo()

BOOL APIENTRY NtUserThunkedMenuInfo	(	HMENU	hMenu,
		LPCMENUINFO	lpcmi
	)

Definition at line 6535 of file menu.c.

{
   PMENU Menu;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserThunkedMenuInfo\n");
   UserEnterExclusive();
 
   Menu = UserGetMenuObject(hMenu);
   if (Menu)
   {
      Ret = UserMenuInfo(Menu, (PROSMENUINFO)lpcmi, TRUE);
   }
 
   TRACE("Leave NtUserThunkedMenuInfo, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by SetMenuInfo().

NtUserThunkedMenuItemInfo()

BOOL APIENTRY NtUserThunkedMenuItemInfo	(	HMENU	hMenu,
		UINT	uItem,
		BOOL	fByPosition,
		BOOL	bInsert,
		LPMENUITEMINFOW	lpmii,
		PUNICODE_STRING	lpszCaption
	)

Definition at line 6560 of file menu.c.

{
   PMENU Menu;
   NTSTATUS Status;
   UNICODE_STRING lstrCaption;
   BOOL Ret = FALSE;
 
   TRACE("Enter NtUserThunkedMenuItemInfo\n");
   UserEnterExclusive();
 
   /* lpszCaption may be NULL, check for it and call RtlInitUnicodeString()
      if bInsert == TRUE call UserInsertMenuItem() else UserSetMenuItemInfo()   */
 
   RtlInitEmptyUnicodeString(&lstrCaption, NULL, 0);
 
   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      goto Cleanup; // Return FALSE
   }
 
   /* Check if we got a Caption */
   if (lpszCaption && lpszCaption->Buffer)
   {
      /* Copy the string to kernel mode */
      Status = ProbeAndCaptureUnicodeString( &lstrCaption,
                                                 UserMode,
                                              lpszCaption);
      if (!NT_SUCCESS(Status))
      {
         ERR("Failed to capture MenuItem Caption (status 0x%08x)\n",Status);
         SetLastNtError(Status);
         goto Cleanup; // Return FALSE
      }
   }
 
   if (bInsert)
   {
      Ret = UserInsertMenuItem(Menu, uItem, fByPosition, lpmii, &lstrCaption);
      goto Cleanup;
   }
 
   Ret = UserMenuItemInfo(Menu, uItem, fByPosition, (PROSMENUITEMINFO)lpmii, TRUE, &lstrCaption);
 
Cleanup:
   if (lstrCaption.Buffer)
   {
      ReleaseCapturedUnicodeString(&lstrCaption, UserMode);
   }
 
   TRACE("Leave NtUserThunkedMenuItemInfo, ret=%i\n", Ret);
   UserLeave();
   return Ret;
}

Referenced by AppendMenuA(), AppendMenuW(), CheckMenuRadioItem(), InsertMenuA(), InsertMenuItemA(), InsertMenuItemW(), InsertMenuW(), ModifyMenuA(), ModifyMenuW(), SetMenuItemInfoA(), and SetMenuItemInfoW().

NtUserTrackPopupMenuEx()

BOOL APIENTRY NtUserTrackPopupMenuEx	(	HMENU	hMenu,
		UINT	fuFlags,
		int	x,
		int	y,
		HWND	hWnd,
		LPTPMPARAMS	lptpm
	)

Definition at line 6624 of file menu.c.

{
   PMENU menu;
   PWND pWnd;
   TPMPARAMS tpm;
   BOOL Ret = FALSE;
   USER_REFERENCE_ENTRY Ref;
 
   TRACE("Enter NtUserTrackPopupMenuEx\n");
   UserEnterExclusive();
   /* Parameter check */
   if (!(menu = UserGetMenuObject( hMenu )))
   {
      ERR("TPME : Invalid Menu handle.\n");
      EngSetLastError( ERROR_INVALID_MENU_HANDLE );
      goto Exit;
   }
 
   if (!(pWnd = UserGetWindowObject(hWnd)))
   {
      ERR("TPME : Invalid Window handle.\n");
      goto Exit;
   }
 
   if (lptpm)
   {
      _SEH2_TRY
      {
         ProbeForRead(lptpm, sizeof(TPMPARAMS), sizeof(ULONG));
         tpm = *lptpm;
      }
      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
      { 
         _SEH2_YIELD(goto Exit);
      }
      _SEH2_END
   }
   UserRefObjectCo(pWnd, &Ref);
   Ret = IntTrackPopupMenuEx(menu, fuFlags, x, y, pWnd, lptpm ? &tpm : NULL);
   UserDerefObjectCo(pWnd);
 
Exit:
   TRACE("Leave NtUserTrackPopupMenuEx, ret=%i\n",Ret);
   UserLeave();
   return Ret;
}

Referenced by TrackPopupMenu().

PopupMenuWndProc()

BOOL WINAPI PopupMenuWndProc	(	PWND	Wnd,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	lResult
	)

Definition at line 4647 of file menu.c.

{
  PPOPUPMENU pPopupMenu;
 
  *lResult = 0;
 
  TRACE("PMWP : pwnd=%x msg=%d wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);
 
  if (Wnd)
  {
     if (!Wnd->fnid)
     {
        if (Message != WM_NCCREATE)
        {
           *lResult = IntDefWindowProc(Wnd, Message, wParam, lParam, FALSE);
           return TRUE;
        }
        Wnd->fnid = FNID_MENU;
        pPopupMenu = DesktopHeapAlloc( Wnd->head.rpdesk, sizeof(POPUPMENU) );
        if (pPopupMenu == NULL)
        {
            return TRUE;
        }
        pPopupMenu->posSelectedItem = NO_SELECTED_ITEM;
        pPopupMenu->spwndPopupMenu = Wnd;
        ((PMENUWND)Wnd)->ppopupmenu = pPopupMenu;
        TRACE("Pop Up Menu is Setup! Msg %d\n",Message);
        *lResult = 1;
        return TRUE;
     }
     else
     {
        if (Wnd->fnid != FNID_MENU)
        {
           ERR("Wrong window class for Menu! fnid %x\n",Wnd->fnid);
           return TRUE;
        }
        pPopupMenu = ((PMENUWND)Wnd)->ppopupmenu;
     }
  }
 
  switch(Message)
    {
    case WM_CREATE:
      {
        CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam;
        pPopupMenu->spmenu = UserGetMenuObject(cs->lpCreateParams);
        if (pPopupMenu->spmenu)
        {
           UserReferenceObject(pPopupMenu->spmenu);
        }
        break;
      }
 
    case WM_MOUSEACTIVATE:  /* We don't want to be activated */
      *lResult = MA_NOACTIVATE;
      break;
 
    case WM_PAINT:
      {
        PAINTSTRUCT ps;
        IntBeginPaint(Wnd, &ps);
        MENU_DrawPopupMenu(Wnd, ps.hdc, pPopupMenu->spmenu);
        IntEndPaint(Wnd, &ps);
        break;
      }
 
    case WM_PRINTCLIENT:
      {
         MENU_DrawPopupMenu( Wnd, (HDC)wParam, pPopupMenu->spmenu);
         break;
      }
 
    case WM_ERASEBKGND:
      *lResult = 1;
      break;
 
    case WM_DESTROY:
      /* zero out global pointer in case resident popup window was destroyed. */
      if (pPopupMenu)
      {
         if (UserHMGetHandle(Wnd) == top_popup)
         {
             top_popup = NULL;
             top_popup_hmenu = NULL;
         }
      }
      else
      {
         ERR("No Window Pop Up!\n");
      }
      break;
 
    case WM_NCDESTROY:
      {
         if (pPopupMenu->spmenu)
         {
            IntReleaseMenuObject(pPopupMenu->spmenu);
         }
         DesktopHeapFree(Wnd->head.rpdesk, pPopupMenu );
         ((PMENUWND)Wnd)->ppopupmenu = 0;
         Wnd->fnid = FNID_DESTROY;
         break;
      }
 
    case MM_SETMENUHANDLE: // wine'isms
    case MN_SETHMENU:
      {
        PMENU pmenu = UserGetMenuObject((HMENU)wParam);
        if (!pmenu)
        {
           ERR("Bad Menu Handle\n");
           break;
        }
        UserReferenceObject(pmenu);
        if (pPopupMenu->spmenu)
        {
           IntReleaseMenuObject(pPopupMenu->spmenu);
        }
        pPopupMenu->spmenu = pmenu;
        break;
      }
 
    case MM_GETMENUHANDLE: // wine'isms
    case MN_GETHMENU:
         *lResult = (LRESULT)(pPopupMenu ? (pPopupMenu->spmenu ? UserHMGetHandle(pPopupMenu->spmenu) : NULL) : NULL);
         break;
 
    default:
      if (Message > MN_GETHMENU && Message < MN_GETHMENU+19)
      {
         ERR("Someone is passing unknown menu messages %d\n",Message);
      }
      TRACE("PMWP to IDWP %d\n",Message);
      *lResult = IntDefWindowProc(Wnd, Message, wParam, lParam, FALSE);
      break;
    }
 
  return TRUE;
}

Referenced by co_IntSendMessageTimeoutSingle(), co_IntSendMessageWithCallBack(), IntDispatchMessage(), and NtUserMessageCall().

RECTL_Intersect()

static BOOL RECTL_Intersect ( const RECT *  pRect, INT  x, INT  y, UINT  width, UINT  height  )

static

Definition at line 2880 of file menu.c.

{
    RECT other = {x, y, x + width, y + height};
    RECT dum;
 
    return RECTL_bIntersectRect(&dum, pRect, &other);
}

Referenced by MENU_ShowPopup().

UITOOLS95_DrawFrameMenu()

BOOL FASTCALL UITOOLS95_DrawFrameMenu	(	HDC	dc,
		LPRECT	r,
		UINT	uFlags
	)

Definition at line 959 of file draw.c.

{
    LOGFONTW lf;
    HFONT hFont, hOldFont;
    WCHAR Symbol;
    RECT myr;
    INT cxy;
    cxy = UITOOLS_MakeSquareRect(r, &myr);
    switch(uFlags & 0x1f)
    {
        case DFCS_MENUARROWUP:
            Symbol = '5';
            break;
 
        case DFCS_MENUARROWDOWN:
            Symbol = '6';
            break;
 
        case DFCS_MENUARROW:
            Symbol = '8';
            break;
 
        case DFCS_MENUARROWRIGHT:
        Symbol = 'w'; // FIXME: needs to confirm
        break;
 
        case DFCS_MENUBULLET:
            Symbol = 'h';
            break;
 
        case DFCS_MENUCHECK:
        case DFCS_MENUCHECK | DFCS_MENUBULLET:
            Symbol = 'a';
            break;
 
        default:
            ERR("Invalid menu; flags=0x%04x\n", uFlags);
            return FALSE;
    }
    /* acquire ressources only if valid menu */
    RtlZeroMemory(&lf, sizeof(LOGFONTW));
    lf.lfHeight = cxy;
    lf.lfWidth = 0;
    lf.lfWeight = FW_NORMAL;
    lf.lfCharSet = DEFAULT_CHARSET;
    RtlCopyMemory(lf.lfFaceName, L"Marlett", sizeof(L"Marlett"));
    hFont = GreCreateFontIndirectW(&lf);
    /* save font */
    hOldFont = NtGdiSelectFont(dc, hFont);
 
    if ((uFlags & 0x1f) == DFCS_MENUARROWUP ||
        (uFlags & 0x1f) == DFCS_MENUARROWDOWN )
    {
#if 0
       if (uFlags & DFCS_INACTIVE)
       {
           /* draw shadow */
           IntGdiSetTextColor(dc, IntGetSysColor(COLOR_BTNHIGHLIGHT));
           GreTextOutW(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
       }
#endif
       IntGdiSetTextColor(dc, IntGetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
    }
    /* draw selected symbol */
    GreTextOutW(dc, myr.left, myr.top, &Symbol, 1);
    /* restore previous settings */
    NtGdiSelectFont(dc, hOldFont);
    GreDeleteObject(hFont);
    return TRUE;
}

Referenced by DrawFrameControl(), MENU_DrawMenuItem(), MENU_DrawScrollArrows(), and RealDrawFrameControl().

UserCreateMenu()

HMENU FASTCALL UserCreateMenu	(	PDESKTOP	Desktop,
		BOOL	PopupMenu
	)

Definition at line 5048 of file menu.c.

{
   PWINSTATION_OBJECT WinStaObject;
   HANDLE Handle;
   PMENU Menu;
   NTSTATUS Status;
   PEPROCESS CurrentProcess = PsGetCurrentProcess();
 
   if (gpepCSRSS != CurrentProcess)
   {
      /*
       * gpepCSRSS does not have a Win32WindowStation
       */
 
      Status = IntValidateWindowStationHandle(CurrentProcess->Win32WindowStation,
                     UserMode,
                     0,
                     &WinStaObject,
                     0);
 
       if (!NT_SUCCESS(Status))
       {
          ERR("Validation of window station handle (%p) failed\n",
              CurrentProcess->Win32WindowStation);
          SetLastNtError(Status);
          return (HMENU)0;
       }
       Menu = IntCreateMenu(&Handle, !PopupMenu, Desktop, GetW32ProcessInfo());
       if (Menu && Menu->head.rpdesk->rpwinstaParent != WinStaObject)
       {
          ERR("Desktop Window Station does not match Process one!\n");
       }
       ObDereferenceObject(WinStaObject);
   }
   else
   {
       Menu = IntCreateMenu(&Handle, !PopupMenu, GetW32ThreadInfo()->rpdesk, GetW32ProcessInfo());
   }
 
   if (Menu) UserDereferenceObject(Menu);
   return (HMENU)Handle;
}

Referenced by MENU_GetSystemMenu(), and NtUserCallNoParam().

UserDestroyMenu()

BOOL FASTCALL UserDestroyMenu

(

HMENU

hMenu

)

Definition at line 5812 of file menu.c.

{
   PMENU Menu;
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      return FALSE;
   }
 
   if (Menu->head.rpdesk != pti->rpdesk)
   {
      EngSetLastError(ERROR_ACCESS_DENIED);
      return FALSE;
   }
   return IntDestroyMenuObject(Menu, FALSE);
}

Referenced by MENU_GetSystemMenu().

UserDestroyMenuObject()

BOOLEAN UserDestroyMenuObject

(

PVOID

Object

)

Definition at line 311 of file menu.c.

{
    return IntDestroyMenuObject(Object, TRUE);
}

UserInsertMenuItem()

DWORD FASTCALL UserInsertMenuItem	(	PMENU	Menu,
		UINT	uItem,
		BOOL	fByPosition,
		LPCMENUITEMINFOW	UnsafeItemInfo,
		PUNICODE_STRING	lpstr
	)

Definition at line 4951 of file menu.c.

{
   NTSTATUS Status;
   ROSMENUITEMINFO ItemInfo;
 
   /* Try to copy the whole MENUITEMINFOW structure */
   Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, sizeof(MENUITEMINFOW));
   if (NT_SUCCESS(Status))
   {
      if (sizeof(MENUITEMINFOW) != ItemInfo.cbSize
         && FIELD_OFFSET(MENUITEMINFOW, hbmpItem) != ItemInfo.cbSize)
      {
         EngSetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
      }
      return IntInsertMenuItem(Menu, uItem, fByPosition, &ItemInfo, lpstr);
   }
 
   /* Try to copy without last field (not present in older versions) */
   Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, FIELD_OFFSET(MENUITEMINFOW, hbmpItem));
   if (NT_SUCCESS(Status))
   {
      if (FIELD_OFFSET(MENUITEMINFOW, hbmpItem) != ItemInfo.cbSize)
      {
         EngSetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
      }
      ItemInfo.hbmpItem = (HBITMAP)0;
      return IntInsertMenuItem(Menu, uItem, fByPosition, &ItemInfo, lpstr);
   }
 
   SetLastNtError(Status);
   return FALSE;
}

Referenced by NtUserThunkedMenuItemInfo().

UserMenuInfo()

BOOL FASTCALL UserMenuInfo	(	PMENU	Menu,
		PROSMENUINFO	UnsafeMenuInfo,
		BOOL	SetOrGet
	)

Definition at line 5194 of file menu.c.

{
   BOOL Res;
   DWORD Size;
   NTSTATUS Status;
   ROSMENUINFO MenuInfo;
 
   Status = MmCopyFromCaller(&Size, &UnsafeMenuInfo->cbSize, sizeof(DWORD));
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return FALSE;
   }
   if ( Size < sizeof(MENUINFO) || Size > sizeof(ROSMENUINFO) )
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      return FALSE;
   }
   Status = MmCopyFromCaller(&MenuInfo, UnsafeMenuInfo, Size);
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return FALSE;
   }
 
   if(SetOrGet)
   {
      /* Set MenuInfo */
      Res = IntSetMenuInfo(Menu, &MenuInfo);
   }
   else
   {
      /* Get MenuInfo */
      Res = IntGetMenuInfo(Menu, &MenuInfo);
      if (Res)
      {
         Status = MmCopyToCaller(UnsafeMenuInfo, &MenuInfo, Size);
         if (! NT_SUCCESS(Status))
         {
            SetLastNtError(Status);
            return FALSE;
         }
      }
   }
 
   return Res;
}

Referenced by NtUserThunkedMenuInfo().

UserMenuItemInfo()

BOOL FASTCALL UserMenuItemInfo	(	PMENU	Menu,
		UINT	Item,
		BOOL	ByPosition,
		PROSMENUITEMINFO	UnsafeItemInfo,
		BOOL	SetOrGet,
		PUNICODE_STRING	lpstr
	)

Definition at line 5120 of file menu.c.

{
   PITEM MenuItem;
   ROSMENUITEMINFO ItemInfo;
   NTSTATUS Status;
   UINT Size;
   BOOL Ret;
 
   Status = MmCopyFromCaller(&Size, &UnsafeItemInfo->cbSize, sizeof(UINT));
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return FALSE;
   }
   if ( Size != sizeof(MENUITEMINFOW) && 
        Size != FIELD_OFFSET(MENUITEMINFOW, hbmpItem) &&
        Size != sizeof(ROSMENUITEMINFO) )
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      return FALSE;
   }
   Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, Size);
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return FALSE;
   }
   /* If this is a pre-0x0500 _WIN32_WINNT MENUITEMINFOW, you can't
      set/get hbmpItem */
   if (FIELD_OFFSET(MENUITEMINFOW, hbmpItem) == Size
         && 0 != (ItemInfo.fMask & MIIM_BITMAP))
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
      return FALSE;
   }
 
   if (!(MenuItem = MENU_FindItem( &Menu, &Item, (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND) )))
   {
      /* workaround for Word 95: pretend that SC_TASKLIST item exists. */
      if ( SetOrGet && Item == SC_TASKLIST && !ByPosition )
         return TRUE;
 
      EngSetLastError(ERROR_MENU_ITEM_NOT_FOUND);
      return FALSE;
   }
 
   if (SetOrGet)
   {
      Ret = IntSetMenuItemInfo(Menu, MenuItem, &ItemInfo, lpstr);
   }
   else
   {
      Ret = IntGetMenuItemInfo(Menu, MenuItem, &ItemInfo);
      if (Ret)
      {
         Status = MmCopyToCaller(UnsafeItemInfo, &ItemInfo, Size);
         if (! NT_SUCCESS(Status))
         {
            SetLastNtError(Status);
            return FALSE;
         }
      }
   }
 
   return Ret;
}

Referenced by NtUserThunkedMenuItemInfo().

UserSetMenuDefaultItem()

BOOL FASTCALL UserSetMenuDefaultItem	(	PMENU	MenuObject,
		UINT	uItem,
		UINT	fByPos
	)

Definition at line 1274 of file menu.c.

{
   UINT i;
   PITEM MenuItem = MenuObject->rgItems;
 
   if (!MenuItem) return FALSE;
 
   /* reset all default-item flags */
   for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
   {
       MenuItem->fState &= ~MFS_DEFAULT;
   }
 
   /* no default item */
   if(uItem == (UINT)-1)
   {
      return TRUE;
   }
   MenuItem = MenuObject->rgItems;
   if ( fByPos )
   {
      if ( uItem >= MenuObject->cItems ) return FALSE;
         MenuItem[uItem].fState |= MFS_DEFAULT;
      return TRUE;
   }
   else
   {
      for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
      {
          if (MenuItem->wID == uItem)
          {
             MenuItem->fState |= MFS_DEFAULT;
             return TRUE;
          }
      }
 
   }
   return FALSE;
}

Referenced by IntSetMenuItemInfo(), MENU_GetSystemMenu(), MENU_InitSysMenuPopup(), and NtUserSetMenuDefaultItem().

VerifyMenu()

PMENU FASTCALL VerifyMenu

(

PMENU

pMenu

)

Definition at line 201 of file menu.c.

{
   HMENU hMenu;
   PITEM pItem;
   ULONG Error;
   UINT i;
   if (!pMenu) return NULL;
 
   Error = EngGetLastError();
 
   _SEH2_TRY
   {
      hMenu = UserHMGetHandle(pMenu);
      pItem = pMenu->rgItems;
      if (pItem)
      {
         i = pItem[0].wID;
         pItem[0].wID = i;
      }
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      ERR("Run away LOOP!\n");
      EngSetLastError(Error);
      _SEH2_YIELD(return NULL);
   }
   _SEH2_END
 
   if ( UserObjectInDestroy(hMenu))
   {
      ERR("Menu is marked for destruction!\n");
      pMenu = NULL;
   }
   EngSetLastError(Error);
   return pMenu;
}

Referenced by MENU_FindItemByKey(), MENU_HideSubPopups(), MENU_TrackKbdMenuBar(), MENU_TrackMenu(), and MENU_TrackMouseMenuBar().

Variable Documentation

fInEndMenu

BOOL fInEndMenu = FALSE

Definition at line 26 of file menu.c.

Referenced by MENU_EndMenu(), and MENU_InitTracking().

fInsideMenuLoop

BOOL fInsideMenuLoop = FALSE

Definition at line 25 of file menu.c.

Referenced by MENU_EndMenu(), MENU_InitTracking(), MENU_TrackMenu(), and NtUserEndMenu().

ghMenuFont

HFONT ghMenuFont = NULL

Definition at line 16 of file menu.c.

Referenced by IntDrawMenuBarTemp(), MENU_DrawMenuBar(), MENU_DrawPopupMenu(), MENU_PopupMenuCalcSize(), MENU_SelectItem(), MENU_ShowSubPopup(), and MenuInit().

ghMenuFontBold

HFONT ghMenuFontBold = NULL

Definition at line 17 of file menu.c.

Referenced by MENU_CalcItemSize(), MENU_DrawMenuItem(), and MenuInit().

MenuCharSize

SIZE MenuCharSize

static

Definition at line 18 of file menu.c.

Referenced by MENU_CalcItemSize(), and MENU_DrawMenuItem().

top_popup

HWND top_popup = NULL

static

Definition at line 22 of file menu.c.

Referenced by MENU_EndMenu(), MENU_ExitTracking(), MENU_HideSubPopups(), MENU_InitTracking(), MENU_IsMenuActive(), MENU_SelectItem(), MENU_ShowPopup(), NtUserEndMenu(), and PopupMenuWndProc().

top_popup_hmenu

HMENU top_popup_hmenu = NULL

static

Definition at line 23 of file menu.c.

Referenced by MENU_EndMenu(), MENU_ExitTracking(), MENU_HideSubPopups(), MENU_InitTracking(), MENU_SelectItem(), MENU_ShowPopup(), NtUserGetMenuBarInfo(), and PopupMenuWndProc().