Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Windows2000/private/shell/ext/thumbvw/thextwnd.cpp
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

3381 lines
106 KiB
C++
Raw Blame History

/* sample source code for IE4 view extension
* Copyright Microsoft 1996
* This file implements the Window routines
*/
#include "precomp.h"
#include "shellp.h"
#include "regstr.h"
#ifdef DEBUG
#define SMALLCACHE 1
#endif
WCHAR const c_szDefault[] = L"Default";
// the view wind proc ....
LRESULT CALLBACK CThumbnailView_WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
DWORD GetAltColor();
#define SUBIDSTART 0x0000
#define SUBIDEND 0x7fff
void CThumbnailView::RegisterWindowClass()
{
// register the window class that will sit as a wrapper for the ListView.
WNDCLASSW wc;
if (!GetClassInfoWrapW(g_hinstDll, VIEWCLASSNAME, &wc)) {
// don't want vredraw and hredraw because that causes horrible
// flicker expecially with full drag
wc.style = CS_PARENTDC;
wc.lpfnWndProc = (WNDPROC)CThumbnailView_WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(CThumbnailView*);
wc.hInstance = g_hinstDll;
wc.hIcon = NULL;
wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = VIEWCLASSNAME;
RegisterClassWrapW(&wc);
}
}
LRESULT CALLBACK CThumbnailView_WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
CThumbnailView* pThis = (CThumbnailView*)GetWindowLongPtrA(hWnd, 0);
LRESULT lRes = TRUE;
switch (iMessage) {
case WM_NOTIFYFORMAT:
// we are now a unicode window....
return NFR_UNICODE;
case WM_MENUCHAR:
if (pThis->m_pCMCache) {
lRes = 0;
IContextMenu3* pcm3;
HRESULT hr = pThis->m_pCMCache->QueryInterface(IID_IContextMenu3, (void**)&pcm3);
if (SUCCEEDED(hr)) {
hr = pcm3->HandleMenuMsg2(iMessage, wParam, lParam, &lRes);
pcm3->Release();
if (SUCCEEDED(hr)) {
return lRes;
}
} else {
goto HandleDefWnd;
}
}
break;
case WM_INITMENUPOPUP:
case WM_DRAWITEM:
case WM_MEASUREITEM:
if (pThis->m_pCMCache) {
// if we have a cached context menu, then we have it displayed,
// so we need to forward these three message to the Menu handler instead
// of doing the default action....
LPCONTEXTMENU2 pcm2;
HRESULT hr = pThis->m_pCMCache->QueryInterface(IID_IContextMenu2, (void**)&pcm2);
if (SUCCEEDED(hr)) {
pcm2->HandleMenuMsg(iMessage, wParam, lParam);
pcm2->Release();
return 0;
}
}
break;
case WM_ERASEBKGND:
if (ListView_GetBkColor(pThis->m_hWndListView) == CLR_NONE) {
return SendMessageA(pThis->m_hWndParent, iMessage, wParam, lParam);
}
// We want to reduce flash
lRes = TRUE;
break;
case WM_CREATE:
{
// cast the create struct pointer to the object (as that is what we passed )
LPCREATESTRUCT pCS = (LPCREATESTRUCT)lParam;
pThis = (CThumbnailView*)pCS->lpCreateParams;
lRes = pThis->OnWmCreate(hWnd, pCS);
break;
}
case WM_DESTROY:
lRes = pThis->OnWmDestroy(hWnd);
break;
// stupid . . . handle case where windows only sends WM_WINDOWPOSCHANGING and not
// WM_SIZE to handle sizing of tv. . .
case WM_WINDOWPOSCHANGING:
{
WINDOWPOS* pWPos = (WINDOWPOS*)lParam;
if (pWPos->cx && pWPos->cy)
lRes = pThis->OnWmSize(hWnd, 0, pWPos->cx, pWPos->cy);
break;
}
case WM_SIZE:
// handle it if we need to ...
lRes = HANDLE_WM_SIZE(hWnd, wParam, lParam, pThis->OnWmSize);
break;
case WM_MENUSELECT:
lRes = pThis->OnWmMenuSelect(hWnd, wParam, lParam);
break;
case WM_ACTIVATE:
// force update on inactive to not ruin save bits
lRes = HANDLE_WM_ACTIVATE(hWnd, wParam, lParam, pThis->OnWmActivate);
break;
case WM_CLIPBOARD_CUTCOPY:
lRes = pThis->OnWmClipboardUpdate();
break;
case WM_TIMER:
{
if (GetTickCount() - pThis->m_dwCacheTickCount > 2000) {
DWORD dwMode;
if (pThis->m_pDiskCache->GetMode(&dwMode) == S_OK && pThis->m_pDiskCache->IsLocked() == S_FALSE) {
// two seconds since last access, close the cache.
pThis->m_pDiskCache->Close(NULL);
}
if (pThis->m_pScheduler->CountTasks(TOID_NULL) == 0) {
// there is nothing in the queue pending, so quit listening...
KillTimer(hWnd, TIMER_DISKCACHE);
}
}
}
break;
case WM_QUERYNEWPALETTE:
{
HDC hdc = GetDC(pThis->m_hWndListView);
HPALETTE hpalOld = SelectPalette(hdc, pThis->m_hpal, FALSE);
RealizePalette(hdc);
SelectPalette(hdc, hpalOld, TRUE);
ReleaseDC(pThis->m_hWndListView, hdc);
return TRUE;
}
case WM_PALETTECHANGED:
{
if ((HWND)wParam != pThis->m_hWndListView) {
HDC hdc = GetDC(pThis->m_hWndListView);
HPALETTE hpalOld = SelectPalette(hdc, pThis->m_hpal, TRUE);
RealizePalette(hdc);
SelectPalette(hdc, hpalOld, TRUE);
ReleaseDC(pThis->m_hWndListView, hdc);
}
// we don't bother forwarding because the list view does nothing unless it
// has a background image, so just invalidate instead..
InvalidateRect(pThis->m_hWndListView, NULL, FALSE);
}
return TRUE;
case WM_SETFOCUS:
{
// NOTE: we use the defView as the IShellView to set as active ..
// NOTE: this allows the defview to handle issues such as menus
// NOTE: and to delegate them to view extensions where necessary
if (pThis->m_pBrowser != NULL) {
pThis->m_pBrowser->OnViewWindowActive(pThis->m_pDefView);
SetFocus(pThis->m_hWndListView);
}
lRes = FALSE;
break;
}
case WM_NOTIFY:
lRes = HANDLE_WM_NOTIFY(hWnd, wParam, lParam, pThis->OnWmNotify);
break;
case WM_CONTEXTMENU:
lRes = pThis->OnWmContextMenu(hWnd, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
break;
case GET_WM_CTLCOLOR_MSG(CTLCOLOR_STATIC):
SetBkColor(GET_WM_CTLCOLOR_HDC(wParam, lParam, iMessage),
GetSysColor(COLOR_WINDOW));
return (LRESULT)GetSysColorBrush(COLOR_WINDOW);
case WM_WININICHANGE:
case WM_SYSCOLORCHANGE:
if (pThis->m_hWndListView != NULL) {
SendMessageA(pThis->m_hWndListView, iMessage, wParam, lParam);
}
lRes = FALSE;
break;
case CWM_GETISHELLBROWSER:
// NOTE: the shell does not Addref this, so neither will we
lRes = (LRESULT)pThis->m_pBrowser;
break;
case WM_UPDATEITEMIMAGE:
{
LV_ITEMW rgItem;
rgItem.mask = LVIF_IMAGE;
rgItem.iItem = (int)wParam;
rgItem.iSubItem = 0;
if (pThis->m_hWndListView && ListView_GetItemWrapW(pThis->m_hWndListView, &rgItem)) {
if (rgItem.iImage != I_IMAGECALLBACK) {
Assert(pThis->m_pImageCache);
// free the previous image in the cache ...
pThis->m_pImageCache->FreeImage((UINT)rgItem.iImage);
}
if (lParam == rgItem.iImage) {
ListView_RedrawItems(pThis->m_hWndListView, wParam, wParam);
} else {
rgItem.iImage = (int)lParam;
ListView_SetItemWrapW(pThis->m_hWndListView, &rgItem);
}
}
}
break;
case WM_STATUSBARUPDATE:
{
if (lParam == 0xffffffff) {
pThis->UpdateStatusBar(NULL, NULL);
} else if (pThis->m_hWndListView) {
WCHAR szText[MAX_PATH];
LV_ITEMW rgItem;
rgItem.mask = LVIF_TEXT;
rgItem.pszText = szText;
rgItem.cchTextMax = ARRAYSIZE(szText);
rgItem.iItem = (int)lParam;
rgItem.iSubItem = 0;
if (ListView_GetItemWrapW(pThis->m_hWndListView, &rgItem)) {
WCHAR szMessage[MAX_PATH];
WCHAR szMessageFinal[MAX_PATH * 2];
LoadStringWrapW(g_hinstDll, (UINT)wParam, szMessage, ARRAYSIZE(szMessage));
wnsprintfW(szMessageFinal, ARRAYSIZE(szMessageFinal), szMessage, szText);
pThis->UpdateStatusBar(szMessageFinal, NULL);
}
}
}
break;
case WM_VIEWREFRESH:
pThis->Refresh();
lRes = FALSE;
break;
case WM_PROCESSITEMS:
pThis->OnWmProcessItems();
lRes = FALSE;
break;
case WM_HANDLESELCHANGE:
{
BOOL fSingular = TRUE;
BOOL fSelChange = (BOOL)wParam;
MSG msgTmp;
while (PeekMessage(&msgTmp, hWnd, WM_HANDLESELCHANGE, WM_HANDLESELCHANGE, PM_REMOVE)) {
if (fSingular) {
fSingular = FALSE;
}
}
// if there are multiple queued, then...
if (pThis->m_fSelChanges > 1) {
fSingular = FALSE;
}
if ((pThis->m_pCommDlg != NULL) && (fSelChange || !fSingular)) {
pThis->m_pCommDlg->OnStateChange(pThis->m_pDefView, CDBOSC_SELCHANGE);
}
pThis->UpdateStatusBar();
if (fSingular && !fSelChange) {
// figure out if the item is one of the selection,
// if so, then send the notification, otherwise don't
LV_ITEMW rgItem;
rgItem.iItem = (int)lParam;
rgItem.mask = LVIF_NORECOMPUTE | LVIF_STATE;
rgItem.iSubItem = 0;
rgItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
int iItem = ListView_GetItemWrapW(pThis->m_hWndListView, &rgItem);
if (rgItem.state & (LVIS_FOCUSED | LVIS_SELECTED)) {
fSelChange = TRUE;
}
}
if (pThis->m_pAuto && (!fSingular || fSelChange)) {
// only automate if you have the automaton
lRes = Invoke_OnConnectionPointerContainer((IUnknown*)pThis->m_pAuto
, DIID_DShellFolderViewEvents, DISPID_SELECTIONCHANGED, IID_NULL
, 0, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
}
pThis->m_fSelChanges = 0;
break;
}
case WM_MOUSEWHEEL:
default:
// Handle the magellan mousewheel message.
if (iMessage == g_msgMSWheel && pThis) {
lRes = SendMessageA(pThis->m_hWndListView, iMessage, wParam, lParam);
} else {
HandleDefWnd:
lRes = DefWindowProcWrapW(hWnd, iMessage, wParam, lParam);
}
break;
}
return lRes;
}
LRESULT CThumbnailView::OnWmSize(HWND hwnd, UINT fFlags, int iWidth, int iHeight)
{
// resize the enhanced list view.
::MoveWindow(m_hWndListView, 0, 0, iWidth, iHeight, TRUE);
return 0;
}
LRESULT CThumbnailView::OnWmClipboardUpdate(void)
{
int iIndex = -1;
// go through everything in the list view.
do {
iIndex = ListView_GetNextItem(m_hWndListView, iIndex, LVNI_ALL);
if (iIndex == -1) {
break;
}
LV_ITEMW rgItem;
rgItem.iItem = iIndex;
rgItem.mask = LVIF_PARAM;
rgItem.iSubItem = 0;
int iItem = ListView_GetItemWrapW(m_hWndListView, &rgItem);
// just incase. ...
if (iItem != -1) {
LPCITEMIDLIST pidl = (LPCITEMIDLIST)rgItem.lParam;
// check if the item should be ghosted or not.
DWORD dwGhosted = SFGAO_GHOSTED;
WORD wCut = 0x0000;
WORD wStateOld = ListView_GetItemState(m_hWndListView,
rgItem.iItem, LVIS_CUT);
m_pFolder->GetAttributesOf(1, &pidl, &dwGhosted);
if (dwGhosted & SFGAO_GHOSTED)
wCut = LVIS_CUT;
if (wStateOld != wCut) {
// update and redraw the items that have changed.
ListView_SetItemState(m_hWndListView, rgItem.iItem, wCut, LVIS_CUT);
ListView_RedrawItems(m_hWndListView, rgItem.iItem, rgItem.iItem);
}
}
} while (TRUE);
return TRUE;
}
LRESULT CThumbnailView::OnWmNotify(HWND hWnd, int iID, NMHDR* pHdr)
{
LRESULT lRes = FALSE;
HRESULT hr = NOERROR;
switch (pHdr->code) {
case NM_CUSTOMDRAW:
return OnCustomDraw((NMCUSTOMDRAW*)pHdr);
case LVN_GETDISPINFOA:
{
LV_DISPINFOA* pInfo = (LV_DISPINFOA*)pHdr;
LPCITEMIDLIST pidl = NULL;
// if the enhanced view is looking for its thumbnnails.
if (pInfo->item.mask & LVIF_IMAGE) {
lRes = OnViewGetThumbnail(pHdr);
pInfo->item.mask |= LVIF_DI_SETITEM;
}
break;
}
case LVN_GETDISPINFOW:
{
LV_DISPINFOW* pInfo = (LV_DISPINFOW*)pHdr;
LPCITEMIDLIST pidl = NULL;
// if the enhanced view is looking for its thumbnnails.
if (pInfo->item.mask & LVIF_IMAGE) {
lRes = OnViewGetThumbnail(pHdr);
pInfo->item.mask |= LVIF_DI_SETITEM;
}
break;
}
case LVN_GETINFOTIPW:
lRes = OnInfoTipText((NMLVGETINFOTIPW*)pHdr);
break;
case LVN_COLUMNCLICK:
{
NM_LISTVIEW* pnmv = (NM_LISTVIEW*)pHdr;
this->SortBy(pnmv->iSubItem, TRUE);
lRes = FALSE;
break;
}
case LVN_ITEMCHANGED:
{
NM_LISTVIEW* pnmv = (NM_LISTVIEW*)pHdr;
BOOL fSelChange = (pnmv->uChanged & LVIF_STATE) != 0;
if (!m_fSelChanges) {
PostMessage(m_hWnd, WM_HANDLESELCHANGE, (WPARAM)fSelChange, (LPARAM)pnmv->iItem);
}
m_fSelChanges++;
break;
}
case LVN_BEGINLABELEDITW:
{
// failure case stop editing ...
lRes = TRUE;
LV_DISPINFOW* pInfo = (LV_DISPINFOW*)pHdr;
LPCITEMIDLIST pidl = (LPCITEMIDLIST)pInfo->item.lParam;
ULONG rgFlags = SFGAO_CANRENAME;
if (pidl == NULL ||
FAILED(m_pFolder->GetAttributesOf(1, (LPCITEMIDLIST*)&pidl, &rgFlags)) ||
!(rgFlags & SFGAO_CANRENAME))
break;
lRes = FALSE;
HWND hwndEdit = ListView_GetEditControl(m_hWndListView);
if (hwndEdit) {
int cchMax = 0;
m_pFolderCB->MessageSFVCB(SFVM_GETCCHMAX, (WPARAM)pidl, (LPARAM)&cchMax);
if (cchMax) {
Assert(cchMax < 1024);
SendMessageA(hwndEdit, EM_LIMITTEXT, cchMax, 0);
}
WCHAR szName[MAX_PATH];
STRRET str;
if (SUCCEEDED(m_pFolder->GetDisplayNameOf(pidl, SHGDN_INFOLDER | SHGDN_FOREDITING, &str)) &&
SUCCEEDED(StrRetToBufW(&str, pidl, szName, ARRAYSIZE(szName)))) {
SetWindowTextWrapW(hwndEdit, szName);
}
}
m_fTranslateAccel = TRUE;
break;
}
case LVN_ENDLABELEDITW:
{
m_fTranslateAccel = FALSE;
// check the HWND to see if we have been destroyed.... (this happens if someone
// navigates while the edit box is up)
if (m_hWnd) {
// AddRef, rename, then release, so that the
// view object stays around until the rename function returns.
// this in case the scope changes in the middle of the rename, the
// view would be released and deleted before the rename returned.
this->InternalAddRef();
this->OnLVNEndLabelEdit(pHdr);
this->InternalRelease();
}
lRes = FALSE;
break;
}
case LVN_BEGINDRAG:
case LVN_BEGINRDRAG:
{
HRESULT hr = OleInitialize(NULL);
if (SUCCEEDED(hr)) {
StartDragDrop((NM_LISTVIEW*)pHdr);
OleUninitialize();
}
SHChangeNotifyHandleEvents();
break;
}
case NM_SETFOCUS:
// NOTE: notify the browser we just got focus, we use the defview
// NOTE: for this so that it can handle the menu merging.
Assert(m_pDefView != NULL);
m_pBrowser->OnViewWindowActive(m_pDefView);
if (m_pCommDlg != NULL) {
m_pCommDlg->OnStateChange(m_pDefView, CDBOSC_SETFOCUS);
}
m_pDefView->UIActivate(SVUIA_ACTIVATE_FOCUS);
break;
case NM_KILLFOCUS:
if (m_pCommDlg != NULL) {
m_pCommDlg->OnStateChange(m_pDefView, CDBOSC_KILLFOCUS);
}
break;
case LVN_ITEMACTIVATE:
{
// make sure there is no context menu up...
if (m_hWndListView)
SendMessageA(m_hWndListView, WM_CANCELMODE, 0, 0);
HRESULT hRes = S_FALSE;
if (m_pCommDlg != NULL) {
// addref the def-view incase it decides to unwind us in the meantime.
IShellView* pView = m_pDefView;
pView->AddRef();
hRes = m_pCommDlg->OnDefaultCommand(pView);
pView->Release();
}
if (hRes == S_FALSE) {
lRes = this->OnDefaultAction(FALSE);
}
lRes = FALSE;
break;
}
}
return lRes;
}
LRESULT CThumbnailView::OnWmActivate(HWND hWnd,
int fActive,
HWND hWndPrev,
BOOL fMinimized)
{
if (fActive == WA_INACTIVE) {
UpdateWindow(m_hWndListView);
}
return (0);
}
LRESULT CThumbnailView::OnWmContextMenu(HWND hWnd, int iX, int iY)
{
int iItem = -1;
HMENU hCMenu = NULL;
LPCONTEXTMENU pICMenu = NULL;
LPCITEMIDLIST* apidl = NULL;
HRESULT hRes;
LRESULT lRes = FALSE;
int iSelectedCount = 0;
UINT id;
UINT grfFlags;
POINT pt = {iX, iY};
RECT rc;
LV_HITTESTINFO rgInfo;
rgInfo.flags = 0;
rgInfo.iItem = -1;
BOOL fItemsFromSelection = TRUE;
// check the loword, as it was a lparam that was broken apart.
if ((LOWORD(iX) == 0xffff) && (LOWORD(iY) == 0xffff)) {
// it must have come from the keyboard contextmenu button
// we need to find an appropriate position....
// find the focussed item
int iItem = ListView_GetNextItem(m_hWndListView, -1, LVNI_FOCUSED | LVNI_SELECTED);
if (iItem != -1) {
RECT rcItem;
ListView_GetItemRect(m_hWndListView, iItem, &rcItem, LVIR_ICON);
pt.x = (rcItem.left + rcItem.right) / 2;
pt.y = (rcItem.top + rcItem.bottom) / 2;
rgInfo.flags = LVHT_ONITEM;
rgInfo.iItem = iItem;
} else {
pt.x = 0;
pt.y = 0;
}
MapWindowPoints(m_hWndListView, HWND_DESKTOP, (LPPOINT)&pt, 1);
iX = pt.x;
iY = pt.y;
} else {
GetClientRect(m_hWndListView, &rc);
ScreenToClient(m_hWndListView, &pt);
rgInfo.pt = pt;
rgInfo.flags = 0;
ListView_HitTest(m_hWndListView, &rgInfo);
}
hCMenu = CreatePopupMenu();
if (hCMenu == NULL) {
return FALSE;
}
BOOL fItem = FALSE;
// did we hit anything ?
if (!(rgInfo.flags & LVHT_ONITEM) || (rgInfo.iItem == -1)) {
// background context menu .....
hRes = this->CreateBackgroundMenu(&pICMenu);
if (FAILED(hRes)) {
goto ContextCleanup;
}
} else {
iSelectedCount = ListView_GetSelectedCount(m_hWndListView);
if (iSelectedCount == 0) {
// we must catch this because sometimes the listview doesn't
// always have an item selected when you context menu and item
fItemsFromSelection = FALSE;
iSelectedCount = 1;
}
// fetch the pidl from the view ...
Assert(iSelectedCount > 0);
apidl = new LPCITEMIDLIST[iSelectedCount];
if (apidl == NULL) {
// do something about low memory ...
MessageBoxWrapW(m_hWnd,
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_OUTOFMEM),
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_SHELLTITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
goto ContextCleanup;
}
if (fItemsFromSelection) {
// there is a selection
GetSelectionPidlList(m_hWndListView, iSelectedCount, apidl, rgInfo.iItem);
} else {
// we failed to get a selection, but we know what item we are
// over ...
LV_ITEMW rgItem;
rgItem.mask = LVIF_PARAM;
rgItem.iItem = rgInfo.iItem;
rgItem.iSubItem = 0;
int iItem = ListView_GetItemWrapW(m_hWndListView, &rgItem);
if (iItem == -1) {
goto ContextCleanup;
}
apidl[0] = (LPCITEMIDLIST)rgItem.lParam;
}
// get the context menu interface for the object ....
UINT rgfInOut = 0;
CComObject<CThumbnailMenu>* pMenuTmp = new CComObject<CThumbnailMenu>;
if (pMenuTmp == NULL) {
goto ContextCleanup;
}
hRes = pMenuTmp->QueryInterface(IID_IContextMenu, (void**)&pICMenu);
Assert(SUCCEEDED(hRes));
hRes = pMenuTmp->Init(this, &rgfInOut, apidl, iSelectedCount);
if (FAILED(hRes)) {
goto ContextCleanup;
}
// it is an item not the background...
fItem = TRUE;
}
grfFlags = CMF_NORMAL | CMF_CANRENAME;
if (m_fExploreMode != FALSE) {
grfFlags |= CMF_EXPLORE;
}
Assert(hCMenu != NULL);
m_idCMStartOffset = SUBIDSTART;
pICMenu->QueryContextMenu(hCMenu, 0, SUBIDSTART, SUBIDEND, grfFlags);
// set site on the context menu if it will let us...
IUnknown_SetSite(pICMenu, (IUnknown*)(IShellView*)this);
// If this is the common dialog browser, we need to make the
// default command "Select" so that double-clicking (which is
// open in common dialog) makes sense.
if (m_pCommDlg && fItem) {
HMENU hmSelect = LoadPopupMenu(g_hinstDll, IDM_COMMDLG_POPUPMERGE);
// NOTE: Since commdlg always eats the default command,
// we don't care what id we assign hmSelect, as long as it
// doesn't conflict with any other context menu id.
// SUBIDSTART won't conflict with anyone.
MergeMenus(hCMenu, hmSelect, (UINT)(SUBIDSTART - 1), 0);
SetMenuDefaultItem(hCMenu, 0, MF_BYPOSITION);
DestroyMenu(hmSelect);
}
// cache the context menu so we can do the status bar stuff ...
// This function needs to be reentrant because the TrackPopupMenu call below blocks in it's own message
// pump. If we already have an m_pCMCache that means there is another WM_CONTEXTMENU message that is still
// being processed and is currently blocked in the TrackPopupMenu call. We need to discard the previously
// stored m_pCMCache and use the new one. Note that we aren't dealing with multi-threaded reentrance, just
// with recursion in our window proc due to the message pump in TrackPopupMenu.
if (m_pCMCache) {
m_pCMCache->Release();
}
m_pCMCache = pICMenu;
m_pCMCache->AddRef();
id = TrackPopupMenu(hCMenu, TPM_RETURNCMD | TPM_RIGHTBUTTON,
iX, iY, 0, m_hWnd, NULL);
// At this point we might have already released the m_pCMCache because we could have recursed into this
// function. If we reentered then we would have already released the interface and set m_pCMCache to
// NULL. Notice that we aren't dealing with multiple threads, just a recursion in our window proc due to
// the message pump in TrackPopupMenu. None of this code is thread safe but it doesn't need to be.
if (m_pCMCache) {
m_pCMCache->Release();
m_pCMCache = NULL;
}
// did we get a valid menu selection ?
if (id > 0) {
if (id >= SUBIDSTART && id <= SUBIDEND) {
// need to see if it was the rename command....
CHAR szBuffer[MAX_PATH];
szBuffer[0] = TEXT('\0');
hRes = pICMenu->GetCommandString(id - SUBIDSTART,
GCS_VERBA, NULL, (LPSTR)szBuffer, ARRAYSIZE(szBuffer));
// check for the unicode version...
if (FAILED(hRes)) {
WCHAR szCommand[60];
szCommand[0] = L'\0';
hRes = pICMenu->GetCommandString(id - SUBIDSTART,
GCS_VERBW, NULL, (LPSTR)szCommand, ARRAYSIZE(szCommand));
SHUnicodeToAnsi(szCommand, szBuffer, ARRAYSIZE(szBuffer));
}
if (SUCCEEDED(hRes) && StrCmpIA(szBuffer, "Rename") == 0) {
// force the view to rename it instead...
int iItem = rgInfo.iItem;
if (fItemsFromSelection && iItem == -1)
iItem = ListView_GetNextItem(m_hWndListView, -1, LVNI_SELECTED);
ListView_EditLabel(m_hWndListView, iItem);
} else {
Assert(m_pidl);
WCHAR szWBuffer[MAX_PATH];
SHGetPathFromIDListWrapW(m_pidl, szWBuffer);
SHUnicodeToAnsi(szWBuffer, szBuffer, ARRAYSIZE(szBuffer));
if (IsOS(OS_NT)) {
// pass the command to the element ....
CMINVOKECOMMANDINFOEX rgCommand;
memset(&rgCommand, 0, sizeof(rgCommand));
rgCommand.cbSize = sizeof(rgCommand);
rgCommand.lpVerb = (LPCSTR)MAKEINTRESOURCE(id - SUBIDSTART);
rgCommand.lpVerbW = (LPWSTR)rgCommand.lpVerb;
rgCommand.fMask = CMIC_MASK_UNICODE;
m_pBrowser->GetWindow(&(rgCommand.hwnd));
rgCommand.nShow = SW_NORMAL;
rgCommand.lpDirectory = szBuffer;
rgCommand.lpDirectoryW = szWBuffer;
pICMenu->InvokeCommand((CMINVOKECOMMANDINFO*)&rgCommand);
} else {
// pass the command to the element ....
CMINVOKECOMMANDINFO rgCommand;
memset(&rgCommand, 0, sizeof(rgCommand));
rgCommand.cbSize = sizeof(rgCommand);
rgCommand.lpVerb = (LPCSTR)MAKEINTRESOURCE(id - SUBIDSTART);
m_pBrowser->GetWindow(&(rgCommand.hwnd));
rgCommand.nShow = SW_NORMAL;
rgCommand.lpDirectory = szBuffer;
pICMenu->InvokeCommand(&rgCommand);
}
}
} else if ((id == SUBIDSTART - 1) && (m_pCommDlg != NULL)) {
// we are in the common dialog, and we are being told to do the default ...
// NOTE: we pass the Defview as the IshellView (it will delegate back)
hRes = m_pCommDlg->OnDefaultCommand(m_pDefView);
}
}
// we handled the command
lRes = FALSE;
ContextCleanup:
// clean up .....
// release the menu first incase it needs to tidy up the menu....
IUnknown_SetSite(pICMenu, NULL);
if (pICMenu != NULL)
pICMenu->Release();
if (hCMenu != NULL)
DestroyMenu(hCMenu);
if (apidl != 0)
delete[] apidl;
return lRes;
}
HRESULT CThumbnailView::CreateBackgroundMenu(IContextMenu** ppMenu)
{
Assert(m_pDefView != NULL);
// Ask the def-view IShellView for the context-menu
return m_pDefView->GetItemObject(SVGIO_BACKGROUND,
IID_IContextMenu,
(void**)ppMenu);
}
void CThumbnailView::UpdateStatusBar(LPCWSTR pszText, LPCWSTR pszText2)
{
int iSelCount;
WCHAR szStatusText[MAX_PATH + 1];
LRESULT lRes;
// make sure we have a pointer to the browser.
if (m_pBrowser == NULL)
return;
if (!pszText) {
// get selection count from view that is being displayed.
iSelCount = ListView_GetSelectedCount(m_hWndListView);
UINT idMsg = 0;
if (iSelCount > 0) {
idMsg = MSG_STATUS_OBJECTS_SELECTED;
} else {
idMsg = MSG_STATUS_OBJECTS;
iSelCount = ListView_GetItemCount(m_hWndListView);
}
void* pArg = (LPVOID)iSelCount;
FormatMessageWrapW(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
g_hinstDll,
idMsg,
0,
szStatusText,
MAX_PATH * 2,
(va_list*)&pArg);
pszText = szStatusText;
} else if (IS_INTRESOURCE(pszText)) {
LoadStringWrapW(g_hinstDll, PtrToUlong(pszText), szStatusText, ARRAYSIZE(szStatusText));
pszText = szStatusText;
}
// display the message.
m_pBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXTW, 0, (LPARAM)pszText, &lRes);
if (pszText2 && IS_INTRESOURCE(pszText2)) {
LoadStringWrapW(g_hinstDll, PtrToUlong(pszText), szStatusText, ARRAYSIZE(szStatusText));
pszText2 = szStatusText;
}
// display the message.
m_pBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXTW, 1, (LPARAM)pszText2, &lRes);
}
LRESULT CThumbnailView::OnWmMenuSelect(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
if (m_pCMCache == NULL) {
// there is no cached menu, forward it to the parent window
return SendMessageA(m_hWndParent, WM_MENUSELECT, wParam, lParam);
} else {
if (lParam != NULL && HIWORD(wParam) != 0xffff) {
// the user has not canceled the menu
WCHAR szMessage[MAX_PATH];
szMessage[0] = 0;
UINT idCmd = LOWORD(wParam) - m_idCMStartOffset;
UINT rgfFlags = HIWORD(wParam);
if (LOWORD(wParam) > m_idCMStartOffset
&& !(rgfFlags & MF_SEPARATOR)) {
HRESULT hRes = m_pCMCache->GetCommandString(idCmd,
GCS_HELPTEXTW,
NULL,
(LPSTR)szMessage,
ARRAYSIZE(szMessage));
// we have tried the uncode stuff, now try the ansi stuff.....
if (hRes != S_OK) {
CHAR szTmp[MAX_PATH];
szTmp[0] = 0;
hRes = m_pCMCache->GetCommandString(idCmd,
GCS_HELPTEXTA,
NULL,
szTmp,
ARRAYSIZE(szTmp));
if (hRes == S_OK) {
MultiByteToWideChar(CP_ACP, 0, szTmp, -1, szMessage, MAX_PATH);
}
}
}
LRESULT lRes = 0;
// send the text to the status bar ...
m_pBrowser->SendControlMsg(FCW_STATUS,
SB_SETTEXTW,
(WPARAM)0,
(LPARAM)(LPWSTR)szMessage,
&lRes);
m_pBrowser->SendControlMsg(FCW_STATUS,
SB_SETTEXTA,
(WPARAM)1,
(LPARAM)(LPTSTR)"",
&lRes);
}
return FALSE;
}
}
LRESULT CThumbnailView::OnLVNEndLabelEdit(NMHDR* pHdr)
{
LV_DISPINFOW* pInfo = (LV_DISPINFOW*)pHdr;
WCHAR szName[MAX_PATH];
LPITEMIDLIST pPidl = (LPITEMIDLIST)pInfo->item.lParam;
LPITEMIDLIST pNewPidl = NULL;
int iImage = pInfo->item.iImage;
if (pInfo->item.pszText == NULL || pInfo->item.iItem == -1) {
// the user has cancelled the edit....
return FALSE;
}
LV_ITEMW rgItem;
memset(&rgItem, 0, sizeof(LV_ITEM));
if (!(pInfo->item.mask & (LVIF_PARAM | LVIF_IMAGE))) {
// if we weren't give the pidl, go get it....
rgItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_NORECOMPUTE;
rgItem.iItem = pInfo->item.iItem;
ListView_GetItemWrapW(m_hWndListView, &rgItem);
pPidl = (LPITEMIDLIST)pInfo->item.lParam;
iImage = rgItem.iImage;
}
// all UNICODE now ...
// copy the new name the user entered
// MultiByteToWideChar( CP_ACP, 0, pInfo->item.pszText, -1, szName, MAX_PATH );
StrCpyW(szName, pInfo->item.pszText);
// the pidl might have dispappeared from under us if they put up a dialog box
// on failure because of the disk notifications.
LPITEMIDLIST pTmpPidl = ILClone(pPidl);
if (pTmpPidl == NULL) {
MessageBoxWrapW(m_hWndListView,
(LPCWSTR)MAKEINTRESOURCE(IDS_ERR_OUTOFMEM),
(LPCWSTR)MAKEINTRESOURCE(IDS_RENAME_TITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
return FALSE;
}
// the folder should handle the renaming including the old extension, as it is
// the only one that knows what the old extension was ....
HRESULT hRes = m_pFolder->SetNameOf(m_hWnd, pPidl, szName, 0, &pNewPidl);
if (SUCCEEDED(hRes)) {
// if we asked for a new pidl, then we should have one ....
Assert(pNewPidl != NULL);
// update the text on screen (I'm surprised it doesn't do this
// automatically ...
// update the pidl ..
rgItem.iItem = pInfo->item.iItem;
rgItem.mask = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
rgItem.lParam = (LPARAM)pNewPidl;
Assert(m_pImageCache);
m_pImageCache->DeleteImage(iImage);
// use the text we were given ...
rgItem.pszText = pInfo->item.pszText;
rgItem.iImage = I_IMAGECALLBACK;
ListView_SetItemWrapW(m_hWndListView, &rgItem);
// should free the old pidl
SHFree(pPidl);
} else {
// we have failed, we must find the item again because if they put up a dialog
// telling the user, it is highly likely that shell change notifications have
// been processed and we might not be on the same item. .....
int iItem = FindInView(m_hWndListView, m_pFolder, pTmpPidl);
if (iItem >= 0) {
SendMessageWrapW(m_hWndListView,
LVM_EDITLABEL,
pInfo->item.iItem,
(LPARAM)pInfo->item.pszText);
}
}
SHFree(pTmpPidl);
return FALSE;
}
LRESULT CThumbnailView::OnDefaultAction(BOOL fDoubleClick)
{
int iHitItem = -1;
BOOL fAlt = (GetAsyncKeyState(VK_MENU) < 0);
if (fDoubleClick) {
// only do a hit-test if there was a double-click.
POINT rgPoint;
DWORD dwPos = GetMessagePos();
rgPoint.x = LOWORD(dwPos);
rgPoint.y = HIWORD(dwPos);
BOOL bRes = ScreenToClient(m_hWndListView, &rgPoint);
LV_HITTESTINFO rgHit;
rgHit.pt = rgPoint;
rgHit.flags = LVHT_ONITEM;
// if there was a double click on the view, ignore it.
int iRes = ListView_HitTest(m_hWndListView, &rgHit);
if (iRes == -1) {
return FALSE;
}
iHitItem = iRes;
}
LPCONTEXTMENU pMenu = NULL;
HRESULT hRes = NOERROR;
// we hit something, use the selection from here on it....
int iCount = ListView_GetSelectedCount(m_hWndListView);
// if there is nothing selected ( this would only happen on enter ),
// then ignore it.
if (iCount <= 0) {
return FALSE;
}
LPCITEMIDLIST* apidl = new LPCITEMIDLIST[iCount];
if (apidl == NULL) {
// TODO: low memory situations
MessageBoxWrapW(m_hWnd,
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_OUTOFMEM),
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_SHELLTITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
}
GetSelectionPidlList(m_hWndListView, iCount, apidl, iHitItem);
UINT rgfFlags = 0;
// now generate the context menu for it ...
hRes = m_pFolder->GetUIObjectOf(m_hWnd,
iCount,
apidl,
IID_IContextMenu,
&rgfFlags,
(void**)&pMenu);
if (FAILED(hRes)) {
MessageBoxWrapW(m_hWnd,
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_CONTEXTMENUFAILED),
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_SHELLTITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
}
HMENU hMenu = CreatePopupMenu();
if (hMenu == NULL) {
MessageBoxWrapW(m_hWnd,
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_CONTEXTMENUFAILED),
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_SHELLTITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
}
UINT grfFlags = CMF_DEFAULTONLY;
if (m_fExploreMode != FALSE) {
grfFlags |= CMF_EXPLORE;
}
hRes = pMenu->QueryContextMenu(hMenu,
0,
SUBIDSTART,
SUBIDEND,
grfFlags);
if (FAILED(hRes)) {
MessageBoxWrapW(m_hWnd,
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_CONTEXTMENUFAILED),
(LPWSTR)MAKEINTRESOURCE(IDS_ERR_SHELLTITLE),
MB_OK | MB_SETFOREGROUND | MB_ICONSTOP);
}
int idCmd = -1;
if (!fAlt) {
// find the default command ID ..
int iSize = GetMenuItemCount(hMenu);
for (int iItem = 0; iItem < iSize; iItem++) {
MENUITEMINFOW mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_STATE;
GetMenuItemInfoWrapW(hMenu, iItem, TRUE, &mii);
if ((mii.fState & MFS_DEFAULT) && !(mii.fState & (MFS_GRAYED | MFS_DISABLED))) {
idCmd = (int)mii.wID;
break;
}
}
// use the first item anyway if there is no default ....
if (idCmd == -1) {
MENUITEMINFOW mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_STATE;
GetMenuItemInfoWrapW(hMenu, 0, TRUE, &mii);
idCmd = mii.wID;
if (mii.fState & (MFS_GRAYED | MFS_DISABLED)) {
idCmd = -1;
}
}
}
if (idCmd != -1 || fAlt) {
WCHAR szWDirectory[MAX_PATH];
CHAR szDirectory[MAX_PATH];
Assert(m_pidl);
SHGetPathFromIDListWrapW(m_pidl, szWDirectory);
SHUnicodeToAnsi(szWDirectory, szDirectory, ARRAYSIZE(szDirectory));
if (IsOS(OS_NT)) {
CMINVOKECOMMANDINFOEX rgCmd;
memset(&rgCmd, 0, sizeof(rgCmd));
rgCmd.cbSize = sizeof(rgCmd);
if (fAlt) {
rgCmd.lpVerb = "Properties";
rgCmd.lpVerbW = L"Properties";
} else {
rgCmd.lpVerb = (LPSTR)idCmd - SUBIDSTART;
rgCmd.lpVerbW = (LPWSTR)rgCmd.lpVerb;
}
rgCmd.nShow = SW_NORMAL;
m_pBrowser->GetWindow(&(rgCmd.hwnd));
rgCmd.fMask = CMIC_MASK_UNICODE;
// execute the command finally !!
hRes = pMenu->InvokeCommand((CMINVOKECOMMANDINFO*)&rgCmd);
} else {
CMINVOKECOMMANDINFO rgCmd;
memset(&rgCmd, 0, sizeof(rgCmd));
rgCmd.cbSize = sizeof(rgCmd);
if (fAlt) {
rgCmd.lpVerb = "Properties";
} else {
rgCmd.lpVerb = (LPSTR)idCmd - SUBIDSTART;
}
rgCmd.nShow = SW_NORMAL;
m_pBrowser->GetWindow(&(rgCmd.hwnd));
rgCmd.lpDirectory = szDirectory;
// execute the command finally !!
hRes = pMenu->InvokeCommand(&rgCmd);
}
}
DestroyMenu(hMenu);
pMenu->Release();
delete[] apidl;
return TRUE;
}
LRESULT CThumbnailView::OnWmCreate(HWND hWnd, LPCREATESTRUCT pCreate)
{
SetWindowLongPtrA(hWnd, 0, (LONG_PTR)this);
// remember the hWnd
m_hWnd = hWnd;
// create the Enhanced view with a size of zero (remember the move is coming next ...)
DWORD dwStyle = LVS_ICON | LVS_SHAREIMAGELISTS | LVS_EDITLABELS | LVS_SHOWSELALWAYS;
if (m_rgSettings.fFlags & FWF_SINGLESEL) {
dwStyle |= LVS_SINGLESEL;
}
if (m_rgSettings.fFlags & FWF_NOSCROLL) {
dwStyle |= LVS_NOSCROLL;
}
if (m_rgSettings.fFlags & FWF_ALIGNLEFT) {
dwStyle |= LVS_ALIGNLEFT;
}
m_hWndListView = CreateWindowExWrapW(WS_EX_CLIENTEDGE,
WC_LISTVIEWW, NULL,
WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | dwStyle,
0, 0,
0, 0, m_hWnd, NULL, g_hinstDll, NULL);
if (m_hWndListView == NULL) {
// fail the create...
return -1;
}
// get the imagelists we will use, here we just grab the system ones
SHFILEINFO rgInfo;
m_hSysLargeImgLst = (HIMAGELIST)SHGetFileInfo(TEXT("*.exe"), 0, &rgInfo, sizeof(rgInfo),
SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES | SHGFI_LARGEICON);
m_hSysSmallImgLst = (HIMAGELIST)SHGetFileInfo(TEXT("*.exe"), 0, &rgInfo, sizeof(rgInfo),
SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES | SHGFI_SMALLICON);
Assert(m_himlThumbs);
ListView_SetImageList(m_hWndListView, m_himlThumbs, LVSIL_NORMAL);
ListView_Arrange(m_hWndListView, LVA_SNAPTOGRID);
int cxIcon, cyIcon;
ImageList_GetIconSize(m_hSysLargeImgLst, &cxIcon, &cyIcon);
ListView_SetIconSpacing(m_hWndListView, cxIcon / 4 + m_iXSizeThumbnail + 1, 0);
// create the window's accelerator table.
// TODO:
// m_hAccel = LoadAccelerators( g_hinstDll, MAKEINTRESOURCE( IDR_ACCELERATOR1 ));
DWORD dwMainStyle;
if (!(m_rgSettings.fFlags & FWF_AUTOARRANGE)) {
// turn off autoarrange if not asked for ....
dwMainStyle = GetWindowStyle(m_hWndListView) & ~LVS_AUTOARRANGE;
SetWindowLongWrapW(m_hWndListView, GWL_STYLE, dwMainStyle);
} else {
// turn on auto arrange in enhanced view.
// this has to be done after setting the imagelist for the enhanced view,
// so that the auto-arrange will work with the appropriate thumbnail size.
dwMainStyle = GetWindowStyle(m_hWndListView) | LVS_AUTOARRANGE;
SetWindowLongWrapW(m_hWndListView, GWL_STYLE, dwMainStyle);
}
ListView_SetExtendedListViewStyle(m_hWndListView, LVS_EX_INFOTIP | LVS_EX_BORDERSELECT);
CheckViewOptions();
return 0;
}
LRESULT CThumbnailView::OnWmDestroy(HWND hWnd)
{
if (m_hWndListView != NULL) {
// ensure it has been emptied ....
HWND hWndList = m_hWndListView;
m_hWndListView = NULL;
Clear(hWndList);
DestroyWindow(hWndList);
}
return 0;
}
HRESULT CThumbnailView::StartDragDrop(NM_LISTVIEW* pNMHdr)
{
LPDATAOBJECT pDataObject = NULL;
LPDROPSOURCE pDropSrc = NULL;
HRESULT hRes = NOERROR;
DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
UINT rgfFlags;
CComObject<CViewDropSource>* pSrc = NULL;
LPCITEMIDLIST* apidl = NULL;
int iSelCount = 0;
// get the view origin
this->GetOrigin(&m_ptDragStart);
// add on the current position within the view, therefore getting the true view start pos
m_ptDragStart.x += pNMHdr->ptAction.x;
m_ptDragStart.y += pNMHdr->ptAction.y;
m_pDropTarget->DragStartHere(&m_ptDragStart);
// how many elements selected ?
iSelCount = ListView_GetSelectedCount(m_hWndListView);
apidl = new LPCITEMIDLIST[iSelCount];
if (apidl == NULL) {
return E_OUTOFMEMORY;
}
// pidl list big enough for the selection
hRes = GetSelectionPidlList(m_hWndListView, iSelCount, apidl, pNMHdr->iItem);
if (FAILED(hRes)) {
hRes = E_FAIL;
goto SDDErrorRecovery;
}
// fetch the attributes of the selection
hRes = m_pFolder->GetAttributesOf(iSelCount, apidl, &dwEffect);
if (FAILED(hRes)) {
// use the hRes fail result
goto SDDErrorRecovery;
}
// ignore all other bits returned....
dwEffect &= (DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY);
hRes = NOERROR;
pSrc = new CComObject<CViewDropSource>;
if (pSrc != NULL) {
if (FAILED(hRes)) {
delete pSrc;
goto SDDErrorRecovery;
}
// get a ref on the object...
hRes = pSrc->QueryInterface(IID_IDropSource, (void**)&pDropSrc);
Assert(SUCCEEDED(hRes));
} else {
hRes = E_OUTOFMEMORY;
goto SDDErrorRecovery;
}
rgfFlags = SVGIO_SELECTION;
// get the DataObject covering the selection...
hRes = m_pFolder->GetUIObjectOf(m_hWnd, iSelCount, apidl, IID_IDataObject,
&rgfFlags, (void**)&pDataObject);
if (SUCCEEDED(hRes)) {
// used to detect if we are dropping in the same view ...
m_fDragStarted = TRUE;
// try and set the item positions in the data object...
SetPointData(pDataObject, apidl, iSelCount);
// Before we enter drag drop, try and initialize the drag images.
if (m_pDragImages)
m_pDragImages->InitializeFromWindow(m_hWndListView, 0, pDataObject);
// here we go, ole drag and drop ....
hRes = DoDragDrop(pDataObject, pDropSrc, dwEffect, &dwEffect);
m_fDragStarted = FALSE;
pDropSrc->Release();
pDropSrc = NULL;
pDataObject->Release();
}
SDDErrorRecovery:
if (pDropSrc != NULL) {
pDropSrc->Release();
}
if (apidl != NULL) {
delete[](LPITEMIDLIST*) apidl;
}
m_fDragStarted = FALSE;
return hRes;
}
LRESULT CThumbnailView::OnViewGetThumbnail(NMHDR* pHdr)
{
LV_DISPINFO* pInfo = (LV_DISPINFO*)pHdr;
WCHAR szFileName[MAX_PATH];
HBITMAP hBmpThumb = NULL;
UINT iImageIndex = (UINT)I_IMAGECALLBACK;
LPCITEMIDLIST pidl = (LPCITEMIDLIST)pInfo->item.lParam;
UINT rgFlags = 0;
UINT iIndex = (UINT)I_IMAGECALLBACK;
HRESULT hr = NOERROR;
BOOL fStampIcon = FALSE;
if (pidl == NULL) {
// we should always get a pidl...
Assert(FALSE);
return TRUE;
}
DWORD dwMask = GetOverlayMask(pidl);
DWORD dwStoreFlags = 0;
// is the thumbnail cache at its limit ? If so, we had better try and make space..
UINT uTmp = 0;
m_pImageCache->GetCacheSize(&uTmp);
int iCacheSpace = m_iMaxCacheSize - uTmp;
int iQueuedFetch = 0;
if (m_pScheduler) {
iQueuedFetch = m_pScheduler->CountTasks(TOID_ExtractImageTask);
iQueuedFetch += m_pScheduler->CountTasks(TOID_DiskCacheTask);
iQueuedFetch -= m_pScheduler->CountTasks(TOID_ImgCacheTidyup);
}
iCacheSpace -= iQueuedFetch;
// add enough scroungers to shrink the cache to the right size...
while ((iCacheSpace++) < 0) {
IRunnableTask* pTask;
hr = CImgCacheTidyup_Create(m_pImageCache, FALSE, m_hWndListView, &m_iLastCtr, &pTask);
if (SUCCEEDED(hr)) {
if (m_pScheduler) {
m_pScheduler->AddTask(pTask,
TOID_ImgCacheTidyup,
ITSAT_DEFAULT_LPARAM,
PRIORITY_NORMAL);
} else {
pTask->Run();
pTask->Release();
}
}
}
hr = ExtractItem(&iImageIndex, pInfo->item.iItem, pidl, TRUE, FALSE);
if (hr != S_OK) {
// create the default one for that file type,
// the index into the sys image list is used to detect items of the
// same type, thus we only generate one default thumbnail for each
// particular icon needed
iIndex = (UINT)ViewGetIconIndex(pidl);
if (iIndex == (UINT)I_IMAGECALLBACK)
iIndex = II_DOCNOASSOC;
// check if the image is already in the image cache.
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_NAME | ICIFLAG_FLAGS | ICIFLAG_INDEX;
rgInfo.pszName = c_szDefault;
rgInfo.dwFlags = dwMask;
rgInfo.iIndex = (int)iIndex;
hr = m_pImageCache->FindImage(&rgInfo, &iImageIndex);
if (hr != S_OK) {
hr = CreateDefaultThumbnail(iIndex, &hBmpThumb, m_fDrawBorder);
StrCpyW(szFileName, c_szDefault);
iImageIndex = (UINT)I_IMAGECALLBACK;
}
}
if (hBmpThumb != NULL) {
// we are creating a new one, so we shouldn't have an index yet ..
Assert(iImageIndex == I_IMAGECALLBACK);
#if 0 // never gets called, fStampIcon always false . . .
if (fStampIcon) {
// a small icon is stamped in bottom right-hand corner of thumbnail.
StampIconOnThumbnail(pidl, hBmpThumb);
}
#endif
// copy thumbnail into the imagelist.
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_NAME | ICIFLAG_FLAGS | ICIFLAG_INDEX | ICIFLAG_LARGE | ICIFLAG_BITMAP;
rgInfo.pszName = szFileName;
rgInfo.dwFlags = dwMask;
rgInfo.iIndex = (int)iIndex;
rgInfo.hBitmapLarge = hBmpThumb;
rgInfo.hMaskLarge = NULL;
if (!fStampIcon) {
rgInfo.dwMask |= ICIFLAG_NOUSAGE;
}
if (IS_BIDI_LOCALIZED_SYSTEM()) {
rgInfo.dwMask |= ICIFLAG_MIRROR;
}
hr = m_pImageCache->AddImage(&rgInfo, &iImageIndex);
DeleteObject(hBmpThumb);
}
pInfo->item.iImage = (int)iImageIndex;
return FALSE;
}
DWORD CThumbnailView::GetOverlayMask(LPCITEMIDLIST pidl)
{
DWORD dwLink = SFGAO_LINK | SFGAO_SHARE | SFGAO_GHOSTED;
m_pFolder->GetAttributesOf(1, &pidl, &dwLink);
return dwLink;
}
int CThumbnailView::ViewGetIconIndex(LPCITEMIDLIST pidl)
{
// do we have an IShellIcon interface ?
if (m_pIcon != NULL) {
int iIndex = -1;
HRESULT hRes = m_pIcon->GetIconOf(pidl, 0, &iIndex);
// check to see if we succeeded and we weren't told to extract the icon
// ourselves ...
if (SUCCEEDED(hRes) && hRes != S_FALSE) {
IShellIconOverlay* pio;
if (SUCCEEDED(m_pFolder->QueryInterface(IID_IShellIconOverlay, (LPVOID*)&pio))) {
int iOverlay;
if (SUCCEEDED(pio->GetOverlayIndex(pidl, &iOverlay))) {
iIndex |= iOverlay << 24;
}
pio->Release();
}
return iIndex;
}
}
SHFILEINFO rgInfo;
LPITEMIDLIST pidlFull;
rgInfo.iIcon = -1;
pidlFull = ILCombine(m_pidl, pidl);
if (pidlFull) {
SHGetFileInfo((LPCTSTR)pidlFull, 0, &rgInfo, sizeof(rgInfo),
SHGFI_SYSICONINDEX | SHGFI_LARGEICON | SHGFI_PIDL | SHGFI_OVERLAYINDEX);
ILFree(pidlFull);
}
return (rgInfo.iIcon >= 0) ? rgInfo.iIcon : II_DOCNOASSOC;
}
//puts the associated icon in bottom left-hand side of thumbnail.
void CThumbnailView::StampIconOnThumbnail(LPCITEMIDLIST pidl, HBITMAP hBmpThumb, BOOL fBorder)
{
HDC hDC = GetDC(m_hWndListView);
HDC hDCMem = CreateCompatibleDC(hDC);
int iImage = ViewGetIconIndex(pidl);
// select the thumbnail bitmap into the memory DC.
HGDIOBJ hTmp = SelectObject(hDCMem, hBmpThumb);
if (m_fIconStamp) {
ImageList_Draw(m_hSysSmallImgLst, (iImage & 0x00ffffff), hDCMem,
m_iXSizeThumbnail - 20, // left.
m_iYSizeThumbnail - 20, // top.
ILD_TRANSPARENT | (INDEXTOOVERLAYMASK(iImage >> 24)));
}
if (fBorder) {
// put a black shadow border on it...
// assume the bitmap is the size we specified...
DrawShadowBorder(hDCMem, 0, 0, m_iXSizeThumbnail, m_iYSizeThumbnail);
}
// get the bitmap back.
SelectObject(hDCMem, hTmp);
// release stuff.
ReleaseDC(m_hWndListView, hDC);
DeleteDC(hDCMem);
}
#define COLOR_BLACK RGB(0, 0, 0)
#define COLOR_DKGRAY RGB(128, 128, 128)
#define COLOR_LTGRAY RGB(192, 192, 192)
#define COLOR_WHITE RGB(255, 255, 255)
void CThumbnailView::DrawShadowBorder(HDC hdc, int x, int y, int dx, int dy)
{
RECT rc;
COLORREF clrSave = SetBkColor(hdc, COLOR_DKGRAY);
int iOldMM = SetMapMode(hdc, MM_TEXT);
//left
rc.left = x;
rc.top = y;
rc.right = x + 1;
rc.bottom = y + dy;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
//top
rc.left = rc.right;
rc.right = rc.left + dx - 2;
rc.bottom = rc.top + 1;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
//right inner
SetBkColor(hdc, COLOR_LTGRAY);
rc.left = rc.right - 1;
rc.top = rc.bottom;
rc.bottom = rc.top + dy - 3;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
// right outer
SetBkColor(hdc, COLOR_BLACK);
rc.left = rc.right;
rc.right = rc.left + 1;
rc.top -= 1;
rc.bottom = rc.top + dy;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
// bottom inner
SetBkColor(hdc, COLOR_LTGRAY);
rc.left = x + 1;
rc.right = rc.left + dx - 2;
rc.bottom -= 1;
rc.top = rc.bottom - 1;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
// bottom outer
SetBkColor(hdc, COLOR_BLACK);
rc.left -= 1;
rc.right += 1;
rc.top = rc.bottom;
rc.bottom = rc.top + 1;
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
SetMapMode(hdc, iOldMM);
SetBkColor(hdc, clrSave);
return;
}
HRESULT CThumbnailView::CreateDefaultThumbnail(int iIndex, HBITMAP* phBmpThumbnail, BOOL fDrawBorder)
{
HDC hdc = GetDC(NULL);
HDC hMemDC = CreateCompatibleDC(hdc);
HRESULT hr = E_FAIL;
// get the background for the default thumbnail.
if (!hMemDC)
goto LGone;
*phBmpThumbnail = CreateCompatibleBitmap(hdc, m_iXSizeThumbnail, m_iYSizeThumbnail);
if (*phBmpThumbnail) {
HGDIOBJ hTmp = SelectObject(hMemDC, *phBmpThumbnail);
COLORREF clrOld = SetBkColor(hMemDC, GetSysColor(COLOR_WINDOW));
RECT rc = {0, 0, m_iXSizeThumbnail, m_iYSizeThumbnail};
ExtTextOut(hMemDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
SetBkColor(hMemDC, clrOld);
int cxIcon, cyIcon, x, y, dx, dy;
// calculate position and width of icon.
ImageList_GetIconSize(m_hSysLargeImgLst, &cxIcon, &cyIcon);
if (cxIcon < m_iXSizeThumbnail) {
x = (m_iXSizeThumbnail - cxIcon) / 2;
dx = cxIcon;
} else {
// in case icon size is larger than thumbnail size.
x = 0;
dx = m_iXSizeThumbnail;
}
if (cyIcon < m_iYSizeThumbnail) {
y = (m_iYSizeThumbnail - cyIcon) / 2;
dy = cyIcon;
} else {
// in case icon size is larger than thumbnail size.
y = 0;
dy = m_iYSizeThumbnail;
}
ImageList_DrawEx(m_hSysLargeImgLst, (iIndex & 0x00ffffff), hMemDC,
x, // left.
y, // top.
dx,
dy,
CLR_DEFAULT,
CLR_DEFAULT,
ILD_TRANSPARENT | (INDEXTOOVERLAYMASK(iIndex >> 24)));
if (m_fDrawBorder) {
DrawShadowBorder(hMemDC, 0, 0, m_iXSizeThumbnail, m_iYSizeThumbnail);
}
// get the bitmap produced so that it will be returned.
*phBmpThumbnail = (HBITMAP)SelectObject(hMemDC, hTmp);
hr = S_OK;
}
LGone:
if (hMemDC)
DeleteDC(hMemDC);
ReleaseDC(NULL, hdc);
return hr;
}
int CThumbnailView::FindItem(LPCITEMIDLIST pidl)
{
return FindInView(m_hWndListView, m_pFolder, pidl);
}
HRESULT CThumbnailView::TaskUpdateItem(LPCITEMIDLIST pidl,
int iItem,
DWORD dwMask,
LPCWSTR pszPath,
const FILETIME* pftDateStamp,
int iThumbnail,
HBITMAP hBmp)
{
// check the size of the bitmap to make sure it is big enough, if it is not, then
// we must center it on a background...
BITMAP rgBitmap;
HBITMAP hBmpCleanup = NULL;
HRESULT hr = E_FAIL;
if (::GetObjectWrapW((HGDIOBJ)hBmp, sizeof(rgBitmap), (LPVOID)&rgBitmap)) {
// if the image is the wrong size, or the wrong colour depth, then do the funky stuff on it..
if (rgBitmap.bmWidth != m_iXSizeThumbnail ||
rgBitmap.bmHeight != m_iYSizeThumbnail ||
rgBitmap.bmBitsPixel > m_dwRecClrDepth) {
// alloc the colour table just incase....
LPBITMAPINFO pInfo = (LPBITMAPINFO)LocalAlloc(LPTR, sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 256);
if (pInfo) {
// get a DC for this operation...
HDC hdcMem = CreateCompatibleDC(NULL);
if (hdcMem) {
pInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
if (GetDIBits(hdcMem, hBmp, 0, 0, NULL, pInfo, DIB_RGB_COLORS)) {
// we have the header, now get the data....
void* pBits = LocalAlloc(LPTR, pInfo->bmiHeader.biSizeImage);
if (pBits) {
if (GetDIBits(hdcMem, hBmp, 0, pInfo->bmiHeader.biHeight, pBits, pInfo, DIB_RGB_COLORS)) {
SIZE rgSize = {m_iXSizeThumbnail, m_iYSizeThumbnail};
RECT rgRect = {0, 0, rgBitmap.bmWidth, rgBitmap.bmHeight};
CalculateAspectRatio(&rgSize, &rgRect);
if (FactorAspectRatio(pInfo, pBits, &rgSize, rgRect, m_dwRecClrDepth, m_hpal, FALSE, &hBmpCleanup)) {
// finally success :-) we have the new image we can abandon the old one...
hBmp = hBmpCleanup;
hr = S_OK;
}
}
LocalFree(pBits);
}
}
// cleanup ....
DeleteDC(hdcMem);
}
LocalFree(pInfo);
}
} else {
// the original bitmap is fine
hr = S_OK;
}
}
UINT iImage;
if (SUCCEEDED(hr)) {
// a small icon is stamped in bottom right-hand corner of thumbnail.
StampIconOnThumbnail(pidl, hBmp, m_fDrawBorder);
// check if we are going away, if so, then don't use Sendmessage because it will block the
// destructor of the scheduler...
if (m_fDestroying) {
hr = E_FAIL;
} else {
// copy thumbnail into the cache.
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_NAME | ICIFLAG_FLAGS | ICIFLAG_INDEX | ICIFLAG_LARGE | ICIFLAG_BITMAP;
rgInfo.pszName = pszPath;
rgInfo.dwFlags = dwMask;
rgInfo.iIndex = (int)iThumbnail;
rgInfo.hBitmapLarge = hBmp;
rgInfo.hMaskLarge = NULL;
if (pftDateStamp) {
rgInfo.dwMask |= ICIFLAG_DATESTAMP;
rgInfo.ftDateStamp = *pftDateStamp;
}
if (IS_BIDI_LOCALIZED_SYSTEM()) {
rgInfo.dwMask |= ICIFLAG_MIRROR;
}
hr = m_pImageCache->AddImage(&rgInfo, &iImage);
}
}
if (hBmpCleanup) {
DeleteObject(hBmpCleanup);
}
if (hr == S_OK) {
// check if we are going away, if so, then don't use Sendmessage because it will block the
// destructor of the scheduler...
if (m_fDestroying) {
return E_FAIL;
}
// post a message to the main thread so we don't block....
::PostMessageA(m_hWnd, WM_UPDATEITEMIMAGE, iItem, iImage);
}
return hr;
}
HRESULT CThumbnailView::ViewUpdateThumbnail(LPCITEMIDLIST pidl, LPCWSTR pszPath, HBITMAP hBitmap)
{
int iItem = FindInView(m_hWndListView, m_pFolder, pidl);
if (iItem == -1) {
return E_INVALIDARG;
}
DWORD dwMask = GetOverlayMask(pidl);
LV_ITEMW rgItem;
ZeroMemory(&rgItem, sizeof(rgItem));
rgItem.mask = LVIF_IMAGE | LVIF_NORECOMPUTE;
rgItem.iItem = iItem;
BOOL bRes = ListView_GetItemWrapW(m_hWndListView, &rgItem);
Assert(bRes);
/*[TODO: do something about persisting the image ... and color reduction ]*/
// a small icon is stamped in bottom right-hand corner of thumbnail.
StampIconOnThumbnail(pidl, hBitmap, m_fDrawBorder);
if (rgItem.iImage != I_IMAGECALLBACK) {
// if it is a shared thumbnail, then the cache will handle if it is to be
// deleted or not.
m_pImageCache->FreeImage((UINT)rgItem.iItem);
}
// there is no item in the cache for it, so we can tag it on the end
UINT iImage;
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_NAME | ICIFLAG_FLAGS | ICIFLAG_BITMAP | ICIFLAG_LARGE;
rgInfo.pszName = pszPath;
rgInfo.dwFlags = dwMask;
rgInfo.hBitmapLarge = hBitmap;
rgInfo.hMaskLarge = NULL;
if (IS_BIDI_LOCALIZED_SYSTEM()) {
rgInfo.dwMask |= ICIFLAG_MIRROR;
}
HRESULT hr = m_pImageCache->AddImage(&rgInfo, &iImage);
if (FAILED(hr)) {
return hr;
}
rgItem.iImage = (int)iImage;
ListView_SetItemWrapW(m_hWndListView, &rgItem);
RECT rcImage;
ListView_GetItemRect(m_hWndListView, rgItem.iItem, &rcImage, LVIR_BOUNDS);
InvalidateRect(m_hWndListView, &rcImage, FALSE);
return NOERROR;
}
#define BLOCKSIZE 100
void CThumbnailView::UpdateWithoutRefresh()
{
// which one are we looking at ?
LPENUMIDLIST pEnum = NULL;
// on error do a refresh
BOOL fRefresh = FALSE;
int iIndex = -1;
ULONG celtFetched = 0;
ULONG celtThisBlock = 0;
HRESULT hRes = NOERROR;
ULONG ulType = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
LPITEMIDLIST* apCurBlock = NULL;
LPITEMIDLIST* apElems = new LPITEMIDLIST[BLOCKSIZE + 1];
if (apElems == NULL) {
fRefresh = TRUE;
goto UpdateCleanup;
}
apCurBlock = apElems;
apCurBlock[BLOCKSIZE] = NULL;
if (m_fShowAllObjects) {
ulType |= SHCONTF_INCLUDEHIDDEN;
}
hRes = m_pFolder->EnumObjects(this->m_hWnd, ulType,
&pEnum);
if (FAILED(hRes)) {
fRefresh = TRUE;
goto UpdateCleanup;
}
// fetch all the new elements ...
do {
// we cannot assume that Next() can return more than one element at
// a time, as most of the IShellFolder implementers of this only
// support one at a time... (so much for relying on the spec....)
celtFetched = 0;
hRes = pEnum->Next(BLOCKSIZE - celtThisBlock, apCurBlock + celtThisBlock, &celtFetched);
if (celtFetched == 0) {
break;
}
// add this lot to the current block count
celtThisBlock += celtFetched;
if (celtThisBlock == BLOCKSIZE) {
// allocate next block
apCurBlock[BLOCKSIZE] = (LPITEMIDLIST) new LPITEMIDLIST[BLOCKSIZE + 1];
if (apCurBlock[BLOCKSIZE] == NULL) {
fRefresh = TRUE;
goto UpdateCleanup;
} else {
celtThisBlock = 0;
apCurBlock = (LPITEMIDLIST*)apCurBlock[BLOCKSIZE];
apCurBlock[BLOCKSIZE] = NULL;
}
}
} while (celtFetched != 0);
// if we reached here, we got a whole load of pidls in an array ...
// now walk the view checking to see if what we have are valid or not ...
do {
iIndex = ListView_GetNextItem(m_hWndListView, iIndex, LVNI_ALL);
if (iIndex == -1) {
break;
}
LV_ITEMW rgItem;
rgItem.iItem = iIndex;
rgItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_NORECOMPUTE;
rgItem.iSubItem = 0;
int iItem = ListView_GetItemWrapW(m_hWndListView, &rgItem);
// just incase. ...
if (iItem != -1) {
LPITEMIDLIST pidl = (LPITEMIDLIST)rgItem.lParam;
// must walk our data chain to find the pidl ...
BOOL fFound = FALSE;
LPITEMIDLIST* apSearch = apElems;
while (apSearch != NULL) {
int iMaxSearch = BLOCKSIZE;
// the last block may not be full
if (apSearch[BLOCKSIZE] == NULL) {
iMaxSearch = celtThisBlock;
}
int iSearch;
for (iSearch = 0; iSearch < iMaxSearch; iSearch++) {
// skip used pidls.
if (apSearch[iSearch] == NULL) {
continue;
}
// try the legal method...
if (this->m_pFolder->CompareIDs(0, pidl, apSearch[iSearch]) == 0) {
fFound = TRUE;
break;
}
}
if (fFound) {
// now we need to check if the image is out of date...
if (rgItem.iImage != I_IMAGECALLBACK) {
IExtractImage* pExtract;
IExtractImage2* pExtract2;
UINT rgfFlags = 0;
FILETIME ftDateStamp;
hRes = m_pFolder->GetUIObjectOf(m_hWnd, 1, (LPCITEMIDLIST*)&pidl,
IID_IExtractImage,
&rgfFlags,
(void**)&pExtract);
if (SUCCEEDED(hRes)) {
hRes = pExtract->QueryInterface(IID_IExtractImage, (void**)&pExtract2);
pExtract->Release();
}
if (SUCCEEDED(hRes)) {
hRes = pExtract2->GetDateStamp(&ftDateStamp);
pExtract2->Release();
}
if (SUCCEEDED(hRes)) {
// now fetch the datestamp from the icon cache so we can see if it has changed...
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_DATESTAMP;
hRes = m_pImageCache->GetImageInfo(rgItem.iImage, &rgInfo);
if (SUCCEEDED(hRes)) {
if (rgInfo.ftDateStamp.dwLowDateTime != ftDateStamp.dwLowDateTime ||
rgInfo.ftDateStamp.dwHighDateTime != ftDateStamp.dwHighDateTime) {
// Delete The image so that it will have to be re-fetched....
m_pImageCache->DeleteImage(rgItem.iImage);
rgItem.iImage = I_IMAGECALLBACK;
rgItem.mask = LVIF_IMAGE;
ListView_SetItemWrapW(m_hWndListView, &rgItem);
}
}
}
}
// free the pidl as don't need it
SHFree((LPVOID)apSearch[iSearch]);
// mark it as NULL
apSearch[iSearch] = NULL;
break;
}
// next block of pidls...
apSearch = (LPITEMIDLIST*)apSearch[BLOCKSIZE];
}
if (!fFound) {
// remove thumbnail from the cache.
if (rgItem.iImage != I_IMAGECALLBACK) {
// now remove it from the thumbnail cache.
m_pImageCache->FreeImage((UINT)rgItem.iImage);
}
ListView_DeleteItem(m_hWndListView, iIndex);
// move back an item in the listview ...
iIndex--;
// free the pidl...
SHFree((LPVOID)pidl);
}
}
} while (TRUE);
// now search the blocks for pidls we don't have and add them ....
apCurBlock = apElems;
while (apCurBlock != NULL) {
int iMaxIndex = BLOCKSIZE;
// the last block may not be full
if (apCurBlock[BLOCKSIZE] == NULL) {
iMaxIndex = celtThisBlock;
}
for (int iSearch = 0; iSearch < iMaxIndex; iSearch++) {
// skip used pidls.
if (apCurBlock[iSearch] == NULL) {
continue;
}
AddItem(apCurBlock[iSearch]);
// the view now owns the pidl...
apCurBlock[iSearch] = NULL;
}
// next block of pidls...
LPITEMIDLIST* apNext = (LPITEMIDLIST*)apCurBlock[BLOCKSIZE];
delete[] apCurBlock;
apCurBlock = apNext;
}
apElems = NULL;
UpdateCleanup:
// walk the list freeing and releasing memory.....
if (apElems != NULL) {
do {
apCurBlock = apElems;
int iMaxIndex = BLOCKSIZE;
if (apCurBlock[BLOCKSIZE] == NULL) {
iMaxIndex = celtThisBlock;
}
for (int iElem = 0; iElem < iMaxIndex; iElem++) {
if (apCurBlock[iElem] != NULL) {
SHFree(apCurBlock[iElem]);
}
}
apElems = (LPITEMIDLIST*)apElems[BLOCKSIZE];
delete[] apCurBlock;
} while (apElems != NULL);
}
if (fRefresh == TRUE) {
// a last resort, refresh...
Refresh();
}
if (pEnum) pEnum->Release();
}
HRESULT CThumbnailView::ExtractItem(UINT* puIndex, int iItem, LPCITEMIDLIST pidl, BOOL fBackground, BOOL fForce)
{
// this will do an extract and put it in the queue if possible
if (iItem == -1 && !pidl) {
// failure....
return FALSE;
}
if (iItem == -1) {
iItem = FindItem(pidl);
if (iItem == -1) {
return FALSE;
}
}
UINT uIndex = 0;
if (!puIndex) {
puIndex = &uIndex;
}
if (!pidl) {
LV_ITEMW rgItem;
ZeroMemory(&rgItem, sizeof(rgItem));
rgItem.mask = LVIF_PARAM | LVIF_NORECOMPUTE;
rgItem.iItem = iItem;
if (ListView_GetItemWrapW(m_hWndListView, &rgItem) == -1) {
return FALSE;
}
pidl = (LPCITEMIDLIST)rgItem.lParam;
}
DWORD dwMask = GetOverlayMask(pidl);
// now create a task
IRunnableTask* pTask = NULL;
IExtractImage2* pExtract = NULL;
WCHAR szPath[MAX_PATH];
HRESULT hr = NOERROR;
UINT rgfFlags = 0;
// try for a thumbnail handler ...
hr = m_pFolder->GetUIObjectOf(m_hWnd,
1,
&pidl,
IID_IExtractImage,
&rgfFlags,
(void**)&pExtract);
if (SUCCEEDED(hr)) {
Assert(pExtract != NULL);
DWORD dwFlags = IEIFLAG_ASYNC | IEIFLAG_ORIGSIZE;
DWORD dwPriority = PRIORITY_NORMAL;
SIZE rgThumbSize = {m_iXSizeThumbnail, m_iYSizeThumbnail};
FILETIME ftImageTimeStamp;
BOOL fNoDateStamp = TRUE;
IExtractImage2* pExtract2;
// od they support date stamps....
if (SUCCEEDED(pExtract->QueryInterface(IID_IExtractImage2, (void**)&pExtract2))) {
if (FAILED(pExtract2->GetDateStamp(&ftImageTimeStamp))) {
ZeroMemory(&ftImageTimeStamp, sizeof(ftImageTimeStamp));
} else {
// Houston, we have a date stamp..
fNoDateStamp = FALSE;
}
pExtract2->Release();
}
if (m_fOffline) {
dwFlags |= IEIFLAG_OFFLINE;
}
// always extract at 24 bit incase we have to cache it ...
hr = pExtract->GetLocation(szPath, ARRAYSIZE(szPath), &dwPriority, &rgThumbSize, 24, &dwFlags);
if (SUCCEEDED(hr) || hr == E_PENDING) {
BOOL fAsync = (hr == E_PENDING);
hr = E_FAIL;
if (!fForce) {
// check if the image is already in the image cache.
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_NAME | ICIFLAG_FLAGS;
rgInfo.pszName = szPath;
rgInfo.dwFlags = dwMask;
if (!fNoDateStamp) {
rgInfo.dwMask |= ICIFLAG_DATESTAMP;
rgInfo.ftDateStamp = ftImageTimeStamp;
}
hr = m_pImageCache->FindImage(&rgInfo, puIndex);
}
if (hr != S_OK) {
// get the full path for the extraction...
WCHAR szFullPath[MAX_PATH];
STRRET rgStr;
hr = m_pFolder->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &rgStr);
if (SUCCEEDED(hr)) {
StrRetToBufW(&rgStr, pidl, szFullPath, ARRAYSIZE(szFullPath));
} else {
szFullPath[0] = 0;
}
hr = CTestCacheTask_Create(this, pExtract, szPath, szFullPath,
(fNoDateStamp ? NULL : &ftImageTimeStamp),
pidl, iItem, dwFlags,
dwPriority, fAsync, fBackground, fForce, &pTask);
if (SUCCEEDED(hr)) {
// does it not support Async, or were we told to run it forground ?
if (!fAsync || !fBackground) {
if (!fBackground) {
// make sure there is no extract task already underway as we
// are not adding this to the queue...
m_pScheduler->RemoveTasks(TOID_ExtractImageTask, (DWORD)iItem, TRUE);
}
hr = pTask->Run();
} else {
// add the task to the scheduler...
hr = m_pScheduler->AddTask(pTask,
TOID_CheckCacheTask,
(DWORD)iItem,
dwPriority);
// signify we want a default icon for now....
hr = S_FALSE;
}
pTask->Release();
}
}
}
pExtract->Release();
}
return hr;
}
HRESULT CDiskCacheTask_Create(CThumbnailView* pView,
int iItem,
LPCITEMIDLIST pidl,
LPCWSTR pszCache,
LPCWSTR pszPath,
const FILETIME* pftDateStamp,
IRunnableTask** ppTask)
{
if (!ppTask) {
return E_INVALIDARG;
}
CDiskCacheTask* pTask = new CComObject<CDiskCacheTask>;
if (pTask == NULL) {
return E_OUTOFMEMORY;
}
pTask->m_pidl = ILClone(pidl);
if (!(pTask->m_pidl)) {
delete pTask;
return E_OUTOFMEMORY;
}
StrCpyNW(pTask->m_szPath, pszPath, ARRAYSIZE(pTask->m_szPath));
StrCpyNW(pTask->m_szCache, pszCache, ARRAYSIZE(pTask->m_szCache));
pTask->m_pView = pView;
pView->InternalAddRef();
pTask->m_iItem = iItem;
pTask->m_fNoDateStamp = (pftDateStamp == NULL);
if (pftDateStamp) {
pTask->m_ftDateStamp = *pftDateStamp;
}
pTask->AddRef();
*ppTask = (LPRUNNABLETASK)pTask;
return NOERROR;
}
STDMETHODIMP CDiskCacheTask::Run()
{
if (m_lState == IRTIR_TASK_RUNNING) {
return S_FALSE;
}
if (m_lState == IRTIR_TASK_PENDING) {
// it is about to die, so fail
return E_FAIL;
}
LONG lRes = InterlockedExchange(&m_lState, IRTIR_TASK_RUNNING);
if (lRes == IRTIR_TASK_PENDING) {
m_lState = IRTIR_TASK_FINISHED;
return NOERROR;
}
// otherwise, run the task ....
HBITMAP hBmp;
DWORD dwLock;
// at this point, we assume that it IS in the cache...
HRESULT hr = m_pView->m_pDiskCache->Open(STGM_READ, &dwLock);
if (SUCCEEDED(hr)) {
hr = m_pView->m_pDiskCache->GetEntry(m_szPath, STGM_READ, &hBmp);
// set the tick count so we know when we last accessed the disk cache
m_pView->m_dwCacheTickCount = GetTickCount();
// release the lock, we don't need it...
m_pView->m_pDiskCache->ReleaseLock(&dwLock);
}
if (SUCCEEDED(hr)) {
hr = m_pView->UpdateImageForItem(hBmp, m_iItem, m_pidl, m_szCache, m_szPath,
(m_fNoDateStamp ? NULL : &m_ftDateStamp), FALSE);
DeleteObject(hBmp);
}
m_lState = IRTIR_TASK_FINISHED;
return hr;
}
STDMETHODIMP CDiskCacheTask::Kill(BOOL fWait)
{
return E_NOTIMPL;
}
STDMETHODIMP CDiskCacheTask::Suspend(void)
{
// not supported....
return E_NOTIMPL;
}
STDMETHODIMP CDiskCacheTask::Resume(void)
{
// not supported....
return E_NOTIMPL;
}
STDMETHODIMP_(ULONG) CDiskCacheTask::IsRunning()
{
return (ULONG)m_lState;
}
CDiskCacheTask::CDiskCacheTask()
{
m_iItem = -1;
m_lState = IRTIR_TASK_NOT_RUNNING;
m_pidl = 0;
m_pView = NULL;
}
CDiskCacheTask::~CDiskCacheTask()
{
if (m_pidl) {
SHFree((LPVOID)m_pidl);
}
if (m_pView) {
m_pView->InternalRelease();
}
}
LRESULT CThumbnailView::OnInfoTipText(NMLVGETINFOTIPW* plvn)
{
LRESULT lRes = FALSE;
LPCITEMIDLIST pidl = (LPCITEMIDLIST)plvn->lParam;
plvn->pszText[0] = 0;
if (!pidl) {
LV_ITEMW rgItem;
ZeroMemory(&rgItem, sizeof(rgItem));
rgItem.iItem = plvn->iItem;
rgItem.iSubItem = plvn->iSubItem;
rgItem.mask = LVIF_PARAM;
ListView_GetItemWrapW(m_hWndListView, &rgItem);
pidl = (LPCITEMIDLIST)rgItem.lParam;
}
if (pidl) {
IQueryInfo* pqi;
if (SUCCEEDED(m_pFolder->GetUIObjectOf(NULL, 1, &pidl, IID_IQueryInfo, NULL, (void**)&pqi))) {
WCHAR* pwszTip = NULL;
pqi->GetInfoTip(0, &pwszTip);
if (pwszTip) {
StrCpyNW(plvn->pszText, pwszTip, plvn->cchTextMax);
SHFree(pwszTip);
}
pqi->Release();
}
}
return lRes;
}
HRESULT CThumbnailView::UpdateImageForItem(HBITMAP hImage,
int iItem,
LPCITEMIDLIST pidl,
LPCWSTR pszCache,
LPCWSTR pszFullPath,
const FILETIME* pftDateStamp,
BOOL fCache)
{
if (!pszCache) {
return E_INVALIDARG;
}
DWORD dwLock;
BOOL fLock = FALSE;
if (fCache) {
Assert(m_pDiskCache);
DWORD dwMode = 0;
HRESULT hr = m_pDiskCache->Open(STGM_WRITE, &dwLock);
if (hr == STG_E_FILENOTFOUND) {
hr = m_pDiskCache->Create(STGM_WRITE, &dwLock);
}
fLock = SUCCEEDED(hr);
if (SUCCEEDED(hr)) {
hr = m_pDiskCache->AddEntry(pszFullPath, pftDateStamp, STGM_WRITE, hImage);
// set the tick count so that when the timer goes off, we can know when we
// last used it...
m_dwCacheTickCount = GetTickCount();
if (fLock) {
hr = m_pDiskCache->ReleaseLock(&dwLock);
}
}
}
DWORD dwMask = GetOverlayMask(pidl);
TaskUpdateItem(pidl,
iItem,
dwMask,
pszCache,
pftDateStamp,
0,
hImage);
return NOERROR;
}
DWORD GetCurrentColorFlags(UINT* puBytesPerPixel)
{
DWORD dwFlags = 0;
UINT uBytesPerPix = 1;
int res = (int)GetCurColorRes();
switch (res) {
case 16: dwFlags = ILC_COLOR16;
uBytesPerPix = 2;
break;
case 24:
case 32: dwFlags = ILC_COLOR24;
uBytesPerPix = 3;
break;
default: dwFlags = ILC_COLOR8;
uBytesPerPix = 1;
}
if (puBytesPerPixel) {
*puBytesPerPixel = uBytesPerPix;
}
return dwFlags;
}
UINT CalcCacheMaxSize(const SIZE* prgSize, UINT uBytesPerPix)
{
MEMORYSTATUS rgMemStat;
UINT uMaxCache = 0;
// calculate the maximum number of thumbnails in the cache.
rgMemStat.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&rgMemStat);
// the minimum in the cache is the number of thumbnails visible on the screen at once.
HDC hdc = GetDC(NULL);
int iWidth = GetDeviceCaps(hdc, HORZRES);
int iHeight = GetDeviceCaps(hdc, VERTRES);
ReleaseDC(NULL, hdc);
// the minimum number of thumbnails in the cache, is set to the maximum amount
// of thumbnails that can be diplayed by a single view at once.
int iRow = iWidth / (prgSize->cx + DEFSIZE_BORDER);
int iCol = iHeight / (prgSize->cy + DEFSIZE_VERTBDR);
UINT iMinThumbs = iRow * iCol;
// set the thumbnail maximum by calculating the memory required for a single thumbnail.
// then, divide half the available memory by the memory needed per thumbnail.
int iMemReqThumb = prgSize->cx * prgSize->cy * uBytesPerPix;
// the larger of the minimum cache required and the number calculated
// from the available memory.
UINT uiThumbsPerMem = UINT((rgMemStat.dwAvailPhys / 3) / iMemReqThumb);
uMaxCache = __max(uiThumbsPerMem, iMinThumbs + 1);
#if defined(SMALLCACHE)
// restrict the size of the thumbnail cache to force it to have to grovel
// entries..
#pragma message("Warning: possible Image Cache limiting in effect")
uMaxCache = 20;
#endif
return uMaxCache;
}
void CThumbnailView::ThreadUpdateStatusBar(UINT idMsg, int idItem)
{
PostMessageA(m_hWnd, WM_STATUSBARUPDATE, (WPARAM)idMsg, (LPARAM)idItem);
}
LRESULT CThumbnailView::OnCustomDraw(NMCUSTOMDRAW* pNM)
{
NMLVCUSTOMDRAW* plvcd = (NMLVCUSTOMDRAW*)pNM;
LRESULT lres = 0;
static HPALETTE hpalOld = NULL;
switch (plvcd->nmcd.dwDrawStage) {
case CDDS_PREPAINT:
if (m_fShowCompColor)
lres |= CDRF_NOTIFYITEMDRAW;
if (m_hpal && plvcd->nmcd.hdc) {
hpalOld = SelectPalette(plvcd->nmcd.hdc, m_hpal, TRUE);
RealizePalette(plvcd->nmcd.hdc);
lres |= CDRF_NOTIFYPOSTPAINT;
}
break;
case CDDS_ITEMPREPAINT:
{
LPCITEMIDLIST pidl = (LPCITEMIDLIST)plvcd->nmcd.lItemlParam;
// We hit a case (only in classic mode) in which pidl is bogus data. This happenes because we had
// alread called Clear and were in the process of calling ListView_DeleteAllItems when we were asked
// to paint an item. Dismissing the label edit box while the view was being emptied caused the item
// to be repainted and we faulted doing a GetAttributesOf on the already freed pidl. We protect
// against this case by ensureing that m_hWndListView is non-null (since we null it out before calling
// Clear).
if (pidl && m_hWndListView) {
DWORD uFlags = SFGAO_COMPRESSED;
HRESULT hres = m_pFolder->GetAttributesOf(1, &pidl, &uFlags);
if (SUCCEEDED(hres) && (uFlags & SFGAO_COMPRESSED)) {
plvcd->clrText = GetAltColor();
}
}
return CDRF_DODEFAULT;
}
case CDDS_POSTPAINT:
if (m_hpal && hpalOld && plvcd->nmcd.hdc) {
SelectPalette(plvcd->nmcd.hdc, hpalOld, TRUE);
RealizePalette(plvcd->nmcd.hdc);
}
break;
}
return lres;
}
HRESULT CUpdateDirTask_Create(CThumbnailView* pView,
IRunnableTask** ppTask)
{
CUpdateDirTask* pTask = new CComObject<CUpdateDirTask>;
if (pTask == NULL) {
return E_OUTOFMEMORY;
}
pTask->m_pView = pView;
Assert(pView);
if (!pTask->m_hEvent || !pTask->m_apElems) {
delete pTask;
return E_OUTOFMEMORY;
}
pTask->AddRef();
*ppTask = (LPRUNNABLETASK)pTask;
return NOERROR;
}
STDMETHODIMP CUpdateDirTask::Run()
{
if (m_lState == IRTIR_TASK_RUNNING) {
return S_FALSE;
}
if (m_lState == IRTIR_TASK_PENDING) {
// it is about to die, so fail
return E_FAIL;
}
LONG lRes = InterlockedExchange(&m_lState, IRTIR_TASK_RUNNING);
if (lRes == IRTIR_TASK_PENDING) {
m_lState = IRTIR_TASK_FINISHED;
return NOERROR;
}
// otherwise, run the task ....
HRESULT hr = InternalResume();
if (hr != E_PENDING)
m_lState = IRTIR_TASK_FINISHED;
return hr;
}
STDMETHODIMP CUpdateDirTask::Suspend()
{
if (m_lState != IRTIR_TASK_RUNNING) {
return E_FAIL;
}
// suspend ourselves
LONG lRes = InterlockedExchange(&m_lState, IRTIR_TASK_SUSPENDED);
if (lRes == IRTIR_TASK_FINISHED) {
m_lState = lRes;
return NOERROR;
}
// if it is running, then there is an Event Handle, if we have passed where
// we are using it, then we are close to finish, so it will ignore the suspend
// request
Assert(m_hEvent);
SetEvent(m_hEvent);
return NOERROR;
}
STDMETHODIMP CUpdateDirTask::Resume()
{
if (m_lState != IRTIR_TASK_SUSPENDED) {
return E_FAIL;
}
ResetEvent(m_hEvent);
m_lState = IRTIR_TASK_RUNNING;
HRESULT hr = InternalResume();
if (hr != E_PENDING) {
m_lState = IRTIR_TASK_FINISHED;
}
return hr;
}
STDMETHODIMP CUpdateDirTask::Kill(BOOL fWait)
{
if (m_lState == IRTIR_TASK_RUNNING) {
LONG lRes = InterlockedExchange(&m_lState, IRTIR_TASK_PENDING);
if (lRes == IRTIR_TASK_FINISHED) {
m_lState = lRes;
} else if (m_hEvent) {
// signal the event it is likely to be waiting on
SetEvent(m_hEvent);
}
return NOERROR;
} else if (m_lState == IRTIR_TASK_PENDING || m_lState == IRTIR_TASK_FINISHED) {
return S_FALSE;
}
return E_FAIL;
}
STDMETHODIMP_(ULONG) CUpdateDirTask::IsRunning()
{
return m_lState;
}
CUpdateDirTask::CUpdateDirTask()
{
m_hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
m_apElems = new LPITEMIDLIST[BLOCKSIZE + 1];
Assert(!m_apElems || m_apElems[BLOCKSIZE] == NULL);
m_iIndex = -1;
}
CUpdateDirTask::~CUpdateDirTask()
{
if (m_hEvent) {
CloseHandle(m_hEvent);
}
if (m_apElems) {
// empty the pidl array ...
do {
LPITEMIDLIST* apCurBlock = m_apElems;
int iMaxIndex = BLOCKSIZE;
if (apCurBlock[BLOCKSIZE] == NULL) {
iMaxIndex = m_celtThisBlock;
}
for (int iElem = 0; iElem < iMaxIndex; iElem++) {
if (apCurBlock[iElem] != NULL) {
SHFree(apCurBlock[iElem]);
}
}
m_apElems = (LPITEMIDLIST*)m_apElems[BLOCKSIZE];
delete[] apCurBlock;
} while (m_apElems != NULL);
}
if (m_pEnum) {
m_pEnum->Release();
}
m_pView->m_fUpdateDir = FALSE;
}
HRESULT CUpdateDirTask::InternalResume()
{
m_pView->m_fUpdateDir = TRUE;
// we have yet to do the enum.....
if (m_pEnum == NULL) {
HRESULT hRes;
ULONG ulType = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
// the blocks are empty right now...
Assert(m_apElems[0] == NULL);
m_apCurBlock = m_apElems;
if (m_pView->m_fShowAllObjects) {
ulType |= SHCONTF_INCLUDEHIDDEN;
}
hRes = m_pView->m_pFolder->EnumObjects(NULL, ulType, &m_pEnum);
if (hRes != S_OK) {
PostMessageA(m_pView->m_hWnd, WM_VIEWREFRESH, 0, 0);
return E_FAIL;
}
// we are starting again, empty the update lists...
m_pView->ThreadEmptyUpdateLists();
}
if (m_pEnum && !m_fEnumDone) {
// fetch all the new elements ...
ULONG celtFetched;
do {
// we cannot assume that Next() can return more than one element at
// a time, as most of the IShellFolder implementers of this only
// support one at a time... (so much for relying on the spec....)
celtFetched = 0;
m_pEnum->Next(BLOCKSIZE - m_celtThisBlock, m_apCurBlock + m_celtThisBlock, &celtFetched);
if (celtFetched == 0) {
break;
}
// add this lot to the current block count
m_celtThisBlock += celtFetched;
if (m_celtThisBlock == BLOCKSIZE) {
// allocate next block
m_apCurBlock[BLOCKSIZE] = (LPITEMIDLIST) new LPITEMIDLIST[BLOCKSIZE + 1];
if (m_apCurBlock[BLOCKSIZE] == NULL) {
// out of memory, resort to the F5 key :-)
PostMessageA(m_pView->m_hWnd, WM_VIEWREFRESH, 0, 0);
return E_FAIL;
} else {
m_celtThisBlock = 0;
m_apCurBlock = (LPITEMIDLIST*)m_apCurBlock[BLOCKSIZE];
m_apCurBlock[BLOCKSIZE] = NULL;
}
}
if (WaitForSingleObject(m_hEvent, 0) == WAIT_OBJECT_0) {
// why were we signalled ...
if (m_lState == IRTIR_TASK_SUSPENDED) {
return E_PENDING;
} else {
return E_FAIL;
}
}
} while (celtFetched != 0);
m_fEnumDone = TRUE;
}
if (m_fEnumDone) {
// if we reached here, we got a whole load of pidls in an array ...
// now walk the view checking to see if what we have are valid or not ...
do {
m_iIndex = ListView_GetNextItem(m_pView->m_hWndListView, m_iIndex, LVNI_ALL);
if (m_iIndex == -1) {
break;
}
LV_ITEMW rgItem;
rgItem.iItem = m_iIndex;
rgItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_NORECOMPUTE;
rgItem.iSubItem = 0;
int iItem = ListView_GetItemWrapW(m_pView->m_hWndListView, &rgItem);
// just incase. ...
if (iItem != -1) {
LPITEMIDLIST pidl = (LPITEMIDLIST)rgItem.lParam;
// must walk our data chain to find the pidl ...
BOOL fFound = FALSE;
LPITEMIDLIST* apSearch = m_apElems;
while (apSearch != NULL) {
int iMaxSearch = BLOCKSIZE;
// the last block may not be full
if (apSearch[BLOCKSIZE] == NULL) {
iMaxSearch = m_celtThisBlock;
}
int iSearch;
for (iSearch = 0; iSearch < iMaxSearch; iSearch++) {
// skip used pidls.
if (apSearch[iSearch] == NULL) {
continue;
}
// try the legal method...
if (m_pView->m_pFolder->CompareIDs(0, pidl, apSearch[iSearch]) == 0) {
fFound = TRUE;
break;
}
}
if (fFound) {
rgItem.mask = 0;
// now we need to check if the image is out of date...
if (rgItem.iImage != I_IMAGECALLBACK) {
IExtractImage* pExtract;
IExtractImage2* pExtract2;
UINT rgfFlags = 0;
FILETIME ftDateStamp;
HRESULT hRes = m_pView->m_pFolder->GetUIObjectOf(m_pView->m_hWnd, 1, (LPCITEMIDLIST*)&pidl,
IID_IExtractImage,
&rgfFlags,
(void**)&pExtract);
if (SUCCEEDED(hRes)) {
hRes = pExtract->QueryInterface(IID_IExtractImage2, (void**)&pExtract2);
pExtract->Release();
}
if (SUCCEEDED(hRes)) {
hRes = pExtract2->GetDateStamp(&ftDateStamp);
pExtract2->Release();
}
if (SUCCEEDED(hRes)) {
// now fetch the datestamp from the icon cache so we can see if it has changed...
IMAGECACHEINFO rgInfo;
rgInfo.cbSize = sizeof(rgInfo);
rgInfo.dwMask = ICIFLAG_DATESTAMP;
hRes = m_pView->m_pImageCache->GetImageInfo(rgItem.iImage, &rgInfo);
if (SUCCEEDED(hRes)) {
if (rgInfo.ftDateStamp.dwLowDateTime != ftDateStamp.dwLowDateTime ||
rgInfo.ftDateStamp.dwHighDateTime != ftDateStamp.dwHighDateTime) {
m_pView->m_pImageCache->FreeImage(rgItem.iImage);
rgItem.mask |= LVIF_IMAGE;
rgItem.iImage = I_IMAGECALLBACK;
}
}
}
}
int iLen1 = GetPidlLength(apSearch[iSearch]);
int iLen2 = GetPidlLength(pidl);
// has the pidl changed ?
if (iLen1 != iLen2 || memcmp(apSearch[iSearch], pidl, iLen1) != 0) {
// swap the pidls....
rgItem.mask |= LVIF_PARAM;
rgItem.lParam = (LPARAM)apSearch[iSearch];
// put the old pidl in the array so it gets freed
apSearch[iSearch] = pidl;
}
if (rgItem.mask != 0) {
ListView_SetItemWrapW(m_pView->m_hWndListView, &rgItem);
}
// free the pidl as don't need it
SHFree((LPVOID)apSearch[iSearch]);
// mark it as NULL
apSearch[iSearch] = NULL;
break;
}
// next block of pidls...
apSearch = (LPITEMIDLIST*)apSearch[BLOCKSIZE];
}
if (!fFound) {
m_pView->ThreadDeleteItem(ILClone((LPITEMIDLIST)rgItem.lParam));
}
}
// check to see if we are told to give up....
if (WaitForSingleObject(m_hEvent, 0) == WAIT_OBJECT_0) {
// why were we signalled ...
if (m_lState == IRTIR_TASK_SUSPENDED) {
// give the view a chance to update
m_pView->m_fUpdateDir = FALSE;
PostMessageA(m_pView->m_hWnd, WM_PROCESSITEMS, 0, 0);
return E_PENDING;
} else {
return E_FAIL;
}
}
} while (TRUE);
m_fViewPassDone = TRUE;
}
if (m_fViewPassDone) {
LPITEMIDLIST* apCurBlock = m_apElems;
// now search the blocks for pidls we don't have and add them ....
while (apCurBlock != NULL) {
int iMaxIndex = BLOCKSIZE;
// the last block may not be full
if (apCurBlock[BLOCKSIZE] == NULL) {
iMaxIndex = m_celtThisBlock;
}
for (int iSearch = 0; iSearch < iMaxIndex; iSearch++) {
// skip used pidls.
if (apCurBlock[iSearch] == NULL) {
continue;
}
m_pView->ThreadAddItem(apCurBlock[iSearch]);
// the view now owns the pidl...
apCurBlock[iSearch] = NULL;
}
// next block of pidls...
LPITEMIDLIST* apNext = (LPITEMIDLIST*)apCurBlock[BLOCKSIZE];
delete[] apCurBlock;
apCurBlock = apNext;
}
m_apElems = NULL;
m_pView->m_fUpdateDir = FALSE;
PostMessageA(m_pView->m_hWnd, WM_PROCESSITEMS, 0, 0);
}
return NOERROR;
}
HRESULT CThumbnailView::ThreadAddItem(LPCITEMIDLIST pidl)
{
if (!pidl)
return E_INVALIDARG;
EnterCriticalSection(&m_csAddLock);
DPA_AppendPtr(m_hAddList, (LPVOID)pidl);
LeaveCriticalSection(&m_csAddLock);
return NOERROR;
}
HRESULT CThumbnailView::ThreadDeleteItem(LPCITEMIDLIST pidl)
{
if (!pidl)
return E_INVALIDARG;
EnterCriticalSection(&m_csAddLock);
DPA_AppendPtr(m_hDeleteList, (LPVOID)pidl);
LeaveCriticalSection(&m_csAddLock);
return NOERROR;
}
HRESULT CThumbnailView::OnWmProcessItems()
{
EnterCriticalSection(&m_csAddLock);
// do the add items first ....
for (int iLoop = DPA_GetPtrCount(m_hAddList) - 1; iLoop >= 0; iLoop--) {
LPITEMIDLIST pidl = (LPITEMIDLIST)DPA_GetPtr(m_hAddList, iLoop);
if (this->AddItem(pidl) < 0) {
SHFree(pidl); // failed to add it to the view, destroy it ...
} else if (m_pidlRename) {
if (m_pFolder->CompareIDs(0, pidl, m_pidlRename) == 0) {
this->SelectAndPositionItem(pidl, SVSI_EDIT, NULL);
SHFree(m_pidlRename);
m_pidlRename = NULL;
}
}
DPA_DeletePtr(m_hAddList, iLoop);
}
if (!m_fUpdateDir) {
// now do the delete items...
for (iLoop = DPA_GetPtrCount(m_hDeleteList) - 1; iLoop >= 0; iLoop--) {
LPITEMIDLIST pidl = (LPITEMIDLIST)DPA_GetPtr(m_hDeleteList, iLoop);
this->RemoveObject(pidl, NULL);
// we failed to add it to the view, destroy it ...
SHFree(pidl);
DPA_DeletePtr(m_hDeleteList, iLoop);
}
} else {
// we are currently doing an update dir, skip deleting things for a moment otherwise we'll screw up teh list order.
PostMessageA(m_hWnd, WM_PROCESSITEMS, 0, 0);
}
// if we still think we need a rename, cleanit up...
if (m_pidlRename) {
SHFree(m_pidlRename);
m_pidlRename = NULL;
}
LeaveCriticalSection(&m_csAddLock);
return NOERROR;
}
HRESULT CThumbnailView::ThreadEmptyUpdateLists()
{
EnterCriticalSection(&m_csAddLock);
for (int iLoop = DPA_GetPtrCount(m_hAddList) - 1; iLoop >= 0; iLoop--) {
LPCITEMIDLIST pidl = (LPCITEMIDLIST)DPA_GetPtr(m_hAddList, iLoop);
SHFree((LPITEMIDLIST)pidl);
DPA_DeletePtr(m_hAddList, iLoop);
}
// now do the delete items...
for (iLoop = DPA_GetPtrCount(m_hDeleteList) - 1; iLoop >= 0; iLoop--) {
LPITEMIDLIST pidl = (LPITEMIDLIST)DPA_GetPtr(m_hAddList, iLoop);
SHFree((LPITEMIDLIST)pidl);
DPA_DeletePtr(m_hAddList, iLoop);
}
LeaveCriticalSection(&m_csAddLock);
return NOERROR;
}
HRESULT CTestCacheTask_Create(CThumbnailView* pView,
IExtractImage* pExtract,
LPCWSTR pszCache,
LPCWSTR pszPath,
const FILETIME* pftDateStamp,
LPCITEMIDLIST pidl,
int iItem,
DWORD dwFlags,
DWORD dwPriority,
BOOL fAsync,
BOOL fBackground,
BOOL fForce,
IRunnableTask** ppTask)
{
*ppTask = NULL;
CTestCacheTask* pNew = new CTestCacheTask;
if (!pNew)
return E_OUTOFMEMORY;
pNew->m_pidl = ILClone(pidl);
if (pNew->m_pidl == NULL) {
delete pNew;
return E_OUTOFMEMORY;
}
StrCpyNW(pNew->m_szFullPath, pszPath, ARRAYSIZE(pNew->m_szFullPath));
StrCpyNW(pNew->m_szCache, pszCache, ARRAYSIZE(pNew->m_szCache));
if (pftDateStamp) {
pNew->m_fDateStamp = TRUE;
pNew->m_ftDateStamp = *pftDateStamp;
}
pNew->m_iItem = iItem;
pNew->m_dwFlags = dwFlags;
pNew->m_dwPriority = dwPriority;
pNew->m_fAsync = fAsync;
pNew->m_fBackground = fBackground;
pNew->m_fForce = fForce;
pNew->m_pExtract = pExtract;
pExtract->AddRef();
pNew->m_pView = pView;
pView->InternalAddRef();
*ppTask = (IRunnableTask*)pNew;
return NOERROR;
}
STDMETHODIMP CTestCacheTask::RunInitRT()
{
DWORD dwLock = 0;
BOOL fLock = FALSE;
HRESULT hr = E_FAIL;
if (!m_fForce) {
if (m_pView->m_pDiskCache) {
// make sure the disk cache is open for reading.
hr = m_pView->m_pDiskCache->Open(STGM_READ, &dwLock);
fLock = SUCCEEDED(hr);
} else {
// no disk cache ...
hr = E_FAIL;
}
if (SUCCEEDED(hr)) {
if (!m_pView->m_fTimerActive) {
// start the timer, once every two seconds....
SetTimer(m_pView->m_hWnd, TIMER_DISKCACHE, 2000, NULL);
m_pView->m_dwCacheTickCount = GetTickCount();
m_pView->m_fTimerActive = TRUE;
}
// is it in the cache....
FILETIME ftCacheTimeStamp;
hr = m_pView->m_pDiskCache->IsEntryInStore(m_szFullPath, &ftCacheTimeStamp);
// if it is in the cache, and it is an uptodate image, then fetch from disk....
// if the timestamps are wrong, then the extract code further down will then try
// and write its image back to the cache to update it anyway.....
if (hr == S_OK &&
((ftCacheTimeStamp.dwLowDateTime == m_ftDateStamp.dwLowDateTime &&
ftCacheTimeStamp.dwHighDateTime == m_ftDateStamp.dwHighDateTime) || !m_fDateStamp)) {
// try it in the background...
IRunnableTask* pTask = NULL;
hr = CDiskCacheTask_Create(m_pView, m_iItem, m_pidl, m_szCache, m_szFullPath,
(!m_fDateStamp ? NULL : &m_ftDateStamp), &pTask);
if (SUCCEEDED(hr) && !m_pView->m_fDestroying) {
Assert(m_pView->m_pScheduler);
// add the task to the scheduler...
hr = m_pView->m_pScheduler->AddTask(pTask, TOID_DiskCacheTask, (DWORD)m_iItem, PRIORITY_NORMAL);
if (SUCCEEDED(hr))
hr = S_FALSE;
pTask->Release();
} else {
hr = E_FAIL;
}
} else {
hr = E_FAIL;
}
}
if (fLock) {
// free the disk cache lock...
m_pView->m_pDiskCache->ReleaseLock(&dwLock);
}
}
if (FAILED(hr)) {
// Extract It....
IRunnableTask* pTask = NULL;
hr = CExtractImageTask_Create(m_pView,
m_pExtract,
m_szCache,
m_szFullPath,
m_pidl,
(!m_fDateStamp ? NULL : &m_ftDateStamp),
m_iItem,
m_dwFlags,
&pTask);
if (SUCCEEDED(hr)) {
// does it not support Async, or were we told to run it forground ?
if (!m_fAsync || !m_fBackground) {
if (!m_fBackground) {
// make sure there is no extract task already underway as we
// are not adding this to the queue...
m_pView->m_pScheduler->RemoveTasks(TOID_ExtractImageTask, (DWORD)m_iItem, TRUE);
}
hr = pTask->Run();
} else {
// add the task to the scheduler...
hr = m_pView->m_pScheduler->AddTask(pTask,
TOID_ExtractImageTask,
(DWORD)m_iItem,
m_dwPriority);
// signify we want a default icon for now....
hr = S_FALSE;
}
pTask->Release();
} else {
hr = E_FAIL;
}
}
return hr;
}
CTestCacheTask::CTestCacheTask()
: CRunnableTask(RTF_DEFAULT)
{
}
CTestCacheTask::~CTestCacheTask()
{
if (m_pidl) {
SHFree((LPVOID)m_pidl);
}
if (m_pExtract) {
m_pExtract->Release();
}
if (m_pView) {
m_pView->InternalRelease();
}
}
HRESULT CThumbnailView::SetPointData(IDataObject* ptdObj, LPCITEMIDLIST* ppPidl, int cidl)
{
static UINT s_cfOffsets = 0;
ITEMSPACING rgSpacing;
// scaling is basically converted to large icon spacing...
HRESULT hres = GetItemSpacing(&rgSpacing);
Assert(SUCCEEDED(hres));
// the offsets format
if (!s_cfOffsets) {
s_cfOffsets = RegisterClipboardFormat(CFSTR_SHELLIDLISTOFFSET);
}
POINT* ppt = (POINT*)GlobalAlloc(GPTR, SIZEOF(POINT) * (1 + cidl));
if (ppt) {
int i;
// Grab the anchor point
Assert(m_fDragStarted);
ppt[0] = m_ptDragStart;
for (i = 1; i <= cidl; i++) {
int iItem = FindInView(m_hWndListView, m_pFolder, ppPidl[i - 1]);
Assert(iItem != -1);
ListView_GetItemPosition(m_hWndListView, iItem, &ppt[i]);
ppt[i].x -= m_ptDragStart.x;
ppt[i].y -= m_ptDragStart.y;
ppt[i].x = (ppt[i].x * rgSpacing.cxLarge) / rgSpacing.cxSmall;
ppt[i].y = (ppt[i].y * rgSpacing.cyLarge) / rgSpacing.cySmall;
}
FORMATETC fmte = {(CLIPFORMAT)s_cfOffsets, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
STGMEDIUM medium;
medium.tymed = TYMED_HGLOBAL;
medium.hGlobal = ppt;
medium.pUnkForRelease = NULL;
// give the data object ownership of ths
hres = ptdObj->SetData(&fmte, &medium, TRUE);
if (FAILED(hres))
GlobalFree((HGLOBAL)ppt);
}
return hres;
}
HRESULT CThumbnailView::AutoAutoArrange(DWORD dwReserved)
{
if (!m_fItemsMoved) {
ListView_Arrange(m_hWndListView, LVA_DEFAULT);
}
return NOERROR;
}
HRESULT CThumbnailView::SetStatusText(LPCWSTR pwszStatusText)
{
UpdateStatusBar();
return NOERROR;
}
// CLR_NONE is a special value that never matches a valid RGB
COLORREF g_crAltColor = CLR_NONE; // uninitialized magic value
DWORD GetAltColor()
{
// Fetch the alternate color (for compression) if supplied.
if (g_crAltColor == CLR_NONE) // initialized yet?
{
DWORD cbData = sizeof(COLORREF);
DWORD dwType;
HKEY hkey;
LONG lRes;
lRes = RegOpenKey(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER, &hkey);
if (lRes == ERROR_SUCCESS && hkey) {
if (SHQueryValueEx(hkey, TEXT("AltColor"), NULL, &dwType, (LPBYTE)&g_crAltColor, &cbData) != ERROR_SUCCESS)
g_crAltColor = RGB(0, 0, 255); // default value
RegCloseKey(hkey);
}
}
return g_crAltColor;
}
Reference in New Issue View Git Blame Copy Permalink