1410 lines
49 KiB
C++
1410 lines
49 KiB
C++
#include "shellprv.h"
|
|
#include "filefldr.h"
|
|
#include "ids.h"
|
|
#include "prop.h"
|
|
#include "copy.h"
|
|
|
|
// If these values are modified, the logic in Extract() must be modified too.
|
|
#define SMALLEST_THUMBNAIL_WITH_4_PREVIEWS 96
|
|
#define MAX_MINIPREVIEWS_COLLECT 8 // collect more than we're going to show, just in case one fails
|
|
#define MAX_MINIPREVIEWS 4
|
|
|
|
#define FOLDER_GUID TEXT("{A42CD7B6-E9B9-4D02-B7A6-288B71AD28BA}")
|
|
|
|
// Function in defview
|
|
void SHGetThumbnailSize(SIZE *psize);
|
|
|
|
typedef enum
|
|
{
|
|
MINIPREVIEW_LAYOUT_1 = 0,
|
|
MINIPREVIEW_LAYOUT_4 = 1,
|
|
} MINIPREVIEW_LAYOUT;
|
|
|
|
// The size of the mini-thumbnails for each thumbnail size. For each thumbnail
|
|
// size, there is a mini-thumbnail size for single layout and 2x2 layout.
|
|
LONG const alFolder120MinipreviewSize[] = {104, 48};
|
|
LONG const alFolder96MinipreviewSize[] = {82, 40};
|
|
LONG const alFolder80MinipreviewSize[] = {69, 32};
|
|
|
|
// These are the margins at which the mini-thumbnails appear within the main thumbnail.
|
|
// For thumbnails with only one large minipreview, we can just use x1,y1.
|
|
LONG const alFolder120MinipreviewOffsets[] = { 8, 64, 13, 67 }; // x1, x2, y1, y2
|
|
LONG const alFolder96MinipreviewOffsets[] = { 7, 49, 11, 52 }; // x1, x2, y1, y2
|
|
LONG const alFolder80MinipreviewOffsets[] = { 5, 42, 9, 45 }; // x1, x2, y1, y2
|
|
|
|
|
|
void FreeMiniPreviewPidls(LPITEMIDLIST apidlPreviews[], UINT cpidlPreviews);
|
|
|
|
// Helper functions
|
|
MINIPREVIEW_LAYOUT _GetMiniPreviewLayout(SIZE size);
|
|
void _GetMiniPreviewLocations(MINIPREVIEW_LAYOUT uLayout, SIZE sizeRequested, SIZE *psizeFolderBmp,
|
|
POINT aptOrigins[], SIZE *psizeMiniPreview);
|
|
HRESULT _DrawMiniPreviewBackground(HDC hdc, SIZE sizeFolderBmp, BOOL fAlpha, BOOL* pIsAlpha, RGBQUAD *prgb);
|
|
HBITMAP _CreateDIBSection(HDC hdcBmp, int cx, int cy);
|
|
HRESULT _CreateMainRenderingDC(HDC* phdc, HBITMAP* phBmpThumbnail, HBITMAP* phbmpOld, int cx, int cy, RGBQUAD** pprgb);
|
|
void _DestroyMainRenderingDC(HDC hdc, HBITMAP hbmpOld);
|
|
HRESULT _AddBitmap(HDC hdc, HBITMAP hbmpSub, POINT ptMargin, SIZE sizeDest, SIZE sizeSource, BOOL fAlphaSource, BOOL fAlphaDest, RGBQUAD *prgbDest, SIZE cxFolderSize);
|
|
|
|
// The files that can serve as thumbnails for folders:
|
|
const LPCWSTR c_szFolderThumbnailPaths[] = { L"folder.jpg", L"folder.gif" };
|
|
|
|
// We always have four now.
|
|
MINIPREVIEW_LAYOUT _GetMiniPreviewLayout(SIZE size)
|
|
{
|
|
return MINIPREVIEW_LAYOUT_4;
|
|
}
|
|
|
|
|
|
void FreeMiniPreviewPidls(LPITEMIDLIST apidlPreviews[], UINT cpidlPreviews)
|
|
{
|
|
for (UINT u = 0; u < cpidlPreviews; u++)
|
|
{
|
|
ILFree(apidlPreviews[u]);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* In: uLayout - The layout (1 or 4 mini previews)
|
|
* sizeRequested - The size of the thumbnail we are trying to generate
|
|
*
|
|
* Out:
|
|
* -psizeFolderBmp is set to
|
|
* the size of the bitmap.
|
|
*
|
|
* -aptOrigins array is filled in with the locations of the n minipreviews
|
|
* (note, aptOrigins is assumed to have MAX_MINIPREVIEWS cells)
|
|
* The size of the minipreviews (square) is returned in pSizeMinipreview;
|
|
*/
|
|
void _GetMiniPreviewLocations(MINIPREVIEW_LAYOUT uLayout, SIZE sizeRequested, SIZE *psizeFolderBmp,
|
|
POINT aptOrigins[], SIZE *psizeMiniPreview)
|
|
{
|
|
|
|
const LONG *alOffsets;
|
|
LONG lSize; // One of the standard sizes, that we have a folder bitmap for.
|
|
LONG lSmallestDimension = min(sizeRequested.cx, sizeRequested.cy);
|
|
|
|
if (lSmallestDimension > 96) // For stuff bigger than 96, we use the 120 size
|
|
{
|
|
lSize = 120;
|
|
alOffsets = alFolder120MinipreviewOffsets;
|
|
psizeMiniPreview->cx = psizeMiniPreview->cy = alFolder120MinipreviewSize[uLayout];
|
|
}
|
|
else if (lSmallestDimension > 80) // For stuff bigger than 80, but <= 96, we use the 96 size.
|
|
{
|
|
lSize = 96;
|
|
alOffsets = alFolder96MinipreviewOffsets;
|
|
psizeMiniPreview->cx = psizeMiniPreview->cy = alFolder96MinipreviewSize[uLayout];
|
|
}
|
|
else // For stuff <= 80, we use 80.
|
|
{
|
|
lSize = 80;
|
|
alOffsets = alFolder80MinipreviewOffsets;
|
|
psizeMiniPreview->cx = psizeMiniPreview->cy = alFolder80MinipreviewSize[uLayout];
|
|
}
|
|
|
|
psizeFolderBmp->cx = psizeFolderBmp->cy = lSize;
|
|
|
|
COMPILETIME_ASSERT(4 == MAX_MINIPREVIEWS);
|
|
|
|
aptOrigins[0].x = alOffsets[0];
|
|
aptOrigins[0].y = alOffsets[2];
|
|
aptOrigins[1].x = alOffsets[1];
|
|
aptOrigins[1].y = alOffsets[2];
|
|
aptOrigins[2].x = alOffsets[0];
|
|
aptOrigins[2].y = alOffsets[3];
|
|
aptOrigins[3].x = alOffsets[1];
|
|
aptOrigins[3].y = alOffsets[3];
|
|
}
|
|
|
|
HBITMAP _CreateDIBSection(HDC h, int cx, int cy, RGBQUAD** pprgb)
|
|
{
|
|
BITMAPINFO bi = {0};
|
|
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
|
|
bi.bmiHeader.biWidth = cx;
|
|
bi.bmiHeader.biHeight = cy;
|
|
bi.bmiHeader.biPlanes = 1;
|
|
bi.bmiHeader.biBitCount = 32;
|
|
bi.bmiHeader.biCompression = BI_RGB;
|
|
|
|
return CreateDIBSection(h, &bi, DIB_RGB_COLORS, (void**)pprgb, NULL, 0);
|
|
}
|
|
|
|
// Pre multiplies alpha channel
|
|
void PreProcessDIB(int cx, int cy, RGBQUAD* pargb)
|
|
{
|
|
int cTotal = cx * cy;
|
|
for (int i = 0; i < cTotal; i++)
|
|
{
|
|
RGBQUAD* prgb = &pargb[i];
|
|
if (prgb->rgbReserved != 0)
|
|
{
|
|
prgb->rgbRed = ((prgb->rgbRed * prgb->rgbReserved) + 128) / 255;
|
|
prgb->rgbGreen = ((prgb->rgbGreen * prgb->rgbReserved) + 128) / 255;
|
|
prgb->rgbBlue = ((prgb->rgbBlue * prgb->rgbReserved) + 128) / 255;
|
|
}
|
|
else
|
|
{
|
|
*((DWORD*)prgb) = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Is there an alpha channel? Check for a non-zero alpha byte.
|
|
BOOL _HasAlpha(RECT rc, int cx, RGBQUAD *pargb)
|
|
{
|
|
for (int y = rc.top; y < rc.bottom; y++)
|
|
{
|
|
for (int x = rc.left; x < rc.right; x++)
|
|
{
|
|
int iOffset = y * cx;
|
|
if (pargb[x + iOffset].rgbReserved != 0)
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/** In:
|
|
* fAlpha: Do we want the folder background to have an alpha channel?
|
|
* sizeFolderBmp: size of the thumbnail
|
|
*
|
|
* Out:
|
|
* pIsAlpha: Did we get what we wanted, if we wanted an alpha channel?
|
|
* (e.g. we won't get it if we're in < 24bit mode.)
|
|
*/
|
|
HRESULT _DrawMiniPreviewBackground(HDC hdc, SIZE sizeFolderBmp, BOOL fAlpha, BOOL* pfIsAlpha, RGBQUAD *prgb)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
HICON hicon = (HICON)LoadImage(HINST_THISDLL, MAKEINTRESOURCE(IDI_FOLDER), IMAGE_ICON, sizeFolderBmp.cx, sizeFolderBmp.cy, 0);
|
|
|
|
if (hicon)
|
|
{
|
|
*pfIsAlpha = FALSE;
|
|
if (fAlpha)
|
|
{
|
|
// Try to blt an alpha channel icon into the dc
|
|
ICONINFO io;
|
|
if (GetIconInfo(hicon, &io))
|
|
{
|
|
BITMAP bm;
|
|
if (GetObject(io.hbmColor, sizeof(bm), &bm))
|
|
{
|
|
if (bm.bmBitsPixel == 32)
|
|
{
|
|
HDC hdcSrc = CreateCompatibleDC(hdc);
|
|
if (hdcSrc)
|
|
{
|
|
HBITMAP hbmpOld = (HBITMAP)SelectObject(hdcSrc, io.hbmColor);
|
|
|
|
BitBlt(hdc, 0, 0, sizeFolderBmp.cx, sizeFolderBmp.cy, hdcSrc, 0, 0, SRCCOPY);
|
|
|
|
// Preprocess the alpha
|
|
PreProcessDIB(sizeFolderBmp.cx, sizeFolderBmp.cy, prgb);
|
|
|
|
*pfIsAlpha = TRUE;
|
|
SelectObject(hdcSrc, hbmpOld);
|
|
DeleteDC(hdcSrc);
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteObject(io.hbmColor);
|
|
DeleteObject(io.hbmMask);
|
|
}
|
|
}
|
|
|
|
if (!*pfIsAlpha)
|
|
{
|
|
// Didn't create an alpha bitmap
|
|
// We're filling the background with background window color.
|
|
RECT rc = { 0, 0, (long)sizeFolderBmp.cx + 1, (long)sizeFolderBmp.cy + 1};
|
|
SHFillRectClr(hdc, &rc, GetSysColor(COLOR_WINDOW));
|
|
|
|
// Then drawing the icon on top.
|
|
DrawIconEx(hdc, 0, 0, hicon, sizeFolderBmp.cx, sizeFolderBmp.cy, 0, NULL, DI_NORMAL);
|
|
|
|
// This may have resulted in an alpha channel - we need to know. (If it
|
|
// did, then when we add a nonalpha minibitmap to this main one, we need to restore
|
|
// the nuked out alpha channel)
|
|
// Check if we have alpha (prgb is the bits for the DIB of size sizeFolderBmp):
|
|
rc.right = sizeFolderBmp.cx;
|
|
rc.bottom = sizeFolderBmp.cy;
|
|
*pfIsAlpha = _HasAlpha(rc, sizeFolderBmp.cx, prgb);
|
|
}
|
|
|
|
DestroyIcon(hicon);
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL DoesFolderContainLogo(LPCITEMIDLIST pidlFull)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
IPropertyBag * pPropBag;
|
|
if (SUCCEEDED(SHGetViewStatePropertyBag(pidlFull, VS_BAGSTR_EXPLORER, SHGVSPB_PERUSER | SHGVSPB_PERFOLDER, IID_PPV_ARG(IPropertyBag, &pPropBag))))
|
|
{
|
|
TCHAR szLogo[MAX_PATH];
|
|
szLogo[0] = 0;
|
|
if (SUCCEEDED(SHPropertyBag_ReadStr(pPropBag, TEXT("Logo"), szLogo, ARRAYSIZE(szLogo))) && szLogo[0])
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
pPropBag->Release();
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
BOOL DoesFolderContainFolderJPG(IShellFolder *psf, LPCITEMIDLIST pidl)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
// return false if there's not folder.jpg, or if folder.jpg is a folder (doh!)
|
|
IShellFolder *psfSubfolder;
|
|
|
|
// SHBTO can deal with NULL psf, he turns it into psfDesktop
|
|
if (SUCCEEDED(SHBindToObject(psf, IID_X_PPV_ARG(IShellFolder, pidl, &psfSubfolder))))
|
|
{
|
|
for (int i = 0; i < ARRAYSIZE(c_szFolderThumbnailPaths); i++)
|
|
{
|
|
DWORD dwFlags = SFGAO_FILESYSTEM | SFGAO_FOLDER;
|
|
LPITEMIDLIST pidlItem;
|
|
if (SUCCEEDED(psfSubfolder->ParseDisplayName(NULL, NULL, (LPOLESTR)c_szFolderThumbnailPaths[i], NULL, &pidlItem, &dwFlags)))
|
|
{
|
|
ILFree(pidlItem);
|
|
if ((dwFlags & (SFGAO_FILESYSTEM | SFGAO_FOLDER)) == SFGAO_FILESYSTEM)
|
|
{
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
psfSubfolder->Release();
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL _IsShortcutTargetACandidate(IShellFolder *psf, LPCITEMIDLIST pidlPreview, BOOL *pbTryCached)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
*pbTryCached = TRUE;
|
|
IShellLink *psl;
|
|
if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, &pidlPreview, IID_PPV_ARG_NULL(IShellLink, &psl))))
|
|
{
|
|
LPITEMIDLIST pidlTarget = NULL;
|
|
if (SUCCEEDED(psl->GetIDList(&pidlTarget)) && pidlTarget)
|
|
{
|
|
DWORD dwTargetFlags = SFGAO_FOLDER;
|
|
if (SUCCEEDED(SHGetNameAndFlags(pidlTarget, 0, NULL, 0, &dwTargetFlags)))
|
|
{
|
|
// return true if its not a folder, or if the folder contains a logo
|
|
// note that this is kinda like recursing into the below function again
|
|
bRet = (0 == (dwTargetFlags & SFGAO_FOLDER));
|
|
|
|
if (!bRet)
|
|
{
|
|
bRet = (DoesFolderContainLogo(pidlTarget) || DoesFolderContainFolderJPG(NULL, pidlTarget));
|
|
if (bRet)
|
|
{
|
|
// It's a logo folder, don't try the cached image.
|
|
*pbTryCached = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
ILFree(pidlTarget);
|
|
}
|
|
psl->Release();
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL _IsMiniPreviewCandidate(IShellFolder *psf, LPCITEMIDLIST pidl, BOOL *pbTryCached)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
DWORD dwAttr = SHGetAttributes(psf, pidl, SFGAO_FOLDER | SFGAO_LINK | SFGAO_FILESYSANCESTOR);
|
|
*pbTryCached = TRUE;
|
|
|
|
// if its a folder, check and see if its got a logo
|
|
// note that folder shortcuts will have both folder and link, and since we check folder first, we won't recurse into folder shortcuts
|
|
// dont do anything unless pidl is a folder on a real filesystem (i.e. dont walk into zip/cab)
|
|
if ((dwAttr & (SFGAO_FOLDER | SFGAO_FILESYSANCESTOR)) == (SFGAO_FOLDER | SFGAO_FILESYSANCESTOR))
|
|
{
|
|
LPITEMIDLIST pidlParent;
|
|
if (SUCCEEDED(SHGetIDListFromUnk(psf, &pidlParent)))
|
|
{
|
|
LPITEMIDLIST pidlFull;
|
|
if (SUCCEEDED(SHILCombine(pidlParent, pidl, &pidlFull)))
|
|
{
|
|
bRet = DoesFolderContainLogo(pidlFull);
|
|
ILFree(pidlFull);
|
|
}
|
|
ILFree(pidlParent);
|
|
}
|
|
|
|
if (!bRet)
|
|
{
|
|
// no logo image, check for a "folder.jpg"
|
|
// if its not there, then don't display pidl as a mini-preview, as it would recurse and produce dumb-looking 1/16 scale previews
|
|
bRet = DoesFolderContainFolderJPG(psf, pidl);
|
|
}
|
|
|
|
if (bRet)
|
|
{
|
|
// For logo folders, we don't look for a cached image (cached image won't have alpha, which we want)
|
|
*pbTryCached = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Only if its not a link, or if its a link to a valid candidate, then we can get its extractor
|
|
if (0 == (dwAttr & SFGAO_LINK) ||
|
|
_IsShortcutTargetACandidate(psf, pidl, pbTryCached))
|
|
{
|
|
IExtractImage *pei;
|
|
if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, &pidl, IID_X_PPV_ARG(IExtractImage, NULL, &pei))))
|
|
{
|
|
bRet = TRUE;
|
|
pei->Release();
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
// We return the bits to the dibsection in the dc, if asked for. We need this for preprocessing the alpha channel,
|
|
// if one exists.
|
|
HRESULT _CreateMainRenderingDC(HDC* phdc, HBITMAP* phbmp, HBITMAP* phbmpOld, int cx, int cy, RGBQUAD** pprgb)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
HDC hdc = GetDC(NULL);
|
|
|
|
if (hdc)
|
|
{
|
|
*phdc = CreateCompatibleDC(hdc);
|
|
if (*phdc)
|
|
{
|
|
RGBQUAD *prgbDummy;
|
|
*phbmp = _CreateDIBSection(*phdc, cx, cy, &prgbDummy);
|
|
if (*phbmp)
|
|
{
|
|
*phbmpOld = (HBITMAP) SelectObject(*phdc, *phbmp);
|
|
if (pprgb)
|
|
*pprgb = prgbDummy;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
DeleteDC(*phdc);
|
|
}
|
|
}
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
void _DestroyMainRenderingDC(HDC hdc, HBITMAP hbmpOld) // Unselects the bitmap, and deletes the Dc
|
|
{
|
|
if (hbmpOld)
|
|
SelectObject(hdc, hbmpOld);
|
|
DeleteDC(hdc);
|
|
}
|
|
|
|
|
|
|
|
// We just blt'd a nonalpha guy into an alpha'd bitmap. This nuked out the alpha channel.
|
|
// Repair it by setting alpha channel to 0xff (opaque).
|
|
void _SetAlpha(RECT rc, SIZE sizeBmp, RGBQUAD *pargb)
|
|
{
|
|
for (int y = (sizeBmp.cy - rc.bottom); y < (sizeBmp.cy - rc.top); y++) // Origin at bottom left.
|
|
{
|
|
int iOffset = y * sizeBmp.cx;
|
|
for (int x = rc.left; x < rc.right; x++)
|
|
{
|
|
pargb[x + iOffset].rgbReserved = 0xff;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* In
|
|
* hbmpSub - little bitmap that we're adding to the thumbnail bitmap.
|
|
* ptMargin - where we're adding it on the destination thumbnail bitmap.
|
|
* sizeDest - how big it needs to be on the destination thumbnail bitmap.
|
|
* sizeSource - how bit it is.
|
|
* fAlphaSource - does the bitmap we're adding have an alpha channel?
|
|
* fAlphaDest - does what we're adding it to, have an alpha channel?
|
|
* prgbDest - the bits of the destination bitmap - needed if we add a non-alpha bitmap
|
|
* to an alpha background, so we can reset the alpha.
|
|
* sizeFolderBmp - the size of the destination bitmap - need this along with prgbDest.
|
|
*/
|
|
HRESULT _AddBitmap(HDC hdc, HBITMAP hbmpSub, POINT ptMargin, SIZE sizeDest, SIZE sizeSource, BOOL fAlphaSource, BOOL fAlphaDest, RGBQUAD *prgbDest, SIZE sizeFolderBmp)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
HDC hdcFrom = CreateCompatibleDC(hdc);
|
|
if (hdcFrom)
|
|
{
|
|
// Select the bitmap into the source hdc.
|
|
HBITMAP hbmpOld = (HBITMAP)SelectObject(hdcFrom, hbmpSub);
|
|
if (hbmpOld)
|
|
{
|
|
// Adjust destination size to preserve aspect ratio
|
|
SIZE sizeDestActual;
|
|
if ((1000 * sizeDest.cx / sizeSource.cx) < // 1000 -> float simulation
|
|
(1000 * sizeDest.cy / sizeSource.cy))
|
|
{
|
|
// Keep destination width
|
|
sizeDestActual.cy = sizeSource.cy * sizeDest.cx / sizeSource.cx;
|
|
sizeDestActual.cx = sizeDest.cx;
|
|
ptMargin.y += (sizeDest.cy - sizeDestActual.cy) / 2; // Center
|
|
}
|
|
else
|
|
{
|
|
// Keep destination height
|
|
sizeDestActual.cx = sizeSource.cx * sizeDest.cy / sizeSource.cy;
|
|
sizeDestActual.cy = sizeDest.cy;
|
|
ptMargin.x += (sizeDest.cx - sizeDestActual.cx) / 2; // Center
|
|
}
|
|
|
|
// Now blt the image onto our folder background.
|
|
// Three alpha possibilities:
|
|
// Dest: no alpha, Src: no alpha -> the normal case
|
|
// Dest: no alpha, Src: alpha -> one of the minipreviews is a logo-ized folder.
|
|
// Dest: alpha, Src: no alpha -> we're a logoized folder being rendered as a minipreview in
|
|
// the parent folder's thumbnail.
|
|
|
|
// If we got back an alpha image, we need to alphablend it.
|
|
if (fAlphaSource)
|
|
{
|
|
// We shouldn't have gotten back an alpha image, if we're alpha'd too. That would imply we're
|
|
// doing a minipreview of a minipreview (1/16 scale).
|
|
//ASSERT(!fAlphaDest);
|
|
BLENDFUNCTION bf;
|
|
bf.BlendOp = AC_SRC_OVER;
|
|
bf.SourceConstantAlpha = 255;
|
|
bf.AlphaFormat = AC_SRC_ALPHA;
|
|
bf.BlendFlags = 0;
|
|
if (AlphaBlend(hdc, ptMargin.x, ptMargin.y, sizeDestActual.cx, sizeDestActual.cy, hdcFrom, 0 ,0, sizeSource.cx, sizeSource.cy, bf))
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, just blt it.
|
|
int iModeSave = SetStretchBltMode(hdc, HALFTONE);
|
|
if (StretchBlt(hdc, ptMargin.x, ptMargin.y, sizeDestActual.cx, sizeDestActual.cy, hdcFrom, 0 ,0, sizeSource.cx, sizeSource.cy, SRCCOPY))
|
|
hr = S_OK;
|
|
SetStretchBltMode(hdc, iModeSave);
|
|
|
|
// Are we alpha'd? We didn't have an alpha source, so where we blt'd it, we've
|
|
// lost the alpha channel. Restore it.
|
|
if (fAlphaDest)
|
|
{
|
|
// Set the alpha channel over where we just blt'd.
|
|
RECT rc = {ptMargin.x, ptMargin.y, ptMargin.x + sizeDestActual.cx, ptMargin.y + sizeDestActual.cy};
|
|
_SetAlpha(rc, sizeFolderBmp, prgbDest);
|
|
}
|
|
}
|
|
SelectObject(hdcFrom, hbmpOld);
|
|
}
|
|
DeleteDC(hdcFrom);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
class CFolderExtractImage : public IExtractImage2,
|
|
public IPersistPropertyBag,
|
|
public IAlphaThumbnailExtractor,
|
|
public IRunnableTask
|
|
{
|
|
public:
|
|
CFolderExtractImage();
|
|
|
|
STDMETHOD (QueryInterface)(REFIID riid, void **ppv);
|
|
STDMETHOD_(ULONG, AddRef) ();
|
|
STDMETHOD_(ULONG, Release) ();
|
|
|
|
// IExtractImage/IExtractLogo
|
|
STDMETHOD (GetLocation)(LPWSTR pszPath, DWORD cch, DWORD *pdwPriority, const SIZE *prgSize, DWORD dwRecClrDepth, DWORD *pdwFlags);
|
|
|
|
STDMETHOD (Extract)(HBITMAP *phbm);
|
|
|
|
// IExtractImage2
|
|
STDMETHOD (GetDateStamp)(FILETIME *pftDateStamp);
|
|
|
|
// IPersist
|
|
STDMETHOD(GetClassID)(CLSID *pClassID);
|
|
|
|
// IPersistPropertyBag
|
|
STDMETHOD(InitNew)();
|
|
STDMETHOD(Load)(IPropertyBag *ppb, IErrorLog *pErr);
|
|
STDMETHOD(Save)(IPropertyBag *ppb, BOOL fClearDirty, BOOL fSaveAll)
|
|
{ return E_NOTIMPL; }
|
|
|
|
// IRunnableTask
|
|
STDMETHOD (Run)(void);
|
|
STDMETHOD (Kill)(BOOL fWait);
|
|
STDMETHOD (Suspend)(void);
|
|
STDMETHOD (Resume)(void);
|
|
STDMETHOD_(ULONG, IsRunning)(void);
|
|
|
|
// IAlphaThumbnailExtractor
|
|
STDMETHOD (RequestAlphaThumbnail)(void);
|
|
|
|
STDMETHOD(Init)(IShellFolder *psf, LPCITEMIDLIST pidl);
|
|
private:
|
|
~CFolderExtractImage();
|
|
LPCTSTR _GetImagePath(UINT cx);
|
|
HRESULT _CreateWithMiniPreviews(IShellFolder *psf, const LPCITEMIDLIST *apidlPreviews, BOOL *abTryCached, UINT cpidlPreviews, MINIPREVIEW_LAYOUT uLayout, IShellImageStore *pImageStore, HBITMAP *phBmpThumbnail);
|
|
HRESULT _FindMiniPreviews(LPITEMIDLIST apidlPreviews[], BOOL abTryCached[], UINT *cpidlPreviews);
|
|
HRESULT _CreateThumbnailFromIconResource(HBITMAP* phBmpThumbnail, int res);
|
|
HRESULT _CheckThumbnailCache(HBITMAP *phbmp);
|
|
void _CacheThumbnail(HBITMAP hbmp);
|
|
|
|
IExtractImage *_pExtract;
|
|
IRunnableTask *_pRun;
|
|
long _cRef;
|
|
TCHAR _szFolder[MAX_PATH];
|
|
TCHAR _szLogo[MAX_PATH];
|
|
TCHAR _szWideLogo[MAX_PATH];
|
|
IShellFolder2 *_psf;
|
|
SIZE _size;
|
|
LPITEMIDLIST _pidl;
|
|
IPropertyBag *_ppb;
|
|
LONG _lState;
|
|
BOOL _fAlpha;
|
|
|
|
DWORD _dwPriority;
|
|
DWORD _dwRecClrDepth;
|
|
|
|
DWORD _dwExtractFlags;
|
|
};
|
|
|
|
STDAPI CFolderExtractImage_Create(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
CFolderExtractImage *pfei = new CFolderExtractImage;
|
|
if (pfei)
|
|
{
|
|
hr = pfei->Init(psf, pidl);
|
|
if (SUCCEEDED(hr))
|
|
hr = pfei->QueryInterface(riid, ppv);
|
|
pfei->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
CFolderExtractImage::CFolderExtractImage() : _cRef(1), _lState(IRTIR_TASK_NOT_RUNNING)
|
|
{
|
|
}
|
|
|
|
CFolderExtractImage::~CFolderExtractImage()
|
|
{
|
|
ATOMICRELEASE(_pExtract);
|
|
ATOMICRELEASE(_psf);
|
|
ILFree(_pidl);
|
|
ATOMICRELEASE(_ppb);
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT (CFolderExtractImage, IExtractImage2),
|
|
QITABENTMULTI (CFolderExtractImage, IExtractImage, IExtractImage2),
|
|
QITABENTMULTI2(CFolderExtractImage, IID_IExtractLogo, IExtractImage2),
|
|
QITABENT (CFolderExtractImage, IPersistPropertyBag),
|
|
QITABENT (CFolderExtractImage, IRunnableTask),
|
|
QITABENT (CFolderExtractImage, IAlphaThumbnailExtractor),
|
|
QITABENTMULTI (CFolderExtractImage, IPersist, IPersistPropertyBag),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFolderExtractImage::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFolderExtractImage::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::GetDateStamp(FILETIME *pftDateStamp)
|
|
{
|
|
HANDLE h = CreateFile(_szFolder, GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_DELETE, NULL,
|
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
|
|
HRESULT hr = (h != INVALID_HANDLE_VALUE) ? S_OK : E_FAIL;
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = GetFileTime(h, NULL, NULL, pftDateStamp) ? S_OK : E_FAIL;
|
|
CloseHandle(h);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFolderExtractImage::InitNew()
|
|
{
|
|
IPropertyBag *ppb;
|
|
// load up the default property bag for peruser perfolder
|
|
// may have problems down the line with thumbs.db being alluser.
|
|
if (SUCCEEDED(SHGetViewStatePropertyBag(_pidl, VS_BAGSTR_EXPLORER, SHGVSPB_PERUSER | SHGVSPB_PERFOLDER, IID_PPV_ARG(IPropertyBag, &ppb))))
|
|
{
|
|
IUnknown_Set((IUnknown**)&_ppb, ppb);
|
|
ppb->Release();
|
|
}
|
|
// return success always -- SHGVSPB can fail if _pidl is on a removable drive,
|
|
// but we still want to do our thing.
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFolderExtractImage::Load(IPropertyBag *ppb, IErrorLog *pErr)
|
|
{
|
|
IUnknown_Set((IUnknown**)&_ppb, ppb);
|
|
return S_OK;
|
|
}
|
|
|
|
LPCTSTR CFolderExtractImage::_GetImagePath(UINT cx)
|
|
{
|
|
if (!_szLogo[0])
|
|
{
|
|
if (_ppb && SUCCEEDED(SHPropertyBag_ReadStr(_ppb, TEXT("Logo"), _szLogo, ARRAYSIZE(_szLogo))) && _szLogo[0])
|
|
{
|
|
if (SUCCEEDED(SHPropertyBag_ReadStr(_ppb, TEXT("WideLogo"), _szWideLogo, ARRAYSIZE(_szWideLogo))) && _szWideLogo[0])
|
|
PathCombine(_szWideLogo, _szFolder, _szWideLogo); // relative path support
|
|
|
|
PathCombine(_szLogo, _szFolder, _szLogo); // relative path support
|
|
}
|
|
else
|
|
{
|
|
TCHAR szFind[MAX_PATH];
|
|
|
|
for (int i = 0; i < ARRAYSIZE(c_szFolderThumbnailPaths); i++)
|
|
{
|
|
PathCombine(szFind, _szFolder, c_szFolderThumbnailPaths[i]);
|
|
if (PathFileExists(szFind))
|
|
{
|
|
lstrcpyn(_szLogo, szFind, ARRAYSIZE(_szLogo));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LPCTSTR psz = ((cx > 120) && _szWideLogo[0]) ? _szWideLogo : _szLogo;
|
|
return *psz ? psz : NULL;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::RequestAlphaThumbnail()
|
|
{
|
|
_fAlpha = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::GetLocation(LPWSTR pszPath, DWORD cch,
|
|
DWORD *pdwPriority, const SIZE *prgSize,
|
|
DWORD dwRecClrDepth, DWORD *pdwFlags)
|
|
{
|
|
lstrcpyn(pszPath, _szFolder, cch);
|
|
|
|
HRESULT hr = S_OK;
|
|
_size = *prgSize;
|
|
_dwRecClrDepth = dwRecClrDepth;
|
|
_dwExtractFlags = *pdwFlags;
|
|
|
|
if (pdwFlags)
|
|
{
|
|
if (*pdwFlags & IEIFLAG_ASYNC)
|
|
hr = E_PENDING;
|
|
|
|
*pdwFlags &= ~IEIFLAG_CACHE; // We handle the caching of this thumbnail inside the folder
|
|
*pdwFlags |= IEIFLAG_REFRESH; // We still want to handle the refresh verb
|
|
}
|
|
|
|
if (pdwPriority)
|
|
{
|
|
_dwPriority = *pdwPriority;
|
|
*pdwPriority = 1; // very low
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::Extract(HBITMAP *phbm)
|
|
{
|
|
// Set it to running (only if we're in the not running state).
|
|
LONG lResOld = InterlockedCompareExchange(&_lState, IRTIR_TASK_RUNNING, IRTIR_TASK_NOT_RUNNING);
|
|
|
|
if (lResOld != IRTIR_TASK_NOT_RUNNING)
|
|
{
|
|
// If we weren't in the not running state, bail.
|
|
return E_FAIL;
|
|
}
|
|
|
|
// If we have an extractor, use that.
|
|
HRESULT hr = E_FAIL;
|
|
hr = _CheckThumbnailCache(phbm);
|
|
if (FAILED(hr))
|
|
{
|
|
LPITEMIDLIST apidlPreviews[MAX_MINIPREVIEWS_COLLECT];
|
|
BOOL abTryCached[MAX_MINIPREVIEWS_COLLECT];
|
|
UINT cpidlPreviews = 0;
|
|
|
|
LPCTSTR pszLogo = _GetImagePath(_size.cx);
|
|
if (pszLogo)
|
|
{
|
|
// Don't do the standard mini-previews - we've got a special thumbnail
|
|
ATOMICRELEASE(_pExtract);
|
|
|
|
LPITEMIDLIST pidl;
|
|
hr = SHILCreateFromPath(pszLogo, &pidl, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPCITEMIDLIST pidlChild;
|
|
IShellFolder* psfLogo;
|
|
hr = SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psfLogo), &pidlChild);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _CreateWithMiniPreviews(psfLogo, &pidlChild, NULL, 1, MINIPREVIEW_LAYOUT_1, NULL, phbm);
|
|
psfLogo->Release();
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const struct
|
|
{
|
|
int csidl;
|
|
int res;
|
|
}
|
|
thumblist[] =
|
|
{
|
|
{CSIDL_PERSONAL, IDI_MYDOCS},
|
|
{CSIDL_MYMUSIC, IDI_MYMUSIC},
|
|
{CSIDL_MYPICTURES, IDI_MYPICS},
|
|
{CSIDL_MYVIDEO, IDI_MYVIDEOS},
|
|
{CSIDL_COMMON_DOCUMENTS, IDI_MYDOCS},
|
|
{CSIDL_COMMON_MUSIC, IDI_MYMUSIC},
|
|
{CSIDL_COMMON_PICTURES, IDI_MYPICS},
|
|
{CSIDL_COMMON_VIDEO, IDI_MYVIDEOS}
|
|
};
|
|
BOOL bFound = FALSE;
|
|
|
|
for (int i=0; i < ARRAYSIZE(thumblist) && !bFound; i++)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
SHGetFolderPath(NULL, thumblist[i].csidl, NULL, 0, szPath);
|
|
if (!lstrcmp(_szFolder, szPath))
|
|
{
|
|
// We return failure in this case so that the requestor can do
|
|
// the default action.
|
|
hr = E_FAIL;
|
|
bFound = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!bFound)
|
|
{
|
|
// Mini-previews.
|
|
IShellImageStore *pDiskCache = NULL;
|
|
|
|
// It's ok if this fails.
|
|
if (!SHRestricted(REST_NOTHUMBNAILCACHE) &&
|
|
!SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("DisableThumbnailCache"), 0, FALSE) &&
|
|
!(_dwExtractFlags & IEIFLAG_QUALITY))
|
|
{
|
|
LoadFromFile(CLSID_ShellThumbnailDiskCache, _szFolder, IID_PPV_ARG(IShellImageStore, &pDiskCache));
|
|
}
|
|
|
|
cpidlPreviews = ARRAYSIZE(apidlPreviews);
|
|
hr = _FindMiniPreviews(apidlPreviews, abTryCached, &cpidlPreviews);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (cpidlPreviews)
|
|
{
|
|
hr = _CreateWithMiniPreviews(_psf, apidlPreviews, abTryCached, cpidlPreviews, _GetMiniPreviewLayout(_size), pDiskCache, phbm);
|
|
FreeMiniPreviewPidls(apidlPreviews, cpidlPreviews);
|
|
}
|
|
else
|
|
{
|
|
// We return failure in this case so that the requestor can do
|
|
// the default action
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
ATOMICRELEASE(pDiskCache);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && *phbm)
|
|
{
|
|
_CacheThumbnail(*phbm);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::GetClassID(CLSID *pClassID)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::Init(IShellFolder *psf, LPCITEMIDLIST pidl)
|
|
{
|
|
HRESULT hr = DisplayNameOf(psf, pidl, SHGDN_FORPARSING, _szFolder, ARRAYSIZE(_szFolder));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlFolder;
|
|
hr = SHGetIDListFromUnk(psf, &pidlFolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILCombine(pidlFolder, pidl, &_pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// hold the _psf for this guy so we can enum
|
|
hr = psf->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder2, &_psf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = InitNew();
|
|
}
|
|
}
|
|
ILFree(pidlFolder);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Not necessary --- IExtractImage::Extract() starts us up.
|
|
STDMETHODIMP CFolderExtractImage::Run(void)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::Kill(BOOL fWait)
|
|
{
|
|
// Try to kill the current subextraction task that's running, if any.
|
|
if (_pRun != NULL)
|
|
{
|
|
_pRun->Kill(fWait);
|
|
// If it didn't work, no big deal, we'll complete this subextraction task,
|
|
// and bail before starting the next one.
|
|
}
|
|
|
|
// If we're running, set to pending.
|
|
LONG lResOld = InterlockedCompareExchange(&_lState, IRTIR_TASK_PENDING, IRTIR_TASK_RUNNING);
|
|
if (lResOld == IRTIR_TASK_RUNNING)
|
|
{
|
|
// We've now set it to pending - ready to die.
|
|
return S_OK;
|
|
}
|
|
else if (lResOld == IRTIR_TASK_PENDING || lResOld == IRTIR_TASK_FINISHED)
|
|
{
|
|
// We've already been killed.
|
|
return S_FALSE;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::Suspend(void)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CFolderExtractImage::Resume(void)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFolderExtractImage::IsRunning(void)
|
|
{
|
|
return _lState;
|
|
}
|
|
|
|
HRESULT CFolderExtractImage::_CreateWithMiniPreviews(IShellFolder *psf, const LPCITEMIDLIST *apidlPreviews, BOOL *abTryCached, UINT cpidlPreviews, MINIPREVIEW_LAYOUT uLayout, IShellImageStore *pImageStore, HBITMAP *phBmpThumbnail)
|
|
{
|
|
*phBmpThumbnail = NULL;
|
|
|
|
HBITMAP hbmpOld;
|
|
HDC hdc;
|
|
|
|
SIZE sizeOriginal; // Size of the source bitmaps that go into the minipreview.
|
|
SIZE sizeFolderBmp; // Size of the folder bmp we use for the background.
|
|
SIZE sizeMiniPreview; // The size calculated for the minipreviews
|
|
POINT aptOrigins[MAX_MINIPREVIEWS];
|
|
RGBQUAD* prgb; // the bits of the destination bitmap.
|
|
|
|
_GetMiniPreviewLocations(uLayout, _size, &sizeFolderBmp,
|
|
aptOrigins, &sizeMiniPreview);
|
|
|
|
// sizeFolderBmp is the size of the folder background bitmap that we're working with,
|
|
// not the size of the final thumbnail.
|
|
HRESULT hr = _CreateMainRenderingDC(&hdc, phBmpThumbnail, &hbmpOld, sizeFolderBmp.cx, sizeFolderBmp.cy, &prgb);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL fIsAlphaBackground;
|
|
hr = _DrawMiniPreviewBackground(hdc, sizeFolderBmp, _fAlpha, &fIsAlphaBackground, prgb);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULONG uPreviewLocation = 0;
|
|
|
|
// Extract the images for the minipreviews
|
|
for (ULONG i = 0 ; i < cpidlPreviews && uPreviewLocation < ARRAYSIZE(aptOrigins) ; i++)
|
|
{
|
|
BOOL bFoundAlphaImage = FALSE;
|
|
|
|
// If we've been killed, stop the processing the minipreviews:
|
|
// PENDING?, we're now FINISHED.
|
|
InterlockedCompareExchange(&_lState, IRTIR_TASK_FINISHED, IRTIR_TASK_PENDING);
|
|
|
|
if (_lState == IRTIR_TASK_FINISHED)
|
|
{
|
|
// Get out.
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
HBITMAP hbmpSubs;
|
|
BOOL bFoundImage = FALSE;
|
|
|
|
// Try the image store first
|
|
DWORD dwLock;
|
|
HRESULT hr2 = (pImageStore && abTryCached[i]) ? pImageStore->Open(STGM_READ, &dwLock) : E_FAIL;
|
|
if (SUCCEEDED(hr2))
|
|
{
|
|
// Get the fullpidl of this guy.
|
|
TCHAR szSubPath[MAX_PATH];
|
|
if (SUCCEEDED(DisplayNameOf(psf, apidlPreviews[i], SHGDN_INFOLDER | SHGDN_FORPARSING, szSubPath, MAX_PATH)))
|
|
{
|
|
if (SUCCEEDED(pImageStore->GetEntry(szSubPath, STGM_READ, &hbmpSubs)))
|
|
{
|
|
bFoundImage = TRUE;
|
|
}
|
|
}
|
|
pImageStore->ReleaseLock(&dwLock);
|
|
}
|
|
|
|
// Resort to calling extractor if the image was not in the cache.
|
|
if (!bFoundImage)
|
|
{
|
|
IExtractImage *peiSub;
|
|
hr2 = psf->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST *)&apidlPreviews[i], IID_X_PPV_ARG(IExtractImage, NULL, &peiSub));
|
|
if (SUCCEEDED(hr2))
|
|
{
|
|
|
|
// Now extract the image.
|
|
DWORD dwPriority = 0;
|
|
DWORD dwFlags = IEIFLAG_ORIGSIZE | IEIFLAG_QUALITY;// ORIGSIZE -> preserve aspect ratio
|
|
|
|
WCHAR szPathBuffer[MAX_PATH];
|
|
hr2 = peiSub->GetLocation(szPathBuffer, ARRAYSIZE(szPathBuffer), &dwPriority, &sizeMiniPreview, 24, &dwFlags);
|
|
|
|
IAlphaThumbnailExtractor *pati;
|
|
if (SUCCEEDED(peiSub->QueryInterface(IID_PPV_ARG(IAlphaThumbnailExtractor, &pati))))
|
|
{
|
|
if (SUCCEEDED(pati->RequestAlphaThumbnail()))
|
|
{
|
|
bFoundAlphaImage = TRUE;
|
|
}
|
|
|
|
pati->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hr2))
|
|
{
|
|
// After we check for IRTIR_TASK_PENDING, but before
|
|
// we call peiSub->Extract, it is possible someone calls
|
|
// Kill on us.
|
|
// Since _pRun will be NULL, we will not kill
|
|
// the subtask, but will instead continue and call extract
|
|
// on it, and not bail until we try the next subthumbnail.
|
|
// Oh well.
|
|
// We could add another check here to reduce the window of
|
|
// opportunity in which this could happen.
|
|
|
|
// Try to get an IRunnableTask so that we can stop execution
|
|
// of this subtask if necessary.
|
|
peiSub->QueryInterface(IID_PPV_ARG(IRunnableTask, &_pRun));
|
|
|
|
if (SUCCEEDED(peiSub->Extract(&hbmpSubs)))
|
|
{
|
|
bFoundImage = TRUE;
|
|
}
|
|
|
|
ATOMICRELEASE(_pRun);
|
|
}
|
|
|
|
peiSub->Release();
|
|
}
|
|
}
|
|
|
|
// Add the extracted bitmap to the main one...
|
|
if (bFoundImage)
|
|
{
|
|
// The bitmap will of course need to be resized:
|
|
BITMAP rgBitmap;
|
|
if (::GetObject((HGDIOBJ)hbmpSubs, sizeof(rgBitmap), &rgBitmap))
|
|
{
|
|
sizeOriginal.cx = rgBitmap.bmWidth;
|
|
sizeOriginal.cy = rgBitmap.bmHeight;
|
|
|
|
// We need to check if this is really an alpha bitmap. It's possible that the
|
|
// extractor said it could generate one, but ended up not being able to.
|
|
if (bFoundAlphaImage)
|
|
{
|
|
RECT rc = {0, 0, rgBitmap.bmWidth, rgBitmap.bmHeight};
|
|
bFoundAlphaImage = (rgBitmap.bmBitsPixel == 32) &&
|
|
_HasAlpha(rc, rgBitmap.bmWidth, (RGBQUAD*)rgBitmap.bmBits);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Couldn't get the info, oh well, no resize.
|
|
// alpha may also be screwed up here, but oh well.
|
|
sizeOriginal = sizeMiniPreview;
|
|
}
|
|
|
|
if (SUCCEEDED(_AddBitmap(hdc, hbmpSubs, aptOrigins[uPreviewLocation], sizeMiniPreview, sizeOriginal, bFoundAlphaImage, fIsAlphaBackground, prgb, sizeFolderBmp)))
|
|
{
|
|
uPreviewLocation++;
|
|
}
|
|
|
|
DeleteObject(hbmpSubs);
|
|
}
|
|
}
|
|
|
|
if (!uPreviewLocation)
|
|
{
|
|
// For whatever reason, we have no mini thumbnails to show, so fail this entire extraction.
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Is the requested size one of the sizes of the folder background bitmaps?
|
|
// Test against smallest requested dimension, because we're square, and we'll fit into that rectangle
|
|
int iSmallestDimension = min(_size.cx, _size.cy);
|
|
if ((sizeFolderBmp.cx != iSmallestDimension) || (sizeFolderBmp.cy != iSmallestDimension))
|
|
{
|
|
// Nope - we need to do some scaling.
|
|
// Create another dc and bitmap the size of the requested bitmap
|
|
HBITMAP hBmpThumbnailFinal = NULL;
|
|
HBITMAP hbmpOld2;
|
|
HDC hdcFinal;
|
|
RGBQUAD *prgbFinal;
|
|
hr = _CreateMainRenderingDC(&hdcFinal, &hBmpThumbnailFinal, &hbmpOld2, iSmallestDimension, iSmallestDimension, &prgbFinal);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Now scale it.
|
|
if (fIsAlphaBackground)
|
|
{
|
|
BLENDFUNCTION bf;
|
|
bf.BlendOp = AC_SRC_OVER;
|
|
bf.SourceConstantAlpha = 255;
|
|
bf.AlphaFormat = AC_SRC_ALPHA;
|
|
bf.BlendFlags = 0;
|
|
if (AlphaBlend(hdcFinal, 0, 0, iSmallestDimension, iSmallestDimension, hdc, 0 ,0, sizeFolderBmp.cx, sizeFolderBmp.cy, bf))
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
int iModeSave = SetStretchBltMode(hdcFinal, HALFTONE);
|
|
|
|
if (StretchBlt(hdcFinal, 0, 0, iSmallestDimension, iSmallestDimension, hdc, 0 ,0, sizeFolderBmp.cx, sizeFolderBmp.cy, SRCCOPY))
|
|
hr = S_OK;
|
|
|
|
SetStretchBltMode(hdcFinal, iModeSave);
|
|
}
|
|
|
|
// Destroy the dc.
|
|
_DestroyMainRenderingDC(hdcFinal, hbmpOld2);
|
|
|
|
// Now do a switcheroo
|
|
// Don't need to check for success here. Down below, we'll delete *phBmpThumbnail
|
|
// if StretchBlt FAILED - and in that case, *pbBmpThumbnail will be hBmpThumbnailFinal.
|
|
DeleteObject(*phBmpThumbnail); // delete this, we don't need it.
|
|
*phBmpThumbnail = hBmpThumbnailFinal; // This is the one we want.
|
|
}
|
|
}
|
|
}
|
|
_DestroyMainRenderingDC(hdc, hbmpOld);
|
|
}
|
|
|
|
|
|
if (FAILED(hr) && *phBmpThumbnail) // Something didn't work? Make sure we delete our bmp
|
|
{
|
|
DeleteObject(*phBmpThumbnail);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/**
|
|
* In/Out: cpidlPreviews - the number of preview items we should look for. Returns the number found.
|
|
* number of pidls returned is cpidlPreviews.
|
|
* Out: apidlPreviews - array of pidls found. The caller must free them.
|
|
*/
|
|
HRESULT CFolderExtractImage::_FindMiniPreviews(LPITEMIDLIST apidlPreviews[], BOOL abTryCached[], UINT *pcpidlPreviews)
|
|
{
|
|
UINT cMaxPreviews = *pcpidlPreviews;
|
|
int uNumPreviewsSoFar = 0;
|
|
BOOL bKilled = FALSE;
|
|
|
|
// Make sure our aFileTimes array is the right size...
|
|
ASSERT(MAX_MINIPREVIEWS_COLLECT == cMaxPreviews);
|
|
|
|
*pcpidlPreviews = 0; // start with none in case of failure
|
|
|
|
IEnumIDList *penum;
|
|
if (S_OK == _psf->EnumObjects(NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &penum))
|
|
{
|
|
FILETIME aFileTimes[MAX_MINIPREVIEWS_COLLECT] = {0};
|
|
|
|
LPITEMIDLIST pidl;
|
|
BOOL bTryCached;
|
|
while (S_OK == penum->Next(1, &pidl, NULL))
|
|
{
|
|
// _IsMiniPreviewCandidate is a potentially expensive operation, so before
|
|
// doing it, we'll check to see if anyone has killed us.
|
|
|
|
// Are we PENDING? Then we're FINISHED.
|
|
InterlockedCompareExchange(&_lState, IRTIR_TASK_FINISHED, IRTIR_TASK_PENDING);
|
|
|
|
// Get out?
|
|
bKilled = (_lState == IRTIR_TASK_FINISHED);
|
|
|
|
if (!bKilled && _IsMiniPreviewCandidate(_psf, pidl, &bTryCached))
|
|
{
|
|
// Get file time of this guy.
|
|
FILETIME ft;
|
|
if (SUCCEEDED(GetDateProperty(_psf, pidl, &SCID_WRITETIME, &ft)))
|
|
{
|
|
for (int i = 0; i < uNumPreviewsSoFar; i++)
|
|
{
|
|
if (CompareFileTime(&aFileTimes[i], &ft) < 0)
|
|
{
|
|
int j;
|
|
// Put it in this slot. First, move guys down by one.
|
|
// No need to copy last guy:
|
|
if (uNumPreviewsSoFar == (int)cMaxPreviews)
|
|
{
|
|
j = (cMaxPreviews - 2);
|
|
// And we must free the pidl we're nuking.
|
|
ILFree(apidlPreviews[cMaxPreviews - 1]);
|
|
apidlPreviews[cMaxPreviews - 1] = NULL;
|
|
}
|
|
else
|
|
{
|
|
j = uNumPreviewsSoFar - 1;
|
|
uNumPreviewsSoFar++;
|
|
}
|
|
|
|
for (; j >= i; j--)
|
|
{
|
|
apidlPreviews[j+1] = apidlPreviews[j];
|
|
abTryCached[j+1] = abTryCached[j];
|
|
aFileTimes[j+1] = aFileTimes[j];
|
|
}
|
|
|
|
aFileTimes[i] = ft;
|
|
apidlPreviews[i] = pidl;
|
|
abTryCached[i] = bTryCached;
|
|
pidl = NULL; // don't free
|
|
break; // for loop
|
|
}
|
|
}
|
|
|
|
// Did we complete the loop?
|
|
if (i == uNumPreviewsSoFar)
|
|
{
|
|
if (i < (int)cMaxPreviews)
|
|
{
|
|
// We still have room for more previews, so tack this on at the end.
|
|
uNumPreviewsSoFar++;
|
|
aFileTimes[i] = ft;
|
|
apidlPreviews[i] = pidl;
|
|
abTryCached[i] = bTryCached;
|
|
pidl = NULL; // don't free below
|
|
}
|
|
}
|
|
|
|
*pcpidlPreviews = uNumPreviewsSoFar;
|
|
}
|
|
}
|
|
ILFree(pidl); // NULL pidl OK
|
|
|
|
if (bKilled)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
penum->Release();
|
|
}
|
|
|
|
if (bKilled)
|
|
{
|
|
FreeMiniPreviewPidls(apidlPreviews, *pcpidlPreviews);
|
|
*pcpidlPreviews = 0;
|
|
return E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return (uNumPreviewsSoFar > 0) ? S_OK : S_FALSE;
|
|
}
|
|
}
|
|
|
|
HRESULT CFolderExtractImage::_CreateThumbnailFromIconResource(HBITMAP* phBmpThumbnail, int res)
|
|
{
|
|
*phBmpThumbnail = NULL;
|
|
|
|
HBITMAP hbmpOld;
|
|
HDC hdc;
|
|
RGBQUAD* prgb; // the bits of the destination bitmap.
|
|
|
|
HRESULT hr = _CreateMainRenderingDC(&hdc, phBmpThumbnail, &hbmpOld, _size.cx, _size.cy, &prgb);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
HICON hicon = (HICON)LoadImage(HINST_THISDLL, MAKEINTRESOURCE(res), IMAGE_ICON, _size.cx, _size.cy, 0);
|
|
|
|
if (hicon)
|
|
{
|
|
RECT rc = { 0, 0, _size.cx + 1, _size.cy + 1};
|
|
SHFillRectClr(hdc, &rc, GetSysColor(COLOR_WINDOW));
|
|
|
|
DrawIconEx(hdc, 0, 0, hicon, _size.cx, _size.cy, 0, NULL, DI_NORMAL);
|
|
|
|
DestroyIcon(hicon);
|
|
hr = S_OK;
|
|
}
|
|
|
|
_DestroyMainRenderingDC(hdc, hbmpOld);
|
|
}
|
|
|
|
if (FAILED(hr) && *phBmpThumbnail)
|
|
{
|
|
DeleteObject(*phBmpThumbnail);
|
|
*phBmpThumbnail = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFolderExtractImage::_CheckThumbnailCache(HBITMAP* phbmp)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (!SHRestricted(REST_NOTHUMBNAILCACHE) &&
|
|
!SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("DisableThumbnailCache"), 0, FALSE) &&
|
|
!(_dwExtractFlags & IEIFLAG_QUALITY))
|
|
{
|
|
IShellImageStore *pDiskCache = NULL;
|
|
|
|
hr = LoadFromFile(CLSID_ShellThumbnailDiskCache, _szFolder, IID_PPV_ARG(IShellImageStore, &pDiskCache));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD dwLock;
|
|
|
|
hr = pDiskCache->Open(STGM_READ, &dwLock);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
FILETIME ftTimeStamp = {0,0};
|
|
|
|
hr = GetDateStamp(&ftTimeStamp);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
FILETIME ftTimeStampCache = {0,0};
|
|
hr = pDiskCache->IsEntryInStore(FOLDER_GUID, &ftTimeStampCache);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (hr == S_OK && (0 == CompareFileTime(&ftTimeStampCache, &ftTimeStamp)))
|
|
{
|
|
hr = pDiskCache->GetEntry(FOLDER_GUID, STGM_READ, phbmp);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
pDiskCache->ReleaseLock(&dwLock);
|
|
pDiskCache->Close(NULL);
|
|
}
|
|
pDiskCache->Release();
|
|
}
|
|
}
|
|
|
|
TraceMsg(TF_DEFVIEW, "CFolderExtractImage::_CheckThumbnailCache (%s, %x)", _szFolder, hr);
|
|
return hr;
|
|
}
|
|
|
|
void CFolderExtractImage::_CacheThumbnail(HBITMAP hbmp)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
if (!SHRestricted(REST_NOTHUMBNAILCACHE) &&
|
|
!SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("DisableThumbnailCache"), 0, FALSE))
|
|
{
|
|
SIZE sizeThumbnail;
|
|
SHGetThumbnailSize(&sizeThumbnail); // Don't cache the mini-thumbnail preview
|
|
if (sizeThumbnail.cx == _size.cx && sizeThumbnail.cy == _size.cy)
|
|
{
|
|
IShellImageStore *pDiskCache = NULL;
|
|
|
|
hr = LoadFromIDList(CLSID_ShellThumbnailDiskCache, _pidl, IID_PPV_ARG(IShellImageStore, &pDiskCache));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD dwLock;
|
|
|
|
hr = pDiskCache->Open(STGM_READWRITE, &dwLock);
|
|
if (hr == STG_E_FILENOTFOUND)
|
|
{
|
|
if (!IsCopyEngineRunning())
|
|
{
|
|
hr = pDiskCache->Create(STGM_WRITE, &dwLock);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
FILETIME ftTimeStamp = {0,0};
|
|
|
|
hr = GetDateStamp(&ftTimeStamp);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pDiskCache->AddEntry(FOLDER_GUID, &ftTimeStamp, STGM_WRITE, hbmp);
|
|
}
|
|
pDiskCache->ReleaseLock(&dwLock);
|
|
pDiskCache->Close(NULL);
|
|
}
|
|
pDiskCache->Release();
|
|
}
|
|
}
|
|
}
|
|
TraceMsg(TF_DEFVIEW, "CFolderExtractImage::_CacheThumbnail (%s, %x)", _szFolder, hr);
|
|
}
|
|
|