UINT
CNewMenu::InsertShellNewItems(HMENU hMenu, UINT idCmdFirst, UINT Pos)
{
MENUITEMINFOW mii;
WCHAR wszBuf[256];
UINT idCmd = idCmdFirst;
if (m_pItems == NULL)
{
if (!LoadAllItems())
return 0;
}
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
/* Insert new folder action */
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWFOLDER, wszBuf, _countof(wszBuf)))
wszBuf[0] = 0;
mii.fMask = MIIM_ID | MIIM_BITMAP | MIIM_STRING;
mii.dwTypeData = wszBuf;
mii.cch = wcslen(mii.dwTypeData);
mii.wID = idCmd;
mii.hbmpItem = HBMMENU_CALLBACK;
if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
++idCmd;
/* Insert new shortcut action */
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWLINK, wszBuf, _countof(wszBuf)))
wszBuf[0] = 0;
mii.dwTypeData = wszBuf;
mii.cch = wcslen(mii.dwTypeData);
mii.wID = idCmd;
if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
++idCmd;
/* Insert seperator for custom new action */
mii.fMask = MIIM_TYPE | MIIM_ID;
mii.fType = MFT_SEPARATOR;
mii.wID = -1;
InsertMenuItemW(hMenu, Pos++, TRUE, &mii);
/* Insert rest of items */
mii.fMask = MIIM_ID | MIIM_BITMAP | MIIM_STRING;
mii.fType = 0;
SHELLNEW_ITEM *pCurItem = m_pItems;
while (pCurItem)
{
TRACE("szDesc %s\n", debugstr_w(pCurItem->pwszDesc));
mii.dwTypeData = pCurItem->pwszDesc;
mii.cch = wcslen(mii.dwTypeData);
mii.wID = idCmd;
if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
++idCmd;
pCurItem = pCurItem->pNext;
}
return idCmd - idCmdFirst;
}
void registry_read_filelist(HWND hMainWnd)
{
HKEY hFileKey;
if(registry_get_handle(&hFileKey, 0, key_recentfiles) == ERROR_SUCCESS)
{
WCHAR itemText[MAX_PATH+3], buffer[MAX_PATH];
/* The menu item name is not the same as the file name, so we need to store
the file name here */
static WCHAR file1[MAX_PATH], file2[MAX_PATH], file3[MAX_PATH], file4[MAX_PATH];
WCHAR numFormat[] = {'&','%','d',' ',0};
LPWSTR pFile[] = {file1, file2, file3, file4};
DWORD pathSize = MAX_PATH*sizeof(WCHAR);
int i;
WCHAR key[6];
MENUITEMINFOW mi;
HMENU hMenu = GetMenu(hMainWnd);
mi.cbSize = sizeof(MENUITEMINFOW);
mi.fMask = MIIM_ID | MIIM_DATA | MIIM_STRING | MIIM_FTYPE;
mi.fType = MFT_STRING;
mi.dwTypeData = itemText;
mi.wID = ID_FILE_RECENT1;
RemoveMenu(hMenu, ID_FILE_RECENT_SEPARATOR, MF_BYCOMMAND);
for(i = 0; i < FILELIST_ENTRIES; i++)
{
wsprintfW(key, var_file, i+1);
RemoveMenu(hMenu, ID_FILE_RECENT1+i, MF_BYCOMMAND);
if(RegQueryValueExW(hFileKey, (LPWSTR)key, 0, NULL, (LPBYTE)pFile[i], &pathSize)
!= ERROR_SUCCESS)
break;
mi.dwItemData = (ULONG_PTR)pFile[i];
wsprintfW(itemText, numFormat, i+1);
lstrcpyW(buffer, pFile[i]);
format_filelist_filename(buffer, itemText);
InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
mi.wID++;
pathSize = MAX_PATH*sizeof(WCHAR);
}
mi.fType = MFT_SEPARATOR;
mi.fMask = MIIM_FTYPE | MIIM_ID;
InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
RegCloseKey(hFileKey);
}
}
static UINT insert_new_menu_items(NewMenuImpl *This, HMENU menu, UINT pos, UINT cmd_first, UINT cmd_last)
{
MENUITEMINFOW item;
WCHAR buffer[256];
memset(&item, 0, sizeof(item));
item.cbSize = sizeof(item);
if (cmd_first > cmd_last)
return cmd_first;
/* FIXME: on windows it is only 'Folder' not 'New Folder' */
if (!LoadStringW(shell32_hInstance, IDS_NEWFOLDER, buffer, sizeof(buffer) / sizeof(WCHAR)))
buffer[0] = 0;
item.fMask = MIIM_ID | MIIM_BITMAP | MIIM_STRING;
item.dwTypeData = buffer;
item.cch = strlenW(buffer);
item.wID = cmd_first;
item.hbmpItem = HBMMENU_CALLBACK;
if (InsertMenuItemW(menu, pos, TRUE, &item))
{
This->folder_cmd = cmd_first++;
pos++;
}
return cmd_first;
}
HRESULT WINAPI CRecycleBin::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
{
WCHAR szBuffer[100];
MENUITEMINFOW mii;
int id = 1;
TRACE("QueryContextMenu %p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
if (!hMenu)
return E_INVALIDARG;
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
mii.fState = RecycleBinIsEmpty() ? MFS_DISABLED : MFS_ENABLED;
szBuffer[0] = L'\0';
LoadStringW(shell32_hInstance, IDS_EMPTY_BITBUCKET, szBuffer, sizeof(szBuffer) / sizeof(WCHAR));
mii.dwTypeData = szBuffer;
mii.cch = wcslen(mii.dwTypeData);
mii.wID = idCmdFirst + id++;
mii.fType = MFT_STRING;
iIdEmpty = 1;
if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
return E_FAIL;
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
}
static void _InsertMenuItemW (
HMENU hmenu,
UINT indexMenu,
BOOL fByPosition,
UINT wID,
UINT fType,
LPWSTR dwTypeData,
UINT fState)
{
MENUITEMINFOW mii;
mii.cbSize = sizeof(mii);
if (fType == MFT_SEPARATOR)
{
mii.fMask = MIIM_ID | MIIM_TYPE;
}
else
{
mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;
mii.dwTypeData = dwTypeData;
mii.fState = fState;
}
mii.wID = wID;
mii.fType = fType;
InsertMenuItemW( hmenu, indexMenu, fByPosition, &mii);
}
void insertSeparatorMenuItem(HMENU menu,
const UINT pos)
{
MENUITEMINFOW mii;
SecureZeroMemory(&mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_FTYPE;
mii.fType = MFT_SEPARATOR;
InsertMenuItemW(menu, pos, TRUE, &mii);
}
static void hugsprim_InsertMenuItemW_18(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsWord32 arg2;
HsBool arg3;
HsPtr arg4;
HsBool res1;
arg1 = hugs->getPtr();
arg2 = hugs->getWord32();
arg3 = hugs->getBool();
arg4 = hugs->getPtr();
res1 = InsertMenuItemW(arg1, arg2, arg3, arg4);
hugs->putBool(res1);
hugs->returnIO(hugs_root,1);
}
int CLocateShellExtension::InsertMenuItems(HMENU hMenu,UINT nStartIndex,UINT idCmdFirst,UINT& nHighestUsedID)
{
ODS("CShellExt::InsertMenuItems()");
if (m_pDataObj==NULL)
return 0;
MENUITEMINFOW mii;
mii.cbSize=sizeof(MENUITEMINFOW);
mii.fMask=MIIM_ID|MIIM_TYPE;
mii.fType=MFT_STRING;
mii.dwTypeData=L"Files:";
mii.wID=idCmdFirst;
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
for (int i=0;i<m_aFiles.GetSize();i++)
{
mii.wID++;
mii.dwTypeData=m_aFiles[i];
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
}
mii.wID++;
mii.dwTypeData=L"Directories:";
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
for (int i=0;i<m_aDirectories.GetSize();i++)
{
mii.wID++;
mii.dwTypeData=m_aDirectories[i];
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
}
mii.wID++;
mii.dwTypeData=L"Computers:";
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
for (int i=0;i<m_aComputers.GetSize();i++)
{
mii.wID++;
mii.dwTypeData=m_aComputers[i];
InsertMenuItemW(hMenu,nStartIndex++,TRUE,&mii);
}
nHighestUsedID=mii.wID;
return mii.wID-idCmdFirst+1;
}
void WINAPI _InsertMenuItemW (
HMENU hmenu,
UINT indexMenu,
BOOL fByPosition,
UINT wID,
UINT fType,
LPCWSTR dwTypeData,
UINT fState)
{
MENUITEMINFOW mii;
WCHAR szText[100];
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
if (fType == MFT_SEPARATOR)
{
mii.fMask = MIIM_ID | MIIM_TYPE;
}
else if (fType == MFT_STRING)
{
mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;
if ((ULONG_PTR)HIWORD((ULONG_PTR)dwTypeData) == 0)
{
if (LoadStringW(netshell_hInstance, LOWORD((ULONG_PTR)dwTypeData), szText, sizeof(szText)/sizeof(WCHAR)))
{
szText[(sizeof(szText)/sizeof(WCHAR))-1] = 0;
mii.dwTypeData = szText;
}
else
{
return;
}
}
else
{
mii.dwTypeData = (LPWSTR) dwTypeData;
}
mii.fState = fState;
}
mii.wID = wID;
mii.fType = fType;
InsertMenuItemW( hmenu, indexMenu, fByPosition, &mii);
}
void insertMenuItem(HMENU menu,
const UINT pos, const UINT id, const wchar_t *text,
const bool enabled)
{
MENUITEMINFOW mii;
SecureZeroMemory(&mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_ID | MIIM_STRING;
mii.wID = id;
mii.dwTypeData = (LPWSTR)text;
if( !enabled ) {
mii.fMask |= MIIM_STATE;
mii.fState |= MFS_DISABLED;
}
InsertMenuItemW(menu, pos, TRUE, &mii);
}
void insertSubMenuItem(HMENU menu, HMENU submenu,
const UINT pos, const UINT id, const wchar_t *text,
const HBITMAP bitmap)
{
MENUITEMINFOW mii;
SecureZeroMemory(&mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_ID | MIIM_STRING | MIIM_SUBMENU;
mii.wID = id;
mii.dwTypeData = (LPWSTR)text;
mii.hSubMenu = submenu;
InsertMenuItemW(menu, pos, TRUE, &mii);
if( bitmap != NULL ) {
SetMenuItemBitmaps(menu, pos, MF_BYPOSITION, bitmap, NULL);
}
}
HRESULT
WINAPI
CNewMenu::QueryContextMenu(HMENU hMenu,
UINT indexMenu,
UINT idCmdFirst,
UINT idCmdLast,
UINT uFlags)
{
WCHAR wszNew[200];
MENUITEMINFOW mii;
UINT cItems = 0;
m_idCmdFirst = idCmdFirst;
TRACE("%p %p %u %u %u %u\n", this,
hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, wszNew, _countof(wszNew)))
return E_FAIL;
m_hSubMenu = CreateMenu();
if (!m_hSubMenu)
return E_FAIL;
cItems = InsertShellNewItems(m_hSubMenu, idCmdFirst, 0);
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE | MIIM_SUBMENU;
mii.fType = MFT_STRING;
mii.wID = -1;
mii.dwTypeData = wszNew;
mii.cch = wcslen(mii.dwTypeData);
mii.fState = MFS_ENABLED;
mii.hSubMenu = m_hSubMenu;
if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
return E_FAIL;
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cItems);
}
BOOL InsertMenuItemUTF8( HMENU hMenu,UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii)
{
if (lpmii && (lpmii->fMask & MIIM_TYPE) && (lpmii->fType&(MFT_SEPARATOR|MFT_STRING|MFT_BITMAP)) == MFT_STRING && lpmii->dwTypeData && WDL_HasUTF8(lpmii->dwTypeData) && GetVersion()<0x80000000)
{
BOOL rv;
MENUITEMINFOW tmp = *(MENUITEMINFOW*)lpmii;
MBTOWIDE(wbuf,lpmii->dwTypeData);
if (wbuf_ok)
{
tmp.cbSize=sizeof(tmp);
tmp.dwTypeData = wbuf;
rv=InsertMenuItemW(hMenu,uItem,fByPosition,&tmp);
MBTOWIDE_FREE(wbuf);
return rv;
}
MBTOWIDE_FREE(wbuf);
}
return InsertMenuItemA(hMenu,uItem,fByPosition,lpmii);
}
void ContextMenu::CreateContextMenuItem(const MenuItem& menuDefinition, const HMENU hParentMenu, const HMENU hSubMenu, UINT* uMenuIndex, UINT* uID)
{
MENUITEMINFOW mii = { sizeof(MENUITEMINFOW) };
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = (*uID)++;
std::vector<WCHAR> buf(menuDefinition.name.begin(), menuDefinition.name.end());
buf.push_back(0);
mii.dwTypeData = buf.data();
if (hSubMenu != NULL)
{
mii.fMask |= MIIM_SUBMENU;
mii.hSubMenu = hSubMenu;
}
else if (!menuDefinition.command.empty())
{
MenuCommand command(mii.wID, menuDefinition.command);
m_menuCommands.push_back(command);
}
InsertMenuItemW(hParentMenu, (*uMenuIndex)++, TRUE, &mii);
}
void VDAppendMenuSeparatorW32(HMENU hmenu) {
int pos = GetMenuItemCount(hmenu);
if (pos < 0)
return;
if (VDIsWindowsNT()) {
MENUITEMINFOW mmiW;
vdfastfixedvector<wchar_t, 256> bufW;
mmiW.cbSize = MENUITEMINFO_SIZE_VERSION_400W;
mmiW.fMask = MIIM_TYPE;
mmiW.fType = MFT_SEPARATOR;
InsertMenuItemW(hmenu, pos, TRUE, &mmiW);
} else {
MENUITEMINFOA mmiA;
mmiA.cbSize = MENUITEMINFO_SIZE_VERSION_400A;
mmiA.fMask = MIIM_TYPE;
mmiA.fType = MFT_SEPARATOR;
InsertMenuItemA(hmenu, pos, TRUE, &mmiA);
}
}
static HRESULT WINAPI
NewMenu_ContextMenu3_QueryContextMenu(IContextMenu3 *iface, HMENU menu, UINT index,
UINT cmd_first, UINT cmd_last, UINT flags)
{
static WCHAR newW[] = {'N','e','w',0};
NewMenuImpl *This = impl_from_IContextMenu3(iface);
MENUITEMINFOW item;
HMENU submenu;
UINT id;
TRACE("(%p)->(%p, %u, %u, %u, %u)\n", This,
menu, index, cmd_first, cmd_last, flags );
if (!This->pidl)
return E_FAIL;
submenu = CreateMenu();
if (!submenu) return E_FAIL;
id = insert_new_menu_items(This, submenu, 0, cmd_first, cmd_last);
memset(&item, 0, sizeof(item));
item.cbSize = sizeof(item);
item.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE | MIIM_SUBMENU;
item.fType = MFT_STRING;
item.wID = -1;
item.dwTypeData = newW; /* FIXME: load from resource file */
item.cch = strlenW(newW);
item.fState = MFS_ENABLED;
item.hSubMenu = submenu;
if (!InsertMenuItemW(menu, index, TRUE, &item))
return E_FAIL;
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
}
void do_startmenu(HWND hwnd)
{
LPITEMIDLIST pidl;
MENUINFO mi;
MENUITEMINFOW mii;
RECT rc={0,0,0,0};
TPMPARAMS tpm;
WCHAR run_label[50];
destroy_menus();
WINE_TRACE("creating start menu\n");
root_menu.menuhandle = public_startmenu.menuhandle = user_startmenu.menuhandle = CreatePopupMenu();
if (!root_menu.menuhandle)
{
return;
}
user_startmenu.parent = public_startmenu.parent = &root_menu;
user_startmenu.base = &public_startmenu;
user_startmenu.menu_filled = public_startmenu.menu_filled = FALSE;
if (!user_startmenu.pidl)
SHGetSpecialFolderLocation(NULL, CSIDL_STARTMENU, &user_startmenu.pidl);
if (!user_startmenu.folder)
pidl_to_shellfolder(user_startmenu.pidl, NULL, &user_startmenu.folder);
if (!public_startmenu.pidl)
SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_STARTMENU, &public_startmenu.pidl);
if (!public_startmenu.folder)
pidl_to_shellfolder(public_startmenu.pidl, NULL, &public_startmenu.folder);
fill_menu(&user_startmenu);
AppendMenuW(root_menu.menuhandle, MF_SEPARATOR, 0, NULL);
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_CONTROLS, &pidl)))
add_shell_item(&root_menu, pidl);
LoadStringW(NULL, IDS_RUN, run_label, sizeof(run_label)/sizeof(run_label[0]));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING|MIIM_ID;
mii.dwTypeData = run_label;
mii.wID = MENU_ID_RUN;
InsertMenuItemW(root_menu.menuhandle, -1, TRUE, &mii);
mi.cbSize = sizeof(mi);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_NOTIFYBYPOS;
SetMenuInfo(root_menu.menuhandle, &mi);
GetWindowRect(hwnd, &rc);
tpm.cbSize = sizeof(tpm);
tpm.rcExclude = rc;
if (!TrackPopupMenuEx(root_menu.menuhandle,
TPM_LEFTALIGN|TPM_BOTTOMALIGN|TPM_VERTICAL,
rc.left, rc.top, hwnd, &tpm))
{
WINE_ERR("couldn't display menu\n");
}
}
/* add an individual file or folder to the menu, takes ownership of pidl */
static struct menu_item* add_shell_item(struct menu_item* parent, LPITEMIDLIST pidl)
{
struct menu_item* item;
MENUITEMINFOW mii;
HMENU parent_menu;
int existing_item_count, i;
BOOL match = FALSE;
SFGAOF flags;
item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct menu_item));
if (parent->pidl == NULL)
{
pidl_to_shellfolder(pidl, &item->displayname, &item->folder);
}
else
{
STRRET strret;
IShellFolder_GetDisplayNameOf(parent->folder, pidl, SHGDN_INFOLDER, &strret);
StrRetToStrW(&strret, NULL, &item->displayname);
flags = SFGAO_FOLDER;
IShellFolder_GetAttributesOf(parent->folder, 1, (LPCITEMIDLIST*)&pidl, &flags);
if (flags & SFGAO_FOLDER)
IShellFolder_BindToObject(parent->folder, pidl, NULL, &IID_IShellFolder, (void *)&item->folder);
}
parent_menu = parent->menuhandle;
item->parent = parent;
item->pidl = pidl;
existing_item_count = GetMenuItemCount(parent_menu);
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_SUBMENU|MIIM_DATA;
/* search for an existing menu item with this name or the spot to insert this item */
if (parent->pidl != NULL)
{
for (i=0; i<existing_item_count; i++)
{
struct menu_item* existing_item;
int cmp;
GetMenuItemInfoW(parent_menu, i, TRUE, &mii);
existing_item = ((struct menu_item*)mii.dwItemData);
if (!existing_item)
continue;
/* folders before files */
if (existing_item->folder && !item->folder)
continue;
if (!existing_item->folder && item->folder)
break;
cmp = CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, item->displayname, -1, existing_item->displayname, -1);
if (cmp == CSTR_LESS_THAN)
break;
if (cmp == CSTR_EQUAL)
{
match = TRUE;
break;
}
}
}
else
/* This item manually added to the root menu, so put it at the end */
i = existing_item_count;
if (!match)
{
/* no existing item with the same name; just add it */
mii.fMask = MIIM_STRING|MIIM_DATA;
mii.dwTypeData = item->displayname;
mii.dwItemData = (ULONG_PTR)item;
if (item->folder)
{
MENUINFO mi;
item->menuhandle = CreatePopupMenu();
mii.fMask |= MIIM_SUBMENU;
mii.hSubMenu = item->menuhandle;
mi.cbSize = sizeof(mi);
mi.fMask = MIM_MENUDATA;
mi.dwMenuData = (ULONG_PTR)item;
SetMenuInfo(item->menuhandle, &mi);
}
InsertMenuItemW(parent->menuhandle, i, TRUE, &mii);
list_add_tail(&items, &item->entry);
}
else if (item->folder)
{
/* there is an existing folder with the same name, combine them */
MENUINFO mi;
item->base = (struct menu_item*)mii.dwItemData;
item->menuhandle = item->base->menuhandle;
mii.dwItemData = (ULONG_PTR)item;
SetMenuItemInfoW(parent_menu, i, TRUE, &mii);
mi.cbSize = sizeof(mi);
mi.fMask = MIM_MENUDATA;
mi.dwMenuData = (ULONG_PTR)item;
SetMenuInfo(item->menuhandle, &mi);
list_add_tail(&items, &item->entry);
}
else {
/* duplicate shortcut, do nothing */
HeapFree(GetProcessHeap(), 0, item->displayname);
HeapFree(GetProcessHeap(), 0, item);
CoTaskMemFree(pidl);
item = NULL;
}
return item;
}
static void test_OleUIAddVerbMenu(void)
{
static const WCHAR cadabraW[] = {'c','a','d','a','b','r','a',0};
HMENU hMenu, verbmenu;
MENUITEMINFOW info;
WCHAR buffW[50];
int count;
BOOL ret;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
hMenu = CreatePopupMenu();
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 1, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
/* object doesn't support EnumVerbs() */
g_enumverbsfail = TRUE;
g_enumpos = 0;
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 2, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumverbsfail = FALSE;
/* added disabled item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_SUBMENU;
ret = GetMenuItemInfoW(hMenu, 2, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState & MFS_DISABLED, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 3, "got %d\n", count);
/* now without object */
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, testW, hMenu, 3, 42, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_ID|MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 3, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
ok(info.wID == 42, "got id %d\n", info.wID);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 4, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 4, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
/* check newly added item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 4, TRUE, &info);
ok(ret, "got %d\n", ret);
/* Item string contains verb, usertype and localized string for 'Object' word,
exact format depends on localization. */
ok(strstrW(buffW, verbW) != NULL, "str %s\n", wine_dbgstr_w(buffW));
ok(info.fState == 0, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 5, "got %d\n", count);
DestroyMenu(hMenu);
/* try to add verb menu repeatedly, with same id */
hMenu = CreatePopupMenu();
count = GetMenuItemCount(hMenu);
ok(count == 0, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* same position, different id */
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 6, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* change added item string and state */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
info.fState = MFS_ENABLED;
info.dwTypeData = buffW;
lstrcpyW(buffW, cadabraW);
ret = SetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
buffW[0] = 0;
GetMenuStringW(hMenu, 0, buffW, sizeof(buffW)/sizeof(buffW[0]), MF_BYPOSITION);
ok(!lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
buffW[0] = 0;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
DestroyMenu(hMenu);
}
static void test_OleUIAddVerbMenu(void)
{
HMENU hMenu, verbmenu;
MENUITEMINFOW info;
WCHAR buffW[50];
int count;
BOOL ret;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
hMenu = CreatePopupMenu();
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 1, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
/* object doesn't support EnumVerbs() */
g_enumverbsfail = TRUE;
g_enumpos = 0;
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 2, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumverbsfail = FALSE;
/* added disabled item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_SUBMENU;
ret = GetMenuItemInfoW(hMenu, 2, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState & MFS_DISABLED, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 3, "got %d\n", count);
/* now without object */
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, testW, hMenu, 3, 42, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_ID|MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 3, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
ok(info.wID == 42, "got id %d\n", info.wID);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 4, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 4, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
/* check newly added item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 4, TRUE, &info);
ok(ret, "got %d\n", ret);
/* Item string contains verb, usertype and localized string for 'Object' word,
exact format depends on localization. */
ok(strstrW(buffW, verbW) != NULL, "str %s\n", wine_dbgstr_w(buffW));
ok(info.fState == 0, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 5, "got %d\n", count);
DestroyMenu(hMenu);
}
/*************************************************************************
* FileMenu_AppendItem [SHELL32.115]
*
*/
static BOOL FileMenu_AppendItemW(
HMENU hMenu,
LPCWSTR lpText,
UINT uID,
int icon,
HMENU hMenuPopup,
int nItemHeight)
{
MENUITEMINFOW mii;
LPFMITEM myItem;
LPFMINFO menudata;
MENUINFO MenuInfo;
TRACE("%p %s 0x%08x 0x%08x %p 0x%08x\n",
hMenu, (lpText!=FM_SEPARATOR) ? debugstr_w(lpText) : NULL,
uID, icon, hMenuPopup, nItemHeight);
ZeroMemory (&mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
if (lpText != FM_SEPARATOR)
{
int len = strlenW (lpText);
myItem = SHAlloc(sizeof(FMITEM) + len*sizeof(WCHAR));
strcpyW (myItem->szItemText, lpText);
myItem->cchItemText = len;
myItem->iIconIndex = icon;
myItem->hMenu = hMenu;
mii.fMask = MIIM_DATA;
mii.dwItemData = (ULONG_PTR) myItem;
}
if ( hMenuPopup )
{ /* sub menu */
mii.fMask |= MIIM_TYPE | MIIM_SUBMENU;
mii.fType = MFT_OWNERDRAW;
mii.hSubMenu = hMenuPopup;
}
else if (lpText == FM_SEPARATOR )
{ mii.fMask |= MIIM_ID | MIIM_TYPE;
mii.fType = MFT_SEPARATOR;
}
else
{ /* normal item */
mii.fMask |= MIIM_ID | MIIM_TYPE | MIIM_STATE;
mii.fState = MFS_ENABLED | MFS_DEFAULT;
mii.fType = MFT_OWNERDRAW;
}
mii.wID = uID;
InsertMenuItemW (hMenu, (UINT)-1, TRUE, &mii);
/* set bFixedItems to true */
MenuInfo.cbSize = sizeof(MENUINFO);
MenuInfo.fMask = MIM_MENUDATA;
if (! GetMenuInfo(hMenu, &MenuInfo))
return FALSE;
menudata = (LPFMINFO)MenuInfo.dwMenuData;
if ((menudata == 0) || (MenuInfo.cbSize != sizeof(MENUINFO)))
{
ERR("menudata corrupt: %p %u\n", menudata, MenuInfo.cbSize);
return 0;
}
menudata->bFixedItems = TRUE;
SetMenuInfo(hMenu, &MenuInfo);
return TRUE;
}
/*************************************************************************
* Shell_MergeMenus [SHELL32.67]
*/
HRESULT WINAPI Shell_MergeMenus (HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
{ int nItem;
HMENU hmSubMenu;
BOOL bAlreadySeparated;
MENUITEMINFOW miiSrc;
WCHAR szName[256];
UINT uTemp, uIDMax = uIDAdjust;
TRACE("hmenu1=%p hmenu2=%p 0x%04x 0x%04x 0x%04x 0x%04x\n",
hmDst, hmSrc, uInsert, uIDAdjust, uIDAdjustMax, uFlags);
if (!hmDst || !hmSrc)
{ return uIDMax;
}
nItem = GetMenuItemCount(hmDst);
if (uInsert >= (UINT)nItem) /* insert position inside menu? */
{
uInsert = (UINT)nItem; /* append on the end */
bAlreadySeparated = TRUE;
}
else
{
bAlreadySeparated = _SHIsMenuSeparator(hmDst, uInsert);
}
if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
{
/* Add a separator between the menus */
InsertMenuA(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
bAlreadySeparated = TRUE;
}
/* Go through the menu items and clone them*/
for (nItem = GetMenuItemCount(hmSrc) - 1; nItem >= 0; nItem--)
{
miiSrc.cbSize = sizeof(MENUITEMINFOW);
miiSrc.fMask = MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_CHECKMARKS | MIIM_TYPE | MIIM_DATA;
/* We need to reset this every time through the loop in case menus DON'T have IDs*/
miiSrc.fType = MFT_STRING;
miiSrc.dwTypeData = szName;
miiSrc.dwItemData = 0;
miiSrc.cch = sizeof(szName)/sizeof(WCHAR);
if (!GetMenuItemInfoW(hmSrc, nItem, TRUE, &miiSrc))
{
continue;
}
/* TRACE("found menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmSrc, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
*/
if (miiSrc.fType & MFT_SEPARATOR)
{
/* This is a separator; don't put two of them in a row */
if (bAlreadySeparated)
continue;
bAlreadySeparated = TRUE;
}
else if (miiSrc.hSubMenu)
{
if (uFlags & MM_SUBMENUSHAVEIDS)
{
miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
if (miiSrc.wID > uIDAdjustMax) /* skip ID's higher uIDAdjustMax */
continue;
if (uIDMax <= miiSrc.wID) /* remember the highest ID */
uIDMax = miiSrc.wID + 1;
}
else
{
miiSrc.fMask &= ~MIIM_ID; /* Don't set IDs for submenus that didn't have them already */
}
hmSubMenu = miiSrc.hSubMenu;
miiSrc.hSubMenu = CreatePopupMenu();
if (!miiSrc.hSubMenu) return(uIDMax);
uTemp = Shell_MergeMenus(miiSrc.hSubMenu, hmSubMenu, 0, uIDAdjust, uIDAdjustMax, uFlags & MM_SUBMENUSHAVEIDS);
if (uIDMax <= uTemp)
uIDMax = uTemp;
bAlreadySeparated = FALSE;
}
else /* normal menu item */
{
miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
if (miiSrc.wID > uIDAdjustMax) /* skip ID's higher uIDAdjustMax */
continue;
if (uIDMax <= miiSrc.wID) /* remember the highest ID */
uIDMax = miiSrc.wID + 1;
bAlreadySeparated = FALSE;
}
/* TRACE("inserting menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmDst, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
*/
if (!InsertMenuItemW(hmDst, uInsert, TRUE, &miiSrc))
{
return(uIDMax);
}
}
/* Ensure the correct number of separators at the beginning of the
inserted menu items*/
if (uInsert == 0)
{
if (bAlreadySeparated)
{
DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
}
}
else
{
if (_SHIsMenuSeparator(hmDst, uInsert-1))
{
if (bAlreadySeparated)
{
DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
}
}
else
{
if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
{
/* Add a separator between the menus*/
InsertMenuW(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
}
}
}
return(uIDMax);
}
void
CDeviceView::BuildActionMenuForNode(
_In_ HMENU OwnerMenu,
_In_ CNode *Node,
_In_ bool MainMenu
)
{
// Create a seperator structure
MENUITEMINFOW MenuSeperator = { 0 };
MenuSeperator.cbSize = sizeof(MENUITEMINFOW);
MenuSeperator.fType = MFT_SEPARATOR;
// Setup the
MENUITEMINFOW MenuItemInfo = { 0 };
MenuItemInfo.cbSize = sizeof(MENUITEMINFOW);
MenuItemInfo.fMask = MIIM_ID | MIIM_STRING | MIIM_DATA | MIIM_SUBMENU;
MenuItemInfo.fType = MFT_STRING;
CAtlStringW String;
int i = 0;
// Device nodes have extra data
if (Node->GetNodeType() == DeviceNode)
{
CDeviceNode *DeviceNode = dynamic_cast<CDeviceNode *>(Node);
if (DeviceNode->CanUpdate())
{
String.LoadStringW(g_hThisInstance, IDS_MENU_UPDATE);
MenuItemInfo.wID = IDC_UPDATE_DRV;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
}
if (DeviceNode->IsDisabled())
{
String.LoadStringW(g_hThisInstance, IDS_MENU_ENABLE);
MenuItemInfo.wID = IDC_ENABLE_DRV;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
}
if (DeviceNode->CanDisable() && !DeviceNode->IsDisabled())
{
String.LoadStringW(g_hThisInstance, IDS_MENU_DISABLE);
MenuItemInfo.wID = IDC_DISABLE_DRV;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
}
if (DeviceNode->CanUninstall())
{
String.LoadStringW(g_hThisInstance, IDS_MENU_UNINSTALL);
MenuItemInfo.wID = IDC_UNINSTALL_DRV;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
}
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuSeperator);
i++;
}
// All nodes have the scan option
String.LoadStringW(g_hThisInstance, IDS_MENU_SCAN);
MenuItemInfo.wID = IDC_SCAN_HARDWARE;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
if ((Node->GetNodeType() == RootNode) || (MainMenu == true))
{
String.LoadStringW(g_hThisInstance, IDS_MENU_ADD);
MenuItemInfo.wID = IDC_ADD_HARDWARE;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
}
if (Node->HasProperties())
{
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuSeperator);
i++;
String.LoadStringW(g_hThisInstance, IDS_MENU_PROPERTIES);
MenuItemInfo.wID = IDC_PROPERTIES;
MenuItemInfo.dwTypeData = String.GetBuffer();
InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo);
i++;
SetMenuDefaultItem(OwnerMenu, IDC_PROPERTIES, FALSE);
}
}
static HRESULT WINAPI ItemMenu_QueryContextMenu(
IContextMenu3 *iface,
HMENU hmenu,
UINT indexMenu,
UINT idCmdFirst,
UINT idCmdLast,
UINT uFlags)
{
ContextMenu *This = impl_from_IContextMenu3(iface);
INT uIDMax;
TRACE("(%p)->(%p %d 0x%x 0x%x 0x%x )\n", This, hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
if(!(CMF_DEFAULTONLY & uFlags) && This->cidl > 0)
{
HMENU hmenures = LoadMenuW(shell32_hInstance, MAKEINTRESOURCEW(MENU_SHV_FILE));
if(uFlags & CMF_EXPLORE)
RemoveMenu(hmenures, FCIDM_SHVIEW_OPEN, MF_BYCOMMAND);
uIDMax = Shell_MergeMenus(hmenu, GetSubMenu(hmenures, 0), indexMenu, idCmdFirst, idCmdLast, MM_SUBMENUSHAVEIDS);
DestroyMenu(hmenures);
if(This->allvalues)
{
MENUITEMINFOW mi;
WCHAR str[255];
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_ID | MIIM_STRING | MIIM_FTYPE;
mi.dwTypeData = str;
mi.cch = 255;
GetMenuItemInfoW(hmenu, FCIDM_SHVIEW_EXPLORE, MF_BYCOMMAND, &mi);
RemoveMenu(hmenu, FCIDM_SHVIEW_EXPLORE + idCmdFirst, MF_BYCOMMAND);
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_STRING;
mi.dwTypeData = str;
mi.fState = MFS_ENABLED;
mi.wID = FCIDM_SHVIEW_EXPLORE;
mi.fType = MFT_STRING;
InsertMenuItemW(hmenu, (uFlags & CMF_EXPLORE) ? 1 : 2, MF_BYPOSITION, &mi);
}
SetMenuDefaultItem(hmenu, 0, MF_BYPOSITION);
if(uFlags & ~CMF_CANRENAME)
RemoveMenu(hmenu, FCIDM_SHVIEW_RENAME, MF_BYCOMMAND);
else
{
UINT enable = MF_BYCOMMAND;
/* can't rename more than one item at a time*/
if (!This->apidl || This->cidl > 1)
enable |= MFS_DISABLED;
else
{
DWORD attr = SFGAO_CANRENAME;
IShellFolder_GetAttributesOf(This->parent, 1, (LPCITEMIDLIST*)This->apidl, &attr);
enable |= (attr & SFGAO_CANRENAME) ? MFS_ENABLED : MFS_DISABLED;
}
EnableMenuItem(hmenu, FCIDM_SHVIEW_RENAME, enable);
}
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, uIDMax-idCmdFirst);
}
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
}
