menu.c File Reference

#include <user32.h>

Include dependency graph for menu.c:

Go to the source code of this file.

Macros
#define	MM_SETMENUHANDLE   (WM_USER + 0)
#define	MM_GETMENUHANDLE   (WM_USER + 1)
#define	MENU_TYPE_MASK   (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR)
#define	MENU_ITEM_TYPE(flags)   ((flags) & MENU_TYPE_MASK)
#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_STRING_ITEM(flags)   (MF_STRING == MENU_ITEM_TYPE(flags))
#define	IS_MAGIC_BITMAP(id)   ((id) && ((INT_PTR)(id) < 12) && ((INT_PTR)(id) >= -1))
#define	IS_SYSTEM_MENU(MenuInfo)   (0 == ((MenuInfo)->fFlags & MNF_POPUP) && 0 != ((MenuInfo)->fFlags & MNF_SYSMENU))
#define	IS_SYSTEM_POPUP(MenuInfo)   (0 != ((MenuInfo)->fFlags & MNF_POPUP) && 0 != ((MenuInfo)->fFlags & MNF_SYSMENU))
#define	IS_BITMAP_ITEM(flags)   (MF_BITMAP == MENU_ITEM_TYPE(flags))
#define	GET_WORD(ptr)   (*(WORD *)(ptr))
#define	GET_DWORD(ptr)   (*(DWORD *)(ptr))

Functions
BOOL WINAPI	GdiValidateHandle (HGDIOBJ hobj)
	WINE_DEFAULT_DEBUG_CHANNEL (menu)
FORCEINLINE PMENU	MENU_GetMenu (HMENU hMenu)
ITEM *	MENU_FindItem (HMENU *hmenu, UINT *nPos, UINT wFlags)
UINT FASTCALL	IntGetMenuDefaultItem (PMENU Menu, BOOL fByPos, UINT gmdiFlags, DWORD *gismc)
static BOOL	GetMenuItemInfo_common (HMENU hmenu, UINT item, BOOL bypos, LPMENUITEMINFOW lpmii, BOOL unicode)
LRESULT WINAPI	PopupMenuWndProcW (HWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	PopupMenuWndProcA (HWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam)
static LPCSTR	MENU_ParseResource (LPCSTR res, HMENU hMenu)
static LPCSTR	MENUEX_ParseResource (LPCSTR res, HMENU hMenu)
static void	MENU_mnu2mnuii (UINT flags, UINT_PTR id, LPCWSTR str, LPMENUITEMINFOW pmii, BOOL Unicode)
static BOOL	MENU_NormalizeMenuItemInfoStruct (const MENUITEMINFOW *pmii_in, MENUITEMINFOW *pmii_out)
BOOL	MenuInit (VOID)
VOID	MenuCleanup (VOID)
NTSTATUS WINAPI	User32LoadSysMenuTemplateForKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallLoadMenuFromKernel (PVOID Arguments, ULONG ArgumentLength)
BOOL WINAPI	AppendMenuA (HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem)
BOOL WINAPI	AppendMenuW (HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem)
DWORD WINAPI	CheckMenuItem (HMENU hmenu, UINT uIDCheckItem, UINT uCheck)
BOOL WINAPI	CheckMenuRadioItem (HMENU hMenu, UINT first, UINT last, UINT check, UINT bypos)
HMENU WINAPI	CreateMenu (VOID)
HMENU WINAPI	CreatePopupMenu (VOID)
BOOL WINAPI	DrawMenuBar (HWND hWnd)
BOOL WINAPI	EnableMenuItem (HMENU hMenu, UINT uIDEnableItem, UINT uEnable)
HMENU WINAPI	GetMenu (HWND hWnd)
LONG WINAPI	GetMenuCheckMarkDimensions (VOID)
DWORD WINAPI	GetMenuContextHelpId (HMENU hmenu)
UINT WINAPI	GetMenuDefaultItem (HMENU hMenu, UINT fByPos, UINT gmdiFlags)
BOOL WINAPI	GetMenuInfo (HMENU hmenu, LPMENUINFO lpcmi)
int WINAPI	GetMenuItemCount (HMENU hmenu)
UINT WINAPI	GetMenuItemID (HMENU hMenu, int nPos)
BOOL WINAPI	GetMenuItemInfoA (HMENU hmenu, UINT item, BOOL bypos, LPMENUITEMINFOA lpmii)
BOOL WINAPI	GetMenuItemInfoW (HMENU hMenu, UINT Item, BOOL bypos, LPMENUITEMINFOW lpmii)
UINT WINAPI	GetMenuState (HMENU hMenu, UINT uId, UINT uFlags)
int WINAPI	GetMenuStringA (HMENU hMenu, UINT uIDItem, LPSTR lpString, int nMaxCount, UINT uFlag)
int WINAPI	GetMenuStringW (HMENU hMenu, UINT uIDItem, LPWSTR lpString, int nMaxCount, UINT uFlag)
HMENU WINAPI	GetSubMenu (HMENU hMenu, int nPos)
HMENU WINAPI	GetSystemMenu (HWND hWnd, BOOL bRevert)
BOOL WINAPI	InsertMenuA (HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem)
BOOL WINAPI	InsertMenuItemA (HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOA lpmii)
BOOL WINAPI	InsertMenuItemW (HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii)
BOOL WINAPI	InsertMenuW (HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem)
BOOL WINAPI	IsMenu (HMENU Menu)
HMENU WINAPI	LoadMenuA (HINSTANCE hInstance, LPCSTR lpMenuName)
HMENU WINAPI	LoadMenuIndirectA (CONST MENUTEMPLATE *lpMenuTemplate)
HMENU WINAPI	LoadMenuIndirectW (CONST MENUTEMPLATE *lpMenuTemplate)
HMENU WINAPI	LoadMenuW (HINSTANCE hInstance, LPCWSTR lpMenuName)
BOOL WINAPI	ModifyMenuA (HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem)
BOOL WINAPI	ModifyMenuW (HMENU hMenu, UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, LPCWSTR lpNewItem)
BOOL WINAPI	SetMenu (HWND hWnd, HMENU hMenu)
BOOL WINAPI	SetMenuInfo (HMENU hmenu, LPCMENUINFO lpcmi)
BOOL WINAPI	SetMenuItemBitmaps (HMENU hMenu, UINT uPosition, UINT uFlags, HBITMAP hBitmapUnchecked, HBITMAP hBitmapChecked)
BOOL WINAPI	SetMenuItemInfoA (HMENU hmenu, UINT item, BOOL bypos, LPCMENUITEMINFOA lpmii)
BOOL WINAPI	SetMenuItemInfoW (HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii)
BOOL WINAPI	SetSystemMenu (HWND hwnd, HMENU hMenu)
BOOL WINAPI	TrackPopupMenu (HMENU Menu, UINT Flags, int x, int y, int Reserved, HWND Wnd, CONST RECT *Rect)
LRESULT WINAPI	MenuWindowProcA (HWND hWnd, ULONG_PTR Result, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	MenuWindowProcW (HWND hWnd, ULONG_PTR Result, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL WINAPI	ChangeMenuW (HMENU hMenu, UINT cmd, LPCWSTR lpszNewItem, UINT cmdInsert, UINT flags)
BOOL WINAPI	ChangeMenuA (HMENU hMenu, UINT cmd, LPCSTR lpszNewItem, UINT cmdInsert, UINT flags)

Variables
const struct builtin_class_descr	POPUPMENU_builtin_class

Macro Definition Documentation

GET_DWORD

#define GET_DWORD

(

ptr

)

(*(DWORD *)(ptr))

Definition at line 71 of file menu.c.

GET_WORD

#define GET_WORD

(

ptr

)

(*(WORD *)(ptr))

Definition at line 68 of file menu.c.

IS_BITMAP_ITEM

#define IS_BITMAP_ITEM

(

flags

)

(MF_BITMAP == MENU_ITEM_TYPE(flags))

Definition at line 51 of file menu.c.

IS_MAGIC_BITMAP

#define IS_MAGIC_BITMAP

(

id

)

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

Definition at line 43 of file menu.c.

IS_STRING_ITEM

#define IS_STRING_ITEM

(

flags

)

(MF_STRING == MENU_ITEM_TYPE(flags))

Definition at line 42 of file menu.c.

IS_SYSTEM_MENU

#define IS_SYSTEM_MENU

(

MenuInfo

)

(0 == ((MenuInfo)->fFlags & MNF_POPUP) && 0 != ((MenuInfo)->fFlags & MNF_SYSMENU))

Definition at line 45 of file menu.c.

IS_SYSTEM_POPUP

#define IS_SYSTEM_POPUP

(

MenuInfo

)

(0 != ((MenuInfo)->fFlags & MNF_POPUP) && 0 != ((MenuInfo)->fFlags & MNF_SYSMENU))

Definition at line 48 of file menu.c.

MENU_ITEM_TYPE

#define MENU_ITEM_TYPE

(

flags

)

((flags) & MENU_TYPE_MASK)

Definition at line 24 of file menu.c.

MENU_TYPE_MASK

#define MENU_TYPE_MASK   (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR)

Definition at line 22 of file menu.c.

MENUITEMINFO_STATE_MASK

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

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

MII_STATE_MASK

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

Definition at line 39 of file menu.c.

MM_GETMENUHANDLE

#define MM_GETMENUHANDLE   (WM_USER + 1)

Definition at line 20 of file menu.c.

MM_SETMENUHANDLE

#define MM_SETMENUHANDLE   (WM_USER + 0)

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

STATE_MASK

#define STATE_MASK   (~TYPE_MASK)

Definition at line 35 of file menu.c.

TYPE_MASK

#define TYPE_MASK   (MENUITEMINFO_TYPE_MASK | MF_POPUP | MF_SYSMENU)

Definition at line 33 of file menu.c.

Function Documentation

AppendMenuA()

BOOL WINAPI AppendMenuA	(	HMENU	hMenu,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCSTR	lpNewItem
	)

Definition at line 684 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING UnicodeString;
  BOOL res;

  RtlInitUnicodeString(&UnicodeString, 0);

  MENU_mnu2mnuii( uFlags, uIDNewItem, (LPCWSTR)lpNewItem, &mii, FALSE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
      if (!RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)mii.dwTypeData))
      {
        SetLastError (ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
      }
      mii.dwTypeData = UnicodeString.Buffer;
      mii.cch = UnicodeString.Length / sizeof(WCHAR);
  }
  else
  {
      TRACE("AMA Handle bitmaps\n");
  }
  res = NtUserThunkedMenuItemInfo(hMenu, -1, TRUE, TRUE, &mii, &UnicodeString);
  if ( UnicodeString.Buffer ) RtlFreeUnicodeString ( &UnicodeString );
  return res;
}

Referenced by ChangeMenuA(), create_menu_from_data(), menu_fill_in_init(), test_AppendMenu(), test_getmenubarinfo(), test_GetMenuItemRect(), test_menu_cancelmode(), test_menu_circref(), test_menu_flags(), test_menu_hilitemenuitem(), test_menu_input(), test_menu_maxdepth(), test_menu_ownerdraw(), test_menu_resource_layout(), test_menu_search_bycommand(), test_menu_trackagain(), and test_menu_trackpopupmenu().

AppendMenuW()

BOOL WINAPI AppendMenuW	(	HMENU	hMenu,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCWSTR	lpNewItem
	)

Definition at line 722 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING MenuText;
  BOOL res;

  RtlInitUnicodeString(&MenuText, 0);    

  MENU_mnu2mnuii( uFlags, uIDNewItem, lpNewItem, &mii, TRUE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
    RtlInitUnicodeString(&MenuText, (PWSTR)mii.dwTypeData);
    mii.dwTypeData = MenuText.Buffer;
    mii.cch = MenuText.Length / sizeof(WCHAR);
  }
  res = NtUserThunkedMenuItemInfo(hMenu, -1, TRUE, TRUE, &mii, &MenuText);
  return res;
}

Referenced by ChangeMenuW(), and MENU_ParseResource().

ChangeMenuA()

BOOL WINAPI ChangeMenuA	(	HMENU	hMenu,
		UINT	cmd,
		LPCSTR	lpszNewItem,
		UINT	cmdInsert,
		UINT	flags
	)

Definition at line 1752 of file menu.c.

{
    /*
        FIXME: Word passes the item id in 'cmd' and 0 or 0xffff as cmdInsert
        for MF_DELETE. We should check the parameters for all others
        MF_* actions also (anybody got a doc on ChangeMenu?).
    */

    switch(flags & (MF_APPEND | MF_DELETE | MF_CHANGE | MF_REMOVE | MF_INSERT))
    {
        case MF_APPEND :
            return AppendMenuA(hMenu, flags &~ MF_APPEND, cmdInsert, lpszNewItem);

        case MF_DELETE :
            return DeleteMenu(hMenu, cmd, flags &~ MF_DELETE);

        case MF_CHANGE :
            return ModifyMenuA(hMenu, cmd, flags &~ MF_CHANGE, cmdInsert, lpszNewItem);

        case MF_REMOVE :
            return RemoveMenu(hMenu, flags & MF_BYPOSITION ? cmd : cmdInsert,
                                flags &~ MF_REMOVE);

        default :   /* MF_INSERT */
            return InsertMenuA(hMenu, cmd, flags, cmdInsert, lpszNewItem);
    };
}

ChangeMenuW()

BOOL WINAPI ChangeMenuW	(	HMENU	hMenu,
		UINT	cmd,
		LPCWSTR	lpszNewItem,
		UINT	cmdInsert,
		UINT	flags
	)

Definition at line 1714 of file menu.c.

{
    /*
        FIXME: Word passes the item id in 'cmd' and 0 or 0xffff as cmdInsert
        for MF_DELETE. We should check the parameters for all others
        MF_* actions also (anybody got a doc on ChangeMenu?).
    */

    switch(flags & (MF_APPEND | MF_DELETE | MF_CHANGE | MF_REMOVE | MF_INSERT))
    {
        case MF_APPEND :
            return AppendMenuW(hMenu, flags &~ MF_APPEND, cmdInsert, lpszNewItem);

        case MF_DELETE :
            return DeleteMenu(hMenu, cmd, flags &~ MF_DELETE);

        case MF_CHANGE :
            return ModifyMenuW(hMenu, cmd, flags &~ MF_CHANGE, cmdInsert, lpszNewItem);

        case MF_REMOVE :
            return RemoveMenu(hMenu, flags & MF_BYPOSITION ? cmd : cmdInsert,
                                flags &~ MF_REMOVE);

        default :   /* MF_INSERT */
            return InsertMenuW(hMenu, cmd, flags, cmdInsert, lpszNewItem);
    };
}

CheckMenuItem()

DWORD WINAPI CheckMenuItem	(	HMENU	hmenu,
		UINT	uIDCheckItem,
		UINT	uCheck
	)

Definition at line 750 of file menu.c.

{
  PITEM item;
  DWORD Ret;
  UINT uID = uIDCheckItem;

  if (!ValidateHandle(hmenu, TYPE_MENU))
     return -1;

  if (!(item = MENU_FindItem( &hmenu, &uID, uCheck ))) return -1;

  Ret = item->fState & MFS_CHECKED;
  if ( Ret == (uCheck & MFS_CHECKED)) return Ret; // Already Checked...

  return NtUserCheckMenuItem(hmenu, uIDCheckItem, uCheck);
}

Referenced by test_system_menu().

CheckMenuRadioItem()

BOOL WINAPI CheckMenuRadioItem	(	HMENU	hMenu,
		UINT	first,
		UINT	last,
		UINT	check,
		UINT	bypos
	)

Definition at line 773 of file menu.c.

{
    BOOL done = FALSE;
    UINT i;
    PITEM mi_first = NULL, mi_check;
    HMENU m_first, m_check;
    MENUITEMINFOW mii;
    mii.cbSize = sizeof( mii);

    for (i = first; i <= last; i++)
    {
        UINT pos = i;

        if (!mi_first)
        {
            m_first = hMenu;
            mi_first = MENU_FindItem(&m_first, &pos, bypos);
            if (!mi_first) continue;
            mi_check = mi_first;
            m_check = m_first;
        }
        else
        {
            m_check = hMenu;
            mi_check = MENU_FindItem(&m_check, &pos, bypos);
            if (!mi_check) continue;
        }

        if (m_first != m_check) continue;
        if (mi_check->fType == MFT_SEPARATOR) continue;

        if (i == check)
        {
            if (!(mi_check->fType & MFT_RADIOCHECK) || !(mi_check->fState & MFS_CHECKED))
            {
               mii.fMask = MIIM_FTYPE | MIIM_STATE;
               mii.fType = (mi_check->fType & MENUITEMINFO_TYPE_MASK) | MFT_RADIOCHECK;
               mii.fState = (mi_check->fState & MII_STATE_MASK) | MFS_CHECKED;
               NtUserThunkedMenuItemInfo(m_check, i, bypos, FALSE, &mii, NULL);
            }
            done = TRUE;
        }
        else
        {
            /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
            if (mi_check->fState & MFS_CHECKED)
            {
               mii.fMask = MIIM_STATE;
               mii.fState = (mi_check->fState & MII_STATE_MASK) & ~MFS_CHECKED;
               NtUserThunkedMenuItemInfo(m_check, i, bypos, FALSE, &mii, NULL);
            }
        }
    }
    return done;
}

Referenced by test_CheckMenuRadioItem().

CreateMenu()

HMENU WINAPI CreateMenu

(

VOID

)

Definition at line 837 of file menu.c.

{
  return NtUserxCreateMenu();
}

Referenced by AWR_init(), create_menu_from_data(), create_menuitem_from_data(), CDefView::CreateViewWindow3(), CDefView::InitList(), LoadMenuIndirectW(), CNewMenu::QueryContextMenu(), CSendToMenu::QueryContextMenu(), shellex_run_context_menu_default(), START_TEST(), test_AppendMenu(), test_CreateWindow(), test_getmenubarinfo(), test_GetMenuItemRect(), test_mbs_help(), test_mdi(), test_mdi_messages(), test_menu_add_string(), test_menu_cancelmode(), test_menu_flags(), test_menu_getmenuinfo(), test_menu_hilitemenuitem(), test_menu_input(), test_menu_locked_by_window(), test_menu_ownerdraw(), test_menu_search_bycommand(), test_menu_setmenuinfo(), test_messages(), Test_OneParamRoutine_MapDesktopObject(), test_SetMenu(), test_SetParent(), and test_system_menu().

CreatePopupMenu()

HMENU WINAPI CreatePopupMenu

(

VOID

)

Definition at line 846 of file menu.c.

{
  return NtUserxCreatePopupMenu();
}

Referenced by CBandSiteBase::_OnContextMenu(), _ShowContextMenu(), _ShowContextMenuR(), CMenuBand::_TrackContextMenu(), add_favs_to_menu(), AppendMenuItems(), BuildLeftPopupMenu(), CDrivesFolder::CallBack(), CDesktopFolder::CallBack(), CFSFolder::CallBack(), ConWndProc(), DesktopShellView::DoDesktopContextMenu(), CDefView::Exec(), FileMenu_Create(), CDefView::FillFileMenu(), FM_InitMenuPopup(), GuiConsoleAppendMenuItems(), GuiConsoleWndProc(), handle_context_menu(), IFileDialogCustomize_fnAddMenu(), IFileDialogCustomize_fnEnableOpenDropDown(), CFolderItemVerbs::Init(), MENU_ParseResource(), MENUEX_ParseResource(), MONTHCAL_LButtonDown(), MONTHCAL_RButtonUp(), msi_seltree_popup_menu(), OleUIAddVerbMenuW(), CDeviceManager::OnCommand(), CDeviceView::OnContextMenu(), CExplorerBand::OnContextMenu(), CDefView::OnContextMenu(), CDefView::OnExplorerCommand(), CInternetToolbar::OnMenuDropDown(), CISFBand::OnWinEvent(), CDefView::OpenSelectedItems(), COpenWithMenu::QueryContextMenu(), Shell_MergeMenus(), ShellFolderContextMenu(), SHInvokeCommand(), ShowContextMenu(), ShowPowerSchemesPopupMenu(), START_TEST(), TaskManager_OnTabWndSelChange(), test_AppendMenu(), test_capture_4(), test_contextmenu(), test_CShellMenu_params(), test_emptypopup(), test_GetMenuItemRect(), test_mbs_help(), test_menu_cancelmode(), test_menu_circref(), test_menu_flags(), test_menu_hilitemenuitem(), test_menu_input(), test_menu_maxdepth(), test_menu_ownerdraw(), test_menu_trackagain(), test_menu_trackpopupmenu(), test_menualign(), test_OleUIAddVerbMenu(), test_subpopup_locked_by_menu(), test_TrackPopupMenu(), test_TrackPopupMenuEmpty(), and CTrayWindow::TrackCtxMenu().

DrawMenuBar()

BOOL WINAPI DrawMenuBar

(

HWND

hWnd

)

Definition at line 855 of file menu.c.

{
  return NtUserxDrawMenuBar(hWnd);
}

Referenced by test_mbs_help(), and test_menu_locked_by_window().

EnableMenuItem()

BOOL WINAPI EnableMenuItem	(	HMENU	hMenu,
		UINT	uIDEnableItem,
		UINT	uEnable
	)

Definition at line 864 of file menu.c.

{
  return NtUserEnableMenuItem(hMenu, uIDEnableItem, uEnable);
}

Referenced by test_system_menu().

GdiValidateHandle()

BOOL WINAPI GdiValidateHandle

(

HGDIOBJ

hobj

)

Definition at line 712 of file misc.c.

{
    PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hobj);
    if ( (Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 &&
            ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) ==
            GDI_HANDLE_GET_TYPE(hobj) )
    {
        HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1);
        if(pid == NULL || pid == CurrentProcessId)
        {
            return TRUE;
        }
    }
    return FALSE;

}

Referenced by GetMenuItemInfo_common(), InsertMenuItemA(), InsertMenuItemW(), SetMenuItemInfoA(), and SetMenuItemInfoW().

GetMenu()

HMENU WINAPI GetMenu

(

HWND

hWnd

)

Definition at line 875 of file menu.c.

{
       PWND Wnd = ValidateHwnd(hWnd);

       if (!Wnd)
               return NULL;

       return UlongToHandle(Wnd->IDMenu);
}

Referenced by test_menu_locked_by_window(), and WndProc().

GetMenuCheckMarkDimensions()

LONG WINAPI GetMenuCheckMarkDimensions

(

VOID

)

Definition at line 889 of file menu.c.

{
  return(MAKELONG(GetSystemMetrics(SM_CXMENUCHECK),
          GetSystemMetrics(SM_CYMENUCHECK)));
}

GetMenuContextHelpId()

DWORD WINAPI GetMenuContextHelpId

(

HMENU

hmenu

)

Definition at line 900 of file menu.c.

{
  PMENU pMenu;
  if ((pMenu = ValidateHandle(hmenu, TYPE_MENU)))
     return pMenu->dwContextHelpId;
  return 0;
}

GetMenuDefaultItem()

UINT WINAPI GetMenuDefaultItem	(	HMENU	hMenu,
		UINT	fByPos,
		UINT	gmdiFlags
	)

Definition at line 912 of file menu.c.

{
  PMENU pMenu;
  DWORD gismc = 0;
  if (!(pMenu = ValidateHandle(hMenu, TYPE_MENU)))
       return (UINT)-1;

  return IntGetMenuDefaultItem( pMenu, (BOOL)fByPos, gmdiFlags, &gismc);
}

GetMenuInfo()

BOOL WINAPI GetMenuInfo	(	HMENU	hmenu,
		LPMENUINFO	lpcmi
	)

Definition at line 928 of file menu.c.

{
  PMENU pMenu;

  if (!lpcmi || (lpcmi->cbSize != sizeof(MENUINFO)))
  {
     SetLastError(ERROR_INVALID_PARAMETER);
     return FALSE;
  }

  if (!(pMenu = ValidateHandle(hmenu, TYPE_MENU)))
     return FALSE;

  if (lpcmi->fMask & MIM_BACKGROUND)
      lpcmi->hbrBack = pMenu->hbrBack;

  if (lpcmi->fMask & MIM_HELPID)
      lpcmi->dwContextHelpID = pMenu->dwContextHelpId;

  if (lpcmi->fMask & MIM_MAXHEIGHT)
      lpcmi->cyMax = pMenu->cyMax;

  if (lpcmi->fMask & MIM_MENUDATA)
      lpcmi->dwMenuData = pMenu->dwMenuData;

  if (lpcmi->fMask & MIM_STYLE)
      lpcmi->dwStyle = pMenu->fFlags & MNS_STYLE_MASK;

  return TRUE;
}

Referenced by test_mbs_help(), test_menu_bmp_and_string(), test_menu_getmenuinfo(), test_menu_setmenuinfo(), test_menualign(), and test_subpopup_locked_by_menu().

GetMenuItemCount()

int WINAPI GetMenuItemCount

(

HMENU

hmenu

)

Definition at line 964 of file menu.c.

{
  PMENU pMenu;
  if ((pMenu = ValidateHandle(hmenu, TYPE_MENU)))
     return pMenu->cItems;
  return -1;
}

Referenced by check_menu_items(), compare_menu_data(), and test_menu_resource_layout().

GetMenuItemID()

UINT WINAPI GetMenuItemID	(	HMENU	hMenu,
		int	nPos
	)

Definition at line 976 of file menu.c.

{
  ITEM * lpmi;
  if (!(lpmi = MENU_FindItem(&hMenu,(UINT*)&nPos,MF_BYPOSITION))) return -1;
  if (lpmi->spSubMenu) return -1;
  return lpmi->wID;
}

Referenced by test_menu_search_bycommand().

GetMenuItemInfo_common()

static BOOL GetMenuItemInfo_common ( HMENU  hmenu, UINT  item, BOOL  bypos, LPMENUITEMINFOW  lpmii, BOOL  unicode  )

static

Definition at line 175 of file menu.c.

{
    ITEM *pItem = MENU_FindItem (&hmenu, &item, bypos ? MF_BYPOSITION : 0);

    //debug_print_menuitem("GetMenuItemInfo_common: ", pItem, "");

    if (!pItem)
    {
        SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
        return FALSE;
    }

    if( lpmii->fMask & MIIM_TYPE)
    {
        if( lpmii->fMask & ( MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP))
        {
            ERR("invalid combination of fMask bits used\n");
            /* this does not happen on Win9x/ME */
            SetLastError( ERROR_INVALID_PARAMETER);
            return FALSE;
        }
    lpmii->fType = pItem->fType & MENUITEMINFO_TYPE_MASK;
        if (pItem->hbmp && !IS_MAGIC_BITMAP(pItem->hbmp))
            lpmii->fType |= MFT_BITMAP;
    lpmii->hbmpItem = pItem->hbmp; /* not on Win9x/ME */
        if( lpmii->fType & MFT_BITMAP)
        {
        lpmii->dwTypeData = (LPWSTR) pItem->hbmp;
        lpmii->cch = 0;
        }
        else if( lpmii->fType & (MFT_OWNERDRAW | MFT_SEPARATOR))
        {
            /* this does not happen on Win9x/ME */
        lpmii->dwTypeData = 0;
        lpmii->cch = 0;
        }
    }

    /* copy the text string */
    if ((lpmii->fMask & (MIIM_TYPE|MIIM_STRING)))
    {
         if( !pItem->Xlpstr )
         {                                         // Very strange this fixes a wine test with a crash.
                if(lpmii->dwTypeData && lpmii->cch && !(GdiValidateHandle((HGDIOBJ)lpmii->dwTypeData)) )
                {
                    if( unicode)
                        *((WCHAR *)lpmii->dwTypeData) = 0;
                    else
                        *((CHAR *)lpmii->dwTypeData) = 0;
                }
                lpmii->cch = 0;
         }
         else
         {
            int len;
            LPWSTR text = DesktopPtrToUser(pItem->Xlpstr);
            if (unicode)
            {
                len = strlenW(text);
                if(lpmii->dwTypeData && lpmii->cch)
                    lstrcpynW(lpmii->dwTypeData, text, lpmii->cch);
            }
            else
            {
                len = WideCharToMultiByte( CP_ACP, 0, text, -1, NULL, 0, NULL, NULL ) - 1;
                if(lpmii->dwTypeData && lpmii->cch)
                    if (!WideCharToMultiByte( CP_ACP, 0, text, -1,
                            (LPSTR)lpmii->dwTypeData, lpmii->cch, NULL, NULL ))
                        ((LPSTR)lpmii->dwTypeData)[lpmii->cch - 1] = 0;
            }
            /* if we've copied a substring we return its length */
            if(lpmii->dwTypeData && lpmii->cch)
                if (lpmii->cch <= len + 1)
                    lpmii->cch--;
                else
                    lpmii->cch = len;
            else
            {
                /* return length of string */
                /* not on Win9x/ME if fType & MFT_BITMAP */
                lpmii->cch = len;
            }
        }
    }

    if (lpmii->fMask & MIIM_FTYPE)
    lpmii->fType = pItem->fType & MENUITEMINFO_TYPE_MASK;

    if (lpmii->fMask & MIIM_BITMAP)
    lpmii->hbmpItem = pItem->hbmp;

    if (lpmii->fMask & MIIM_STATE)
    lpmii->fState = pItem->fState & MENUITEMINFO_STATE_MASK;

    if (lpmii->fMask & MIIM_ID)
    lpmii->wID = pItem->wID;

    if (lpmii->fMask & MIIM_SUBMENU && pItem->spSubMenu )
    {
        PMENU pSubMenu = DesktopPtrToUser(pItem->spSubMenu);
        HMENU hSubMenu = UserHMGetHandle(pSubMenu);
    lpmii->hSubMenu = hSubMenu;
    }
    else
    {
        /* hSubMenu is always cleared 
         * (not on Win9x/ME ) */
        lpmii->hSubMenu = 0;
    }

    if (lpmii->fMask & MIIM_CHECKMARKS)
    {
    lpmii->hbmpChecked = pItem->hbmpChecked;
    lpmii->hbmpUnchecked = pItem->hbmpUnchecked;
    }
    if (lpmii->fMask & MIIM_DATA)
    lpmii->dwItemData = pItem->dwItemData;

  return TRUE;
}

Referenced by GetMenuItemInfoA(), and GetMenuItemInfoW().

GetMenuItemInfoA()

BOOL WINAPI GetMenuItemInfoA	(	HMENU	hmenu,
		UINT	item,
		BOOL	bypos,
		LPMENUITEMINFOA	lpmii
	)

Definition at line 989 of file menu.c.

{
    BOOL ret;
    MENUITEMINFOA mii;

    if( lpmii->cbSize != sizeof( mii) &&
        lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem))
    {
        SetLastError( ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    memcpy( &mii, lpmii, lpmii->cbSize);
    mii.cbSize = sizeof( mii);
    ret = GetMenuItemInfo_common (hmenu,
                                  item,
                                  bypos,
                                  (LPMENUITEMINFOW)&mii,
                                  FALSE);
    mii.cbSize = lpmii->cbSize;
    memcpy( lpmii, &mii, mii.cbSize);
    return ret;
}

Referenced by check_menu_item_info(), check_menu_items(), compare_menu_data(), test_AppendMenu(), test_menu_add_string(), test_menu_bmp_and_string(), test_menu_ownerdraw(), test_menu_resource_layout(), test_menu_search_bycommand(), test_subpopup_locked_by_menu(), and test_system_menu().

GetMenuItemInfoW()

BOOL WINAPI GetMenuItemInfoW	(	HMENU	hMenu,
		UINT	Item,
		BOOL	bypos,
		LPMENUITEMINFOW	lpmii
	)

Definition at line 1020 of file menu.c.

{
   BOOL ret;
   MENUITEMINFOW mii;
   if( lpmii->cbSize != sizeof( mii) && lpmii->cbSize != sizeof( mii) - sizeof ( mii.hbmpItem))
   {
      SetLastError( ERROR_INVALID_PARAMETER);
      return FALSE;
   }
   memcpy( &mii, lpmii, lpmii->cbSize);
   mii.cbSize = sizeof( mii);
   ret = GetMenuItemInfo_common (hMenu, Item, bypos, &mii, TRUE);
   mii.cbSize = lpmii->cbSize;
   memcpy( lpmii, &mii, mii.cbSize);
   return ret;
}

Referenced by check_menu_item_info().

GetMenuState()

UINT WINAPI GetMenuState	(	HMENU	hMenu,
		UINT	uId,
		UINT	uFlags
	)

Definition at line 1046 of file menu.c.

{
  PITEM pItem;
  UINT Type = 0;
  TRACE("(menu=%p, id=%04x, flags=%04x);\n", hMenu, uId, uFlags);
  if (!(pItem = MENU_FindItem( &hMenu, &uId, uFlags ))) return -1;

  if (!pItem->Xlpstr && pItem->hbmp) Type = MFT_BITMAP;

  if (pItem->spSubMenu)
  {
     PMENU pSubMenu = DesktopPtrToUser(pItem->spSubMenu);
     HMENU hsubmenu = UserHMGetHandle(pSubMenu);
     Type |= MF_POPUP; // Fix CORE-9269
     if (!IsMenu(hsubmenu)) return (UINT)-1;
     else return (pSubMenu->cItems << 8) | ((pItem->fState|pItem->fType|Type) & 0xff);
  }
  else
     return (pItem->fType | pItem->fState | Type);  
}

Referenced by test_menu_circref(), test_menu_flags(), test_menu_hilitemenuitem(), test_system_menu(), and WndProc().

GetMenuStringA()

int WINAPI GetMenuStringA	(	HMENU	hMenu,
		UINT	uIDItem,
		LPSTR	lpString,
		int	nMaxCount,
		UINT	uFlag
	)

Definition at line 1075 of file menu.c.

{
  ITEM *item;
  LPWSTR text;
  TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, uIDItem, lpString, nMaxCount, uFlag );

  if (lpString && nMaxCount) lpString[0] = '\0';

  if (!(item = MENU_FindItem( &hMenu, &uIDItem, uFlag )))
  {
      SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
      return 0;
  }

  text = item->Xlpstr ? DesktopPtrToUser(item->Xlpstr) : NULL;

  if (!text) return 0;
  if (!lpString || !nMaxCount) return WideCharToMultiByte( CP_ACP, 0, text, -1, NULL, 0, NULL, NULL );
  if (!WideCharToMultiByte( CP_ACP, 0, text, -1, lpString, nMaxCount, NULL, NULL ))
      lpString[nMaxCount-1] = 0;
  TRACE("A returning %s\n", lpString);
  return strlen(lpString);
}

Referenced by check_menu_item_info(), and test_menu_add_string().

GetMenuStringW()

int WINAPI GetMenuStringW	(	HMENU	hMenu,
		UINT	uIDItem,
		LPWSTR	lpString,
		int	nMaxCount,
		UINT	uFlag
	)

Definition at line 1110 of file menu.c.

{
  ITEM *item;
  LPWSTR text;

  TRACE("menu=%p item=%04x ptr=%p len=%d flags=%04x\n", hMenu, uIDItem, lpString, nMaxCount, uFlag );

  if (lpString && nMaxCount) lpString[0] = '\0';

  if (!(item = MENU_FindItem( &hMenu, &uIDItem, uFlag )))
  {
      SetLastError( ERROR_MENU_ITEM_NOT_FOUND);
      return 0;
  }

  text = item->Xlpstr ? DesktopPtrToUser(item->Xlpstr) : NULL;

  if (!lpString || !nMaxCount) return text ? strlenW(text) : 0;
  if( !(text))
  {
      lpString[0] = 0;
      return 0;
  }
  lstrcpynW( lpString, text, nMaxCount );
  TRACE("W returning %S\n", lpString);
  return strlenW(lpString);
}

Referenced by check_menu_item_info(), and test_menu_add_string().

GetSubMenu()

HMENU WINAPI GetSubMenu	(	HMENU	hMenu,
		int	nPos
	)

Definition at line 1148 of file menu.c.

{
  PITEM pItem;
  if (!(pItem = MENU_FindItem( &hMenu, (UINT*)&nPos, MF_BYPOSITION ))) return NULL;

  if (pItem->spSubMenu)
  {
     PMENU pSubMenu = DesktopPtrToUser(pItem->spSubMenu);
     HMENU hsubmenu = UserHMGetHandle(pSubMenu);
     if (IsMenu(hsubmenu)) return hsubmenu;
  }
  return NULL;
}

GetSystemMenu()

HMENU WINAPI GetSystemMenu	(	HWND	hWnd,
		BOOL	bRevert
	)

Definition at line 1169 of file menu.c.

{
    return NtUserGetSystemMenu(hWnd, bRevert);
}

Referenced by test_menu_bmp_and_string(), and test_system_menu().

InsertMenuA()

BOOL WINAPI InsertMenuA	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCSTR	lpNewItem
	)

Definition at line 1179 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING UnicodeString;
  BOOL res;

  RtlInitUnicodeString(&UnicodeString, 0);

  MENU_mnu2mnuii( uFlags, uIDNewItem, (LPCWSTR)lpNewItem, &mii, FALSE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
      if (!RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)mii.dwTypeData))
      {
        SetLastError (ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
      }
      mii.dwTypeData = UnicodeString.Buffer;
      mii.cch = UnicodeString.Length / sizeof(WCHAR);
  }
  else
  {
      TRACE("Handle bitmaps\n");
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uPosition, (BOOL)(uFlags & MF_BYPOSITION), TRUE, &mii, &UnicodeString);
  if ( UnicodeString.Buffer ) RtlFreeUnicodeString ( &UnicodeString );
  return res;
}

Referenced by ChangeMenuA(), test_menu_flags(), test_menu_locked_by_window(), test_menu_search_bycommand(), and test_subpopup_locked_by_menu().

InsertMenuItemA()

BOOL WINAPI InsertMenuItemA	(	HMENU	hMenu,
		UINT	uItem,
		BOOL	fByPosition,
		LPCMENUITEMINFOA	lpmii
	)

Definition at line 1219 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING UnicodeString;
  BOOL res;

  TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, fByPosition, lpmii);

  RtlInitUnicodeString(&UnicodeString, 0);

  if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &mii )) return FALSE;

  /* copy the text string */
  if (((mii.fMask & MIIM_STRING) ||
      ((mii.fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(mii.fType) == MF_STRING)))
        && mii.dwTypeData && !(GdiValidateHandle((HGDIOBJ)mii.dwTypeData)) )
  {
      if (!RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)mii.dwTypeData))
      {
        SetLastError (ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
      }
      mii.dwTypeData = UnicodeString.Buffer;
      mii.cch = UnicodeString.Length / sizeof(WCHAR);
  }
  else
  {
      TRACE("Handle bitmaps\n");
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uItem, fByPosition, TRUE, &mii, &UnicodeString);
  if ( UnicodeString.Buffer ) RtlFreeUnicodeString ( &UnicodeString );
  return res;
}

Referenced by create_menuitem_from_data(), insert_menu_item(), test_AppendMenu(), test_mbs_help(), test_menu_add_string(), test_menu_search_bycommand(), test_menu_setmenuinfo(), and test_menualign().

InsertMenuItemW()

BOOL WINAPI InsertMenuItemW	(	HMENU	hMenu,
		UINT	uItem,
		BOOL	fByPosition,
		LPCMENUITEMINFOW	lpmii
	)

Definition at line 1262 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING MenuText;
  BOOL res = FALSE;

  /* while we could just pass 'lpmii' to win32k, we make a copy so that
     if a bad user passes bad data, we crash his process instead of the
     entire kernel */

  TRACE("hmenu %p, item %04x, by pos %d, info %p\n", hMenu, uItem, fByPosition, lpmii);

  RtlInitUnicodeString(&MenuText, 0);    

  if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &mii )) return FALSE;

  /* copy the text string */
  if (((mii.fMask & MIIM_STRING) ||
      ((mii.fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(mii.fType) == MF_STRING)))
        && mii.dwTypeData && !(GdiValidateHandle((HGDIOBJ)mii.dwTypeData)) )
  {
    RtlInitUnicodeString(&MenuText, (PWSTR)lpmii->dwTypeData);
    mii.dwTypeData = MenuText.Buffer;
    mii.cch = MenuText.Length / sizeof(WCHAR);
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uItem, fByPosition, TRUE, &mii, &MenuText);
  return res;
}

Referenced by insert_menu_item(), and MENUEX_ParseResource().

InsertMenuW()

BOOL WINAPI InsertMenuW	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCWSTR	lpNewItem
	)

Definition at line 1300 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING MenuText;
  BOOL res;

  RtlInitUnicodeString(&MenuText, 0);    

  MENU_mnu2mnuii( uFlags, uIDNewItem, lpNewItem, &mii, TRUE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
    RtlInitUnicodeString(&MenuText, (PWSTR)mii.dwTypeData);
    mii.dwTypeData = MenuText.Buffer;
    mii.cch = MenuText.Length / sizeof(WCHAR);
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uPosition, (BOOL)(uFlags & MF_BYPOSITION), TRUE, &mii, &MenuText);
  return res;
}

Referenced by ChangeMenuW().

IntGetMenuDefaultItem()

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

Definition at line 144 of file menu.c.

{
   UINT i = 0;
   PITEM Item = Menu->rgItems ? DesktopPtrToUser(Menu->rgItems) : NULL;

   /* empty menu */
   if (!Item) return -1;

   while ( !( Item->fState & MFS_DEFAULT ) )
   {
      i++; Item++;
      if  (i >= Menu->cItems ) return -1;
   }

   /* default: don't return disabled items */
   if ( (!(GMDI_USEDISABLED & gmdiFlags)) && (Item->fState & MFS_DISABLED )) return -1;

   /* search rekursiv when needed */
   if ( (gmdiFlags & GMDI_GOINTOPOPUPS) && Item->spSubMenu )
   {
      UINT ret;
      (*gismc)++;
      ret = IntGetMenuDefaultItem( DesktopPtrToUser(Item->spSubMenu), fByPos, gmdiFlags, gismc );
      (*gismc)--;
      if ( -1 != ret ) return ret;

      /* when item not found in submenu, return the popup item */
   }
   return ( fByPos ) ? i : Item->wID;
}

IsMenu()

BOOL WINAPI IsMenu

(

HMENU

Menu

)

Definition at line 1331 of file menu.c.

{
  if (ValidateHandle(Menu, TYPE_MENU)) return TRUE;
  return FALSE;
}

Referenced by get_bad_hmenu(), GetMenuState(), GetSubMenu(), MENU_NormalizeMenuItemInfoStruct(), test_menu_locked_by_window(), and test_subpopup_locked_by_menu().

LoadMenuA()

HMENU WINAPI LoadMenuA	(	HINSTANCE	hInstance,
		LPCSTR	lpMenuName
	)

Definition at line 1342 of file menu.c.

{
  HANDLE Resource = FindResourceA(hInstance, lpMenuName, MAKEINTRESOURCEA(4));
  if (Resource == NULL)
    {
      return(NULL);
    }
  return(LoadMenuIndirectA((PVOID)LoadResource(hInstance, Resource)));
}

Referenced by test_CheckMenuRadioItem().

LoadMenuIndirectA()

HMENU WINAPI LoadMenuIndirectA

(

CONST MENUTEMPLATE *

lpMenuTemplate

)

Definition at line 1357 of file menu.c.

{
  return(LoadMenuIndirectW(lpMenuTemplate));
}

Referenced by LoadMenuA(), and test_menu_resource_layout().

LoadMenuIndirectW()

HMENU WINAPI LoadMenuIndirectW

(

CONST MENUTEMPLATE *

lpMenuTemplate

)

Definition at line 1366 of file menu.c.

{
  HMENU hMenu;
  WORD version, offset;
  LPCSTR p = (LPCSTR)lpMenuTemplate;

  version = GET_WORD(p);
  p += sizeof(WORD);

  switch (version)
  {
    case 0: /* standard format is version of 0 */
      offset = GET_WORD(p);
      p += sizeof(WORD) + offset;
      if (!(hMenu = CreateMenu())) return 0;
      if (!MENU_ParseResource(p, hMenu))
      {
        DestroyMenu(hMenu);
        return 0;
      }
      return hMenu;
    case 1: /* extended format is version of 1 */
      offset = GET_WORD(p);
      p += sizeof(WORD) + offset;
      if (!(hMenu = CreateMenu())) return 0;
      if (!MENUEX_ParseResource(p, hMenu))
      {
        DestroyMenu( hMenu );
        return 0;
      }
      return hMenu;
    default:
      ERR("Menu template version %d not supported.\n", version);
      return 0;
  }
}

Referenced by LoadMenuIndirectA(), and LoadMenuW().

LoadMenuW()

HMENU WINAPI LoadMenuW	(	HINSTANCE	hInstance,
		LPCWSTR	lpMenuName
	)

Definition at line 1407 of file menu.c.

{
  HANDLE Resource = FindResourceW(hInstance, lpMenuName, RT_MENU);
  if (Resource == NULL)
    {
      return(NULL);
    }
  return(LoadMenuIndirectW((PVOID)LoadResource(hInstance, Resource)));
}

Referenced by User32CallLoadMenuFromKernel().

MENU_FindItem()

ITEM* MENU_FindItem	(	HMENU *	hmenu,
		UINT *	nPos,
		UINT	wFlags
	)

Definition at line 91 of file menu.c.

{
    MENU *menu;
    ITEM *fallback = NULL;
    UINT fallback_pos = 0;
    UINT i;
    PITEM pItem;

    if ((*hmenu == (HMENU)0xffff) || (!(menu = MENU_GetMenu(*hmenu)))) return NULL;
    if (wFlags & MF_BYPOSITION)
    {
    if (*nPos >= menu->cItems) return NULL;
    pItem = menu->rgItems ? DesktopPtrToUser(menu->rgItems) : NULL;
    if (pItem) pItem = &pItem[*nPos];
    return pItem;
    }
    else
    {
        PITEM item = menu->rgItems ? DesktopPtrToUser(menu->rgItems) : NULL;
    for (i = 0; item && (i < menu->cItems); i++, item++)
    {
        if (item->spSubMenu)
        {
            PMENU pSubMenu = DesktopPtrToUser(item->spSubMenu);
        HMENU hsubmenu = UserHMGetHandle(pSubMenu);
        ITEM *subitem = MENU_FindItem( &hsubmenu, nPos, wFlags );
        if (subitem)
        {
            *hmenu = hsubmenu;
            return subitem;
        }
        else if (item->wID == *nPos)
        {
            /* fallback to this item if nothing else found */
            fallback_pos = i;
            fallback = item;
        }
        }
        else if (item->wID == *nPos)
        {
        *nPos = i;
        return item;
        }
    }
    }

    if (fallback)
        *nPos = fallback_pos;

    return fallback;
}

MENU_GetMenu()

FORCEINLINE PMENU MENU_GetMenu

(

HMENU

hMenu

)

Definition at line 80 of file menu.c.

{
    return ValidateHandleNoErr(hMenu, TYPE_MENU); 
}

Referenced by MENU_FindItem(), and MENU_mnu2mnuii().

MENU_mnu2mnuii()

static void MENU_mnu2mnuii ( UINT  flags, UINT_PTR  id, LPCWSTR  str, LPMENUITEMINFOW  pmii, BOOL  Unicode  )

static

Definition at line 529 of file menu.c.

{
    RtlZeroMemory( pmii, sizeof( MENUITEMINFOW));
    pmii->cbSize = sizeof( MENUITEMINFOW);
    pmii->fMask = MIIM_STATE | MIIM_ID | MIIM_FTYPE;
    /* setting bitmap clears text and vice versa */
    if( IS_STRING_ITEM(flags)) {
        pmii->fMask |= MIIM_STRING | MIIM_BITMAP;
        if( !str)
            flags |= MF_SEPARATOR;
        /* Item beginning with a backspace is a help item */
        /* FIXME: wrong place, this is only true in win16 */
        else
        {
            if (Unicode)
           {
              if (*str == '\b')
              {
                flags |= MF_HELP;
                str++;
              }
           }
           else
           {
              LPCSTR NewItemA = (LPCSTR) str;
              if (*NewItemA == '\b')
              {
                 flags |= MF_HELP;
                 NewItemA++;
                 str = (LPCWSTR) NewItemA;
              }
              TRACE("A cch %d\n",strlen(NewItemA));
           }
        }
        pmii->dwTypeData = (LPWSTR)str;
    } else if( flags & MFT_BITMAP){
        pmii->fMask |= MIIM_BITMAP | MIIM_STRING;
        pmii->hbmpItem = (HBITMAP)str;
    }
    if( flags & MF_OWNERDRAW){
        pmii->fMask |= MIIM_DATA;
        pmii->dwItemData = (ULONG_PTR) str;
    }
    if( flags & MF_POPUP && MENU_GetMenu((HMENU)id)) {
        pmii->fMask |= MIIM_SUBMENU;
        pmii->hSubMenu = (HMENU)id;
    }
    if( flags & MF_SEPARATOR) flags |= MF_GRAYED | MF_DISABLED;
    pmii->fState = flags & MENUITEMINFO_STATE_MASK & ~MFS_DEFAULT;
    pmii->fType = flags & MENUITEMINFO_TYPE_MASK;
    pmii->wID = (UINT)id;
}

Referenced by AppendMenuA(), AppendMenuW(), InsertMenuA(), InsertMenuW(), ModifyMenuA(), and ModifyMenuW().

MENU_NormalizeMenuItemInfoStruct()

static BOOL MENU_NormalizeMenuItemInfoStruct ( const MENUITEMINFOW *  pmii_in, MENUITEMINFOW *  pmii_out  )

static

Definition at line 588 of file menu.c.

{
    /* do we recognize the size? */
    if( !pmii_in || (pmii_in->cbSize != sizeof( MENUITEMINFOW) &&
            pmii_in->cbSize != sizeof( MENUITEMINFOW) - sizeof( pmii_in->hbmpItem)) ) {
        SetLastError( ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    /* copy the fields that we have */
    memcpy( pmii_out, pmii_in, pmii_in->cbSize);
    /* if the hbmpItem member is missing then extend */
    if( pmii_in->cbSize != sizeof( MENUITEMINFOW)) {
        pmii_out->cbSize = sizeof( MENUITEMINFOW);
        pmii_out->hbmpItem = NULL;
    }
    /* test for invalid bit combinations */
    if( (pmii_out->fMask & MIIM_TYPE &&
         pmii_out->fMask & (MIIM_STRING | MIIM_FTYPE | MIIM_BITMAP)) ||
        (pmii_out->fMask & MIIM_FTYPE && pmii_out->fType & MFT_BITMAP)) {
        ERR("invalid combination of fMask bits used\n");
        /* this does not happen on Win9x/ME */
        SetLastError( ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    /* convert old style (MIIM_TYPE) to the new and keep the old one too */
    if( pmii_out->fMask & MIIM_TYPE){
        pmii_out->fMask |= MIIM_FTYPE;
        if( IS_STRING_ITEM(pmii_out->fType)){
            pmii_out->fMask |= MIIM_STRING;
        } else if( (pmii_out->fType) & MFT_BITMAP){
            pmii_out->fMask |= MIIM_BITMAP;
            pmii_out->hbmpItem = UlongToHandle(LOWORD(pmii_out->dwTypeData));
        }
    }
    if (pmii_out->fMask & MIIM_FTYPE )
    {
        pmii_out->fType &= ~MENUITEMINFO_TYPE_MASK;
        pmii_out->fType |= pmii_in->fType & MENUITEMINFO_TYPE_MASK;
    }
    if (pmii_out->fMask & MIIM_STATE)
    /* Other menu items having MFS_DEFAULT are not converted
       to normal items */
       pmii_out->fState = pmii_in->fState & MENUITEMINFO_STATE_MASK;

    if (pmii_out->fMask & MIIM_SUBMENU)
    {
       if ((pmii_out->hSubMenu != NULL) && !IsMenu(pmii_out->hSubMenu))
          return FALSE;
    }

    return TRUE;
}

Referenced by InsertMenuItemA(), InsertMenuItemW(), SetMenuItemInfoA(), and SetMenuItemInfoW().

MENU_ParseResource()

static LPCSTR MENU_ParseResource ( LPCSTR  res, HMENU  hMenu  )

static

Definition at line 418 of file menu.c.

{
    WORD flags, id = 0;
    HMENU hSubMenu;
    LPCWSTR str;
    BOOL end = FALSE;

    do
    {
        flags = GET_WORD(res);

        /* remove MF_END flag before passing it to AppendMenu()! */
        end = (flags & MF_END);
        if(end) flags ^= MF_END;

        res += sizeof(WORD);
        if(!(flags & MF_POPUP))
        {
            id = GET_WORD(res);
            res += sizeof(WORD);
        }
        str = (LPCWSTR)res;
        res += (strlenW(str) + 1) * sizeof(WCHAR);

        if (flags & MF_POPUP)
        {
            hSubMenu = CreatePopupMenu();
            if(!hSubMenu) return NULL;
            if(!(res = MENU_ParseResource(res, hSubMenu))) return NULL;
            AppendMenuW(hMenu, flags, (UINT_PTR)hSubMenu, (LPCWSTR)str);
        }
        else  /* Not a popup */
        {
            AppendMenuW(hMenu, flags, id, *(LPCWSTR)str ? (LPCWSTR)str : NULL);
        }
    } while(!end);
    return res;
}

Referenced by LoadMenuIndirectW().

MenuCleanup()

VOID MenuCleanup

(

VOID

)

Definition at line 649 of file menu.c.

{
}

Referenced by Cleanup().

MENUEX_ParseResource()

static LPCSTR MENUEX_ParseResource ( LPCSTR  res, HMENU  hMenu  )

static

Definition at line 463 of file menu.c.

{
    WORD resinfo;
    do
    {
        MENUITEMINFOW mii;

        mii.cbSize = sizeof(mii);
        mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
        mii.fType = GET_DWORD(res);
        res += sizeof(DWORD);
        mii.fState = GET_DWORD(res);
        res += sizeof(DWORD);
        mii.wID = GET_DWORD(res);
        res += sizeof(DWORD);
        resinfo = GET_WORD(res);
        res += sizeof(WORD);
        /* Align the text on a word boundary.  */
        res += (~((UINT_PTR)res - 1)) & 1;
        mii.dwTypeData = (LPWSTR)res;
        mii.cch = strlenW(mii.dwTypeData);
        res += (1 + strlenW(mii.dwTypeData)) * sizeof(WCHAR);
        /* Align the following fields on a dword boundary.  */
        res += (~((UINT_PTR)res - 1)) & 3;

        TRACE("Menu item: [%08x,%08x,%04x,%04x,%S]\n",
              mii.fType, mii.fState, mii.wID, resinfo, mii.dwTypeData);

        if (resinfo & 1) /* Pop-up? */
        {
            /* DWORD helpid = GET_DWORD(res); FIXME: use this. */
            res += sizeof(DWORD);
            mii.hSubMenu = CreatePopupMenu();
            if (!mii.hSubMenu)
            {
                ERR("CreatePopupMenu failed\n");
                return NULL;
            }

            if (!(res = MENUEX_ParseResource(res, mii.hSubMenu)))
            {
                ERR("MENUEX_ParseResource failed\n");
                DestroyMenu(mii.hSubMenu);
                return NULL;
            }
            mii.fMask |= MIIM_SUBMENU;
            mii.fType |= MF_POPUP;
        }
        else if (!mii.dwTypeData[0] && !(mii.fType & MF_SEPARATOR))
        {
            WARN("Converting NULL menu item %04x, type %04x to SEPARATOR\n",
                mii.wID, mii.fType);
            mii.fType |= MF_SEPARATOR;
        }
        InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
    } while (!(resinfo & MF_END));
    return res;
}

Referenced by LoadMenuIndirectW().

MenuInit()

BOOL MenuInit

(

VOID

)

Definition at line 643 of file menu.c.

{
  return TRUE;
}

MenuWindowProcA()

LRESULT WINAPI MenuWindowProcA	(	HWND	hWnd,
		ULONG_PTR	Result,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1674 of file menu.c.

{
  if ( Msg < WM_USER)
  {
     return PopupMenuWndProcA(hWnd, Msg, wParam, lParam );
  }
  return NtUserMessageCall(hWnd, Msg, wParam, lParam, Result, FNID_MENU, TRUE);
}

MenuWindowProcW()

LRESULT WINAPI MenuWindowProcW	(	HWND	hWnd,
		ULONG_PTR	Result,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1694 of file menu.c.

{
  if ( Msg < WM_USER)
  {
     return PopupMenuWndProcW(hWnd, Msg, wParam, lParam );
  }
  return NtUserMessageCall(hWnd, Msg, wParam, lParam, Result, FNID_MENU, FALSE);
}

ModifyMenuA()

BOOL WINAPI ModifyMenuA	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCSTR	lpNewItem
	)

Definition at line 1423 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING UnicodeString;
  BOOL res;

  RtlInitUnicodeString(&UnicodeString, 0);

  MENU_mnu2mnuii( uFlags, uIDNewItem, (LPCWSTR)lpNewItem, &mii, FALSE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
      if (!RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)mii.dwTypeData))
      {
        SetLastError (ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
      }
      mii.dwTypeData = UnicodeString.Buffer;
      mii.cch = UnicodeString.Length / sizeof(WCHAR);
  }
  else
  {
      TRACE("Handle bitmaps\n");
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uPosition, (BOOL)(uFlags & MF_BYPOSITION), FALSE, &mii, &UnicodeString);
  if ( UnicodeString.Buffer ) RtlFreeUnicodeString ( &UnicodeString );
  return res;
}

Referenced by ChangeMenuA(), modify_menu(), test_AppendMenu(), test_menu_circref(), test_menu_flags(), test_menu_ownerdraw(), and test_system_menu().

ModifyMenuW()

BOOL WINAPI ModifyMenuW	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags,
		UINT_PTR	uIDNewItem,
		LPCWSTR	lpNewItem
	)

Definition at line 1463 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING MenuText;
  BOOL res;

  RtlInitUnicodeString(&MenuText, 0);    

  MENU_mnu2mnuii( uFlags, uIDNewItem, lpNewItem, &mii, TRUE);

  /* copy the text string, it will be one or the other */
  if (lpNewItem && mii.fMask & MIIM_STRING && !mii.hbmpItem && mii.dwTypeData)
  {
    RtlInitUnicodeString(&MenuText, (PWSTR)mii.dwTypeData);
    mii.dwTypeData = MenuText.Buffer;
    mii.cch = MenuText.Length / sizeof(WCHAR);
  }
  else
  {
      TRACE("Handle bitmaps\n");
  }
  res = NtUserThunkedMenuItemInfo(hMenu, uPosition, (BOOL)(uFlags & MF_BYPOSITION), FALSE, &mii, &MenuText);
  return res;
}

Referenced by ChangeMenuW(), modify_menu(), and test_system_menu().

PopupMenuWndProcA()

LRESULT WINAPI PopupMenuWndProcA	(	HWND	Wnd,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 376 of file menu.c.

{
  PWND pWnd;

  pWnd = ValidateHwnd(Wnd);
  if (pWnd && !pWnd->fnid && Message != WM_NCCREATE)
  {
     return DefWindowProcA(Wnd, Message, wParam, lParam);
  }    
  TRACE("YES! hwnd=%x msg=0x%04x wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);

  switch(Message)
    {
    case WM_NCCREATE:
    case WM_CREATE:
    case WM_MOUSEACTIVATE:
    case WM_PAINT:
    case WM_PRINTCLIENT:
    case WM_ERASEBKGND:
    case WM_DESTROY:
    case WM_NCDESTROY:
    case WM_SHOWWINDOW:
    case MM_SETMENUHANDLE:
    case MM_GETMENUHANDLE:
    case MN_SETHMENU:
    case MN_GETHMENU: 
      return PopupMenuWndProcW(Wnd, Message, wParam, lParam);

    default:
      return DefWindowProcA(Wnd, Message, wParam, lParam);
    }
  return 0;
}

Referenced by MenuWindowProcA(), and RegisterClientPFN().

PopupMenuWndProcW()

LRESULT WINAPI PopupMenuWndProcW	(	HWND	Wnd,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 305 of file menu.c.

{
  LRESULT lResult;
  PWND pWnd;

  TRACE("PMWPW : hwnd=%x msg=0x%04x wp=0x%04lx lp=0x%08lx\n", Wnd, Message, wParam, lParam);

  pWnd = ValidateHwnd(Wnd);
  if (pWnd)
  {
     if (!pWnd->fnid)
     {
        if (Message != WM_NCCREATE)
        {
           return DefWindowProcW(Wnd, Message, wParam, lParam);
        }
     }
     else
     {
        if (pWnd->fnid != FNID_MENU)
        {
           ERR("Wrong window class for Menu!\n");
           return 0;
        }
     }
  }

  switch(Message)
    {
    case WM_DESTROY:
    case WM_NCDESTROY:
    case WM_NCCREATE:
    case WM_CREATE:
    case MM_SETMENUHANDLE:
    case MM_GETMENUHANDLE:
    case MN_SETHMENU:
    case MN_GETHMENU:
    case WM_PAINT:
    case WM_PRINTCLIENT:
      {
        TRACE("Menu Class ProcW\n");
        NtUserMessageCall( Wnd, Message, wParam, lParam, (ULONG_PTR)&lResult, FNID_MENU, FALSE);
        return lResult;
      }
    case WM_MOUSEACTIVATE:  /* We don't want to be activated */
      return MA_NOACTIVATE;

    case WM_ERASEBKGND:
      return 1;

    case WM_SHOWWINDOW: // Not sure what this does....
      if (0 != wParam)
        {
          if (0 == GetWindowLongPtrW(Wnd, 0))
            {
              OutputDebugStringA("no menu to display\n");
            }
        }
      else
        {
          //SetWindowLongPtrW(Wnd, 0, 0);
        }
      break;

    default:
      return DefWindowProcW(Wnd, Message, wParam, lParam);
    }

  return 0;
}

Referenced by MenuWindowProcW(), PopupMenuWndProcA(), and RegisterClientPFN().

SetMenu()

BOOL WINAPI SetMenu	(	HWND	hWnd,
		HMENU	hMenu
	)

Definition at line 1497 of file menu.c.

{
  return NtUserSetMenu(hWnd, hMenu, TRUE);
}

Referenced by test_getmenubarinfo(), test_GetMenuItemRect(), test_mbs_help(), test_menu_cancelmode(), test_menu_hilitemenuitem(), test_menu_input(), test_menu_locked_by_window(), and test_menu_ownerdraw().

SetMenuInfo()

BOOL WINAPI SetMenuInfo	(	HMENU	hmenu,
		LPCMENUINFO	lpcmi
	)

Definition at line 1508 of file menu.c.

{
  MENUINFO mi;
  BOOL res = FALSE;

  if (!lpcmi || (lpcmi->cbSize != sizeof(MENUINFO)))
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return res;
  }

  memcpy(&mi, lpcmi, sizeof(MENUINFO));
  return NtUserThunkedMenuInfo(hmenu, (LPCMENUINFO)&mi);
}

Referenced by test_mbs_help(), and test_menu_setmenuinfo().

SetMenuItemBitmaps()

BOOL WINAPI SetMenuItemBitmaps	(	HMENU	hMenu,
		UINT	uPosition,
		UINT	uFlags,
		HBITMAP	hBitmapUnchecked,
		HBITMAP	hBitmapChecked
	)

Definition at line 1530 of file menu.c.

{
  MENUITEMINFOW uItem;
  memset ( &uItem, 0, sizeof(uItem) );
  uItem.cbSize = sizeof(MENUITEMINFOW);
  uItem.fMask = MIIM_CHECKMARKS;
  uItem.hbmpUnchecked = hBitmapUnchecked;
  uItem.hbmpChecked = hBitmapChecked;
  return SetMenuItemInfoW(hMenu, uPosition, (BOOL)(uFlags & MF_BYPOSITION), &uItem);
}

SetMenuItemInfoA()

BOOL WINAPI SetMenuItemInfoA	(	HMENU	hmenu,
		UINT	item,
		BOOL	bypos,
		LPCMENUITEMINFOA	lpmii
	)

Definition at line 1551 of file menu.c.

{
  MENUITEMINFOW mii;
  UNICODE_STRING UnicodeString;
  BOOL Ret;

  TRACE("hmenu %p, item %u, by pos %d, info %p\n", hmenu, item, bypos, lpmii);

  RtlInitUnicodeString(&UnicodeString, 0);

  if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &mii )) return FALSE;
/*
 *  MIIM_STRING              == good
 *  MIIM_TYPE & MFT_STRING   == good
 *  MIIM_STRING & MFT_STRING == good
 *  MIIM_STRING & MFT_OWNERDRAW == good
 */
  if (((mii.fMask & MIIM_STRING) ||
      ((mii.fMask & MIIM_TYPE) && (MENU_ITEM_TYPE(mii.fType) == MF_STRING)))
        && mii.dwTypeData && !(GdiValidateHandle((HGDIOBJ)mii.dwTypeData)) )
  {
    /* cch is ignored when the content of a menu item is set by calling SetMenuItemInfo. */
     if (!RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)mii.dwTypeData))
     {
        SetLastError (ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
     }
     mii.dwTypeData = UnicodeString.Buffer;
     mii.cch = UnicodeString.Length / sizeof(WCHAR);
  }
  else
  {
     UnicodeString.Buffer = NULL;
  }
  Ret = NtUserThunkedMenuItemInfo(hmenu, item, bypos, FALSE, &mii, &UnicodeString);
  if (UnicodeString.Buffer != NULL) RtlFreeUnicodeString(&UnicodeString);
  return Ret;
}

Referenced by clear_ftype_and_state(), set_menu_item_info(), test_AppendMenu(), test_menu_add_string(), test_menu_search_bycommand(), test_menualign(), and test_system_menu().

SetMenuItemInfoW()

BOOL WINAPI SetMenuItemInfoW	(	HMENU	hMenu,
		UINT	uItem,
		BOOL	fByPosition,
		LPCMENUITEMINFOW	lpmii
	)

Definition at line 1599 of file menu.c.

{
  MENUITEMINFOW MenuItemInfoW;
  UNICODE_STRING UnicodeString;
  BOOL Ret;

  TRACE("hmenu %p, item %u, by pos %d, info %p\n", hMenu, uItem, fByPosition, lpmii);

  RtlInitUnicodeString(&UnicodeString, 0);

  if (!MENU_NormalizeMenuItemInfoStruct( (const MENUITEMINFOW *)lpmii, &MenuItemInfoW )) return FALSE;

  if (((MenuItemInfoW.fMask & MIIM_STRING) ||
      ((MenuItemInfoW.fMask & MIIM_TYPE) &&
                           (MENU_ITEM_TYPE(MenuItemInfoW.fType) == MF_STRING)))
        && MenuItemInfoW.dwTypeData && !(GdiValidateHandle((HGDIOBJ)MenuItemInfoW.dwTypeData)) )
  {
      RtlInitUnicodeString(&UnicodeString, (PCWSTR)MenuItemInfoW.dwTypeData);
      MenuItemInfoW.cch = strlenW(MenuItemInfoW.dwTypeData);
  }
  Ret = NtUserThunkedMenuItemInfo(hMenu, uItem, fByPosition, FALSE, &MenuItemInfoW, &UnicodeString);

  return Ret;
}

Referenced by set_menu_item_info(), SetMenuItemBitmaps(), and test_system_menu().

SetSystemMenu()

BOOL WINAPI SetSystemMenu	(	HWND	hwnd,
		HMENU	hMenu
	)

Definition at line 1633 of file menu.c.

{
  if(!hwnd)
  {
    SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    return FALSE;
  }
  if(!hMenu)
  {
    SetLastError(ERROR_INVALID_MENU_HANDLE);
    return FALSE;
  }
  return NtUserSetSystemMenu(hwnd, hMenu);
}

TrackPopupMenu()

BOOL WINAPI TrackPopupMenu	(	HMENU	Menu,
		UINT	Flags,
		int	x,
		int	y,
		int	Reserved,
		HWND	Wnd,
		CONST RECT *	Rect
	)

Definition at line 1652 of file menu.c.

{
  return NtUserTrackPopupMenuEx( Menu,
                                Flags,
                                    x,
                                    y,
                                  Wnd,
                                 NULL); // LPTPMPARAMS is null
}

Referenced by menu_track_again_wnd_proc(), MyTrackPopupMenu(), test_emptypopup(), test_mbs_help(), test_menu_cancelmode(), test_menu_ownerdraw(), test_menu_trackagain(), test_menualign(), and test_subpopup_locked_by_menu().

User32CallLoadMenuFromKernel()

NTSTATUS WINAPI User32CallLoadMenuFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 665 of file menu.c.

{
  PLOADMENU_CALLBACK_ARGUMENTS Common;
  LRESULT Result;

  Common = (PLOADMENU_CALLBACK_ARGUMENTS) Arguments;

  Result = (LRESULT)LoadMenuW( Common->hModule, Common->InterSource ? MAKEINTRESOURCE(Common->InterSource) : (LPCWSTR)&Common->MenuName);

  return ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
}

User32LoadSysMenuTemplateForKernel()

NTSTATUS WINAPI User32LoadSysMenuTemplateForKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 655 of file menu.c.

{
  LRESULT Result = 0;

  // Use this for Menu Ole!!

  return(ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS));
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

menu

)

Variable Documentation

POPUPMENU_builtin_class

const struct builtin_class_descr POPUPMENU_builtin_class

Initial value:

=
{
    WC_MENU,                     
    CS_SAVEBITS | CS_DBLCLKS,                  
    NULL,                                      
    PopupMenuWndProcW,                         
    sizeof(MENUINFO *),                        
    (LPCWSTR) IDC_ARROW,                       
    (HBRUSH)(COLOR_MENU + 1)                   
}

Definition at line 56 of file menu.c.