You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1636 lines
52 KiB
1636 lines
52 KiB
/*++
|
|
*
|
|
* WOW v1.0
|
|
*
|
|
* Copyright (c) 1991, Microsoft Corporation
|
|
*
|
|
* WUMENU.C
|
|
* WOW32 16-bit User API support
|
|
*
|
|
* History:
|
|
* Created 07-Mar-1991 by Jeff Parsons (jeffpar)
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
MODNAME(wumenu.c);
|
|
|
|
|
|
/*++
|
|
BOOL AppendMenu(<hMenu>, <wFlags>, <wIDNewItem>, <lpNewItem>)
|
|
HMENU <hMenu>;
|
|
WORD <wFlags>;
|
|
WORD <wIDNewItem>;
|
|
LPSTR <lpNewItem>;
|
|
|
|
The %AppendMenu% function appends a new item to the end of a menu. The
|
|
application can specify the state of the menu item by setting values in the
|
|
<wFlags> parameter.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<wFlags>
|
|
Specifies information about the state of the new menu item when
|
|
it is added to the menu. It consists of one or more values listed in the
|
|
following Comments section.
|
|
|
|
<wIDNewItem>
|
|
Specifies either the command ID of the new menu item or, if
|
|
<wFlags> is set to MF_POPUP, the menu handle of the pop-up menu.
|
|
|
|
<lpNewItem>
|
|
Specifies the content of the new menu item. The interpretation
|
|
of the <lpNewItem> parameter depends upon the setting of the <wFlags>
|
|
parameter.
|
|
|
|
MF_STRING
|
|
Contains a long pointer to a null-terminated string.
|
|
|
|
MF_BITMAP
|
|
Contains a bitmap handle in its low-order word.
|
|
|
|
MF_OWNERDRAW
|
|
Contains an application-supplied 32-bit value which the application can
|
|
use to maintain additional data associated with the menu item. This
|
|
32-bit value is available to the application in the %itemData% member of
|
|
the structure pointed to by the <lParam> parameter of the WM_MEASUREITEM
|
|
and WM_DRAWITEM messages sent when the menu item is initially displayed
|
|
or is changed.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%.
|
|
|
|
Each of the following groups list flags that are mutually exclusive and
|
|
cannot be used together:
|
|
|
|
o MF_BYCOMMAND and MF_BYPOSITION
|
|
|
|
o MF_DISABLED, MF_ENABLED, and MF_GRAYED
|
|
|
|
o MF_BITMAP, MF_STRING, and MF_OWNERDRAW
|
|
|
|
o MF_MENUBARBREAK and MF_MENUBREAK
|
|
|
|
o MF_CHECKED and MF_UNCHECKED
|
|
|
|
.cmt
|
|
16-Sep-1990 [ralphw]
|
|
|
|
Some of the above flags aren't documented as valid values for the wFlags
|
|
parameter. If they are valid, they should be documented, otherwise, they
|
|
should be removed from the list.
|
|
.endcmt
|
|
|
|
The following list describes the flags which may be set in the <wFlags>
|
|
parameter:
|
|
|
|
MF_BITMAP
|
|
Uses a bitmap as the item. The low-order word of the lpNewItem parameter
|
|
contains the handle of the bitmap.
|
|
|
|
MF_CHECKED
|
|
Places a checkmark next to the item. If the application has supplied
|
|
checkmark bitmaps (see %SetMenuItemBitmaps%), setting this flag displays
|
|
the checkmark on bitmap next to the menu item.
|
|
|
|
MF_DISABLED
|
|
Disables the menu item so that it cannot be selected, but does not gray
|
|
it.
|
|
|
|
MF_ENABLED
|
|
Enables the menu item so that it can be selected and restores it from
|
|
its grayed state.
|
|
|
|
MF_GRAYED
|
|
Disables the menu item so that it cannot be selected and grays it.
|
|
|
|
MF_MENUBARBREAK
|
|
Same as MF_MENUBREAK except that for pop-up menus, separates the new
|
|
column from the old column with a vertical line.
|
|
|
|
MF_MENUBREAK
|
|
Places the item on a new line for static menu-bar items. For pop-up
|
|
menus, places the item in a new column, with no dividing line between
|
|
the columns.
|
|
|
|
MF_OWNERDRAW
|
|
Specifies that the item is an owner-draw item. The window that owns the
|
|
menu receives a WM_MEASUREITEM message when the menu is displayed for
|
|
the first time to retrieve the height and width of the menu item. The
|
|
WM_DRAWITEM message is then sent whenever the owner must update the
|
|
visual appearance of the menu item. This option is not valid for a
|
|
top-level menu item.
|
|
|
|
MF_POPUP
|
|
Specifies that the menu item has a pop-up menu associated with it. The
|
|
<wIDNewItem> parameter specifies a handle to a pop-up menu to be
|
|
associated with the item. This is used for adding either a top-level
|
|
pop-up menu or adding a hierarchical pop-up menu to a pop-up menu item.
|
|
|
|
MF_SEPARATOR
|
|
Draws a horizontal dividing line. Can only be used in a pop-up menu.
|
|
This line cannot be grayed, disabled, or highlighted. The <lpNewItem>
|
|
and <wIDNewItem> parameters are ignored.
|
|
|
|
MF_STRING
|
|
Specifies that the menu item is a character string; the <lpNewItem>
|
|
parameter points to the string for the menu item.
|
|
|
|
MF_UNCHECKED
|
|
Does not place a checkmark next to the item (default). If the
|
|
application has supplied checkmark bitmaps (see %SetMenuItemBitmaps%),
|
|
setting this flag displays the checkmark off bitmap next to the menu
|
|
item.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32AppendMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz4;
|
|
register PAPPENDMENU16 parg16;
|
|
UINT wIDNewItem;
|
|
|
|
GETARGPTR(pFrame, sizeof(APPENDMENU16), parg16);
|
|
|
|
// USER has some internal bitmap identifiers for menu item bitmaps so
|
|
// it doesn't have to store multiple copies of these bitmaps when they
|
|
// appear in multiple menus. WinProj does its own MDI and uses these
|
|
// bitmaps.
|
|
|
|
// #define MENUHBM_CHILDCLOSE (UINT)1
|
|
// #define MENUHBM_RESTORE (UINT)2
|
|
// #define MENUHBM_MINIMIZE (UINT)3
|
|
// #define MENUHBM_MAX (UINT)4
|
|
|
|
if (parg16->f2 & MF_BITMAP) {
|
|
if (LOW(parg16->f4) >= 4)
|
|
psz4 = (PSZ)HBITMAP32(LOW(parg16->f4));
|
|
else
|
|
psz4 = (PSZ)WORD32(parg16->f4);
|
|
}
|
|
else if (parg16->f2 & MF_OWNERDRAW)
|
|
psz4 = (PSZ)DWORD32(parg16->f4);
|
|
else
|
|
GETPSZPTR(parg16->f4, psz4);
|
|
|
|
wIDNewItem = (UINT) WORD32(parg16->f3);
|
|
|
|
if (parg16->f2 & MF_POPUP)
|
|
wIDNewItem = (UINT) HMENU32(parg16->f3);
|
|
|
|
|
|
ul = GETBOOL16(AppendMenu(HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
wIDNewItem,
|
|
psz4));
|
|
|
|
#ifdef FE_SB
|
|
// For AutherWare Star ( APP BUG ) MAKKBUG:3203
|
|
if (CURRENTPTD()->dwWOWCompatFlagsFE & WOWCF_FE_ASWHELPER) { if (parg16->f2 & MF_POPUP) {
|
|
HWND hWnd;
|
|
|
|
if (!(hWnd=GetActiveWindow())) {
|
|
hWnd = GetForegroundWindow();
|
|
}
|
|
SetMenu(hWnd , HMENU32(parg16->f1));
|
|
}
|
|
}
|
|
#endif // FE_SB
|
|
|
|
FREEPSZPTR(psz4);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
BOOL ChangeMenu(<hMenu>,<wIDChangeItem>,<lpNewItem>,<wIDNewItem>,<wFlags>)
|
|
HMENU <hMenu>;
|
|
WORD <wIDChangeItem>;
|
|
LPSTR <lpNewItem>;
|
|
WORD <wIDNewItem>;
|
|
WORD <wFlags>;
|
|
|
|
The %ChangeMenu% function appends, inserts, deletes, or modifies a menu
|
|
item in the menu given by the <hMenu> parameter. The <wIDChangeItem>,
|
|
<lpNewItem>, <wIDNewItem> and <wFlags> parameters define which item to
|
|
change and how to change it.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<wIDChangeItem>
|
|
Specifies the item to be changed. If MF_BYPOSITION is specified,
|
|
<wIDChangeItem> gives the position of the menu item to be
|
|
changed (the first item is at position zero). If MF_BYCOMMAND is
|
|
specified instead, <wIDChangeItem> specifies the menu-item ID.
|
|
The menu-item ID can specify any popup-menu item (that is, an item
|
|
in a popup menu associated with an item of <hMenu>). If neither
|
|
flag is given, the default is MF_BYCOMMAND. When MF_INSERT is used,
|
|
<wIDChangeItem> identifies the item before which the new item is to
|
|
be inserted. When MF_APPEND is used, <wIDChangeItem> is NULL.
|
|
|
|
<lpNewItem>
|
|
Specifies the content of the new menu item. The interpretation
|
|
of the <lpNewItem> parameter depends upon the setting of the <wFlags>
|
|
parameter. The <lpNewItem> parameter is never a handle to a menu.
|
|
The MF_POPUP flag applies to the <wIDNewItem> parameter only.
|
|
|
|
MF_BITMAP
|
|
<lpNewItem> contains a bitmap handle in its low-order word.
|
|
|
|
MF_STRING
|
|
<lpNewItem> contains a long pointer to a null-terminated string.
|
|
|
|
The default is MF_STRING. A NULL value for <lpNewItem> creates a
|
|
horizontal break (the same effect as using the MF_SEPARATOR flag).
|
|
|
|
Note that MF_OWNERDRAW is not allowed on ChangeMenu; it conflicts with
|
|
the ChangeMenu command bit MF_APPEND.
|
|
|
|
<wIDNewItem>
|
|
Specifies either the command ID of the new menu item or, if
|
|
<wFlags> is set to MF_POPUP, the menu handle of the pop-up menu.
|
|
It is never a menu-item position.
|
|
|
|
<wFlags>
|
|
Specifies information about the state of the new menu item when it
|
|
is added to the menu. It consists of one or more values listed in
|
|
the following Comments section.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%.
|
|
|
|
Each of the following groups list flags that are mutually exclusive and
|
|
cannot be used together:
|
|
|
|
o MF_APPEND, MF_CHANGE, MF_DELETE, MF_INSERT and MF_REMOVE
|
|
|
|
o MF_BYCOMMAND and MF_BYPOSITION
|
|
|
|
o MF_DISABLED, MF_ENABLED, and MF_GRAYED
|
|
|
|
o MF_BITMAP, MF_POPUP and MF_STRING
|
|
|
|
o MF_MENUBARBREAK and MF_MENUBREAK
|
|
|
|
o MF_CHECKED and MF_UNCHECKED
|
|
|
|
.cmt
|
|
16-Sep-1990 [ralphw]
|
|
|
|
Some of the above flags aren't documented as valid values for the wFlags
|
|
parameter. If they are valid, they should be documented, otherwise, they
|
|
should be removed from the list.
|
|
.endcmt
|
|
|
|
The following list describes the flags which may be set in the <wFlags>
|
|
parameter:
|
|
|
|
MF_APPEND
|
|
Appends the new item to the end of the menu.
|
|
|
|
MF_BITMAP
|
|
Uses a bitmap as the item. The low-order word of the lpNewItem parameter
|
|
contains the handle of the bitmap.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies that the <wIDChangeItem> parameter gives the menu-item ID
|
|
number (default).
|
|
|
|
MF_BYPOSITION
|
|
Specifies that the <wIDChangeItem> parameter gives the position of
|
|
the menu item to be changed.
|
|
|
|
MF_CHANGE
|
|
Changes or replaces the specified item.
|
|
|
|
MF_CHECKED
|
|
Places a checkmark next to the item. If the application has supplied
|
|
checkmark bitmaps (see %SetMenuItemBitmaps%), setting this flag displays
|
|
the checkmark on bitmap next to the menu item.
|
|
|
|
MF_DELETE
|
|
Deletes the item.
|
|
|
|
MF_DISABLED
|
|
Disables the menu item so that it cannot be selected, but does not gray
|
|
it.
|
|
|
|
MF_ENABLED
|
|
Enables the menu item so that it can be selected and restores it from
|
|
its grayed state.
|
|
|
|
MF_GRAYED
|
|
Disables the menu item so that it cannot be selected and grays it.
|
|
|
|
MF_INSERT
|
|
Inserts a new item, just before the specified item.
|
|
|
|
MF_MENUBARBREAK
|
|
Same as MF_MENUBREAK except that for pop-up menus, separates the new
|
|
column from the old column with a vertical line.
|
|
|
|
MF_MENUBREAK
|
|
Places the item on a new line for static menu-bar items. For pop-up
|
|
menus, places the item in a new column, with no dividing line between
|
|
the columns.
|
|
|
|
MF_POPUP
|
|
Specifies that the menu item has a pop-up menu associated with it. The
|
|
<wIDNewItem> parameter specifies a handle to a pop-up menu to be
|
|
associated with the item. This is used for adding either a top-level
|
|
pop-up menu or adding a hierarchical pop-up menu to a pop-up menu item.
|
|
|
|
MF_REMOVE
|
|
Removes the item but does not delete it.
|
|
|
|
MF_SEPARATOR
|
|
Draws a horizontal dividing line. Can only be used in a pop-up menu.
|
|
This line cannot be grayed, disabled, or highlighted. The <lpNewItem>
|
|
and <wIDNewItem> parameters are ignored.
|
|
|
|
MF_STRING
|
|
Specifies that the menu item is a character string; the <lpNewItem>
|
|
parameter points to the string for the menu item.
|
|
|
|
MF_UNCHECKED
|
|
Does not place a checkmark next to the item (default). If the
|
|
application has supplied checkmark bitmaps (see %SetMenuItemBitmaps%),
|
|
setting this flag displays the checkmark off bitmap next to the menu
|
|
item.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32ChangeMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz3;
|
|
DWORD dw4;
|
|
|
|
register PCHANGEMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CHANGEMENU16), parg16);
|
|
|
|
if (parg16->f5 & MF_BITMAP) {
|
|
if (LOW(parg16->f3) >= 4)
|
|
psz3 = (PSZ)HBITMAP32(LOW(parg16->f3));
|
|
else
|
|
psz3 = (PSZ)WORD32(parg16->f3);
|
|
}
|
|
else
|
|
GETPSZPTR(parg16->f3, psz3);
|
|
|
|
dw4 = WORD32(parg16->f4);
|
|
if (WORD32(parg16->f5) & MF_POPUP)
|
|
dw4 = (DWORD)HMENU32(parg16->f4);
|
|
|
|
ul = GETBOOL16(ChangeMenu(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
psz3,
|
|
dw4,
|
|
WORD32(parg16->f5)
|
|
));
|
|
|
|
FREEPSZPTR(psz3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL CheckMenuItem(<hMenu>, <wIDCheckItem>, <wCheck>)
|
|
HMENU <hMenu>;
|
|
WORD <wIDCheckItem>;
|
|
WORD <wCheck>;
|
|
|
|
The %CheckMenuItem% function places checkmarks next to or removes checkmarks
|
|
from menu items in the pop-up menu specified by the <hMenu> parameter. The
|
|
<wIDCheckItem> parameter specifies the item to be modified.
|
|
|
|
<hMenu>
|
|
Identifies the menu.
|
|
|
|
<wIDCheckItem>
|
|
Specifies the menu item to be checked.
|
|
|
|
<wCheck>
|
|
Specifies how to check the menu item and how to determine the item's
|
|
position in the menu. The <wCheck> parameter can be a combination of the
|
|
MF_CHECKED or MF_UNCHECKED with MF_BYPOSITION or MF_BYCOMMAND flags.
|
|
These flags can be combined by using the bitwise OR operator. They have
|
|
the following meanings:
|
|
|
|
MF_BYCOMMAND
|
|
Specifies that the <wIDCheckItem> parameter gives the menu-item ID
|
|
(MF_BYCOMMAND is the default).
|
|
|
|
MF_BYPOSITION
|
|
Specifies that the <wIDCheckItem > parameter gives the position of the
|
|
menu item (the first item is at position zero).
|
|
|
|
MF_CHECKED
|
|
Adds checkmark.
|
|
|
|
MF_UNCHECKED
|
|
Removes checkmark.
|
|
|
|
The return value specifies the previous state of the item. It is either
|
|
MF_CHECKED or MF_UNCHECKED. The return value is -1 if the menu item does not
|
|
exist.
|
|
|
|
The <wIDCheckItem> parameter may identify a pop-up menu item as well as a
|
|
menu item. No special steps are required to check a pop-up menu item.
|
|
|
|
Top-level menu items cannot be checked.
|
|
|
|
A pop-up menu item should be checked by position since it does not have a
|
|
menu-item identifier associated with it.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32CheckMenuItem(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PCHECKMENUITEM16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(CHECKMENUITEM16), parg16);
|
|
|
|
ul = GETBOOL16(CheckMenuItem(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HMENU CreateMenu(VOID)
|
|
|
|
The %CreateMenu% function creates a menu. The menu is initially empty, but
|
|
can be filled with menu items by using the %AppendMenu% or %InsertMenu%
|
|
function.
|
|
|
|
This function has no parameters.
|
|
|
|
The return value identifies the newly created menu. It is NULL if the menu
|
|
cannot be created.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32CreateMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
|
|
UNREFERENCED_PARAMETER(pFrame);
|
|
|
|
ul = GETHMENU16(CreateMenu());
|
|
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HMENU CreatePopupMenu(VOID)
|
|
|
|
The %CreatePopupMenu% function creates and returns a handle to an empty
|
|
pop-up menu.
|
|
|
|
An application adds items to the pop-up menu by calling %InsertMenu% and
|
|
%AppendMenu%. The application can add the pop-up menu to an existing menu or
|
|
pop-up menu, or it may display and track selections on the pop-up menu by
|
|
calling %TrackPopupMenu%.
|
|
|
|
This function has no parameters.
|
|
|
|
The return value identifies the newly created menu. It is NULL if the menu
|
|
cannot be created.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32CreatePopupMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
|
|
UNREFERENCED_PARAMETER(pFrame);
|
|
|
|
ul = GETHMENU16(CreatePopupMenu());
|
|
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL DeleteMenu(<hMenu>, <nPosition>, <wFlags>)
|
|
HMENU <hMenu>;
|
|
WORD <nPosition>;
|
|
WORD <wFlags>;
|
|
|
|
The %DeleteMenu% function deletes an item from the menu identified by the
|
|
<hMenu> parameter; if the menu item has an associated pop-up menu,
|
|
%DeleteMenu% destroys the handle by the pop-up menu and frees the memory
|
|
used by the pop-up menu.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<nPosition>
|
|
Specifies the menu item which is to be deleted, as determined by the
|
|
<wFlags> parameter:
|
|
|
|
MF_BYPOSITION
|
|
Specifies the position of the menu item; the first item in the menu is
|
|
at position 0.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies the command ID of the existing menu item.
|
|
|
|
<wFlags>
|
|
Specifies how the <nPosition> parameter is interpreted. It may be
|
|
set to either MF_BYCOMMAND or MF_BYPOSITION.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%.
|
|
--*/
|
|
ULONG FASTCALL WU32DeleteMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PDELETEMENU16 parg16;
|
|
PSZ pszModName;
|
|
|
|
GETARGPTR(pFrame, sizeof(DELETEMENU16), parg16);
|
|
|
|
// Nasty Hack to fix MSVC 1.5, they remove the close item
|
|
// from their system menu, so we prevent them from doing
|
|
// this and act like nothing happened ( ie return TRUE ).
|
|
// From Win 95, Bug#8154, [t-arthb]
|
|
|
|
if ((parg16->f2 == 6) && (parg16->f3 & MF_BYPOSITION)) {
|
|
pszModName = ((PTDB)SEGPTR(CURRENTPTD()->htask16,0))->TDB_ModName;
|
|
if (!WOW32_strncmp(pszModName, "MSVC", 4)) {
|
|
FREEARGPTR(parg16);
|
|
RETURN(GETBOOL16(TRUE));
|
|
}
|
|
}
|
|
|
|
ul = GETBOOL16(DeleteMenu(HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3)));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL DestroyMenu(<hMenu>)
|
|
HMENU <hMenu>;
|
|
|
|
The %DestroyMenu% function destroys the menu specified by the <hMenu>
|
|
parameter and frees any memory that the menu occupied.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be destroyed.
|
|
|
|
The return value specifies whether or not the specified menu is destroyed.
|
|
It is TRUE if the menu is destroyed. Otherwise, it is FALSE.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DestroyMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PDESTROYMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(DESTROYMENU16), parg16);
|
|
|
|
ul = GETBOOL16(DestroyMenu(HMENU32(parg16->f1)));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
void DrawMenuBar(<hwnd>)
|
|
HWND <hwnd>;
|
|
|
|
The %DrawMenuBar% function redraws the menu bar. If a menu bar is changed
|
|
<after> Windows has created the window, this function should be called to
|
|
draw the changed menu bar.
|
|
|
|
<hwnd>
|
|
Identifies the window whose menu needs redrawing.
|
|
|
|
This function does not return a value.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32DrawMenuBar(PVDMFRAME pFrame)
|
|
{
|
|
register PDRAWMENUBAR16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(DRAWMENUBAR16), parg16);
|
|
|
|
DrawMenuBar(HWND32(parg16->f1));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(TRUE);
|
|
}
|
|
|
|
|
|
/*++
|
|
DWORD GetMenuCheckMarkDimensions(VOID)
|
|
|
|
The %GetMenuCheckMarkDimensions% function returns the dimensions of the
|
|
default checkmark bitmap. Windows displays this bitmap next to checked menu
|
|
items. Before calling the %SetMenuItemBitmaps% function to replace the
|
|
default checkmark, an application should call the
|
|
%GetMenuCheckMarkDimensions% function to determine the correct size for the
|
|
bitmaps.
|
|
|
|
This function has no parameters.
|
|
|
|
The return value specifies the height and width of the default checkmark
|
|
bitmap. The high-order word contains the height in pixels and the low-order
|
|
word contains the width.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetMenuCheckMarkDimensions(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
|
|
UNREFERENCED_PARAMETER(pFrame);
|
|
|
|
ul = GETLONG16(GetMenuCheckMarkDimensions());
|
|
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
int GetMenuString(<hMenu>, <wIDItem>, <lpString>, <nMaxCount>, <wFlag>)
|
|
HMENU <hMenu>;
|
|
WORD <wIDItem>;
|
|
LPSTR <lpString>;
|
|
int <nMaxCount>;
|
|
WORD <wFlag>;
|
|
|
|
The %GetMenuString% function copies the label of the specified menu item
|
|
into the <lpString> parameter.
|
|
|
|
<hMenu>
|
|
Identifies the menu.
|
|
|
|
<wIDItem>
|
|
Specifies the integer identifier of the menu item (from the
|
|
resource file) or the offset of the menu item in the menu, depending on
|
|
the value of the <wFlag> parameter.
|
|
|
|
<lpString>
|
|
Points to the buffer that is to receive the label.
|
|
|
|
<nMaxCount>
|
|
Specifies the maximum length of the label to be copied. If the
|
|
label is longer than the maximum specified in <nMaxCount>, the extra
|
|
characters are truncated.
|
|
|
|
<wFlag>
|
|
Specifies the nature of the <wID> parameter. If <wFlags> contains
|
|
MF_BYPOSITION, <wId> specifies a (zero-based) relative position; if the
|
|
<wFlags> parameter contains MF_BYCOMMAND, <wId> specifies the item ID.
|
|
|
|
The return value specifies the actual number of bytes copied to the buffer.
|
|
|
|
The <nMaxCount> parameter should be one larger than the number of characters
|
|
in the label to accommodate the null character that terminates a string.
|
|
--*/
|
|
|
|
#define GMS32_LIMIT 2000
|
|
ULONG FASTCALL WU32GetMenuString(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz3;
|
|
register PGETMENUSTRING16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETMENUSTRING16), parg16);
|
|
ALLOCVDMPTR(parg16->f3, parg16->f4, psz3);
|
|
|
|
// limit nMaxCount to a reasonable amount so it does not fail in client
|
|
// server. Some wow apps passed in -1.
|
|
ul = GETINT16(GetMenuString(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
psz3,
|
|
(WORD32(parg16->f4) > GMS32_LIMIT) ? GMS32_LIMIT : WORD32(parg16->f4),
|
|
WORD32(parg16->f5)
|
|
));
|
|
|
|
FLUSHVDMPTR(parg16->f3, strlen(psz3)+1, psz3);
|
|
FREEVDMPTR(psz3);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HMENU GetSystemMenu(<hwnd>, <bRevert>)
|
|
HWND <hwnd>;
|
|
BOOL <bRevert>;
|
|
|
|
The %GetSystemMenu% function allows the application to access the System
|
|
menu for copying and modification.
|
|
|
|
<hwnd>
|
|
Identifies the window that will own a copy of the System menu.
|
|
|
|
<bRevert>
|
|
Specifies the action to be taken.
|
|
|
|
If <bRevert> is FALSE, the %GetSystemMenu% returns a handle to a copy of
|
|
the System menu currently in use. This copy is initially identical to
|
|
the System menu, but can be modified.
|
|
|
|
If <bRevert> is TRUE, the %GetSystemMenu% function destroys the possibly
|
|
modified copy of the System menu (if there is one) that belongs to the
|
|
specified window and returns a handle to the original, unmodified
|
|
version of the System menu.
|
|
|
|
The return value identifies the System menu if <bRevert> is TRUE and the
|
|
System menu has been modified. If <bRevert> is TRUE and the System menu
|
|
has <not> been modified, the return value is NULL. If <bRevert> is FALSE, the
|
|
return value identifies a copy of the System menu.
|
|
|
|
Any window that does not use the %GetSystemMenu% function to make its own
|
|
copy of the System menu receives the standard System menu.
|
|
|
|
The handle returned by the %GetSystemMenu% function can be used with the
|
|
%AppendMenu%, %InsertMenu% or %ModifyMenu% functions to change the System
|
|
menu. The System menu initially contains items identified with various ID
|
|
values such as SC_CLOSE, SC_MOVE, and SC_SIZE. Menu items on the System menu
|
|
send WM_SYSCOMMAND messages. All predefined System-menu items have ID
|
|
numbers greater than 0xF000. If an application adds commands to the System
|
|
menu, it should use ID numbers less than F000.
|
|
|
|
Windows automatically grays items on the standard System menu, depending on
|
|
the situation. The application can carry out its own checking or graying by
|
|
responding to the WM_INITMENU message, which is sent before any menu is
|
|
displayed.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32GetSystemMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PGETSYSTEMMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(GETSYSTEMMENU16), parg16);
|
|
|
|
ul = GETHMENU16(GetSystemMenu(HWND32(parg16->f1),
|
|
BOOL32(parg16->f2)));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL HiliteMenuItem(<hwnd>, <hMenu>, <wIDHiliteItem>, <wHilite>)
|
|
HWND <hwnd>;
|
|
HMENU <hMenu>;
|
|
WORD <wIDHiliteItem>;
|
|
WORD <wHilite>;
|
|
|
|
The %HiliteMenuItem% function highlights or removes the highlighting from a
|
|
top-level (menu-bar) menu item.
|
|
|
|
<hwnd>
|
|
Identifies the window that contains the menu.
|
|
|
|
<hMenu>
|
|
Identifies the top-level menu that contains the item to be
|
|
highlighted.
|
|
|
|
<wIDHiliteItem>
|
|
Specifies the integer identifier of the menu item or the offset
|
|
of the menu item in the menu, depending on the value of the <wHilite>
|
|
parameter.
|
|
|
|
<wHilite>
|
|
Specifies whether the menu item is highlighted or the highlight
|
|
is removed. It can be a combination of MF_HILITE or MF_UNHILITE with
|
|
MF_BYCOMMAND or MF_BYPOSITION. The values can be combined using the
|
|
bitwise OR operator. These values have the following meanings:
|
|
|
|
MF_BYCOMMAND
|
|
Interprets wIDHiliteItem as the menu-item ID (the default
|
|
interpretation).
|
|
|
|
MF_BYPOSITION
|
|
Interprets <wIDHiliteItem> as an offset.
|
|
|
|
MF_HILITE
|
|
Highlights the item. If this value is not given, highlighting is removed
|
|
from the item.
|
|
|
|
MF_UNHILITE
|
|
Removes highlighting from the item.
|
|
|
|
The return value specifies whether or not the menu item is highlighted the
|
|
outcome of the function. It is TRUE if the item is highlighted was set to
|
|
the specified highlight state. Otherwise, it is FALSE.
|
|
|
|
The MF_HILITE and MF_UNHILITE flags can be used only with the
|
|
%HiliteMenuItem% function; they cannot be used with the %ModifyMenu%
|
|
function.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32HiliteMenuItem(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PHILITEMENUITEM16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(HILITEMENUITEM16), parg16);
|
|
|
|
ul = GETBOOL16(HiliteMenuItem(
|
|
HWND32(parg16->f1),
|
|
HMENU32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
WORD32(parg16->f4)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL InsertMenu(<hMenu>, <nPosition>, <wFlags>, <wIDNewItem>, <lpNewItem>)
|
|
HMENU <hMenu>;
|
|
WORD <nPosition>;
|
|
WORD <wFlags>;
|
|
WORD <wIDNewItem>;
|
|
LPSTR <lpNewItem>;
|
|
|
|
The %InsertMenu% function inserts a new menu item at the position specified
|
|
by the <nPosition> parameter, moving other items down the menu. The
|
|
application can specify the state of the menu item by setting values in the
|
|
<wFlags> parameter.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<nPosition>
|
|
Specifies the menu item before which the new menu item is to be
|
|
inserted. The interpretation of the <nPosition> parameter depends upon
|
|
the setting of the <wFlags> parameter.
|
|
|
|
MF_BYPOSITION
|
|
Specifies the position of the existing menu item. The first item in the
|
|
menu is at position zero.
|
|
|
|
If nPosition is -1, the new menu item is appended to the end of the
|
|
menu.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies the command ID of the existing menu item.
|
|
|
|
<wFlags>
|
|
Specifies how the <nPosition> parameter is interpreted and
|
|
information about the state of the new menu item when it is added to the
|
|
menu. It consists of one or more values listed in the following Comments
|
|
section.
|
|
|
|
<wIDNewItem>
|
|
Specifies either the command ID of the new menu item or, if
|
|
<wFlags> is set to MF_POPUP, the menu handle of the pop-up menu.
|
|
|
|
<lpNewItem>
|
|
Specifies the content of the new menu item. If <wFlags> is set
|
|
to MF_STRING (the default), then <lpNewItem> is a long pointer to a
|
|
null-terminated string. If <wFlags> is set to MF_BITMAP instead, then
|
|
<lpNewItem> contains a bitmap handle (%HBITMAP%) in its low-order word.
|
|
If <wFlags> is set to MF_OWNERDRAW, <lpNewItem> specifies an
|
|
application-supplied 32-bit value which the application can use to
|
|
maintain additional data associated with the menu item. This 32-bit
|
|
value is available to the application in the %itemData% member of the
|
|
structure pointed to by the <lParam> parameter of the following
|
|
messages:
|
|
|
|
WM_MEASUREITEM
|
|
WM_DRAWITEM
|
|
|
|
These messages are sent when the menu item is initially displayed, or is
|
|
changed.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%.
|
|
|
|
Each of the following groups lists flags that should not be used together:
|
|
|
|
o MF_BYCOMMAND and MF_BYPOSITION
|
|
|
|
o MF_DISABLED, MF_ENABLED, and MF_GRAYED
|
|
|
|
o MF_BITMAP, MF_STRING, MF_OWNERDRAW, and MF_SEPARATOR
|
|
|
|
o MF_MENUBARBREAK and MF_MENUBREAK
|
|
|
|
o MF_CHECKED and MF_UNCHECKED
|
|
|
|
The following list describes the flags which may be set in the <wFlags>
|
|
parameter:
|
|
|
|
MF_BITMAP
|
|
Uses a bitmap as the item. The low-order word of the lpNewItem parameter
|
|
contains the handle of the bitmap. MF_BYCOMMAND Specifies that the
|
|
<nPosition> parameter gives the menu-item control ID number (default).
|
|
|
|
MF_BYPOSITION
|
|
Specifies that the <nPosition> parameter gives the position of the menu
|
|
item to be changed rather than an ID number.
|
|
|
|
MF_CHECKED
|
|
Places a checkmark next to the menu item. If the application has
|
|
supplied checkmark bitmaps (see the %SetMenuItemBitmaps% function),
|
|
setting this flag displays the checkmark on bitmap next to the menu
|
|
item.
|
|
|
|
MF_DISABLED
|
|
Disables the menu item so that it cannot be selected, but does not gray
|
|
it.
|
|
|
|
MF_ENABLED
|
|
Enables the menu item so that it can be selected and restores it from
|
|
its grayed state.
|
|
|
|
MF_GRAYED
|
|
Disables the menu item so that it cannot be selected and grays it.
|
|
|
|
MF_MENUBARBREAK
|
|
Same as MF_MENUBREAK except that for pop-up menus, separates the new
|
|
column from the old column with a vertical line.
|
|
|
|
MF_MENUBREAK
|
|
Places the menu item on a new line for static menu-bar items. For pop-up
|
|
menus, places the menu item in a new column, with no dividing line
|
|
between the columns.
|
|
|
|
MF_OWNERDRAW
|
|
Specifies that the item is an owner-draw item. The window that owns the
|
|
menu receives a WM_MEASUREITEM message when the menu is displayed for
|
|
the first time to retrieve the height and width of the menu item. The
|
|
WM_DRAWITEM message is then sent to the owner whenever the owner must
|
|
update the visual appearance of the menu item. This option is not valid
|
|
for a top-level menu item.
|
|
|
|
MF_POPUP
|
|
Specifies that the menu item has a pop-up menu associated with it. The
|
|
<wIDNewItem> parameter specifies a handle to a pop-up menu to be
|
|
associated with the item. Use the MF_OWNERDRAW flag to add either a
|
|
top-level pop-up menu or a hierarchical pop-up menu to a pop-up menu
|
|
item.
|
|
|
|
MF_SEPARATOR
|
|
Draws a horizontal dividing line. You can use this flag in a pop-up
|
|
menu. This line cannot be grayed, disabled, or highlighted. Windows
|
|
ignores the <lpNewItem> and <wIDNewItem> parameters.
|
|
|
|
MF_STRING
|
|
Specifies that the menu item is a character string; the <lpNewItem>
|
|
parameter points to the string for the item.
|
|
|
|
MF_UNCHECKED
|
|
Does not place a checkmark next to the item (default). If the
|
|
application has supplied checkmark bitmaps (see %SetMenuItemBitmaps%),
|
|
setting this flag displays the "checkmark off" bitmap next to the menu
|
|
item.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32InsertMenu(PVDMFRAME pFrame)
|
|
{
|
|
BOOL fNeedToFreePsz5 = FALSE;
|
|
ULONG ul;
|
|
PSZ psz5;
|
|
UINT w4;
|
|
register PINSERTMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(INSERTMENU16), parg16);
|
|
|
|
if (parg16->f3 & MF_BITMAP) {
|
|
if (LOW(parg16->f5) >= 4)
|
|
psz5 = (PSZ)HBITMAP32(LOW(parg16->f5));
|
|
else
|
|
psz5 = (PSZ)WORD32(parg16->f5);
|
|
}
|
|
else if (parg16->f3 & MF_OWNERDRAW) {
|
|
psz5 = (PSZ)DWORD32(parg16->f5);
|
|
}
|
|
else if (parg16->f3 & MF_SEPARATOR) {
|
|
// lpszNewItem is ignored when inserting a separator bar.
|
|
psz5 = NULL;
|
|
}
|
|
else {
|
|
GETPSZPTR(parg16->f5, psz5);
|
|
fNeedToFreePsz5 = TRUE;
|
|
}
|
|
|
|
w4 = (parg16->f3 & MF_POPUP) ? (UINT)HMENU32(parg16->f4) : WORD32(parg16->f4);
|
|
|
|
ul = GETBOOL16(InsertMenu(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
w4,
|
|
psz5
|
|
));
|
|
|
|
if (fNeedToFreePsz5) {
|
|
FREEPSZPTR(psz5);
|
|
}
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HMENU LoadMenu(<hInstance>, <lpMenuName>)
|
|
HANDLE <hInstance>;
|
|
LPSTR <lpMenuName>;
|
|
|
|
This function loads the menu resource named by the <lpMenuName> parameter
|
|
from the executable file associated with the module specified by the
|
|
<hInstance> parameter.
|
|
|
|
<hInstance>
|
|
Identifies an instance of the module whose executable file contains the
|
|
menu.
|
|
|
|
<lpMenuName>
|
|
Points to a character string that names the menu resource. The
|
|
string must be a null-terminated string.
|
|
|
|
The return value identifies a menu resource if the function is successful.
|
|
Otherwise, it is NULL.
|
|
|
|
The <lpMenuName> parameter can contain a value created by the
|
|
%MAKEINTRESOURCE% macro. If it does, the ID must reside in the low-order
|
|
word of <lpMenuName>, and the high-order word must be set to zero.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32LoadMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = 0;
|
|
PSZ psz2;
|
|
register PLOADMENU16 parg16;
|
|
DWORD cb;
|
|
LPBYTE lpResData;
|
|
|
|
LPWSTR lpUniName_Menu;
|
|
|
|
GETARGPTR(pFrame, sizeof(LOADMENU16), parg16);
|
|
psz2 = (PSZ)DWORD32(parg16->f2);
|
|
GETPSZIDPTR(parg16->f2, psz2);
|
|
|
|
if (HIWORD(psz2) != (WORD) NULL) {
|
|
if (!(MBToWCS(psz2, -1, &lpUniName_Menu, -1, TRUE))) {
|
|
FREEPSZIDPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
}
|
|
else {
|
|
lpUniName_Menu = (LPWSTR) psz2;
|
|
}
|
|
|
|
cb = parg16->f4 * sizeof(WCHAR); // see SizeofResource16
|
|
if (cb && (lpResData = malloc_w(cb))) {
|
|
ConvertMenu16(parg16->f5, lpResData, parg16->f3, cb, parg16->f4);
|
|
|
|
ul = GETHMENU16((pfnOut.pfnServerLoadCreateMenu)(HMODINST32(parg16->f1),
|
|
(LPTSTR) lpUniName_Menu,
|
|
lpResData,
|
|
cb,
|
|
FALSE));
|
|
|
|
|
|
|
|
free_w (lpResData);
|
|
}
|
|
|
|
if (HIWORD(psz2) != (WORD) NULL) {
|
|
LocalFree (lpUniName_Menu);
|
|
}
|
|
|
|
FREEPSZIDPTR(psz2);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
HMENU LoadMenuIndirect(<lpMenuTemplate>)
|
|
LPSTR <lpMenuTemplate>;
|
|
|
|
The %LoadMenuIndirect% function loads into memory the menu named by the
|
|
<lpMenuTemplate> parameter. The template specified by <lpMenuTemplate> is a
|
|
header followed by a collection of one or more %MENUITEMTEMPLATE%
|
|
structures, each of which may contain one or more menu items and pop-up
|
|
menus.
|
|
|
|
<lpMenuTemplate>
|
|
Points to a menu template (which is a collection of one or more
|
|
%MENUITEMTEMPLATE% structures).
|
|
|
|
The return value identifies the menu if the function is successful.
|
|
Otherwise, it is NULL.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32LoadMenuIndirect(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul = 0;
|
|
DWORD cb = 0;
|
|
PVOID pMenu32;
|
|
PLOADMENUINDIRECT16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(LOADMENUINDIRECT16), parg16);
|
|
/*
|
|
* we need to convert this randomly created 16-bit resource into a
|
|
* 32-bit resource so that NT user will be able to use it.
|
|
*/
|
|
if ((cb = (DWORD)ConvertMenu16((WORD)0x300, NULL, (VPBYTE)parg16->f1, cb, 0)) != 0) {
|
|
pMenu32 = malloc_w(cb);
|
|
if (pMenu32 != NULL) {
|
|
ConvertMenu16((WORD)0x300, pMenu32, (VPBYTE)parg16->f1, cb, 0);
|
|
ul = GETHMENU16(LoadMenuIndirect(pMenu32));
|
|
free_w(pMenu32);
|
|
}
|
|
}
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL ModifyMenu(<hMenu>, <nPosition>, <wFlags>, <wIDNewItem>, <lpNewItem>)
|
|
HMENU <hMenu>;
|
|
WORD <nPosition>;
|
|
WORD <wFlags>;
|
|
WORD <wIDNewItem>;
|
|
LPSTR <lpNewItem>;
|
|
|
|
The %ModifyMenu% function changes an existing menu item at the position
|
|
specified by the <nPosition> parameter. The application specifies the new
|
|
state of the menu item by setting values in the <wFlags> parameter. If this
|
|
function replaces a pop-up menu associated with the menu item, it destroys
|
|
the old pop-up menu and frees the memory used by the pop-up menu.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<nPosition>
|
|
Specifies the menu item to be changed. The interpretation of the
|
|
<nPosition> parameter depends upon the setting of the <wFlags>
|
|
parameter.
|
|
|
|
MF_BYPOSITION
|
|
Specifies the position of the existing menu item. The first item in the
|
|
menu is at position zero.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies the command ID of the existing menu item.
|
|
|
|
<wFlags>
|
|
Specifies how the <nPosition> parameter is interpreted and
|
|
information about the changes to be made to the menu item. It consists
|
|
of one or more values listed in the following Comments section.
|
|
|
|
<wIDNewItem>
|
|
Specifies either the command ID of the modified menu item or, if
|
|
<wFlags> is set to MF_POPUP, the menu handle of the pop-up menu.
|
|
|
|
<lpNewItem>
|
|
Specifies the content of the changed menu item. If <wFlags> is
|
|
set to MF_STRING (the default), then <lpNewItem> is a long pointer to a
|
|
null-terminated string. If <wFlags> is set to MF_BITMAP instead, then
|
|
<lpNewItem> contains a bitmap handle (%HBITMAP%) in its low-order word.
|
|
If <wFlags> is set to MF_OWNERDRAW, <lpNewItem> specifies an
|
|
application-supplied 32-bit value which the application can use to
|
|
maintain additional data associated with the menu item. This 32-bit
|
|
value is available to the application in the %itemData% field of the
|
|
structure, pointed to by the <lParam> parameter of the following
|
|
messages:
|
|
|
|
WM_MEASUREITEM
|
|
WM_DRAWITEM
|
|
|
|
These messages are sent when the menu item is initially displayed, or is
|
|
changed.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%. In order to change
|
|
the attributes of existing menu items, it is much faster to use the
|
|
%CheckMenuItem% and %EnableMenuItem% functions.
|
|
|
|
Each of the following groups lists flags that should not be used together:
|
|
|
|
o MF_BYCOMMAND and MF_BYPOSITION
|
|
|
|
o MF_DISABLED, MF_ENABLED, and MF_GRAYED
|
|
|
|
o MF_BITMAP, MF_STRING, MF_OWNERDRAW, and MF_SEPARATOR
|
|
|
|
o MF_MENUBARBREAK and MF_MENUBREAK
|
|
|
|
o MF_CHECKED and MF_UNCHECKED
|
|
|
|
The following list describes the flags which may be set in the <wFlags>
|
|
parameter:
|
|
|
|
MF_BITMAP
|
|
Uses a bitmap as the menu item. The low-order word of the lpNewItem
|
|
parameter contains the handle of the bitmap.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies that the <nPosition> parameter gives the menu item control ID
|
|
number. This is the default if neither MF_BYCOMMAND nor MF_POSITION is
|
|
set.
|
|
|
|
MF_BYPOSITION
|
|
Specifies that the <nPosition> parameter gives the position of the menu
|
|
item to be changed rather than an ID number.
|
|
|
|
MF_CHECKED
|
|
Places a checkmark next to the menu item. If the application has
|
|
supplied checkmark bitmaps (see %SetMenuItemBitmaps%), setting this flag
|
|
displays the checkmark on bitmap next to the menu item.
|
|
|
|
MF_DISABLED
|
|
Disables the menu item so that it cannot be selected, but does not gray
|
|
it.
|
|
|
|
MF_ENABLED
|
|
Enables the menu item so that it can be selected and restores it from
|
|
its grayed state.
|
|
|
|
MF_GRAYED
|
|
Disables the menu item so that it cannot be selected and grays it.
|
|
|
|
MF_MENUBARBREAK
|
|
Same as MF_MENUBREAK except that for pop-up menus, separates the new
|
|
column from the old column with a vertical line.
|
|
|
|
MF_MENUBREAK
|
|
Places the menu item on a new line for static menu-bar items. For pop-up
|
|
menus, this flag places the item in a new column, with no dividing line
|
|
between the columns.
|
|
|
|
MF_OWNERDRAW
|
|
Specifies that the menu item is an owner-draw item. The window that owns
|
|
the menu receives a WM_MEASUREITEM message when the menu is displayed
|
|
for the first time to retrieve the height and width of the menu item.
|
|
The WM_DRAWITEM message is then sent whenever the owner must update the
|
|
visual appearance of the menu item. This option is not valid for a
|
|
top-level menu item.
|
|
|
|
MF_POPUP
|
|
Specifies that the item has a pop-up menu associated with it. The
|
|
<wIDNewItem> parameter specifies a handle to a pop-up menu to be
|
|
associated with the menu item. Use this flag for adding either a
|
|
top-level pop-up menu or adding a hierarchical pop-up menu to a pop-up
|
|
menu item.
|
|
|
|
MF_SEPARATOR
|
|
Draws a horizontal dividing line. You can only use this flag in a pop-up
|
|
menu. This line cannot be grayed, disabled, or highlighted. The
|
|
<lpNewItem> and <wIDNewItem> parameters are ignored.
|
|
|
|
MF_STRING
|
|
Specifies that the menu item is a character string; the <lpNewItem>
|
|
parameter points to the string for the menu item.
|
|
|
|
MF_UNCHECKED
|
|
Does not place a checkmark next to the menu item. No checkmark is the
|
|
default if neither MF_CHECKED nor MF_UNCHECKED is set. If the
|
|
application has supplied checkmark bitmaps (see %SetMenuItemBitmaps%),
|
|
setting this flag displays the checkmark off bitmap next to the menu
|
|
item.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32ModifyMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
PSZ psz5;
|
|
register PMODIFYMENU16 parg16;
|
|
UINT wIDNewItem;
|
|
|
|
|
|
|
|
GETARGPTR(pFrame, sizeof(MODIFYMENU16), parg16);
|
|
|
|
if (parg16->f3 & MF_BITMAP) {
|
|
if (LOW16(parg16->f5) >= 4)
|
|
psz5 = (PSZ)HBITMAP32(LOW(parg16->f5));
|
|
else
|
|
psz5 = (PSZ)WORD32(parg16->f5);
|
|
}
|
|
else if (parg16->f3 & MF_OWNERDRAW)
|
|
psz5 = (PSZ)DWORD32(parg16->f5);
|
|
else
|
|
GETPSZPTR(parg16->f5, psz5);
|
|
|
|
wIDNewItem = (UINT) WORD32(parg16->f4);
|
|
|
|
if (parg16->f3 & MF_POPUP)
|
|
wIDNewItem = (UINT) HMENU32(parg16->f4);
|
|
|
|
|
|
|
|
ul = GETBOOL16(ModifyMenu(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
wIDNewItem,
|
|
psz5
|
|
));
|
|
|
|
if ( ul == FALSE && (parg16->f3 & MF_POPUP) ) {
|
|
//
|
|
// PowerPoint v4.0c passes an wIDNewItem which is not a menu handle
|
|
// when they do pass MF_POPUP. This hack allows it to avoid the
|
|
// error path in WINSRV. On Win 3.1, they never validated it so it
|
|
// got through. Luckily they quickly modify the menu to not have
|
|
// a popup menu soon after that.
|
|
//
|
|
if ( !IsMenu((HMENU) wIDNewItem) ) {
|
|
//
|
|
// Try again with a better sub-menu handle.
|
|
//
|
|
wIDNewItem = (UINT)GetSubMenu( HMENU32(parg16->f1),
|
|
WORD32(parg16->f2) );
|
|
|
|
ul = GETBOOL16(ModifyMenu( HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
wIDNewItem,
|
|
psz5 ));
|
|
}
|
|
}
|
|
|
|
FREEPSZPTR(psz5);
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL RemoveMenu(<hMenu>, <nPosition>, <wFlags>)
|
|
HMENU <hMenu>;
|
|
WORD <nPosition>;
|
|
WORD <wFlags>;
|
|
|
|
The %RemoveMenu% function deletes an menu item with an associated pop-up
|
|
menu from the menu identified by the <hMenu> parameter but does not destroy
|
|
the handle for the pop-up menu, allowing the menu to be reused. Before
|
|
calling this function, the application should call %GetSubMenu% to retrieve
|
|
the pop-up menu handle.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<nPosition>
|
|
Specifies the menu item to be removed. The interpretation of the
|
|
<nPosition> parameter depends upon the setting of the <wFlags>
|
|
parameter.
|
|
|
|
MF_BYCOMMAND
|
|
Specifies the command ID of the existing menu item.
|
|
|
|
MF_BYPOSITION
|
|
Specifies the position of the menu item. The first item in the menu is
|
|
at position zero.
|
|
|
|
<wFlags>
|
|
Specifies how the <nPosition> parameter is interpreted. It must
|
|
be either MF_BYCOMMAND or MF_BYPOSITION.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
Whenever a menu changes (whether or not the menu resides in a window that is
|
|
displayed), the application should call %DrawMenuBar%.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32RemoveMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PREMOVEMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(REMOVEMENU16), parg16);
|
|
|
|
ul = GETBOOL16(RemoveMenu(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL SetMenu(<hwnd>, <hMenu>)
|
|
HWND <hwnd>;
|
|
HMENU <hMenu>;
|
|
|
|
The %SetMenu% function sets the given window's menu to the menu specified by
|
|
the <hMenu> parameter. If <hMenu> is NULL, the window's current menu is
|
|
removed. The %SetMenu% function causes the window to be redrawn to reflect
|
|
the menu change.
|
|
|
|
<hwnd>
|
|
Identifies the window whose menu is to be changed.
|
|
|
|
<hMenu>
|
|
Identifies the new menu.
|
|
|
|
The return value specifies whether the menu is changed. It is TRUE if the
|
|
menu is changed. Otherwise, it is FALSE.
|
|
|
|
%SetMenu% will not destroy a previous menu. An application should call the
|
|
%DestroyMenu% function to accomplish this task.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32SetMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PSETMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SETMENU16), parg16);
|
|
|
|
ul = GETBOOL16(SetMenu(
|
|
HWND32(parg16->f1),
|
|
HMENU32(parg16->f2)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL SetMenuItemBitmaps(<hMenu>, <nPosition>, <wFlags>,
|
|
<hBitmapUnchecked>, <hBitmapChecked>)
|
|
HMENU <hMenu>;
|
|
WORD <nPosition>;
|
|
WORD <wFlags>;
|
|
HBITMAP <hBitmapUnchecked>;
|
|
HBITMAP <hBitmapChecked>;
|
|
|
|
The %SetMenuItemBitmaps% function associates the specified bitmaps with a
|
|
menu item. Whether the menu item is checked or unchecked, Windows displays
|
|
the appropriate bitmap next to the menu item.
|
|
|
|
<hMenu>
|
|
Identifies the menu to be changed.
|
|
|
|
<nPosition>
|
|
Specifies the menu item to be changed. If <wFlags> is set to
|
|
MF_BYPOSITION, <nPosition> specifies the position of the menu item; the
|
|
first item in the menu is at position 0. If <wFlags> is set to
|
|
MF_BYCOMMAND, then <nPosition> specifies the command ID of the menu
|
|
item.
|
|
|
|
<wFlags>
|
|
Specifies how the <nPosition> parameter is interpreted. It may be
|
|
set to MF_BYCOMMAND (the default) or MF_BYPOSITION.
|
|
|
|
<hBitmapUnchecked>
|
|
Identifies the bitmap to be displayed when the menu item is
|
|
not checked.
|
|
|
|
<hBitmapChecked>
|
|
Identifies the bitmap to be displayed when the menu item is
|
|
checked.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
|
|
If either the <hBitmapUnchecked> or the <hBitmapChecked> parameters is NULL,
|
|
then Windows displays nothing next to the menu item for the corresponding
|
|
attribute. If both parameters are NULL, Windows uses the default checkmark
|
|
when the item is checked and removes the checkmark when the item is
|
|
unchecked.
|
|
|
|
When the menu is destroyed, these bitmaps are not destroyed; it is the
|
|
responsibility of the application to destroy them.
|
|
|
|
The %GetMenuCheckMarkDimensions% function retrieves the dimensions of the
|
|
default checkmark used for menu items. The application should use these
|
|
values to determine the appropriate size for the bitmaps supplied with this
|
|
function.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32SetMenuItemBitmaps(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
register PSETMENUITEMBITMAPS16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(SETMENUITEMBITMAPS16), parg16);
|
|
|
|
ul = GETBOOL16(SetMenuItemBitmaps(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
WORD32(parg16->f3),
|
|
HBITMAP32(parg16->f4),
|
|
HBITMAP32(parg16->f5)
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|
|
|
|
|
|
/*++
|
|
BOOL TrackPopupMenu(<hMenu>, <wFlags>, <x>, <y>, <nReserved>, <hwnd>,
|
|
<lpReserved>)
|
|
|
|
The %TrackPopupMenu% function displays a floating pop-up menu at the
|
|
specified location and tracks the selection of items on the pop-up menu. A
|
|
floating pop-up menu can appear anywhere on the screen. The <hMenu>
|
|
parameter specifies the handle of the menu to be displayed; the application
|
|
obtains this handle by calling %CreatePopupMenu% to create a new pop-up menu
|
|
or by calling %GetSubMenu% to retrieve the handle of a pop-up menu
|
|
associated with an existing menu item.
|
|
|
|
Windows sends messages generated by the menu to the window identified by the
|
|
<hwnd> parameter.
|
|
|
|
<hMenu>
|
|
Identifies the pop-up menu to be displayed.
|
|
|
|
<wFlags>
|
|
Not used. This parameter must be set to zero.
|
|
|
|
<x>
|
|
Specifies the horizontal position in screen coordinates of the
|
|
left side of the menu on the screen.
|
|
|
|
<y>
|
|
Specifies the vertical position in screen coordinates of the top
|
|
of the menu on the screen.
|
|
|
|
<nReserved>
|
|
Is reserved and must be set to zero.
|
|
|
|
<hwnd>
|
|
Identifies the window which owns the pop-up menu. This window
|
|
receives all WM_COMMAND messages from the menu.
|
|
|
|
<lpReserved>
|
|
Is reserved and must be set to NULL.
|
|
|
|
The return value specifies the outcome of the function. It is TRUE if the
|
|
function is successful. Otherwise, it is FALSE.
|
|
--*/
|
|
|
|
ULONG FASTCALL WU32TrackPopupMenu(PVDMFRAME pFrame)
|
|
{
|
|
ULONG ul;
|
|
RECT t7, *p7;
|
|
register PTRACKPOPUPMENU16 parg16;
|
|
|
|
GETARGPTR(pFrame, sizeof(TRACKPOPUPMENU16), parg16);
|
|
p7 = GETRECT16(parg16->f7, &t7);
|
|
|
|
ul = GETBOOL16(TrackPopupMenu(
|
|
HMENU32(parg16->f1),
|
|
WORD32(parg16->f2),
|
|
INT32(parg16->f3),
|
|
INT32(parg16->f4),
|
|
INT32(parg16->f5),
|
|
HWND32(parg16->f6),
|
|
p7
|
|
));
|
|
|
|
FREEARGPTR(parg16);
|
|
RETURN(ul);
|
|
}
|