HRESULT WINAPI CDesktopFolder::GetDetailsOf(
PCUITEMID_CHILD pidl,
UINT iColumn,
SHELLDETAILS *psd)
{
if (!psd || iColumn >= DESKTOPSHELLVIEWCOLUMNS)
return E_INVALIDARG;
if (!pidl)
{
psd->fmt = DesktopSFHeader[iColumn].fmt;
psd->cxChar = DesktopSFHeader[iColumn].cxChar;
return SHSetStrRet(&psd->str, DesktopSFHeader[iColumn].colnameid);
}
CComPtr<IShellFolder2> psf;
HRESULT hr = _GetSFFromPidl(pidl, &psf);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
hr = psf->GetDetailsOf(pidl, iColumn, psd);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return hr;
}
// Stop tracking a system popup submenu
HRESULT CMenuFocusManager::PopTrackedPopup(HMENU popup)
{
StackEntryType type;
HMENU hmenu;
HRESULT hr;
TRACE("PopTrackedPopup %p\n", popup);
hr = PopFromArray(&type, NULL, &hmenu);
if (FAILED_UNEXPECTEDLY(hr))
{
UpdateFocus();
return hr;
}
_ASSERT(type == TrackedMenuEntry);
if (type != TrackedMenuEntry)
return E_FAIL;
if (hmenu != popup)
return E_FAIL;
hr = UpdateFocus();
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return S_OK;
}
HRESULT CBandSiteMenu::_CreateNewISFBand(HWND hwnd, REFIID riid, void** ppv)
{
WCHAR path[MAX_PATH];
WCHAR message[256];
BROWSEINFOW bi = { hwnd, NULL, path };
if (LoadStringW(GetModuleHandleW(L"browseui.dll"), IDS_BROWSEFORNEWTOOLAR, message, _countof(message)))
bi.lpszTitle = message;
else
bi.lpszTitle = L"Choose a folder";
CComHeapPtr<ITEMIDLIST> pidlSelected;
pidlSelected.Attach(SHBrowseForFolderW(&bi));
if (pidlSelected == NULL)
return S_FALSE;
CComPtr<IShellFolderBand> pISFB;
HRESULT hr = CISFBand_CreateInstance(IID_IShellFolderBand, (PVOID*)&pISFB);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
hr = pISFB->InitializeSFB(NULL, pidlSelected);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return pISFB->QueryInterface(riid, ppv);
}
HRESULT CMenuFocusManager::IsTrackedWindowOrParent(HWND hWnd)
{
for (int i = m_bandCount; --i >= 0;)
{
StackEntry& entry = m_bandStack[i];
if (entry.type != TrackedMenuEntry)
{
HRESULT hr = entry.mb->IsWindowOwner(hWnd);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (hr == S_OK)
return S_OK;
if (entry.mb->_IsPopup() == S_OK)
{
CComPtr<IUnknown> site;
CComPtr<IOleWindow> pw;
hr = entry.mb->GetSite(IID_PPV_ARG(IUnknown, &site));
if (FAILED_UNEXPECTEDLY(hr))
continue;
hr = IUnknown_QueryService(site, SID_SMenuBandParent, IID_PPV_ARG(IOleWindow, &pw));
if (FAILED_UNEXPECTEDLY(hr))
continue;
HWND hParent;
if (pw->GetWindow(&hParent) == S_OK && hParent == hWnd)
return S_OK;
}
}
}
return S_FALSE;
}
HRESULT CComCatCachedCategory::LoadFromComCatMgr()
{
HRESULT hr;
CComPtr<ICatInformation> pCatInformation;
CComPtr<IEnumGUID> pEnumGUID;
ULONG pFetched;
CLSID tmp;
// Get component categories manager instance
hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(ICatInformation, &pCatInformation));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
// Get the proper enumerator
hr = pCatInformation->EnumClassesOfCategories(1, &fCategory, NULL, NULL, &pEnumGUID);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
// Enumerate elements
do
{
pFetched = 0;
pEnumGUID->Next(1, &tmp, &pFetched);
if (pFetched)
{
if (DSA_InsertItem(fLocalDsa, DSA_APPEND, &tmp) == E_OUTOFMEMORY)
return E_OUTOFMEMORY;
}
}
while (pFetched > 0);
return S_OK;
}
HRESULT CBandSiteMenu::_AddISFBandToMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, IUnknown* pBand, DWORD dwBandID, UINT *newMenuId)
{
CComPtr<IShellFolderBand> psfb;
HRESULT hr = pBand->QueryInterface(IID_PPV_ARG(IShellFolderBand, &psfb));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
BANDINFOSFB bi = {ISFB_MASK_IDLIST};
hr = psfb->GetBandInfoSFB(&bi);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
CComHeapPtr<ITEMIDLIST> pidl(bi.pidl);
if (!pidl)
{
ERR("Failed to get the pidl of the CISFBand\n");
return E_OUTOFMEMORY;
}
WCHAR buffer[MAX_PATH];
hr = ILGetDisplayNameEx(NULL, pidl, buffer, ILGDN_INFOLDER) ? S_OK : E_FAIL;
if (FAILED_UNEXPECTEDLY(hr))
return hr;
UINT id = idCmdFirst + m_ComCatGuids.GetSize() + FIRST_COMCAT_MENU_ID + dwBandID;
if (id >= idCmdLast)
return E_FAIL;
*newMenuId = id;
InsertMenu(hmenu, indexMenu, MF_BYPOSITION, id, buffer);
return S_OK;
}
/***********************************************************************
* SHOpenFolderAndSelectItems
*
* Unimplemented.
*/
EXTERN_C HRESULT
WINAPI
SHOpenFolderAndSelectItems(LPITEMIDLIST pidlFolder,
UINT cidl,
PCUITEMID_CHILD_ARRAY apidl,
DWORD dwFlags)
{
ERR("SHOpenFolderAndSelectItems() is hackplemented\n");
PCIDLIST_ABSOLUTE pidlItem;
if (cidl)
{
/* Firefox sends a full pidl here dispite the fact it is a PCUITEMID_CHILD_ARRAY -_- */
if (ILGetNext(apidl[0]) != NULL)
{
pidlItem = apidl[0];
}
else
{
pidlItem = ILCombine(pidlFolder, apidl[0]);
}
}
else
{
pidlItem = pidlFolder;
}
CComPtr<IShellFolder> psfDesktop;
HRESULT hr = SHGetDesktopFolder(&psfDesktop);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
STRRET strret;
hr = psfDesktop->GetDisplayNameOf(pidlItem, SHGDN_FORPARSING, &strret);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
WCHAR wszBuf[MAX_PATH];
hr = StrRetToBufW(&strret, pidlItem, wszBuf, _countof(wszBuf));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
WCHAR wszParams[MAX_PATH];
wcscpy(wszParams, L"/select,");
wcscat(wszParams, wszBuf);
SHELLEXECUTEINFOW sei;
memset(&sei, 0, sizeof sei);
sei.cbSize = sizeof sei;
sei.fMask = SEE_MASK_WAITFORINPUTIDLE;
sei.lpFile = L"explorer.exe";
sei.lpParameters = wszParams;
if (ShellExecuteExW(&sei))
return S_OK;
else
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE CAddressEditBox::ParseNow(long paramC)
{
ULONG eaten;
ULONG attributes;
HRESULT hr;
HWND topLevelWindow;
CComPtr<IShellBrowser> pisb;
hr = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IShellBrowser, &pisb));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
hr = IUnknown_GetWindow(pisb, &topLevelWindow);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
LPWSTR input;
int inputLength = fCombobox.GetWindowTextLength() + 2;
input = new WCHAR[inputLength];
fCombobox.GetWindowText(input, inputLength);
LPWSTR address;
int addressLength = ExpandEnvironmentStrings(input, NULL, 0);
if (addressLength <= 0)
{
address = input;
}
else
{
addressLength += 2;
address = new WCHAR[addressLength];
if (!ExpandEnvironmentStrings(input, address, addressLength))
{
delete[] address;
address = input;
}
}
CComPtr<IShellFolder> psfDesktop;
hr = SHGetDesktopFolder(&psfDesktop);
if (SUCCEEDED(hr))
{
hr = psfDesktop->ParseDisplayName(topLevelWindow, NULL, address, &eaten, &pidlLastParsed, &attributes);
}
if (address != input)
delete [] address;
delete [] input;
return hr;
}
HRESULT WINAPI CDesktopFolder::FinalConstruct()
{
WCHAR szMyPath[MAX_PATH];
HRESULT hr;
/* Create the root pidl */
pidlRoot = _ILCreateDesktop();
if (!pidlRoot)
return E_OUTOFMEMORY;
/* Create the inner fs folder */
hr = SHELL32_CoCreateInitSF(pidlRoot,
NULL,
NULL,
&CLSID_ShellFSFolder,
CSIDL_DESKTOPDIRECTORY,
IID_PPV_ARG(IShellFolder2, &m_DesktopFSFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Create the inner shared fs folder. Dont fail on failure. */
hr = SHELL32_CoCreateInitSF(pidlRoot,
NULL,
NULL,
&CLSID_ShellFSFolder,
CSIDL_COMMON_DESKTOPDIRECTORY,
IID_PPV_ARG(IShellFolder2, &m_SharedDesktopFSFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Create the inner reg folder */
hr = CRegFolder_CreateInstance(&CLSID_ShellDesktop,
pidlRoot,
L"",
IID_PPV_ARG(IShellFolder2, &m_regFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Cache the path to the user desktop directory */
if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE ))
return E_UNEXPECTED;
sPathTarget = (LPWSTR)SHAlloc((wcslen(szMyPath) + 1) * sizeof(WCHAR));
if (!sPathTarget)
return E_OUTOFMEMORY;
wcscpy(sPathTarget, szMyPath);
return S_OK;
}
// Code is duplicated in CDefaultContextMenu
HRESULT CNewMenu::CreateNewFolder(LPCMINVOKECOMMANDINFO lpici)
{
WCHAR wszPath[MAX_PATH];
WCHAR wszName[MAX_PATH];
WCHAR wszNewFolder[25];
HRESULT hr;
/* Get folder path */
hr = SHGetPathFromIDListW(m_pidlFolder, wszPath);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (!LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, _countof(wszNewFolder)))
return E_FAIL;
/* Create the name of the new directory */
if (!PathYetAnotherMakeUniqueName(wszName, wszPath, NULL, wszNewFolder))
return E_FAIL;
/* Create the new directory and show the appropriate dialog in case of error */
if (SHCreateDirectory (lpici->hwnd, wszName) != ERROR_SUCCESS)
return E_FAIL;
/* Show and select the new item in the def view */
SelectNewItem(lpici, SHCNE_MKDIR, SHCNF_PATHW, wszName);
return S_OK;
}
HRESULT CMenuToolbarBase::OnPopupTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if (wParam != TIMERID_HOTTRACK)
{
bHandled = FALSE;
return 0;
}
KillTimer(TIMERID_HOTTRACK);
if (!m_timerEnabled)
return 0;
m_timerEnabled = FALSE;
if (m_hotItem < 0)
return 0;
// Returns S_FALSE if the current item did not show a submenu
HRESULT hr = PopupItem(m_hotItem, FALSE);
if (hr != S_FALSE)
return 0;
// If we didn't switch submenus, cancel the current popup regardless
if (m_popupBar)
{
HRESULT hr = CancelCurrentPopup();
if (FAILED_UNEXPECTEDLY(hr))
return 0;
}
return 0;
}
HRESULT CMenuToolbarBase::UpdateImageLists()
{
if ((m_initFlags & (SMINIT_TOPLEVEL | SMINIT_VERTICAL)) == SMINIT_TOPLEVEL) // not vertical.
{
// No image list, prevents the buttons from having a margin at the left side
SetImageList(NULL);
return S_OK;
}
// Assign the correct imagelist and padding based on the current icon size
int shiml;
if (m_menuBand->UseBigIcons())
{
shiml = SHIL_LARGE;
SetPadding(4, 0);
}
else
{
shiml = SHIL_SMALL;
SetPadding(4, 4);
}
IImageList * piml;
HRESULT hr = SHGetImageList(shiml, IID_PPV_ARG(IImageList, &piml));
if (FAILED_UNEXPECTEDLY(hr))
{
SetImageList(NULL);
}
else
{
SetImageList((HIMAGELIST)piml);
}
return S_OK;
}
HRESULT CMenuSFToolbar::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
{
HRESULT hr;
hr = m_shellFolder->QueryInterface(riid, ppv);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (pdwFlags)
*pdwFlags = m_dwMenuFlags;
if (ppidl)
{
LPITEMIDLIST pidl = NULL;
if (m_idList)
{
pidl = ILClone(m_idList);
if (!pidl)
{
ERR("ILClone failed!\n");
(*reinterpret_cast<IUnknown**>(ppv))->Release();
return E_FAIL;
}
}
*ppidl = pidl;
}
return hr;
}
HRESULT CMenuToolbarBase::PopupItem(INT iItem, BOOL keyInitiated)
{
INT index;
DWORD_PTR dwData;
if (iItem < 0)
return S_OK;
if (m_popupBar == this && m_popupItem == iItem)
return S_OK;
GetDataFromId(iItem, &index, &dwData);
HRESULT hr = InternalHasSubMenu(iItem, index, dwData);
if (hr != S_OK)
return hr;
if (m_popupBar)
{
HRESULT hr = CancelCurrentPopup();
if (FAILED_UNEXPECTEDLY(hr))
return hr;
}
if (!(m_initFlags & SMINIT_VERTICAL))
{
TRACE("PopupItem non-vertical %d %d\n", index, iItem);
m_menuBand->_ChangeHotItem(this, iItem, 0);
}
return InternalPopupItem(iItem, index, dwData, keyInitiated);
}
// Used so that the toolbar can properly ignore mouse events, when the menu is being used with the keyboard
void CMenuFocusManager::DisableMouseTrack(HWND parent, BOOL disableThis)
{
BOOL bDisable = FALSE;
BOOL lastDisable = FALSE;
int i = m_bandCount;
while (--i >= 0)
{
StackEntry& entry = m_bandStack[i];
if (entry.type != TrackedMenuEntry)
{
HWND hwnd;
HRESULT hr = entry.mb->_GetTopLevelWindow(&hwnd);
if (FAILED_UNEXPECTEDLY(hr))
break;
if (hwnd == parent)
{
lastDisable = disableThis;
entry.mb->_DisableMouseTrack(disableThis);
bDisable = TRUE;
}
else
{
lastDisable = bDisable;
entry.mb->_DisableMouseTrack(bDisable);
}
}
}
m_mouseTrackDisabled = lastDisable;
}
HRESULT STDMETHODCALLTYPE CAddressBand::OnWinEvent(
HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
{
CComPtr<IWinEventHandler> winEventHandler;
HRESULT hResult;
RECT rect;
if (theResult)
*theResult = 0;
switch (uMsg)
{
case WM_WININICHANGE:
break;
case WM_COMMAND:
if (wParam == IDM_TOOLBARS_GOBUTTON)
{
fGoButtonShown = !SHRegGetBoolUSValueW(L"Software\\Microsoft\\Internet Explorer\\Main", L"ShowGoButton", FALSE, TRUE);
SHRegSetUSValueW(L"Software\\Microsoft\\Internet Explorer\\Main", L"ShowGoButton", REG_SZ, fGoButtonShown ? (LPVOID)L"yes" : (LPVOID)L"no", fGoButtonShown ? 8 : 6, SHREGSET_FORCE_HKCU);
if (!fGoButton)
CreateGoButton();
::ShowWindow(fGoButton,fGoButtonShown ? SW_HIDE : SW_SHOW);
GetWindowRect(&rect);
SendMessage(m_hWnd,WM_SIZE,0,MAKELPARAM(rect.right-rect.left,rect.bottom-rect.top));
// broadcast change notification to all explorer windows
}
break;
}
hResult = fAddressEditBox->QueryInterface(IID_PPV_ARG(IWinEventHandler, &winEventHandler));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
return winEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
}
HRESULT SHELL32_SetNameOfGuidItem(PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
{
GUID const *clsid = _ILGetGUIDPointer (pidl);
LPOLESTR pStr;
HRESULT hr;
WCHAR szName[100];
if (!clsid)
{
ERR("Pidl is not reg item!\n");
return E_FAIL;
}
hr = StringFromCLSID(*clsid, &pStr);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
swprintf(szName, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\%s", pStr);
DWORD cbData = (wcslen(lpName) + 1) * sizeof(WCHAR);
LONG res = SHSetValueW(HKEY_CURRENT_USER, szName, NULL, RRF_RT_REG_SZ, lpName, cbData);
CoTaskMemFree(pStr);
if (res == ERROR_SUCCESS)
{
*pPidlOut = ILClone(pidl);
return S_OK;
}
return E_FAIL;
}
HRESULT CMenuFocusManager::IsTrackedWindow(HWND hWnd, StackEntry ** pentry)
{
if (pentry)
*pentry = NULL;
for (int i = m_bandCount; --i >= 0;)
{
StackEntry& entry = m_bandStack[i];
if (entry.type != TrackedMenuEntry)
{
HRESULT hr = entry.mb->IsWindowOwner(hWnd);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (hr == S_OK)
{
if (pentry)
*pentry = &entry;
return S_OK;
}
}
}
return S_FALSE;
}
/**************************************************************************
* CDesktopFolder::GetDisplayNameOf
*
* NOTES
* special case: pidl = null gives desktop-name back
*/
HRESULT WINAPI CDesktopFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
if (!_ILIsPidlSimple (pidl))
{
return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
}
else if (_ILIsDesktop(pidl))
{
if ((GET_SHGDN_RELATION(dwFlags) == SHGDN_NORMAL) && (GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING))
return SHSetStrRet(strRet, sPathTarget);
else
return HCR_GetClassName(CLSID_ShellDesktop, strRet);
}
/* file system folder or file rooted at the desktop */
CComPtr<IShellFolder2> psf;
HRESULT hr = _GetSFFromPidl(pidl, &psf);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return psf->GetDisplayNameOf(pidl, dwFlags, strRet);
}
HRESULT CSHEnumClassesOfCategories::Initialize(ULONG cImplemented, CATID *pImplemented, ULONG cRequired, CATID *pRequired)
{
UINT i;
HRESULT hr;
if (!fDsa)
return E_FAIL;
if (cRequired > 0 || cImplemented == (ULONG)-1)
{
FIXME("Implement required categories class enumeration\n");
return E_NOTIMPL;
}
// Don't do anything if we have nothing
if (cRequired == 0 && cImplemented == (ULONG)-1)
return E_FAIL;
// For each implemented category, create a cache and add it to our local DSA
for (i = 0; i < cImplemented; i++)
{
CComCatCachedCategory cachedCat;
hr = cachedCat.Initialize(pImplemented[i], FALSE);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
cachedCat.WriteCacheToDSA(fDsa);
}
return S_OK;
}
HRESULT CBandSiteMenu::_CreateBuiltInISFBand(UINT uID, REFIID riid, void** ppv)
{
LPITEMIDLIST pidl;
HRESULT hr;
switch (uID)
{
case IDM_TASKBAR_TOOLBARS_DESKTOP:
{
if (m_DesktopPidl != NULL)
m_DesktopPidl.Free();
hr = SHGetFolderLocation(0, CSIDL_DESKTOP, NULL, 0, &m_DesktopPidl);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
pidl = m_DesktopPidl;
break;
}
case IDM_TASKBAR_TOOLBARS_QUICKLAUNCH:
{
pidl = _GetQLaunchPidl(true);
break;
}
}
if (pidl == NULL)
return E_FAIL;
CComPtr<IShellFolderBand> pISFB;
hr = CISFBand_CreateInstance(IID_IShellFolderBand, (PVOID*)&pISFB);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
hr = pISFB->InitializeSFB(NULL, pidl);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* HACK! We shouldn't pass ISFB_STATE_QLINKSMODE and CISFBand shouldn't handle it! */
if (uID == IDM_TASKBAR_TOOLBARS_QUICKLAUNCH)
{
BANDINFOSFB bisfb = {ISFB_MASK_STATE, ISFB_STATE_QLINKSMODE, ISFB_STATE_QLINKSMODE};
pISFB->SetBandInfoSFB(&bisfb);
}
return pISFB->QueryInterface(riid, ppv);
}
HRESULT CMenuStaticToolbar::FillToolbar(BOOL clearFirst)
{
int i;
int ic = GetMenuItemCount(m_hmenu);
if (clearFirst)
{
ClearToolbar();
}
int count = 0;
for (i = 0; i < ic; i++)
{
BOOL last = i + 1 == ic;
MENUITEMINFOW info;
info.cbSize = sizeof(info);
info.dwTypeData = NULL;
info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
if (!GetMenuItemInfoW(m_hmenu, i, TRUE, &info))
{
TRACE("Error obtaining info for menu item at pos=%d\n", i);
continue;
}
count++;
if (info.fType & MFT_SEPARATOR)
{
AddSeparator(last);
}
else if (!(info.fType & MFT_BITMAP))
{
info.cch++;
info.dwTypeData = (PWSTR) HeapAlloc(GetProcessHeap(), 0, (info.cch + 1) * sizeof(WCHAR));
info.fMask = MIIM_STRING | MIIM_SUBMENU | MIIM_ID;
GetMenuItemInfoW(m_hmenu, i, TRUE, &info);
SMINFO * sminfo = new SMINFO();
sminfo->dwMask = SMIM_ICON | SMIM_FLAGS;
HRESULT hr = m_menuBand->_CallCBWithItemId(info.wID, SMC_GETINFO, 0, reinterpret_cast<LPARAM>(sminfo));
if (FAILED_UNEXPECTEDLY(hr))
{
delete sminfo;
return hr;
}
AddButton(info.wID, info.dwTypeData, info.hSubMenu != NULL, sminfo->iIcon, reinterpret_cast<DWORD_PTR>(sminfo), last);
HeapFree(GetProcessHeap(), 0, info.dwTypeData);
}
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE CComCatCachedCategory::Initialize(CATID &catID, BOOL reloadCache)
{
HRESULT hr;
fCategory = catID;
if (reloadCache || !LoadFromRegistry())
{
hr = LoadFromComCatMgr();
if (FAILED_UNEXPECTEDLY(hr))
return hr;
hr = CacheDSA();
if (FAILED_UNEXPECTEDLY(hr))
return hr;
}
return S_OK;
}
// Stop tracking a shell menu
HRESULT CMenuFocusManager::PopMenuPopup(CMenuBand * mb)
{
StackEntryType type;
CMenuBand * mbc;
HRESULT hr;
TRACE("PopMenuPopup %p\n", mb);
if (m_current == m_entryUnderMouse)
{
m_entryUnderMouse = NULL;
}
m_menuDepth--;
hr = PopFromArray(&type, &mbc, NULL);
if (FAILED_UNEXPECTEDLY(hr))
{
UpdateFocus();
return hr;
}
_ASSERT(type == MenuPopupEntry);
if (type != MenuPopupEntry)
return E_FAIL;
if (!mbc)
return E_FAIL;
mbc->_SetParentBand(NULL);
mbc->Release();
hr = UpdateFocus();
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (m_current)
{
_ASSERT(m_current->type != TrackedMenuEntry);
m_current->mb->_SetChildBand(NULL);
}
return S_OK;
}
HRESULT CBandSiteMenu::_CreateMenuPart()
{
WCHAR wszBandName[MAX_PATH];
WCHAR wszBandGUID[MAX_PATH];
WCHAR wRegKey[MAX_PATH];
UINT cBands;
DWORD dwDataSize;
CATID category = CATID_DeskBand;
HMENU hmenuToolbars;
DWORD dwRead;
CComPtr<IEnumGUID> pEnumGUID;
HRESULT hr;
if (m_hmenu)
DestroyMenu(m_hmenu);
/* Load the template we will fill in */
m_hmenu = LoadMenuW(GetModuleHandleW(L"browseui.dll"), MAKEINTRESOURCEW(IDM_TASKBAR_TOOLBARS));
if (!m_hmenu)
return HRESULT_FROM_WIN32(GetLastError());
/* Get the handle of the submenu where the available items will be shown */
hmenuToolbars = GetSubMenu(m_hmenu, 0);
/* Create the category enumerator */
hr = SHEnumClassesOfCategories(1, &category, 0, NULL, &pEnumGUID);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
m_ComCatGuids.RemoveAll();
/* Enumerate the classes in the CATID_DeskBand category */
cBands = 0;
do
{
GUID iter;
pEnumGUID->Next(1, &iter, &dwRead);
if (!dwRead)
continue;
if (!StringFromGUID2(iter, wszBandGUID, MAX_PATH))
continue;
/* Get the band name */
StringCchPrintfW(wRegKey, MAX_PATH, L"CLSID\\%s", wszBandGUID);
dwDataSize = MAX_PATH;
SHGetValue(HKEY_CLASSES_ROOT, wRegKey, NULL, NULL, wszBandName, &dwDataSize);
/* Insert it */
InsertMenu(hmenuToolbars, cBands, MF_BYPOSITION, m_ComCatGuids.GetSize() + FIRST_COMCAT_MENU_ID, wszBandName);
m_ComCatGuids.Add(iter);
cBands++;
}
while (dwRead > 0);
return S_OK;
}
HRESULT STDMETHODCALLTYPE CBrandBand::SetSite(IUnknown* pUnkSite)
{
CComPtr<IBrowserService> browserService;
CComPtr<IOleWindow> oleWindow;
CComPtr<IServiceProvider> serviceProvider;
CComPtr<IProfferService> profferService;
HWND parentWindow;
HWND hwnd;
HRESULT hResult;
fSite.Release();
if (pUnkSite == NULL)
{
hResult = AtlUnadvise(fSite, DIID_DWebBrowserEvents, fAdviseCookie);
// TODO: revoke brand band service
return S_OK;
}
// get window handle of parent
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &fSite));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
parentWindow = NULL;
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &oleWindow));
if (SUCCEEDED(hResult))
hResult = oleWindow->GetWindow(&parentWindow);
if (!::IsWindow(parentWindow))
return E_FAIL;
// create worker window in parent window
hwnd = SHCreateWorkerWindowW(0, parentWindow, 0,
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, NULL, 0);
if (hwnd == NULL)
return E_FAIL;
SubclassWindow(hwnd);
// take advice to watch events
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
if (SUCCEEDED(hResult))
{
hResult = serviceProvider->QueryService(
SID_SBrandBand, IID_PPV_ARG(IProfferService, &profferService));
if (SUCCEEDED(hResult))
hResult = profferService->ProfferService(SID_SBrandBand,
static_cast<IServiceProvider *>(this), &fProfferCookie);
hResult = serviceProvider->QueryService(SID_SShellBrowser,
IID_PPV_ARG(IBrowserService, &browserService));
if (SUCCEEDED(hResult))
hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
}
// ignore any hResult errors up to here - they are nonfatal
hResult = S_OK;
SelectImage();
return hResult;
}
HRESULT STDMETHODCALLTYPE CBandProxy::IsConnected()
{
CComPtr<IUnknown> webBrowser;
HRESULT hResult;
hResult = FindBrowserWindow(&webBrowser);
if (FAILED_UNEXPECTEDLY(hResult) || webBrowser.p == NULL)
return S_FALSE;
return S_OK;
}
HRESULT CFolder::GetShellFolder(CComPtr<IShellFolder>& psfCurrent)
{
CComPtr<IShellFolder> psfDesktop;
HRESULT hr = SHGetDesktopFolder(&psfDesktop);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return psfDesktop->BindToObject(m_idlist, NULL, IID_PPV_ARG(IShellFolder, &psfCurrent));
}
/*************************************************************************
* SHEnumClassesOfCategories [BROWSEUI.136]
*/
extern "C" HRESULT WINAPI SHEnumClassesOfCategories(ULONG cImplemented, CATID *pImplemented, ULONG cRequired, CATID *pRequired, IEnumGUID **out)
{
HRESULT hr;
hr = ShellObjectCreatorInit<CSHEnumClassesOfCategories, ULONG, CATID*, ULONG, CATID*, IEnumGUID>(
cImplemented, pImplemented, cRequired, pRequired, IID_IEnumGUID, out);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CAddressBand::Refresh(long param8)
{
CComPtr<IAddressBand> addressBand;
HRESULT hResult;
hResult = fAddressEditBox->QueryInterface(IID_PPV_ARG(IAddressBand, &addressBand));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
return addressBand->Refresh(param8);
}
