自学教程：C++ FAILED_UNEXPECTEDLY函数代码示例

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 submenuHRESULT 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 HRESULTWINAPISHOpenFolderAndSelectItems(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 CDefaultContextMenuHRESULT 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 keyboardvoid 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;}

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);}