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

GET_WORD

#define GET_WORD

(

ptr

)

(*(WORD *)(ptr))

Definition at line 60 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.

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 676 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;
}

AppendMenuW()

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

Definition at line 714 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 1744 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 1706 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 742 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);
}

CheckMenuRadioItem()

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

Definition at line 765 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;
}

CreateMenu()

HMENU WINAPI CreateMenu

(

VOID

)

Definition at line 829 of file menu.c.

{
  return NtUserxCreateMenu();
}

Referenced by AWR_init(), create_menu_from_data(), create_menuitem_from_data(), CShellMenuCallback::CreateRecentMenu(), CDefView::CreateViewWindow3(), CDefView::InitList(), LoadMenuIndirectW(), CSendToMenu::QueryContextMenu(), CNewMenu::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 838 of file menu.c.

{
  return NtUserxCreatePopupMenu();
}

Referenced by CBandSiteBase::_OnContextMenu(), _ShowContextMenu(), _ShowContextMenuR(), CMenuBand::_TrackContextMenu(), add_favs_to_menu(), CShellMenuCallback::AddOrSetMenuItem(), AdvProcDetailsDlgProc(), AppendMenuItems(), BuildLeftPopupMenu(), CDesktopFolder::CallBack(), CDrivesFolder::CallBack(), CFSFolder::CallBack(), ConWndProc(), DesktopShellView::DoDesktopContextMenu(), CDefView::Exec(), FileMenu_Create(), CDefView::FillFileMenu(), FM_InitMenuPopup(), handle_context_menu(), IContextMenu_Invoke(), 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(), ShellExecute_ContextMenuVerb(), 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(), CTrayWindow::TrackCtxMenu(), and wmain().

DrawMenuBar()

BOOL WINAPI DrawMenuBar

(

HWND

hWnd

)

Definition at line 847 of file menu.c.

{
  return NtUserxDrawMenuBar(hWnd);
}

EnableMenuItem()

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

Definition at line 856 of file menu.c.

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

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

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

GetMenuCheckMarkDimensions()

LONG WINAPI GetMenuCheckMarkDimensions

(

VOID

)

Definition at line 881 of file menu.c.

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

GetMenuContextHelpId()

DWORD WINAPI GetMenuContextHelpId

(

HMENU

hmenu

)

Definition at line 892 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 904 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 920 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;
}

GetMenuItemCount()

int WINAPI GetMenuItemCount

(

HMENU

hmenu

)

Definition at line 956 of file menu.c.

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

GetMenuItemID()

UINT WINAPI GetMenuItemID	(	HMENU	hMenu,
		int	nPos
	)

Definition at line 968 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;
}

GetMenuItemInfo_common()

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

static

Definition at line 167 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 981 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;
}

GetMenuItemInfoW()

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

Definition at line 1012 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;
}

GetMenuState()

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

Definition at line 1038 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);  
}

GetMenuStringA()

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

Definition at line 1067 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);
}

GetMenuStringW()

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

Definition at line 1102 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);
}

GetSubMenu()

HMENU WINAPI GetSubMenu	(	HMENU	hMenu,
		int	nPos
	)

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

{
    return NtUserGetSystemMenu(hWnd, bRevert);
}

InsertMenuA()

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

Definition at line 1171 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;
}

InsertMenuItemA()

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

Definition at line 1211 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;
}

InsertMenuItemW()

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

Definition at line 1254 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;
}

InsertMenuW()

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

Definition at line 1292 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 136 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 1323 of file menu.c.

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

LoadMenuA()

HMENU WINAPI LoadMenuA	(	HINSTANCE	hInstance,
		LPCSTR	lpMenuName
	)

Definition at line 1334 of file menu.c.

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

LoadMenuIndirectA()

HMENU WINAPI LoadMenuIndirectA

(

CONST MENUTEMPLATE *

lpMenuTemplate

)

Definition at line 1349 of file menu.c.

{
  return(LoadMenuIndirectW(lpMenuTemplate));
}

LoadMenuIndirectW()

HMENU WINAPI LoadMenuIndirectW

(

CONST MENUTEMPLATE *

lpMenuTemplate

)

Definition at line 1358 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 1399 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 83 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 72 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 521 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 580 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 410 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(), and MENU_ParseResource().

MenuCleanup()

VOID MenuCleanup

(

VOID

)

Definition at line 641 of file menu.c.

{
}

MENUEX_ParseResource()

static LPCSTR MENUEX_ParseResource ( LPCSTR  res, HMENU  hMenu  )

static

Definition at line 455 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(), and MENUEX_ParseResource().

MenuInit()

BOOL MenuInit

(

VOID

)

Definition at line 635 of file menu.c.

{
  return TRUE;
}

MenuWindowProcA()

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

Definition at line 1666 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 1686 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 1415 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;
}

ModifyMenuW()

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

Definition at line 1455 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;
}

PopupMenuWndProcA()

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

Definition at line 368 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 297 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 1489 of file menu.c.

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

SetMenuInfo()

BOOL WINAPI SetMenuInfo	(	HMENU	hmenu,
		LPCMENUINFO	lpcmi
	)

Definition at line 1500 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);
}

SetMenuItemBitmaps()

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

Definition at line 1522 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 1543 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;
}

SetMenuItemInfoW()

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

Definition at line 1591 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;
}

SetSystemMenu()

BOOL WINAPI SetSystemMenu	(	HWND	hwnd,
		HMENU	hMenu
	)

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

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

User32CallLoadMenuFromKernel()

NTSTATUS WINAPI User32CallLoadMenuFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 657 of file menu.c.

{
  PLOADMENU_CALLBACK_ARGUMENTS Common;
  LRESULT Result;
 
  Common = (PLOADMENU_CALLBACK_ARGUMENTS) Arguments;
 
  Result = (LRESULT)LoadMenuW(Common->hModule, Common->InterSource ? MAKEINTRESOURCEW(Common->InterSource) : (LPCWSTR)&Common->MenuName);
 
  return ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
}

User32LoadSysMenuTemplateForKernel()

NTSTATUS WINAPI User32LoadSysMenuTemplateForKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

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