menu.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

         if (idItem)
           {
              if (idItem-1 == SubMenuObject->MenuInfo.FocusedItem)
                   kmbi.fFocused = TRUE;
           }
         if (SubMenuObject->MenuInfo.FocusedItem != NO_SELECTED_ITEM)
               kmbi.fBarFocused = TRUE;
         XSubMenuObject = UserGetMenuObject(SubMenuObject->MenuItemList->hSubMenu);
         if (XSubMenuObject) kmbi.hwndMenu = XSubMenuObject->MenuInfo.Wnd;
         DPRINT("OBJID_CLIENT, idItem = %d\n",idItem);
         break;
      }
      case OBJID_SYSMENU:
      {
         PMENU_OBJECT SysMenuObject, SubMenuObject;
         if(!(SysMenuObject = IntGetSystemMenu(WindowObject, FALSE, FALSE)))
         {
           Res = FALSE;
           break;
         }
         kmbi.hMenu = SysMenuObject->MenuInfo.Self;
         if (idItem)
           {
              if (IntGetMenuItemByFlag(SysMenuObject, idItem-1, MF_BYPOSITION, &mi, NULL) > -1)
                   kmbi.rcBar = mi->Rect;
              else
                {
                   Res = FALSE;
                   break;
                }
           }
         else
           {
              PWINDOW_OBJECT SysWinObj;
              if (!(SysWinObj = UserGetWindowObject(SysMenuObject->MenuInfo.Wnd)))
                {
                   Res = FALSE;
                   break;
                }
              if (!(IntGetClientOrigin(SysWinObj, &Offset)))
                {
                   Res = FALSE;
                   break;
                }
              Rect.left = Offset.x;
              Rect.right = Offset.x + SysMenuObject->MenuInfo.Width;
              Rect.top = Offset.y;
              Rect.bottom = Offset.y + SysMenuObject->MenuInfo.Height;
              kmbi.rcBar = Rect;
           }
         if (idItem)
           {
              if (idItem-1 == SysMenuObject->MenuInfo.FocusedItem)
                    kmbi.fFocused = TRUE;
           }
         if (SysMenuObject->MenuInfo.FocusedItem != NO_SELECTED_ITEM)
               kmbi.fBarFocused = TRUE;
         SubMenuObject = UserGetMenuObject(SysMenuObject->MenuItemList->hSubMenu);
         if(SubMenuObject) kmbi.hwndMenu = SubMenuObject->MenuInfo.Wnd;
         DPRINT("OBJID_SYSMENU, idItem = %d\n",idItem);
         break;
      }
      default:
         Res = FALSE;
         DPRINT1("Unknown idObject = %d, idItem = %d\n",idObject,idItem);
   }
   if (Res)
     {
        NTSTATUS Status = MmCopyToCaller(pmbi, &kmbi, sizeof(MENUBARINFO));
        if (! NT_SUCCESS(Status))
          {
            SetLastNtError(Status);
            RETURN(FALSE);
          }
     }
   RETURN(Res);

CLEANUP:
   DPRINT("Leave NtUserGetMenuBarInfo, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;  
}


/*
 * @unimplemented
 */
UINT STDCALL
NtUserGetMenuIndex(
   HMENU hMenu,
   UINT wID)
{
   UNIMPLEMENTED

   return 0;
}


/*
 * @implemented
 */
BOOL STDCALL
NtUserGetMenuItemRect(
   HWND hWnd,
   HMENU hMenu,
   UINT uItem,
   LPRECT lprcItem)
{
   ROSMENUINFO mi;
   HWND referenceHwnd;
   RECT Rect;
   NTSTATUS Status;
   PMENU_OBJECT Menu;
   PMENU_ITEM MenuItem;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserGetMenuItemRect\n");
   UserEnterShared();

   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN(FALSE);
   }

   if (IntGetMenuItemByFlag(Menu, uItem, MF_BYPOSITION, &MenuItem, NULL) > -1)
        Rect = MenuItem->Rect;
   else
      RETURN(FALSE);
   
   referenceHwnd = hWnd;
   
   if(!hWnd)
   {
      if(!UserMenuInfo(Menu, &mi, FALSE))
         RETURN( FALSE);
      if(mi.Wnd == 0)
         RETURN( FALSE);
      referenceHwnd = mi.Wnd; /* Okay we found it, so now what do we do? */
   }

   if (lprcItem == NULL)
      RETURN( FALSE);

   Status = MmCopyToCaller(lprcItem, &Rect, sizeof(RECT));
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      RETURN( FALSE);
   }
   RETURN( TRUE);

CLEANUP:
   DPRINT("Leave NtUserGetMenuItemRect, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}


/*
 * @implemented
 */
BOOL STDCALL
NtUserHiliteMenuItem(
   HWND hWnd,
   HMENU hMenu,
   UINT uItemHilite,
   UINT uHilite)
{
   PMENU_OBJECT Menu;
   PWINDOW_OBJECT Window;
   DECLARE_RETURN(BOOLEAN);

   DPRINT("Enter NtUserHiliteMenuItem\n");
   UserEnterExclusive();

   if(!(Window = UserGetWindowObject(hWnd)))
   {
      RETURN(FALSE);
   }
   
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN(FALSE);
   }
   
   if(Window->IDMenu == (UINT)hMenu)
   {
      RETURN( IntHiliteMenuItem(Window, Menu, uItemHilite, uHilite));
   }

   RETURN(FALSE);

CLEANUP:
   DPRINT("Leave NtUserHiliteMenuItem, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}


static
BOOL FASTCALL
UserMenuInfo(
   PMENU_OBJECT Menu,
   PROSMENUINFO UnsafeMenuInfo,
   BOOL SetOrGet)
{
   BOOL Res;
   DWORD Size;
   NTSTATUS Status;
   ROSMENUINFO MenuInfo;

   Status = MmCopyFromCaller(&Size, &UnsafeMenuInfo->cbSize, sizeof(DWORD));
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return( FALSE);
   }
   if(Size < sizeof(MENUINFO) || sizeof(ROSMENUINFO) < Size)
   {
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      return( FALSE);
   }
   Status = MmCopyFromCaller(&MenuInfo, UnsafeMenuInfo, Size);
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return( FALSE);
   }

   if(SetOrGet)
   {
      /* Set MenuInfo */
      Res = IntSetMenuInfo(Menu, &MenuInfo);
   }
   else
   {
      /* Get MenuInfo */
      Res = IntGetMenuInfo(Menu, &MenuInfo);
      if (Res)
      {
         Status = MmCopyToCaller(UnsafeMenuInfo, &MenuInfo, Size);
         if (! NT_SUCCESS(Status))
         {
            SetLastNtError(Status);
            return( FALSE);
         }
      }
   }

   return( Res);
}





/*
 * @implemented
 */
BOOL
STDCALL
NtUserMenuInfo(
   HMENU hMenu,
   PROSMENUINFO UnsafeMenuInfo,
   BOOL SetOrGet)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserMenuInfo\n");
   UserEnterShared();

   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN(FALSE);
   }

   RETURN(UserMenuInfo(Menu, UnsafeMenuInfo, SetOrGet));

CLEANUP:
   DPRINT("Leave NtUserMenuInfo, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}



/*
 * @implemented
 */
int STDCALL
NtUserMenuItemFromPoint(
   HWND hWnd,
   HMENU hMenu,
   DWORD X,
   DWORD Y)
{
   PMENU_OBJECT Menu;
   PWINDOW_OBJECT Window = NULL;
   PMENU_ITEM mi;
   int i;
   DECLARE_RETURN(int);

   DPRINT("Enter NtUserMenuItemFromPoint\n");
   UserEnterExclusive();

   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN( -1);
   }

   if (!(Window = UserGetWindowObject(Menu->MenuInfo.Wnd)))
   {
      RETURN( -1);
   }

   X -= Window->WindowRect.left;
   Y -= Window->WindowRect.top;

   mi = Menu->MenuItemList;
   for (i = 0; NULL != mi; i++)
   {
      if (InRect(mi->Rect, X, Y))
      {
         break;
      }
      mi = mi->Next;
   }

   RETURN( (mi ? i : NO_SELECTED_ITEM));

CLEANUP:
   DPRINT("Leave NtUserMenuItemFromPoint, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}



static
BOOL FASTCALL
UserMenuItemInfo(
   PMENU_OBJECT Menu,
   UINT Item,
   BOOL ByPosition,
   PROSMENUITEMINFO UnsafeItemInfo,
   BOOL SetOrGet)
{
   PMENU_ITEM MenuItem;
   ROSMENUITEMINFO ItemInfo;
   NTSTATUS Status;
   UINT Size;
   BOOL Ret;

   Status = MmCopyFromCaller(&Size, &UnsafeItemInfo->cbSize, sizeof(UINT));
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return( FALSE);
   }
   if (sizeof(MENUITEMINFOW) != Size
         && FIELD_OFFSET(MENUITEMINFOW, hbmpItem) != Size
         && sizeof(ROSMENUITEMINFO) != Size)
   {
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      return( FALSE);
   }
   Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, Size);
   if (! NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return( FALSE);
   }
   /* If this is a pre-0x0500 _WIN32_WINNT MENUITEMINFOW, you can't
      set/get hbmpItem */
   if (FIELD_OFFSET(MENUITEMINFOW, hbmpItem) == Size
         && 0 != (ItemInfo.fMask & MIIM_BITMAP))
   {
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      return( FALSE);
   }

   if (IntGetMenuItemByFlag(Menu, Item,
                            (ByPosition ? MF_BYPOSITION : MF_BYCOMMAND),
                            &MenuItem, NULL) < 0)
   {
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      return( FALSE);
   }

   if (SetOrGet)
   {
      Ret = IntSetMenuItemInfo(Menu, MenuItem, &ItemInfo);
   }
   else
   {
      Ret = IntGetMenuItemInfo(Menu, MenuItem, &ItemInfo);
      if (Ret)
      {
         Status = MmCopyToCaller(UnsafeItemInfo, &ItemInfo, Size);
         if (! NT_SUCCESS(Status))
         {
            SetLastNtError(Status);
            return( FALSE);
         }
      }
   }

   return( Ret);
}



/*
 * @implemented
 */
BOOL
STDCALL
NtUserMenuItemInfo(
   HMENU hMenu,
   UINT Item,
   BOOL ByPosition,
   PROSMENUITEMINFO UnsafeItemInfo,
   BOOL SetOrGet)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserMenuItemInfo\n");
   UserEnterExclusive();

   if (!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN(FALSE);
   }

   RETURN( UserMenuItemInfo(Menu, Item, ByPosition, UnsafeItemInfo, SetOrGet));

CLEANUP:
   DPRINT("Leave NtUserMenuItemInfo, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;

}


/*
 * @implemented
 */
BOOL STDCALL
NtUserRemoveMenu(
   HMENU hMenu,
   UINT uPosition,
   UINT uFlags)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserRemoveMenu\n");
   UserEnterExclusive();

   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN( FALSE);
   }

   RETURN(IntRemoveMenuItem(Menu, uPosition, uFlags, FALSE));

CLEANUP:
   DPRINT("Leave NtUserRemoveMenu, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;

}


/*
 * @implemented
 */
BOOL STDCALL
NtUserSetMenuContextHelpId(
   HMENU hMenu,
   DWORD dwContextHelpId)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserSetMenuContextHelpId\n");
   UserEnterExclusive();

   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN( FALSE);
   }

   RETURN(IntSetMenuContextHelpId(Menu, dwContextHelpId));

CLEANUP:
   DPRINT("Leave NtUserSetMenuContextHelpId, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}



/*
 * @implemented
 */
BOOL STDCALL
NtUserSetMenuDefaultItem(
   HMENU hMenu,
   UINT uItem,
   UINT fByPos)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserSetMenuDefaultItem\n");
   UserEnterExclusive();

   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN( FALSE);
   }

   RETURN( UserSetMenuDefaultItem(Menu, uItem, fByPos));

CLEANUP:
   DPRINT("Leave NtUserSetMenuDefaultItem, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}


/*
 * @implemented
 */
BOOL STDCALL
NtUserSetMenuFlagRtoL(
   HMENU hMenu)
{
   PMENU_OBJECT Menu;
   DECLARE_RETURN(BOOL);

   DPRINT("Enter NtUserSetMenuFlagRtoL\n");
   UserEnterExclusive();

   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      RETURN( FALSE);
   }

   RETURN(IntSetMenuFlagRtoL(Menu));

CLEANUP:
   DPRINT("Leave NtUserSetMenuFlagRtoL, ret=%i\n",_ret_);
   UserLeave();
   END_CLEANUP;
}


/*
 * @unimplemented
 */
DWORD STDCALL
NtUserThunkedMenuInfo(
   HMENU hMenu,
   LPCMENUINFO lpcmi)
{
   UNIMPLEMENTED
   /* This function seems just to call SetMenuInfo() */
   return 0;
}


/*
 * @unimplemented
 */
DWORD STDCALL
NtUserThunkedMenuItemInfo(
   HMENU hMenu,
   UINT uItem,
   BOOL fByPosition,
   BOOL bInsert,
   LPMENUITEMINFOW lpmii,
   PUNICODE_STRING lpszCaption)
{
   UNIMPLEMENTED
   /* lpszCaption may be NULL, check for it and call RtlInitUnicodeString()
      if bInsert == TRUE call NtUserInsertMenuItem() else NtUserSetMenuItemInfo()
   */
   return 0;
}


/*
 * @implemented
 */
/* NOTE: unused function */
BOOL STDCALL
NtUserTrackPopupMenuEx(
   HMENU hMenu,
   UINT fuFlags,
   int x,
   int y,
   HWND hWnd,
   LPTPMPARAMS lptpm)
{
   UNIMPLEMENTED

   return FALSE;
}


/* EOF */