able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/upnp/upnpui/dll/ishellf.cpp

1753 lines
46 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: I S H E L L F . C P P
//
// Contents: IShellFolder implementation for CUPnPDeviceFolder
// Implemention of CUPnPDeviceFoldPidl
//
// Notes: The IShellFolder interface is used to manage folders within
// the namespace. Objects that support IShellFolder are
// usually created by other shell folder objects, with the root
// object (the Desktop shell folder) being returned from the
// SHGetDesktopFolder function.
//
// Author: jeffspr 22 Sep 1997
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include <upscmn.h>
#include "tfind.h"
#include "clist.h"
#include "clistndn.h"
#include "tconst.h"
CUPnPDeviceFoldPidl::CUPnPDeviceFoldPidl()
{
// if these change, the UPNPUI_PIDL_HEADER structure
// above needs to change to be the right size
// Why we used 4 different types, I don't know...
Assert(2 == sizeof(WORD));
Assert(2 == sizeof(USHORT));
Assert(4 == sizeof(DWORD));
Assert(4 == sizeof(ULONG));
m_pszName = NULL;
m_pszUrl = NULL;
m_pszUdn = NULL;
m_pszType = NULL;
m_pszDesc = NULL;
}
CUPnPDeviceFoldPidl::~CUPnPDeviceFoldPidl()
{
if (m_pszName)
{
delete [] m_pszName;
}
if (m_pszUrl)
{
delete [] m_pszUrl;
}
if (m_pszUdn)
{
delete [] m_pszUdn;
}
if (m_pszType)
{
delete [] m_pszType;
}
if (m_pszDesc)
{
delete [] m_pszDesc;
}
}
HRESULT
CUPnPDeviceFoldPidl::HrInit(FolderDeviceNode * pDeviceNode)
{
Assert(!m_pszName);
Assert(!m_pszUrl);
Assert(!m_pszUdn);
Assert(!m_pszType);
Assert(!m_pszDesc);
Assert(pDeviceNode);
Assert(pDeviceNode->pszDisplayName);
Assert(pDeviceNode->pszPresentationURL);
Assert(pDeviceNode->pszUDN);
Assert(pDeviceNode->pszType);
HRESULT hr;
LPWSTR pszName;
LPWSTR pszUrl;
LPWSTR pszUdn;
LPWSTR pszType;
LPWSTR pszDesc;
ULONG cchName;
ULONG cchUrl;
ULONG cchUdn;
ULONG cchType;
ULONG cchDesc;
hr = E_OUTOFMEMORY;
pszName = NULL;
pszUrl = NULL;
pszUdn = NULL;
pszType = NULL;
pszDesc = NULL;
// Get the size of the name, and tack on a trailing NULL (since we now
// have something else in the buffer behind it.
//
cchName = lstrlenW(pDeviceNode->pszDisplayName);
pszName = new WCHAR [cchName + 1];
if (!pszName)
{
goto Cleanup;
}
cchUrl = lstrlenW(pDeviceNode->pszPresentationURL);
pszUrl = new WCHAR [cchUrl + 1];
if (!pszUrl)
{
goto Cleanup;
}
cchUdn = lstrlenW(pDeviceNode->pszUDN);
pszUdn = new WCHAR [cchUdn + 1];
if (!pszUdn)
{
goto Cleanup;
}
cchType = lstrlenW(pDeviceNode->pszType);
pszType = new WCHAR [cchType + 1];
if (!pszType)
{
goto Cleanup;
}
cchDesc = lstrlenW(pDeviceNode->pszDescription);
pszDesc = new WCHAR [cchDesc + 1];
if (!pszDesc)
{
goto Cleanup;
}
// everything that can fail has succeeded.
hr = S_OK;
// We don't need to check these since we know there's
// enough room.
wcscpy(pszName, pDeviceNode->pszDisplayName);
wcscpy(pszUrl, pDeviceNode->pszPresentationURL);
wcscpy(pszUdn, pDeviceNode->pszUDN);
wcscpy(pszType, pDeviceNode->pszType);
wcscpy(pszDesc, pDeviceNode->pszDescription);
m_pszName = pszName;
m_pszUrl = pszUrl;
m_pszUdn = pszUdn;
m_pszType = pszType;
m_pszDesc = pszDesc;
Cleanup:
if (FAILED(hr))
{
if (pszName)
{
delete [] pszName;
}
if (pszUrl)
{
delete [] pszUrl;
}
if (pszUdn)
{
delete [] pszUdn;
}
if (pszType)
{
delete [] pszType;
}
if (pszDesc)
{
delete [] pszDesc;
}
}
Assert(FImplies(SUCCEEDED(hr), pszName));
Assert(FImplies(SUCCEEDED(hr), pszUrl));
Assert(FImplies(SUCCEEDED(hr), pszUdn));
Assert(FImplies(SUCCEEDED(hr), pszType));
Assert(FImplies(SUCCEEDED(hr), pszDesc));
return hr;
}
HRESULT
HrCopyUnalignedBytesToNewString(BYTE * pByteData,
ULONG cbData,
LPWSTR * ppszResult)
{
Assert(ppszResult);
HRESULT hr;
LPWSTR pszResult;
ULONG cchMax;
hr = S_OK;
pszResult = NULL;
{
BOOL fInvalid;
fInvalid = IsBadReadPtr(pByteData, cbData);
if (fInvalid)
{
hr = E_POINTER;
goto Cleanup;
}
}
if (!cbData || cbData % sizeof(WCHAR))
{
hr = E_INVALIDARG;
goto Cleanup;
}
cchMax = (cbData / sizeof(WCHAR)) - 1;
pszResult = new WCHAR [ cchMax + 1 ];
if (!pszResult)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
::CopyMemory(pszResult, pByteData, cbData);
// make sure that the data is null-terminated.
pszResult[cchMax] = UNICODE_NULL;
Cleanup:
if (FAILED(hr))
{
if (pszResult)
{
delete [] pszResult;
pszResult = NULL;
}
}
*ppszResult = pszResult;
TraceError("HrCopyUnalignedBytesToNewString", hr);
return hr;
}
HRESULT
CUPnPDeviceFoldPidl::HrInit(PUPNPDEVICEFOLDPIDL pidl)
{
Assert(!m_pszName);
Assert(!m_pszUrl);
Assert(!m_pszUdn);
Assert(!m_pszType);
Assert(!m_pszDesc);
HRESULT hr;
UNALIGNED UPNPUI_PIDL_HEADER * puph;
LPWSTR pszName;
LPWSTR pszUrl;
LPWSTR pszUdn;
LPWSTR pszType;
LPWSTR pszDesc;
hr = S_OK;
puph = (UPNPUI_PIDL_HEADER *) pidl;
pszName = NULL;
pszUrl = NULL;
pszUdn = NULL;
pszType = NULL;
pszDesc = NULL;
{
BOOL fInvalid;
fInvalid = IsBadReadPtr(pidl, sizeof(UPNPUI_PIDL_HEADER));
if (fInvalid)
{
hr = E_POINTER;
goto Cleanup;
}
}
// minimal version checking should have happened already,
// so we just assert that everything is ok here
//
Assert(UPNPDEVICEFOLDPIDL_LEADID == puph->uLeadId);
Assert(UPNPDEVICEFOLDPIDL_TRAILID == puph->uTrailId);
{
BYTE * pbString;
ULONG ulOffset;
ULONG cb;
pbString = (BYTE *)pidl;
ulOffset = puph->ulNameOffset;
ulOffset += sizeof(UPNPUI_PIDL_HEADER);
cb = puph->cbName;
pbString += ulOffset;
hr = HrCopyUnalignedBytesToNewString(pbString,
cb,
&pszName);
if (FAILED(hr))
{
goto Cleanup;
}
}
{
BYTE * pbString;
ULONG ulOffset;
ULONG cb;
pbString = (BYTE *)pidl;
ulOffset = puph->ulUrlOffset;
ulOffset += sizeof(UPNPUI_PIDL_HEADER);
cb = puph->cbUrl;
pbString += ulOffset;
hr = HrCopyUnalignedBytesToNewString(pbString,
cb,
&pszUrl);
if (FAILED(hr))
{
goto Cleanup;
}
}
{
BYTE * pbString;
ULONG ulOffset;
ULONG cb;
pbString = (BYTE *)pidl;
ulOffset = puph->ulUdnOffset;
ulOffset += sizeof(UPNPUI_PIDL_HEADER);
cb = puph->cbUdn;
pbString += ulOffset;
hr = HrCopyUnalignedBytesToNewString(pbString,
cb,
&pszUdn);
if (FAILED(hr))
{
goto Cleanup;
}
}
{
BYTE * pbString;
ULONG ulOffset;
ULONG cb;
pbString = (BYTE *)pidl;
ulOffset = puph->ulTypeOffset;
ulOffset += sizeof(UPNPUI_PIDL_HEADER);
cb = puph->cbType;
pbString += ulOffset;
hr = HrCopyUnalignedBytesToNewString(pbString,
cb,
&pszType);
if (FAILED(hr))
{
goto Cleanup;
}
}
{
BYTE * pbString;
ULONG ulOffset;
ULONG cb;
pbString = (BYTE *)pidl;
ulOffset = puph->ulDescOffset;
ulOffset += sizeof(UPNPUI_PIDL_HEADER);
cb = puph->cbDesc;
pbString += ulOffset;
hr = HrCopyUnalignedBytesToNewString(pbString,
cb,
&pszDesc);
if (FAILED(hr))
{
goto Cleanup;
}
}
m_pszName = pszName;
m_pszUrl = pszUrl;
m_pszUdn = pszUdn;
m_pszType = pszType;
m_pszDesc = pszDesc;
Cleanup:
if (FAILED(hr))
{
if (pszName)
{
delete [] pszName;
}
if (pszUrl)
{
delete [] pszUrl;
}
if (pszUdn)
{
delete [] pszUdn;
}
if (pszType)
{
delete [] pszType;
}
if (pszDesc)
{
delete [] pszDesc;
}
}
Assert(FImplies(SUCCEEDED(hr), pszName));
Assert(FImplies(SUCCEEDED(hr), pszUrl));
Assert(FImplies(SUCCEEDED(hr), pszUdn));
Assert(FImplies(SUCCEEDED(hr), pszType));
Assert(FImplies(SUCCEEDED(hr), pszDesc));
TraceError("CUPnPDeviceFoldPidl::HrInit", hr);
return hr;
}
HRESULT
CUPnPDeviceFoldPidl::HrPersist(IMalloc * pMalloc, LPITEMIDLIST * ppidl)
{
Assert(m_pszName);
Assert(m_pszUrl);
Assert(m_pszUdn);
Assert(m_pszType);
Assert(m_pszDesc);
Assert(pMalloc);
Assert(ppidl);
HRESULT hr;
ULONG cbTotalPidlSize;
ULONG cbName;
ULONG cbUrl;
ULONG cbUdn;
ULONG cbType;
ULONG cbDesc;
ULONG ulNameOffset;
ULONG ulUrlOffset;
ULONG ulUdnOffset;
ULONG ulTypeOffset;
ULONG ulDescOffset;
UNALIGNED UPNPUI_PIDL_HEADER * puph;
LPBYTE pbData;
hr = S_OK;
pbData = NULL;
cbName = wcslen(m_pszName);
cbName = (cbName + 1) * sizeof(WCHAR);
cbUrl = wcslen(m_pszUrl);
cbUrl = (cbUrl + 1) * sizeof(WCHAR);
cbUdn = wcslen(m_pszUdn);
cbUdn = (cbUdn + 1) * sizeof(WCHAR);
cbType = wcslen(m_pszType);
cbType = (cbType + 1) * sizeof(WCHAR);
cbDesc = wcslen(m_pszDesc);
cbDesc = (cbDesc + 1) * sizeof(WCHAR);
ulNameOffset = 0;
ulUrlOffset = ulNameOffset + cbName;
ulUdnOffset = ulUrlOffset + cbUrl;
ulTypeOffset = ulUdnOffset + cbUdn;
ulDescOffset = ulTypeOffset + cbType;
cbTotalPidlSize = sizeof(UPNPUI_PIDL_HEADER);
cbTotalPidlSize += cbName;
cbTotalPidlSize += cbUrl;
cbTotalPidlSize += cbUdn;
cbTotalPidlSize += cbType;
cbTotalPidlSize += cbDesc;
// don't count the PIDL-terminating bytes in the size
//
pbData = (BYTE *) pMalloc->Alloc(cbTotalPidlSize +
FIELD_OFFSET(ITEMIDLIST, mkid.cb) + sizeof(USHORT));
if (!pbData)
{
hr = E_OUTOFMEMORY;
TraceError("CUPnPDeviceFoldPidl::HrPersist: Alloc()", hr);
goto Cleanup;
}
// delegate folder alert: since we're a delete folder, the Alloc() above
// doesn't just allocate the bytes we asked for, but rather a bunch for our
// delegate folder prefix, then the bytes we asked for. We need to skip
// the prefix bytes and just write to our own.
puph = (UPNPUI_PIDL_HEADER *)ConvertToUPnPDevicePIDL((ITEMIDLIST*)pbData);
puph->iCB = cbTotalPidlSize;
puph->uLeadId = UPNPDEVICEFOLDPIDL_LEADID;
puph->dwVersion = UP_DEVICE_FOLDER_IDL_VERSION;
puph->uTrailId = UPNPDEVICEFOLDPIDL_TRAILID;
puph->uVOID = 0;
puph->dwCharacteristics = 0;
puph->ulNameOffset = ulNameOffset;
puph->cbName = cbName;
puph->ulUrlOffset = ulUrlOffset;
puph->cbUrl = cbUrl;
puph->ulUdnOffset = ulUdnOffset;
puph->cbUdn = cbUdn;
puph->ulTypeOffset = ulTypeOffset;
puph->cbType = cbType;
puph->ulDescOffset = ulDescOffset;
puph->cbDesc = cbDesc;
{
LPBYTE pbDynamicField;
LPBYTE pbName;
LPBYTE pbUrl;
LPBYTE pbUdn;
LPBYTE pbType;
LPBYTE pbDesc;
// note: this has to be puph (not pbData) because we still
// have to skip the "delegate folder prefix" junk.
pbDynamicField = ((BYTE *)puph) + sizeof(UPNPUI_PIDL_HEADER);
pbName = pbDynamicField + ulNameOffset;
pbUrl = pbDynamicField + ulUrlOffset;
pbUdn = pbDynamicField + ulUdnOffset;
pbType = pbDynamicField + ulTypeOffset;
pbDesc = pbDynamicField + ulDescOffset;
::CopyMemory(pbName, m_pszName, cbName);
::CopyMemory(pbUrl, m_pszUrl, cbUrl);
::CopyMemory(pbUdn, m_pszUdn, cbUdn);
::CopyMemory(pbType, m_pszType, cbType);
::CopyMemory(pbDesc, m_pszDesc, cbDesc);
}
{
// terminate the PIDL
LPITEMIDLIST pidlNext;
pidlNext = ILNext((LPITEMIDLIST)puph);
Assert((FIELD_OFFSET(ITEMIDLIST, mkid.cb) +
sizeof(pidlNext->mkid.cb)) == sizeof(USHORT));
pidlNext->mkid.cb = 0;
}
Cleanup:
Assert(FImplies(FAILED(hr), !pbData));
Assert(FImplies(SUCCEEDED(hr), pbData));
*ppidl = (LPITEMIDLIST)pbData;
TraceError("CUPnPDeviceFoldPidl::HrPersist", hr);
return hr;
}
PCWSTR
CUPnPDeviceFoldPidl::PszGetNamePointer() const
{
return m_pszName;
}
PCWSTR
CUPnPDeviceFoldPidl::PszGetURLPointer() const
{
return m_pszUrl;
}
PCWSTR
CUPnPDeviceFoldPidl::PszGetUDNPointer() const
{
return m_pszUdn;
}
PCWSTR
CUPnPDeviceFoldPidl::PszGetTypePointer() const
{
return m_pszType;
}
PCWSTR
CUPnPDeviceFoldPidl::PszGetDescriptionPointer() const
{
return m_pszDesc;
}
HRESULT CUPnPDeviceFoldPidl::HrSetName(PCWSTR szName)
{
HRESULT hr = S_OK;
if (szName)
{
// Free old name
delete [] m_pszName;
// Copy in new name
m_pszName = WszDupWsz(szName);
if (!m_pszName)
{
hr = E_OUTOFMEMORY;
}
}
TraceError("CUPnPDeviceFoldPidl::HrSetName", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::HrMakeUPnPDevicePidl
//
// Purpose: Private function of the folder object that constructs the
// UPNP device pidl using the delegated allocator
//
// Arguments:
// FolderDeviceNode [in] Structure that contains all the
// strings we need for the pidl
// ppidl [out] The result pidl
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise
//
// Author: tongl 15 Feb 2000
//
// Notes:
//
HRESULT CUPnPDeviceFolder::HrMakeUPnPDevicePidl(FolderDeviceNode * pDeviceNode,
LPITEMIDLIST * ppidl)
{
HRESULT hr;
CUPnPDeviceFoldPidl udfp;
hr = udfp.HrInit(pDeviceNode);
if (SUCCEEDED(hr))
{
hr = udfp.HrPersist(m_pDelegateMalloc, ppidl);
}
return hr;
}
HRESULT CUPnPDeviceFolder::HrMakeUPnPDevicePidl(IUPnPDevice * pDevice,
LPITEMIDLIST * ppidl)
{
HRESULT hr = S_OK;
Assert(pDevice);
BSTR bstrUDN = NULL;
BSTR bstrDisplayName = NULL;
BSTR bstrType = NULL;
BSTR bstrPresentationURL = NULL;
BSTR bstrDescription = NULL;
Assert(pDevice);
pDevice->AddRef();
hr = pDevice->get_UniqueDeviceName(&bstrUDN);
if (SUCCEEDED(hr))
{
hr = pDevice->get_FriendlyName(&bstrDisplayName);
if (SUCCEEDED(hr))
{
hr = pDevice->get_Type(&bstrType);
if (SUCCEEDED(hr))
{
hr = pDevice->get_PresentationURL(&bstrPresentationURL);
if (SUCCEEDED(hr))
{
hr = pDevice->get_Description(&bstrDescription);
if (SUCCEEDED(hr))
{
FolderDeviceNode * pDevNode = new FolderDeviceNode;
if (pDevNode)
{
// the buffers in FolderDeviceNode are MAX_PATH
// wide, so we can only copy MAX_PATH - 1 chars
// and still have room for the terminating null
//
CONST SIZE_T cchMax = MAX_PATH - 1;
Assert(bstrUDN);
wcscpy(pDevNode->pszUDN, L"");
wcsncat(pDevNode->pszUDN,(PWSTR)bstrUDN,cchMax);
Assert(bstrDisplayName);
wcscpy(pDevNode->pszDisplayName, L"");
wcsncat(pDevNode->pszDisplayName,(PWSTR)bstrDisplayName,cchMax);
Assert(bstrType);
wcscpy(pDevNode->pszType, L"");
wcsncat(pDevNode->pszType,(PWSTR)bstrType,cchMax);
wcscpy(pDevNode->pszPresentationURL, L"");
if (bstrPresentationURL)
{
wcsncat(pDevNode->pszPresentationURL,
(PWSTR)bstrPresentationURL,
cchMax);
}
wcscpy(pDevNode->pszDescription, L"");
if (bstrDescription)
{
wcsncat(pDevNode->pszDescription,
(PWSTR)bstrDescription,
cchMax);
}
hr = HrMakeUPnPDevicePidl(pDevNode, ppidl);
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
TraceTag(ttidShellFolder, "Failed in pDevice->get_Description from HrMakeUPnPDevicePidl");
}
}
else
{
TraceTag(ttidShellFolder, "Failed in pDevice->get_PresentationURL from HrMakeUPnPDevicePidl");
}
}
else
{
TraceTag(ttidShellFolder, "Failed in pDevice->get_Type from HrMakeUPnPDevicePidl");
}
}
else
{
TraceTag(ttidShellFolder, "Failed in pDevice->get_FriendlyName from HrMakeUPnPDevicePidl");
}
}
else
{
TraceTag(ttidShellFolder, "Failed in pDevice->get_UniqueDeviceName from HrMakeUPnPDevicePidl");
}
SysFreeString(bstrUDN);
SysFreeString(bstrDisplayName);
SysFreeString(bstrPresentationURL);
SysFreeString(bstrType);
SysFreeString(bstrDescription);
ReleaseObj(pDevice);
TraceError("CUPnPDeviceFolder::HrMakeUPnPDevicePidl", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::ParseDisplayName
//
// Purpose: Translates a file object or folder's display name into an
// item identifier.
//
// Arguments:
// hwndOwner [in] Handle of owner window
// pbcReserved [in] Reserved
// lpszDisplayName [in] Pointer to diplay name
// pchEaten [out] Pointer to value for parsed characters
// ppidl [out] Pointer to new item identifier list
// pdwAttributes [out] Address receiving attributes of file object
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise
//
// Author: tongl 16 Feb 2000
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::ParseDisplayName(
HWND hwndOwner,
LPBC pbcReserved,
LPOLESTR lpszDisplayName,
ULONG * pchEaten,
LPITEMIDLIST * ppidl,
ULONG * pdwAttributes)
{
TraceTag(ttidShellFolderIface, "CUPnPDeviceFolder::ParseDisplayName");
HRESULT hr = S_OK;
// note: this is bogus, but we're doing this all over...
Assert(lpszDisplayName);
Assert(ppidl);
*ppidl = NULL;
// first, make sure that this is one of our display names:
// it must start with c_szDelegateFolderPrefix
//
int result;
result = wcsncmp(lpszDisplayName,
c_szDelegateFolderPrefix,
c_cchDelegateFolderPrefix);
if (0 == result)
{
LPCWSTR pszUdn = NULL;
LPITEMIDLIST pidlDevice = NULL;
FolderDeviceNode * pDeviceNode = NULL;
// this is OK since lpszDisplayName is an LPOLESTR
pszUdn = lpszDisplayName + c_cchDelegateFolderPrefix;
// search our list of devices and try to find a matching UDN
if (g_CListFolderDeviceNode.FFind(pszUdn, &pDeviceNode))
{
Assert(pDeviceNode);
// yes, this is one of our devices, construct the pidl using
// the allocator we are given
hr = HrMakeUPnPDevicePidl(pDeviceNode, &pidlDevice);
if (SUCCEEDED(hr))
{
Assert(pidlDevice);
*ppidl = pidlDevice;
if (pdwAttributes)
{
*pdwAttributes = 0;
}
}
}
else
{
// no, we don't have such a device in the list
// (tongl): try to do a SearchByUDN before we fail the call,
// as this may be a device discovered by the search from the
// tray icon, and we are asked for the pidl to create a shortcut.
BSTR bstrUdn = NULL;
IUPnPDeviceFinder * pdf = NULL;
bstrUdn = ::SysAllocString(pszUdn);
if (bstrUdn)
{
hr = CoCreateInstance(CLSID_UPnPDeviceFinder, NULL, CLSCTX_INPROC_SERVER,
IID_IUPnPDeviceFinder, (LPVOID *)&pdf);
if (SUCCEEDED(hr))
{
IUPnPDevice * pdev = NULL;
hr = pdf->FindByUDN(bstrUdn, &pdev);
if (S_OK == hr)
{
hr = HrMakeUPnPDevicePidl(pdev, &pidlDevice);
ReleaseObj(pdev);
}
ReleaseObj(pdf);
}
::SysFreeString(bstrUdn);
}
else
{
hr = E_OUTOFMEMORY;
TraceError("CUPnPDeviceFolder::ParseDisplayName: "
"SysAllocString", hr);
}
}
}
else
{
TraceTag(ttidShellFolderIface,
"CUPnPDeviceFolder::ParseDisplayName: "
"passed non-upnp display name");
hr = E_FAIL;
}
TraceHr(ttidShellFolder, FAL, hr, FALSE, "CUPnPDeviceFolder::ParseDisplayName");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::EnumObjects
//
// Purpose: Determines the contents of a folder by creating an item
// enumeration object (a set of item identifiers) that can be
// retrieved using the IEnumIDList interface.
//
// Arguments:
// hwndOwner [in] Handle of owner window
// grfFlags [in] Items to include in enumeration
// ppenumIDList [out] Pointer to IEnumIDList
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::EnumObjects(
HWND hwndOwner,
DWORD grfFlags,
LPENUMIDLIST * ppenumIDList)
{
HRESULT hr = NOERROR;
Assert(ppenumIDList);
*ppenumIDList = NULL;
if ((grfFlags & SHCONTF_FOLDERS) && !(grfFlags & SHCONTF_NONFOLDERS))
{
// if shell wants to enumerate only folders, we don't return anything
hr = E_NOTIMPL;
}
else
{
// Create the IEnumIDList object (CUPnPDeviceFolderEnum)
//
hr = CUPnPDeviceFolderEnum::CreateInstance (
IID_IEnumIDList,
reinterpret_cast<void**>(ppenumIDList));
if (SUCCEEDED(hr))
{
Assert(*ppenumIDList);
// Call the PidlInitialize function to allow the enumeration
// object to copy the list.
//
reinterpret_cast<CUPnPDeviceFolderEnum *>(*ppenumIDList)->Initialize(
m_pidlFolderRoot, this);
}
else
{
// On all failures, this should be NULL.
if (*ppenumIDList)
{
ReleaseObj(*ppenumIDList);
}
*ppenumIDList = NULL;
}
}
TraceHr(ttidError, FAL, hr, FALSE, "CUPnPDeviceFolder::EnumObjects");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::BindToObject
//
// Purpose: Creates an IShellFolder object for a subfolder.
//
// Arguments:
// pidl [in] Pointer to an ITEMIDLIST
// pbcReserved [in] Reserved - specify NULL
// riid [in] Interface to return
// ppvOut [out] Address that receives interface pointer;
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise
//
// Author: jeffspr 18 Oct 1997
//
// Notes: We don't need this function, since we don't have subfolders.
//
STDMETHODIMP CUPnPDeviceFolder::BindToObject(
LPCITEMIDLIST pidl,
LPBC pbcReserved,
REFIID riid,
LPVOID * ppvOut)
{
HRESULT hr = E_NOTIMPL;
// Note - If we add code here, then we ought to param check pidl
//
Assert(pidl);
*ppvOut = NULL;
TraceHr(ttidShellFolder, FAL, hr, FALSE, "CUPnPDeviceFolder::BindToObject");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::BindToStorage
//
// Purpose: Reserved for a future use. This method should
// return E_NOTIMPL.
//
// Arguments:
// pidl [] Pointer to an ITEMIDLIST
// pbcReserved [] Reserved<65>specify NULL
// riid [] Interface to return
// ppvObj [] Address that receives interface pointer);
//
// Returns: E_NOTIMPL always
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::BindToStorage(
LPCITEMIDLIST pidl,
LPBC pbcReserved,
REFIID riid,
LPVOID * ppvObj)
{
HRESULT hr = E_NOTIMPL;
// Note - If we add code here, then we ought to param check pidl
//
Assert(pidl);
*ppvObj = NULL;
TraceHr(ttidShellFolder, FAL, hr, FALSE, "CUPnPDeviceFolder::BindToStorage");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::CompareIDs
//
// Purpose: Determines the relative ordering of two file objects or
// folders, given their item identifier lists.
//
// Arguments:
// lParam [in] Type of comparison to perform
// pidl1 [in] Address of ITEMIDLIST structure
// pidl2 [in] Address of ITEMIDLIST structure
//
// Returns: Returns a handle to a result code. If this method is
// successful, the CODE field of the status code (SCODE) has
// the following meaning:
//
// CODE field Meaning
// ---------- -------
// Less than zero The first item should precede the second
// (pidl1 < pidl2).
// Greater than zero The first item should follow the second
// (pidl1 > pidl2)
// Zero The two items are the same (pidl1 = pidl2)
//
// Author: jeffspr 18 Oct 1997
//
// Notes: Passing 0 as the lParam indicates sort by name.
// 0x00000001-0x7fffffff are for folder specific sorting rules.
// 0x80000000-0xfffffff are used the system.
//
STDMETHODIMP CUPnPDeviceFolder::CompareIDs(
LPARAM lParam,
LPCITEMIDLIST pidl1,
LPCITEMIDLIST pidl2)
{
HRESULT hr = S_OK;
PUPNPDEVICEFOLDPIDL pupdfp1 = NULL;
PUPNPDEVICEFOLDPIDL pupdfp2 = NULL;
CUPnPDeviceFoldPidl udfp1;
CUPnPDeviceFoldPidl udfp2;
LPCWSTR psz1;
LPCWSTR psz2;
CONST INT ciTieBreaker = -1;
int iCompare = 0;
int result;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::CompareIDs");
// Make sure that the pidls passed in are our pidls.
//
if (!FIsUPnPDeviceFoldPidl(pidl1) || !FIsUPnPDeviceFoldPidl(pidl2))
{
hr = E_INVALIDARG;
goto Exit;
}
pupdfp1 = ConvertToUPnPDevicePIDL(pidl1);
pupdfp2 = ConvertToUPnPDevicePIDL(pidl2);
hr = udfp1.HrInit(pupdfp1);
if (FAILED(hr))
{
goto Exit;
}
hr = udfp2.HrInit(pupdfp2);
if (FAILED(hr))
{
goto Exit;
}
// We use the following procedure to compare PIDLs:
// 1. If two UDNs are the same, the PIDLs are the same
// 2. Otherwise, the PIDLs _must_ be different, and
// A. will be sorted based on the desired column
// B. If the column text matches, we'll return
// ciTieBreaker (-1), so that the PIDLs are
// distinguished.
//
psz1 = udfp1.PszGetUDNPointer();
psz2 = udfp2.PszGetUDNPointer();
Assert(psz1 && psz2);
result = wcscmp(psz1, psz2);
if (0 == result)
{
// The UDNs match, these are effectively the same PIDL
TraceTag(ttidShellFolder, "CUPnPDeviceFolder::CompareIDs: "
"UDN equal, automatically returning equality");
iCompare = 0;
}
else
{
// Sort based on the desired column
switch(lParam & SHCIDS_COLUMNMASK)
{
case ICOL_NAME:
psz1 = udfp1.PszGetNamePointer();
psz2 = udfp2.PszGetNamePointer();
break;
case ICOL_URL:
psz1 = udfp1.PszGetURLPointer();
psz2 = udfp2.PszGetURLPointer();
break;
case ICOL_UDN:
psz1 = udfp1.PszGetUDNPointer();
psz2 = udfp2.PszGetUDNPointer();
break;
case ICOL_TYPE:
psz1 = udfp1.PszGetTypePointer();
psz2 = udfp2.PszGetTypePointer();
break;
default:
AssertSz(FALSE, "Sorting on unknown category");
break;
}
Assert(psz1 && psz2);
iCompare = _wcsicmp(psz1, psz2);
// Ensure that we don't return equality
if (0 == iCompare)
{
TraceTag(ttidShellFolder, "CUPnPDeviceFolder::CompareIDs: "
"UDNs unequal but column-text equal, breaking tie");
iCompare = ciTieBreaker;
}
}
if (SUCCEEDED(hr))
{
hr = ResultFromShort(iCompare);
}
TraceTag(ttidShellFolder, "CUPnPDeviceFolder::CompareIDs: returning %d", iCompare);
Exit:
TraceHr(ttidError, FAL, hr, SUCCEEDED(hr), "CUPnPDeviceFolder::CompareIDs");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::CreateViewObject
//
// Purpose: Creates a view object of a folder.
//
// Arguments:
// hwndOwner [in] Handle of owner window
// riid [in] Interface identifier
// ppvOut [none] Reserved
//
// Returns: Returns NOERROR if successful or an OLE defined error
// value otherwise.
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::CreateViewObject(
HWND hwndOwner,
REFIID riid,
LPVOID * ppvOut)
{
HRESULT hr = E_NOINTERFACE;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::CreateViewObject");
Assert(ppvOut);
// Pre-initialize the out param, per OLE guidelines
//
*ppvOut = NULL;
// (tongl) We are a delegate folder now, CreateViewObject is never called.
return E_NOTIMPL;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::GetAttributesOf
//
// Purpose: Retrieves the attributes that all passed-in objects (file
// objects or subfolders) have in common.
//
// Arguments:
// cidl [in] Number of file objects
// apidl [in] Pointer to array of pointers to ITEMIDLIST structures
// rgfInOut [out] Address of value containing attributes of the
// file objects
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise.
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::GetAttributesOf(
UINT cidl,
LPCITEMIDLIST * apidl,
ULONG * rgfInOut)
{
HRESULT hr = S_OK;
ULONG rgfMask = 0;
PUPNPDEVICEFOLDPIDL pupdfp = NULL;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::GetAttributesOf");
if (cidl > 0)
{
// Prepopulate with all values (removed CANCOPY and CANMOVE)
//
rgfMask = /* SFGAO_CANDELETE | */ // Don't support delete
SFGAO_CANRENAME |
SFGAO_CANLINK |
SFGAO_HASPROPSHEET;
// Disable propsheets for > 1 object
//
if (cidl > 1)
{
rgfMask &= ~SFGAO_HASPROPSHEET;
}
}
else
{
// Apparently, we're called with 0 objects to indicate that we're
// supposed to return flags for the folder itself, not an individual
// object. Weird.
rgfMask = SFGAO_CANCOPY |
SFGAO_CANDELETE |
SFGAO_CANMOVE |
SFGAO_CANRENAME;
}
if (SUCCEEDED(hr))
{
*rgfInOut &= rgfMask;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::GetUIObjectOf
//
// Purpose: Creates a COM object that can be used to carry out actions
// on the specified file objects or folders, typically, to
// create context menus or carry out drag-and-drop operations.
//
// Arguments:
// hwndOwner [in] Handle to owner window
// cidl [in] Number of objects specified in apidl
// apidl [in] Pointer to an array of pointers to an ITEMIDLIST
// riid [in] Interface to return
// prgfInOut [none] Reserved
// ppvOut [out] Address to receive interface pointer
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::GetUIObjectOf(
HWND hwndOwner,
UINT cidl,
LPCITEMIDLIST * apidl,
REFIID riid,
UINT * prgfInOut,
LPVOID * ppvOut)
{
HRESULT hr = E_NOINTERFACE;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::GetUIObjectOf");
if (cidl >= 1)
{
Assert(apidl);
Assert(apidl[0]);
Assert(ppvOut);
if (riid == IID_IDataObject)
{
// Need to initialize so the SUCCEEED check below doesn't fail.
//
hr = S_OK;
Assert(m_pidlFolderRoot);
if (SUCCEEDED(hr))
{
Assert(m_pidlFolderRoot);
// Internal IDataObject impl removed. Replaced with common
// shell code.
//
hr = CIDLData_CreateFromIDArray(m_pidlFolderRoot, cidl, apidl, (IDataObject **) ppvOut);
}
}
else if (riid == IID_IContextMenu)
{
// Create our context menu object if only one device is selected
//
hr = CUPnPDeviceFolderContextMenu::CreateInstance (
IID_IContextMenu,
reinterpret_cast<void**>(ppvOut),
CMT_OBJECT,
hwndOwner,
cidl,
apidl,
this);
if (SUCCEEDED(hr))
{
Assert(*ppvOut);
}
else
{
hr = E_NOINTERFACE;
}
}
else if (riid == IID_IExtractIconA || riid == IID_IExtractIconW)
{
if (cidl == 1)
{
hr = CUPnPDeviceFolderExtractIcon::CreateInstance (
apidl[0],
riid,
reinterpret_cast<void**>(ppvOut));
if(SUCCEEDED(hr))
{
hr = reinterpret_cast<CUPnPDeviceFolderExtractIcon *>
(*ppvOut)->Initialize((LPITEMIDLIST)apidl[0]);
}
if (SUCCEEDED(hr))
{
Assert(*ppvOut);
}
}
else
{
hr = E_NOINTERFACE;
}
}
else if (riid == IID_IDropTarget)
{
// We don't support drag/drop
//
hr = E_NOINTERFACE;
}
else if (riid == IID_IQueryInfo)
{
if (cidl == 1)
{
// Create the IQueryInfo interface
hr = CUPnPDeviceFolderQueryInfo::CreateInstance (
IID_IQueryInfo,
reinterpret_cast<void**>(ppvOut));
if (SUCCEEDED(hr))
{
Assert(*ppvOut);
reinterpret_cast<CUPnPDeviceFolderQueryInfo *>
(*ppvOut)->PidlInitialize((LPITEMIDLIST)apidl[0]);
// Normalize return code
//
hr = NOERROR;
}
}
else
{
AssertSz(FALSE, "GetUIObjectOf asked for query info for more than one item!");
hr = E_NOINTERFACE;
}
}
else
{
TraceTag(ttidShellFolder, "CUPnPDeviceFolder::GetUIObjectOf asked for object "
"that it didn't know how to create. 0x%08x", riid.Data1);
hr = E_NOINTERFACE;
}
}
if (FAILED(hr))
{
*ppvOut = NULL;
}
TraceHr(ttidError, FAL, hr, (hr == E_NOINTERFACE), "CUPnPDeviceFolder::GetUIObjectOf");
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrTszToStrRet
//
// Purpose: Convert a TCHAR string to a STRRET, depending on the platform
//
// Arguments:
// pszName [in] input string
// pStrRet [in/out] output STRRET
//
// Returns:
//
// Author: jeffspr 25 Jan 2000
//
// Notes:
//
HRESULT HrTszToStrRet(LPCTSTR pszName, STRRET *pStrRet)
{
HRESULT hr = S_OK;
#ifdef UNICODE
pStrRet->uType = STRRET_WSTR;
// Allocate a new POLESTR block, which the shell can then free,
// and copy the displayable portion to it.
//
hr = HrDupeShellString(
pszName,
&pStrRet->pOleStr);
#else
pStrRet->uType = STRRET_CSTR;
lstrcpyn(pStrRet->cStr, pszName, celems(pStrRet->cStr));
hr = S_OK;
#endif
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::GetDisplayNameOf
//
// Purpose: Retrieves the display name for the specified file object or
// subfolder, returning it in a STRRET structure.
//
// Arguments:
// pidl [in] Pointer to an ITEMIDLIST
// uFlags [in] Type of display to return
// lpName [out] Pointer to a STRRET structure
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise.
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::GetDisplayNameOf(
LPCITEMIDLIST pidl,
DWORD uFlags,
LPSTRRET lpName)
{
HRESULT hr = S_OK;
PCWSTR pwszStrToCopy = NULL;
PTSTR pszTemp = NULL;
PUPNPDEVICEFOLDPIDL pupdfp = NULL;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::GetDisplayNameOf");
Assert(pidl);
Assert(lpName);
if (!pidl || !lpName)
{
hr = E_INVALIDARG;
}
else if (FIsUPnPDeviceFoldPidl(pidl))
{
CUPnPDeviceFoldPidl udfp;
pupdfp = ConvertToUPnPDevicePIDL(pidl);
#ifdef DBG
// Throw these in here just so I can quickly peek at the values
// set while I'm dorking around in the debugger.
//
DWORD dwInFolder = (uFlags & SHGDN_INFOLDER);
DWORD dwForAddressBar = (uFlags & SHGDN_FORADDRESSBAR);
DWORD dwForParsing = (uFlags & SHGDN_FORPARSING);
#endif
if (uFlags & SHGDN_FORPARSING)
{
#if 0
AssertSz(FALSE, "SHGDN_FORPARSING support NYI in GetDisplayNameOf");
#endif
}
hr = udfp.HrInit(pupdfp);
if (SUCCEEDED(hr))
{
pwszStrToCopy = udfp.PszGetNamePointer();
Assert(pwszStrToCopy);
pszTemp = TszFromWsz(pwszStrToCopy);
if (!pszTemp)
{
hr = E_OUTOFMEMORY;
}
else
{
hr = HrTszToStrRet(pszTemp, lpName);
free((PVOID) pszTemp);
}
}
}
else
{
// not a valid connections pidl (neither Win2K nor Win98).
//
hr = E_INVALIDARG;
}
TraceHr(ttidError, FAL, hr, FALSE, "CUPnPDeviceFolder::GetDisplayNameOf");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CUPnPDeviceFolder::SetNameOf
//
// Purpose: Changes the name of a file object or subfolder, changing its
// item identifier in the process.
//
// Arguments:
// hwndOwner [in] Handle of owner window
// pidl [in] Pointer to an ITEMIDLIST structure
// lpszName [in] Pointer to string specifying new display name
// uFlags [in] Type of name specified in lpszName
// ppidlOut [out] Pointer to new ITEMIDLIST
//
// Returns: Returns NOERROR if successful or an OLE-defined error
// value otherwise.
//
// Author: jeffspr 18 Oct 1997
//
// Notes:
//
STDMETHODIMP CUPnPDeviceFolder::SetNameOf(
HWND hwndOwner,
LPCITEMIDLIST pidl,
LPCOLESTR lpszName,
DWORD uFlags,
LPITEMIDLIST * ppidlOut)
{
HRESULT hr = S_OK;
PUPNPDEVICEFOLDPIDL pupdfp = NULL;
TraceTag(ttidShellFolderIface, "OBJ: CUPnPDeviceFolder::SetNameOf");
Assert(hwndOwner);
Assert(pidl);
Assert(lpszName);
if (!pidl && !lpszName)
{
hr = E_INVALIDARG;
}
else if (!*lpszName)
{
hr = S_OK;
}
else if (FIsUPnPDeviceFoldPidl(pidl))
{
CUPnPDeviceFoldPidl udfp;
pupdfp = ConvertToUPnPDevicePIDL(pidl);
hr = udfp.HrInit(pupdfp);
if (SUCCEEDED(hr))
{
// Change the name of the item in the PIDL
hr = udfp.HrSetName(lpszName);
}
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidlOut;
// Persist the PIDL data to a new PIDL so we can generate an event
// for it
hr = udfp.HrPersist(m_pDelegateMalloc, &pidlOut);
if (SUCCEEDED(hr))
{
NAME_MAP * pnm;
pnm = new NAME_MAP;
if (pnm)
{
// Copy the name and UDN to a struct to keep in a list
// of mapped UDNs to friendly names.
//
pnm->szName = TszDupTsz(udfp.PszGetNamePointer());
if (!pnm->szName)
{
hr = E_OUTOFMEMORY;
}
else
{
pnm->szUdn = TszDupTsz(udfp.PszGetUDNPointer());
if (!pnm->szUdn)
{
hr = E_OUTOFMEMORY;
}
else
{
// Delete the item and re-add it again
g_CListNameMap.FDelete(udfp.PszGetUDNPointer());
g_CListNameMap.FAdd(pnm);
// Notify the shell of the rename
GenerateEvent(SHCNE_RENAMEITEM, m_pidlFolderRoot,
pidl, pidlOut);
FolderDeviceNode * pDeviceNode;
if (g_CListFolderDeviceNode.FFind(pnm->szUdn,
&pDeviceNode))
{
// Delete the node's old name and give it the new
// one
//
wcscpy(pDeviceNode->pszDisplayName,
pnm->szName);
}
}
}
}
else
{
hr = E_OUTOFMEMORY;
}
if (ppidlOut)
{
*ppidlOut = pidlOut;
}
else
{
FreeIDL(pidlOut);
}
}
}
}
else
{
// not a valid UPnP pidl
//
hr = E_INVALIDARG;
}
TraceHr(ttidError, FAL, hr, FALSE, "CUPnPDeviceFolder::SetNameOf");
return hr;
}
Reference in a new issue Copy permalink