menu.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagMENUSTATE
struct	_SETMENUITEMRECT
struct	tagROSMENUINFO
struct	tagROSMENUITEMINFO

Macros
#define	IS_ATOM(x)    (((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))
#define	MENU_ITEM_TYPE(flags)    ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
#define	MF_END   (0x0080)
#define	IntReleaseMenuObject(MenuObj)    UserDereferenceObject(MenuObj)

Typedefs
typedef struct tagMENUSTATE	MENUSTATE
typedef struct tagMENUSTATE *	PMENUSTATE
typedef struct _SETMENUITEMRECT	SETMENUITEMRECT
typedef struct _SETMENUITEMRECT *	PSETMENUITEMRECT
typedef struct tagROSMENUINFO	ROSMENUINFO
typedef struct tagROSMENUINFO *	PROSMENUINFO
typedef struct tagROSMENUITEMINFO	ROSMENUITEMINFO
typedef struct tagROSMENUITEMINFO *	PROSMENUITEMINFO

Functions
BOOL FASTCALL	IntIsMenu (HMENU)
PMENU FASTCALL	IntGetMenuObject (HMENU hMenu)
BOOLEAN	UserDestroyMenuObject (PVOID Object)
BOOL FASTCALL	IntDestroyMenuObject (PMENU MenuObject, BOOL bRecurse)
PMENU FASTCALL	IntCloneMenu (PMENU Source)
int FASTCALL	IntGetMenuItemByFlag (PMENU MenuObject, UINT uSearchBy, UINT fFlag, PMENU *SubMenu, PITEM *MenuItem, PITEM *PrevMenuItem)
BOOL FASTCALL	IntCleanupMenus (struct _EPROCESS *Process, PPROCESSINFO Win32Process)
BOOL FASTCALL	IntInsertMenuItem (_In_ PMENU MenuObject, UINT uItem, BOOL fByPosition, PROSMENUITEMINFO ItemInfo, PUNICODE_STRING lpstr)
PMENU FASTCALL	IntGetSystemMenu (PWND Window, BOOL bRevert)
UINT FASTCALL	IntFindSubMenu (HMENU *hMenu, HMENU hSubTarget)
UINT FASTCALL	IntGetMenuState (HMENU hMenu, UINT uId, UINT uFlags)
BOOL FASTCALL	IntRemoveMenuItem (PMENU Menu, UINT uPosition, UINT uFlags, BOOL bRecurse)
PITEM FASTCALL	MENU_FindItem (PMENU *pmenu, UINT *nPos, UINT wFlags)
BOOL FASTCALL	IntMenuItemInfo (PMENU Menu, UINT Item, BOOL ByPosition, PROSMENUITEMINFO UnsafeItemInfo, BOOL SetOrGet, PUNICODE_STRING lpstr)
BOOL FASTCALL	IntSetMenu (PWND Wnd, HMENU Menu, BOOL *Changed)
UINT	MENU_DrawMenuBar (HDC hDC, LPRECT lprect, PWND pWnd, BOOL suppress_draw)
BOOL	MenuInit (VOID)
VOID	MENU_TrackKbdMenuBar (PWND pwnd, UINT wParam, WCHAR wChar)
VOID	MENU_TrackMouseMenuBar (PWND pWnd, ULONG ht, POINT pt)
BOOL WINAPI	PopupMenuWndProc (PWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
BOOL FASTCALL	IntSetMenuItemInfo (PMENU, PITEM, PROSMENUITEMINFO, PUNICODE_STRING)
PWND	MENU_IsMenuActive (VOID)
void	MENU_EndMenu (PWND pwnd)
void FASTCALL	MENU_InitSysMenuPopup (PMENU menu, DWORD style, DWORD clsStyle, LONG HitTest)
INT FASTCALL	IntMenuItemFromPoint (PWND pWnd, HMENU hMenu, POINT ptScreen)
BOOL WINAPI	IntTrackPopupMenuEx (PMENU menu, UINT wFlags, int x, int y, PWND pWnd, LPTPMPARAMS lpTpm)

Macro Definition Documentation

IntReleaseMenuObject

#define IntReleaseMenuObject

(

MenuObj

)

UserDereferenceObject(MenuObj)

Definition at line 130 of file menu.h.

IS_ATOM

#define IS_ATOM

(

x

)

(((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))

Definition at line 3 of file menu.h.

MENU_ITEM_TYPE

#define MENU_ITEM_TYPE

(

flags

)

((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))

Definition at line 6 of file menu.h.

MF_END

#define MF_END   (0x0080)

Definition at line 10 of file menu.h.

Typedef Documentation

MENUSTATE

typedef struct tagMENUSTATE MENUSTATE

PMENUSTATE

typedef struct tagMENUSTATE * PMENUSTATE

PROSMENUINFO

typedef struct tagROSMENUINFO * PROSMENUINFO

PROSMENUITEMINFO

typedef struct tagROSMENUITEMINFO * PROSMENUITEMINFO

PSETMENUITEMRECT

typedef struct _SETMENUITEMRECT * PSETMENUITEMRECT

ROSMENUINFO

typedef struct tagROSMENUINFO ROSMENUINFO

ROSMENUITEMINFO

typedef struct tagROSMENUITEMINFO ROSMENUITEMINFO

SETMENUITEMRECT

typedef struct _SETMENUITEMRECT SETMENUITEMRECT

Function Documentation

IntCleanupMenus()

BOOL FASTCALL IntCleanupMenus	(	struct _EPROCESS *	Process,
		PPROCESSINFO	Win32Process
	)

IntCloneMenu()

PMENU FASTCALL IntCloneMenu

(

PMENU

Source

)

Definition at line 824 of file menu.c.

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

Referenced by MENU_GetSystemMenu().

IntDestroyMenuObject()

BOOL FASTCALL IntDestroyMenuObject	(	PMENU	MenuObject,
		BOOL	bRecurse
	)

Definition at line 319 of file menu.c.

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

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

IntFindSubMenu()

UINT FASTCALL IntFindSubMenu	(	HMENU *	hMenu,
		HMENU	hSubTarget
	)

Definition at line 5015 of file menu.c.

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

Referenced by co_IntTranslateAccelerator().

IntGetMenuItemByFlag()

int FASTCALL IntGetMenuItemByFlag	(	PMENU	MenuObject,
		UINT	uSearchBy,
		UINT	fFlag,
		PMENU *	SubMenu,
		PITEM *	MenuItem,
		PITEM *	PrevMenuItem
	)

IntGetMenuObject()

PMENU FASTCALL IntGetMenuObject

(

HMENU

hMenu

)

Definition at line 194 of file menu.c.

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

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

IntGetMenuState()

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

Definition at line 4975 of file menu.c.

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

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

IntGetSystemMenu()

PMENU FASTCALL IntGetSystemMenu	(	PWND	Window,
		BOOL	bRevert
	)

Definition at line 5383 of file menu.c.

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

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

IntInsertMenuItem()

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

Definition at line 693 of file menu.c.

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

Referenced by MENU_GetSystemMenu(), and UserInsertMenuItem().

IntIsMenu()

BOOL FASTCALL IntIsMenu

(

HMENU

Menu

)

Definition at line 242 of file menu.c.

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

IntMenuItemFromPoint()

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

Definition at line 1520 of file menu.c.

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

Referenced by IntDefWindowProc().

IntMenuItemInfo()

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

Definition at line 5076 of file menu.c.

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

Referenced by MENU_GetSystemMenu().

IntRemoveMenuItem()

BOOL FASTCALL IntRemoveMenuItem	(	PMENU	Menu,
		UINT	uPosition,
		UINT	uFlags,
		BOOL	bRecurse
	)

Definition at line 598 of file menu.c.

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

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

IntSetMenu()

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

Definition at line 5459 of file menu.c.

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

Referenced by IntCreateWindow(), and NtUserSetMenu().

IntSetMenuItemInfo()

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

Definition at line 1035 of file menu.c.

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

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

IntTrackPopupMenuEx()

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

Definition at line 4561 of file menu.c.

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

Referenced by IntDefWindowProc(), and NtUserTrackPopupMenuEx().

MENU_DrawMenuBar()

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

Definition at line 2744 of file menu.c.

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

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

MENU_EndMenu()

void MENU_EndMenu

(

PWND

pwnd

)

Definition at line 2664 of file menu.c.

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

Referenced by IntDefWindowProc().

MENU_FindItem()

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

Definition at line 509 of file menu.c.

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

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

MENU_InitSysMenuPopup()

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

Definition at line 1364 of file menu.c.

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

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

MENU_IsMenuActive()

PWND MENU_IsMenuActive

(

VOID

)

Definition at line 2652 of file menu.c.

{
   return ValidateHwndNoErr(top_popup);
}

Referenced by IntDefWindowProc().

MENU_TrackKbdMenuBar()

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

Definition at line 4500 of file menu.c.

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

Referenced by DefWndHandleSysCommand().

MENU_TrackMouseMenuBar()

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

Definition at line 4470 of file menu.c.

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

Referenced by DefWndHandleSysCommand().

MenuInit()

BOOL MenuInit

(

VOID

)

Definition at line 361 of file menu.c.

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

PopupMenuWndProc()

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

Definition at line 4631 of file menu.c.

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

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

UserDestroyMenuObject()

BOOLEAN UserDestroyMenuObject

(

PVOID

Object

)

Definition at line 313 of file menu.c.

{
    return IntDestroyMenuObject(Object, TRUE);
}