windows-nt/Source/XPSP1/NT/shell/ext/cdfview/exticon.cpp

1606 lines
40 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// exticon.cpp
//
// IExtractIcon com object. Used by the shell to obtain icons.
//
// History:
//
// 3/21/97 edwardp Created.
//
////////////////////////////////////////////////////////////////////////////////
//
// Includes
//
#include "stdinc.h"
#include "resource.h"
#include "cdfidl.h"
#include "xmlutil.h"
#include "exticon.h"
#include "dll.h"
#include "persist.h"
//
// Constructor and destructor.
//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::CExtractIcon ***
//
// Constructor.
//
////////////////////////////////////////////////////////////////////////////////
CExtractIcon::CExtractIcon (
PCDFITEMIDLIST pcdfidl,
IXMLElementCollection *pIXMLElementCollection
)
: m_cRef(1)
{
ASSERT(CDFIDL_IsValid(pcdfidl));
ASSERT(ILIsEmpty(_ILNext((LPITEMIDLIST)pcdfidl)));
ASSERT(XML_IsCdfidlMemberOf(pIXMLElementCollection, pcdfidl));
ASSERT(NULL == m_bstrIconURL);
ASSERT(FALSE == m_fGleam);
//
// Set the default icon type.
//
if (CDFIDL_IsFolderId(&pcdfidl->mkid))
{
m_iconType = IDI_CLOSESUBCHANNEL;
}
else
{
m_iconType = IDI_STORY;
}
//
// Get the URL for the custom icon.
//
if (pIXMLElementCollection)
{
IXMLElement* pIXMLElement;
HRESULT hr;
if (CDFIDL_GetIndex(pcdfidl) != -1)
{
hr = XML_GetElementByIndex(pIXMLElementCollection,
CDFIDL_GetIndex(pcdfidl), &pIXMLElement);
}
else
{
IXMLElement *pIXMLElementChild;
hr = XML_GetElementByIndex(pIXMLElementCollection, 0, &pIXMLElementChild);
if (pIXMLElementChild)
{
hr = pIXMLElementChild->get_parent(&pIXMLElement);
if (!pIXMLElement)
{
ASSERT(FALSE);
hr = E_FAIL;
}
pIXMLElementChild->Release();
}
}
if (SUCCEEDED(hr))
{
ASSERT(pIXMLElement);
m_bstrIconURL = XML_GetAttribute(pIXMLElement, XML_ICON);
pIXMLElement->Release();
}
}
//
// Don't allow the DLL to unload.
//
TraceMsg(TF_OBJECTS, "+ IExtractIcon");
DllAddRef();
return;
}
// Used for initializing the Root Element
CExtractIcon::CExtractIcon (
PCDFITEMIDLIST pcdfidl,
IXMLElement *pElem
)
: m_cRef(1)
{
ASSERT(CDFIDL_IsValid(pcdfidl));
ASSERT(ILIsEmpty(_ILNext((LPITEMIDLIST)pcdfidl)));
ASSERT(NULL == m_bstrIconURL);
ASSERT(FALSE == m_fGleam);
//
// Set the default icon type.
//
m_iconType = IDI_CHANNEL;
//
// Get the URL for the custom icon.
//
if (pElem)
{
HRESULT hr;
IXMLElement *pDeskElem;
LONG nIndex;
hr = XML_GetDesktopElementFromChannelElement(pElem, &pDeskElem, &nIndex);
if (SUCCEEDED(hr))
{
m_iconType = IDI_DESKTOP;
pDeskElem->Release();
}
m_bstrIconURL = XML_GetAttribute(pElem, XML_ICON);
}
//
// Don't allow the DLL to unload.
//
TraceMsg(TF_OBJECTS, "+ IExtractIcon");
DllAddRef();
return;
}
// this constructor is used for the default channel case where
// we draw the icon information from the desktop.ini case
// to avoid having to parse the XML stuff
CExtractIcon::CExtractIcon( BSTR pstrPath ) : m_cRef(1)
{
ASSERT(NULL == m_bstrIconURL);
ASSERT(FALSE == m_fGleam);
m_iconType = IDI_CHANNEL;
m_bstrIconURL = SysAllocString( pstrPath );
DllAddRef();
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::~CExtractIcon ***
//
// Destructor.
//
////////////////////////////////////////////////////////////////////////////////
CExtractIcon::~CExtractIcon (
void
)
{
ASSERT(0 == m_cRef);
if (m_bstrIconURL)
SysFreeString(m_bstrIconURL);
//
// Matching Release for the constructor Addref.
//
TraceMsg(TF_OBJECTS, "- IExtractIcon");
DllRelease();
return;
}
//
// IUnknown methods.
//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::QueryInterface ***
//
// CExtractIcon QI.
//
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CExtractIcon::QueryInterface (
REFIID riid,
void **ppv
)
{
ASSERT(ppv);
HRESULT hr;
if (IID_IUnknown == riid || IID_IExtractIcon == riid)
{
AddRef();
*ppv = (IExtractIcon*)this;
hr = S_OK;
}
#ifdef UNICODE
else if (IID_IExtractIconA == riid)
{
AddRef();
*ppv = (IExtractIconA*)this;
hr = S_OK;
}
#endif
else
{
*ppv = NULL;
hr = E_NOINTERFACE;
}
ASSERT((SUCCEEDED(hr) && *ppv) || (FAILED(hr) && NULL == *ppv));
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::AddRef ***
//
// CExtractIcon AddRef.
//
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG)
CExtractIcon::AddRef (
void
)
{
ASSERT(m_cRef != 0);
ASSERT(m_cRef < (ULONG)-1);
return ++m_cRef;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::Release ***
//
// CExtractIcon Release.
//
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG)
CExtractIcon::Release (
void
)
{
ASSERT (m_cRef != 0);
ULONG cRef = --m_cRef;
if (0 == cRef)
delete this;
return cRef;
}
//
// IExtractIcon methods.
//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::GetIconLocation ***
//
//
// Description:
// Returns a name index pair for the icon associated with this cdf item.
//
// Parameters:
// [In] uFlags - GIL_FORSHELL, GIL_OPENICON.
// [Out] szIconFile - The address of the buffer that receives the associated
// icon name. It can be a filename, but doesn't have to
// be.
// [In] cchMax - Size of the buffer that receives the icon location.
// [Out] piIndex - A pointer that receives the icon's index.
// [Out] pwFlags - A pointer the receives flags about the icon.
//
// Return:
// S_OK if an was found.
// S_FALSE if the shell should supply a default icon.
//
// Comments:
// The shell can cache an icon associated with a name index pair. This
// improves performance on subsequent calls for an icon with the same name
// index pair.
//
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CExtractIcon::GetIconLocation(
UINT uFlags,
LPTSTR szIconFile,
UINT cchMax,
int *piIndex,
UINT *pwFlags
)
{
ASSERT(szIconFile);
ASSERT(piIndex);
ASSERT(pwFlags);
HRESULT hr = E_FAIL;
//TraceMsg(TF_CDFICON, "<IN> CExtractIcon::GetLocation (icon) tid:0x%x",
// GetCurrentThreadId());
if (m_bstrIconURL && (uFlags & GIL_ASYNC))
{
hr = E_PENDING;
}
else
{
if (m_bstrIconURL)
{
hr = GetCustomIconLocation(uFlags, szIconFile, cchMax, piIndex,
pwFlags);
if (FAILED(hr))
{
SysFreeString(m_bstrIconURL);
m_bstrIconURL = NULL;
}
}
if (FAILED(hr))
{
hr = GetDefaultIconLocation(uFlags, szIconFile, cchMax, piIndex,
pwFlags);
}
//
// If szIconFile is a path the shell will only use the filename part
// of the path as the cache index. To ensure a unique index the full
// path must be used. This is accomplished by modifying the path string
// so it is no longer recognized as a path.
//
if (SUCCEEDED(hr) && INDEX_IMAGE == *piIndex)
MungePath(szIconFile);
if (FAILED(hr))
{
*szIconFile = TEXT('\0');
*piIndex = 0;
hr = S_FALSE; // The shell will use a default icon.
}
ASSERT((S_OK == hr && *szIconFile) ||
(S_FALSE == hr && 0 == *szIconFile));
}
//TraceMsg(TF_CDFICON, "<OUT> CExtractIcon::GetLocation (icon) tid:0x%x",
// GetCurrentThreadId());
return hr;
}
#ifdef UNICODE
// IExtractIconA methods.
STDMETHODIMP
CExtractIcon::GetIconLocation(
UINT uFlags,
LPSTR szIconFile,
UINT cchMax,
int *piIndex,
UINT *pwFlags
)
{
HRESULT hr;
WCHAR* pszIconFileW = new WCHAR[cchMax];
if (pszIconFileW == NULL)
return ERROR_OUTOFMEMORY;
hr = GetIconLocation(uFlags, pszIconFileW, cchMax, piIndex, pwFlags);
if (SUCCEEDED(hr))
SHUnicodeToAnsi(pszIconFileW, szIconFile, cchMax);
delete [] pszIconFileW;
return hr;
}
#endif
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::Extract ***
//
//
// Description:
// Return an icon given the name index pair returned from GetIconLocation.
//
// Parameters:
// [In] pszFile - A pointer to the name associated with the requested
// icon.
// [In] nIconIndex - An index associated with the requested icon.
// [Out] phiconLarge - Pointer to the variable that receives the handle of
// the large icon.
// [Out] phiconSmall - Pointer to the variable that receives the handle of
// the small icon.
// [Out] nIconSize - Value specifying the size, in pixels, of the icon
// required. The LOWORD and HIWORD specify the size of
// the large and small icons, respectively.
//
// Return:
// S_OK if the icon was extracted.
// S_FALSE if the shell should extract the icon assuming the name is a
// filename and the index is the icon index.
//
// Comments:
// The shell may cache the icon returned from this function.
//
// If the icon index indicates that the icon is specified by an internet
// image then custom extraction is required.
//
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CExtractIcon::Extract(
LPCTSTR pszFile,
UINT nIconIndex,
HICON *phiconLarge,
HICON *phiconSmall,
UINT nIconSize
)
{
HRESULT hr;
TCHAR szPath[MAX_PATH];
TCHAR* pszPath = szPath;
StrCpyN(szPath, pszFile, ARRAYSIZE(szPath) - 1);
//TraceMsg(TF_CDFICON, "<IN> CExtractIcon::Extract (icon) tid:0x%x",
// GetCurrentThreadId());
if (INDEX_IMAGE == nIconIndex)
{
DemungePath(pszPath);
if (m_fGleam && *pszPath == TEXT('G'))
{
pszPath++;
}
IImgCtx* pIImgCtx;
HANDLE hExitThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (hExitThreadEvent)
{
#ifdef UNIX
unixEnsureFileScheme(pszPath);
#endif /* UNIX */
hr = SynchronousDownload(pszPath, &pIImgCtx, hExitThreadEvent);
if (SUCCEEDED(hr))
{
ASSERT(pIImgCtx);
*phiconLarge = ExtractImageIcon(LOWORD(nIconSize), pIImgCtx,
m_fGleam);
*phiconSmall = ExtractImageIcon(HIWORD(nIconSize), pIImgCtx,
m_fGleam);
pIImgCtx->Release();
}
SetEvent(hExitThreadEvent);
}
else
{
hr = E_OUTOFMEMORY;
}
}
else if (m_fGleam)
{
// Add gleam to icon for the shell
hr = ExtractGleamedIcon(pszPath + 1, nIconIndex, 0,
phiconLarge, phiconSmall, nIconSize);
}
else
{
hr = S_FALSE; // Let shell extract it.
}
//TraceMsg(TF_CDFICON, "<OUT> CExtractIcon::Extract (icon) tid:0x%x",
// GetCurrentThreadId());
return hr;
}
#ifdef UNICODE
STDMETHODIMP
CExtractIcon::Extract(
LPCSTR pszFile,
UINT nIconIndex,
HICON *phiconLarge,
HICON *phiconSmall,
UINT nIconSize)
{
HRESULT hr;
int cch = lstrlenA(pszFile) + 1;
WCHAR* pszFileW = new WCHAR[cch];
if (pszFileW == NULL)
return ERROR_OUTOFMEMORY;
SHAnsiToUnicode(pszFile, pszFileW, cch);
hr = Extract(pszFileW, nIconIndex, phiconLarge, phiconSmall, nIconSize);
delete [] pszFileW;
return hr;
}
#endif
//
// Helper functions.
//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::GetCustomIconLocation ***
//
//
// Description:
// Gets the location string name for an icon specified via a LOGO element
// in a cdf.
//
// Parameters:
// [In] uFlags - GIL_FORSHELL, GIL_OPENICON.
// [Out] szIconFile - The address of the buffer that receives the associated
// icon name.
// [In] cchMax - Size of the buffer that receives the icon location.
// [Out] piIndex - A pointer that receives the icon's index.
// [Out] pwFlags - A pointer the receives flags about the icon.
//
// Return:
// S_OK if the custom icon location was determined.
// E_FAIL if the location couldn't be determined.
//
// Comments:
// If the extension of the image url isn't .ico then it's treated as an
// internet image file. IImgCtx is used to convert these files into icons.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::GetCustomIconLocation(
UINT uFlags,
LPTSTR szIconFile,
UINT cchMax,
int *piIndex,
UINT *pwFlags
)
{
ASSERT(szIconFile);
ASSERT(piIndex);
ASSERT(pwFlags);
HRESULT hr;
ASSERT(m_bstrIconURL);
*piIndex = 0;
*pwFlags = 0;
TCHAR szURL[INTERNET_MAX_URL_LENGTH];
if (SHUnicodeToTChar(m_bstrIconURL, szURL, ARRAYSIZE(szURL)))
{
hr = URLGetLocalFileName(szURL, szIconFile, cchMax, NULL);
#ifdef DEBUG
if (SUCCEEDED(hr))
{
TraceMsg(TF_CDFICON, "[URLGetLocalFileName %s]", szIconFile);
}
else
{
TraceMsg(TF_CDFICON, "[URLGetLocalFileName %s FAILED]",
szURL);
}
#endif // DEBUG
//hr = URLDownloadToCacheFile(NULL, szURL, szIconFile, cchMax, 0, NULL);
if (SUCCEEDED(hr))
{
LPTSTR pszExt = PathFindExtension(szIconFile);
if (*pszExt != TEXT('.') || 0 != StrCmpI(pszExt, TSTR_ICO_EXT))
*piIndex = INDEX_IMAGE;
}
}
else
{
*szIconFile = TEXT('\0');
hr = E_FAIL;
}
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::GetDefaultIconLocation ***
//
//
// Description:
// Return the location of the defualt icon.
//
// Parameters:
// [In] uFlags - GIL_FORSHELL, GIL_OPENICON.
// [Out] szIconFile - The address of the buffer that receives the associated
// icon name.
// [In] cchMax - Size of the buffer that receives the icon location.
// [Out] piIndex - A pointer that receives the icon's index.
// [Out] pwFlags - A pointer the receives flags about the icon.
//
// Return:
// S_OK if the default location is returned.
// E_FAIL otherwise.
//
// Comments:
// The default icons are in the resource file.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::GetDefaultIconLocation(
UINT uFlags,
LPTSTR szIconFile,
UINT cchMax,
int *piIndex,
UINT *pwFlags
)
{
ASSERT(szIconFile);
ASSERT(piIndex);
ASSERT(pwFlags);
HRESULT hr;
*pwFlags = 0;
ASSERT(g_szModuleName[0]);
StrCpyN(szIconFile, g_szModuleName, cchMax);
if (*szIconFile)
{
switch (m_iconType)
{
case IDI_STORY:
case IDI_CHANNEL:
case IDI_DESKTOP:
*piIndex = - m_iconType;
break;
default:
*piIndex = (uFlags & GIL_OPENICON) ?
(-IDI_OPENSUBCHANNEL) :
(-IDI_CLOSESUBCHANNEL);
break;
}
hr = S_OK;
}
else
{
hr = E_FAIL;
}
ASSERT((SUCCEEDED(hr) && *szIconFile) || FAILED(hr));
return hr;
}
struct ThreadData
{
HANDLE hEvent;
HANDLE hExitThreadEvent;
IImgCtx * pImgCtx;
LPCWSTR pszBuffer;
HRESULT * pHr;
};
DWORD CALLBACK SyncDownloadThread( LPVOID pData )
{
ThreadData * pTD = (ThreadData * ) pData;
HANDLE hExitThreadEvent = pTD->hExitThreadEvent;
CoInitialize(NULL);
pTD->pImgCtx = NULL;
HRESULT hr;
hr = CoCreateInstance(CLSID_IImgCtx, NULL, CLSCTX_INPROC_SERVER,
IID_IImgCtx, (void**)&(pTD->pImgCtx));
if (SUCCEEDED(hr))
{
hr = pTD->pImgCtx->Load(pTD->pszBuffer, 0);
if (SUCCEEDED(hr))
{
ULONG fState;
SIZE sz;
pTD->pImgCtx->GetStateInfo(&fState, &sz, TRUE);
if (!(fState & (IMGLOAD_COMPLETE | IMGLOAD_ERROR)))
{
BOOL fDone = FALSE;
hr = pTD->pImgCtx->SetCallback(ImgCtx_Callback, &fDone);
if (SUCCEEDED(hr))
{
hr = pTD->pImgCtx->SelectChanges(IMGCHG_COMPLETE, 0, TRUE);
if (SUCCEEDED(hr))
{
MSG msg;
BOOL fMsg;
// HACK: restrict the message pump to those messages we know that URLMON and
// HACK: the imageCtx stuff needs, otherwise we will be pumping messages for
// HACK: windows we shouldn't be pumping right now...
while(!fDone )
{
fMsg = PeekMessage(&msg, NULL, WM_USER + 1, WM_USER + 4, PM_REMOVE );
if (!fMsg)
{
fMsg = PeekMessage( &msg, NULL, WM_APP + 2, WM_APP + 2, PM_REMOVE );
}
if (!fMsg)
{
// go to sleep until we get a new message....
WaitMessage();
continue;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
}
hr = pTD->pImgCtx->GetStateInfo(&fState, &sz, TRUE);
if (SUCCEEDED(hr))
hr = (fState & IMGLOAD_ERROR) ? E_FAIL : S_OK;
}
// Must disconnect on the same thread that SetCallback is
// done. This object becomes a primary object on the thread
// which connects the callback function. The primary object
// count is decremented when Disconnect is called, or when the
// object is released. In this case, the release is definitely
// going to happen on a different thread than this one, so we
// need to disconnect the callback function right now before
// returning. There is no further needs for callbacks at this
// point.
pTD->pImgCtx->Disconnect();
}
if ( FAILED( hr ) && pTD->pImgCtx )
{
pTD->pImgCtx->Release();
pTD->pImgCtx = NULL;
}
*(pTD->pHr) = hr;
SetEvent( pTD->hEvent );
//
// Wait for the calling thread to finish up with IImgCtx before
// CoUninitialize gets called.
//
WaitForSingleObject(hExitThreadEvent, INFINITE);
CloseHandle(hExitThreadEvent);
CoUninitialize();
return 0;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::SynchronousDownload ***
//
//
// Description:
// Synchronously downloads the image associated with the image context.
//
// Parameters:
// [In] szFile - The local (already in cache) file name of the
// image.
// [In] pIImgCtx - A pointer to the image context.
// [In] hExitThreadEvent - An event that gets signaled when the IImgCtx
// object is no longer in use.
//
// Return:
// S_OK if the image was successfully downloaded.
// E_FAIL if the image wasn't downloaded.
//
// Comments:
// The image context object doesn't directly support synchronous download.
// Here a message loop is used to make sure ulrmon keeps geeting messages
// and the download progresses.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::SynchronousDownload(
LPCTSTR pszFile,
IImgCtx** ppIImgCtx,
HANDLE hExitThreadEvent
)
{
ASSERT(ppIImgCtx);
HRESULT hr;
TraceMsg(TF_CDFPARSE, "[*** IImgCtx downloading logo %s ***]",
pszFile);
TraceMsg(TF_CDFICON, "[*** IImgCtx downloading logo %s ***]",
pszFile);
WCHAR szFileW[MAX_PATH];
SHTCharToUnicode(pszFile, szFileW, ARRAYSIZE(szFileW));
ThreadData rgData;
rgData.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
if ( rgData.hEvent == NULL )
{
CloseHandle(hExitThreadEvent);
return E_OUTOFMEMORY;
}
rgData.hExitThreadEvent = hExitThreadEvent;
rgData.pszBuffer = szFileW;
rgData.pHr = &hr;
*ppIImgCtx = NULL;
if ( SHCreateThread( SyncDownloadThread, &rgData, 0, NULL ))
{
WaitForSingleObject( rgData.hEvent, INFINITE );
*ppIImgCtx = rgData.pImgCtx;
}
else
{
CloseHandle(hExitThreadEvent);
hr = E_OUTOFMEMORY;
}
CloseHandle( rgData.hEvent );
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::ExtractImageIcon ***
//
//
// Description:
// Returns an HICON for the image in IImgCtx.
//
// Parameters:
// [In] wSize - The height and width of the icon,
// [In] pIImgCtx - The image to convert into an icon.
// [In] fDrawGleam - TRUE if a gleam should be added, FALSE otherwise.
//
// Return:
// An hicon of size nSize for the given IImgCtx.
// NULL on failure.
//
// Comments:
// Uses the image in IImgCtx to create bitmaps to pass to
// CreateIconIndirect.
//
////////////////////////////////////////////////////////////////////////////////
HICON
CExtractIcon::ExtractImageIcon(
WORD wSize,
IImgCtx* pIImgCtx,
BOOL fDrawGleam
)
{
ASSERT(pIImgCtx);
HICON hiconRet = NULL;
HDC hdcScreen = GetDC(NULL);
if (hdcScreen)
{
HBITMAP hbmImage = CreateCompatibleBitmap(hdcScreen, wSize, wSize);
if (hbmImage)
{
HBITMAP hbmMask = CreateBitmap(wSize, wSize, 1, 1, NULL);
if (hbmMask)
{
SIZE sz;
sz.cx = sz.cy = wSize;
if (SUCCEEDED(CreateImageAndMask(pIImgCtx, hdcScreen, &sz,
&hbmImage, &hbmMask,
fDrawGleam)))
{
ICONINFO ii;
ii.fIcon = TRUE;
ii.hbmMask = hbmMask;
ii.hbmColor = hbmImage;
hiconRet = CreateIconIndirect(&ii);
}
DeleteObject(hbmMask);
}
DeleteObject(hbmImage);
}
ReleaseDC(NULL, hdcScreen);
}
return hiconRet;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::CreateImageAndMask ***
//
//
// Description:
// Create the image and mask bitmaps that get used by CreateIconIndirect,
//
// Parameters:
// [In] IImgCtx - The internet image.
// [In] hdcScreen - The screen hdc.
// [In] pSize - The size of the image and mask bitmaps.
// [In Out] phbmImage - A pointer to the handle of the Image bitmap.
// [In Out] phbmMask - A pointer to the handle of the Mask bitmap.
// [In] fDrawGleam - TRUE if a gleam should be added, FALSE otherwise.
//
// Return:
// S_OK if the image and mask bitmaps where successfully created.
// E_FAIL if the image or mask couldn't be created.
//
// Comments:
// The image bitmap has the opaque section come through and the transparent
// sections set to black.
//
// The mask has the transparent sections set to 1 and the opaque sections to
// 0.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::CreateImageAndMask(
IImgCtx* pIImgCtx,
HDC hdcScreen,
SIZE* pSize,
HBITMAP* phbmImage,
HBITMAP* phbmMask,
BOOL fDrawGleam
)
{
ASSERT(pIImgCtx);
ASSERT(phbmImage);
ASSERT(phbmMask);
HRESULT hr = E_FAIL;
HDC hdcImgDst = CreateCompatibleDC(NULL);
if (hdcImgDst)
{
HGDIOBJ hbmOld = SelectObject(hdcImgDst, *phbmImage);
if (hbmOld)
{
if (ColorFill(hdcImgDst, pSize, COLOR1))
{
hr = StretchBltImage(pIImgCtx, pSize, hdcImgDst, fDrawGleam);
if (SUCCEEDED(hr))
{
hr = CreateMask(pIImgCtx, hdcScreen, hdcImgDst, pSize,
phbmMask, fDrawGleam);
}
}
SelectObject(hdcImgDst, hbmOld);
}
DeleteDC(hdcImgDst);
}
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::StretchBltImage ***
//
//
// Description:
// Stretches the image associated with IImgCtx to the given size and places
// the result in the given DC.
//
// Parameters:
// [In] pIImgCtx - The image context for the image.
// [In] pSize - The size of the resultant image.
// [In/Out] hdcDst - The destination DC of the stretch blt.
//
// Return:
// S_OK if the image was successfully resized into the destination DC.
// E_FAIL otherwise.
//
// Comments:
// The destination DC already has a bitmap of pSize selected into it.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::StretchBltImage(
IImgCtx* pIImgCtx,
const SIZE* pSize,
HDC hdcDst,
BOOL fDrawGleam
)
{
ASSERT(pIImgCtx);
ASSERT(hdcDst);
HRESULT hr;
SIZE sz;
ULONG fState;
hr = pIImgCtx->GetStateInfo(&fState, &sz, FALSE);
if (SUCCEEDED(hr))
{
hr = pIImgCtx->StretchBlt(hdcDst, 0, 0, pSize->cx, pSize->cy, 0, 0,
sz.cx, sz.cy, SRCCOPY);
ASSERT(SUCCEEDED(hr) && "Icon extraction pIImgCtx->StretchBlt failed!");
if (fDrawGleam)
{
hr = E_FAIL;
HANDLE hGleam = LoadImage(g_hinst, TEXT("ICONGLEAM"),
IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
if (hGleam)
{
if (DrawIconEx(hdcDst, 0, 0, (HICON)hGleam, pSize->cx, pSize->cy, 0, NULL,DI_NORMAL))
hr = S_OK;
DeleteObject(hGleam);
}
}
}
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::CreateMask ***
//
//
// Description:
// Creates the mask for an icon and also adjusts the image bitmap for use
// with the mask.
//
// Parameters:
// [In] pIImgCtx - The original image.
// [In] hdcScreen - A screen dc.
// [In/Out] hdc1 - The DC containing the image bitmap.
// [In] pSize - The size of the bitmaps.
// [In/Out] phbMask - A pointer to the handle of the mask bitmap
//
// Return:
// S_OK if the mask is properly constructed.
// E_FAIL otherwise.
//
// Comments:
// The mask is created by first drawing the original image into a bitmap
// with background COLOR1. Then the same image is drawn into another
// bitmap but this bitmap has background of COLOR2. These two bitmaps
// are XOR'ed and the opaque sections come out 0 while the transparent
// sections are COLOR1 XOR COLOR2.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::CreateMask(
IImgCtx* pIImgCtx,
HDC hdcScreen,
HDC hdc1,
const SIZE* pSize,
HBITMAP* phbMask,
BOOL fDrawGleam
)
{
ASSERT(hdc1);
ASSERT(pSize);
ASSERT(phbMask);
HRESULT hr = E_FAIL;
HDC hdc2 = CreateCompatibleDC(NULL);
if (hdc2)
{
HBITMAP hbm2 = CreateCompatibleBitmap(hdcScreen, pSize->cx, pSize->cy);
if (hbm2)
{
HGDIOBJ hbmOld2 = SelectObject(hdc2, hbm2);
if (hbmOld2)
{
ColorFill(hdc2, pSize, COLOR2);
hr = StretchBltImage(pIImgCtx, pSize, hdc2, fDrawGleam);
#ifndef UNIX
if (SUCCEEDED(hr) &&
BitBlt(hdc2, 0, 0, pSize->cx, pSize->cy, hdc1, 0, 0,
SRCINVERT))
{
if (GetDeviceCaps(hdcScreen, BITSPIXEL) <= 8)
{
//
// 6 is the XOR of the index for COLOR1 and the index
// for COLOR2.
//
SetBkColor(hdc2, PALETTEINDEX(6));
}
else
{
SetBkColor(hdc2, (COLORREF)(COLOR1 ^ COLOR2));
}
HDC hdcMask = CreateCompatibleDC(NULL);
if (hdcMask)
{
HGDIOBJ hbmOld = SelectObject(hdcMask, *phbMask);
if (hbmOld)
{
if (BitBlt(hdcMask, 0, 0, pSize->cx, pSize->cy, hdc2, 0,
0, SRCCOPY))
{
//
// RasterOP 0x00220326 does a copy of the ~mask bits
// of hdc1 and sets everything else to 0 (Black).
//
if (BitBlt(hdc1, 0, 0, pSize->cx, pSize->cy, hdcMask,
0, 0, 0x00220326))
{
hr = S_OK;
}
}
SelectObject(hdcMask, hbmOld);
}
DeleteDC(hdcMask);
}
}
#else
SetBkColor(hdc2, COLOR2);
HDC hdcMask = CreateCompatibleDC(NULL);
if (hdcMask)
{
HGDIOBJ hbmOld = SelectObject(hdcMask, *phbMask);
if (hbmOld)
{
if (BitBlt(hdcMask, 0, 0, pSize->cx, pSize->cy, hdc2, 0,
0, SRCCOPY))
{
//
// RasterOP 0x00220326 does a copy of the ~mask bits
// of hdc1 and sets everything else to 0 (Black).
//
if (BitBlt(hdc1, 0, 0, pSize->cx, pSize->cy, hdcMask,
0, 0, 0x00220326))
{
hr = S_OK;
}
}
SelectObject(hdcMask, hbmOld);
}
DeleteDC(hdcMask);
}
#endif /* UNIX */
SelectObject(hdc2, hbmOld2);
}
DeleteObject(hbm2);
}
DeleteDC(hdc2);
}
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** ImgCtx_Callback ***
//
//
// Description:
// Callback function for IImgCtx loads.
//
// Parameters:
// [In] pIImgCtx - Not Used.
// [Out] pfDone - Set to TRUE on this callback.
//
// Return:
// None.
//
// Comments:
// This callback gets called if IImgCtx is finished downloading an image.
// It is used in CExtractIcon and CIconHandler.
//
////////////////////////////////////////////////////////////////////////////////
void
CALLBACK
ImgCtx_Callback(
void* pIImgCtx,
void* pfDone
)
{
ASSERT(pfDone);
*(BOOL*)pfDone = TRUE;
return;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::ColorFill ***
//
//
// Description:
// Fills the given bitmap with the given color.
//
// Parameters:
// [In/Out] hdc - The hdc that contains the bitmap.
// [In] pSize - the size of the bitmap.
// [In] clr - The color used to fill in the bitmap.
//
// Return:
// TRUE if the bitmap was filled with color clr.
// FALSE if the itmap wasn't filled.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
CExtractIcon::ColorFill(
HDC hdc,
const SIZE* pSize,
COLORREF clr
)
{
ASSERT(hdc);
BOOL fRet = FALSE;
HBRUSH hbSolid = CreateSolidBrush(clr);
if (hbSolid)
{
HGDIOBJ hbOld = SelectObject(hdc, hbSolid);
if (hbOld)
{
PatBlt(hdc, 0, 0, pSize->cx, pSize->cy, PATCOPY);
fRet = TRUE;
SelectObject(hdc, hbOld);
}
DeleteObject(hbSolid);
}
return fRet;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::ExtractGleamedIcon ***
//
//
// Description:
// Extracts icon resources and applies gleams to them.
//
// Parameters:
// [In] pszIconFile - path to the icon
// [In] iIndex - index of icon with the file
// [In] uFlags - ignore, pass 0
// [Out] phiconLarge - HICON in large format with gleam
// [Out] phiconSmall - HICON in small format with gleam
//
// Return:
// S_OK if success
// S_FALSE if the file has no icons (or not the asked for icon)
// E_FAIL for files on a slow link.
// E_FAIL if cant access the file
// E_FAIL if gleam icon construction failed
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::ExtractGleamedIcon(
LPCTSTR pszIconFile,
int iIndex,
UINT uFlags,
HICON *phiconLarge,
HICON *phiconSmall,
UINT nIconSize)
{
HICON hIconLargeShell, hIconSmallShell;
HRESULT hr;
hr = Priv_SHDefExtractIcon(pszIconFile, iIndex, uFlags,
&hIconLargeShell, &hIconSmallShell, nIconSize);
if (FAILED(hr))
goto cleanup1;
if (hIconLargeShell)
{
hr = ApplyGleamToIcon(hIconLargeShell, LOWORD(nIconSize), phiconLarge);
if (FAILED(hr))
goto cleanup2;
}
if (hIconSmallShell)
{
hr = ApplyGleamToIcon(hIconSmallShell, HIWORD(nIconSize), phiconSmall);
if (FAILED(hr))
goto cleanup3;
}
cleanup3:
if (FAILED(hr) && *phiconLarge)
{
DestroyIcon(*phiconLarge);
*phiconLarge = NULL;
}
cleanup2:
if (hIconLargeShell)
DestroyIcon(hIconLargeShell);
if (hIconSmallShell)
DestroyIcon(hIconSmallShell);
cleanup1:
return hr;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CExtractIcon::ApplyGleamToIcon ***
//
//
// Description:
// Makes a gleamed version of an icon.
//
// Parameters:
// [In] hIcon - icon that needs to be gleamed
// [In] nSize - size of icon in pixels
// [Out] phGleamIcon - variable to contain the gleamed icon
//
//
// Return:
// S_OK if success
// E_FAIL if unsuccessful
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CExtractIcon::ApplyGleamToIcon(
HICON hIcon1,
ULONG nSize,
HICON *phGleamedIcon)
{
HRESULT hr = E_FAIL;
HICON hIcon2 = (HICON)LoadImage(g_hinst, TEXT("ICONGLEAM"), IMAGE_ICON,
nSize, nSize, 0);
if (hIcon2)
{
HDC dc = GetDC(NULL);
if (dc)
{
ICONINFO ii1, ii2;
if (GetIconInfo(hIcon1, &ii1) && GetIconInfo(hIcon2, &ii2))
{
HDC dcSrc = CreateCompatibleDC(dc);
if (dcSrc)
{
HDC dcDst = CreateCompatibleDC(dc);
if (dcDst)
{
HBITMAP bmMask = CreateBitmap(nSize, nSize, 1, 1, NULL);
if (bmMask)
{
HBITMAP bmImage = CreateCompatibleBitmap(dc, nSize,
nSize);
if (bmImage)
{
int cx1, cy1, cx2, cy2;
GetBitmapSize(ii1.hbmMask, &cx1, &cy1);
GetBitmapSize(ii2.hbmMask, &cx2, &cy2);
//
// Mask
//
HBITMAP hbmpOldDst = (HBITMAP)SelectObject(
dcDst,
bmMask);
HBITMAP hbmpOldSrc = (HBITMAP)SelectObject(
dcSrc,
ii1.hbmMask);
StretchBlt(dcDst, 0, 0, nSize, nSize, dcSrc, 0,
0, cx1, cy1, SRCCOPY);
SelectObject(dcSrc, ii2.hbmMask);
StretchBlt(dcDst, 0, 0, nSize, nSize, dcSrc, 0,
0, cx2, cy2, SRCAND);
//
// Image.
//
SelectObject(dcDst, bmImage);
SelectObject(dcSrc, ii1.hbmColor);
StretchBlt(dcDst, 0, 0, nSize, nSize, dcSrc, 0,
0, cx1, cy1, SRCCOPY);
SelectObject(dcSrc, ii2.hbmMask);
StretchBlt(dcDst, 0, 0, nSize, nSize, dcSrc, 0,
0, cx2, cy2, SRCAND);
SelectObject(dcSrc, ii2.hbmColor);
StretchBlt(dcDst, 0, 0, nSize, nSize, dcSrc, 0,
0, cx2, cy2, SRCINVERT);
ii1.hbmMask = bmMask;
ii1.hbmColor = bmImage;
*phGleamedIcon = CreateIconIndirect(&ii1);
if (*phGleamedIcon)
hr = S_OK;
SelectObject(dcSrc, hbmpOldSrc);
SelectObject(dcDst, hbmpOldDst);
DeleteObject(bmImage);
}
DeleteObject(bmMask);
}
DeleteDC(dcDst);
}
DeleteDC(dcSrc);
}
}
ReleaseDC(NULL, dc);
}
DestroyIcon(hIcon2);
}
return hr;
}
//
// Get the size of the given bitmap.
//
BOOL
CExtractIcon::GetBitmapSize(HBITMAP hbmp, int* pcx, int* pcy)
{
BOOL fRet;
BITMAP bm;
if (GetObject(hbmp, sizeof(bm), &bm))
{
*pcx = bm.bmWidth;
*pcy = bm.bmHeight;
fRet = TRUE;
}
else
{
fRet = FALSE;
}
return fRet;
}
//
// Replace '\' with '*' so the path is nolonger a recognized path name. This
// is done in-place and can be called multiple times on the same string.
//
void
MungePath(LPTSTR pszPath)
{
ASSERT(pszPath);
while(*pszPath)
{
if (TEXT(FILENAME_SEPARATOR) == *pszPath)
*pszPath = TEXT('*');
pszPath++;
}
return;
}
//
// Replace '*' with '\'.
//
void
DemungePath(LPTSTR pszPath)
{
ASSERT(pszPath);
while(*pszPath)
{
if (TEXT('*') == *pszPath)
*pszPath = TEXT(FILENAME_SEPARATOR);
pszPath++;
}
return;
}