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);
        }
        UserDeref