mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8733 lines
258 KiB
8733 lines
258 KiB
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
|
|
// Uncomment following line to turn on timing of view enumeration
|
|
// #define TIMING 1
|
|
//
|
|
#ifdef TIMING
|
|
DWORD dwFinish, dwStart;
|
|
#endif
|
|
|
|
|
|
#include "iid.h"
|
|
#include "iasynch.h"
|
|
|
|
void CloudHookBeginRename(LPTSTR, HWND, int);
|
|
void CloudHookEndRename(void);
|
|
|
|
HRESULT SHGetIconFromPIDL(IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, int *piImage);
|
|
|
|
#ifndef SIF_ALL
|
|
#define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS)
|
|
#endif
|
|
|
|
#define ID_LISTVIEW 1
|
|
#define ID_STATIC 2
|
|
|
|
#define WM_DVI_FILLSTUFF (WM_USER + 0x100)
|
|
#define WM_DVI_LOADSTUFF (WM_USER + 0x101)
|
|
|
|
#define OD_CROSSOVER_LIMIT (50)
|
|
|
|
#define INVALID_THREAD_ID ((DWORD)-1)
|
|
|
|
#define DV_CDB_OnDefaultCommand(_pdsv) \
|
|
(_pdsv->pcdb ? _pdsv->pcdb->lpVtbl->OnDefaultCommand(_pdsv->pcdb, \
|
|
_pdsv->psvOuter ? _pdsv->psvOuter : &_pdsv->sv) : E_NOTIMPL)
|
|
|
|
#define DV_CDB_OnStateChange(_pdsv, _code) \
|
|
(_pdsv->pcdb ? _pdsv->pcdb->lpVtbl->OnStateChange(_pdsv->pcdb, \
|
|
_pdsv->psvOuter ? _pdsv->psvOuter : &_pdsv->sv, _code) : E_NOTIMPL)
|
|
|
|
#define DV_CDB_IncludeObject(_pdsv, _pidl) \
|
|
(_pdsv->pcdb ? _pdsv->pcdb->lpVtbl->IncludeObject(_pdsv->pcdb, \
|
|
_pdsv->psvOuter ? _pdsv->psvOuter : &_pdsv->sv, _pidl) : S_OK)
|
|
|
|
BOOL WINAPI DAD_DragEnterEx(HWND hwndTarget, const POINT ptStart);
|
|
extern BOOL g_fDraggingOverSource;
|
|
|
|
|
|
#pragma data_seg(DATASEG_PERINSTANCE)
|
|
struct _DEFVIEWPROCINFO
|
|
{
|
|
UINT cRef;
|
|
HANDLE hThreadIdle;
|
|
DWORD idThreadIdle;
|
|
} gp_dvp =
|
|
{
|
|
0,
|
|
NULL,
|
|
0,
|
|
} ;
|
|
#pragma data_seg()
|
|
|
|
const TCHAR c_szDefViewClass[] = TEXT("SHELLDLL_DefView");
|
|
const TCHAR c_szAnimateClass[] = ANIMATE_CLASS;
|
|
#ifdef CUST_TOOLBAR
|
|
const TCHAR c_szDefViewToobar[] = TEXT("DefViewToolbar");
|
|
#endif
|
|
const TCHAR c_szDesktopKey[] = REGSTR_PATH_DESKTOP;
|
|
const TCHAR c_szWallpaper[] = TEXT("Wallpaper");
|
|
const TCHAR c_szPattern[] = TEXT("Pattern");
|
|
|
|
typedef struct
|
|
{
|
|
LPARAM lParamSort;
|
|
int iDirection;
|
|
int iLastColumnClick;
|
|
} DVSAVESTATE, *PDVSAVESTATE;
|
|
|
|
typedef struct
|
|
{
|
|
USHORT cbSize;
|
|
UINT ViewMode;
|
|
POINTS ptScroll;
|
|
USHORT cbColOffset;
|
|
USHORT cbPosOffset;
|
|
DVSAVESTATE dvState;
|
|
} DVSAVEHEADER, *PDVSAVEHEADER;
|
|
|
|
#define IsDefaultState(_dvHead) ((_dvHead).dvState.lParamSort == 0 && \
|
|
(_dvHead).dvState.iDirection == 1 && \
|
|
(_dvHead).dvState.iLastColumnClick == -1 && \
|
|
(_dvHead).ptScroll.x == 0 && (_dvHead).ptScroll.y == 0)
|
|
|
|
typedef struct
|
|
{
|
|
POINT pt;
|
|
ITEMIDLIST idl;
|
|
} DVITEM, *PDVITEM;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int xMul;
|
|
int xDiv;
|
|
|
|
int yMul;
|
|
int yDiv;
|
|
} SCALEINFO, *LPSCALEINFO;
|
|
|
|
//=============================================================================
|
|
// CDVDropTarget : class definition
|
|
//=============================================================================
|
|
typedef struct { // dvdt
|
|
IDropTarget dt;
|
|
LPDATAOBJECT pdtobj; // from DragEnter()/Drop()
|
|
RECT rcLockWindow; // WindowRect of hwnd for DAD_ENTER
|
|
int itemOver; // item we are visually dragging over
|
|
LPDROPTARGET pdtgtCur; // current drop target, derived from hit testing
|
|
DWORD dwEffectOut; // last *pdwEffect out
|
|
DWORD grfKeyState; // cached key state
|
|
POINT ptLast; // last dragged position
|
|
AUTO_SCROLL_DATA asd; // for auto scrolling
|
|
} CDVDropTarget;
|
|
|
|
//
|
|
// Class definition of CDefView
|
|
//
|
|
typedef struct { // dsv
|
|
IShellView sv;
|
|
CDVDropTarget dvdt;
|
|
UINT cRef;
|
|
|
|
IShellView * psvOuter; // May be NULL
|
|
IShellFolder *pshf;
|
|
IShellBrowser *psb;
|
|
ICommDlgBrowser *pcdb;
|
|
FOLDERSETTINGS fs;
|
|
IContextMenu *pcmSel; // pcm for selected objects.
|
|
DWORD dwAttrSel; // dwAttrs for selected objects
|
|
IShellIcon * psi; // for getting icon fast
|
|
IAsynchEnumIDList *pasyncenum;
|
|
HWND hwndMain;
|
|
HWND hwndView;
|
|
HWND hwndListview;
|
|
HWND hwndStatic;
|
|
HACCEL hAccel;
|
|
|
|
BOOL fEnumFailed; // TRUE if enum failed.
|
|
HRESULT hres; // Enum result
|
|
|
|
UINT uState; // SVUIA_*
|
|
HMENU hmenuCur;
|
|
|
|
ULONG uRegister;
|
|
|
|
POINT ptDrop;
|
|
|
|
POINT ptDragAnchor; // start of the drag
|
|
int itemCur; // The current item in the drop target
|
|
|
|
IDataObject *pdtobjHdrop; // for 3.1 HDROP drag/drop
|
|
IDropTarget *pdtgtBack; // of the background (shell folder)
|
|
|
|
// BUGBUG: this is obsolete, use callback (DVM_GETDETAILSOF and DVM_COLUMNCLICK)
|
|
IShellDetails *psd;
|
|
// Officially, pdr should be an IDelayedRelease interface, but it
|
|
// only has IUnknown member functions, so why bother?
|
|
IUnknown *pdr;
|
|
UINT cxChar;
|
|
|
|
LPCITEMIDLIST pidlMonitor;
|
|
LONG lFSEvents;
|
|
|
|
DVSAVESTATE dvState;
|
|
PDVSAVEHEADER pSaveHeader;
|
|
UINT uSaveHeaderLen;
|
|
|
|
HANDLE hThreadIdle; // handle of the idle proc thread
|
|
DWORD idThreadIdle; // ID of the idle proc thread
|
|
int cRefForIdle; // did idle thread forget
|
|
// to release this
|
|
|
|
BOOL bDragSource:1;
|
|
BOOL bDropAnchor:1;
|
|
|
|
BOOL bItemsMoved:1;
|
|
BOOL bClearItemPos:1;
|
|
|
|
BOOL bHaveCutStuff:1;
|
|
BOOL bClipViewer:1;
|
|
|
|
BOOL fShowAllObjects:1;
|
|
BOOL fInLabelEdit:1;
|
|
BOOL fDisabled:1;
|
|
|
|
BOOL bUpdatePending:1;
|
|
BOOL bBkFilling:1;
|
|
|
|
BOOL bContextMenuMode:1;
|
|
BOOL bMouseMenu:1;
|
|
BOOL fHasDeskWallPaper:1;
|
|
|
|
BOOL fIsOwnerData:1;
|
|
#ifdef CUST_TOOLBAR
|
|
BOOL fToolbarSaved; // avoid saving twice
|
|
#endif // CUST_TOOLBAR
|
|
|
|
HWND hwndNextViewer;
|
|
|
|
LONG lSelChangeInfo;
|
|
|
|
int iStdBMOffset;
|
|
int iViewBMOffset;
|
|
|
|
LPFNVIEWCALLBACK pfnCallback; // Optional client callback
|
|
|
|
LPITEMIDLIST pidlSelect; // Item to select when background
|
|
UINT uFlagsSelect; // enumeration is done
|
|
|
|
|
|
int iLastFind;
|
|
#ifdef DEBUG
|
|
TIMEVAR(Update);
|
|
TIMEVAR(Fill);
|
|
TIMEVAR(GetIcon);
|
|
TIMEVAR(GetName);
|
|
TIMEVAR(FSNotify);
|
|
TIMEVAR(AddObject);
|
|
TIMEVAR(EnumNext);
|
|
TIMEVAR(RestoreState);
|
|
TIMEVAR(WMNotify);
|
|
TIMEVAR(LVChanging);
|
|
TIMEVAR(LVChanged);
|
|
TIMEVAR(LVDelete);
|
|
TIMEVAR(LVGetDispInfo);
|
|
#endif
|
|
} CDefView, *LPDEFVIEW;
|
|
|
|
LPDEFVIEW WINAPI DV_HwndMain2DefView(HWND hwndMain);
|
|
|
|
#define DV_ISOWNERDATA(pdsv) (pdsv->fIsOwnerData)
|
|
|
|
//
|
|
// Note that it returns NULL, if iItem is -1.
|
|
//
|
|
|
|
__inline LPITEMIDLIST DSV_GetPIDL(LPDEFVIEW this, INT i)
|
|
{
|
|
//
|
|
// If the listview is in ownerdata mode, we need to go to the
|
|
// item cache in order to get the pidl. Otherwise, we just
|
|
// ask for the lParam of the listview item in question
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(this))
|
|
{
|
|
LPITEMIDLIST pidl = NULL;
|
|
ASSERT(this->pasyncenum);
|
|
this->pasyncenum->lpVtbl->NextAt(this->pasyncenum, 1, i, &pidl, NULL);
|
|
|
|
return pidl;
|
|
}
|
|
else
|
|
{
|
|
return (LPITEMIDLIST) LVUtil_GetLParam(this->hwndListview, i);
|
|
}
|
|
}
|
|
|
|
DWORD CALLBACK DefView_LoadIcons(LPDEFVIEW this, BOOL bAnother);
|
|
|
|
LRESULT DefView_Command(LPDEFVIEW pdsv, LPCONTEXTMENU pcmSel, WPARAM wParam, LPARAM lParam);
|
|
|
|
STDMETHODIMP CDefView_SelectItem(IShellView * psv, LPCITEMIDLIST pidlItem, UINT uFlags);
|
|
STDMETHODIMP CDefView_GetItemObject(IShellView * psv, UINT uFlags, REFIID riid, LPVOID *ppv);
|
|
STDMETHODIMP CDefView_Refresh(LPSHELLVIEW psv);
|
|
STDMETHODIMP CDefView_SaveViewState(IShellView *psv);
|
|
|
|
LRESULT DV_OldDragMsgs(LPDEFVIEW pdsv, UINT iMessage, WPARAM wParam, const DROPSTRUCT * lpds);
|
|
void DV_UpdateStatusBar(LPDEFVIEW pdsv, BOOL fInitialize);
|
|
void DefView_MergeToolBar(LPDEFVIEW this, BOOL bCanRestore);
|
|
LRESULT DefView_TBNotify(LPDEFVIEW pdsv, NMHDR *pnm);
|
|
int DefView_FindItem(LPDEFVIEW this, LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlFound, BOOL fSamePtr);
|
|
BOOL CALLBACK DV_ViewOptionsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
BOOL CDefView_OnActivate(LPDEFVIEW this, UINT uState);
|
|
BOOL CDefView_OnDeactivate(LPDEFVIEW this);
|
|
void DefView_ExplorerCommand(LPDEFVIEW pdsv, UINT idFCIDM);
|
|
void DefView_DismissEdit(LPDEFVIEW pdsv);
|
|
void DefView_OnInitMenu(LPDEFVIEW pdsv);
|
|
LRESULT DefView_OnInitMenuPopup(LPDEFVIEW this, HMENU hSubMenu, int nIndex, BOOL fSystemMenu);
|
|
void DefView_InitViewMenu(LPDEFVIEW this, HMENU hmInit);
|
|
LRESULT DefView_OnMenuSelect(LPDEFVIEW pdsv, UINT id, UINT mf, HMENU hmenu);
|
|
void DV_GetMenuHelpText(LPDEFVIEW pdsv, UINT id, LPTSTR pszText, UINT cchText);
|
|
void DV_GetToolTipText(LPDEFVIEW pdsv, UINT id, LPTSTR pszText, UINT cchText);
|
|
void DefView_ContextMenu(LPDEFVIEW pdsv, DWORD dwPos);
|
|
void DV_DoDefaultStatusBar(LPDEFVIEW pdsv, BOOL fInitialize);
|
|
|
|
BOOL DefView_GetDropPoint(LPDEFVIEW pdv, POINT *lpPt);
|
|
BOOL DefView_GetDragPoint(LPDEFVIEW pdv, POINT *lpPt);
|
|
void DefView_MoveSelectedItems(LPDEFVIEW pdsv, int dx, int dy);
|
|
BOOL DefView_GetItemPosition(LPDEFVIEW pdv, LPCITEMIDLIST pidl, LPPOINT lpPt);
|
|
DWORD LVStyleFromView(LPDEFVIEW lpdv);
|
|
void CDVDropTarget_LeaveAndReleaseData(LPDEFVIEW this);
|
|
void DefView_AddCopyHook(LPDEFVIEW this);
|
|
void DefView_RemoveCopyHook(LPDEFVIEW this);
|
|
HRESULT DefView_SelectAndPositionItem(IShellView *psv, LPCITEMIDLIST pidlItem, UINT uFlags, POINT *ppt);
|
|
HRESULT DefView_GetItemObjects(LPDEFVIEW pdsv, LPCITEMIDLIST **ppidl,
|
|
UINT uItem);
|
|
|
|
void CDVDropTarget_ReleaseCurrentDropTarget(CDVDropTarget * this);
|
|
void CDVDropTarget_ReleaseDataObject(CDVDropTarget * this);
|
|
|
|
HRESULT DefView_FillObjectsShowHide(LPDEFVIEW pdsv, BOOL bRefresh,
|
|
PDVSAVEHEADER pSaveHeader, UINT uLen, BOOL fInteractive);
|
|
BOOL DefView_IdleDoStuff(LPDEFVIEW pdsv, UINT message, LPARAM lParam);
|
|
|
|
HRESULT DV_AllocRestOfStream(LPSTREAM pstm, LPVOID *ppData, UINT *puLen);
|
|
|
|
#define DV_ISDESKTOP(pdsv) (pdsv->fs.fFlags & FWF_DESKTOP)
|
|
|
|
|
|
// determine if color is light or dark
|
|
#define COLORISLIGHT(clr) ((5*GetGValue((clr)) + 2*GetRValue((clr)) + GetBValue((clr))) > 8*128)
|
|
|
|
//----------------------------------------------------------------------------
|
|
#define MINVIEWWIDTH 170
|
|
#define MINVIEWHEIGHT 132
|
|
|
|
// REVIEW UNDONE - calculate these, don't guess!
|
|
#define PARENTGAPWIDTH 40
|
|
#define PARENTGAPHEIGHT 32
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
#ifdef DEBUG
|
|
|
|
void DefView_StartNotify(LPDEFVIEW pdsv, NMHDR *pnm)
|
|
{
|
|
if (pdsv == NULL)
|
|
return;
|
|
|
|
TIMESTART(pdsv->WMNotify);
|
|
|
|
if (pnm == NULL)
|
|
return;
|
|
|
|
switch (pnm->code) {
|
|
case LVN_ITEMCHANGING:
|
|
TIMESTART(pdsv->LVChanging);
|
|
break;
|
|
|
|
case LVN_ITEMCHANGED:
|
|
TIMESTART(pdsv->LVChanged);
|
|
break;
|
|
|
|
case LVN_DELETEITEM:
|
|
TIMESTART(pdsv->LVDelete);
|
|
break;
|
|
|
|
case LVN_GETDISPINFO:
|
|
TIMESTART(pdsv->LVGetDispInfo);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void DefView_StopNotify(LPDEFVIEW pdsv, NMHDR *pnm)
|
|
{
|
|
if (pdsv == NULL)
|
|
return;
|
|
|
|
TIMESTOP(pdsv->WMNotify);
|
|
|
|
if (pnm == NULL)
|
|
return;
|
|
|
|
switch (pnm->code) {
|
|
case LVN_ITEMCHANGING:
|
|
TIMESTOP(pdsv->LVChanging);
|
|
break;
|
|
|
|
case LVN_ITEMCHANGED:
|
|
TIMESTOP(pdsv->LVChanged);
|
|
break;
|
|
|
|
case LVN_DELETEITEM:
|
|
TIMESTOP(pdsv->LVDelete);
|
|
break;
|
|
|
|
case LVN_GETDISPINFO:
|
|
TIMESTOP(pdsv->LVGetDispInfo);
|
|
break;
|
|
}
|
|
}
|
|
|
|
HRESULT DV_Next(LPDEFVIEW pdsv, LPENUMIDLIST peunk, int cnt, LPITEMIDLIST *ppidl, ULONG *pcelt)
|
|
{
|
|
HRESULT hres;
|
|
|
|
TIMESTART(pdsv->EnumNext);
|
|
hres = peunk->lpVtbl->Next(peunk, cnt, ppidl, pcelt);
|
|
TIMESTOP(pdsv->EnumNext);
|
|
|
|
return hres;
|
|
}
|
|
|
|
TCHAR *DV_Name(LPDEFVIEW pdsv)
|
|
{
|
|
static TCHAR ach[128];
|
|
GetWindowText(pdsv->hwndMain, ach, ARRAYSIZE(ach));
|
|
return ach;
|
|
}
|
|
|
|
#else
|
|
#define DefView_StartNotify(pdsv, pnm)
|
|
#define DefView_StopNotify(pdsv, pnm)
|
|
#define DV_Next(pdsv,peunk,cnt,ppidl,pcelt) peunk->lpVtbl->Next(peunk, cnt, ppidl, pcelt)
|
|
#define DV_Name(pdsv) NULL
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL DV_IsDropOnSource(LPDEFVIEW pdsv, LPDROPTARGET pdtgt)
|
|
{
|
|
|
|
// context menu paste (bMouseMenu shows context menu, cut stuff shows source)
|
|
if (pdsv->bMouseMenu && pdsv->bHaveCutStuff) {
|
|
int iItem = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_SELECTED);
|
|
if (iItem == -1) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
//
|
|
// If pdtgt is specified, it should match.
|
|
//
|
|
if (pdtgt && (pdtgt != pdsv->pdtgtBack))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (pdsv->itemCur != -1 || !pdsv->bDragSource)
|
|
{
|
|
// We did not drag onto the background of the source
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void DV_MoveIcons(LPDEFVIEW pdsv, LPDATAOBJECT pDataObj)
|
|
{
|
|
STGMEDIUM medium;
|
|
POINT pt, *lpPts;
|
|
FORMATETC fmt = {g_cfOFFSETS, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
|
|
switch (LVStyleFromView(pdsv) & LVS_TYPEMASK) {
|
|
// We are in a mode that does not allow icon moving
|
|
case LVS_LIST:
|
|
case LVS_REPORT:
|
|
return;
|
|
}
|
|
|
|
if (SUCCEEDED(pDataObj->lpVtbl->GetData(pDataObj, &fmt, &medium)))
|
|
{
|
|
lpPts = (POINT *)medium.hGlobal;
|
|
if (lpPts)
|
|
{
|
|
DefView_GetDropPoint(pdsv, &pt);
|
|
DefView_MoveSelectedItems(pdsv, pt.x - lpPts[0].x, pt.y - lpPts[0].y);
|
|
}
|
|
SHReleaseStgMedium(&medium);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// Set the colors for the folder - taking care if it's the desktop.
|
|
void DSV_SetFolderColors(LPDEFVIEW pdsv)
|
|
{
|
|
COLORREF clrText, clrTextBk, clrWindow;
|
|
|
|
// Is this view for the desktop?
|
|
if (DV_ISDESKTOP(pdsv))
|
|
{
|
|
TCHAR szWallpaper[128];
|
|
TCHAR szPattern[128];
|
|
HKEY hkey;
|
|
UINT cb;
|
|
|
|
Shell_SysColorChange();
|
|
|
|
// Yep.
|
|
// Clear the background color of the desktop to make it
|
|
// properly handle transparency.
|
|
clrTextBk = GetSysColor(COLOR_BACKGROUND);
|
|
// set a text color that will show up over desktop color
|
|
if (COLORISLIGHT(clrTextBk))
|
|
clrText = 0x000000; // black
|
|
else
|
|
clrText = 0xFFFFFF; // white
|
|
|
|
//
|
|
// if there is no wallpaper or pattern we can use
|
|
// a solid color for the ListView. otherwise we
|
|
// need to use a transparent ListView, this is much
|
|
// slower so dont do it unless we need to.
|
|
//
|
|
// dont do this optimization in FailSafe boot, otherwise
|
|
// the "FailSafe" text on the desktop can't be seen.
|
|
//
|
|
// dont do this optimization in DEBUG either, for the
|
|
// same reason.
|
|
//
|
|
// too bad there is no SPI_GETWALLPAPER, we need to read
|
|
// from WIN.INI.
|
|
//
|
|
// BUGBUG we assume the string for none starts with a '('
|
|
// BUGBUG we dont know if a random app has subclassed
|
|
// BUGBUG ..the desktop, we should check this case too.
|
|
//
|
|
szWallpaper[0] = 0;
|
|
szPattern[0] = 0;
|
|
|
|
if (RegOpenKey(HKEY_CURRENT_USER, c_szDesktopKey, &hkey) == 0)
|
|
{
|
|
cb = SIZEOF(szWallpaper);
|
|
RegQueryValueEx(hkey, c_szWallpaper, NULL, NULL, (LPBYTE)szWallpaper, &cb);
|
|
cb = SIZEOF(szPattern);
|
|
RegQueryValueEx(hkey, c_szPattern, NULL, NULL, (LPBYTE)szPattern, &cb);
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
if (GetSystemMetrics(SM_CLEANBOOT) == 0 &&
|
|
GetSystemMetrics(SM_DEBUG) == 0 &&
|
|
(!pdsv->fHasDeskWallPaper) &&
|
|
(szWallpaper[0] == 0 || szWallpaper[0] == TEXT('(')) &&
|
|
(szPattern[0] == 0 || szPattern[0] == TEXT('(')))
|
|
{
|
|
clrWindow = GetSysColor(COLOR_BACKGROUND);
|
|
}
|
|
else
|
|
{
|
|
clrWindow = CLR_NONE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Nope.
|
|
clrWindow = GetSysColor(COLOR_WINDOW);
|
|
clrTextBk = clrWindow;
|
|
clrText = GetSysColor(COLOR_WINDOWTEXT);
|
|
}
|
|
|
|
ListView_SetBkColor(pdsv->hwndListview, clrWindow);
|
|
ListView_SetTextBkColor(pdsv->hwndListview, clrTextBk);
|
|
ListView_SetTextColor(pdsv->hwndListview, clrText);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
DWORD LVStyleFromView(LPDEFVIEW pdv)
|
|
{
|
|
DWORD dwStyle;
|
|
|
|
if (DV_ISDESKTOP(pdv))
|
|
{
|
|
dwStyle = LVS_ICON | LVS_NOSCROLL | LVS_ALIGNLEFT;
|
|
}
|
|
else
|
|
{
|
|
switch (pdv->fs.ViewMode) {
|
|
case FVM_LIST:
|
|
dwStyle = LVS_LIST;
|
|
break;
|
|
case FVM_DETAILS:
|
|
dwStyle = LVS_REPORT;
|
|
break;
|
|
case FVM_SMALLICON:
|
|
dwStyle = LVS_SMALLICON;
|
|
break;
|
|
default:
|
|
DebugMsg(DM_ERROR, TEXT("Unknown ViewMode value"));
|
|
// fall through...
|
|
case FVM_ICON:
|
|
dwStyle = LVS_ICON;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pdv->fs.fFlags & FWF_AUTOARRANGE)
|
|
dwStyle |= LVS_AUTOARRANGE;
|
|
|
|
if (pdv->fs.fFlags & FWF_SINGLESEL)
|
|
dwStyle |= LVS_SINGLESEL;
|
|
|
|
return dwStyle;
|
|
}
|
|
|
|
void DefView_AddColumns(LPDEFVIEW pdsv)
|
|
{
|
|
int i = 0, iEndWid;
|
|
USHORT *pColWid;
|
|
LV_COLUMN col;
|
|
TCHAR szInfo[MAX_PATH];
|
|
HDC hdc;
|
|
SIZE siz;
|
|
DETAILSINFO di;
|
|
|
|
// I also use this as a flag for whether to free pColWid
|
|
LPSTREAM pstmCols = NULL;
|
|
|
|
//
|
|
// Calculate a reasonable size to initialize the column width to.
|
|
hdc = GetDC(HWND_DESKTOP);
|
|
SelectFont(hdc, FORWARD_WM_GETFONT(pdsv->hwndListview, SendMessage));
|
|
GetTextExtentPoint(hdc, TEXT("0"), 1, &siz);
|
|
ReleaseDC(HWND_DESKTOP, hdc);
|
|
|
|
pdsv->cxChar = siz.cx;
|
|
|
|
if (!pdsv->psd && !pdsv->pfnCallback)
|
|
{
|
|
goto Error1;
|
|
}
|
|
|
|
if (pdsv->pfnCallback && SUCCEEDED(pdsv->pfnCallback(pdsv->psvOuter,
|
|
pdsv->pshf, pdsv->hwndMain, DVM_GETCOLSAVESTREAM, STGM_READ,
|
|
(LPARAM)&pstmCols)))
|
|
{
|
|
UINT uLen = 0;
|
|
HRESULT hres = DV_AllocRestOfStream(pstmCols, &pColWid, &uLen);
|
|
|
|
pstmCols->lpVtbl->Release(pstmCols);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
iEndWid = uLen / SIZEOF(*pColWid);
|
|
}
|
|
else
|
|
{
|
|
// Make sure we do not try to Free below
|
|
pstmCols = NULL;
|
|
iEndWid = 0;
|
|
}
|
|
}
|
|
else if (pdsv->pSaveHeader && pdsv->pSaveHeader->cbColOffset>=SIZEOF(DVSAVEHEADER))
|
|
{
|
|
USHORT *pEndWid;
|
|
|
|
pColWid = (USHORT *)(((BYTE *)pdsv->pSaveHeader)
|
|
+ pdsv->pSaveHeader->cbColOffset);
|
|
pEndWid = (USHORT *)(((BYTE *)pdsv->pSaveHeader)
|
|
+ pdsv->pSaveHeader->cbPosOffset);
|
|
iEndWid = pEndWid - pColWid;
|
|
}
|
|
else
|
|
{
|
|
iEndWid = 0;
|
|
}
|
|
|
|
for ( ; ; ++i)
|
|
{
|
|
di.fmt = LVCFMT_LEFT;
|
|
di.cxChar = 20;
|
|
di.str.uType = (UINT)-1;
|
|
di.pidl = NULL;
|
|
|
|
if (pdsv->psd)
|
|
{
|
|
if(FAILED(pdsv->psd->lpVtbl->GetDetailsOf(pdsv->psd, NULL, i,
|
|
(LPSHELLDETAILS)&di.fmt)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if (pdsv->pfnCallback)
|
|
{
|
|
if (FAILED(pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_GETDETAILSOF, i, (LPARAM)&di)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
col.mask = LVCF_ALL;
|
|
col.fmt = di.fmt;
|
|
if (i < iEndWid)
|
|
{
|
|
col.cx = pColWid[i];
|
|
}
|
|
else
|
|
{
|
|
col.cx = di.cxChar * siz.cx;
|
|
}
|
|
col.pszText = szInfo;
|
|
col.cchTextMax = ARRAYSIZE(szInfo);
|
|
col.iSubItem = i;
|
|
|
|
StrRetToStrN(col.pszText, col.cchTextMax, &di.str, NULL);
|
|
|
|
ListView_InsertColumn(pdsv->hwndListview, i, &col);
|
|
}
|
|
|
|
if (pstmCols)
|
|
{
|
|
LocalFree((HLOCAL)pColWid);
|
|
}
|
|
|
|
Error1:;
|
|
|
|
if (pdsv->dvState.iLastColumnClick >= i) {
|
|
pdsv->dvState.lParamSort = 0;
|
|
pdsv->dvState.iDirection = 1;
|
|
pdsv->dvState.iLastColumnClick = -1;
|
|
|
|
}
|
|
|
|
// Add in Name Column, such that report view has at least one...
|
|
if (i == 0)
|
|
{
|
|
LoadString(HINST_THISDLL, IDS_NAME_COL, szInfo, ARRAYSIZE(szInfo));
|
|
|
|
col.mask = LVCF_ALL;
|
|
col.fmt = LVCFMT_LEFT;
|
|
col.pszText = szInfo;
|
|
col.cchTextMax = 0;
|
|
col.cx = 30 * siz.cx;
|
|
col.iSubItem = -1;
|
|
ListView_InsertColumn(pdsv->hwndListview, 0, &col);
|
|
}
|
|
|
|
}
|
|
|
|
TCHAR const c_szListViewClass[] = WC_LISTVIEW;
|
|
|
|
LRESULT DefView_CreateListView(LPDEFVIEW pdsv, HWND hWnd)
|
|
{
|
|
DWORD dwStyle;
|
|
DWORD dwExStyle;
|
|
HIMAGELIST himlLarge, himlSmall;
|
|
ULONG rgfAttr;
|
|
|
|
// Map the ViewMode to the proper listview style
|
|
dwStyle = LVStyleFromView(pdsv);
|
|
dwExStyle = 0;
|
|
|
|
rgfAttr = SFGAO_CANRENAME;
|
|
if (SUCCEEDED(pdsv->pshf->lpVtbl->GetAttributesOf(pdsv->pshf, 0, NULL, &rgfAttr))
|
|
&& (rgfAttr & SFGAO_CANRENAME))
|
|
{
|
|
dwStyle |= LVS_EDITLABELS;
|
|
}
|
|
|
|
//
|
|
// If this needs to be an ownerdata list view, set the style accordingly
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
dwStyle |= LVS_OWNERDATA;
|
|
}
|
|
|
|
if (!DV_ISDESKTOP(pdsv))
|
|
{
|
|
dwExStyle |= WS_EX_CLIENTEDGE;
|
|
//dwStyle |= WS_HSCROLL | WS_VSCROLL;
|
|
}
|
|
|
|
// We don't do ownerdata desktops
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv) || FALSE == DV_ISDESKTOP(pdsv));
|
|
|
|
pdsv->hwndListview = CreateWindowEx(dwExStyle, c_szListViewClass, NULL,
|
|
WS_CHILD | WS_CLIPCHILDREN | dwStyle | LVS_SHAREIMAGELISTS,
|
|
0, 0, 0, 0, hWnd, (HMENU)ID_LISTVIEW, HINST_THISDLL, NULL);
|
|
if (!pdsv->hwndListview)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("Failed to create view window"));
|
|
return -1L; // failure
|
|
}
|
|
|
|
Shell_GetImageLists(&himlLarge, &himlSmall);
|
|
ListView_SetImageList(pdsv->hwndListview, himlLarge, LVSIL_NORMAL);
|
|
ListView_SetImageList(pdsv->hwndListview, himlSmall, LVSIL_SMALL);
|
|
|
|
// Give the listview an initial item count if its ownerdata
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
ULONG cCount = pdsv->pasyncenum->lpVtbl->GetCount(pdsv->pasyncenum);
|
|
ListView_SetItemCount(pdsv->hwndListview, cCount);
|
|
}
|
|
|
|
Assert(pdsv->psd == NULL); // this should not be set yet...
|
|
|
|
pdsv->pshf->lpVtbl->CreateViewObject(pdsv->pshf, pdsv->hwndMain, &IID_IShellDetails, &pdsv->psd);
|
|
|
|
DefView_AddColumns(pdsv);
|
|
|
|
DSV_SetFolderColors(pdsv);
|
|
|
|
return 0; // success
|
|
}
|
|
|
|
LRESULT DefView_WndCreate(HWND hWnd, LPCREATESTRUCT lpcs)
|
|
{
|
|
LPDEFVIEW pdsv = (LPDEFVIEW)lpcs->lpCreateParams;
|
|
|
|
SetWindowLong(hWnd, 0, (LONG)pdsv);
|
|
pdsv->sv.lpVtbl->AddRef(&pdsv->sv); // hwnd -> pdsv
|
|
pdsv->hwndView = hWnd;
|
|
pdsv->hmenuCur = NULL;
|
|
pdsv->uState = SVUIA_DEACTIVATE;
|
|
|
|
pdsv->hAccel = LoadAccelerators(HINST_THISDLL, MAKEINTRESOURCE(ACCEL_DEFVIEW));
|
|
|
|
//
|
|
// Note that we are going to get a WM_SIZE message soon, which will
|
|
// place this window correctly
|
|
//
|
|
|
|
return DefView_CreateListView(pdsv, hWnd);
|
|
}
|
|
|
|
|
|
LRESULT DefView_WndSize(HWND hWnd, LPDEFVIEW pdsv)
|
|
{
|
|
RECT rc;
|
|
|
|
// We need to dismiss "name edit" mode, if we are in.
|
|
DefView_DismissEdit(pdsv);
|
|
|
|
// Move the listview to match the View window.
|
|
GetClientRect(hWnd, &rc);
|
|
|
|
if (pdsv->hwndStatic)
|
|
{
|
|
MoveWindow(pdsv->hwndStatic, rc.left, rc.top, rc.right-rc.left,
|
|
rc.bottom-rc.top, TRUE);
|
|
RedrawWindow(pdsv->hwndStatic, NULL, NULL, RDW_ERASE |RDW_INVALIDATE);
|
|
}
|
|
|
|
MoveWindow(pdsv->hwndListview, rc.left, rc.top, rc.right-rc.left,
|
|
rc.bottom-rc.top, TRUE);
|
|
return(1);
|
|
}
|
|
|
|
|
|
UINT _DSV_GetMenuIDFromViewMode(UINT ViewMode)
|
|
{
|
|
switch (ViewMode) {
|
|
case FVM_SMALLICON:
|
|
return SFVIDM_VIEW_SMALLICON;
|
|
case FVM_LIST:
|
|
return SFVIDM_VIEW_LIST;
|
|
case FVM_DETAILS:
|
|
return SFVIDM_VIEW_DETAILS;
|
|
case FVM_ICON:
|
|
default:
|
|
return SFVIDM_VIEW_ICON;
|
|
}
|
|
}
|
|
|
|
void _DSV_CheckToolbar(LPDEFVIEW this)
|
|
{
|
|
UINT idCmd;
|
|
UINT idCmdCurView = _DSV_GetMenuIDFromViewMode(this->fs.ViewMode);
|
|
for (idCmd = SFVIDM_VIEW_ICON; idCmd <= SFVIDM_VIEW_DETAILS; idCmd++)
|
|
{
|
|
this->psb->lpVtbl->SendControlMsg(this->psb,
|
|
FCW_TOOLBAR, TB_CHECKBUTTON, idCmd, (LPARAM)(idCmd == idCmdCurView), NULL);
|
|
}
|
|
}
|
|
|
|
void DSV_OnListViewDelete(LPDEFVIEW this, int iItem, LPITEMIDLIST pidl)
|
|
{
|
|
if (pidl)
|
|
ILFree(pidl);
|
|
}
|
|
|
|
// NOTE: many keys are handled as accelerators
|
|
|
|
void DefView_HandleKeyDown(LPDEFVIEW this, LV_KEYDOWN *lpnmhdr)
|
|
{
|
|
// REVIEW: these are things not handled by accelerators, see if we can
|
|
// make them all based on accelerators
|
|
|
|
switch (lpnmhdr->wVKey) {
|
|
case VK_ESCAPE:
|
|
if (this->bHaveCutStuff)
|
|
SHSetClipboard(NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// DefView_GetItemPIDLS
|
|
//
|
|
// This function returns an array of LPCITEMIDLIST for "selected" objects in the
|
|
// listview. It always returns the number of selected objects. Typically, the
|
|
// client (1) calls this function with cItemMax==0 to know the required size for the
|
|
// array, (2) allocates a block of memory for the array, and (3) calls this function
|
|
// again to get the list of LPCITEMIDLIST.
|
|
//
|
|
// Notes: Note that this function returns LP*C*ITEMIDLIST. The caller is not
|
|
// supposed alter or delete them. Their lifetime are very short (until the
|
|
// list view is modified).
|
|
//
|
|
UINT DefView_GetItemPIDLS(LPDEFVIEW pdsv, LPCITEMIDLIST apidl[], UINT cItemMax,
|
|
UINT uItem)
|
|
{
|
|
// REVIEW: We should put the focused one at the top of the list.
|
|
int iItem = -1;
|
|
int iItemFocus = -1;
|
|
UINT cItem = 0;
|
|
UINT uType;
|
|
|
|
switch (uItem)
|
|
{
|
|
case SVGIO_SELECTION:
|
|
// special case for faster search
|
|
if (!cItemMax) {
|
|
return ListView_GetSelectedCount(pdsv->hwndListview);
|
|
}
|
|
iItemFocus = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_FOCUSED);
|
|
uType = LVNI_SELECTED;
|
|
break;
|
|
|
|
case SVGIO_ALLVIEW:
|
|
// special case for faster search
|
|
if (!cItemMax)
|
|
return ListView_GetItemCount(pdsv->hwndListview);
|
|
uType = LVNI_ALL;
|
|
break;
|
|
}
|
|
|
|
while((iItem = ListView_GetNextItem(pdsv->hwndListview, iItem, uType))!=-1)
|
|
{
|
|
if (cItem < cItemMax)
|
|
{
|
|
// Check if the item is the focused one or not.
|
|
if (iItem == iItemFocus)
|
|
{
|
|
// Yes, put it at the top.
|
|
apidl[cItem] = apidl[0];
|
|
apidl[0] = DSV_GetPIDL(pdsv, iItem);
|
|
}
|
|
else
|
|
{
|
|
// No, put it at the end of the list.
|
|
apidl[cItem] = DSV_GetPIDL(pdsv, iItem);
|
|
}
|
|
}
|
|
cItem++;
|
|
}
|
|
|
|
return cItem;
|
|
}
|
|
|
|
|
|
//
|
|
// This function get the array of IDList from the selection and calls
|
|
// IShellFolder::GetUIObjectOf member to get the specified UI object
|
|
// interface.
|
|
//
|
|
HRESULT DefView_GetUIObjectFromItem(LPDEFVIEW pdsv, REFIID riid, LPVOID * ppv,
|
|
UINT uItem)
|
|
{
|
|
LPCITEMIDLIST * apidl;
|
|
HRESULT hres = DefView_GetItemObjects(pdsv, &apidl, uItem);
|
|
UINT cItems = ShortFromResult(hres);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (cItems)
|
|
{
|
|
hres = pdsv->pshf->lpVtbl->GetUIObjectOf(pdsv->pshf,
|
|
pdsv->hwndMain, cItems, apidl, riid, 0, ppv);
|
|
LocalFree((HLOCAL)apidl);
|
|
}
|
|
else
|
|
{
|
|
hres = E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
//
|
|
// This function creates the cached context menu for the current selection
|
|
// and update the cache, if it is not created yet. Then, returns a copied
|
|
// pointer to it. The caller should Release() it.
|
|
//
|
|
LPCONTEXTMENU DefView_GetContextMenuFromSelection(LPDEFVIEW pdsv)
|
|
{
|
|
LPCONTEXTMENU pcm = NULL;
|
|
|
|
if (pdsv->pcmSel == NULL)
|
|
{
|
|
if (FAILED(DefView_GetUIObjectFromItem(pdsv, &IID_IContextMenu,
|
|
&pdsv->pcmSel, SVGIO_SELECTION)))
|
|
{
|
|
pdsv->pcmSel = NULL;
|
|
}
|
|
}
|
|
|
|
if (pdsv->pcmSel)
|
|
{
|
|
pcm = pdsv->pcmSel;
|
|
pcm->lpVtbl->AddRef(pcm);
|
|
}
|
|
|
|
Assert(pcm == pdsv->pcmSel);
|
|
|
|
return pcm;
|
|
}
|
|
|
|
#define DEFAULT_ATTRIBUTES (DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY | SFGAO_CANDELETE | SFGAO_CANRENAME | SFGAO_HASPROPSHEET)
|
|
DWORD DefView_GetAttributesFromSelection(LPDEFVIEW pdsv, DWORD dwAttrMask)
|
|
{
|
|
DWORD dwAttrQuery = DEFAULT_ATTRIBUTES | dwAttrMask;
|
|
|
|
if ((pdsv->dwAttrSel == (DWORD)-1) || (dwAttrQuery != DEFAULT_ATTRIBUTES))
|
|
{
|
|
LPCITEMIDLIST *apidl;
|
|
HRESULT hres = DefView_GetItemObjects(pdsv, &apidl, SVGIO_SELECTION);
|
|
|
|
//
|
|
// this cache was written right before RC1 if you hit this after fix it
|
|
//
|
|
Assert(dwAttrQuery == DEFAULT_ATTRIBUTES);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
UINT cItems = ShortFromResult(hres);
|
|
|
|
if (cItems)
|
|
{
|
|
if (SUCCEEDED(pdsv->pshf->lpVtbl->GetAttributesOf(pdsv->pshf,
|
|
cItems, apidl, &dwAttrQuery)))
|
|
{
|
|
pdsv->dwAttrSel = dwAttrQuery;
|
|
}
|
|
|
|
LocalFree((HLOCAL)apidl);
|
|
} else {
|
|
// mask out attrib bits here... if there's no selection, we can't
|
|
// rename, delete, link, prop...
|
|
|
|
// BUGBUG: maybe this should be set to 0, but I'm afraid of what
|
|
// yanking SFGAO_FILESYS and other random stuff will do to us..
|
|
|
|
pdsv->dwAttrSel &= ~(DROPEFFECT_LINK |
|
|
DROPEFFECT_MOVE |
|
|
DROPEFFECT_COPY |
|
|
SFGAO_CANDELETE |
|
|
SFGAO_CANRENAME |
|
|
SFGAO_HASPROPSHEET);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (pdsv->dwAttrSel & dwAttrMask);
|
|
}
|
|
|
|
void DV_FlushCachedMenu(LPDEFVIEW pdsv)
|
|
{
|
|
if (pdsv->pcmSel)
|
|
{
|
|
LPCONTEXTMENU pcm = pdsv->pcmSel;
|
|
pdsv->pcmSel = NULL;
|
|
pcm->lpVtbl->Release(pcm);
|
|
}
|
|
}
|
|
|
|
void DefView_ContextMenu(LPDEFVIEW pdsv, DWORD dwPos)
|
|
{
|
|
int iItem;
|
|
int idCmd;
|
|
int idDefault = -1;
|
|
int nInsert;
|
|
HMENU hmContext;
|
|
LPCONTEXTMENU pcm = NULL;
|
|
UINT fFlags = 0;
|
|
POINT pt;
|
|
|
|
// Find the selected item
|
|
iItem = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_SELECTED);
|
|
|
|
if (dwPos == (DWORD) -1)
|
|
{
|
|
if (iItem != -1)
|
|
{
|
|
RECT rc;
|
|
int iItemFocus = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_FOCUSED|LVNI_SELECTED);
|
|
if (iItemFocus == -1)
|
|
iItemFocus = iItem;
|
|
|
|
//
|
|
// Note that LV_GetItemRect returns it in client coordinate!
|
|
//
|
|
ListView_GetItemRect(pdsv->hwndListview, iItemFocus, &rc, LVIR_ICON);
|
|
pt.x = (rc.left+rc.right)/2;
|
|
pt.y = (rc.top+rc.bottom)/2;
|
|
}
|
|
else
|
|
{
|
|
pt.x = pt.y = 0;
|
|
}
|
|
MapWindowPoints(pdsv->hwndListview, HWND_DESKTOP, &pt, 1);
|
|
}
|
|
else
|
|
{
|
|
pt.x = LOWORD(dwPos);
|
|
pt.y = HIWORD(dwPos);
|
|
}
|
|
|
|
if (iItem == -1)
|
|
{
|
|
// No selected item; use the background context menu
|
|
hmContext = _LoadPopupMenu(POPUP_SFV_BACKGROUND);
|
|
nInsert = -1;
|
|
|
|
if (!hmContext)
|
|
{
|
|
// BUGBUG: There should be an error message here
|
|
return;
|
|
}
|
|
|
|
// HACK: we are only initializing the Paste command, so we don't
|
|
// need any attributes
|
|
Def_InitEditCommands(0, hmContext, SFVIDM_FIRST, pdsv->pdtgtBack, DIEC_BACKGROUNDCONTEXT);
|
|
DefView_InitViewMenu(pdsv, hmContext);
|
|
|
|
if (SUCCEEDED(pdsv->pshf->lpVtbl->CreateViewObject(pdsv->pshf, pdsv->hwndMain,
|
|
&IID_IContextMenu, &pcm)))
|
|
{
|
|
pdsv->pcmSel = pcm;
|
|
pcm->lpVtbl->AddRef(pcm);
|
|
}
|
|
else
|
|
{
|
|
Assert(FALSE);
|
|
}
|
|
#if DEBUG
|
|
if (GetKeyState(VK_CONTROL)<0)
|
|
{
|
|
HMENU hmenuDebug = _LoadPopupMenu(POPUP_DEBUG_DEFVIEW);
|
|
if (hmenuDebug)
|
|
{
|
|
InsertMenu(hmContext, (UINT)-1, MF_POPUP|MF_BYPOSITION, (UINT)hmenuDebug, TEXT("(&Debug)"));
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
fFlags |= CMF_CANRENAME;
|
|
|
|
hmContext = CreatePopupMenu();
|
|
nInsert = 0;
|
|
|
|
if (!hmContext)
|
|
{
|
|
// BUGBUG: There should be an error message here
|
|
return;
|
|
}
|
|
|
|
// One or more items are selected, let the folder add menuitems.
|
|
pcm = DefView_GetContextMenuFromSelection(pdsv);
|
|
}
|
|
|
|
if (pcm)
|
|
{
|
|
if (pdsv->psb) {
|
|
HWND hwnd = NULL;
|
|
pdsv->psb->lpVtbl->GetControlWindow(pdsv->psb, FCW_TREE, &hwnd);
|
|
if (hwnd) {
|
|
fFlags |= CMF_EXPLORE;
|
|
}
|
|
}
|
|
|
|
pcm->lpVtbl->QueryContextMenu(pcm, hmContext, nInsert,
|
|
SFVIDM_CONTEXT_FIRST, SFVIDM_CONTEXT_LAST, fFlags);
|
|
|
|
// 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 (pdsv->pcdb)
|
|
{
|
|
// make sure this is an item
|
|
if (iItem != -1)
|
|
{
|
|
HMENU hmSelect = _LoadPopupMenu(POPUP_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.
|
|
// SFVIDM_CONTEXT_FIRST-1 won't conflict with anyone.
|
|
Shell_MergeMenus(hmContext, hmSelect, 0,
|
|
(UINT)(SFVIDM_CONTEXT_FIRST-1), (UINT)-1,
|
|
MM_ADDSEPARATOR);
|
|
|
|
SetMenuDefaultItem(hmContext, 0, MF_BYPOSITION);
|
|
DestroyMenu(hmSelect);
|
|
}
|
|
}
|
|
|
|
idDefault = GetMenuDefaultItem(hmContext, MF_BYCOMMAND, 0);
|
|
}
|
|
|
|
_SHPrettyMenu(hmContext);
|
|
|
|
idCmd = TrackPopupMenu(hmContext,
|
|
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
|
|
pt.x, pt.y, 0, pdsv->hwndView, NULL);
|
|
|
|
if ((idCmd == idDefault) &&
|
|
DV_CDB_OnDefaultCommand(pdsv) == S_OK)
|
|
{
|
|
// commdlg browser ate the default command
|
|
}
|
|
else if (idCmd == 0)
|
|
{
|
|
// No item selected
|
|
}
|
|
else
|
|
{
|
|
// A default menu item was selected; let everybody
|
|
// process it normally
|
|
// Note that this must be called before clearing out pdsv->pcmSel,
|
|
// so we cannot do this with a PostMessage
|
|
DefView_Command(pdsv, pcm, GET_WM_COMMAND_MPS(idCmd, 0, 0));
|
|
}
|
|
|
|
if (pcm)
|
|
{
|
|
pcm->lpVtbl->Release(pcm);
|
|
if (pdsv->pcmSel == pcm)
|
|
{
|
|
DV_FlushCachedMenu(pdsv);
|
|
}
|
|
}
|
|
|
|
DestroyMenu(hmContext);
|
|
}
|
|
|
|
void CALLBACK DefView_GetDataPoint(LPCITEMIDLIST pidl, LPPOINT lpPt, LPARAM lParam)
|
|
{
|
|
#define pdsv ((LPDEFVIEW)lParam)
|
|
|
|
if (pidl)
|
|
DefView_GetItemPosition(pdsv, pidl, lpPt);
|
|
else
|
|
DefView_GetDragPoint(pdsv, lpPt);
|
|
|
|
#undef pdsv
|
|
}
|
|
|
|
HRESULT DataObj_SetGlobal(IDataObject *pdtobj, UINT cf, HGLOBAL hGlobal)
|
|
{
|
|
FORMATETC fmte = {cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
STGMEDIUM medium;
|
|
|
|
medium.tymed = TYMED_HGLOBAL;
|
|
medium.hGlobal = hGlobal;
|
|
medium.pUnkForRelease = NULL;
|
|
|
|
// give the data object ownership of ths
|
|
return pdtobj->lpVtbl->SetData(pdtobj, &fmte, &medium, TRUE);
|
|
}
|
|
|
|
HRESULT DataObj_SetPoints(LPDATAOBJECT pdtobj, LPFNCIDLPOINTS lpfnPts, LPARAM lParam, LPSCALEINFO lpsi)
|
|
{
|
|
HRESULT hres = (E_OUTOFMEMORY);
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium); // This should never fail
|
|
if (pida)
|
|
{
|
|
POINT *ppt = GlobalAlloc(GPTR, SIZEOF(POINT) * (1 + pida->cidl));
|
|
if (ppt)
|
|
{
|
|
UINT i;
|
|
POINT ptOrigin;
|
|
// Grab the anchor point
|
|
lpfnPts(NULL, &ptOrigin, lParam);
|
|
ppt[0] = ptOrigin;
|
|
|
|
for (i = 1; i <= pida->cidl; i++)
|
|
{
|
|
LPCITEMIDLIST pidl = IDA_GetIDListPtr(pida, i - 1);
|
|
|
|
lpfnPts(pidl, &ppt[i], lParam);
|
|
ppt[i].x -= ptOrigin.x;
|
|
ppt[i].y -= ptOrigin.y;
|
|
ppt[i].x = (ppt[i].x * lpsi->xMul) / lpsi->xDiv;
|
|
ppt[i].y = (ppt[i].y * lpsi->yMul) / lpsi->yDiv;
|
|
}
|
|
|
|
hres = DataObj_SetGlobal(pdtobj, g_cfOFFSETS, ppt);
|
|
if (FAILED(hres))
|
|
GlobalFree((HGLOBAL)ppt);
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
///returns TRUE if in a small view
|
|
|
|
BOOL DV_GetItemSpacing(LPDEFVIEW pdsv, LPITEMSPACING lpis)
|
|
{
|
|
DWORD dwSize;
|
|
|
|
dwSize = ListView_GetItemSpacing(pdsv->hwndListview, TRUE);
|
|
lpis->cxSmall = LOWORD(dwSize);
|
|
lpis->cySmall = HIWORD(dwSize);
|
|
dwSize = ListView_GetItemSpacing(pdsv->hwndListview, FALSE);
|
|
lpis->cxLarge = LOWORD(dwSize);
|
|
lpis->cyLarge = HIWORD(dwSize);
|
|
|
|
return (pdsv->fs.ViewMode != FVM_ICON);
|
|
}
|
|
|
|
void DefView_SetPoints(LPDEFVIEW pdsv, LPDATAOBJECT pdtobj)
|
|
{
|
|
SCALEINFO si;
|
|
|
|
// convert coordinates to large icon view spacing
|
|
if (pdsv->fs.ViewMode == FVM_ICON) {
|
|
si.xMul = si.yMul = si.xDiv = si.yDiv = 1;
|
|
} else {
|
|
ITEMSPACING is;
|
|
|
|
DV_GetItemSpacing(pdsv, &is);
|
|
|
|
si.xDiv = is.cxSmall;
|
|
si.yDiv = is.cySmall;
|
|
si.xMul = is.cxLarge;
|
|
si.yMul = is.cyLarge;
|
|
}
|
|
|
|
// Assuming this is a CIDLData thing, poke the icon
|
|
// locations into it
|
|
DataObj_SetPoints(pdtobj, DefView_GetDataPoint, (LPARAM)pdsv, &si);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// REVIEW: Currently, we are not doing any serialization assuming that
|
|
// only one GUI thread can come here at a time.
|
|
//
|
|
LRESULT DefView_BeginDrag(LPDEFVIEW pdsv, NM_LISTVIEW * lpnm)
|
|
{
|
|
LPDATAOBJECT pdtobj;
|
|
POINT ptOffset = lpnm->ptAction; // hwndLV client coords
|
|
|
|
//
|
|
// Get the dwEffect from the selection.
|
|
//
|
|
DWORD dwEffect = DefView_GetAttributesFromSelection(pdsv, DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY) & (DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY);
|
|
/// not when you dragfrom wastebasket
|
|
///Assert(dwEffect & DROPEFFECT_LINK); // We should always have DROPEFFECT_LINK
|
|
|
|
// Somebody began dragging in our window, so store that fact
|
|
pdsv->bDragSource = TRUE;
|
|
|
|
// save away the anchor point;
|
|
pdsv->ptDragAnchor = lpnm->ptAction;
|
|
LVUtil_ClientToLV(pdsv->hwndListview, &pdsv->ptDragAnchor);
|
|
|
|
ClientToScreen(pdsv->hwndListview, &ptOffset); // now in screen
|
|
|
|
if (DAD_SetDragImageFromListView(pdsv->hwndListview, ptOffset))
|
|
{
|
|
if (SUCCEEDED(DefView_GetUIObjectFromItem(pdsv, &IID_IDataObject, &pdtobj,
|
|
SVGIO_SELECTION)))
|
|
{
|
|
HRESULT hres;
|
|
|
|
DefView_SetPoints(pdsv, pdtobj);
|
|
hres = SHDoDragDrop(pdsv->hwndMain, pdtobj, NULL, dwEffect, &dwEffect);
|
|
|
|
if (SUCCEEDED(hres) && dwEffect && pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter,
|
|
pdsv->pshf, pdsv->hwndMain, DVM_DIDDRAGDROP,
|
|
(WPARAM)dwEffect, (LPARAM)pdtobj);
|
|
}
|
|
|
|
pdtobj->lpVtbl->Release(pdtobj);
|
|
}
|
|
|
|
//
|
|
// We need to clear the dragged image only if we still have the drag context.
|
|
//
|
|
DAD_SetDragImage((HIMAGELIST)-1, NULL);
|
|
}
|
|
|
|
// All done dragging
|
|
pdsv->bDragSource = FALSE;
|
|
|
|
return 0L;
|
|
}
|
|
|
|
void DV_FocusOnSomething(LPDEFVIEW pdsv)
|
|
{
|
|
int iFocus;
|
|
|
|
iFocus = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_FOCUSED);
|
|
if (iFocus == -1) {
|
|
// set the focus on the first item.
|
|
ListView_SetItemState(pdsv->hwndListview, 0, LVIS_FOCUSED, LVIS_FOCUSED);
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT DefView_InvokeCommand(LPDEFVIEW pdsv, IContextMenu *pcm,
|
|
CMINVOKECOMMANDINFOEX *pici)
|
|
{
|
|
TCHAR szWorkingDir[MAX_PATH];
|
|
HRESULT hres;
|
|
#ifdef UNICODE
|
|
CHAR szWorkingDirAnsi[MAX_PATH];
|
|
#endif
|
|
|
|
if (SUCCEEDED(pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_GETWORKINGDIR,
|
|
ARRAYSIZE(szWorkingDir), (LPARAM)szWorkingDir)))
|
|
{
|
|
#ifdef UNICODE
|
|
// Fill in both the ansi working dir and the unicode one
|
|
// since we don't know who's gonna be processing this thing.
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
szWorkingDir, -1,
|
|
szWorkingDirAnsi, ARRAYSIZE(szWorkingDirAnsi),
|
|
NULL, NULL);
|
|
pici->lpDirectory = szWorkingDirAnsi;
|
|
pici->lpDirectoryW = szWorkingDir;
|
|
pici->fMask |= CMIC_MASK_UNICODE;
|
|
#else
|
|
pici->lpDirectory = szWorkingDir;
|
|
#endif
|
|
}
|
|
|
|
hres = pcm->lpVtbl->InvokeCommand(pcm, (LPCMINVOKECOMMANDINFO)pici);
|
|
|
|
return(hres);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
#define CMD_ID_FIRST 1
|
|
#define CMD_ID_LAST 0x7fff
|
|
|
|
void DefView_ProcessDblClick(LPDEFVIEW pdsv)
|
|
{
|
|
// Use the cached context menu object if there is one, else
|
|
// make it.
|
|
LPCONTEXTMENU pcmSel;
|
|
// SHIFT invokes the "alternate" command (usually Print)
|
|
int iShowCmd = SW_NORMAL;
|
|
DECLAREWAITCURSOR;
|
|
|
|
if (DV_CDB_OnDefaultCommand(pdsv) == S_OK)
|
|
{
|
|
return; /* commdlg browser ate the message */
|
|
}
|
|
SetWaitCursor();
|
|
pcmSel = DefView_GetContextMenuFromSelection(pdsv);
|
|
|
|
if (pcmSel)
|
|
{
|
|
HMENU hmenu = CreatePopupMenu();
|
|
|
|
if (hmenu)
|
|
{
|
|
CMINVOKECOMMANDINFOEX ici = {
|
|
SIZEOF(CMINVOKECOMMANDINFOEX),
|
|
0L,
|
|
pdsv->hwndMain,
|
|
NULL,
|
|
NULL, NULL,
|
|
iShowCmd,
|
|
};
|
|
|
|
if (GetAsyncKeyState(VK_MENU) < 0)
|
|
{
|
|
#ifdef UNICODE
|
|
// Fill in both the ansi verb and the unicode verb since we
|
|
// don't know who is going to be processing this thing.
|
|
ici.lpVerb = c_szPropertiesAnsi;
|
|
ici.lpVerbW = c_szProperties;
|
|
ici.fMask |= CMIC_MASK_UNICODE;
|
|
#else
|
|
ici.lpVerb = c_szProperties;
|
|
#endif
|
|
// If ALT double click, accelerator for "Properties..."
|
|
|
|
// need to reset it so that user won't blow off the app starting cursor
|
|
// also so that if we won't leave the wait cursor up when we're not waiting
|
|
// (like in a prop sheet or something that has a message loop
|
|
ResetWaitCursor();
|
|
hcursor_wait_cursor_save = NULL;
|
|
|
|
DefView_InvokeCommand(pdsv, pcmSel, &ici);
|
|
}
|
|
else
|
|
{
|
|
UINT idCmd;
|
|
UINT fFlags = CMF_DEFAULTONLY;
|
|
if (pdsv->psb) {
|
|
HWND hwnd = NULL;
|
|
pdsv->psb->lpVtbl->GetControlWindow(pdsv->psb, FCW_TREE, &hwnd);
|
|
if (hwnd) {
|
|
fFlags |= CMF_EXPLORE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// SHIFT+dblclick does a Explore by default
|
|
//
|
|
if (GetAsyncKeyState(VK_SHIFT) < 0)
|
|
fFlags |= CMF_EXPLORE;
|
|
|
|
pcmSel->lpVtbl->QueryContextMenu(pcmSel, hmenu, 0, CMD_ID_FIRST, CMD_ID_LAST,
|
|
fFlags);
|
|
|
|
idCmd = GetMenuDefaultItem(hmenu, MF_BYCOMMAND, 0);
|
|
|
|
// need to reset it so that user won't blow off the app starting cursor
|
|
// also so that if we won't leave the wait cursor up when we're not waiting
|
|
// (like in a prop sheet or something that has a message loop
|
|
ResetWaitCursor();
|
|
hcursor_wait_cursor_save = NULL;
|
|
if (idCmd)
|
|
{
|
|
ici.lpVerb = (LPSTR)MAKEINTRESOURCE(idCmd - CMD_ID_FIRST);
|
|
DefView_InvokeCommand(pdsv, pcmSel, &ici);
|
|
}
|
|
DestroyMenu(hmenu);
|
|
}
|
|
}
|
|
// Release our use of the context menu
|
|
pcmSel->lpVtbl->Release(pcmSel);
|
|
if (pdsv->pcmSel == pcmSel)
|
|
{
|
|
DV_FlushCachedMenu(pdsv);
|
|
}
|
|
}
|
|
|
|
if (hcursor_wait_cursor_save)
|
|
ResetWaitCursor();
|
|
}
|
|
|
|
|
|
LRESULT DefView_OnLVNotify(LPDEFVIEW pdsv, NMHDR *pnm)
|
|
{
|
|
switch (pnm->code) {
|
|
case NM_KILLFOCUS:
|
|
// force update on inactive to not ruin save bits
|
|
DV_CDB_OnStateChange(pdsv, CDBOSC_KILLFOCUS);
|
|
if (GetForegroundWindow() != pdsv->hwndMain)
|
|
UpdateWindow(pdsv->hwndListview);
|
|
break;
|
|
|
|
case NM_SETFOCUS:
|
|
{
|
|
LPSHELLVIEW psv = (pdsv->psvOuter ? pdsv->psvOuter : &pdsv->sv);
|
|
// We should call IShellBrowser::OnViewWindowActive() before
|
|
// calling its InsertMenus().
|
|
pdsv->psb->lpVtbl->OnViewWindowActive(pdsv->psb, psv);
|
|
DV_CDB_OnStateChange(pdsv, CDBOSC_SETFOCUS);
|
|
CDefView_OnActivate(pdsv, SVUIA_ACTIVATE_FOCUS);
|
|
DV_FocusOnSomething(pdsv);
|
|
}
|
|
break;
|
|
|
|
#define lplvn ((NM_LISTVIEW *)pnm)
|
|
case NM_RETURN:
|
|
case NM_DBLCLK:
|
|
if (!pdsv->fDisabled)
|
|
DefView_ProcessDblClick(pdsv);
|
|
break;
|
|
|
|
|
|
case LVN_BEGINDRAG:
|
|
case LVN_BEGINRDRAG:
|
|
{
|
|
if (pdsv->fDisabled)
|
|
return FALSE; /* commdlg doesn't want user dragging */
|
|
|
|
return DefView_BeginDrag(pdsv, lplvn);
|
|
}
|
|
|
|
case LVN_ITEMCHANGING:
|
|
if (pdsv->fDisabled)
|
|
return TRUE;
|
|
break;
|
|
|
|
// Something changed in the listview. Delete any data that
|
|
// we might have cached away.
|
|
//
|
|
case LVN_ITEMCHANGED:
|
|
// We only care about STATECHANGE messages
|
|
if (!(lplvn->uChanged & LVIF_STATE))
|
|
{
|
|
// If the text is changed, we need to flush the cached
|
|
// context menu.
|
|
if (lplvn->uChanged&LVIF_TEXT)
|
|
{
|
|
DV_FlushCachedMenu(pdsv);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// tell commdlg that selection may have changed
|
|
DV_CDB_OnStateChange(pdsv, CDBOSC_SELCHANGE);
|
|
|
|
// The rest only cares about SELCHANGE messages
|
|
if ((lplvn->uNewState^lplvn->uOldState) & LVIS_SELECTED)
|
|
{
|
|
// toss the cached context menu
|
|
DV_FlushCachedMenu(pdsv);
|
|
|
|
// throw away cached attribute bits
|
|
pdsv->dwAttrSel = (DWORD)-1;
|
|
|
|
// Tell the defview client that the selection may have changed
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
DVSELCHANGEINFO dvsci;
|
|
|
|
dvsci.uNewState = lplvn->uNewState;
|
|
dvsci.uOldState = lplvn->uOldState;
|
|
dvsci.plParam = &pdsv->lSelChangeInfo;
|
|
dvsci.lParamItem = lplvn->lParam;
|
|
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_SELCHANGE,
|
|
MAKEWPARAM(SFVIDM_CLIENT_FIRST, lplvn->iItem),
|
|
(LPARAM)&dvsci);
|
|
}
|
|
|
|
DV_UpdateStatusBar(pdsv, FALSE);
|
|
}
|
|
|
|
break;
|
|
|
|
case LVN_DELETEITEM:
|
|
|
|
//
|
|
// We should not be called to clean up items when in ownerdata mode,
|
|
// since there's nothing to clean up
|
|
//
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
DSV_OnListViewDelete(pdsv, lplvn->iItem, (LPITEMIDLIST)lplvn->lParam);
|
|
DV_FlushCachedMenu(pdsv);
|
|
break;
|
|
|
|
case LVN_COLUMNCLICK:
|
|
// Quick hack to allow clicking on columns to set the sort order
|
|
if (pdsv->psd || pdsv->pfnCallback)
|
|
{
|
|
// toggle the direction of the sort if on the same column
|
|
if (pdsv->dvState.iLastColumnClick == lplvn->iSubItem)
|
|
pdsv->dvState.iDirection = -pdsv->dvState.iDirection;
|
|
else
|
|
pdsv->dvState.iDirection = 1;
|
|
|
|
pdsv->dvState.iLastColumnClick = lplvn->iSubItem;
|
|
|
|
if (pdsv->psd)
|
|
pdsv->psd->lpVtbl->ColumnClick(pdsv->psd, lplvn->iSubItem);
|
|
else
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_COLUMNCLICK, lplvn->iSubItem, 0L);
|
|
}
|
|
break;
|
|
|
|
#undef lplvn
|
|
|
|
case LVN_KEYDOWN:
|
|
DefView_HandleKeyDown(pdsv, ((LV_KEYDOWN *)pnm));
|
|
break;
|
|
|
|
#define lpdi ((LV_DISPINFO *)pnm)
|
|
|
|
case LVN_BEGINLABELEDIT:
|
|
{
|
|
ULONG rgfAttr;
|
|
|
|
LPCITEMIDLIST pidl;
|
|
|
|
//
|
|
// If this is an owner-data listview, we need to retrieve the pidl
|
|
// based on the index of the item. Otherwise, we just just take the
|
|
// lParam (which is the pidl in non-ownerdata cases)
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
pidl = DSV_GetPIDL(pdsv, lpdi->item.iItem);
|
|
}
|
|
else
|
|
{
|
|
pidl = (LPITEMIDLIST)lpdi->item.lParam;
|
|
}
|
|
|
|
ASSERT(pidl);
|
|
|
|
rgfAttr = SFGAO_CANRENAME;
|
|
|
|
if (!pidl || FAILED(pdsv->pshf->lpVtbl->GetAttributesOf(pdsv->pshf, 1, &pidl, &rgfAttr))
|
|
|| !(rgfAttr & SFGAO_CANRENAME))
|
|
{
|
|
MessageBeep(0);
|
|
return TRUE; // Don't allow label edit
|
|
}
|
|
|
|
pdsv->fInLabelEdit = TRUE;
|
|
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
HWND hwndEdit = ListView_GetEditControl(pdsv->hwndListview);
|
|
int cchMax = 0;
|
|
HRESULT hres = pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_GETCCHMAX, (WPARAM)pidl, (LPARAM)&cchMax);
|
|
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_OnBeginLabelEdit cchMax=%d hwndEdit=%x"),
|
|
cchMax, hwndEdit);
|
|
|
|
if (SUCCEEDED(hres) && cchMax>0 && hwndEdit)
|
|
{
|
|
Assert(cchMax < 1024);
|
|
SendMessage(hwndEdit, EM_LIMITTEXT, cchMax, 0);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LVN_ENDLABELEDIT:
|
|
|
|
pdsv->fInLabelEdit = FALSE;
|
|
if (lpdi->item.pszText)
|
|
{
|
|
LPCITEMIDLIST pidl;
|
|
|
|
//
|
|
// If this is an owner-data listview, we need to retrieve the pidl
|
|
// based on the index of the item. Otherwise, we just just take the
|
|
// lParam (which is the pidl in non-ownerdata cases)
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
pidl = DSV_GetPIDL(pdsv, lpdi->item.iItem);
|
|
}
|
|
else
|
|
{
|
|
pidl = (LPITEMIDLIST)lpdi->item.lParam;
|
|
}
|
|
|
|
if (pidl)
|
|
{
|
|
// BUGBUG I made this lstrlenA, since i think its always ansi->wchar conversion
|
|
|
|
LPOLESTR pwsz = (LPOLESTR)LocalAlloc(LPTR, (lstrlen(lpdi->item.pszText) + 1) * SIZEOF(WCHAR));
|
|
if (pwsz)
|
|
{
|
|
CloudHookBeginRename(lpdi->item.pszText,
|
|
pdsv->hwndListview, lpdi->item.iItem);
|
|
StrToOleStr(pwsz, lpdi->item.pszText);
|
|
if (SUCCEEDED(pdsv->pshf->lpVtbl->SetNameOf(pdsv->pshf, pdsv->hwndMain,
|
|
pidl, pwsz, SHGDN_INFOLDER, NULL)))
|
|
{
|
|
SHChangeNotifyHandleEvents();
|
|
DV_CDB_OnStateChange(pdsv, CDBOSC_RENAME);
|
|
}
|
|
else
|
|
SendMessage(pdsv->hwndListview, LVM_EDITLABEL, lpdi->item.iItem,
|
|
(LPARAM)lpdi->item.pszText);
|
|
LocalFree((HLOCAL)pwsz);
|
|
CloudHookEndRename();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The user canceled. so return TRUE to let things like the mouse
|
|
// click be processed.
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
|
|
case LVN_GETDISPINFO:
|
|
{
|
|
LPCITEMIDLIST pidl;
|
|
LV_ITEM item;
|
|
TCHAR szIconFile[MAX_PATH];
|
|
DETAILSINFO di;
|
|
|
|
if (!(lpdi->item.mask & (LVIF_TEXT | LVIF_IMAGE)))
|
|
break;
|
|
|
|
//
|
|
// If this is an owner-data listview, we need to retrieve the pidl
|
|
// based on the index of the item. Otherwise, we just just take the
|
|
// lParam (which is the pidl in non-ownerdata cases)
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
pidl = DSV_GetPIDL(pdsv, lpdi->item.iItem);
|
|
}
|
|
else
|
|
{
|
|
pidl = (LPITEMIDLIST)lpdi->item.lParam;
|
|
}
|
|
|
|
if (!pidl)
|
|
break;
|
|
|
|
item.mask = lpdi->item.mask & (LVIF_TEXT | LVIF_IMAGE);
|
|
item.iItem = lpdi->item.iItem;
|
|
item.iSubItem = lpdi->item.iSubItem;
|
|
item.iImage = lpdi->item.iImage = -1; // for iSubItem!=0 case
|
|
|
|
if (item.iSubItem==0 && (item.mask&LVIF_IMAGE))
|
|
{
|
|
DWORD uFlags = SFGAO_DISPLAYATTRMASK;
|
|
|
|
pdsv->pshf->lpVtbl->GetAttributesOf(pdsv->pshf, 1, &pidl, &uFlags);
|
|
|
|
// set the mask
|
|
item.mask |= LVIF_STATE;
|
|
lpdi->item.mask |= LVIF_STATE;
|
|
item.stateMask = LVIS_OVERLAYMASK | LVIS_CUT;
|
|
|
|
// Pick the right overlay icon. The order is significant.
|
|
item.state = 0;
|
|
if (uFlags & SFGAO_LINK) {
|
|
item.state = INDEXTOOVERLAYMASK(IDOI_LINK);
|
|
} else if (uFlags & SFGAO_SHARE) {
|
|
item.state = INDEXTOOVERLAYMASK(IDOI_SHARE);
|
|
} else if (uFlags & SFGAO_READONLY) {
|
|
item.state = INDEXTOOVERLAYMASK(IDOI_READONLY);
|
|
}
|
|
if (uFlags & SFGAO_GHOSTED) {
|
|
item.state |= LVIS_CUT;
|
|
}
|
|
|
|
lpdi->item.stateMask = item.stateMask;
|
|
lpdi->item.state = item.state;
|
|
|
|
// Get the image
|
|
TIMESTART(pdsv->GetIcon);
|
|
SHGetIconFromPIDL(pdsv->pshf,pdsv->psi,pidl,0,&item.iImage);
|
|
TIMESTOP(pdsv->GetIcon);
|
|
|
|
lpdi->item.iImage = item.iImage;
|
|
}
|
|
|
|
// Note that TEXT must come after IMAGE, since we reuse
|
|
// szIconFile
|
|
if (item.mask & LVIF_TEXT)
|
|
{
|
|
if (lpdi->item.cchTextMax)
|
|
*lpdi->item.pszText = TEXT('\0');
|
|
|
|
di.str.uType = STRRET_CSTR;
|
|
di.str.cStr[0] = '\0';
|
|
|
|
// Note that we do something different for index 0 = NAME
|
|
if (item.iSubItem == 0)
|
|
{
|
|
item.pszText = szIconFile;
|
|
item.cchTextMax = ARRAYSIZE(szIconFile);
|
|
|
|
TIMESTART(pdsv->GetName);
|
|
if (SUCCEEDED(pdsv->pshf->lpVtbl->GetDisplayNameOf(pdsv->pshf,
|
|
pidl, SHGDN_INFOLDER, &di.str)))
|
|
{
|
|
if (di.str.uType == STRRET_OFFSET)
|
|
{
|
|
// If an offset, we just pass the name back
|
|
// but don't store it to save on space
|
|
|
|
// BUGBUG (DavePl) Note that this is someone's notify
|
|
// message, and we are placing a text pointer in it...
|
|
// a unicode text pointer out of a pidl, which is therefore
|
|
// not even aligned!
|
|
|
|
lpdi->item.pszText = (LPTSTR)(((LPBYTE)pidl) + di.str.uOffset);
|
|
item.mask &= ~LVIF_TEXT;
|
|
}
|
|
else
|
|
{
|
|
StrRetToStrN(item.pszText, item.cchTextMax,
|
|
&di.str, pidl);
|
|
lstrcpyn(lpdi->item.pszText, item.pszText, lpdi->item.cchTextMax);
|
|
}
|
|
}
|
|
TIMESTOP(pdsv->GetName);
|
|
}
|
|
else
|
|
{
|
|
if (pdsv->psd)
|
|
{
|
|
if (SUCCEEDED(pdsv->psd->lpVtbl->GetDetailsOf(pdsv->psd,
|
|
pidl, item.iSubItem, (LPSHELLDETAILS)&di.fmt)))
|
|
{
|
|
StrRetToStrN(lpdi->item.pszText, lpdi->item.cchTextMax,
|
|
&di.str, pidl);
|
|
}
|
|
}
|
|
else if (pdsv->pfnCallback)
|
|
{
|
|
di.pidl = pidl;
|
|
if (SUCCEEDED(pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_GETDETAILSOF,
|
|
item.iSubItem, (LPARAM)&di)))
|
|
{
|
|
StrRetToStrN(lpdi->item.pszText, lpdi->item.cchTextMax,
|
|
&di.str, pidl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We only store the name; all other info comes on demand
|
|
if (item.iSubItem == 0)
|
|
{
|
|
lpdi->item.mask |= LVIF_DI_SETITEM;
|
|
//ListView_SetItem(pdsv->hwndListview, &item);
|
|
}
|
|
break;
|
|
} // LVN_GETDISPINFO
|
|
}
|
|
#undef lpdi
|
|
return 0;
|
|
}
|
|
|
|
#define IN_VIEW_BMP 0x8000
|
|
#define IN_STD_BMP 0x0000
|
|
|
|
#ifdef CUST_TOOLBAR
|
|
|
|
#pragma data_seg(".text", "CODE")
|
|
|
|
struct {
|
|
USHORT idCmd;
|
|
USHORT idBmp;
|
|
} c_DVButtons[] = {
|
|
SFVIDM_EDIT_CUT, 0,
|
|
SFVIDM_EDIT_COPY, 1,
|
|
SFVIDM_EDIT_PASTE, 2,
|
|
SFVIDM_EDIT_UNDO, 3,
|
|
SFVIDM_FILE_LINK,
|
|
SFVIDM_FILE_DELETE, 5,
|
|
SFVIDM_FILE_RENAME, 6,
|
|
SFVIDM_FILE_PROPERTIES, 10,
|
|
//SFVIDM_SELECT_ALL
|
|
//SFVIDM_SELECT_INVERT
|
|
SFVIDM_VIEW_ICON, 0 | IN_VIEW_BMP,
|
|
SFVIDM_VIEW_SMALLICON, 1 | IN_VIEW_BMP,
|
|
SFVIDM_VIEW_LIST, 2 | IN_VIEW_BMP,
|
|
SFVIDM_VIEW_DETAILS, 3 | IN_VIEW_BMP,
|
|
SFVIDM_VIEW_OPTIONS, 10,
|
|
|
|
FSIDM_SORTBYNAME + SFVIDM_CLIENT_FIRST, 4 | IN_VIEW_BMP,
|
|
FSIDM_SORTBYSIZE + SFVIDM_CLIENT_FIRST, 5 | IN_VIEW_BMP,
|
|
FSIDM_SORTBYTYPE + SFVIDM_CLIENT_FIRST, 6 | IN_VIEW_BMP,
|
|
FSIDM_SORTBYDATE + SFVIDM_CLIENT_FIRST, 7 | IN_VIEW_BMP
|
|
// FEIDM_FINDFILES, 11, // this is 0!
|
|
|
|
//SFVIDM_ARRANGE_AUTO
|
|
//SFVIDM_ARRANGE_GRID
|
|
};
|
|
#pragma data_seg()
|
|
|
|
const USHORT c_CmdRemap[] = {
|
|
SFVIDM_EDIT_CUT,
|
|
SFVIDM_EDIT_COPY,
|
|
SFVIDM_EDIT_PASTE,
|
|
SFVIDM_EDIT_UNDO,
|
|
0, // redo
|
|
SFVIDM_FILE_DELETE,
|
|
0, // new doc
|
|
0, // file open
|
|
0, // file save
|
|
0, // print preview
|
|
SFVIDM_FILE_PROPERTIES,
|
|
// 0, // context help
|
|
// 0 // find
|
|
};
|
|
|
|
|
|
void ReMapTBCommands(LPDEFVIEW this)
|
|
{
|
|
int nItem;
|
|
TBBUTTON tb;
|
|
HWND hwndTB;
|
|
|
|
this->psb->lpVtbl->GetControlWindow(this->psb, FCW_TREE, &hwndTB);
|
|
|
|
for (nItem = 0; SendMessage(hwndTB, TB_GETBUTTON, nItem, (LPARAM)&tb); nItem++)
|
|
{
|
|
if (!(tb.fsStyle & TBSTYLE_SEP))
|
|
{
|
|
int iCmdOffset = tb.idCommand - this->iStdBMOffset;
|
|
|
|
if ((iCmdOffset >= 0) && (iCmdOffset < ARRAYSIZE(c_CmdRemap)) && c_CmdRemap[iCmdOffset])
|
|
SendMessage(hwndTB, TB_SETCMDID, nItem, c_CmdRemap[iCmdOffset]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // CUST_TOOLBAR
|
|
|
|
|
|
LRESULT DefView_OnNotify(LPDEFVIEW pdsv, NMHDR *pnm)
|
|
{
|
|
switch (pnm->idFrom) {
|
|
|
|
case FCIDM_TOOLBAR:
|
|
return DefView_TBNotify(pdsv, pnm);
|
|
|
|
case ID_LISTVIEW:
|
|
return DefView_OnLVNotify(pdsv, pnm);
|
|
|
|
default:
|
|
|
|
switch (pnm->code) {
|
|
|
|
case TTN_NEEDTEXT:
|
|
|
|
#define ptt ((LPTOOLTIPTEXT)pnm)
|
|
|
|
DV_GetToolTipText(pdsv, ptt->hdr.idFrom, ptt->szText, ARRAYSIZE(ptt->szText));
|
|
|
|
#undef ptt
|
|
|
|
break;
|
|
|
|
case NM_RCLICK:
|
|
if (GetParent(pnm->hwndFrom) == pdsv->hwndListview)
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int CALLBACK DefView_Compare(LPARAM p1, LPARAM p2, LPARAM lParam)
|
|
{
|
|
#define pdsv ((LPDEFVIEW)lParam)
|
|
HRESULT hres = pdsv->pshf->lpVtbl->CompareIDs(pdsv->pshf, pdsv->dvState.lParamSort, (LPITEMIDLIST)p1, (LPITEMIDLIST)p2);
|
|
|
|
Assert(SUCCEEDED(hres))
|
|
Assert(pdsv->dvState.iDirection != 0);
|
|
return (short)SCODE_CODE(GetScode(hres)) * pdsv->dvState.iDirection;
|
|
#undef pdsv
|
|
}
|
|
|
|
|
|
void DV_ReArrange(LPDEFVIEW pdsv)
|
|
{
|
|
TIMEVAR(DV_ReArrange);
|
|
TIMEIN(DV_ReArrange);
|
|
|
|
TIMESTART(DV_ReArrange);
|
|
ListView_SortItems(pdsv->hwndListview, DefView_Compare, (LPARAM)pdsv);
|
|
TIMESTOP(DV_ReArrange);
|
|
|
|
TIMEOUT(DV_ReArrange);
|
|
}
|
|
|
|
|
|
int CALLBACK DefView_DVITEM_Compare(LPVOID p1, LPVOID p2, LPARAM lParam)
|
|
{
|
|
PDVITEM pdvi1 = (PDVITEM)p1;
|
|
PDVITEM pdvi2 = (PDVITEM)p2;
|
|
LPITEMIDLIST pFakeEnd1, pFakeEnd2;
|
|
USHORT uSave1, uSave2;
|
|
int nCmp;
|
|
|
|
// BUGBUG: Note that all this would be unnecessary if
|
|
// IShellFolder::CompareIDs took a bRecurse flag
|
|
pFakeEnd1 = _ILNext(&pdvi1->idl);
|
|
uSave1 = pFakeEnd1->mkid.cb;
|
|
pFakeEnd1->mkid.cb = 0;
|
|
|
|
pFakeEnd2 = _ILNext(&pdvi2->idl);
|
|
uSave2 = pFakeEnd2->mkid.cb;
|
|
pFakeEnd2->mkid.cb = 0;
|
|
|
|
nCmp = DefView_Compare((LPARAM)&pdvi1->idl, (LPARAM)&pdvi2->idl, lParam);
|
|
|
|
pFakeEnd2->mkid.cb = uSave2;
|
|
pFakeEnd1->mkid.cb = uSave1;
|
|
|
|
return(nCmp);
|
|
}
|
|
|
|
|
|
//
|
|
// This returns TRUE if everything went OK, FALSE otherwise
|
|
// Side effect: the listview items are always arranged after this call
|
|
//
|
|
BOOL DefView_RestorePos(LPDEFVIEW pdsv, PDVSAVEHEADER pSaveHeader, UINT uLen)
|
|
{
|
|
PDVITEM pDVItem, pDVEnd;
|
|
HDPA dpaItems;
|
|
UNALIGNED DVITEM * UNALIGNED * ppDVItem, * UNALIGNED * ppEndDVItems;
|
|
BOOL bOK = FALSE;
|
|
int iCount, i;
|
|
DWORD dwStyle;
|
|
|
|
// Do the specified sorting for both the ListView and the DPA,
|
|
// so we can traverse them both in order (like the merge step of a
|
|
// merge sort), which should be pretty quick
|
|
DV_ReArrange(pdsv);
|
|
|
|
|
|
pDVItem = (PDVITEM)(((LPBYTE)pSaveHeader) + pSaveHeader->cbPosOffset);
|
|
|
|
// BUGBUG more runtime size checking, should be init in case you don't get
|
|
// here the day you happen to break its validity (DavePl)
|
|
|
|
Assert(SIZEOF(DVSAVEHEADER) >= SIZEOF(DVITEM));
|
|
pDVEnd = (PDVITEM)(((LPBYTE)pSaveHeader) + uLen - SIZEOF(DVITEM));
|
|
|
|
// Grow every 16 items
|
|
dpaItems = DPA_Create(16);
|
|
if (!dpaItems)
|
|
{
|
|
return bOK;
|
|
}
|
|
|
|
for ( ; ; pDVItem=(PDVITEM)_ILNext(&pDVItem->idl))
|
|
{
|
|
if (pDVItem > pDVEnd)
|
|
{
|
|
// Invalid list
|
|
break;
|
|
}
|
|
|
|
// End normally when we reach a NULL IDList
|
|
if (pDVItem->idl.mkid.cb == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (DPA_InsertPtr(dpaItems, INT_MAX, pDVItem) < 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!DPA_Sort(dpaItems, DefView_DVITEM_Compare, (LPARAM)pdsv))
|
|
{
|
|
goto Error1;
|
|
}
|
|
|
|
ppDVItem = (PDVITEM *)DPA_GetPtrPtr(dpaItems);
|
|
ppEndDVItems = ppDVItem + DPA_GetPtrCount(dpaItems);
|
|
|
|
// Turn off auto-arrange if it's on at the mo.
|
|
dwStyle = GetWindowStyle(pdsv->hwndListview);
|
|
if (dwStyle & LVS_AUTOARRANGE)
|
|
SetWindowLong(pdsv->hwndListview, GWL_STYLE, dwStyle & ~LVS_AUTOARRANGE);
|
|
|
|
iCount = ListView_GetItemCount(pdsv->hwndListview);
|
|
for (i=0; i<iCount; ++i)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
|
|
pidl = DSV_GetPIDL(pdsv, i);
|
|
|
|
// need to check for pidl because this could be on a background
|
|
// thread and an fsnotify could be coming through to blow it away
|
|
for ( ; pidl ; )
|
|
{
|
|
int nCmp;
|
|
LPITEMIDLIST pFakeEnd;
|
|
USHORT uSave;
|
|
|
|
if (ppDVItem < ppEndDVItems)
|
|
{
|
|
// We terminate the IDList manually after saving
|
|
// the needed information. Note we will not GP fault
|
|
// since we added sizeof(ITEMIDLIST) onto the Alloc
|
|
pFakeEnd = _ILNext(&(*ppDVItem)->idl);
|
|
uSave = pFakeEnd->mkid.cb;
|
|
pFakeEnd->mkid.cb = 0;
|
|
|
|
nCmp = DefView_Compare((LPARAM)&((*ppDVItem)->idl), (LPARAM)pidl, (LPARAM)pdsv);
|
|
|
|
pFakeEnd->mkid.cb = uSave;
|
|
} else {
|
|
|
|
// do this by default. this prevents overlap of icons
|
|
//
|
|
// i.e. if we've run out of saved positions information,
|
|
// we need to just loop through and set all remaining items
|
|
// to position 0x7FFFFFFFF so that when it's really shown,
|
|
// the listview will pick a new (unoccupied) spot.
|
|
// breaking out now would leave it were the DV_ReArrange
|
|
// put it, but another item with saved state info could
|
|
// have come and be placed on top of it.
|
|
nCmp = 1;
|
|
}
|
|
|
|
|
|
if (nCmp > 0)
|
|
{
|
|
// We did not find the item
|
|
// reset it's position to be recomputed
|
|
ListView_SetItemPosition32(pdsv->hwndListview, i,
|
|
0x7FFFFFFF, 0x7FFFFFFF);
|
|
break;
|
|
}
|
|
else if (nCmp == 0)
|
|
{
|
|
UNALIGNED DVITEM * pDVItem = *ppDVItem;
|
|
|
|
// They are equal
|
|
ListView_SetItemPosition32(pdsv->hwndListview,
|
|
i, pDVItem->pt.x, pDVItem->pt.y);
|
|
// Don't check this one again
|
|
++ppDVItem;
|
|
break;
|
|
}
|
|
|
|
// It's less than the current item, so try the next one
|
|
++ppDVItem;
|
|
}
|
|
}
|
|
|
|
// Turn auto-arrange back on if needed...
|
|
if (dwStyle & LVS_AUTOARRANGE)
|
|
SetWindowLong(pdsv->hwndListview, GWL_STYLE, dwStyle);
|
|
|
|
bOK = TRUE;
|
|
|
|
if (DPA_GetPtrCount(dpaItems) > 0)
|
|
{
|
|
// If we read in any icon positions, we should save them later
|
|
// unless the user does something to cause us to go back to
|
|
// the default state
|
|
pdsv->bItemsMoved = TRUE;
|
|
}
|
|
|
|
Error1:;
|
|
DPA_Destroy(dpaItems);
|
|
return(bOK);
|
|
}
|
|
|
|
|
|
//
|
|
// Save (and check) column header information
|
|
// Returns TRUE if the columns are the default width, FALSE otherwise
|
|
// Side effect: the stream pointer is left right after the last column
|
|
//
|
|
BOOL DefView_SaveCols(LPDEFVIEW this, LPSTREAM pstm)
|
|
{
|
|
BOOL bDefaultCols = TRUE;
|
|
LV_COLUMN col;
|
|
DETAILSINFO di;
|
|
int i;
|
|
LPSTREAM pstmCols;
|
|
|
|
if (!this->psd && !this->pfnCallback)
|
|
return TRUE;
|
|
|
|
di.pidl = NULL;
|
|
|
|
if (this->pfnCallback && SUCCEEDED(this->pfnCallback(this->psvOuter,
|
|
this->pshf, this->hwndMain, DVM_GETCOLSAVESTREAM, STGM_WRITE,
|
|
(LPARAM)&pstmCols)))
|
|
{
|
|
pstm = pstmCols;
|
|
}
|
|
else
|
|
{
|
|
pstmCols = NULL;
|
|
}
|
|
|
|
for (i = 0; ; ++i)
|
|
{
|
|
di.fmt = LVCFMT_LEFT;
|
|
di.cxChar = 20;
|
|
di.str.uType = (UINT)-1;
|
|
|
|
if (this->psd)
|
|
{
|
|
if(FAILED(this->psd->lpVtbl->GetDetailsOf(this->psd, NULL, i, (LPSHELLDETAILS)&di.fmt)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if (this->pfnCallback)
|
|
{
|
|
if (FAILED(this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_GETDETAILSOF, i, (LPARAM)&di)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
col.mask = LVCF_WIDTH;
|
|
if (!ListView_GetColumn(this->hwndListview, i, &col))
|
|
{
|
|
// There is some problem, so just assume
|
|
// default column widths
|
|
bDefaultCols = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (col.cx != (int)(di.cxChar * this->cxChar))
|
|
{
|
|
bDefaultCols = FALSE;
|
|
}
|
|
|
|
// HACK: I don't really care about column widths larger
|
|
// than 64K
|
|
if (FAILED(pstm->lpVtbl->Write(pstm, &col.cx, SIZEOF(USHORT), NULL)))
|
|
{
|
|
// There is some problem, so just assume
|
|
// default column widths
|
|
bDefaultCols = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pstmCols)
|
|
{
|
|
pstmCols->lpVtbl->Release(pstmCols);
|
|
|
|
// Always pretend we got default columns
|
|
return(TRUE);
|
|
}
|
|
|
|
return bDefaultCols;
|
|
}
|
|
|
|
|
|
//
|
|
// Save (and check) icon position information
|
|
// Returns TRUE if the positions are the default, FALSE otherwise
|
|
// Side effect: the stream pointer is left right after the last icon
|
|
//
|
|
BOOL DefView_SavePos(LPDEFVIEW this, LPSTREAM pstm)
|
|
{
|
|
int iCount, i;
|
|
DVITEM dvitem;
|
|
LPITEMIDLIST pidl;
|
|
BOOL bDefault = TRUE;
|
|
HRESULT hres;
|
|
|
|
if (!this->bItemsMoved || this->fs.ViewMode == FVM_DETAILS || this->fs.ViewMode == FVM_LIST)
|
|
return bDefault;
|
|
|
|
iCount = ListView_GetItemCount(this->hwndListview);
|
|
|
|
for (i = 0; ; i++)
|
|
{
|
|
if (i >= iCount)
|
|
{
|
|
bDefault = FALSE;
|
|
break;
|
|
}
|
|
|
|
ListView_GetItemPosition(this->hwndListview, i, &dvitem.pt);
|
|
pidl = DSV_GetPIDL(this, i);
|
|
|
|
hres = pstm->lpVtbl->Write(pstm, &dvitem.pt, SIZEOF(dvitem.pt), NULL);
|
|
if (FAILED(hres))
|
|
{
|
|
break;
|
|
}
|
|
hres = pstm->lpVtbl->Write(pstm, pidl, pidl->mkid.cb, NULL);
|
|
if (FAILED(hres))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Terminate the list with a NULL IDList
|
|
dvitem.idl.mkid.cb = 0;
|
|
hres = pstm->lpVtbl->Write(pstm, &dvitem, SIZEOF(dvitem), NULL);
|
|
if (FAILED(hres))
|
|
{
|
|
bDefault = TRUE;
|
|
}
|
|
|
|
return(bDefault);
|
|
}
|
|
|
|
// this should NOT check for whether the item is already in the listview
|
|
// if it does, we'll have some serious performance problems
|
|
int DefView_AddObject(LPDEFVIEW pdsv, LPITEMIDLIST pidl)
|
|
{
|
|
int i;
|
|
LV_ITEM item;
|
|
|
|
TIMESTART(pdsv->AddObject);
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
//
|
|
// We can't support adding a pidl in this fashion if we are in ownerdata
|
|
// mode. BUGBUG Maybe this just needs to invalidate the cache?
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
TIMESTOP(pdsv->AddObject);
|
|
return(-1);
|
|
}
|
|
|
|
// Check the commdlg hook to see if we should include this
|
|
// object.
|
|
if (DV_CDB_IncludeObject(pdsv, pidl) != S_OK)
|
|
{
|
|
TIMESTOP(pdsv->AddObject);
|
|
return(-1);
|
|
}
|
|
|
|
// Check with callback first to sanction the add
|
|
if (pdsv->pfnCallback) {
|
|
DVSELCHANGEINFO dvsci;
|
|
|
|
dvsci.lParamItem = (LPARAM)pidl;
|
|
dvsci.plParam = (LPARAM*)&pdsv->lSelChangeInfo;
|
|
if (S_FALSE == pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_INSERTITEM,
|
|
(WPARAM)pidl, (LPARAM)&dvsci))
|
|
{
|
|
// Don't add this object
|
|
TIMESTOP(pdsv->AddObject);
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
|
|
item.iItem = INT_MAX; // add at end
|
|
item.iSubItem = 0;
|
|
|
|
item.iImage = I_IMAGECALLBACK;
|
|
item.pszText = LPSTR_TEXTCALLBACK;
|
|
item.lParam = (LPARAM)pidl;
|
|
|
|
i = ListView_InsertItem(pdsv->hwndListview, &item);
|
|
|
|
TIMESTOP(pdsv->AddObject);
|
|
return i;
|
|
}
|
|
|
|
|
|
int DefView_FindItem(LPDEFVIEW pdsv, LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlFound, BOOL fSamePtr)
|
|
{
|
|
LV_ITEM item;
|
|
int cItems;
|
|
int cCounter;
|
|
|
|
item.mask = LVIF_PARAM;
|
|
item.iSubItem = 0;
|
|
|
|
cItems = ListView_GetItemCount(pdsv->hwndListview);
|
|
|
|
if (pdsv->iLastFind >= cItems)
|
|
pdsv->iLastFind = 0;
|
|
|
|
for (cCounter = 0, item.iItem = pdsv->iLastFind; cCounter < cItems; item.iItem = (item.iItem + 1) % cItems, cCounter++) {
|
|
HRESULT hres = ResultFromShort(-1);
|
|
ListView_GetItem(pdsv->hwndListview, &item);
|
|
|
|
// BUGBUG: this passes 0 for the lParam
|
|
if (item.lParam == (LPARAM)pidl) {
|
|
hres = ResultFromShort(0);
|
|
} else if (!fSamePtr) {
|
|
// if we don't insist on being the same pointer, do the ole style compare
|
|
//BUGBUGLPARAM hres = pdsv->pshf->lpVtbl->CompareIDs(pdsv->pshf, 0, pidl, (LPITEMIDLIST)item.lParam);
|
|
}
|
|
|
|
Assert(SUCCEEDED(hres));
|
|
if (FAILED(hres))
|
|
return -1;
|
|
|
|
if (ShortFromResult(hres) == 0)
|
|
{
|
|
if (ppidlFound)
|
|
*ppidlFound = (LPITEMIDLIST)item.lParam;
|
|
pdsv->iLastFind = item.iItem;
|
|
#ifdef FINDCACHE_DEBUG
|
|
DebugMsg(DM_TRACE, TEXT("###############FIND CACHE RESULT --- %s by %d"), cCounter < item.iItem ? TEXT("WIN") : TEXT("LOSE"), item.iItem - cCounter);
|
|
#endif
|
|
return item.iItem;
|
|
}
|
|
}
|
|
|
|
pdsv->iLastFind = 0;
|
|
return -1; // not found
|
|
}
|
|
|
|
|
|
//
|
|
// Function to process the SFVM_REMOVEOBJECT message, by searching
|
|
// through the list for a match of the pidl. If a match is found, the
|
|
// item is removed from the list and the index number is returned, else
|
|
// -1 is returned.
|
|
|
|
int DefView_RemoveObject(LPDEFVIEW pdsv, LPITEMIDLIST pidl, BOOL fSamePtr)
|
|
{
|
|
int i;
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
//
|
|
// We can't support adding a pidl in this fashion if we are in ownerdata
|
|
// mode. BUGBUG Maybe this just needs to invalidate the cache?
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
// Docfind will pass in a null pointer to tell us that it wants
|
|
// to refresh the window by deleting all of the items from it.
|
|
if (pidl == NULL)
|
|
{
|
|
// notify the iSHellFolder
|
|
if (pdsv->pfnCallback) {
|
|
DVSELCHANGEINFO dvsci;
|
|
dvsci.lParamItem = 0;
|
|
dvsci.plParam = (LPARAM*)&pdsv->lSelChangeInfo;
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain, DVM_DELETEITEM, 0, (LPARAM)&dvsci);
|
|
}
|
|
ListView_DeleteAllItems(pdsv->hwndListview);
|
|
return(0);
|
|
}
|
|
|
|
// Non null go look for item.
|
|
i = DefView_FindItem(pdsv, pidl, NULL, fSamePtr);
|
|
|
|
if (i >= 0)
|
|
{
|
|
UINT uState = ListView_GetItemState(pdsv->hwndListview, i, LVIS_ALL);
|
|
RECT rc;
|
|
if (uState & LVIS_FOCUSED) {
|
|
ListView_GetItemRect(pdsv->hwndListview, i, &rc, LVIR_ICON);
|
|
}
|
|
|
|
// let IShellFolder know we're deleting something.
|
|
if (pdsv->pfnCallback) {
|
|
LPITEMIDLIST pidlReal = DSV_GetPIDL(pdsv, i);
|
|
if (pidlReal) {
|
|
DVSELCHANGEINFO dvsci;
|
|
dvsci.lParamItem = (LPARAM)pidlReal;
|
|
dvsci.plParam = (LPARAM*)&pdsv->lSelChangeInfo;
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain, DVM_DELETEITEM, 0, (LPARAM)&dvsci);
|
|
}
|
|
}
|
|
|
|
// do the actual delete
|
|
ListView_DeleteItem(pdsv->hwndListview, i);
|
|
|
|
// we deleted the focused item.. replace the focus to the nearest item.
|
|
if (uState & LVIS_FOCUSED) {
|
|
int iFocus = i;
|
|
if ((pdsv->fs.ViewMode == FVM_SMALLICON) ||
|
|
(pdsv->fs.ViewMode == FVM_ICON)) {
|
|
LV_FINDINFO lvfi;
|
|
|
|
lvfi.flags = LVFI_NEARESTXY;
|
|
lvfi.pt.x = rc.left;
|
|
lvfi.pt.y = rc.top;
|
|
lvfi.vkDirection = 0;
|
|
iFocus = ListView_FindItem(pdsv->hwndListview, -1, &lvfi);
|
|
|
|
} else {
|
|
if (ListView_GetItemCount(pdsv->hwndListview) >= iFocus)
|
|
iFocus--;
|
|
|
|
}
|
|
|
|
if (iFocus != -1) {
|
|
ListView_SetItemState(pdsv->hwndListview, iFocus, LVIS_FOCUSED, LVIS_FOCUSED);
|
|
ListView_EnsureVisible(pdsv->hwndListview, iFocus, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return(i);
|
|
}
|
|
|
|
//
|
|
// Function to process the SFVM_UPDATEOBJECT message, by searching
|
|
// through the list for a match of the first pidl. If a match is found,
|
|
// the item is updated to the second pidl...
|
|
|
|
int DefView_UpdateObject(LPDEFVIEW pdsv, LPITEMIDLIST *ppidl)
|
|
{
|
|
LPITEMIDLIST pidlOld;
|
|
int i;
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
//
|
|
// We can't support adding a pidl in this fashion if we are in ownerdata
|
|
// mode. BUGBUG Maybe this just needs to invalidate the cache?
|
|
//
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
i = DefView_FindItem(pdsv, ppidl[0], &pidlOld, FALSE);
|
|
|
|
if (i >= 0)
|
|
{
|
|
LV_ITEM item;
|
|
|
|
//
|
|
// We found the item so lets now update it in the
|
|
// the view.
|
|
//
|
|
|
|
item.mask = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
|
|
item.iItem = i;
|
|
item.lParam = (LPARAM)ppidl[1]; // update the second item.
|
|
item.pszText = LPSTR_TEXTCALLBACK;
|
|
item.iImage = I_IMAGECALLBACK;
|
|
item.iSubItem = 0; // REVIEW: bug in listview?
|
|
|
|
ListView_SetItem(pdsv->hwndListview, &item);
|
|
|
|
// Free the old pidl after we've added the new one
|
|
ILFree(pidlOld);
|
|
}
|
|
|
|
return(i);
|
|
}
|
|
|
|
//
|
|
// invalidates all items with the given image index.
|
|
//
|
|
// or update all items if iImage == -1
|
|
//
|
|
void DefView_UpdateImage(LPDEFVIEW pdsv, int iImage)
|
|
{
|
|
LV_ITEM item;
|
|
int cItems;
|
|
|
|
DebugMsg(DM_TRACE, TEXT("DefView_UpdateImage: %d"), iImage);
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
// Can't do this in owner data.
|
|
// BUGBUG invalidate the cache?
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// -1 means update all
|
|
// reset the imagelists incase the size has changed, and do
|
|
// a full update.
|
|
//
|
|
if (iImage == -1)
|
|
{
|
|
HIMAGELIST himlLarge, himlSmall;
|
|
|
|
Shell_GetImageLists(&himlLarge, &himlSmall);
|
|
ListView_SetImageList(pdsv->hwndListview, himlLarge, LVSIL_NORMAL);
|
|
ListView_SetImageList(pdsv->hwndListview, himlSmall, LVSIL_SMALL);
|
|
pdsv->sv.lpVtbl->Refresh(&pdsv->sv);
|
|
return;
|
|
}
|
|
|
|
item.iSubItem = 0;
|
|
|
|
cItems = ListView_GetItemCount(pdsv->hwndListview);
|
|
|
|
for (item.iItem = 0; item.iItem < cItems; item.iItem++)
|
|
{
|
|
item.mask = LVIF_IMAGE|LVIF_PARAM;
|
|
ListView_GetItem(pdsv->hwndListview, &item);
|
|
|
|
if (item.iImage == iImage)
|
|
{
|
|
Icon_FSEvent(SHCNE_UPDATEITEM, (LPCITEMIDLIST)item.lParam, NULL);
|
|
|
|
item.mask = LVIF_IMAGE;
|
|
item.iImage = I_IMAGECALLBACK;
|
|
item.iSubItem = 0;
|
|
|
|
ListView_SetItem(pdsv->hwndListview, &item);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function to process the SFVM_REFRESHOBJECT message, by searching
|
|
// through the list for a match of the first pidl. If a match is found,
|
|
// the item is redrawn.
|
|
|
|
int DefView_RefreshObject(LPDEFVIEW pdsv, LPITEMIDLIST *ppidl)
|
|
{
|
|
int i;
|
|
|
|
// BUGBUG: should support refreshing a range of pidls
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
// Can't do this in ownerdata mode
|
|
// BUGBUG invalidate cache?
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
i = DefView_FindItem(pdsv, ppidl[0], NULL, FALSE);
|
|
|
|
if (i >= 0)
|
|
{
|
|
ListView_RedrawItems(pdsv->hwndListview, i, i);
|
|
}
|
|
|
|
return(i);
|
|
}
|
|
|
|
|
|
//
|
|
// Function to process the SFVM_GETSELECTEDOBJECTS message
|
|
//
|
|
|
|
HRESULT DefView_GetItemObjects(LPDEFVIEW pdsv, LPCITEMIDLIST **ppidl,
|
|
UINT uItem)
|
|
{
|
|
UINT cItems = DefView_GetItemPIDLS(pdsv, NULL, 0, uItem);
|
|
LPITEMIDLIST * apidl;
|
|
|
|
if (ppidl != NULL)
|
|
{
|
|
*ppidl = NULL;
|
|
|
|
if (cItems == 0)
|
|
return(ResultFromShort(0)); // nothing allocated...
|
|
|
|
apidl=LocalAlloc(LPTR, SIZEOF(LPITEMIDLIST) * cItems);
|
|
if (!apidl)
|
|
return(E_OUTOFMEMORY);
|
|
|
|
*ppidl = apidl;
|
|
cItems = DefView_GetItemPIDLS(pdsv, apidl, cItems, uItem);
|
|
}
|
|
return(ResultFromShort(cItems));
|
|
}
|
|
|
|
|
|
void DefView_SetItemPos(LPDEFVIEW pdsv, LPSFV_SETITEMPOS psip)
|
|
{
|
|
int i;
|
|
|
|
ASSERT(FALSE == DV_ISOWNERDATA(pdsv));
|
|
|
|
// Can't do this in ownerdata mode
|
|
// BUGBUG invalidate cache?
|
|
|
|
if (DV_ISOWNERDATA(pdsv))
|
|
{
|
|
return;
|
|
}
|
|
|
|
i = DefView_FindItem(pdsv, psip->pidl, NULL, FALSE);
|
|
if (i >= 0)
|
|
{
|
|
ListView_SetItemPosition32(pdsv->hwndListview, i, psip->pt.x, psip->pt.y);
|
|
|
|
pdsv->bItemsMoved = TRUE;
|
|
pdsv->bClearItemPos = FALSE;
|
|
}
|
|
}
|
|
|
|
#define DV_IDTIMER 1
|
|
#define ENUMTIMEOUT 3000 // 3 seconds
|
|
#define SHORTENUMTIMEOUT 500 // 1/2 second
|
|
|
|
|
|
HRESULT DV_AllocRestOfStream(LPSTREAM pstm, LPVOID *ppData, UINT *puLen)
|
|
{
|
|
UINT uLen;
|
|
ULARGE_INTEGER libCurPos;
|
|
ULARGE_INTEGER libEndPos;
|
|
LARGE_INTEGER dlibMove = {0, 0};
|
|
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_CUR, &libCurPos);
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_END, &libEndPos);
|
|
|
|
uLen = libEndPos.LowPart - libCurPos.LowPart;
|
|
// Note that we add room for an extra ITEMIDLIST so we don't GP fault
|
|
// when we manually terminate the last ID list
|
|
if (uLen == 0)
|
|
{
|
|
return(E_UNEXPECTED);
|
|
}
|
|
|
|
// Allow the caller to have some extra room
|
|
*puLen += uLen;
|
|
if ((*ppData = (void*)LocalAlloc(LPTR, *puLen)) == NULL)
|
|
{
|
|
return(E_OUTOFMEMORY);
|
|
}
|
|
|
|
pstm->lpVtbl->Seek(pstm, *(LARGE_INTEGER *)&libCurPos, STREAM_SEEK_SET, NULL);
|
|
// This really should not fail
|
|
pstm->lpVtbl->Read(pstm, *ppData, uLen, NULL);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
UINT DefView_GetSaveHeader(LPDEFVIEW pdsv, PDVSAVEHEADER *ppSaveHeader)
|
|
{
|
|
LPSTREAM pstm;
|
|
UINT uLen = SIZEOF(ITEMIDLIST);
|
|
|
|
*ppSaveHeader = NULL;
|
|
|
|
if (FAILED(pdsv->psb->lpVtbl->GetViewStateStream(pdsv->psb, STGM_READ, &pstm)))
|
|
return 0;
|
|
|
|
if (FAILED(DV_AllocRestOfStream(pstm, ppSaveHeader, &uLen)))
|
|
{
|
|
goto Error1;
|
|
}
|
|
|
|
if (uLen<SIZEOF(DVSAVEHEADER)+SIZEOF(ITEMIDLIST)
|
|
|| (*ppSaveHeader)->cbSize != SIZEOF(DVSAVEHEADER))
|
|
{
|
|
LocalFree((HLOCAL)*ppSaveHeader);
|
|
*ppSaveHeader = NULL;
|
|
goto Error1;
|
|
}
|
|
|
|
goto CleanUp;
|
|
|
|
Error1:
|
|
uLen = 0;
|
|
|
|
CleanUp:
|
|
pstm->lpVtbl->Release(pstm);
|
|
|
|
return uLen;
|
|
}
|
|
|
|
|
|
// restore the window state
|
|
//
|
|
// icon positions
|
|
// window scroll position
|
|
//
|
|
|
|
void DefView_RestoreState(LPDEFVIEW pdsv, PDVSAVEHEADER pInSaveHeader, UINT uLen)
|
|
{
|
|
PDVSAVEHEADER pSaveHeader;
|
|
|
|
if (pInSaveHeader)
|
|
{
|
|
pSaveHeader = pInSaveHeader;
|
|
}
|
|
else
|
|
{
|
|
uLen = DefView_GetSaveHeader(pdsv, &pSaveHeader);
|
|
if (uLen == 0)
|
|
{
|
|
DV_ReArrange(pdsv);
|
|
return;
|
|
}
|
|
}
|
|
|
|
pdsv->dvState = pSaveHeader->dvState;
|
|
|
|
// Columns get restored during window creation
|
|
|
|
// make sure the view modes of the saved state match what we have now
|
|
|
|
if (pSaveHeader->ViewMode == pdsv->fs.ViewMode)
|
|
{
|
|
// If we restored all the icon positions restore the scroll position too
|
|
if (DefView_RestorePos(pdsv, pSaveHeader, uLen))
|
|
ListView_Scroll(pdsv->hwndListview, pSaveHeader->ptScroll.x, pSaveHeader->ptScroll.y);
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("restore state view modes don't match"));
|
|
}
|
|
|
|
if (!pInSaveHeader)
|
|
LocalFree((HLOCAL)pSaveHeader);
|
|
}
|
|
|
|
//
|
|
// This function can be called only when we are filling listview items
|
|
// (from within DefView_FillObjects. It is very important to pass consistent
|
|
// dwFlags to GetDisplayNameOf and SetNameOf.
|
|
//
|
|
void DefView_UpdateGlobalFlags(LPDEFVIEW pdsv)
|
|
{
|
|
SHELLSTATE ss;
|
|
SHGetSetSettings(&ss, SSF_SHOWALLOBJECTS, FALSE);
|
|
pdsv->fShowAllObjects = ss.fShowAllObjects;
|
|
}
|
|
|
|
void DSV_FilterDPAs(LPDEFVIEW pdsv, HDPA hdpa, HDPA hdpaOld)
|
|
{
|
|
int i, j;
|
|
LPITEMIDLIST pidl, pidlOld;
|
|
|
|
#ifdef DPA_FILTER_TEST
|
|
for (i = 0; i < DPA_GetPtrCount(hdpaOld); i++) {
|
|
pidl = DPA_FastGetPtr(hdpaOld, i);
|
|
DebugMsg(DM_TRACE, TEXT("pidl = %x, %x, %x"), pidl, *(DWORD*)pidl, i);
|
|
}
|
|
#endif
|
|
|
|
// do the compares
|
|
for (;;) {
|
|
int iCompare;
|
|
i = DPA_GetPtrCount(hdpaOld);
|
|
j = DPA_GetPtrCount(hdpa);
|
|
|
|
if (!i && !j)
|
|
break;
|
|
|
|
if (!i) {
|
|
// only new ones left. Insert all of them.
|
|
iCompare = -1;
|
|
pidl = DPA_FastGetPtr(hdpa, 0);
|
|
|
|
} else if (!j) {
|
|
|
|
// only old ones left. remove them all.
|
|
iCompare = 1;
|
|
pidlOld = DPA_FastGetPtr(hdpaOld, 0);
|
|
|
|
} else {
|
|
pidlOld = DPA_FastGetPtr(hdpaOld, 0);
|
|
pidl = DPA_FastGetPtr(hdpa, 0);
|
|
iCompare = DefView_Compare((LPARAM)pidl, (LPARAM)pidlOld, (LPARAM)pdsv);
|
|
}
|
|
|
|
if (iCompare == 0) {
|
|
// they're the same ,remove one of each.
|
|
DPA_DeletePtr(hdpa, 0);
|
|
DPA_DeletePtr(hdpaOld, 0);
|
|
ILFree(pidl);
|
|
} else if (iCompare < 0) {
|
|
// the new item!
|
|
if (DefView_AddObject(pdsv, pidl) == -1)
|
|
ILFree(pidl);
|
|
DPA_DeletePtr(hdpa, 0);
|
|
} else {
|
|
#ifdef DPA_FILTER_TEST
|
|
// old item, delete it.
|
|
DebugMsg(DM_TRACE, TEXT("remove pidl = %x, %x"), pidlOld, *(DWORD*)pidlOld);
|
|
#endif
|
|
DefView_RemoveObject(pdsv, pidlOld, TRUE);
|
|
DPA_DeletePtr(hdpaOld, 0);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// this is only called from within SHCNE_* don't put up ui on the enum error.
|
|
void DefView_Update(LPDEFVIEW pdsv)
|
|
{
|
|
if (pdsv->bBkFilling)
|
|
{
|
|
pdsv->bUpdatePending = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DefView_FillObjectsShowHide(pdsv, FALSE, NULL, 0, FALSE);
|
|
}
|
|
}
|
|
|
|
#define HM_OK 0
|
|
#define HM_ABORT 1
|
|
#define HM_DESTROY 2
|
|
|
|
#ifdef DEADCODE
|
|
UINT HandleMessages(HWND hwnd, HWND hwndMain)
|
|
{
|
|
MSG msg;
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
|
|
// intercept these messages
|
|
if ((msg.message == WM_SYSKEYDOWN || msg.message == WM_KEYDOWN) && msg.wParam == VK_ESCAPE)
|
|
return HM_ABORT;
|
|
|
|
if (((msg.hwnd == hwnd) || (msg.hwnd == hwndMain)) &&
|
|
( ((msg.message == WM_SYSCOMMAND) && (msg.wParam == SC_CLOSE)) ||
|
|
(msg.message == WM_DESTROY) || (msg.message == WM_CLOSE) ||
|
|
(msg.message == WM_QUIT)))
|
|
{
|
|
PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam);
|
|
DebugMsg(DM_TRACE, TEXT("Got WM_SYSCOMMAND SC_CLOSE!"));
|
|
return HM_DESTROY;
|
|
}
|
|
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
|
|
}
|
|
return HM_OK;
|
|
}
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Alter the size of the parent to best fit around the items we have.
|
|
void ViewWindow_BestFit(LPDEFVIEW pdsv, BOOL bTimeout)
|
|
{
|
|
const int cxMin = MINVIEWWIDTH, cyMin = MINVIEWHEIGHT;
|
|
const int cxSpacing = GetSystemMetrics(SM_CXICONSPACING);
|
|
const int cySpacing = GetSystemMetrics(SM_CYICONSPACING);
|
|
|
|
DWORD dwStyle = GetWindowStyle(pdsv->hwndListview);
|
|
RECT rc;
|
|
WINDOWPLACEMENT wp;
|
|
int cItems, cxScreen, cyScreen;
|
|
|
|
int cxMax, cyMax;
|
|
RECT rcWork;
|
|
int cxWorkArea;
|
|
int cyWorkArea;
|
|
|
|
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWork, 0);
|
|
cxWorkArea = (rcWork.right - rcWork.left);
|
|
cyWorkArea = (rcWork.bottom - rcWork.top);
|
|
cxMax = (cxWorkArea * 3) / 5;
|
|
cyMax = (cyWorkArea * 3) / 5;
|
|
|
|
if (!(pdsv->fs.fFlags & FWF_BESTFITWINDOW))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Don't try to do it again.
|
|
pdsv->fs.fFlags &= ~FWF_BESTFITWINDOW;
|
|
|
|
// Find the largest square.
|
|
// 4000 should be close enough to infinite
|
|
if (bTimeout)
|
|
{
|
|
cItems = 4000;
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
// Give Control Panel a chance to tell us it will
|
|
// probably only have a few items, even though it timed
|
|
// out.
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_DEFITEMCOUNT,
|
|
0, (LPARAM)&cItems);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cItems = ListView_GetItemCount(pdsv->hwndListview);
|
|
}
|
|
|
|
rc.left = rc.top = rc.right = rc.bottom = 0;
|
|
if (cItems)
|
|
{
|
|
int cy, i1, i2, i3;
|
|
|
|
i1 = 1;
|
|
i2 = 0;
|
|
i3 = cItems;
|
|
while (i3 > 0)
|
|
{
|
|
i3 -= i1;
|
|
i1 += 2;
|
|
i2++;
|
|
}
|
|
|
|
// Convert this into an equivalent rect for the effective
|
|
// client area.
|
|
// The width.
|
|
rc.right = (i2 * cxSpacing);
|
|
if (rc.right > cxMax)
|
|
{
|
|
rc.right = cxMax;
|
|
// Now recalculate the number of rows
|
|
i2 = rc.right / cxSpacing;
|
|
}
|
|
|
|
// The height.
|
|
cy = (cItems + i2 - 1) / i2;
|
|
rc.bottom = (cy * cySpacing);
|
|
}
|
|
|
|
// Make sure we are in the "default" view
|
|
if ((dwStyle&LVS_TYPEMASK) == LVS_ICON)
|
|
{
|
|
// If it's going to be too big then flip into listview.
|
|
pdsv->fs.ViewMode = (rc.bottom > (cyMax * 3))
|
|
? FVM_LIST : FVM_ICON;
|
|
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
// Give Briefcase a chance to tell us it likes details
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf,
|
|
pdsv->hwndMain, DVM_DEFVIEWMODE,
|
|
0, (LPARAM)&pdsv->fs.ViewMode);
|
|
}
|
|
|
|
|
|
dwStyle = (LVStyleFromView(pdsv) & LVS_TYPEMASK) | (dwStyle & ~LVS_TYPEMASK);
|
|
SetWindowLong(pdsv->hwndListview, GWL_STYLE, dwStyle);
|
|
|
|
if (pdsv->fs.ViewMode == FVM_DETAILS)
|
|
{
|
|
// Need to special-case details because it could be any width
|
|
// I need to add an item in case there were none to start with
|
|
|
|
LV_ITEM item;
|
|
int i;
|
|
|
|
item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
|
|
item.iItem = INT_MAX; // add at end
|
|
item.iSubItem = 0;
|
|
|
|
item.iImage = 0;
|
|
item.pszText = (LPTSTR)c_szNULL;
|
|
item.lParam = 0;
|
|
|
|
i = ListView_InsertItem(pdsv->hwndListview, &item);
|
|
|
|
if (i >= 0)
|
|
{
|
|
ListView_GetItemRect(pdsv->hwndListview, i, &rc, LVIR_BOUNDS);
|
|
ListView_DeleteItem(pdsv->hwndListview, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure things aren't too small, or too big
|
|
rc.left = rc.top = 0;
|
|
rc.right = max(min(rc.right, cxMax), cxMin);
|
|
rc.bottom = max(min(rc.bottom, cyMax), cyMin);
|
|
|
|
// Allow room for the parent, toolbars etc.
|
|
// Also allow room for some text.
|
|
InflateRect(&rc, PARENTGAPWIDTH, PARENTGAPHEIGHT + (cySpacing / 2));
|
|
|
|
// Make sure it will still fit on the screen.
|
|
wp.length = SIZEOF(wp);
|
|
GetWindowPlacement(pdsv->hwndMain, &wp);
|
|
|
|
// Make sure the window fits in the work area.
|
|
cxScreen = cxWorkArea - GetSystemMetrics(SM_CXFRAME);
|
|
cyScreen = cyWorkArea - GetSystemMetrics(SM_CYFRAME);
|
|
if (wp.rcNormalPosition.left + rc.right > cxScreen)
|
|
rc.right = cxScreen - wp.rcNormalPosition.left;
|
|
if (wp.rcNormalPosition.top + rc.bottom > cyScreen)
|
|
rc.bottom = cyScreen - wp.rcNormalPosition.top;
|
|
|
|
// Resize the parent.
|
|
SetWindowPos(pdsv->hwndMain, NULL, 0, 0, rc.right, rc.bottom, SWP_NOMOVE | SWP_NOZORDER);
|
|
|
|
// If we're still in icon mode but AutoArrange is off -
|
|
// things will look weird so fix it now.
|
|
if ((pdsv->fs.ViewMode==FVM_ICON || pdsv->fs.ViewMode==FVM_SMALLICON)
|
|
&& !(dwStyle & LVS_AUTOARRANGE))
|
|
{
|
|
// Cause everything to fit again.
|
|
DebugMsg(DM_TRACE, TEXT("vw_bf: Re-arrange."));
|
|
ListView_Arrange(pdsv->hwndListview, LVA_DEFAULT);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL EnumerationTimeout(LPDEFVIEW pdsv, BOOL bRefresh)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("s.et: Enumeration is taking too long."));
|
|
|
|
// The static window could already exist during a refresh
|
|
if (!pdsv->hwndStatic && bRefresh)
|
|
{
|
|
RECT rc;
|
|
|
|
// Note that new windows go to the bottom of the Z order
|
|
pdsv->hwndStatic = CreateWindowEx(WS_EX_CLIENTEDGE, c_szAnimateClass, c_szNULL,
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | ACS_TRANSPARENT | ACS_AUTOPLAY | ACS_CENTER,
|
|
0, 0, 0, 0, pdsv->hwndView, (HMENU)ID_STATIC, HINST_THISDLL, NULL);
|
|
if (!pdsv->hwndStatic)
|
|
{
|
|
// We need this window to exist so that we do not get strange
|
|
// painting and clicking results
|
|
return(FALSE);
|
|
}
|
|
|
|
GetClientRect(pdsv->hwndView, &rc);
|
|
// Move this window to the top so the user sees the looking icon
|
|
SetWindowPos(pdsv->hwndStatic, HWND_TOP, 0, 0,
|
|
rc.right, rc.bottom, 0);
|
|
ShowWindow(pdsv->hwndListview, SW_HIDE);
|
|
}
|
|
|
|
ViewWindow_BestFit(pdsv, TRUE);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void DefView_CheckForFillDoneOnDestroy(LPDEFVIEW pdsv, HWND hwndView)
|
|
{
|
|
MSG msg;
|
|
HDPA hdpa;
|
|
int i;
|
|
|
|
if (PeekMessage(&msg, hwndView, WM_DSV_DESTROYSTATIC, WM_DSV_DESTROYSTATIC, PM_NOREMOVE))
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("DefView: Fill_Completed after WM_DESTROY!!!"));
|
|
hdpa = (HDPA)msg.lParam;
|
|
if (hdpa)
|
|
{
|
|
for (i=DPA_GetPtrCount(hdpa)-1; i >= 0; i--)
|
|
{
|
|
ILFree((LPITEMIDLIST)DPA_FastGetPtr(hdpa, i));
|
|
}
|
|
|
|
DPA_Destroy(hdpa);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void DefView_FillDone(LPDEFVIEW pdsv, HDPA hdpaNew,
|
|
PDVSAVEHEADER pSaveHeader, UINT uLen, BOOL bRefresh, BOOL fInteractive)
|
|
{
|
|
HDPA hdpaOld = NULL;
|
|
int i, j;
|
|
|
|
SendMessage(pdsv->hwndListview, WM_SETREDRAW, (WPARAM)FALSE, 0);
|
|
|
|
if (FALSE == DV_ISOWNERDATA(pdsv))
|
|
{
|
|
//
|
|
// Make it sure that we have pdsv around while in this function.
|
|
//
|
|
pdsv->sv.lpVtbl->AddRef(&pdsv->sv);
|
|
|
|
hdpaOld = DPA_Create(16);
|
|
if (!hdpaOld)
|
|
{
|
|
goto Error1;
|
|
}
|
|
|
|
// now get the dpa of what's currently being viewed.
|
|
i = ListView_GetItemCount(pdsv->hwndListview);
|
|
|
|
for (j = 0; j < i ; j++)
|
|
{
|
|
LPITEMIDLIST pidl = DSV_GetPIDL(pdsv, j);
|
|
if (pidl)
|
|
{
|
|
DPA_InsertPtr(hdpaOld, INT_MAX, pidl);
|
|
}
|
|
}
|
|
|
|
// sort the two for easy comparisions
|
|
// Note the new list should already be sorted
|
|
// I wish we could do this sort in the background, but we just can't
|
|
DPA_Sort(hdpaOld, (PFNDPACOMPARE)DefView_Compare, (LPARAM)pdsv);
|
|
|
|
DSV_FilterDPAs(pdsv, hdpaNew, hdpaOld);
|
|
}
|
|
|
|
if (hdpaOld)
|
|
{
|
|
DPA_Destroy(hdpaOld);
|
|
}
|
|
|
|
Error1:;
|
|
DPA_Destroy(hdpaNew);
|
|
|
|
if (bRefresh)
|
|
{
|
|
TIMESTART(pdsv->RestoreState);
|
|
DefView_RestoreState(pdsv, pSaveHeader, uLen);
|
|
TIMESTOP(pdsv->RestoreState);
|
|
}
|
|
|
|
// Bring this to the top while showing it to avoid a second paint when
|
|
// hwndStatic is destroyed
|
|
SetWindowPos(pdsv->hwndListview, HWND_TOP, 0, 0, 0, 0,
|
|
SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
|
|
|
|
if (pdsv->hwndStatic)
|
|
{
|
|
// Apparently, we were filling in the background
|
|
LPITEMIDLIST pidlSelect;
|
|
UINT uFlags;
|
|
|
|
DestroyWindow(pdsv->hwndStatic);
|
|
pdsv->hwndStatic = NULL;
|
|
|
|
ENTERCRITICAL;
|
|
pidlSelect = pdsv->pidlSelect;
|
|
uFlags = pdsv->uFlagsSelect;
|
|
pdsv->pidlSelect = NULL;
|
|
LEAVECRITICAL;
|
|
|
|
if (pidlSelect)
|
|
{
|
|
CDefView_SelectItem(&pdsv->sv, pidlSelect, uFlags);
|
|
ILFree(pidlSelect);
|
|
}
|
|
}
|
|
|
|
// set the focus on the first item.
|
|
DV_FocusOnSomething(pdsv);
|
|
|
|
// Tell the defview client that this window has been refreshed
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_REFRESH, 0, pdsv->lSelChangeInfo);
|
|
}
|
|
|
|
DV_UpdateStatusBar(pdsv, TRUE);
|
|
|
|
if (pdsv->bUpdatePending)
|
|
{
|
|
pdsv->bUpdatePending = FALSE;
|
|
DefView_FillObjectsShowHide(pdsv, FALSE, NULL, 0, fInteractive);
|
|
}
|
|
else if (!DV_ISDESKTOP(pdsv) && !DV_ISOWNERDATA(pdsv))
|
|
{
|
|
// We don't need to get desktop icons in the background, since it
|
|
// doesn't scroll anyway
|
|
DefView_IdleDoStuff(pdsv, WM_DVI_LOADSTUFF, (LPARAM)pdsv);
|
|
}
|
|
|
|
//
|
|
// Decrement the reference count
|
|
//
|
|
pdsv->sv.lpVtbl->Release(&pdsv->sv);
|
|
SendMessage(pdsv->hwndListview, WM_SETREDRAW, (WPARAM)TRUE, 0);
|
|
|
|
if (pdsv->pSaveHeader)
|
|
{
|
|
LocalFree((HLOCAL)pdsv->pSaveHeader);
|
|
pdsv->pSaveHeader = NULL;
|
|
pdsv->uSaveHeaderLen = 0;
|
|
}
|
|
|
|
#ifdef TIMING
|
|
dwFinish = GetTickCount();
|
|
{
|
|
TCHAR sz[40];
|
|
wsprintf(sz, TEXT("%d\n"), dwFinish - dwStart);
|
|
OutputDebugString(sz);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
void ChangeRefForIdle(LPDEFVIEW pdsv, BOOL bAdd)
|
|
{
|
|
if (bAdd)
|
|
{
|
|
if (InterlockedIncrement(&pdsv->cRefForIdle) == 0)
|
|
{
|
|
pdsv->sv.lpVtbl->AddRef(&pdsv->sv);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (InterlockedDecrement(&pdsv->cRefForIdle) < 0)
|
|
{
|
|
pdsv->sv.lpVtbl->Release(&pdsv->sv);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
typedef struct _ENUMTHREAD
|
|
{
|
|
LPDEFVIEW pdsv;
|
|
LPENUMIDLIST peunk;
|
|
HDPA hdpaNew;
|
|
BOOL bRefresh;
|
|
} ENUMTHREAD, *PENUMTHREAD;
|
|
|
|
|
|
//
|
|
// Enumeration loop for IDLE thread.
|
|
//
|
|
void DefView_EnumObjs(PENUMTHREAD pEnum, BOOL bAnother)
|
|
{
|
|
ENUMTHREAD et = *pEnum;
|
|
|
|
// We'll only QI for ASyncEnum once. If it's rejected, we'll set this to
|
|
// FALSE so we don't keep trying
|
|
|
|
BOOL fCouldDoOwnerData = TRUE;
|
|
|
|
LPITEMIDLIST pidl = NULL; // just in case
|
|
ULONG celt;
|
|
DWORD idThisThread = GetCurrentThreadId();
|
|
DWORD cFoundSoFar = 0;
|
|
|
|
Free(pEnum);
|
|
|
|
if (bAnother)
|
|
{
|
|
// I assume this is an invalid thread ID
|
|
idThisThread = INVALID_THREAD_ID;
|
|
}
|
|
|
|
while (et.pdsv->idThreadIdle==idThisThread
|
|
&& DV_Next(et.pdsv, et.peunk, 1, &pidl, &celt) == S_OK)
|
|
{
|
|
if (et.pdsv->idThreadIdle!=idThisThread
|
|
|| DPA_InsertPtr(et.hdpaNew, INT_MAX, pidl)==-1)
|
|
{
|
|
SHFree(pidl);
|
|
}
|
|
else
|
|
{
|
|
cFoundSoFar++;
|
|
|
|
if (fCouldDoOwnerData && cFoundSoFar >= OD_CROSSOVER_LIMIT)
|
|
{
|
|
if (FAILED(et.peunk->lpVtbl->QueryInterface(et.peunk,
|
|
&IID_IAsynchEnumIDList,
|
|
&(et.pdsv->pasyncenum))))
|
|
{
|
|
// This enumerator has never heard of async enumeration, so
|
|
// don't do it now and don't bother asking it again
|
|
|
|
fCouldDoOwnerData = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// We're going to go async/ownerdata
|
|
|
|
ASSERT(et.pdsv->hwndView);
|
|
if (et.pdsv->hwndListview)
|
|
{
|
|
|
|
SendMessage(et.pdsv->hwndView, WM_DSV_CREATEODLISTVIEW, 0, 0);
|
|
|
|
// If the flashlight animation is playing, we can shut it
|
|
// down now
|
|
|
|
|
|
if (et.pdsv->hwndView && PostMessage(et.pdsv->hwndView, WM_DSV_DESTROYSTATIC,
|
|
et.bRefresh, (LPARAM)et.hdpaNew))
|
|
|
|
// Clean up
|
|
|
|
et.pdsv->bBkFilling = FALSE;
|
|
DPA_Destroy(et.hdpaNew);
|
|
|
|
et.peunk->lpVtbl->Release(et.peunk);
|
|
ChangeRefForIdle(et.pdsv, FALSE);
|
|
|
|
|
|
// We're outta here
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pidl = NULL;
|
|
}
|
|
|
|
et.pdsv->bBkFilling = FALSE;
|
|
|
|
if (et.pdsv->idThreadIdle == idThisThread)
|
|
{
|
|
HWND hwndView;
|
|
|
|
// Sort on this thread so we do not hang the main thread for as long
|
|
DPA_Sort(et.hdpaNew, (PFNDPACOMPARE)DefView_Compare, (LPARAM)et.pdsv);
|
|
|
|
// Tell the main thread to merge the items
|
|
hwndView = et.pdsv->hwndView;
|
|
if (hwndView && PostMessage(hwndView, WM_DSV_DESTROYSTATIC,
|
|
et.bRefresh, (LPARAM)et.hdpaNew))
|
|
{
|
|
// If hwndView is destroyed before receiving this message, we could
|
|
// have a memory leak. Oh well.
|
|
et.hdpaNew = NULL;
|
|
}
|
|
}
|
|
|
|
if (et.hdpaNew)
|
|
{
|
|
DPA_Destroy(et.hdpaNew);
|
|
}
|
|
|
|
et.peunk->lpVtbl->Release(et.peunk);
|
|
|
|
ChangeRefForIdle(et.pdsv, FALSE);
|
|
}
|
|
|
|
|
|
DWORD DefView_IdleThreadProc(MSG *pMsg)
|
|
{
|
|
MSG msg;
|
|
LPDEFVIEW pdsv = NULL;
|
|
HANDLE hThread;
|
|
DWORD idThread, idThisThread = GetCurrentThreadId();
|
|
BOOL bRet;
|
|
|
|
msg = *pMsg;
|
|
LocalFree((HLOCAL)pMsg);
|
|
|
|
do
|
|
{
|
|
// Note the first thing we do is create a message queue
|
|
MSG msgTemp;
|
|
BOOL bAnother = PeekMessage(&msgTemp, NULL,
|
|
msg.message, msg.message, PM_NOREMOVE);
|
|
|
|
switch (msg.message)
|
|
{
|
|
case WM_DVI_FILLSTUFF:
|
|
DefView_EnumObjs((PENUMTHREAD)msg.lParam, bAnother);
|
|
|
|
// Get the LPDEFVIEW for the last known message
|
|
pdsv = (LPDEFVIEW)msg.wParam;
|
|
break;
|
|
|
|
case WM_DVI_LOADSTUFF:
|
|
DefView_LoadIcons((LPDEFVIEW)msg.lParam, bAnother);
|
|
|
|
// Get the LPDEFVIEW for the last known message
|
|
pdsv = (LPDEFVIEW)msg.wParam;
|
|
break;
|
|
|
|
default:
|
|
// We got a message we did not expect. Very bad.
|
|
DebugMsg( DM_ERROR, TEXT("Defview_IdleThreadProc: Got unexpected message 0x%lx!!!"), msg.message );
|
|
break;
|
|
}
|
|
|
|
GetNextMessage:;
|
|
}
|
|
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE));
|
|
|
|
|
|
bRet = TRUE;
|
|
|
|
ENTERCRITICAL;
|
|
if (pdsv)
|
|
{
|
|
// BUGBUG: If the thread exits early, we will blow it away. I can
|
|
// live with this for now.
|
|
hThread = pdsv->hThreadIdle;
|
|
idThread = pdsv->idThreadIdle;
|
|
|
|
if (idThread == idThisThread)
|
|
{
|
|
pdsv->hThreadIdle = NULL;
|
|
pdsv->idThreadIdle = 0;
|
|
}
|
|
else
|
|
{
|
|
hThread = NULL;
|
|
}
|
|
|
|
// Make sure I don't use this when I shouldn't
|
|
pdsv = NULL;
|
|
}
|
|
else
|
|
{
|
|
hThread = NULL;
|
|
}
|
|
|
|
if (hThread)
|
|
{
|
|
if (gp_dvp.hThreadIdle)
|
|
{
|
|
CloseHandle(hThread);
|
|
}
|
|
else
|
|
{
|
|
bRet = FALSE;
|
|
gp_dvp.hThreadIdle = hThread;
|
|
gp_dvp.idThreadIdle = idThread;
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (!bRet)
|
|
{
|
|
// Note the "last" thread may not return; it should always be
|
|
// safe to terminate it while in a wait
|
|
// We will only leave this thread around for about 5 minutes
|
|
// so it does not take up memory forever after a user has
|
|
// played with the Shell just once
|
|
if (MsgWaitForMultipleObjects(0, NULL, FALSE, 5*60*1000,
|
|
QS_POSTMESSAGE) != WAIT_TIMEOUT)
|
|
{
|
|
// We must have gotten a message, so wake up and
|
|
// process it
|
|
goto GetNextMessage;
|
|
}
|
|
|
|
ENTERCRITICAL;
|
|
if (gp_dvp.idThreadIdle == idThisThread)
|
|
{
|
|
CloseHandle(gp_dvp.hThreadIdle);
|
|
gp_dvp.hThreadIdle = NULL;
|
|
gp_dvp.idThreadIdle = 0;
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
// Check if somebody stole the global thread (and it was this
|
|
// one) just after the MsgWait
|
|
if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
|
|
{
|
|
goto GetNextMessage;
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
DWORD WaitForSendMessageThread(HANDLE hThread, DWORD dwTimeout)
|
|
{
|
|
MSG msg;
|
|
DWORD dwRet;
|
|
DWORD dwEnd = GetTickCount() + dwTimeout;
|
|
|
|
// We will attempt to wait up to dwTimeout for the thread to
|
|
// terminate
|
|
do
|
|
{
|
|
dwRet = MsgWaitForMultipleObjects(1, &hThread, FALSE,
|
|
dwTimeout, QS_SENDMESSAGE);
|
|
if (dwRet == WAIT_OBJECT_0 ||
|
|
dwRet == WAIT_FAILED)
|
|
{
|
|
// The thread must have exited, so we are happy
|
|
break;
|
|
}
|
|
|
|
if (dwRet == WAIT_TIMEOUT)
|
|
{
|
|
// The thread is taking too long to finish, so just
|
|
// return and let the caller kill it
|
|
break;
|
|
}
|
|
|
|
// There must be a pending SendMessage from either the
|
|
// thread we are killing or some other thread/process besides
|
|
// this one. Do a PeekMessage to process the pending
|
|
// SendMessage and try waiting again
|
|
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
|
|
|
|
if (dwTimeout != INFINITE)
|
|
dwTimeout = dwEnd - GetTickCount();
|
|
}
|
|
while((dwTimeout == INFINITE) || ((long)dwTimeout > 0));
|
|
|
|
return(dwRet);
|
|
}
|
|
|
|
|
|
void DefView_KillIdleThread(LPDEFVIEW pdsv, BOOL bTerminate)
|
|
{
|
|
HANDLE hThread;
|
|
DWORD idThread;
|
|
|
|
ENTERCRITICAL;
|
|
hThread = pdsv->hThreadIdle;
|
|
idThread = pdsv->idThreadIdle;
|
|
|
|
pdsv->hThreadIdle = NULL;
|
|
pdsv->idThreadIdle = 0;
|
|
LEAVECRITICAL;
|
|
|
|
if (hThread)
|
|
{
|
|
// still running!
|
|
|
|
// We will attempt to wait up to 2 seconds for the thread to
|
|
// terminate
|
|
if (WaitForSendMessageThread(hThread, 2000)==WAIT_TIMEOUT
|
|
&& bTerminate)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DV_KillIdlleThread calling TerminateThread because of timeout!"));
|
|
// Blow it away!
|
|
TerminateThread(hThread, (DWORD)-1);
|
|
|
|
ENTERCRITICAL;
|
|
if (pdsv->cRefForIdle != -1)
|
|
{
|
|
// Note that we will err on the side of not
|
|
// releasing enough rather than too often,
|
|
// which should never happen.
|
|
// There is only a tiny window when the forgotme
|
|
// flag is not set and the release has happened,
|
|
// so the chance of a memory leak is nearly 0.
|
|
pdsv->cRefForIdle = 0;
|
|
ChangeRefForIdle(pdsv, FALSE);
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
CloseHandle(hThread);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Returns: TRUE, if we successfully create the idle thread.
|
|
//
|
|
BOOL DV_StartIdle(LPDEFVIEW pdsv, LPENUMIDLIST peunk, HDPA hdpaNew, BOOL bRefresh)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
if (EnumerationTimeout(pdsv, bRefresh))
|
|
{
|
|
PENUMTHREAD pEnum = Alloc(SIZEOF(ENUMTHREAD));
|
|
|
|
if (pEnum)
|
|
{
|
|
pEnum->pdsv = pdsv;
|
|
pEnum->peunk = peunk;
|
|
pEnum->hdpaNew = hdpaNew;
|
|
pEnum->bRefresh = bRefresh;
|
|
|
|
pdsv->bBkFilling = TRUE;
|
|
|
|
if (DefView_IdleDoStuff(pdsv, WM_DVI_FILLSTUFF, (LPARAM)pEnum))
|
|
{
|
|
SetTimer(pdsv->hwndView, DV_IDTIMER, ENUMTIMEOUT, NULL);
|
|
fRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
Free(pEnum);
|
|
pdsv->idThreadIdle = 0;
|
|
pdsv->bBkFilling = FALSE;
|
|
}
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Enumeration loop for the main GUI thread.
|
|
//
|
|
HRESULT DefView_FillObjects(LPDEFVIEW pdsv, BOOL bRefresh,
|
|
PDVSAVEHEADER pSaveHeader, UINT uLen, BOOL fInteractive)
|
|
{
|
|
LPENUMIDLIST peunk;
|
|
LPITEMIDLIST pidl = NULL; // just in case
|
|
ULONG celt;
|
|
BOOL fCouldDoOwnerData = TRUE;
|
|
ULONG cFoundSoFar = 0;
|
|
DWORD dwTime;
|
|
BOOL fTimeOut;
|
|
HRESULT hres;
|
|
DWORD dwEnumFlags;
|
|
DWORD dwTimeout = pdsv->fs.fFlags&FWF_BESTFITWINDOW ?
|
|
ENUMTIMEOUT : SHORTENUMTIMEOUT;
|
|
HDPA hdpaNew;
|
|
DECLAREWAITCURSOR;
|
|
|
|
#ifdef TIMING
|
|
dwStart = GetTickCount();
|
|
#endif
|
|
|
|
// This is a potentially long operation
|
|
SetWaitCursor();
|
|
DefView_KillIdleThread(pdsv, FALSE);
|
|
|
|
if (pdsv->pidlSelect)
|
|
{
|
|
// We should not save the selection if we are doing a refresh
|
|
ILFree(pdsv->pidlSelect);
|
|
pdsv->pidlSelect = NULL;
|
|
}
|
|
|
|
if (bRefresh)
|
|
{
|
|
DefView_UpdateGlobalFlags(pdsv);
|
|
DefView_RemoveObject(pdsv, NULL, FALSE);
|
|
}
|
|
|
|
// Setup the enum flags.
|
|
dwEnumFlags = SHCONTF_NONFOLDERS;
|
|
if (pdsv->fShowAllObjects)
|
|
{
|
|
dwEnumFlags |= SHCONTF_INCLUDEHIDDEN ;
|
|
}
|
|
// Start menu view doesn't want folders.
|
|
if (!(pdsv->fs.fFlags & FWF_NOSUBFOLDERS))
|
|
{
|
|
dwEnumFlags |= SHCONTF_FOLDERS;
|
|
}
|
|
|
|
hres = pdsv->pshf->lpVtbl->EnumObjects(pdsv->pshf,
|
|
fInteractive ? pdsv->hwndMain:NULL,
|
|
dwEnumFlags, &peunk);
|
|
|
|
// Please note the it may return S_FALSE which indicates no enumerator.
|
|
// That's why we shouldn't use if (FAILED(hres))
|
|
if (hres != S_OK)
|
|
{
|
|
//
|
|
// Special case for doc-find.
|
|
//
|
|
if (hres == S_FALSE)
|
|
ShowWindow(pdsv->hwndListview, SW_SHOW);
|
|
goto Done;
|
|
}
|
|
|
|
hdpaNew = DPA_Create(16);
|
|
if (!hdpaNew)
|
|
{
|
|
goto Error1;
|
|
}
|
|
|
|
// If you want to hang around for a while, just support the
|
|
// IDelayedRelease interface
|
|
if (pdsv->pdr)
|
|
pdsv->pdr->lpVtbl->Release(pdsv->pdr);
|
|
|
|
peunk->lpVtbl->QueryInterface(peunk, &IID_IDelayedRelease, &pdsv->pdr);
|
|
|
|
TIMEIN(pdsv->Fill);
|
|
TIMEIN(pdsv->AddObject);
|
|
TIMEIN(pdsv->GetIcon);
|
|
TIMEIN(pdsv->GetName);
|
|
TIMEIN(pdsv->FSNotify);
|
|
TIMEIN(pdsv->EnumNext);
|
|
TIMEIN(pdsv->RestoreState);
|
|
|
|
TIMEIN(pdsv->WMNotify);
|
|
TIMEIN(pdsv->LVChanging);
|
|
TIMEIN(pdsv->LVChanged);
|
|
TIMEIN(pdsv->LVDelete);
|
|
TIMEIN(pdsv->LVGetDispInfo);
|
|
|
|
TIMESTART(pdsv->Fill);
|
|
DebugMsg(DM_TRACE, TEXT("DefView_FillObjects(%s) *****************************************"), DV_Name(pdsv));
|
|
|
|
//
|
|
// If the callback returns S_OK to DVM_BACKGROUNDENUM, start the idle
|
|
// thread immediately.
|
|
//
|
|
if ( pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_BACKGROUNDENUM, 0, 0) == S_OK )
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_FillObjects : Start idle thread immediately"));
|
|
if (DV_StartIdle(pdsv, peunk, hdpaNew, bRefresh)) {
|
|
goto Done;
|
|
}
|
|
fTimeOut = TRUE; // Failed to start, don't try it again.
|
|
}
|
|
else
|
|
{
|
|
fTimeOut = FALSE;
|
|
}
|
|
|
|
dwTime = GetTickCount();
|
|
while (DV_Next(pdsv, peunk, 1, &pidl, &celt) == S_OK)
|
|
{
|
|
if (DPA_InsertPtr(hdpaNew, INT_MAX, pidl) == -1)
|
|
{
|
|
SHFree(pidl);
|
|
}
|
|
else
|
|
{
|
|
cFoundSoFar++;
|
|
|
|
if (fCouldDoOwnerData && cFoundSoFar >= OD_CROSSOVER_LIMIT)
|
|
{
|
|
if (FAILED(peunk->lpVtbl->QueryInterface(peunk,
|
|
&IID_IAsynchEnumIDList,
|
|
&(pdsv->pasyncenum))))
|
|
{
|
|
// This enumerator has never heard of async enumeration, so
|
|
// don't do it now and don't bother asking it again
|
|
|
|
fCouldDoOwnerData = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// We're going to go async/ownerdata
|
|
|
|
ASSERT(pdsv->hwndView);
|
|
if (pdsv->hwndListview)
|
|
{
|
|
// Tell the view we've hit the point at which we need
|
|
// to become ownerdata, and have it recreate the appropriate
|
|
// listview type
|
|
|
|
SendMessage(pdsv->hwndView, WM_DSV_CREATEODLISTVIEW, 0, 0);
|
|
|
|
// Clean up
|
|
|
|
DefView_FillDone(pdsv, hdpaNew, pSaveHeader, uLen, bRefresh, fInteractive);
|
|
peunk->lpVtbl->Release(peunk);
|
|
|
|
// We're outta here
|
|
|
|
return hres;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
pidl = NULL;
|
|
|
|
// Are we taking too long?
|
|
if (!fTimeOut && ((GetTickCount() - dwTime) > dwTimeout))
|
|
{
|
|
fTimeOut = TRUE;
|
|
|
|
if (!DV_ISDESKTOP(pdsv))
|
|
{
|
|
if (DV_StartIdle(pdsv, peunk, hdpaNew, bRefresh)) {
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DPA_Sort(hdpaNew, (PFNDPACOMPARE)DefView_Compare, (LPARAM)pdsv);
|
|
|
|
DefView_FillDone(pdsv, hdpaNew, pSaveHeader, uLen, bRefresh, fInteractive);
|
|
|
|
Error1:;
|
|
peunk->lpVtbl->Release(peunk);
|
|
Done:
|
|
ResetWaitCursor();
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT DefView_FillObjectsShowHide(LPDEFVIEW pdsv, BOOL bRefresh,
|
|
PDVSAVEHEADER pSaveHeader, UINT uLen, BOOL fInteractive)
|
|
{
|
|
HRESULT hres;
|
|
|
|
hres = DefView_FillObjects(pdsv, bRefresh, pSaveHeader, uLen, fInteractive);
|
|
if (!pdsv->hwndListview) {
|
|
return hres;
|
|
}
|
|
|
|
pdsv->hres = hres;
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
//
|
|
// If previous enumeration failed, we need to make it visible.
|
|
//
|
|
if (pdsv->fEnumFailed)
|
|
{
|
|
pdsv->fEnumFailed = FALSE;
|
|
ShowWindow(pdsv->hwndListview, SW_SHOW);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The fill objects failed for some reason, we should
|
|
// display an appropriate error message.
|
|
//
|
|
if (!pdsv->fEnumFailed)
|
|
{
|
|
ShowWindow(pdsv->hwndListview, SW_HIDE);
|
|
}
|
|
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - TRACE: DefView_FillObjects failed (%x)"), hres);
|
|
|
|
pdsv->fEnumFailed = TRUE;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
void DefView_MoveSelectedItems(LPDEFVIEW pdsv, int dx, int dy)
|
|
{
|
|
LVUtil_MoveSelectedItems(pdsv->hwndListview, dx, dy);
|
|
pdsv->bItemsMoved = TRUE;
|
|
pdsv->bClearItemPos = FALSE;
|
|
}
|
|
|
|
|
|
TCHAR const c_szDelete[] = TEXT("delete");
|
|
TCHAR const c_szCut[] = TEXT("cut");
|
|
TCHAR const c_szCopy[] = TEXT("copy");
|
|
TCHAR const c_szLink[] = TEXT("link");
|
|
TCHAR const c_szProperties[] = TEXT("properties");
|
|
TCHAR const c_szPaste[] = TEXT("paste");
|
|
TCHAR const c_szPasteLink[] = TEXT("pastelink");
|
|
// char const c_szPasteSpecial[] = "pastespecial";
|
|
TCHAR const c_szRename[] = TEXT("rename");
|
|
|
|
//
|
|
// This function processes command from explorer menu (FCIDM_*)
|
|
//
|
|
// HACK ALERT:
|
|
// This implementation uses following assumptions.
|
|
// (1) The IShellFolder uses CDefFolderMenu.
|
|
// (2) The CDefFolderMenu always add the folder at the top.
|
|
//
|
|
|
|
#define EC_SELECTION 0
|
|
#define EC_BACKGROUND 1
|
|
#define EC_EITHER 3
|
|
|
|
void DefView_ExplorerCommand(LPDEFVIEW pdsv, UINT idFCIDM)
|
|
{
|
|
//
|
|
// s_idMap[i][0] = Defview menuitem ID
|
|
// s_idMap[i][1] = FALSE, context menu; TRUE; background menu
|
|
// s_idMap[i][2] = Folder menuitem ID
|
|
//
|
|
#pragma data_seg(".text", "CODE")
|
|
struct {
|
|
UINT idmFC;
|
|
UINT f_Background;
|
|
LPCTSTR pszVerb;
|
|
} const c_idMap[] = {
|
|
{ SFVIDM_FILE_RENAME, EC_SELECTION, c_szRename },
|
|
{ SFVIDM_FILE_DELETE, EC_SELECTION, c_szDelete },
|
|
{ SFVIDM_FILE_PROPERTIES, EC_EITHER, c_szProperties },
|
|
{ SFVIDM_EDIT_COPY, EC_SELECTION, c_szCopy },
|
|
{ SFVIDM_EDIT_CUT, EC_SELECTION, c_szCut },
|
|
{ SFVIDM_FILE_LINK, EC_SELECTION, c_szLink },
|
|
{ SFVIDM_EDIT_PASTE, EC_BACKGROUND, c_szPaste },
|
|
{ SFVIDM_EDIT_PASTELINK, EC_BACKGROUND, c_szPasteLink },
|
|
// { SFVIDM_EDIT_PASTESPECIAL,TRUE, c_szPasteSpecial },
|
|
};
|
|
#pragma data_seg()
|
|
int i;
|
|
|
|
for (i=0; i<ARRAYSIZE(c_idMap); i++)
|
|
{
|
|
if (c_idMap[i].idmFC==idFCIDM)
|
|
{
|
|
LPCONTEXTMENU pcm = NULL;
|
|
|
|
if (c_idMap[i].f_Background == EC_BACKGROUND)
|
|
{
|
|
TryBackground:
|
|
pdsv->pshf->lpVtbl->CreateViewObject(pdsv->pshf, pdsv->hwndMain,
|
|
&IID_IContextMenu, &pcm);
|
|
}
|
|
else
|
|
{
|
|
pcm = DefView_GetContextMenuFromSelection(pdsv);
|
|
if (!pcm && c_idMap[i].f_Background == EC_EITHER &&
|
|
!ListView_GetSelectedCount(pdsv->hwndListview)) {
|
|
goto TryBackground;
|
|
}
|
|
}
|
|
|
|
if (pcm)
|
|
{
|
|
CMINVOKECOMMANDINFOEX ici = {
|
|
SIZEOF(CMINVOKECOMMANDINFOEX),
|
|
0L,
|
|
pdsv->hwndMain,
|
|
NULL,
|
|
NULL, NULL,
|
|
SW_NORMAL,
|
|
};
|
|
//
|
|
// We need to call QueryContextMenu() so that CDefFolderMenu
|
|
// can initialize its dispatch table correctly.
|
|
//
|
|
HMENU hmenu = CreatePopupMenu();
|
|
#ifdef UNICODE
|
|
// Fill in both the ansi verb and the unicode verb since we
|
|
// don't know who is going to be processing this thing.
|
|
CHAR szVerbAnsi[40];
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
c_idMap[i].pszVerb, -1,
|
|
szVerbAnsi, ARRAYSIZE(szVerbAnsi),
|
|
NULL, NULL);
|
|
ici.lpVerb = szVerbAnsi;
|
|
ici.lpVerbW = c_idMap[i].pszVerb;
|
|
ici.fMask |= CMIC_MASK_UNICODE;
|
|
#else
|
|
ici.lpVerb = c_idMap[i].pszVerb;
|
|
#endif
|
|
|
|
if (hmenu)
|
|
{
|
|
pcm->lpVtbl->QueryContextMenu(pcm, hmenu, 0,
|
|
SFVIDM_CONTEXT_FIRST, SFVIDM_CONTEXT_LAST, 0);
|
|
pdsv->bContextMenuMode = TRUE;
|
|
DefView_InvokeCommand(pdsv, pcm, &ici);
|
|
pdsv->bContextMenuMode = FALSE;
|
|
DestroyMenu(hmenu);
|
|
}
|
|
pcm->lpVtbl->Release(pcm);
|
|
if (pdsv->pcmSel == pcm)
|
|
{
|
|
DV_FlushCachedMenu(pdsv);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We should beep if when one of those object keys are
|
|
// pressed when there is no selection.
|
|
//
|
|
MessageBeep(0);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
Assert(i<ARRAYSIZE(c_idMap));
|
|
}
|
|
|
|
#ifdef MEMMON
|
|
void WINAPI MemMon_Msgs(BOOL fEnable);
|
|
void WINAPI MemMon_ResetCounters(void);
|
|
void WINAPI MemMon_GetCounters(LPDWORD pdwAllocs, LPDWORD pdwFrees, LPDWORD pdwReallocs, LPDWORD pdwAlloced);
|
|
|
|
//---------------------------------------------------------------------------
|
|
static g_fDebugOuts = 0;
|
|
|
|
#define IDT_MEMMON 1
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL MemMonUI_UpdateStats(HWND hwnd)
|
|
{
|
|
static DWORD dwAllocsOld, dwFreesOld, dwReallocsOld, dwAllocatedOld, dwLeftOld;
|
|
DWORD dwAllocs, dwFrees, dwReallocs, dwAllocated, dwLeft;
|
|
TCHAR szAlloced[MAX_PATH];
|
|
|
|
MemMon_GetCounters(&dwAllocs, &dwFrees, &dwReallocs, &dwAllocated);
|
|
dwLeft = dwAllocs - dwFrees;
|
|
|
|
if (dwAllocs != dwAllocsOld)
|
|
SetDlgItemInt(hwnd, IDC_ALLOCS, dwAllocs, FALSE);
|
|
if (dwReallocs != dwReallocsOld)
|
|
SetDlgItemInt(hwnd, IDC_REALLOCS, dwReallocs, FALSE);
|
|
if (dwFrees != dwFreesOld)
|
|
SetDlgItemInt(hwnd, IDC_FREES, dwFrees, FALSE);
|
|
if (dwAllocated != dwAllocatedOld || dwLeft != dwLeftOld)
|
|
{
|
|
wsprintf(szAlloced, TEXT("%d (%d)"), dwLeft, dwAllocated);
|
|
SetDlgItemText(hwnd, IDC_ALLOCED, szAlloced);
|
|
}
|
|
|
|
// if (fUpdateAddress)
|
|
// SetDlgItemInt(hwnd, IDC_ADDRESS, g_dwAddress, FALSE);
|
|
|
|
dwAllocsOld = dwAllocs;
|
|
dwReallocsOld = dwReallocs;
|
|
dwFreesOld = dwFrees;
|
|
dwAllocatedOld = dwAllocated;
|
|
dwLeftOld = dwLeft;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL MemMonUI_OnInitDlg(HWND hwnd)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_DEBUGOUTS, g_fDebugOuts);
|
|
MemMon_Msgs(g_fDebugOuts);
|
|
MemMonUI_UpdateStats(hwnd);
|
|
SetTimer(hwnd, IDT_MEMMON, 1*1000, NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL MemMonUI_OnCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UINT idCmd = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
switch(idCmd)
|
|
{
|
|
case IDCANCEL:
|
|
case IDCLOSE:
|
|
KillTimer(hwnd, IDT_MEMMON);
|
|
EndDialog(hwnd, idCmd);
|
|
return TRUE;
|
|
case IDC_RESET:
|
|
MemMon_ResetCounters();
|
|
MemMonUI_UpdateStats(hwnd);
|
|
return TRUE;
|
|
case IDC_DEBUGOUTS:
|
|
g_fDebugOuts = IsDlgButtonChecked(hwnd, IDC_DEBUGOUTS) ? FALSE : TRUE;
|
|
CheckDlgButton(hwnd, IDC_DEBUGOUTS, g_fDebugOuts);
|
|
MemMon_Msgs(g_fDebugOuts);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL MemMonUI_OnTimer(HWND hwnd)
|
|
{
|
|
MemMonUI_UpdateStats(hwnd);
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL CALLBACK MemMonUI_DlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch(uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return MemMonUI_OnInitDlg(hwnd);
|
|
case WM_COMMAND:
|
|
return MemMonUI_OnCommand(hwnd, wParam, lParam);
|
|
case WM_TIMER:
|
|
return MemMonUI_OnTimer(hwnd);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
void _MemMon(HWND hwnd)
|
|
{
|
|
CreateDialog(HINST_THISDLL, MAKEINTRESOURCE(DLG_MEMMON), hwnd, MemMonUI_DlgProc);
|
|
}
|
|
#endif
|
|
|
|
BOOL Def_IsPasteAvailable(LPDROPTARGET pdtgt, LPDWORD pdwEffect);
|
|
|
|
BOOL DefView_AllowCommand(LPDEFVIEW pdsv, UINT uID, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
DWORD dwAttribsIn;
|
|
DWORD dwEffect;
|
|
|
|
switch (uID)
|
|
{
|
|
case SFVIDM_EDIT_PASTE:
|
|
return Def_IsPasteAvailable(pdsv->pdtgtBack, &dwEffect);
|
|
|
|
case SFVIDM_EDIT_PASTELINK:
|
|
Def_IsPasteAvailable(pdsv->pdtgtBack, &dwEffect);
|
|
return dwEffect & DROPEFFECT_LINK;
|
|
|
|
case SFVIDM_EDIT_COPY:
|
|
dwAttribsIn = SFGAO_CANCOPY;
|
|
break;
|
|
|
|
case SFVIDM_EDIT_CUT:
|
|
dwAttribsIn = SFGAO_CANMOVE;
|
|
break;
|
|
|
|
case SFVIDM_FILE_DELETE:
|
|
dwAttribsIn = SFGAO_CANDELETE;
|
|
break;
|
|
|
|
case SFVIDM_FILE_LINK:
|
|
dwAttribsIn = SFGAO_CANLINK;
|
|
break;
|
|
|
|
case SFVIDM_FILE_PROPERTIES:
|
|
dwAttribsIn = SFGAO_HASPROPSHEET;
|
|
break;
|
|
|
|
default:
|
|
Assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
return (DefView_GetAttributesFromSelection(pdsv, dwAttribsIn) & dwAttribsIn);
|
|
}
|
|
|
|
TCHAR const c_szWindowsHlp[] = TEXT("windows.hlp");
|
|
|
|
LRESULT DefView_Command(LPDEFVIEW pdsv, LPCONTEXTMENU pcmSel, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
DWORD dwStyle;
|
|
int iItem;
|
|
UINT uID = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
if (InRange(uID, SFVIDM_CONTEXT_FIRST, SFVIDM_CONTEXT_LAST))
|
|
{
|
|
TCHAR szCommandString[20];
|
|
BOOL bRenameIt = FALSE;
|
|
|
|
if (pcmSel == NULL)
|
|
{
|
|
// We hopefully have a pcmSel object cached away for the current
|
|
// selection. If not this wont work anyway so blow out.
|
|
pcmSel = pdsv->pcmSel;
|
|
}
|
|
|
|
if (pcmSel)
|
|
{
|
|
HRESULT hres;
|
|
|
|
// make sure this object exists throughout the operation.
|
|
// ie we dont want a change attributes callback delete this
|
|
// object while we are using it...
|
|
pcmSel->lpVtbl->AddRef(pcmSel);
|
|
|
|
// We need to special case the rename command
|
|
szCommandString[0] = TEXT('\0');
|
|
hres = pcmSel->lpVtbl->GetCommandString(pcmSel,
|
|
uID-SFVIDM_CONTEXT_FIRST, GCS_VERB, NULL,
|
|
(LPSTR)szCommandString, ARRAYSIZE(szCommandString));
|
|
if (FAILED(hres) || *szCommandString == TEXT('\0'))
|
|
{
|
|
#ifdef UNICODE
|
|
CHAR szCommand[20];
|
|
szCommand[0] = '\0';
|
|
hres = pcmSel->lpVtbl->GetCommandString(pcmSel,
|
|
uID-SFVIDM_CONTEXT_FIRST, GCS_VERBA, NULL,
|
|
szCommand, ARRAYSIZE(szCommand));
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
szCommand, -1,
|
|
szCommandString, ARRAYSIZE(szCommandString));
|
|
#else
|
|
WCHAR szCommand[20];
|
|
szCommand[0] = L'\0';
|
|
hres = pcmSel->lpVtbl->GetCommandString(pcmSel,
|
|
uID-SFVIDM_CONTEXT_FIRST, GCS_VERBW, NULL,
|
|
(LPSTR)szCommand, ARRAYSIZE(szCommand));
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
szCommand, -1,
|
|
szCommandString, ARRAYSIZE(szCommandString),
|
|
NULL, NULL);
|
|
#endif
|
|
}
|
|
|
|
if (SUCCEEDED(hres) && lstrcmpi(szCommandString, c_szRename)==0)
|
|
{
|
|
bRenameIt = TRUE;
|
|
}
|
|
else
|
|
{
|
|
CMINVOKECOMMANDINFOEX ici = {
|
|
SIZEOF(CMINVOKECOMMANDINFOEX),
|
|
0L,
|
|
pdsv->hwndMain,
|
|
(LPSTR)MAKEINTRESOURCE(uID - SFVIDM_CONTEXT_FIRST),
|
|
NULL, NULL,
|
|
SW_NORMAL,
|
|
};
|
|
|
|
DefView_InvokeCommand(pdsv, pcmSel, &ici);
|
|
}
|
|
|
|
// And release our use of it.
|
|
pcmSel->lpVtbl->Release(pcmSel);
|
|
|
|
if (bRenameIt)
|
|
{
|
|
goto RenameIt;
|
|
}
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
// Is the ID within the client's range?
|
|
if (InRange(uID, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && pdsv->pfnCallback)
|
|
{
|
|
// Yes; pass it on to the callback
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_INVOKECOMMAND, uID - SFVIDM_CLIENT_FIRST, 0);
|
|
return 0L;
|
|
}
|
|
|
|
switch (uID)
|
|
{
|
|
|
|
case SFVIDM_TOOL_CONNECT:
|
|
SHNetConnectionDialog(pdsv->hwndMain, NULL, RESOURCETYPE_DISK);
|
|
SHChangeNotifyHandleEvents(); // flush any drive notifications
|
|
break;
|
|
|
|
case SFVIDM_TOOL_DISCONNECT:
|
|
WNetDisconnectDialog(pdsv->hwndMain, RESOURCETYPE_DISK);
|
|
SHChangeNotifyHandleEvents(); // flush any drive notifications
|
|
break;
|
|
|
|
case SFVIDM_EDIT_UNDO:
|
|
Undo(pdsv->hwndMain);
|
|
break;
|
|
|
|
case SFVIDM_SELECT_ALL:
|
|
{
|
|
DECLAREWAITCURSOR;
|
|
|
|
if (!pdsv->pfnCallback || (pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain, DVM_SELECTALL, 0, pdsv->lSelChangeInfo) != (S_FALSE))) {
|
|
SetWaitCursor();
|
|
SetFocus(pdsv->hwndListview);
|
|
ListView_SetItemState(pdsv->hwndListview, -1, LVIS_SELECTED, LVIS_SELECTED);
|
|
ResetWaitCursor();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SFVIDM_DESELECT_ALL:
|
|
ListView_SetItemState(pdsv->hwndListview, -1, 0, LVIS_SELECTED);
|
|
break;
|
|
|
|
case SFVIDM_SELECT_INVERT:
|
|
{
|
|
DECLAREWAITCURSOR;
|
|
SetWaitCursor();
|
|
SetFocus(pdsv->hwndListview);
|
|
iItem = -1;
|
|
while ((iItem = ListView_GetNextItem(pdsv->hwndListview, iItem, 0)) != -1)
|
|
{
|
|
UINT flag;
|
|
|
|
// flip the selection bit on each item
|
|
flag = ListView_GetItemState(pdsv->hwndListview, iItem, LVIS_SELECTED);
|
|
flag ^= LVNI_SELECTED;
|
|
ListView_SetItemState(pdsv->hwndListview, iItem, flag, LVIS_SELECTED);
|
|
}
|
|
ResetWaitCursor();
|
|
break;
|
|
}
|
|
|
|
case SFVIDM_ARRANGE_AUTO:
|
|
pdsv->fs.fFlags ^= FWF_AUTOARRANGE; // toggle
|
|
SetWindowLong(pdsv->hwndListview, GWL_STYLE, GetWindowStyle(pdsv->hwndListview) ^ LVS_AUTOARRANGE);
|
|
break;
|
|
|
|
case SFVIDM_ARRANGE_GRID:
|
|
|
|
#ifdef TEST_LVDISABLE
|
|
{
|
|
static BOOL fFlag = 0;
|
|
EnableWindow(pdsv->hwndListview, fFlag);
|
|
fFlag = !fFlag;
|
|
}
|
|
#endif
|
|
ListView_Arrange(pdsv->hwndListview, LVA_SNAPTOGRID);
|
|
break;
|
|
|
|
case SFVIDM_VIEW_ICON:
|
|
dwStyle = LVS_ICON;
|
|
pdsv->bClearItemPos = FALSE;
|
|
pdsv->fs.ViewMode = FVM_ICON;
|
|
goto SetStyle;
|
|
|
|
case SFVIDM_VIEW_SMALLICON:
|
|
dwStyle = LVS_SMALLICON;
|
|
pdsv->bClearItemPos = FALSE;
|
|
pdsv->fs.ViewMode = FVM_SMALLICON;
|
|
goto SetStyle;
|
|
|
|
case SFVIDM_VIEW_LIST:
|
|
dwStyle = LVS_LIST;
|
|
pdsv->bClearItemPos = TRUE;
|
|
pdsv->fs.ViewMode = FVM_LIST;
|
|
goto SetStyle;
|
|
|
|
case SFVIDM_VIEW_DETAILS:
|
|
dwStyle = LVS_REPORT;
|
|
pdsv->bClearItemPos = TRUE;
|
|
pdsv->fs.ViewMode = FVM_DETAILS;
|
|
goto SetStyle;
|
|
|
|
SetStyle:
|
|
pdsv->dvState.iDirection = 1;
|
|
SetWindowLong(pdsv->hwndListview, GWL_STYLE, dwStyle | (GetWindowStyle(pdsv->hwndListview) & ~LVS_TYPEMASK));
|
|
_DSV_CheckToolbar(pdsv);
|
|
break;
|
|
|
|
case SFVIDM_EDIT_PASTE:
|
|
case SFVIDM_EDIT_PASTELINK:
|
|
case SFVIDM_EDIT_COPY:
|
|
case SFVIDM_EDIT_CUT:
|
|
case SFVIDM_FILE_LINK:
|
|
case SFVIDM_FILE_DELETE:
|
|
case SFVIDM_FILE_PROPERTIES:
|
|
if (DefView_AllowCommand(pdsv, uID, wParam, lParam))
|
|
{
|
|
DefView_ExplorerCommand(pdsv, GET_WM_COMMAND_ID(wParam, lParam));
|
|
}
|
|
else
|
|
{
|
|
MessageBeep(0);
|
|
}
|
|
break;
|
|
|
|
case SFVIDM_FILE_RENAME:
|
|
// May need to add some more support here later, but...
|
|
{
|
|
int iItemFocus;
|
|
|
|
RenameIt:
|
|
iItemFocus = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_FOCUSED);
|
|
if (iItemFocus >= 0)
|
|
{
|
|
// Deselect all items...
|
|
UINT uState = ListView_GetItemState(pdsv->hwndListview, iItemFocus, LVIS_SELECTED);
|
|
// Deselect all items...
|
|
ListView_SetItemState(pdsv->hwndListview, -1, 0, LVIS_SELECTED);
|
|
if (uState)
|
|
ListView_SetItemState(pdsv->hwndListview, iItemFocus, LVIS_SELECTED, LVIS_SELECTED);
|
|
ListView_EditLabel(pdsv->hwndListview, iItemFocus);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SFVIDM_MISC_MENUTERM1:
|
|
// HACKHACK: After the menu goes away, this command is posted to the
|
|
// window, but note that any WM_COMMAND from the menu would still
|
|
// be in the queue, so we need to post another WM_COMMAND to delete
|
|
// the context menu.
|
|
FORWARD_WM_COMMAND(pdsv->hwndView, SFVIDM_MISC_MENUTERM2, 0, 0, PostMessage);
|
|
break;
|
|
|
|
case SFVIDM_MISC_MENUTERM2:
|
|
DV_FlushCachedMenu(pdsv);
|
|
|
|
if (pdsv->pfnCallback) {
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_EXITMENULOOP, 0, 0);
|
|
}
|
|
break;
|
|
|
|
case SFVIDM_HELP_TOPIC:
|
|
//
|
|
// HACK: Don't call WinHelp when we are in the common dialog.
|
|
//
|
|
if (pdsv->pcdb==NULL)
|
|
{
|
|
//
|
|
// REVIEW: Should we jump to a topic which describes current
|
|
// viewed folder?
|
|
//
|
|
WinHelp(pdsv->hwndMain, c_szWindowsHlp, HELP_FINDER, 0);
|
|
}
|
|
break;
|
|
|
|
#ifdef DEBUG
|
|
case SFVIDM_DEBUG_HASH:
|
|
DumpHashItemTable(NULL);
|
|
break;
|
|
|
|
case SFVIDM_DEBUG_ICON:
|
|
_IconCacheDump();
|
|
break;
|
|
|
|
case SFVIDM_DEBUG_ICON_SAVE:
|
|
_IconCacheSave();
|
|
break;
|
|
|
|
case SFVIDM_DEBUG_ICON_FLUSH:
|
|
_IconCacheFlush(TRUE);
|
|
break;
|
|
|
|
case (SFVIDM_DEBUG_FIRST) :
|
|
case (SFVIDM_DEBUG_FIRST+1):
|
|
case (SFVIDM_DEBUG_FIRST+2):
|
|
case (SFVIDM_DEBUG_FIRST+3):
|
|
case (SFVIDM_DEBUG_FIRST+4):
|
|
case (SFVIDM_DEBUG_FIRST+5):
|
|
case (SFVIDM_DEBUG_FIRST+6):
|
|
case (SFVIDM_DEBUG_FIRST+7):
|
|
case (SFVIDM_DEBUG_FIRST+8):
|
|
{
|
|
HRESULT hres;
|
|
UINT uFlags;
|
|
LPITEMIDLIST pidlNew = NULL;
|
|
int iItemFocus;
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
switch((uID-SFVIDM_DEBUG_FIRST)/3)
|
|
{
|
|
case 0:
|
|
uFlags = SBSP_PARENT;
|
|
break;
|
|
|
|
case 1:
|
|
uFlags = SBSP_ABSOLUTE;
|
|
GetWindowsDirectory(szPath, ARRAYSIZE(szPath));
|
|
pidlNew = ILCreateFromPath(szPath);
|
|
break;
|
|
|
|
case 2:
|
|
uFlags = SBSP_RELATIVE;
|
|
iItemFocus = ListView_GetNextItem(pdsv->hwndListview, -1, LVNI_FOCUSED);
|
|
if (iItemFocus!=-1) {
|
|
pidlNew = ILClone(DSV_GetPIDL(pdsv, iItemFocus));
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch((uID-SFVIDM_DEBUG_FIRST)%3)
|
|
{
|
|
case 0: uFlags |= SBSP_SAMEBROWSER; break;
|
|
case 1: uFlags |= SBSP_NEWBROWSER; break;
|
|
case 2: uFlags |= SBSP_DEFBROWSER; break;
|
|
}
|
|
|
|
hres = pdsv->psb->lpVtbl->BrowseObject(pdsv->psb, pidlNew, uFlags);
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - ISB:BrowseObject test returns (%x)"), hres);
|
|
|
|
if (pidlNew) {
|
|
ILFree(pidlNew);
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#ifdef MEMMON
|
|
case SFVIDM_DEBUG_MEMMON:
|
|
_MemMon(pdsv->hwndMain);
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
// BUGBUG: should not be any of these
|
|
// Ignore if this is a WM_COMMAND message from a control.
|
|
//
|
|
if (!lParam)
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(pdsv->hwndView, TEXT("This feature is not implemented yet"),
|
|
TEXT("UNDER CONSTRUCTION"), MB_OK);
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - command not processed in %s at %d (%x)"),
|
|
__FILE__, __LINE__, uID);
|
|
Assert(0);
|
|
#endif // DEBUG
|
|
}
|
|
return(1L);
|
|
}
|
|
|
|
return(0L);
|
|
}
|
|
|
|
LPITEMIDLIST DSV_SubObjectExists(LPDEFVIEW pdv, LPCITEMIDLIST pidl)
|
|
{
|
|
LPITEMIDLIST pidlReal = NULL;
|
|
|
|
SHGetRealIDL(pdv->pshf, pidl, &pidlReal);
|
|
return pidlReal;
|
|
}
|
|
|
|
LRESULT DSV_OnFSNotify(LPDEFVIEW pdsv, LONG lNotification, LPCITEMIDLIST* ppidl);
|
|
|
|
void DSV_HandleObjectRename(LPDEFVIEW pdsv, LPCITEMIDLIST* ppidl)
|
|
{
|
|
LPITEMIDLIST ppItems[2];
|
|
|
|
if (!pdsv->pidlMonitor)
|
|
return;
|
|
|
|
if (!ILIsParent(pdsv->pidlMonitor, ppidl[0], TRUE)) {
|
|
// move to this folder
|
|
DSV_OnFSNotify(pdsv, SHCNE_CREATE, &ppidl[1]);
|
|
} else if (!ILIsParent(pdsv->pidlMonitor, ppidl[1], TRUE)) {
|
|
// move from this folder
|
|
DSV_OnFSNotify(pdsv, SHCNE_DELETE, &ppidl[0]);
|
|
} else {
|
|
|
|
// rename within this folder
|
|
ppItems[0] = (LPITEMIDLIST)ILFindLastID(ppidl[0]);
|
|
ppItems[1] = DSV_SubObjectExists(pdsv, ILFindLastID(ppidl[1]));
|
|
if (ppItems[1]) {
|
|
if (DefView_UpdateObject(pdsv, ppItems) == -1) {
|
|
ILFree(ppItems[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DV_UpdateStatusBar(LPDEFVIEW pdsv, BOOL fInitialize)
|
|
{
|
|
if (pdsv->pfnCallback)
|
|
{
|
|
if (FAILED(pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain, DVM_UPDATESTATUSBAR, fInitialize, pdsv->lSelChangeInfo)))
|
|
{
|
|
DV_DoDefaultStatusBar(pdsv, fInitialize);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Processes a WM_DSV_FSNOTIFY message
|
|
//
|
|
LRESULT DSV_OnFSNotify(LPDEFVIEW pdsv, LONG lNotification, LPCITEMIDLIST* ppidl)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
LPCITEMIDLIST pidlItem;
|
|
|
|
//
|
|
// Note that renames between directories are changed to
|
|
// create/delete pairs by SHChangeNotify.
|
|
//
|
|
|
|
#ifdef FSNDEBUG
|
|
DebugMsg(DM_TRACE, TEXT("DSV_OnFSNotify, hwnd = %d lEvent = %d"), pdsv->hwndView, lNotification);
|
|
#endif
|
|
|
|
switch(lNotification) {
|
|
|
|
case SHCNE_DRIVEADD:
|
|
case SHCNE_CREATE:
|
|
case SHCNE_MKDIR:
|
|
pidlItem = ILFindLastID(ppidl[0]);
|
|
if (pidl = DSV_SubObjectExists(pdsv, pidlItem))
|
|
{
|
|
// if the item is already in our listview, or if we fail to add it
|
|
// then cleanup because we didnt' store the pidl.
|
|
|
|
if (DefView_FindItem(pdsv, pidlItem, NULL, FALSE) != -1)
|
|
{
|
|
LPITEMIDLIST pp[2];
|
|
pp[0] = (LPITEMIDLIST)pidlItem;
|
|
pp[1] = pidl;
|
|
if (DefView_UpdateObject(pdsv, pp) < 0) {
|
|
// we're bummed
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else if (DefView_AddObject(pdsv, pidl) == -1)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("s.dsv_ofn: Item already exists."));
|
|
ILFree(pidl);
|
|
}
|
|
else
|
|
{
|
|
// Item got added OK, we'll need to save it's position.
|
|
pdsv->bItemsMoved = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SHCNE_DRIVEREMOVED:
|
|
case SHCNE_DELETE:
|
|
case SHCNE_RMDIR:
|
|
pidlItem = ILFindLastID(ppidl[0]);
|
|
DefView_RemoveObject(pdsv, (LPITEMIDLIST)pidlItem, FALSE);
|
|
break;
|
|
|
|
case SHCNE_RENAMEITEM:
|
|
case SHCNE_RENAMEFOLDER:
|
|
DSV_HandleObjectRename(pdsv, ppidl);
|
|
break;
|
|
|
|
case SHCNE_UPDATEIMAGE:
|
|
//
|
|
// the system image cache is changing
|
|
//
|
|
// ppidl[0] is a IDLIST of image indexs that have changed
|
|
//
|
|
if (ppidl && ppidl[0])
|
|
{
|
|
int iImage = *(int UNALIGNED *)((BYTE *)ppidl[0] + 2);
|
|
DefView_UpdateImage(pdsv, iImage);
|
|
}
|
|
break;
|
|
|
|
case SHCNE_ASSOCCHANGED:
|
|
// For this one we will call refresh as we may need to reextract
|
|
// the icons and the like. Later we can optimize this somewhat if
|
|
// we can detect which ones changed and only update those.
|
|
pdsv->sv.lpVtbl->Refresh(&pdsv->sv);
|
|
break;
|
|
|
|
case SHCNE_MEDIAINSERTED:
|
|
case SHCNE_MEDIAREMOVED:
|
|
case SHCNE_NETUNSHARE:
|
|
case SHCNE_NETSHARE:
|
|
case SHCNE_UPDATEITEM:
|
|
if (ppidl)
|
|
{
|
|
LPITEMIDLIST pp[2];
|
|
pidlItem = ILFindLastID(ppidl[0]);
|
|
pp[0] = (LPITEMIDLIST)pidlItem;
|
|
pp[1] = DSV_SubObjectExists(pdsv, pidlItem);
|
|
if (pp[1]) {
|
|
if (DefView_UpdateObject(pdsv, (LPITEMIDLIST*)&pp) < 0)
|
|
{
|
|
// something went wrong
|
|
DefView_Update(pdsv);
|
|
ILFree(pp[1]);
|
|
}
|
|
}
|
|
}
|
|
else // ppidl == NULL means update all items (re-enum them)
|
|
{
|
|
DefView_Update(pdsv);
|
|
}
|
|
break;
|
|
|
|
|
|
case SHCNE_FREESPACE:
|
|
// BUGBUG: should only do this if the drive is ours
|
|
// and we should change the bool to an enum
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
int idDrive;
|
|
if (pdsv->pidlMonitor) {
|
|
if (SHGetPathFromIDList(pdsv->pidlMonitor, szPath)) {
|
|
DWORD dwChangedDrives = *(DWORD UNALIGNED *)((BYTE *)ppidl[0] + 2);
|
|
idDrive = PathGetDriveNumber(szPath);
|
|
DebugMsg(DM_TRACE, TEXT("Changed drives = %x"), dwChangedDrives);
|
|
if (idDrive != -1 &&
|
|
((1 << idDrive) & dwChangedDrives )) {
|
|
DV_UpdateStatusBar(pdsv, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DebugMsg(DM_TRACE, TEXT("DefView: unknown FSNotify %08lX, doing full update"), lNotification);
|
|
DefView_Update(pdsv);
|
|
break;
|
|
}
|
|
|
|
DV_UpdateStatusBar(pdsv, FALSE);
|
|
|
|
return 0L;
|
|
}
|
|
|
|
BOOL DefView_GetItemPosition(LPDEFVIEW pdv, LPCITEMIDLIST pidl, LPPOINT lpPt)
|
|
{
|
|
int i = DefView_FindItem(pdv, pidl, NULL, FALSE);
|
|
if (i != -1)
|
|
return ListView_GetItemPosition(pdv->hwndListview, i, lpPt);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// called when some of our objects get put on the clipboard
|
|
//
|
|
LRESULT DSV_OnSetClipboard(LPDEFVIEW pdsv, UINT idCmd)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("DSV_OnSetClipboard"));
|
|
|
|
Assert((idCmd == DFM_CMD_MOVE) || (idCmd == DFM_CMD_COPY));
|
|
|
|
if (idCmd == DFM_CMD_MOVE) // move
|
|
{
|
|
//
|
|
// mark all selected items as being "cut"
|
|
//
|
|
int i = -1;
|
|
while ((i = ListView_GetNextItem(pdsv->hwndListview, i, LVIS_SELECTED)) != -1)
|
|
{
|
|
ListView_SetItemState(pdsv->hwndListview, i, LVIS_CUT, LVIS_CUT);
|
|
//ListView_RedrawItems(pdsv->hwndListview, i, i+1); // is there a better way?
|
|
pdsv->bHaveCutStuff = TRUE;
|
|
}
|
|
|
|
//
|
|
// join the clipboard viewer chain so we will know when to
|
|
// "uncut" our selected items.
|
|
//
|
|
if (pdsv->bHaveCutStuff)
|
|
{
|
|
Assert(!pdsv->bClipViewer);
|
|
Assert(pdsv->hwndNextViewer == NULL);
|
|
|
|
pdsv->hwndNextViewer = SetClipboardViewer(pdsv->hwndView);
|
|
pdsv->bClipViewer = TRUE;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// called when the clipboard get changed, clear any items in the "cut" state
|
|
//
|
|
LRESULT DSV_OnClipboardChange(LPDEFVIEW pdsv)
|
|
{
|
|
//
|
|
// if we dont have any cut stuff we dont care.
|
|
//
|
|
if (!pdsv->bHaveCutStuff)
|
|
return 0;
|
|
|
|
Assert(pdsv->bClipViewer);
|
|
DebugMsg(DM_TRACE, TEXT("DSV_OnDrawClipboard"));
|
|
|
|
ListView_SetItemState(pdsv->hwndListview, -1, 0, LVIS_CUT);
|
|
pdsv->bHaveCutStuff = FALSE;
|
|
|
|
//
|
|
// unhook from the clipboard viewer chain.
|
|
//
|
|
ChangeClipboardChain(pdsv->hwndView, pdsv->hwndNextViewer);
|
|
pdsv->bClipViewer = FALSE;
|
|
pdsv->hwndNextViewer = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Note: this function returns the point in Listview Coordinate
|
|
// space. So any hit testing done with this needs to be converted
|
|
// back to Client coordinate space...
|
|
BOOL DefView_GetDropPoint(LPDEFVIEW pdv, POINT *lpPt)
|
|
{
|
|
// Check whether we already have gotten the drop anchor (before any
|
|
// menu processing)
|
|
if (pdv->bDropAnchor)
|
|
{
|
|
*lpPt = pdv->ptDrop;
|
|
LVUtil_ClientToLV(pdv->hwndListview, lpPt);
|
|
}
|
|
else if (pdv->bMouseMenu)
|
|
{
|
|
*lpPt = pdv->ptDragAnchor;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// We need the most up-to-date cursor information, since this
|
|
// may be called during a drop, and the last time the current
|
|
// thread called GetMessage was about 10 minutes ago
|
|
GetCursorPos(lpPt);
|
|
LVUtil_ScreenToLV(pdv->hwndListview, lpPt);
|
|
}
|
|
|
|
return pdv->bDropAnchor;
|
|
|
|
}
|
|
|
|
|
|
BOOL DefView_GetDragPoint(LPDEFVIEW pdv, POINT *lpPt)
|
|
{
|
|
BOOL fSource = pdv->bDragSource || pdv->bMouseMenu;
|
|
if (fSource) {
|
|
// if anchor from mouse activity
|
|
*lpPt = pdv->ptDragAnchor;
|
|
} else {
|
|
// if anchor from keyboard activity... use the focused item
|
|
int i = ListView_GetNextItem(pdv->hwndListview, -1, LVNI_FOCUSED);
|
|
if (i != -1)
|
|
ListView_GetItemPosition(pdv->hwndListview, i, lpPt);
|
|
}
|
|
return fSource;
|
|
}
|
|
|
|
|
|
void DV_PaintErrMsg(HWND hWnd, LPDEFVIEW pdsv)
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = BeginPaint(hWnd, &ps);
|
|
RECT rc;
|
|
|
|
GetClientRect(hWnd, &rc);
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DV_PaintErrMsg is called (%x,%d)"), pdsv->hres, SCODE_CODE(pdsv->hres));
|
|
DrawEdge(hdc, &rc, EDGE_SUNKEN, BF_RECT|BF_SOFT|BF_ADJUST|BF_MIDDLE);
|
|
|
|
EndPaint(hWnd, &ps);
|
|
}
|
|
|
|
void DV_DoDefaultStatusBar(LPDEFVIEW pdsv, BOOL fInitialize)
|
|
{
|
|
if (pdsv->psb)
|
|
{
|
|
// Some of the failure cases do not null hwnd...
|
|
HWND hwndStatus=NULL;
|
|
pdsv->psb->lpVtbl->GetControlWindow(pdsv->psb, FCW_STATUS, &hwndStatus);
|
|
if (hwndStatus)
|
|
{
|
|
int ciParts[] = {-1};
|
|
int nSelected;
|
|
TCHAR szTemp[30];
|
|
TCHAR szTemplate[80];
|
|
TCHAR szStatus[128];
|
|
|
|
if (fInitialize)
|
|
SendMessage(hwndStatus, SB_SETPARTS, ARRAYSIZE(ciParts), (LPARAM)ciParts);
|
|
|
|
if (nSelected = ListView_GetSelectedCount(pdsv->hwndListview))
|
|
{
|
|
LoadString(HINST_THISDLL,
|
|
IDS_FSSTATUSSELECTED,
|
|
szTemplate, ARRAYSIZE(szTemplate));
|
|
#ifdef WINDOWS_ME
|
|
wsprintf(&szStatus[2], szTemplate, AddCommas(nSelected, szTemp));
|
|
#else
|
|
wsprintf(szStatus, szTemplate, AddCommas(nSelected, szTemp));
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
int i = ListView_GetItemCount(pdsv->hwndListview);
|
|
LoadString(HINST_THISDLL, IDS_FSSTATUSNOHIDDENTEMPLATE,
|
|
szTemplate, ARRAYSIZE(szTemplate));
|
|
|
|
#ifdef WINDOWS_ME
|
|
wsprintf(&szStatus[2], szTemplate, AddCommas(i, szTemp));
|
|
#else
|
|
wsprintf(szStatus, szTemplate, AddCommas(i, szTemp));
|
|
#endif
|
|
}
|
|
#ifdef WINDOWS_ME
|
|
szStatus[0] = szStatus[1] = TEXT('\t');
|
|
SendMessage(hwndStatus, SB_SETTEXT, (WPARAM)SB_RTLREADING, (LPARAM)szStatus);
|
|
#else
|
|
SendMessage(hwndStatus, SB_SETTEXT, (WPARAM)0, (LPARAM)szStatus);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void DefView_OnWinIniChange(LPDEFVIEW pdsv, WPARAM wParam, LPCTSTR lpszSection)
|
|
{
|
|
if (!wParam || (lpszSection && !lstrcmpi(lpszSection, TEXT("intl"))))
|
|
{
|
|
// has the time format changed while we're in details mode?
|
|
if (FVM_DETAILS == pdsv->fs.ViewMode) {
|
|
InvalidateRect(pdsv->hwndListview, NULL, TRUE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// we may need to rebuild the icon cache.
|
|
//
|
|
if (wParam == SPI_SETICONMETRICS ||
|
|
wParam == SPI_SETNONCLIENTMETRICS)
|
|
{
|
|
HIMAGELIST himlLarge, himlSmall;
|
|
|
|
Shell_GetImageLists(&himlLarge, &himlSmall);
|
|
ListView_SetImageList(pdsv->hwndListview, himlLarge, LVSIL_NORMAL);
|
|
ListView_SetImageList(pdsv->hwndListview, himlSmall, LVSIL_SMALL);
|
|
}
|
|
|
|
//
|
|
// we need to invalidate the cursor cache
|
|
//
|
|
if (wParam == SPI_SETCURSORS) {
|
|
extern void DAD_InvalidateCursors(void);
|
|
DAD_InvalidateCursors();
|
|
}
|
|
|
|
if (DV_ISDESKTOP(pdsv) &&
|
|
(wParam == SPI_SETDESKWALLPAPER || wParam == SPI_SETDESKPATTERN)) {
|
|
DSV_SetFolderColors(pdsv);
|
|
InvalidateRect(pdsv->hwndListview, NULL, TRUE);
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK DefView_WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPDEFVIEW pdsv;
|
|
LRESULT l;
|
|
|
|
if (iMessage==WM_CREATE) {
|
|
return DefView_WndCreate(hWnd, (LPCREATESTRUCT)lParam);
|
|
}
|
|
|
|
pdsv = (LPDEFVIEW)GetWindowLong(hWnd, 0);
|
|
if (pdsv==NULL)
|
|
{
|
|
if (iMessage!=WM_NCCALCSIZE && iMessage!=WM_NCCREATE)
|
|
{
|
|
Assert(0); // we are not supposed to hit this assert
|
|
}
|
|
goto DoDefWndProc;
|
|
}
|
|
|
|
switch (iMessage) {
|
|
|
|
case WM_DESTROY:
|
|
DefView_KillIdleThread(pdsv, TRUE);
|
|
|
|
// Depending on when it is closed we may have an outstanding post
|
|
// to us about the rest of the fill data which we should try to
|
|
// process in order to keep from leaking stuff...
|
|
DefView_CheckForFillDoneOnDestroy(pdsv, hWnd);
|
|
|
|
//
|
|
// remove ourself as a clipboard viewer
|
|
//
|
|
if (pdsv->bClipViewer)
|
|
{
|
|
ChangeClipboardChain(hWnd, pdsv->hwndNextViewer);
|
|
pdsv->bClipViewer = FALSE;
|
|
pdsv->hwndNextViewer = NULL;
|
|
}
|
|
|
|
if (pdsv->uRegister)
|
|
{
|
|
SHChangeNotifyDeregister(pdsv->uRegister);
|
|
pdsv->uRegister = 0;
|
|
}
|
|
|
|
if (pdsv->psd)
|
|
{
|
|
pdsv->psd->lpVtbl->Release(pdsv->psd);
|
|
pdsv->psd = NULL;
|
|
}
|
|
|
|
if (pdsv->pdtgtBack)
|
|
{
|
|
pdsv->pdtgtBack->lpVtbl->Release(pdsv->pdtgtBack);
|
|
pdsv->pdtgtBack = NULL;
|
|
}
|
|
|
|
if (pdsv->pSaveHeader)
|
|
{
|
|
LocalFree((HLOCAL)pdsv->pSaveHeader);
|
|
pdsv->pSaveHeader = NULL;
|
|
pdsv->uSaveHeaderLen = 0;
|
|
}
|
|
|
|
Assert(pdsv->pdtobjHdrop == NULL); // this should not still be around
|
|
|
|
if (pdsv->hwndListview)
|
|
{
|
|
SHRevokeDragDrop(pdsv->hwndListview);
|
|
}
|
|
break;
|
|
|
|
case WM_NCDESTROY:
|
|
|
|
pdsv->hwndView = NULL;
|
|
|
|
//
|
|
// Now we can release it.
|
|
//
|
|
pdsv->sv.lpVtbl->Release(&pdsv->sv);
|
|
|
|
SetWindowLong(hWnd, 0, 0);
|
|
|
|
//
|
|
// get rid of extra junk in the icon cache
|
|
//
|
|
_IconCacheFlush(FALSE);
|
|
#ifdef NO_LONGER_NEEDED
|
|
//
|
|
// call the PIFMGR code in SHELL(16).DLL and let it get rid of PIFMGR.DLL
|
|
// if no one is using it.
|
|
//
|
|
// BUGBUG: This is not necessary now that PifMgr has been moved over into
|
|
// shell32.dll
|
|
PifMgr_CloseProperties(0, 0);
|
|
#endif
|
|
|
|
break;
|
|
|
|
case WM_ENABLE:
|
|
pdsv->fDisabled = !wParam;
|
|
break;
|
|
|
|
case WM_ERASEBKGND:
|
|
if (ListView_GetBkColor(pdsv->hwndListview) == CLR_NONE)
|
|
return SendMessage(pdsv->hwndMain, iMessage, wParam, lParam);
|
|
// We want to reduce flash
|
|
return 1;
|
|
|
|
case WM_PAINT:
|
|
if (pdsv->fEnumFailed) {
|
|
DV_PaintErrMsg(hWnd, pdsv);
|
|
} else {
|
|
goto DoDefWndProc;
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
if (pdsv->fEnumFailed) {
|
|
PostMessage(hWnd, WM_KEYDOWN, (WPARAM)VK_F5, 0);
|
|
} else {
|
|
goto DoDefWndProc;
|
|
}
|
|
break;
|
|
|
|
case WM_SETFOCUS:
|
|
if (!pdsv->hwndView) // Ignore if we are destroying hwndView.
|
|
break;
|
|
|
|
if (pdsv->pfnCallback)
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_SETFOCUS, 0, pdsv->lSelChangeInfo);
|
|
|
|
if (pdsv->hwndListview)
|
|
SetFocus(pdsv->hwndListview);
|
|
break;
|
|
|
|
// this keeps our window from comming to the front on button down
|
|
// instead, we activate the window on the up click
|
|
|
|
case WM_MOUSEACTIVATE:
|
|
|
|
if (LOWORD(lParam) == HTCLIENT)
|
|
return MA_NOACTIVATE;
|
|
|
|
goto DoDefWndProc;
|
|
|
|
case WM_ACTIVATE:
|
|
// force update on inactive to not ruin save bits
|
|
if (wParam == WA_INACTIVE)
|
|
UpdateWindow(pdsv->hwndListview);
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
return DefView_WndSize(hWnd, pdsv);
|
|
|
|
case WM_NOTIFY:
|
|
pdsv->sv.lpVtbl->AddRef(&pdsv->sv); // just in case
|
|
DefView_StartNotify(pdsv, (NMHDR *)lParam);
|
|
l = DefView_OnNotify(pdsv, (NMHDR *)lParam);
|
|
DefView_StopNotify(pdsv, (NMHDR *)lParam);
|
|
pdsv->sv.lpVtbl->Release(&pdsv->sv); // release
|
|
return l;
|
|
|
|
case WM_CONTEXTMENU:
|
|
DebugMsg(DM_TRACE, TEXT("GOT WM_CONTEXTMENU %d %d !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), wParam, lParam);
|
|
if (!pdsv->fDisabled) {
|
|
if (lParam != (DWORD) -1) {
|
|
pdsv->bMouseMenu = TRUE;
|
|
pdsv->ptDragAnchor.x = LOWORD(lParam);
|
|
pdsv->ptDragAnchor.y = HIWORD(lParam);
|
|
LVUtil_ScreenToLV(pdsv->hwndListview, &pdsv->ptDragAnchor);
|
|
}
|
|
pdsv->bContextMenuMode = TRUE;
|
|
DefView_ContextMenu(pdsv, lParam);
|
|
pdsv->bContextMenuMode = TRUE;
|
|
if (lParam != (DWORD)-1) {
|
|
pdsv->bMouseMenu = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
return DefView_Command(pdsv, NULL, wParam, lParam);
|
|
|
|
case WM_DRAGSELECT:
|
|
case WM_DRAGMOVE:
|
|
case WM_QUERYDROPOBJECT:
|
|
case WM_DROPOBJECT:
|
|
case WM_DROPFILES:
|
|
return DV_OldDragMsgs(pdsv, iMessage, wParam, (const DROPSTRUCT *)lParam);
|
|
|
|
case WM_DSV_FSNOTIFY:
|
|
{
|
|
LPSHChangeNotificationLock pshcnl;
|
|
LPCITEMIDLIST *ppidl;
|
|
LONG lEvent;
|
|
|
|
TIMESTART(pdsv->FSNotify);
|
|
|
|
pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
|
|
if (pshcnl)
|
|
{
|
|
if (pdsv->fDisabled ||
|
|
(pdsv->pfnCallback &&
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain, DVM_FSNOTIFY,
|
|
(WPARAM)ppidl, (LPARAM)lParam) == (S_FALSE)))
|
|
lParam = 0L;
|
|
else
|
|
lParam = DSV_OnFSNotify(pdsv, lEvent, ppidl);
|
|
|
|
SHChangeNotification_Unlock(pshcnl);
|
|
}
|
|
TIMESTOP(pdsv->FSNotify);
|
|
}
|
|
return lParam;
|
|
|
|
case WM_DSV_DESTROYSTATIC:
|
|
DefView_FillDone(pdsv, (HDPA)lParam, pdsv->pSaveHeader, pdsv->uSaveHeaderLen, (BOOL)wParam, FALSE);
|
|
break;
|
|
|
|
// The WM_DSV_CREATEODLISTVIEW is used to tell us to destroy any existing listview we
|
|
// might have, then to create a new ownerdata one
|
|
|
|
case WM_DSV_CREATEODLISTVIEW:
|
|
{
|
|
// The king is dead...
|
|
|
|
if (pdsv->hwndListview)
|
|
{
|
|
SHRevokeDragDrop(pdsv->hwndListview);
|
|
DestroyWindow(pdsv->hwndListview);
|
|
pdsv->hwndListview = NULL;
|
|
}
|
|
|
|
// ...long live the king
|
|
|
|
pdsv->fIsOwnerData = TRUE;
|
|
if (-1 == DefView_CreateListView(pdsv, hWnd))
|
|
{
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return DefView_WndSize(hWnd, pdsv);
|
|
}
|
|
}
|
|
|
|
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_DRAWCLIPBOARD:
|
|
if (pdsv->hwndNextViewer != NULL)
|
|
SendMessage(pdsv->hwndNextViewer, iMessage, wParam, lParam);
|
|
|
|
if (pdsv->bClipViewer)
|
|
return DSV_OnClipboardChange(pdsv);
|
|
|
|
break;
|
|
|
|
case WM_CHANGECBCHAIN:
|
|
if ((HWND)wParam == pdsv->hwndNextViewer)
|
|
{
|
|
pdsv->hwndNextViewer = (HWND)lParam;
|
|
return TRUE;
|
|
}
|
|
|
|
if (pdsv->hwndNextViewer != NULL)
|
|
return SendMessage(pdsv->hwndNextViewer, iMessage, wParam, lParam);
|
|
break;
|
|
|
|
case WM_WININICHANGE:
|
|
DefView_OnWinIniChange(pdsv, wParam, (LPCTSTR)lParam);
|
|
SendMessage(pdsv->hwndListview, iMessage, wParam, lParam);
|
|
break;
|
|
|
|
case WM_SHELLNOTIFY:
|
|
#define SHELLNOTIFY_SETDESKWALLPAPER 0x0004
|
|
if (wParam == SHELLNOTIFY_SETDESKWALLPAPER) {
|
|
if (DV_ISDESKTOP(pdsv)) {
|
|
pdsv->fHasDeskWallPaper = (lParam != 0);
|
|
DSV_SetFolderColors(pdsv);
|
|
InvalidateRect(pdsv->hwndListview, NULL, TRUE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_INITMENU:
|
|
DefView_OnInitMenu(pdsv);
|
|
break;
|
|
|
|
case WM_INITMENUPOPUP:
|
|
if (DefView_OnInitMenuPopup(pdsv, (HMENU)wParam, LOWORD(lParam), HIWORD(lParam)))
|
|
goto RelayToCM;
|
|
break;
|
|
|
|
case WM_EXITMENULOOP:
|
|
FORWARD_WM_COMMAND(hWnd, SFVIDM_MISC_MENUTERM1, 0, 0, PostMessage);
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
if (pdsv->hwndStatic) {
|
|
Animate_Open(pdsv->hwndStatic, TEXT("#150"));
|
|
}
|
|
KillTimer(pdsv->hwndView, DV_IDTIMER);
|
|
break;
|
|
|
|
case WM_SETCURSOR:
|
|
if (pdsv->hwndStatic) {
|
|
//DebugMsg(DM_TRACE,"########### SET WAIT CURSOR WM_SETCURSOR %d", pfc->iWaitCount);
|
|
SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
return TRUE;
|
|
} else
|
|
goto DoDefWndProc;
|
|
|
|
|
|
case WM_DRAWITEM:
|
|
#define lpdis ((LPDRAWITEMSTRUCT)lParam)
|
|
|
|
if (lpdis->CtlType != ODT_MENU)
|
|
return 0L;
|
|
if (InRange(lpdis->itemID, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_DRAWITEM, SFVIDM_CLIENT_FIRST, lParam);
|
|
return 1L;
|
|
}
|
|
else
|
|
goto RelayToCM;
|
|
#undef lpdis
|
|
|
|
case WM_MEASUREITEM:
|
|
#define lpmis ((LPMEASUREITEMSTRUCT)lParam)
|
|
|
|
if (lpmis->CtlType != ODT_MENU)
|
|
return 0L;
|
|
if (InRange(lpmis->itemID, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, pdsv->hwndMain,
|
|
DVM_MEASUREITEM, SFVIDM_CLIENT_FIRST, lParam);
|
|
return 1L;
|
|
}
|
|
RelayToCM:
|
|
if (pdsv->pcmSel)
|
|
{
|
|
IContextMenu2 *pcm2;
|
|
if (SUCCEEDED(pdsv->pcmSel->lpVtbl->QueryInterface(pdsv->pcmSel, &IID_IContextMenu2, &pcm2)))
|
|
{
|
|
pcm2->lpVtbl->HandleMenuMsg(pcm2, iMessage, wParam, lParam);
|
|
pcm2->lpVtbl->Release(pcm2);
|
|
}
|
|
}
|
|
return 0L;
|
|
|
|
// there are two possible ways to put help texts in the
|
|
// status bar, (1) processing WM_MENUSELECT or (2) handling MenuHelp
|
|
// messages. (1) is compatible with OLE, but (2) is required anyway
|
|
// for tooltips.
|
|
|
|
case WM_MENUSELECT:
|
|
DefView_OnMenuSelect(pdsv, GET_WM_MENUSELECT_CMD(wParam, lParam), GET_WM_MENUSELECT_FLAGS(wParam, lParam), GET_WM_MENUSELECT_HMENU(wParam, lParam));
|
|
break;
|
|
|
|
case WM_SYSCOLORCHANGE:
|
|
DSV_SetFolderColors(pdsv);
|
|
SendMessage(pdsv->hwndListview, iMessage, wParam, lParam);
|
|
break;
|
|
|
|
// BUGBUG: some of these are dead
|
|
|
|
case SVM_SELECTITEM:
|
|
CDefView_SelectItem(&pdsv->sv, (LPCITEMIDLIST)lParam, wParam);
|
|
break;
|
|
|
|
case SVM_MOVESELECTEDITEMS:
|
|
DefView_MoveSelectedItems(pdsv, LOWORD(lParam), HIWORD(lParam));
|
|
break;
|
|
|
|
case SVM_GETANCHORPOINT:
|
|
if (wParam)
|
|
return DefView_GetDragPoint(pdsv, (POINT*)lParam);
|
|
else
|
|
return DefView_GetDropPoint(pdsv, (POINT*)lParam);
|
|
|
|
|
|
case SVM_GETITEMPOSITION:
|
|
return DefView_GetItemPosition(pdsv, (LPCITEMIDLIST)wParam, (POINT*)lParam);
|
|
|
|
case SVM_SELECTANDPOSITIONITEM:
|
|
{
|
|
UINT i;
|
|
SFM_SAP * psap = (SFM_SAP*)lParam;
|
|
for (i = 0; i < wParam; psap++, i++)
|
|
DefView_SelectAndPositionItem(&pdsv->sv, psap->pidl, psap->uSelectFlags, psap->fMove ? &psap->pt : NULL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
DoDefWndProc:
|
|
return DefWindowProc(hWnd, iMessage, wParam, lParam) ;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOL DefView_RegisterWindow(void)
|
|
{
|
|
WNDCLASS wc;
|
|
|
|
if (!GetClassInfo(HINST_THISDLL, c_szDefViewClass, &wc))
|
|
{
|
|
// don't want vredraw and hredraw because that causes horrible
|
|
// flicker expecially with full drag
|
|
wc.style = CS_PARENTDC;
|
|
wc.lpfnWndProc = DefView_WndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = SIZEOF(LPDEFVIEW);
|
|
wc.hInstance = HINST_THISDLL;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = c_szDefViewClass;
|
|
|
|
return RegisterClass(&wc);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDefView_QueryInterface(LPSHELLVIEW psv, REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
// If we just want the same interface or an unknown one, return
|
|
// this guy
|
|
//
|
|
if (IsEqualIID(riid, &IID_IShellView) || IsEqualIID(riid, &IID_IUnknown))
|
|
{
|
|
(LPSHELLVIEW)*ppvObj = &(this->sv);
|
|
this->cRef++;
|
|
return S_OK;
|
|
}
|
|
if (IsEqualIID(riid, &IID_IDropTarget))
|
|
{
|
|
(LPDROPTARGET)*ppvObj = &this->dvdt.dt;
|
|
this->cRef++;
|
|
return S_OK;
|
|
}
|
|
|
|
*ppvObj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CDefView_AddRef(LPSHELLVIEW psv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
this->cRef++;
|
|
return(this->cRef);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CDefView_Release(LPSHELLVIEW psv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
Assert(this->cRef);
|
|
|
|
this->cRef--;
|
|
if (this->cRef>0)
|
|
{
|
|
return(this->cRef);
|
|
}
|
|
|
|
//
|
|
// Just in case, there is a left over.
|
|
//
|
|
CDVDropTarget_LeaveAndReleaseData(this);
|
|
|
|
//
|
|
// We need to give it a chance to clean up.
|
|
//
|
|
if (this->pfnCallback) {
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_RELEASE, 0, (LPARAM)this->lSelChangeInfo);
|
|
}
|
|
|
|
this->sv.lpVtbl->DestroyViewWindow(&this->sv);
|
|
|
|
//
|
|
// We should release psb after pshf (for docfindx)
|
|
//
|
|
this->pshf->lpVtbl->Release(this->pshf);
|
|
|
|
if (this->psi) {
|
|
this->psi->lpVtbl->Release(this->psi);
|
|
}
|
|
|
|
if (this->pcdb) {
|
|
this->pcdb->lpVtbl->Release(this->pcdb);
|
|
}
|
|
|
|
if (this->psb) {
|
|
this->psb->lpVtbl->Release(this->psb);
|
|
}
|
|
|
|
if (this->psd)
|
|
{
|
|
this->psd->lpVtbl->Release(this->psd);
|
|
}
|
|
|
|
if (this->pdr)
|
|
{
|
|
this->pdr->lpVtbl->Release(this->pdr);
|
|
}
|
|
|
|
if (this->pcmSel)
|
|
{
|
|
this->pcmSel->lpVtbl->Release(this->pcmSel);
|
|
}
|
|
|
|
//
|
|
// Cleanup dvdt
|
|
//
|
|
CDVDropTarget_ReleaseDataObject(&this->dvdt);
|
|
CDVDropTarget_ReleaseCurrentDropTarget(&this->dvdt);
|
|
|
|
if (this->pidlSelect)
|
|
{
|
|
ILFree(this->pidlSelect);
|
|
}
|
|
|
|
ENTERCRITICAL;
|
|
--gp_dvp.cRef;
|
|
if (!gp_dvp.cRef)
|
|
{
|
|
if (gp_dvp.hThreadIdle)
|
|
{
|
|
// This thread should just be in a WaitForObject, so it should
|
|
// be safe to blow it away
|
|
TerminateThread(gp_dvp.hThreadIdle, (DWORD)-1);
|
|
CloseHandle(gp_dvp.hThreadIdle);
|
|
gp_dvp.hThreadIdle = NULL;
|
|
gp_dvp.idThreadIdle = 0;
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
//
|
|
// We MUST free this object at VERY end.
|
|
//
|
|
LocalFree((HLOCAL)this);
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
HMENU _GetMenuFromID(HMENU hmMain, UINT uID)
|
|
{
|
|
MENUITEMINFO miiSubMenu;
|
|
|
|
miiSubMenu.cbSize = SIZEOF(MENUITEMINFO);
|
|
miiSubMenu.fMask = MIIM_SUBMENU;
|
|
miiSubMenu.cch = 0; // just in case
|
|
|
|
if (!GetMenuItemInfo(hmMain, uID, FALSE, &miiSubMenu))
|
|
return NULL;
|
|
|
|
return miiSubMenu.hSubMenu;
|
|
}
|
|
|
|
|
|
|
|
DWORD CALLBACK DefView_LoadIcons(LPDEFVIEW this, BOOL bAnother)
|
|
{
|
|
LV_ITEM item;
|
|
int i, iCount;
|
|
DWORD idThisThread = GetCurrentThreadId();
|
|
|
|
if (DV_ISOWNERDATA(this))
|
|
{
|
|
ChangeRefForIdle(this, FALSE);
|
|
return 0;
|
|
}
|
|
|
|
if (bAnother)
|
|
{
|
|
// I assume this is an invalid thread ID
|
|
idThisThread = INVALID_THREAD_ID;
|
|
}
|
|
|
|
item.iSubItem = 0;
|
|
item.mask = LVIF_IMAGE; // This should be the only slow part
|
|
|
|
for (i = 0, iCount = ListView_GetItemCount(this->hwndListview);
|
|
this->idThreadIdle==idThisThread && i < iCount ; i++)
|
|
{
|
|
|
|
item.iItem = i;
|
|
|
|
ListView_GetItem(this->hwndListview, &item);
|
|
}
|
|
|
|
ChangeRefForIdle(this, FALSE);
|
|
|
|
TIMESTOP(this->Fill);
|
|
TIMEOUT(this->Fill);
|
|
TIMEOUT(this->EnumNext);
|
|
TIMEOUT(this->AddObject);
|
|
TIMEOUT(this->GetIcon);
|
|
TIMEOUT(this->GetName);
|
|
TIMEOUT(this->RestoreState);
|
|
|
|
TIMEOUT(this->FSNotify);
|
|
TIMEOUT(this->WMNotify);
|
|
TIMEOUT(this->LVChanging);
|
|
TIMEOUT(this->LVChanged);
|
|
TIMEOUT(this->LVDelete);
|
|
TIMEOUT(this->LVGetDispInfo);
|
|
|
|
DebugMsg(DM_TRACE, TEXT("DefView_FillObjects(%s) done! **********************"), DV_Name(this));
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOL DefView_IdleDoStuff(LPDEFVIEW pdsv, UINT message, LPARAM lParam)
|
|
{
|
|
// The wParam for every message is the LPDEFVIEW
|
|
WPARAM wParam = (WPARAM)pdsv;
|
|
BOOL bRet = FALSE;
|
|
|
|
ENTERCRITICAL;
|
|
if (!pdsv->hThreadIdle)
|
|
{
|
|
pdsv->hThreadIdle = gp_dvp.hThreadIdle;
|
|
pdsv->idThreadIdle = gp_dvp.idThreadIdle;
|
|
gp_dvp.hThreadIdle = NULL;
|
|
gp_dvp.idThreadIdle = 0;
|
|
}
|
|
|
|
if (pdsv->hThreadIdle)
|
|
{
|
|
ChangeRefForIdle(pdsv, TRUE);
|
|
|
|
if (PostThreadMessage(pdsv->idThreadIdle, message, wParam, lParam))
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MSG *pMsg = (MSG *)LocalAlloc(LPTR, SIZEOF(MSG));
|
|
if (pMsg)
|
|
{
|
|
pMsg->message = message;
|
|
pMsg->wParam = wParam;
|
|
pMsg->lParam = lParam;
|
|
|
|
ChangeRefForIdle(pdsv, TRUE);
|
|
|
|
pdsv->hThreadIdle = CreateThread(NULL, 0, DefView_IdleThreadProc,
|
|
pMsg, 0, &pdsv->idThreadIdle);
|
|
|
|
if (pdsv->hThreadIdle)
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LocalFree(pMsg);
|
|
ChangeRefForIdle(pdsv, FALSE);
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
return(bRet);
|
|
}
|
|
|
|
|
|
#pragma data_seg(".text", "CODE")
|
|
const TBBUTTON c_tbDefView[] = {
|
|
{ VIEW_NETCONNECT | IN_VIEW_BMP, SFVIDM_TOOL_CONNECT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1 },
|
|
{ VIEW_NETDISCONNECT | IN_VIEW_BMP, SFVIDM_TOOL_DISCONNECT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1 },
|
|
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1 },
|
|
#define MAX_NETBUTTON 3
|
|
{ STD_CUT | IN_STD_BMP, SFVIDM_EDIT_CUT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ STD_COPY | IN_STD_BMP, SFVIDM_EDIT_COPY, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ STD_PASTE | IN_STD_BMP, SFVIDM_EDIT_PASTE, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1 },
|
|
{ STD_UNDO | IN_STD_BMP, SFVIDM_EDIT_UNDO, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1 },
|
|
{ STD_DELETE | IN_STD_BMP, SFVIDM_FILE_DELETE, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ STD_PROPERTIES | IN_STD_BMP, SFVIDM_FILE_PROPERTIES, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
|
|
{ 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1 },
|
|
// the bitmap indexes here are relative to the view bitmap
|
|
{ VIEW_LARGEICONS | IN_VIEW_BMP, SFVIDM_VIEW_ICON, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
|
|
{ VIEW_SMALLICONS | IN_VIEW_BMP, SFVIDM_VIEW_SMALLICON, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
|
|
{ VIEW_LIST | IN_VIEW_BMP, SFVIDM_VIEW_LIST, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
|
|
{ VIEW_DETAILS | IN_VIEW_BMP, SFVIDM_VIEW_DETAILS, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
|
|
};
|
|
#pragma data_seg()
|
|
|
|
|
|
LRESULT DefView_TBNotify(LPDEFVIEW pdsv, NMHDR *pnm)
|
|
{
|
|
#define ptbn ((LPTBNOTIFY)pnm)
|
|
|
|
switch (pnm->code) {
|
|
case TBN_BEGINDRAG:
|
|
DefView_OnMenuSelect(pdsv, ptbn->iItem, 0, 0);
|
|
break;
|
|
|
|
#ifdef CUST_TOOLBAR
|
|
case TBN_GETBUTTONINFO:
|
|
|
|
if (ptbn->iItem < ARRAYSIZE(c_tbDefView))
|
|
{
|
|
if (ptbn->pszText)
|
|
DV_GetMenuHelpText(pdsv, c_tbDefView[ptbn->iItem].idCommand, ptbn->pszText, ptbn->cchText);
|
|
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case TBN_QUERYINSERT:
|
|
return TRUE;
|
|
|
|
case TBN_QUERYDELETE:
|
|
return TRUE;
|
|
|
|
case TBN_RESET:
|
|
DefView_MergeToolBar(pdsv, FALSE);
|
|
return TRUE;
|
|
#endif // CUST_TOOLBAR
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void DefView_MergeToolBar(LPDEFVIEW this, BOOL bCanRestore)
|
|
{
|
|
TBADDBITMAP ab;
|
|
BOOL fNetButtons;
|
|
DWORD rgfAttr;
|
|
int iStartDefButtons = 0;
|
|
int iEndDefButtons = ARRAYSIZE(c_tbDefView);
|
|
|
|
ab.hInst = HINST_COMMCTRL; // hinstCommctrl
|
|
ab.nID = IDB_STD_SMALL_COLOR; // std bitmaps
|
|
this->psb->lpVtbl->SendControlMsg(this->psb, FCW_TOOLBAR, TB_ADDBITMAP, 8, (LPARAM)&ab, &this->iStdBMOffset);
|
|
|
|
ab.nID = IDB_VIEW_SMALL_COLOR; // std view bitmaps
|
|
this->psb->lpVtbl->SendControlMsg(this->psb, FCW_TOOLBAR, TB_ADDBITMAP, 8, (LPARAM)&ab, &this->iViewBMOffset);
|
|
|
|
rgfAttr = SFGAO_FILESYSTEM | SFGAO_FILESYSANCESTOR;
|
|
fNetButtons = (GetSystemMetrics(SM_NETWORK) & RNC_NETWORKS) &&
|
|
SUCCEEDED(this->pshf->lpVtbl->GetAttributesOf(this->pshf, 0, NULL, &rgfAttr)) &&
|
|
(rgfAttr & (SFGAO_FILESYSTEM | SFGAO_FILESYSANCESTOR));
|
|
|
|
if (!fNetButtons)
|
|
iStartDefButtons = MAX_NETBUTTON;
|
|
|
|
#ifdef CUST_TOOLBAR
|
|
|
|
LRESULT lres;
|
|
|
|
bCanRestore = FALSE; // disable saving for now
|
|
|
|
if (bCanRestore &&
|
|
(this->psb->lpVtbl->SendControlMsg(this->psb, FCW_TOOLBAR, TB_SAVERESTORE, FALSE, (LPARAM)&tbs, &lres), lres))
|
|
{
|
|
this->psb->lpVtbl->SetToolbarItems(this->psb, NULL, 0, FCT_CONFIGABLE);
|
|
DebugMsg(DM_TRACE, TEXT("loaded saved toolbar"));
|
|
}
|
|
else
|
|
|
|
#endif // CUST_TOOLBAR
|
|
|
|
{
|
|
LPTBBUTTON pbtn;
|
|
TBINFO tbinfo;
|
|
int i;
|
|
|
|
tbinfo.uFlags = TBIF_APPEND;
|
|
tbinfo.cbuttons = 0;
|
|
|
|
// Does the client want to prepend/append a toolbar?
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_GETBUTTONINFO, 0, (LPARAM)&tbinfo);
|
|
|
|
pbtn = LocalAlloc(LPTR, SIZEOF(c_tbDefView) + (tbinfo.cbuttons * SIZEOF(TBBUTTON)));
|
|
if (pbtn)
|
|
{
|
|
int iStart = 0;
|
|
int cButtons = tbinfo.cbuttons + iEndDefButtons - iStartDefButtons;
|
|
|
|
// Merge the toolbars
|
|
switch (tbinfo.uFlags)
|
|
{
|
|
case TBIF_PREPEND:
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_GETBUTTONS,
|
|
MAKEWPARAM(SFVIDM_CLIENT_FIRST, tbinfo.cbuttons),
|
|
(LPARAM)pbtn);
|
|
iStart = tbinfo.cbuttons;
|
|
break;
|
|
|
|
case TBIF_APPEND:
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_GETBUTTONS,
|
|
MAKEWPARAM(SFVIDM_CLIENT_FIRST, tbinfo.cbuttons),
|
|
(LPARAM)&pbtn[iEndDefButtons - iStartDefButtons]);
|
|
iStart = 0;
|
|
break;
|
|
|
|
case TBIF_REPLACE:
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_GETBUTTONS,
|
|
MAKEWPARAM(SFVIDM_CLIENT_FIRST, tbinfo.cbuttons),
|
|
(LPARAM)pbtn);
|
|
|
|
cButtons = tbinfo.cbuttons;
|
|
iEndDefButtons = iStartDefButtons;
|
|
break;
|
|
|
|
default:
|
|
Assert(0); // should never be here
|
|
break;
|
|
}
|
|
|
|
for (i = 0;iStartDefButtons < iEndDefButtons; iStartDefButtons++, i++)
|
|
{
|
|
pbtn[i + iStart] = c_tbDefView[iStartDefButtons];
|
|
if (!(c_tbDefView[iStartDefButtons].fsStyle & TBSTYLE_SEP))
|
|
{
|
|
if (c_tbDefView[iStartDefButtons].iBitmap & IN_VIEW_BMP)
|
|
pbtn[i + iStart].iBitmap = (c_tbDefView[iStartDefButtons].iBitmap & ~IN_VIEW_BMP) + this->iViewBMOffset;
|
|
else
|
|
pbtn[i + iStart].iBitmap = c_tbDefView[iStartDefButtons].iBitmap + this->iStdBMOffset;
|
|
}
|
|
}
|
|
|
|
this->psb->lpVtbl->SetToolbarItems(this->psb, pbtn, cButtons, FCT_MERGE);
|
|
LocalFree((HLOCAL)pbtn);
|
|
}
|
|
}
|
|
|
|
_DSV_CheckToolbar(this);
|
|
|
|
}
|
|
|
|
STDMETHODIMP CDefView_GetWindow(LPSHELLVIEW psv, HWND *phwnd)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
*phwnd = this->hwndView;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDefView_ContextSensitiveHelp(LPSHELLVIEW psv, BOOL fEnterMode)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CDefView_EnableModeless(LPSHELLVIEW psv, BOOL fEnable)
|
|
{
|
|
// We have no modeless window to be enabled/disabled
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDefView_Refresh(LPSHELLVIEW psv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
ULONG rgf = SFGAO_VALIDATE;
|
|
HRESULT hres;
|
|
LV_ITEM item;
|
|
|
|
//
|
|
// HACK: We always call IsShared with fUpdateCache=FALSE for performance.
|
|
// However, we need to update the cache when the user explicitly tell
|
|
// us to "Refresh". This is not the ideal place to put this code, but
|
|
// we have no other choice.
|
|
//
|
|
// BUGBUG: this update cache thing is old and bogus I think... talk to the net guys
|
|
//
|
|
TCHAR szPathAny[MAX_PATH];
|
|
|
|
// finish any pending edits
|
|
SendMessage(this->hwndListview, LVM_EDITLABEL, (WPARAM)-1, 0L);
|
|
|
|
GetWindowsDirectory(szPathAny, ARRAYSIZE(szPathAny));
|
|
IsShared(szPathAny, TRUE);
|
|
|
|
// First we have to save all the icon positions, so they will be restored
|
|
// properly during the FillObjects
|
|
CDefView_SaveViewState(psv);
|
|
|
|
// Then we have to notify IShellFolder that we're refreshing
|
|
this->pshf->lpVtbl->GetAttributesOf(this->pshf, 0, NULL, &rgf);
|
|
|
|
//
|
|
// if a item is selected, make sure it gets nuked from the icon
|
|
// cache, this is a last resort type thing, select a item and
|
|
// hit F5 to fix all your problems.
|
|
//
|
|
item.iItem = ListView_GetNextItem(this->hwndListview, -1, LVNI_SELECTED);
|
|
|
|
if (item.iItem != -1) {
|
|
item.iSubItem = 0;
|
|
item.mask = LVIF_PARAM;
|
|
item.lParam = 0;
|
|
ListView_GetItem(this->hwndListview, &item);
|
|
Icon_FSEvent(SHCNE_UPDATEITEM, (LPCITEMIDLIST)item.lParam, NULL);
|
|
}
|
|
|
|
this->dvState.lParamSort = 0;
|
|
this->dvState.iDirection = 1;
|
|
this->dvState.iLastColumnClick = -1;
|
|
|
|
hres = DefView_FillObjectsShowHide(this, TRUE, NULL, 0, TRUE);
|
|
return hres;
|
|
}
|
|
|
|
STDMETHODIMP CDefView_CreateViewWindow(IShellView *psv, IShellView *lpPrevView,
|
|
LPCFOLDERSETTINGS lpfs, IShellBrowser *psb, RECT *prc, HWND *phWnd)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
HRESULT hres;
|
|
UINT uLen;
|
|
BOOL fAllowDrop = TRUE;
|
|
FOLDERVIEWMODE fvmSave;
|
|
|
|
*phWnd = NULL;
|
|
|
|
if (this->hwndView || !DefView_RegisterWindow() || !psb)
|
|
return (E_UNEXPECTED);
|
|
|
|
Assert(this->pshf);
|
|
this->pshf->lpVtbl->QueryInterface(this->pshf, &IID_IShellIcon, &this->psi);
|
|
|
|
// We need to make sure to store this before doing the GetWindowRect
|
|
//
|
|
this->psb = psb;
|
|
psb->lpVtbl->AddRef(psb);
|
|
|
|
psb->lpVtbl->QueryInterface(psb, &IID_ICommDlgBrowser, &this->pcdb);
|
|
|
|
fvmSave = this->fs.ViewMode;
|
|
this->fs = *lpfs;
|
|
if (fvmSave && (lpfs->fFlags & FWF_BESTFITWINDOW))
|
|
this->fs.ViewMode = fvmSave;
|
|
|
|
// This should never fail
|
|
psb->lpVtbl->GetWindow(psb, &this->hwndMain);
|
|
Assert(IsWindow(this->hwndMain));
|
|
|
|
// We need to restore the column widths before showing the window
|
|
uLen = DefView_GetSaveHeader(this, &this->pSaveHeader);
|
|
this->uSaveHeaderLen = uLen;
|
|
|
|
// if there was a previous view that we know about, preserve the sort order
|
|
if (lpPrevView && (lpPrevView->lpVtbl == this->sv.lpVtbl)) {
|
|
LPDEFVIEW pdsvPrev;
|
|
pdsvPrev = IToClass(CDefView, sv,lpPrevView);
|
|
if (pdsvPrev) {
|
|
this->dvState = pdsvPrev->dvState;
|
|
if (this->pSaveHeader)
|
|
this->pSaveHeader->dvState = pdsvPrev->dvState;
|
|
}
|
|
}
|
|
|
|
if (!CreateWindow(c_szDefViewClass, szNULL, WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | WS_CLIPSIBLINGS | WS_TABSTOP,
|
|
prc->left, prc->top, prc->right-prc->left, prc->bottom-prc->top,
|
|
this->hwndMain, NULL, HINST_THISDLL, this))
|
|
{
|
|
hres = (E_OUTOFMEMORY);
|
|
goto Error1;
|
|
}
|
|
|
|
// since DefView_FillObjects can take a while
|
|
// we force a paint now before any items are added so
|
|
// we don't see the grey background of the cabinet window
|
|
// for a long time.
|
|
UpdateWindow(this->hwndView);
|
|
|
|
// NB - Nasty side effect - this needs to be done
|
|
// before calling _BestFit (in DV_FillObjects) so that the
|
|
// parent can handle size changes effectively.
|
|
*phWnd = this->hwndView;
|
|
|
|
|
|
|
|
// Fill the listview with subobjects
|
|
hres = DefView_FillObjectsShowHide(this, TRUE, this->pSaveHeader, uLen, TRUE);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
//
|
|
// The fill objects failed for some reason, we should
|
|
// return an error.
|
|
//
|
|
this->sv.lpVtbl->DestroyViewWindow(&this->sv);
|
|
Assert(this->hwndView == NULL);
|
|
*phWnd = NULL;
|
|
|
|
//
|
|
// Note that we don't need to clean this->psb or this->pcdb
|
|
// because this object will be deleted anyway.
|
|
//
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
// this needs to be done after the enumeration
|
|
if (this->pidlMonitor || this->lFSEvents) // check both so that views can register for everything
|
|
{
|
|
int fSources = (this->lFSEvents & SHCNE_DISKEVENTS) ? SHCNRF_ShellLevel | SHCNRF_InterruptLevel : SHCNRF_ShellLevel;
|
|
UINT uFSEvents = this->lFSEvents | SHCNE_UPDATEIMAGE;
|
|
SHChangeNotifyEntry fsne;
|
|
|
|
if (!this->pfnCallback ||
|
|
(this->pfnCallback && FAILED(this->pfnCallback(this->psvOuter,
|
|
this->pshf, this->hwndMain, DVM_QUERYFSNOTIFY,
|
|
0, (LPARAM)&fsne))) )
|
|
{
|
|
// Reset entry
|
|
fsne.pidl = this->pidlMonitor;
|
|
fsne.fRecursive = FALSE;
|
|
}
|
|
|
|
this->uRegister = SHChangeNotifyRegister(this->hwndView, SHCNRF_NewDelivery | fSources,
|
|
uFSEvents, WM_DSV_FSNOTIFY, 1, &fsne);
|
|
}
|
|
|
|
// We do the toolbar before the menu bar to avoid flash
|
|
DefView_MergeToolBar(this, TRUE);
|
|
|
|
// BUGBUG: commdlg should support drag drop too!
|
|
Assert(this->pdtgtBack == NULL);
|
|
|
|
// this may fail
|
|
this->pshf->lpVtbl->CreateViewObject(this->pshf, this->hwndMain, &IID_IDropTarget, &this->pdtgtBack);
|
|
SHRegisterDragDrop(this->hwndListview, &this->dvdt.dt);
|
|
|
|
hres = S_OK;
|
|
|
|
ViewWindow_BestFit(this, FALSE);
|
|
|
|
// Tell the defview client that this windows has been initialized
|
|
if (this->pfnCallback)
|
|
{
|
|
HRESULT hresT;
|
|
DVSELCHANGEINFO dvsci;
|
|
|
|
dvsci.plParam = &this->lSelChangeInfo;
|
|
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_WINDOWCREATED, (WPARAM)this->hwndView, (LPARAM)&dvsci);
|
|
hresT = this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_QUERYCOPYHOOK, 0, 0);
|
|
|
|
if (SUCCEEDED(hresT)) {
|
|
DefView_AddCopyHook(this);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
|
|
Error1:
|
|
|
|
if (this->pSaveHeader)
|
|
{
|
|
LocalFree((HLOCAL)this->pSaveHeader);
|
|
this->pSaveHeader = NULL;
|
|
this->uSaveHeaderLen = 0;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDefView_DestroyViewWindow(IShellView *psv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
if (this->pdr)
|
|
{
|
|
// The whole point of delayed release is that loading and
|
|
// unloading is slow, so put up an hourglass
|
|
// BUGBUG: We should set the priority to very low and kill
|
|
// the window first, but that won;t do a whole lot of good
|
|
// if 16-bit code is going to be called, which is the case
|
|
// for the Control Panel.
|
|
DECLAREWAITCURSOR;
|
|
|
|
SetWaitCursor();
|
|
this->pdr->lpVtbl->Release(this->pdr);
|
|
this->pdr = NULL;
|
|
ResetWaitCursor();
|
|
}
|
|
|
|
#ifdef CUST_TOOLBAR
|
|
|
|
if (!this->fToolbarSaved && this->psb)
|
|
{
|
|
TBSAVEPARAMS tbs = {HKEY_CURRENT_USER, c_szShellState, c_szDefViewToobar};
|
|
|
|
this->psb->lpVtbl->SendControlMsg(this->psb, FCW_TOOLBAR, TB_SAVERESTORE, TRUE, (LPARAM)&tbs, NULL);
|
|
this->fToolbarSaved = TRUE;
|
|
}
|
|
|
|
#endif // CUST_TOOLBAR
|
|
|
|
//
|
|
// Just in case...
|
|
//
|
|
CDefView_OnDeactivate(this);
|
|
|
|
if (this->hwndView)
|
|
{
|
|
HWND hwndTemp = this->hwndView;
|
|
|
|
//
|
|
// This is a bit lazy implementation, but minimum code.
|
|
//
|
|
DefView_RemoveCopyHook(this);
|
|
|
|
// Put NULL in hwndView indicating that we are destroying.
|
|
this->hwndView = NULL;
|
|
|
|
// Tell the defview client that this window will be destroyed
|
|
if (this->pfnCallback)
|
|
{
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_WINDOWDESTROY, (WPARAM)hwndTemp, 0);
|
|
}
|
|
|
|
DestroyWindow(hwndTemp);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void DV_MergeViewMenu(HMENU hmenu, HMENU hmenuMerge)
|
|
{
|
|
HMENU hmenuView = _GetMenuFromID(hmenu, FCIDM_MENU_VIEW);
|
|
if (hmenuView)
|
|
{
|
|
int index;
|
|
//
|
|
// Find the "options" separator in the view menu.
|
|
//
|
|
for (index = GetMenuItemCount(hmenuView)-1; index>=0; index--)
|
|
{
|
|
MENUITEMINFO mii;
|
|
mii.cbSize = SIZEOF(MENUITEMINFO);
|
|
mii.fMask = MIIM_ID;
|
|
mii.cch = 0; // just in case
|
|
if (GetMenuItemInfo(hmenuView, (UINT)index, TRUE, &mii)
|
|
&& (mii.wID == FCIDM_MENU_VIEW_SEP_OPTIONS))
|
|
{
|
|
// merge it right above the separator.
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Here, index is the index of he "optoins" separator if it has;
|
|
// otherwise, it is -1.
|
|
//
|
|
|
|
// Add the separator above (in addition to existing one if any).
|
|
InsertMenu(hmenuView, index, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
|
|
|
|
// Then merge our menu between two separators (or right below if only one).
|
|
if (index != -1) {
|
|
index++;
|
|
}
|
|
Shell_MergeMenus(hmenuView, hmenuMerge, (UINT)index, 0, (UINT)-1, MM_SUBMENUSHAVEIDS);
|
|
}
|
|
}
|
|
|
|
|
|
// set up the menus based on our activation state
|
|
//
|
|
BOOL CDefView_OnActivate(LPDEFVIEW this, UINT uState)
|
|
{
|
|
if (this->uState != uState)
|
|
{
|
|
HMENU hMenu;
|
|
|
|
CDefView_OnDeactivate(this);
|
|
|
|
Assert(this->hmenuCur == NULL);
|
|
|
|
hMenu = CreateMenu();
|
|
|
|
if (hMenu)
|
|
{
|
|
HMENU hMergeMenu;
|
|
OLEMENUGROUPWIDTHS mwidth = { { 0, 0, 0, 0, 0, 0 } };
|
|
|
|
this->hmenuCur = hMenu;
|
|
this->psb->lpVtbl->InsertMenusSB(this->psb, hMenu, &mwidth);
|
|
|
|
if (uState == SVUIA_ACTIVATE_FOCUS)
|
|
{
|
|
hMergeMenu = LoadMenu(HINST_THISDLL, MAKEINTRESOURCE(POPUP_SFV_MAINMERGE));
|
|
if (hMergeMenu)
|
|
{
|
|
// NOTE: hard coded references to offsets in this menu
|
|
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_FILE),
|
|
GetSubMenu(hMergeMenu, 0), (UINT)0, 0, (UINT)-1,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_EDIT),
|
|
GetSubMenu(hMergeMenu, 1), (UINT)-1, 0, (UINT)-1,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
|
|
DV_MergeViewMenu(hMenu, GetSubMenu(hMergeMenu, 2));
|
|
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_HELP),
|
|
GetSubMenu(hMergeMenu, 3), (UINT)0, 0, (UINT)-1,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
|
|
DestroyMenu(hMergeMenu);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
hMergeMenu = LoadMenu(HINST_THISDLL, MAKEINTRESOURCE(POPUP_SFV_MAINMERGENF));
|
|
if (hMergeMenu)
|
|
{
|
|
// NOTE: hard coded references to offsets in this menu
|
|
|
|
// top half of edit menu
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_EDIT),
|
|
GetSubMenu(hMergeMenu, 0), (UINT)0, 0, (UINT)-1,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
|
|
// bottom half of edit menu
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_EDIT),
|
|
GetSubMenu(hMergeMenu, 1), (UINT)-1, 0, (UINT)-1,
|
|
MM_SUBMENUSHAVEIDS);
|
|
|
|
// view menu
|
|
DV_MergeViewMenu(hMenu, GetSubMenu(hMergeMenu, 2));
|
|
|
|
Shell_MergeMenus(_GetMenuFromID(hMenu, FCIDM_MENU_HELP),
|
|
GetSubMenu(hMergeMenu, 3), (UINT)0, 0, (UINT)-1,
|
|
MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
|
|
|
|
DestroyMenu(hMergeMenu);
|
|
}
|
|
}
|
|
|
|
if (this->pfnCallback)
|
|
{
|
|
// Allow the client to merge its own menus
|
|
UINT indexClient = GetMenuItemCount(hMenu)-1;
|
|
QCMINFO info = { hMenu, indexClient, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST };
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_MERGEMENU, 0, (LPARAM)&info);
|
|
}
|
|
|
|
this->psb->lpVtbl->SetMenuSB(this->psb, hMenu, NULL, this->hwndView);
|
|
}
|
|
|
|
this->uState = uState;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CDefView_OnDeactivate(LPDEFVIEW this)
|
|
{
|
|
if (this->uState != SVUIA_DEACTIVATE)
|
|
{
|
|
Assert(this->hmenuCur);
|
|
|
|
if (this->pfnCallback)
|
|
{
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain, DVM_UNMERGEMENU, 0, (LPARAM)this->hmenuCur);
|
|
}
|
|
|
|
this->psb->lpVtbl->SetMenuSB(this->psb, NULL, NULL, NULL);
|
|
this->psb->lpVtbl->RemoveMenusSB(this->psb, this->hmenuCur);
|
|
DestroyMenu(this->hmenuCur);
|
|
this->hmenuCur = NULL;
|
|
this->uState = SVUIA_DEACTIVATE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// This function activates the view window. Note that activating it
|
|
// will not change the focus (while setting the focus will activate it).
|
|
//
|
|
STDMETHODIMP CDefView_UIActivate(LPSHELLVIEW psv, UINT uState)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
if (uState)
|
|
{
|
|
CDefView_OnActivate(this, uState);
|
|
Assert(this->hmenuCur);
|
|
}
|
|
else
|
|
{
|
|
CDefView_OnDeactivate(this);
|
|
Assert(this->hmenuCur==NULL);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDefView_GetCurrentInfo(IShellView * psv, LPFOLDERSETTINGS lpfs)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
*lpfs = this->fs;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDefView_TranslateAccelerator(LPSHELLVIEW psv, LPMSG pmsg)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
if (this->fInLabelEdit)
|
|
{
|
|
// DebugMsg(DM_TRACE, "in label edit mode, disabled exploeres accelerator");
|
|
|
|
// process this msg so the exploer does not get to translate
|
|
TranslateMessage(pmsg);
|
|
DispatchMessage(pmsg);
|
|
return S_OK; // we handled it
|
|
}
|
|
|
|
return TranslateAccelerator(this->hwndView, this->hAccel, pmsg) ? S_OK : ResultFromShort(S_FALSE);
|
|
}
|
|
|
|
void DefView_InitViewMenu(LPDEFVIEW this, HMENU hmInit)
|
|
{
|
|
int iCurViewMenuItem = _DSV_GetMenuIDFromViewMode(this->fs.ViewMode);
|
|
UINT uEnable;
|
|
|
|
CheckMenuRadioItem(hmInit, SFVIDM_VIEW_ICON, SFVIDM_VIEW_DETAILS,
|
|
iCurViewMenuItem, MF_BYCOMMAND | MF_CHECKED);
|
|
|
|
uEnable = ((iCurViewMenuItem == SFVIDM_VIEW_LIST) || (iCurViewMenuItem == SFVIDM_VIEW_DETAILS)) ?
|
|
(MF_GRAYED | MF_BYCOMMAND) : (MF_ENABLED | MF_BYCOMMAND);
|
|
|
|
|
|
EnableMenuItem(hmInit, SFVIDM_ARRANGE_GRID, uEnable);
|
|
EnableMenuItem(hmInit, SFVIDM_ARRANGE_AUTO, uEnable);
|
|
CheckMenuItem(hmInit, SFVIDM_ARRANGE_AUTO,
|
|
((uEnable == (MF_ENABLED | MF_BYCOMMAND)) && (this->fs.fFlags & FWF_AUTOARRANGE)) ? MF_CHECKED : MF_UNCHECKED);
|
|
}
|
|
|
|
|
|
|
|
void DV_GetMenuHelpText(LPDEFVIEW pdsv, UINT id, LPTSTR pszText, UINT cchText)
|
|
{
|
|
VDATEINPUTBUF(pszText, TCHAR, cchText);
|
|
*pszText = 0;
|
|
|
|
if (InRange(id, SFVIDM_CONTEXT_FIRST, SFVIDM_CONTEXT_LAST) && pdsv->pcmSel)
|
|
{
|
|
*pszText = '\0';
|
|
// First try to get the stardard help string
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_HELPTEXT, NULL,
|
|
(LPSTR)pszText, cchText);
|
|
if (*pszText == TEXT('\0'))
|
|
{
|
|
// If we didn't get anything, try to grab the other version of the
|
|
// (ansi for a unicode build, or unicode for an ansi build)
|
|
#ifdef UNICODE
|
|
CHAR szText[MAX_PATH];
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_HELPTEXTA, NULL,
|
|
szText, ARRAYSIZE(szText));
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
szText, -1,
|
|
pszText, cchText);
|
|
#else
|
|
WCHAR szText[MAX_PATH];
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_HELPTEXTW, NULL,
|
|
(LPSTR)szText, ARRAYSIZE(szText));
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
szText, -1,
|
|
pszText, cchText,
|
|
NULL, NULL);
|
|
#endif
|
|
}
|
|
|
|
#ifdef SN_TRACE
|
|
if (GetKeyState(VK_CONTROL)<0)
|
|
{
|
|
UINT cch;
|
|
lstrcat(pszText, TEXT(" (debug only) Canonical Verb = "));
|
|
cch=lstrlen(pszText);
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_VERB, NULL,
|
|
(LPSTR)(pszText+cch), cchText-cch);
|
|
if (*(pszText+cch)==TEXT('\0'))
|
|
{
|
|
#ifdef UNICODE
|
|
CHAR szVerb[MAX_PATH];
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_VERBA, NULL,
|
|
szVerb, ARRAYSIZE(szVerb));
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
szVerb, -1,
|
|
pszText+cch, cchText-cch);
|
|
#else
|
|
WCHAR szVerb[MAX_PATH];
|
|
pdsv->pcmSel->lpVtbl->GetCommandString(pdsv->pcmSel,
|
|
id - SFVIDM_CONTEXT_FIRST, GCS_VERBW, NULL,
|
|
(LPSTR)szVerb, ARRAYSIZE(szVerb));
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
szVerb, -1,
|
|
pszText+cch, cchText-cch);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else if (InRange(id, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, NULL, DVM_GETHELPTEXT,
|
|
MAKEWPARAM(id - SFVIDM_CLIENT_FIRST, cchText), (LPARAM)pszText);
|
|
}
|
|
else if (InRange(id, SFVIDM_FIRST, SFVIDM_LAST))
|
|
{
|
|
if ((id == SFVIDM_EDIT_UNDO) && IsUndoAvailable()) {
|
|
GetUndoText(PeekUndoAtom(), pszText, UNDO_STATUSTEXT);
|
|
} else {
|
|
LoadString(HINST_THISDLL, id + SFVIDS_MH_FIRST, pszText, cchText);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DV_GetToolTipText(LPDEFVIEW pdsv, UINT id, LPTSTR pszText, UINT cchText)
|
|
{
|
|
VDATEINPUTBUF(pszText, TCHAR, cchText);
|
|
*pszText = 0;
|
|
|
|
if (InRange(id, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && pdsv->pfnCallback)
|
|
{
|
|
pdsv->pfnCallback(pdsv->psvOuter, pdsv->pshf, NULL, DVM_GETTOOLTIPTEXT,
|
|
MAKEWPARAM(id - SFVIDM_CLIENT_FIRST, cchText), (LPARAM)pszText);
|
|
}
|
|
else
|
|
{
|
|
Assert(InRange(id, SFVIDM_FIRST, SFVIDM_LAST));
|
|
if (id == SFVIDM_EDIT_UNDO) {
|
|
if (IsUndoAvailable()) {
|
|
GetUndoText(PeekUndoAtom(), pszText, UNDO_MENUTEXT);
|
|
return;
|
|
}
|
|
}
|
|
LoadString(HINST_THISDLL, IDS_TT_SFVIDM_FIRST + id, pszText, cchText);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
LRESULT DefView_OnMenuSelect(LPDEFVIEW pdsv, UINT id, UINT mf, HMENU hmenu)
|
|
{
|
|
TCHAR szHelpText[80 + 2*MAX_PATH]; // Lots of stack!
|
|
|
|
// If we dismissed the edit restore our status bar...
|
|
if (!hmenu && LOWORD(mf)==0xffff)
|
|
{
|
|
pdsv->psb->lpVtbl->SendControlMsg(pdsv->psb,
|
|
FCW_STATUS, SB_SIMPLE, 0, 0L, NULL);
|
|
return 0L;
|
|
}
|
|
|
|
|
|
if (mf & (MF_SYSMENU | MF_SEPARATOR))
|
|
return 0L;
|
|
|
|
|
|
szHelpText[0] = 0; // in case of failures below
|
|
|
|
if (mf & MF_POPUP)
|
|
{
|
|
MENUITEMINFO miiSubMenu;
|
|
|
|
miiSubMenu.cbSize = SIZEOF(MENUITEMINFO);
|
|
miiSubMenu.fMask = MIIM_ID;
|
|
miiSubMenu.cch = 0; // just in case
|
|
|
|
if (!GetMenuItemInfo(hmenu, id, TRUE, &miiSubMenu))
|
|
return 0;
|
|
|
|
// Change the parameters to simulate a "normal" menu item
|
|
id = miiSubMenu.wID;
|
|
mf &= ~MF_POPUP;
|
|
}
|
|
|
|
#ifdef WINDOWS_ME
|
|
szHelpText[0] = szHelpText[1] = TEXT('\t');
|
|
szHelpText[2] = TEXT('\0');
|
|
DV_GetMenuHelpText(pdsv, id, &szHelpText[2], ARRAYSIZE(szHelpText)-2);
|
|
|
|
pdsv->psb->lpVtbl->SendControlMsg(pdsv->psb,
|
|
FCW_STATUS, SB_SETTEXT, SBT_RTLREADING | SBT_NOBORDERS | 255, (LPARAM)szHelpText, NULL);
|
|
#else
|
|
DV_GetMenuHelpText(pdsv, id, szHelpText, ARRAYSIZE(szHelpText));
|
|
pdsv->psb->lpVtbl->SendControlMsg(pdsv->psb,
|
|
FCW_STATUS, SB_SETTEXT, SBT_NOBORDERS | 255, (LPARAM)szHelpText, NULL);
|
|
#endif
|
|
pdsv->psb->lpVtbl->SendControlMsg(pdsv->psb,
|
|
FCW_STATUS, SB_SIMPLE, 1, 0L, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// This function dismisses the name edit mode if there is any.
|
|
//
|
|
// REVIEW: Moving the focus away from the edit window will
|
|
// dismiss the name edit mode. Should we introduce
|
|
// a LV_DISMISSEDIT instead?
|
|
//
|
|
void DefView_DismissEdit(LPDEFVIEW pdsv)
|
|
{
|
|
if (pdsv->uState == SVUIA_ACTIVATE_FOCUS)
|
|
{
|
|
HWND hwndFocus = GetFocus();
|
|
if (hwndFocus && pdsv->hwndListview && GetParent(hwndFocus)==pdsv->hwndListview)
|
|
{
|
|
SetFocus(pdsv->hwndListview);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DefView_OnInitMenu(LPDEFVIEW pdsv)
|
|
{
|
|
//
|
|
// We need to dismiss the edit mode if it is any.
|
|
//
|
|
DefView_DismissEdit(pdsv);
|
|
}
|
|
|
|
|
|
LRESULT DefView_OnInitMenuPopup(LPDEFVIEW this, HMENU hmInit, int nIndex, BOOL fSystemMenu)
|
|
{
|
|
int i;
|
|
BOOL bDeleteItems;
|
|
LPCONTEXTMENU pcmSel;
|
|
MENUITEMINFO mii;
|
|
ULONG dwAttr;
|
|
|
|
mii.cbSize = SIZEOF(MENUITEMINFO);
|
|
mii.fMask = MIIM_SUBMENU|MIIM_ID;
|
|
mii.cch = 0; // just in case
|
|
|
|
if (!this->hmenuCur)
|
|
return(1);
|
|
|
|
if (!GetMenuItemInfo(this->hmenuCur, nIndex, TRUE, &mii) || mii.hSubMenu!=hmInit)
|
|
{
|
|
//
|
|
// BUGBUG: We need to get the submenu ID of hmInit ifself, but there is no
|
|
// such an API. JeffBog suggested me to file a bug, but he does not think
|
|
// he can put it in M6. For M6, we probably should live with this hack
|
|
// which get the ID of the first menuitem ID and treat it as the submenu ID.
|
|
//
|
|
#define WORKAROUND_21740
|
|
#ifdef WORKAROUND_21740
|
|
mii.fMask = MIIM_ID;
|
|
if (GetMenuItemInfo(hmInit, 0, TRUE, &mii)
|
|
&& InRange(mii.wID, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST)
|
|
&& this->pfnCallback)
|
|
{
|
|
goto NotifyClient;
|
|
}
|
|
#endif
|
|
return 1L;
|
|
}
|
|
|
|
// Is the ID within the client's range?
|
|
if (InRange(mii.wID, SFVIDM_CLIENT_FIRST, SFVIDM_CLIENT_LAST) && this->pfnCallback)
|
|
{
|
|
NotifyClient:
|
|
// Yes; pass it on to the callback
|
|
this->pfnCallback(this->psvOuter, this->pshf, this->hwndMain,
|
|
DVM_INITMENUPOPUP,
|
|
MAKEWPARAM(SFVIDM_CLIENT_FIRST, nIndex),
|
|
(LPARAM)hmInit);
|
|
return 0L;
|
|
}
|
|
|
|
switch (mii.wID)
|
|
{
|
|
case FCIDM_MENU_FILE:
|
|
//
|
|
// Don't touch the file menu unless we have the focus.
|
|
//
|
|
if (this->uState == SVUIA_ACTIVATE_FOCUS)
|
|
{
|
|
DWORD dwMenuState;
|
|
bDeleteItems = FALSE;
|
|
//
|
|
// First of all, remove all the menu items we've added.
|
|
//
|
|
for (i = GetMenuItemCount(hmInit) - 1; i >= 0; --i)
|
|
{
|
|
if (!bDeleteItems)
|
|
{
|
|
MENUITEMINFO mii;
|
|
mii.cbSize = SIZEOF(mii);
|
|
mii.fMask = MIIM_ID;
|
|
mii.cch = 0; // just in case
|
|
|
|
if (GetMenuItemInfo(hmInit, i, TRUE, &mii))
|
|
{
|
|
if (InRange(mii.wID, SFVIDM_CONTEXT_FIRST, SFVIDM_CONTEXT_LAST))
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_OnInitMenuPopup: setting bDeleteItems at %d, %d"), i, mii.wID);
|
|
bDeleteItems = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bDeleteItems)
|
|
{
|
|
DeleteMenu(hmInit, i, MF_BYPOSITION);
|
|
}
|
|
}
|
|
|
|
dwMenuState = GetMenuState(hmInit, 0, MF_BYPOSITION);
|
|
if ((dwMenuState & MF_SEPARATOR) &&
|
|
!(dwMenuState & MF_POPUP))
|
|
{
|
|
DeleteMenu(hmInit, 0, MF_BYPOSITION);
|
|
}
|
|
|
|
// Let the object add the separator.
|
|
|
|
//
|
|
// Now add item specific commands to the menu
|
|
// This is done by seeing if we already have a context menu
|
|
// object for our selection. If not we generate it now.
|
|
//
|
|
pcmSel = DefView_GetContextMenuFromSelection(this);
|
|
Assert(pcmSel == this->pcmSel);
|
|
|
|
if (pcmSel)
|
|
{
|
|
pcmSel->lpVtbl->QueryContextMenu(pcmSel,
|
|
hmInit, 0, SFVIDM_CONTEXT_FIRST,
|
|
SFVIDM_CONTEXT_LAST, CMF_DVFILE);
|
|
pcmSel->lpVtbl->Release(pcmSel);
|
|
}
|
|
|
|
//
|
|
// Enable/disable menuitems in the "File" pulldown.
|
|
//
|
|
dwAttr = DefView_GetAttributesFromSelection(this,
|
|
SFGAO_CANRENAME|SFGAO_CANDELETE|SFGAO_CANLINK|SFGAO_HASPROPSHEET);
|
|
Def_InitFileCommands(dwAttr, hmInit, SFVIDM_FIRST, FALSE);
|
|
goto NotifyClient;
|
|
}
|
|
break;
|
|
|
|
case FCIDM_MENU_EDIT:
|
|
//
|
|
// Enable/disable menuitems in the "Edit" pulldown.
|
|
//
|
|
dwAttr = DefView_GetAttributesFromSelection(this, SFGAO_CANCOPY|SFGAO_CANMOVE);
|
|
Def_InitEditCommands(dwAttr, hmInit, SFVIDM_FIRST, this->pdtgtBack, 0);
|
|
break;
|
|
|
|
case FCIDM_MENU_VIEW:
|
|
DefView_InitViewMenu(this, hmInit);
|
|
break;
|
|
|
|
default:
|
|
return 1L;
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
|
|
//
|
|
// Member: CDefView::AddPropertySheetPages
|
|
//
|
|
STDMETHODIMP CDefView_AddPropertySheetPages(IShellView *psv, DWORD dwReserved, LPFNADDPROPSHEETPAGE lpfn, LPARAM lparam)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// Member: CDefView::SaveViewState
|
|
//
|
|
STDMETHODIMP CDefView_SaveViewState(IShellView *psv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
LPSTREAM pstm;
|
|
HRESULT hres;
|
|
LARGE_INTEGER dlibMove = {0, 0};
|
|
ULARGE_INTEGER libCurPosition;
|
|
ULARGE_INTEGER libPosPosition;
|
|
ULONG ulWrite;
|
|
DVSAVEHEADER dvSaveHeader;
|
|
BOOL bDefaultCols, bDefaultPos;
|
|
|
|
hres = this->psb->lpVtbl->GetViewStateStream(this->psb, STGM_WRITE, &pstm);
|
|
if (FAILED(hres))
|
|
{
|
|
return hres;
|
|
}
|
|
|
|
// Position the stream right after the header, and save the starting
|
|
// position at the same time
|
|
dlibMove.LowPart = SIZEOF(dvSaveHeader);
|
|
hres = pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_CUR, &libCurPosition);
|
|
if (FAILED(hres))
|
|
{
|
|
goto Error1;
|
|
}
|
|
// HACK: Avoid 2 calls to seek by just subtracting
|
|
libCurPosition.LowPart -= SIZEOF(dvSaveHeader);
|
|
|
|
bDefaultCols = DefView_SaveCols(this, pstm);
|
|
|
|
dvSaveHeader.cbSize = SIZEOF(dvSaveHeader);
|
|
// We save the view mode to determine if the scroll positions are
|
|
// still valid on restore
|
|
dvSaveHeader.ViewMode = this->fs.ViewMode;
|
|
dvSaveHeader.ptScroll.x = GetScrollPos(this->hwndListview, SB_HORZ);
|
|
dvSaveHeader.ptScroll.y = GetScrollPos(this->hwndListview, SB_VERT);
|
|
dvSaveHeader.dvState = this->dvState;
|
|
|
|
// Check whether everything is the default; clear out the stream if so
|
|
if (this->bClearItemPos && IsDefaultState(dvSaveHeader) && bDefaultCols)
|
|
{
|
|
goto SetSize;
|
|
}
|
|
|
|
if (bDefaultCols)
|
|
{
|
|
// No need to save column info
|
|
dvSaveHeader.cbColOffset = 0;
|
|
dvSaveHeader.cbPosOffset = SIZEOF(dvSaveHeader);
|
|
}
|
|
else
|
|
{
|
|
dlibMove.LowPart = 0;
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_CUR, &libPosPosition);
|
|
dvSaveHeader.cbColOffset = SIZEOF(dvSaveHeader);
|
|
dvSaveHeader.cbPosOffset = (USHORT)(libPosPosition.LowPart - libCurPosition.LowPart);
|
|
}
|
|
|
|
dlibMove.LowPart = libCurPosition.LowPart;
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_SET, NULL);
|
|
hres = pstm->lpVtbl->Write(pstm, &dvSaveHeader, SIZEOF(dvSaveHeader), &ulWrite);
|
|
if (FAILED(hres) || ulWrite != SIZEOF(dvSaveHeader))
|
|
{
|
|
goto SetSize;
|
|
}
|
|
|
|
// Make sure we save all information written so far
|
|
libCurPosition.LowPart += dvSaveHeader.cbPosOffset;
|
|
dlibMove.LowPart = libCurPosition.LowPart;
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_SET, NULL);
|
|
|
|
bDefaultPos = DefView_SavePos(this, pstm);
|
|
if (!bDefaultPos)
|
|
{
|
|
dlibMove.LowPart = 0;
|
|
pstm->lpVtbl->Seek(pstm, dlibMove, STREAM_SEEK_CUR,
|
|
&libCurPosition);
|
|
}
|
|
|
|
SetSize:
|
|
pstm->lpVtbl->SetSize(pstm, libCurPosition);
|
|
Error1:;
|
|
pstm->lpVtbl->Release(pstm);
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT DefView_SelectAndPositionItem(IShellView *psv, LPCITEMIDLIST pidlItem, UINT uFlags, POINT *ppt)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
int i;
|
|
|
|
// See if we should first deselect everything else
|
|
if (!pidlItem)
|
|
{
|
|
if (uFlags != SVSI_DESELECTOTHERS)
|
|
{
|
|
// I only know how to deselect everything
|
|
return(E_INVALIDARG);
|
|
}
|
|
|
|
ListView_SetItemState(this->hwndListview, -1, 0, LVIS_SELECTED);
|
|
return(S_OK);
|
|
}
|
|
|
|
i = DefView_FindItem(this, pidlItem, NULL, FALSE);
|
|
if (i != -1)
|
|
{
|
|
// set the position first so that the ensure visible scrolls to
|
|
// the new position
|
|
if (ppt)
|
|
{
|
|
ListView_SetItemPosition32(this->hwndListview, i, ppt->x, ppt->y);
|
|
|
|
this->bItemsMoved = TRUE;
|
|
this->bClearItemPos = FALSE;
|
|
}
|
|
|
|
// The SVSI_EDIT flag also contains SVSI_SELECT and as such
|
|
// a simple & wont work!
|
|
if ((uFlags & SVSI_EDIT) == SVSI_EDIT)
|
|
{
|
|
ListView_EditLabel(this->hwndListview, i);
|
|
}
|
|
else
|
|
{
|
|
UINT stateMask = LVIS_SELECTED;
|
|
UINT state = (uFlags & SVSI_SELECT) ? LVIS_SELECTED : 0;
|
|
if (uFlags & SVSI_FOCUSED)
|
|
{
|
|
state |= LVIS_FOCUSED;
|
|
stateMask |= LVIS_FOCUSED;
|
|
}
|
|
|
|
// See if we should first deselect everything else
|
|
if (uFlags & SVSI_DESELECTOTHERS)
|
|
ListView_SetItemState(this->hwndListview, -1, 0, LVIS_SELECTED);
|
|
|
|
ListView_SetItemState(this->hwndListview, i, state, stateMask);
|
|
|
|
if (uFlags & SVSI_ENSUREVISIBLE)
|
|
ListView_EnsureVisible(this->hwndListview, i, FALSE);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return (E_FAIL);
|
|
}
|
|
//
|
|
// Member: CDefView::SelectItem
|
|
//
|
|
STDMETHODIMP CDefView_SelectItem(IShellView *psv, LPCITEMIDLIST pidlItem, UINT uFlags)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
if (this->hwndStatic)
|
|
{
|
|
ENTERCRITICAL;
|
|
// We must be filling in the background, so this item may not be
|
|
// visible yet. Defer this action until later.
|
|
if (this->pidlSelect)
|
|
{
|
|
ILFree(this->pidlSelect);
|
|
}
|
|
|
|
this->pidlSelect = ILClone(pidlItem);
|
|
this->uFlagsSelect = uFlags;
|
|
LEAVECRITICAL;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
return DefView_SelectAndPositionItem(psv, pidlItem, uFlags, NULL);
|
|
}
|
|
|
|
//
|
|
// To be called back from within CDefFolderMenu
|
|
//
|
|
// Returns:
|
|
// S_OK, if successfully processed.
|
|
// (S_FALSE), if default code should be used.
|
|
//
|
|
HRESULT CALLBACK DefView_DFMCallBackBG(LPSHELLFOLDER psf, HWND hwndOwner,
|
|
LPDATAOBJECT pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
extern TCHAR const c_szNewFolder[];
|
|
#ifdef UNICODE
|
|
extern CHAR const c_szNewFolderAnsi[];
|
|
#endif
|
|
HRESULT hres = S_OK;
|
|
|
|
switch(uMsg) {
|
|
case DFM_VALIDATECMD:
|
|
switch (wParam)
|
|
{
|
|
case DFM_CMD_NEWFOLDER:
|
|
{
|
|
IContextMenu *pcm;
|
|
|
|
if (SUCCEEDED(psf->lpVtbl->CreateViewObject(psf, hwndOwner,
|
|
&IID_IContextMenu, &pcm)))
|
|
{
|
|
TCHAR szTemp[10];
|
|
|
|
// BUGBUG: Do I need to QueryContextMenu?
|
|
hres = pcm->lpVtbl->GetCommandString(pcm, (ULONG)c_szNewFolder,
|
|
GCS_VALIDATE, NULL,
|
|
(LPSTR)szTemp, ARRAYSIZE(szTemp));
|
|
#ifdef UNICODE
|
|
if(FAILED(hres))
|
|
{
|
|
hres = pcm->lpVtbl->GetCommandString(pcm, (ULONG)c_szNewFolder,
|
|
GCS_VALIDATEA, NULL,
|
|
(LPSTR)szTemp, ARRAYSIZE(szTemp));
|
|
}
|
|
#endif
|
|
pcm->lpVtbl->Release(pcm);
|
|
}
|
|
else
|
|
{
|
|
hres = S_FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DFM_CMD_VIEWLIST:
|
|
case DFM_CMD_VIEWDETAILS:
|
|
break;
|
|
|
|
default:
|
|
hres = S_FALSE;
|
|
}
|
|
break;
|
|
|
|
case DFM_INVOKECOMMAND:
|
|
switch(wParam)
|
|
{
|
|
case DFM_CMD_NEWFOLDER:
|
|
{
|
|
IContextMenu *pcm;
|
|
|
|
if (SUCCEEDED(psf->lpVtbl->CreateViewObject(psf, hwndOwner,
|
|
&IID_IContextMenu, &pcm)))
|
|
{
|
|
CMINVOKECOMMANDINFOEX ici;
|
|
ici.cbSize = SIZEOF(CMINVOKECOMMANDINFOEX);
|
|
ici.fMask = 0L;
|
|
ici.hwnd = hwndOwner;
|
|
ici.lpParameters = NULL;
|
|
ici.lpDirectory = NULL;
|
|
ici.nShow = SW_NORMAL;
|
|
#ifdef UNICODE
|
|
ici.lpVerb = c_szNewFolderAnsi;
|
|
ici.lpVerbW = c_szNewFolder;
|
|
#else
|
|
ici.lpVerb = c_szNewFolder;
|
|
#endif
|
|
|
|
// BUGBUG: Do I need to QueryContextMenu?
|
|
pcm->lpVtbl->InvokeCommand(pcm, (LPCMINVOKECOMMANDINFO)&ici);
|
|
pcm->lpVtbl->Release(pcm);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DFM_CMD_VIEWLIST:
|
|
{
|
|
LPDEFVIEW pdsv = DV_HwndMain2DefView(hwndOwner);
|
|
|
|
SendMessage(pdsv->hwndView, WM_COMMAND, SFVIDM_VIEW_LIST, 0);
|
|
break;
|
|
}
|
|
|
|
case DFM_CMD_VIEWDETAILS:
|
|
{
|
|
LPDEFVIEW pdsv = DV_HwndMain2DefView(hwndOwner);
|
|
|
|
SendMessage(pdsv->hwndView, WM_COMMAND, SFVIDM_VIEW_DETAILS, 0);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// This is one of view menu items, use the default code.
|
|
hres = (S_FALSE);
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
hres = E_NOTIMPL;
|
|
break;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
//
|
|
// Member: CDefView::SelectItem
|
|
//
|
|
STDMETHODIMP CDefView_GetItemObject(IShellView * psv, UINT uItem, REFIID riid, LPVOID *ppv)
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, psv);
|
|
|
|
*ppv = NULL;
|
|
|
|
switch (uItem)
|
|
{
|
|
case SVGIO_BACKGROUND:
|
|
if (IsEqualIID(riid, &IID_IContextMenu))
|
|
{
|
|
return(CDefFolderMenu_Create(NULL,
|
|
this->hwndMain,
|
|
0, NULL,
|
|
this->pshf,
|
|
DefView_DFMCallBackBG,
|
|
NULL, NULL,
|
|
(IContextMenu **)ppv));
|
|
}
|
|
break;
|
|
|
|
case SVGIO_ALLVIEW:
|
|
if (this->hwndStatic)
|
|
{
|
|
DECLAREWAITCURSOR;
|
|
|
|
SetWaitCursor();
|
|
|
|
do
|
|
{
|
|
// If hwndStatic is around, we must be filling the
|
|
// view in a background thread, so we will peek for
|
|
// messages to it (so SendMessages will get through)
|
|
// and dispatch only hwndStatic messages so we get the
|
|
// animation effect.
|
|
// Note there is no timeout, so this could take
|
|
// a while on a slow link, but there really isn't
|
|
// much else I can do
|
|
|
|
MSG msg;
|
|
|
|
// Since hwndStatic can only be destroyed on a DESTROYSTATIC
|
|
// message, we should never get a RIP
|
|
if (PeekMessage(&msg, this->hwndView, WM_DSV_DESTROYSTATIC,
|
|
WM_DSV_DESTROYSTATIC, PM_REMOVE)
|
|
|| PeekMessage(&msg, this->hwndStatic, 0, 0,
|
|
PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
} while (this->hwndStatic);
|
|
|
|
ResetWaitCursor();
|
|
}
|
|
|
|
// Fall through
|
|
|
|
case SVGIO_SELECTION:
|
|
return(DefView_GetUIObjectFromItem(this, riid, ppv, uItem));
|
|
}
|
|
|
|
return(E_NOTIMPL);
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
// Constructor of CDefView class
|
|
//===========================================================================
|
|
#pragma data_seg(".text", "CODE")
|
|
IShellViewVtbl c_DefViewVtbl =
|
|
{
|
|
CDefView_QueryInterface,
|
|
CDefView_AddRef,
|
|
CDefView_Release,
|
|
|
|
CDefView_GetWindow,
|
|
CDefView_ContextSensitiveHelp,
|
|
CDefView_TranslateAccelerator,
|
|
CDefView_EnableModeless,
|
|
CDefView_UIActivate,
|
|
CDefView_Refresh,
|
|
|
|
CDefView_CreateViewWindow,
|
|
CDefView_DestroyViewWindow,
|
|
CDefView_GetCurrentInfo,
|
|
CDefView_AddPropertySheetPages,
|
|
CDefView_SaveViewState,
|
|
CDefView_SelectItem,
|
|
CDefView_GetItemObject,
|
|
};
|
|
|
|
//=============================================================================
|
|
// CDVDropTarget : member prototypes
|
|
//=============================================================================
|
|
STDMETHODIMP CDVDropTarget_QueryInterface(LPDROPTARGET pdt, REFIID riid, LPVOID * ppvObj);
|
|
STDMETHODIMP_(ULONG) CDVDropTarget_AddRef(LPDROPTARGET pdt);
|
|
STDMETHODIMP_(ULONG) CDVDropTarget_Release(LPDROPTARGET pdt);
|
|
STDMETHODIMP CDVDropTarget_DragEnter(LPDROPTARGET pdt, LPDATAOBJECT pdtobj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
|
|
STDMETHODIMP CDVDropTarget_DragOver(LPDROPTARGET pdt, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
|
|
STDMETHODIMP CDVDropTarget_DragLeave(LPDROPTARGET pdt);
|
|
STDMETHODIMP CDVDropTarget_Drop(LPDROPTARGET pdt, LPDATAOBJECT pdtobj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
|
|
|
|
//=============================================================================
|
|
// CDVDropTarget : VTable
|
|
//=============================================================================
|
|
IDropTargetVtbl c_CDVDropTarget = {
|
|
CDVDropTarget_QueryInterface,
|
|
CDVDropTarget_AddRef,
|
|
CDVDropTarget_Release,
|
|
CDVDropTarget_DragEnter,
|
|
CDVDropTarget_DragOver,
|
|
CDVDropTarget_DragLeave,
|
|
CDVDropTarget_Drop
|
|
};
|
|
#pragma data_seg()
|
|
|
|
HRESULT _CreateShellFolderView(LPSHELLFOLDER pshf, LPCITEMIDLIST pidl, LONG lEvents, LPSHELLVIEW * ppsv)
|
|
{
|
|
LPDEFVIEW pdsv = (void*)LocalAlloc(LPTR, SIZEOF(*pdsv));
|
|
|
|
if (!pdsv)
|
|
{
|
|
*ppsv = NULL;
|
|
return E_OUTOFMEMORY; // error
|
|
}
|
|
|
|
pdsv->sv.lpVtbl = &c_DefViewVtbl;
|
|
pdsv->dvdt.dt.lpVtbl = &c_CDVDropTarget;
|
|
pdsv->cRef = 1;
|
|
|
|
pshf->lpVtbl->AddRef(pshf);
|
|
pdsv->pshf = pshf;
|
|
pdsv->pidlMonitor = pidl;
|
|
pdsv->lFSEvents = lEvents;
|
|
pdsv->dvState.iDirection = 1;
|
|
pdsv->dvState.iLastColumnClick = -1;
|
|
pdsv->cRefForIdle = -1;
|
|
pdsv->dwAttrSel = (DWORD)-1;
|
|
//
|
|
// LPTR contains LMEM_ZEROINIT
|
|
// pdsv->psvOuter = NULL;
|
|
// pdsv->psi = NULL;
|
|
// pdsv->dvState.lParamSort = 0;
|
|
// pdsv->psd = NULL;
|
|
// pdsv->pcmSel = NULL;
|
|
// pdsv->pfnCallback = NULL;
|
|
//
|
|
|
|
*ppsv = &pdsv->sv;
|
|
|
|
++gp_dvp.cRef;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT WINAPI SHCreateShellFolderViewEx(LPCSFV pcsfv, LPSHELLVIEW * ppsv)
|
|
{
|
|
HRESULT hres = (E_INVALIDARG);
|
|
Assert(pcsfv);
|
|
Assert(ppsv);
|
|
|
|
if (pcsfv)
|
|
{
|
|
Assert(SIZEOF(*pcsfv) == pcsfv->cbSize);
|
|
|
|
hres = _CreateShellFolderView(pcsfv->pshf, pcsfv->pidl, pcsfv->lEvents, ppsv);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
LPDEFVIEW this = IToClass(CDefView, sv, *ppsv);
|
|
this->psvOuter = pcsfv->psvOuter;
|
|
this->pfnCallback = pcsfv->pfnCallback;
|
|
this->fs.ViewMode = pcsfv->fvm;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
//===========================================================================
|
|
// Drag & Drop
|
|
//===========================================================================
|
|
|
|
|
|
void CDVDropTarget_LeaveAndReleaseData(LPDEFVIEW this)
|
|
{
|
|
this->dvdt.dt.lpVtbl->DragLeave(&this->dvdt.dt);
|
|
|
|
if (this->pdtobjHdrop)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - releasing 3.1 HDROP data object"));
|
|
|
|
this->pdtobjHdrop->lpVtbl->Release(this->pdtobjHdrop);
|
|
this->pdtobjHdrop = NULL;
|
|
}
|
|
}
|
|
|
|
void DV_DropFiles(LPDEFVIEW this, HDROP hdrop)
|
|
{
|
|
if (this->pdtobjHdrop)
|
|
{
|
|
DWORD dwEffect = DROPEFFECT_COPY;
|
|
POINT pt;
|
|
POINTL ptl;
|
|
// hdrop becomes owned by this data object, it will free it
|
|
HRESULT hres = DataObj_SetGlobal(this->pdtobjHdrop, CF_HDROP, hdrop);
|
|
|
|
// we created this data object so this should not fail
|
|
Assert(SUCCEEDED(hres));
|
|
|
|
DragQueryPoint(hdrop, &pt); // in client coords of window dropped on
|
|
ClientToScreen(this->hwndListview, &pt);
|
|
|
|
ptl.x = pt.x;
|
|
ptl.y = pt.y;
|
|
|
|
// MK_LBUTTON means treat as a default drop
|
|
this->dvdt.dt.lpVtbl->Drop(&this->dvdt.dt, this->pdtobjHdrop, MK_LBUTTON, ptl, &dwEffect);
|
|
|
|
CDVDropTarget_LeaveAndReleaseData(this);
|
|
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("sh ER - WM_DROPFILES with no pdtgt or no pdtobjHDrop"));
|
|
DragFinish(hdrop); // be sure to free this
|
|
}
|
|
}
|
|
|
|
//
|
|
// This function processes win 3.1 Drag & Drop messages
|
|
//
|
|
LRESULT DV_OldDragMsgs(LPDEFVIEW this, UINT uMsg, WPARAM wParam, const DROPSTRUCT * lpds)
|
|
{
|
|
DWORD dwEffect = DROPEFFECT_COPY;
|
|
//
|
|
// We don't need to do this hack if NT defined POINT as typedef POINTL.
|
|
//
|
|
union {
|
|
POINT ptScreen;
|
|
POINTL ptlScreen;
|
|
} drop;
|
|
|
|
Assert(SIZEOF(drop.ptScreen)==SIZEOF(drop.ptlScreen));
|
|
|
|
if (lpds) // Notes: lpds is NULL, if uMsg is WM_DROPFILES.
|
|
{
|
|
drop.ptScreen = lpds->ptDrop;
|
|
ClientToScreen(this->hwndMain, &drop.ptScreen);
|
|
}
|
|
|
|
switch (uMsg) {
|
|
case WM_DRAGSELECT:
|
|
// WM_DRAGSELECT is sent to a sink whenever an new object is dragged inside of it.
|
|
// wParam: TRUE if the sink is being entered, FALSE if it's being exited.
|
|
|
|
if (wParam)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("3.1 drag enter"));
|
|
|
|
if (this->pdtobjHdrop)
|
|
{
|
|
// can happen if old target fails to generate drag leave properly
|
|
DebugMsg(DM_TRACE, TEXT("generating DragLeave on old drag enter"));
|
|
CDVDropTarget_LeaveAndReleaseData(this);
|
|
}
|
|
|
|
if (SUCCEEDED(CIDLData_CreateFromIDArray(NULL, 0, NULL, &this->pdtobjHdrop)))
|
|
{
|
|
// promise the CF_HDROP by setting a NULL handle
|
|
// indicating that this dataobject will have an hdrop at Drop() time
|
|
|
|
DataObj_SetGlobal(this->pdtobjHdrop, CF_HDROP, (HGLOBAL)NULL);
|
|
|
|
this->dvdt.dt.lpVtbl->DragEnter(&this->dvdt.dt, this->pdtobjHdrop, MK_LBUTTON, drop.ptlScreen, &dwEffect);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("3.1 drag leave"));
|
|
|
|
CDVDropTarget_LeaveAndReleaseData(this);
|
|
}
|
|
break;
|
|
|
|
case WM_DRAGMOVE:
|
|
// WM_DRAGMOVE is sent to a sink as the object is being dragged within it.
|
|
// wParam: Unused
|
|
if (this->pdtobjHdrop)
|
|
{
|
|
this->dvdt.dt.lpVtbl->DragOver(&this->dvdt.dt, MK_LBUTTON, drop.ptlScreen, &dwEffect);
|
|
}
|
|
break;
|
|
|
|
case WM_QUERYDROPOBJECT:
|
|
|
|
switch (lpds->wFmt) {
|
|
case DOF_SHELLDATA:
|
|
case DOF_DIRECTORY:
|
|
case DOF_DOCUMENT:
|
|
case DOF_MULTIPLE:
|
|
case DOF_EXECUTABLE:
|
|
#if 0
|
|
// this works, but it flashes the cursor a lot. don't bother with this now...
|
|
if (this->pdtobjHdrop)
|
|
{
|
|
// REVIEW: we could construct MK_LEFTBUTTON
|
|
return SUCCEEDED(this->dvdt.dt.lpVtbl->DragOver(&this->dvdt.dt, MK_LBUTTON, drop.ptlScreen, &dwEffect)) && dwEffect;
|
|
}
|
|
#endif
|
|
// assume all targets can accept HDROP if we don't have the data object yet
|
|
return TRUE; // we will accept the drop
|
|
}
|
|
return FALSE; // don't accept
|
|
|
|
case WM_DROPOBJECT:
|
|
if (!this->pdtobjHdrop)
|
|
return FALSE;
|
|
|
|
// Check the format of dragged object.
|
|
switch (lpds->wFmt) {
|
|
case DOF_EXECUTABLE:
|
|
case DOF_DOCUMENT:
|
|
case DOF_DIRECTORY:
|
|
case DOF_MULTIPLE:
|
|
case DOF_PROGMAN:
|
|
case DOF_SHELLDATA:
|
|
// We need to unlock this window if this drag&drop is originated
|
|
// from the shell itself.
|
|
DAD_DragLeave();
|
|
|
|
// The source is Win 3.1 app (probably FileMan), request HDROP.
|
|
return DO_DROPFILE; // Send us a WM_DROPFILES with HDROP
|
|
}
|
|
break;
|
|
|
|
case WM_DROPFILES:
|
|
DV_DropFiles(this, (HDROP)wParam);
|
|
break;
|
|
}
|
|
|
|
return 0; // Unknown format. Don't drop any
|
|
}
|
|
|
|
//=============================================================================
|
|
// CDVDropTarget : member
|
|
//=============================================================================
|
|
STDMETHODIMP CDVDropTarget_QueryInterface(LPDROPTARGET pdt, REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
Assert(pdv->sv.lpVtbl->QueryInterface == CDefView_QueryInterface);
|
|
return CDefView_QueryInterface(&pdv->sv, riid, ppvObj);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDVDropTarget_AddRef(LPDROPTARGET pdt)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
Assert(pdv->sv.lpVtbl->AddRef == CDefView_AddRef);
|
|
return CDefView_AddRef(&pdv->sv);
|
|
}
|
|
|
|
void CDVDropTarget_ReleaseDataObject(CDVDropTarget * this)
|
|
{
|
|
if (this->pdtobj)
|
|
{
|
|
//
|
|
// JUST-IN-CASE: Put NULL in this->pdtobj before we release it.
|
|
// We do this just in case because we don't know what OLE does
|
|
// from inside Release (it might call back one of our members).
|
|
//
|
|
LPDATAOBJECT pdtobj = this->pdtobj;
|
|
this->pdtobj = NULL;
|
|
pdtobj->lpVtbl->Release(pdtobj);
|
|
}
|
|
}
|
|
|
|
void CDVDropTarget_ReleaseCurrentDropTarget(CDVDropTarget * this)
|
|
{
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
if (this->pdtgtCur)
|
|
{
|
|
this->pdtgtCur->lpVtbl->DragLeave(this->pdtgtCur);
|
|
this->pdtgtCur->lpVtbl->Release(this->pdtgtCur);
|
|
this->pdtgtCur = NULL;
|
|
}
|
|
pdv->itemCur = -2;
|
|
|
|
// WARNING: Never touch pdv->itemOver in this function.
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CDVDropTarget_Release(LPDROPTARGET pdt)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
UINT cRef;
|
|
|
|
Assert(pdv->sv.lpVtbl->Release == CDefView_Release);
|
|
|
|
cRef = CDefView_Release(&pdv->sv);
|
|
|
|
#ifdef DEBUG
|
|
if (cRef == 0)
|
|
{
|
|
AssertMsg(this->pdtobj == NULL, TEXT("didn't get matching DragLeave"));
|
|
}
|
|
#endif
|
|
return cRef;
|
|
}
|
|
|
|
STDMETHODIMP CDVDropTarget_DragEnter(LPDROPTARGET pdt, LPDATAOBJECT pdtobj, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
POINT pt;
|
|
HWND hwndLock;
|
|
|
|
g_fDraggingOverSource = FALSE;
|
|
|
|
DebugMsg(DM_TRACE, TEXT("sh - TR CDVDropTarget::DragEnter with *pdwEffect=%x"), *pdwEffect);
|
|
|
|
Assert(this->pdtobj == NULL);
|
|
|
|
pdtobj->lpVtbl->AddRef(pdtobj);
|
|
this->pdtobj = pdtobj;
|
|
this->grfKeyState = grfKeyState;
|
|
|
|
Assert(this->pdtgtCur == NULL);
|
|
// don't really need to do this, but this sets the target state
|
|
CDVDropTarget_ReleaseCurrentDropTarget(this);
|
|
this->itemOver = -2;
|
|
|
|
//
|
|
// In case of Desktop, we should not lock the enter screen.
|
|
//
|
|
hwndLock = DV_ISDESKTOP(pdv) ? pdv->hwndListview : pdv->hwndMain;
|
|
GetWindowRect(hwndLock, &this->rcLockWindow);
|
|
pt.x = ptl.x-this->rcLockWindow.left;
|
|
pt.y = ptl.y-this->rcLockWindow.top;
|
|
DAD_DragEnterEx(hwndLock, pt);
|
|
|
|
DAD_InitScrollData(&this->asd);
|
|
|
|
this->ptLast.x = this->ptLast.y = 0x7fffffff; // put bogus value to force redraw
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// Returns: if the cursor is over a listview item, its index; otherwise, -1.
|
|
//
|
|
int DV_GetDropTarget(LPDEFVIEW pdsv, const POINT *ppt)
|
|
{
|
|
LV_HITTESTINFO info;
|
|
|
|
info.pt = *ppt;
|
|
return ListView_HitTest(pdsv->hwndListview, &info);
|
|
}
|
|
|
|
#define DVAE_BEFORE 0x01
|
|
#define DVAE_AFTER 0x02
|
|
|
|
// this MUST set pdwEffect to 0 or DROPEFFECT_MOVE if it's a default drag drop
|
|
// in the same window
|
|
void DV_AlterEffect(LPDEFVIEW pdv, DWORD grfKeyState, DWORD *pdwEffect, UINT uFlags)
|
|
{
|
|
//
|
|
// Check if we are dragginv over the drag source itself.
|
|
//
|
|
g_fDraggingOverSource = FALSE;
|
|
|
|
if (DV_IsDropOnSource(pdv, NULL))
|
|
{
|
|
// Yes.
|
|
//
|
|
// Check if we are in icon mode or not.
|
|
//
|
|
if ((pdv->fs.ViewMode != FVM_DETAILS) && (pdv->fs.ViewMode != FVM_LIST))
|
|
{
|
|
// Yes.
|
|
//
|
|
// If this is default drag&drop, enable move.
|
|
//
|
|
if (uFlags & DVAE_AFTER) {
|
|
if (grfKeyState & MK_LBUTTON)
|
|
{
|
|
if (!(grfKeyState & MK_CONTROL) &&
|
|
!(grfKeyState & MK_SHIFT))
|
|
{
|
|
*pdwEffect = DROPEFFECT_MOVE;
|
|
g_fDraggingOverSource = TRUE;
|
|
}
|
|
} else if (grfKeyState & MK_RBUTTON) {
|
|
*pdwEffect |= DROPEFFECT_MOVE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (uFlags & DVAE_BEFORE) {
|
|
// No. Disable move.
|
|
*pdwEffect &= ~DROPEFFECT_MOVE;
|
|
|
|
//
|
|
// If this is default drag&drop, disable all.
|
|
//
|
|
if (grfKeyState & MK_LBUTTON)
|
|
{
|
|
*pdwEffect = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CDVDropTarget_DragOver(LPDROPTARGET pdt, DWORD grfKeyState, POINTL ptl, LPDWORD pdwEffect)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
int itemNew;
|
|
POINT pt = { ptl.x, ptl.y }; // in screen coords
|
|
RECT rc;
|
|
BOOL fInRect;
|
|
DWORD dwEffectScroll = 0;
|
|
DWORD dwEffectOut = 0;
|
|
BOOL fSameImage = FALSE;
|
|
|
|
if (this->pdtobj == NULL)
|
|
{
|
|
Assert(0); // DragEnter should be called before.
|
|
return (E_FAIL);
|
|
}
|
|
|
|
GetWindowRect(pdv->hwndListview, &rc);
|
|
fInRect = PtInRect(&rc, pt);
|
|
|
|
ScreenToClient(pdv->hwndListview, &pt);
|
|
|
|
// assume coords of our window match listview
|
|
if (DAD_AutoScroll(pdv->hwndListview, &this->asd, &pt))
|
|
dwEffectScroll = DROPEFFECT_SCROLL;
|
|
|
|
// hilight an item, or unhilight all items (DropTarget returns -1)
|
|
if (fInRect)
|
|
itemNew = DV_GetDropTarget(pdv, &pt);
|
|
else
|
|
itemNew = -1;
|
|
|
|
//
|
|
// If we are dragging over on a different item, get its IDropTarget
|
|
// interface or adjust itemNew to -1.
|
|
//
|
|
if (this->itemOver != itemNew)
|
|
{
|
|
LPDROPTARGET pdtgtNew = NULL;
|
|
this->itemOver = itemNew;
|
|
|
|
// Avoid dropping onto drag source objects.
|
|
if ((itemNew != -1) && pdv->bDragSource)
|
|
{
|
|
UINT uState = ListView_GetItemState(pdv->hwndListview, itemNew, LVIS_SELECTED);
|
|
if (uState & LVIS_SELECTED)
|
|
itemNew = -1;
|
|
}
|
|
|
|
// If we are dragging over an item, try to get its IDropTarget.
|
|
if (itemNew != -1)
|
|
{
|
|
// We are dragging over an item.
|
|
LPCITEMIDLIST apidl[1] = { DSV_GetPIDL(pdv, itemNew) };
|
|
UINT dwAttr = SFGAO_DROPTARGET;
|
|
hres = pdv->pshf->lpVtbl->GetAttributesOf(pdv->pshf, 1, apidl, &dwAttr);
|
|
if (SUCCEEDED(hres) && (dwAttr & SFGAO_DROPTARGET))
|
|
{
|
|
hres = pdv->pshf->lpVtbl->GetUIObjectOf(pdv->pshf,
|
|
pdv->hwndMain, 1, apidl, &IID_IDropTarget, NULL, &pdtgtNew);
|
|
|
|
Assert(itemNew != pdv->itemCur); // MUST not be the same
|
|
}
|
|
|
|
if (pdtgtNew==NULL) {
|
|
// If the item is not a drop target, don't hightlight it
|
|
// treat it as transparent.
|
|
itemNew = -1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the new target is different from the current one, switch it.
|
|
//
|
|
if (pdv->itemCur != itemNew)
|
|
{
|
|
// Release previous drop target, if any.
|
|
CDVDropTarget_ReleaseCurrentDropTarget(this);
|
|
Assert(this->pdtgtCur==NULL);
|
|
|
|
// Update pdv->itemCur which indicates the current target.
|
|
// (Note that it might be different from this->itemOver).
|
|
pdv->itemCur = itemNew;
|
|
|
|
// If we are dragging over the background or over non-sink item,
|
|
// get the drop target for the folder.
|
|
if (itemNew == -1)
|
|
{
|
|
// We are dragging over the background, this can be NULL
|
|
Assert(pdtgtNew == NULL);
|
|
this->pdtgtCur = pdv->pdtgtBack;
|
|
if (this->pdtgtCur)
|
|
this->pdtgtCur->lpVtbl->AddRef(this->pdtgtCur);
|
|
}
|
|
else
|
|
{
|
|
Assert(pdtgtNew);
|
|
this->pdtgtCur = pdtgtNew;
|
|
}
|
|
|
|
// Hilight the sink item (itemNew != -1) or unhilight all (-1).
|
|
LVUtil_DragSelectItem(pdv->hwndListview, itemNew);
|
|
|
|
|
|
// Call IDropTarget::DragEnter of the target object.
|
|
if (this->pdtgtCur)
|
|
{
|
|
//
|
|
// Note that pdwEffect is in/out parameter.
|
|
//
|
|
dwEffectOut = *pdwEffect; // pdwEffect in
|
|
|
|
// Special case if we are dragging within a source window
|
|
DV_AlterEffect(pdv, grfKeyState, &dwEffectOut, DVAE_BEFORE);
|
|
hres = this->pdtgtCur->lpVtbl->DragEnter(this->pdtgtCur, this->pdtobj, grfKeyState, ptl, &dwEffectOut);
|
|
DV_AlterEffect(pdv, grfKeyState, &dwEffectOut, DVAE_AFTER);
|
|
}
|
|
else
|
|
{
|
|
Assert(dwEffectOut==0);
|
|
DV_AlterEffect(pdv, grfKeyState, &dwEffectOut, DVAE_BEFORE | DVAE_AFTER);
|
|
}
|
|
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - CDV::DragOver dwEIn=%x, dwEOut=%x"), *pdwEffect, dwEffectOut);
|
|
}
|
|
else
|
|
{
|
|
Assert(pdtgtNew == NULL); // It must be NULL
|
|
goto NoChange;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NoChange:
|
|
//
|
|
// No change in the selection. We assume that *pdwEffect stays
|
|
// the same during the same drag-loop as long as the key state doesn't change.
|
|
//
|
|
if ((this->grfKeyState != grfKeyState) && this->pdtgtCur)
|
|
{
|
|
//
|
|
// Note that pdwEffect is in/out parameter.
|
|
//
|
|
dwEffectOut = *pdwEffect; // pdwEffect in
|
|
// Special case if we are dragging within a source window
|
|
DV_AlterEffect(pdv, grfKeyState, &dwEffectOut, DVAE_BEFORE);
|
|
hres = this->pdtgtCur->lpVtbl->DragOver(this->pdtgtCur, grfKeyState, ptl, &dwEffectOut);
|
|
DV_AlterEffect(pdv, grfKeyState, &dwEffectOut, DVAE_AFTER);
|
|
|
|
} else {
|
|
//
|
|
// Same item and same key state. Use the previous dwEffectOut.
|
|
//
|
|
dwEffectOut = this->dwEffectOut;
|
|
fSameImage = TRUE;
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
this->grfKeyState = grfKeyState; // store these for the next Drop
|
|
this->dwEffectOut = dwEffectOut; // and DragOver
|
|
|
|
//
|
|
// HACK ALERT:
|
|
// OLE does not call IDropTarget::Drop if we return something
|
|
// valid. We force OLE call it by returning DROPEFFECT_SCROLL.
|
|
//
|
|
if (g_fDraggingOverSource) {
|
|
dwEffectScroll = DROPEFFECT_SCROLL;
|
|
}
|
|
|
|
*pdwEffect = dwEffectOut | dwEffectScroll; // pdwEffect out
|
|
|
|
// We need pass pt relative to the locked window (not the client).
|
|
pt.x = ptl.x-this->rcLockWindow.left;
|
|
pt.y = ptl.y-this->rcLockWindow.top;
|
|
|
|
if (!(fSameImage && pt.x==this->ptLast.x && pt.y==this->ptLast.y))
|
|
{
|
|
DAD_DragMove(pt);
|
|
this->ptLast.x = pt.x;
|
|
this->ptLast.y = pt.y;
|
|
}
|
|
|
|
// DebugMsg(DM_TRACE, "sh TR - CDVDropTarget_DragOver dwEffect:%4x hres:%d", *pdwEffect, hres);
|
|
|
|
return hres;
|
|
}
|
|
|
|
STDMETHODIMP CDVDropTarget_DragLeave(LPDROPTARGET pdt)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
|
|
//
|
|
// Make it possible to call it more than necessary.
|
|
//
|
|
if (this->pdtobj)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh - TR CDVDropTarget::DragLeave"));
|
|
|
|
CDVDropTarget_ReleaseCurrentDropTarget(this);
|
|
this->itemOver = -2;
|
|
CDVDropTarget_ReleaseDataObject(this);
|
|
|
|
DAD_DragLeave();
|
|
LVUtil_DragSelectItem(pdv->hwndListview, -1);
|
|
}
|
|
|
|
g_fDraggingOverSource = FALSE;
|
|
|
|
Assert(this->pdtgtCur == NULL);
|
|
Assert(this->pdtobj == NULL);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDVDropTarget_Drop(LPDROPTARGET pdt, LPDATAOBJECT pdtobj,
|
|
DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
|
|
{
|
|
CDVDropTarget * this = IToClass(CDVDropTarget, dt, pdt);
|
|
LPDEFVIEW pdv = IToClass(CDefView, dvdt, this);
|
|
HRESULT hres = S_OK;
|
|
BOOL bDropHandled = FALSE;
|
|
|
|
DebugMsg(DM_TRACE, TEXT("sh - TR CDVDropTarget::Drop (*pdwEffect=%x)"), *pdwEffect);
|
|
|
|
//
|
|
// According to AlexGo (OLE), this is by-design. We should make it sure
|
|
// that we use pdtobj instead of this->pdtobj.
|
|
//
|
|
#if 0
|
|
Assert(pdtobj == this->pdtobj);
|
|
#else
|
|
this->pdtobj = pdtobj;
|
|
#endif
|
|
|
|
pdv->ptDrop.x = pt.x;
|
|
pdv->ptDrop.y = pt.y;
|
|
|
|
ScreenToClient(pdv->hwndListview, &pdv->ptDrop);
|
|
|
|
//
|
|
// handle moves within the same window here.
|
|
// depend on DV_AlterEffect forcing in DROPEFFECT_MOVE and only
|
|
// dropeffect move when drag in same window
|
|
//
|
|
// Notes: We need to use this->grfKeyState instead of grfKeyState
|
|
// to see if the left mouse was used or not during dragging.
|
|
//
|
|
DV_AlterEffect(pdv, this->grfKeyState, pdwEffect, DVAE_BEFORE|DVAE_AFTER);
|
|
|
|
if ((this->grfKeyState & MK_LBUTTON) && (*pdwEffect == DROPEFFECT_MOVE) &&
|
|
(DV_IsDropOnSource(pdv, NULL)))
|
|
{
|
|
// This means we are left-dropping on ourselves, so we just move
|
|
// the icons.
|
|
pdv->bDropAnchor = TRUE;
|
|
DAD_DragLeave();
|
|
DV_MoveIcons(pdv, pdtobj);
|
|
SetForegroundWindow(pdv->hwndMain);
|
|
pdv->bDropAnchor = FALSE;
|
|
bDropHandled = TRUE;
|
|
*pdwEffect = 0; // the underlying objects didn't 'move' anywhere
|
|
}
|
|
|
|
//
|
|
// Note that we don't use the drop position intentionally,
|
|
// so that it matches to the last destination feedback.
|
|
//
|
|
if (this->pdtgtCur)
|
|
{
|
|
|
|
// use this local because if pdtgtCur::Drop does a UnlockWindow
|
|
// then hits an error and needs to put up a dialog,
|
|
// we could get re-entered and clobber the defview's pdtgtCur
|
|
LPDROPTARGET pdtgtCur = this->pdtgtCur;
|
|
this->pdtgtCur = NULL;
|
|
//
|
|
// HACK ALERT!!!!
|
|
//
|
|
// If we don't call LVUtil_DragEnd here, we'll be able to leave
|
|
// dragged icons visible when the menu is displayed. However, because
|
|
// we are calling IDropTarget::Drop() which may create some modeless
|
|
// dialog box or something, we can not ensure the locked state of
|
|
// the list view -- LockWindowUpdate() can lock only one window at
|
|
// a time. Therefore, we skip this call only if the pdtgtCur
|
|
// is a subclass of CIDLDropTarget, assuming its Drop calls
|
|
// CDefView_DragEnd (or CIDLDropTarget_DragDropMenu) appropriately.
|
|
//
|
|
if (!bDropHandled)
|
|
{
|
|
pdv->bDropAnchor = TRUE;
|
|
|
|
if (!ISIDLDROPTARGET(pdtgtCur))
|
|
{
|
|
//
|
|
// This will hide the dragged image.
|
|
//
|
|
DAD_DragLeave();
|
|
|
|
//
|
|
// We need to reset the drag image list so that the user
|
|
// can start another drag&drop while we are in this
|
|
// Drop() member function call.
|
|
//
|
|
DAD_SetDragImage(NULL, NULL);
|
|
}
|
|
|
|
// Special case if we are dragging within a source window
|
|
DV_AlterEffect(pdv, grfKeyState, pdwEffect, DVAE_BEFORE|DVAE_AFTER);
|
|
|
|
pdtgtCur->lpVtbl->Drop(pdtgtCur, pdtobj, grfKeyState, pt, pdwEffect);
|
|
DAD_DragLeave();
|
|
|
|
bDropHandled = TRUE;
|
|
pdv->bDropAnchor = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// match the drag enter
|
|
pdtgtCur->lpVtbl->DragLeave(pdtgtCur);
|
|
}
|
|
|
|
pdtgtCur->lpVtbl->Release(pdtgtCur);
|
|
|
|
//
|
|
// Assert if (ISIDLDROPTARGET(this->pdtgtCur)
|
|
// && IDropTarget::Drop did not call CDefView_UnlockWindow())
|
|
//
|
|
Assert(!DAD_IsDragging());
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We come here if Drop is called without DragMove (with DragEnter).
|
|
//
|
|
DebugMsg(DM_TRACE, TEXT("CDV::Drop this->pdtgtCur == 0"));
|
|
*pdwEffect = 0;
|
|
}
|
|
|
|
//
|
|
// Clean up everything (OLE won't call DragLeave after Drop).
|
|
//
|
|
CDVDropTarget_DragLeave(pdt);
|
|
|
|
return hres;
|
|
}
|
|
|
|
//
|
|
// HACK ALERT!!! (see CDVDropTarget_Drop as well)
|
|
//
|
|
// All the subclasses of CIDLDropTarget MUST call this function from
|
|
// within its Drop() member function. Calling CIDLDropTarget_DragDropMenu()
|
|
// is sufficient because it calls CDefView_UnlockWindow.
|
|
//
|
|
|
|
// lego... make this a #define in defview.h
|
|
#ifndef CDefView_UnlockWindow
|
|
void CDefView_UnlockWindow()
|
|
{
|
|
DAD_DragLeave();
|
|
}
|
|
#endif
|
|
|
|
LPDEFVIEW WINAPI DV_HwndMain2DefView(HWND hwndMain)
|
|
{
|
|
LPDEFVIEW pdsv = NULL;
|
|
LPSHELLBROWSER psb = FileCabinet_GetIShellBrowser(hwndMain);
|
|
if (psb)
|
|
{
|
|
LPSHELLVIEW psv;
|
|
if (SUCCEEDED(psb->lpVtbl->QueryActiveShellView(psb, &psv)))
|
|
{
|
|
if (psv->lpVtbl->QueryInterface == CDefView_QueryInterface)
|
|
{
|
|
pdsv = IToClass(CDefView, sv, psv);
|
|
}
|
|
else if (psv->lpVtbl->QueryInterface)
|
|
{
|
|
// We might have the psvOuter, query for the pdsv
|
|
LPSHELLVIEW psvInner;
|
|
if (SUCCEEDED(psv->lpVtbl->QueryInterface(psv, &IID_IShellView, &psvInner)))
|
|
{
|
|
pdsv = IToClass(CDefView, sv, psvInner);
|
|
psv->lpVtbl->Release(psv);
|
|
}
|
|
}
|
|
psv->lpVtbl->Release(psv);
|
|
}
|
|
}
|
|
return pdsv;
|
|
}
|
|
|
|
|
|
HWND WINAPI DV_HwndMain2HwndView(HWND hwndMain)
|
|
{
|
|
LPDEFVIEW pdsv = DV_HwndMain2DefView(hwndMain);
|
|
return pdsv ? pdsv->hwndView : NULL;
|
|
}
|
|
|
|
BOOL DefView_IsBkDropTarget(LPDEFVIEW pdsv, LPDROPTARGET pdtg)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
POINT pt;
|
|
|
|
if (pdsv->bContextMenuMode) {
|
|
if (ListView_GetSelectedCount(pdsv->hwndListview) == 0) {
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
if (!fRet && DefView_GetDropPoint(pdsv, &pt)) {
|
|
// The Drop point is returned in internal listview coordinates
|
|
// space, so we need to convert it back to client space
|
|
// before we call this function...
|
|
|
|
LVUtil_LVToClient(pdsv->hwndListview, &pt);
|
|
if (DV_GetDropTarget(pdsv, &pt) == -1) {
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
LRESULT WINAPI SHShellFolderView_Message(HWND hwndMain, UINT uMsg, LPARAM lParam)
|
|
{
|
|
LPDEFVIEW pdsv = DV_HwndMain2DefView(hwndMain);
|
|
if (!pdsv)
|
|
{
|
|
//
|
|
// DV_HwndMain2DefView fails if we are either closing the view or
|
|
// switchin the view window. In such a case, we simply need to fail.
|
|
//
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - ShellFolderView_Message DV_HwndMain2DefView failes (bogus hwnd or closing/switching view)"));
|
|
return 0;
|
|
}
|
|
|
|
switch (uMsg)
|
|
{
|
|
case SFVM_REARRANGE:
|
|
{
|
|
DECLAREWAITCURSOR;
|
|
pdsv->dvState.lParamSort = lParam;
|
|
|
|
SetWaitCursor();
|
|
DV_ReArrange(pdsv);
|
|
ResetWaitCursor();
|
|
break;
|
|
}
|
|
|
|
case SFVM_ARRANGEGRID:
|
|
DefView_Command(pdsv, NULL, GET_WM_COMMAND_MPS(SFVIDM_ARRANGE_GRID, 0, 0));
|
|
break;
|
|
|
|
case SFVM_AUTOARRANGE:
|
|
DefView_Command(pdsv, NULL, GET_WM_COMMAND_MPS(SFVIDM_ARRANGE_AUTO, 0, 0));
|
|
break;
|
|
|
|
case SFVM_GETAUTOARRANGE:
|
|
return pdsv->fs.fFlags & FWF_AUTOARRANGE;
|
|
|
|
// BUGBUG: not used?
|
|
case SFVM_GETARRANGEPARAM:
|
|
return pdsv->dvState.lParamSort;
|
|
|
|
case SFVM_ADDOBJECT:
|
|
// BUGBUG: Shouldn't this make a copy of the PIDL? Maybe not for
|
|
// performance
|
|
return (LPARAM)DefView_AddObject(pdsv, (LPITEMIDLIST)lParam);
|
|
|
|
case SFVM_GETOBJECTCOUNT:
|
|
return (LPARAM)ListView_GetItemCount(pdsv->hwndListview);
|
|
|
|
case SFVM_GETOBJECT:
|
|
return (LPARAM)DSV_GetPIDL(pdsv, (int)lParam);
|
|
|
|
case SFVM_REMOVEOBJECT:
|
|
return (LPARAM)DefView_RemoveObject(pdsv, (LPITEMIDLIST)lParam, FALSE);
|
|
|
|
case SFVM_UPDATEOBJECT:
|
|
return (LPARAM)DefView_UpdateObject(pdsv, (LPITEMIDLIST *)lParam);
|
|
|
|
case SFVM_REFRESHOBJECT:
|
|
return (LPARAM)DefView_RefreshObject(pdsv, (LPITEMIDLIST *)lParam);
|
|
|
|
case SFVM_SETREDRAW:
|
|
SendMessage(pdsv->hwndListview, WM_SETREDRAW, (WPARAM)lParam, 0);
|
|
break;
|
|
|
|
case SFVM_GETSELECTEDOBJECTS:
|
|
{
|
|
HRESULT hres;
|
|
|
|
hres = DefView_GetItemObjects(pdsv, (LPCITEMIDLIST **)lParam,
|
|
SVGIO_SELECTION);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
return(ResultFromShort(hres));
|
|
}
|
|
else
|
|
{
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
case SFVM_GETSELECTEDCOUNT:
|
|
return (LPARAM)ListView_GetSelectedCount(pdsv->hwndListview);
|
|
|
|
case SFVM_ISDROPONSOURCE:
|
|
return(DV_IsDropOnSource(pdsv, (LPDROPTARGET)lParam));
|
|
|
|
case SFVM_MOVEICONS:
|
|
DV_MoveIcons(pdsv, (LPDATAOBJECT)lParam);
|
|
break;
|
|
|
|
case SFVM_GETDROPPOINT:
|
|
return DefView_GetDropPoint(pdsv, (LPPOINT)lParam);
|
|
|
|
case SFVM_GETDRAGPOINT:
|
|
return DefView_GetDragPoint(pdsv, (LPPOINT)lParam);
|
|
|
|
case SFVM_SETITEMPOS:
|
|
DefView_SetItemPos(pdsv, (LPSFV_SETITEMPOS)lParam);
|
|
break;
|
|
|
|
case SFVM_ISBKDROPTARGET:
|
|
return DefView_IsBkDropTarget(pdsv, (LPDROPTARGET)lParam);
|
|
|
|
case SFVM_SETCLIPBOARD:
|
|
return DSV_OnSetClipboard(pdsv, lParam);
|
|
|
|
case SFVM_SETPOINTS:
|
|
DefView_SetPoints(pdsv, (LPDATAOBJECT)lParam);
|
|
break;
|
|
|
|
case SFVM_GETITEMSPACING:
|
|
return DV_GetItemSpacing(pdsv, (LPITEMSPACING)lParam);
|
|
|
|
default:
|
|
// -1L is the default return value
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
// A common function that given an IShellFolder and and an Idlist that is
|
|
// contained in it, get back the index into the system image list.
|
|
//===========================================================================
|
|
|
|
HRESULT _GetILIndexGivenPXIcon(LPEXTRACTICON pxicon, UINT uFlags, LPCITEMIDLIST pidl, int *piImage, BOOL fAnsiCrossOver)
|
|
{
|
|
TCHAR szIconFile[MAX_PATH];
|
|
#ifdef UNICODE
|
|
CHAR szIconFileA[MAX_PATH];
|
|
IExtractIconA *pxiconA = (IExtractIconA *)pxicon;
|
|
#endif
|
|
int iIndex;
|
|
int iImage = -1;
|
|
UINT wFlags=0;
|
|
HRESULT hres;
|
|
|
|
Assert(himlIcons); // you must initialize the icon cache first
|
|
|
|
#ifdef UNICODE
|
|
if (fAnsiCrossOver)
|
|
{
|
|
szIconFileA[0] = '\0';
|
|
hres = pxiconA->lpVtbl->GetIconLocation(pxiconA, uFlags | GIL_FORSHELL,
|
|
szIconFileA, ARRAYSIZE(szIconFileA), &iIndex, &wFlags);
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
szIconFileA, -1,
|
|
szIconFile, ARRAYSIZE(szIconFile));
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
hres = pxicon->lpVtbl->GetIconLocation(pxicon, uFlags | GIL_FORSHELL,
|
|
szIconFile, ARRAYSIZE(szIconFile), &iIndex, &wFlags);
|
|
#ifdef UNICODE
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// "*" as the file name means iIndex is already a system
|
|
// icon index, we are done.
|
|
//
|
|
// this is a hack for our own internal icon handler
|
|
//
|
|
if (SUCCEEDED(hres) && (wFlags & GIL_NOTFILENAME) &&
|
|
szIconFile[0] == TEXT('*') && szIconFile[1] == 0)
|
|
{
|
|
*piImage = iIndex;
|
|
return hres;
|
|
}
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
//
|
|
// if GIL_DONTCACHE was returned by the icon handler, dont
|
|
// lookup the previous icon, assume a cache miss.
|
|
//
|
|
if (!(wFlags & GIL_DONTCACHE))
|
|
iImage = LookupIconIndex(PathFindFileName(szIconFile), iIndex, wFlags);
|
|
|
|
// if we miss our cache...
|
|
if (iImage == -1)
|
|
{
|
|
HICON hiconLarge=NULL;
|
|
HICON hiconSmall=NULL;
|
|
|
|
// try getting it from the ExtractIcon member fuction
|
|
#ifdef UNICODE
|
|
if (fAnsiCrossOver)
|
|
{
|
|
hres=pxiconA->lpVtbl->Extract(pxiconA, szIconFileA, iIndex,
|
|
&hiconLarge, &hiconSmall, MAKELONG(g_cxIcon, g_cxSmIcon));
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
hres=pxicon->lpVtbl->Extract(pxicon, szIconFile, iIndex,
|
|
&hiconLarge, &hiconSmall, MAKELONG(g_cxIcon, g_cxSmIcon));
|
|
#ifdef UNICODE
|
|
}
|
|
#endif
|
|
// S_FALSE means, can you please do it...Thanks
|
|
|
|
if (hres == S_FALSE)
|
|
{
|
|
hres = SHDefExtractIcon(szIconFile, iIndex, wFlags,
|
|
&hiconLarge, &hiconSmall, MAKELONG(g_cxIcon, g_cxSmIcon));
|
|
}
|
|
|
|
// if we extracted a icon add it to the cache.
|
|
|
|
if (hiconLarge)
|
|
{
|
|
// yes! got it, stuff it into our cache
|
|
iImage = SHAddIconsToCache(hiconLarge, hiconSmall, szIconFile, iIndex, wFlags);
|
|
}
|
|
|
|
// if we failed in any way pick a default icon
|
|
|
|
if (iImage == -1)
|
|
{
|
|
int iIcon;
|
|
|
|
if (wFlags & GIL_SIMULATEDOC)
|
|
iIcon = II_DOCUMENT;
|
|
else if ((wFlags & GIL_PERINSTANCE) && PathIsExe(szIconFile))
|
|
iIcon = II_APPLICATION;
|
|
else
|
|
iIcon = II_DOCNOASSOC;
|
|
|
|
iIndex = Shell_GetCachedImageIndex(szIconFile, iIcon, 0);
|
|
|
|
// if the handler failed dont cache this default icon.
|
|
// so we will try again later and mabey get the right icon.
|
|
//
|
|
// handlers should only fail if they cant access the file
|
|
// or something equaly bad.
|
|
|
|
if (SUCCEEDED(hres))
|
|
//
|
|
// Pretend that we were able to extract this from that file
|
|
//
|
|
AddToIconTable(szIconFile, iIndex, wFlags, iImage);
|
|
else
|
|
DebugMsg(DM_TRACE, TEXT("not caching icon for '%s' because cant access file"), szIconFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iImage < 0)
|
|
iImage = Shell_GetCachedImageIndex(c_szShell32Dll,
|
|
II_DOCNOASSOC, 0);
|
|
|
|
*piImage = iImage;
|
|
return hres;
|
|
}
|
|
|
|
//===========================================================================
|
|
// A common function that given an IShellFolder and and an Idlist that is
|
|
// contained in it, get back the index into the system image list.
|
|
//===========================================================================
|
|
|
|
HRESULT SHGetIconFromPIDL(IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, int *piImage)
|
|
{
|
|
IExtractIcon *pxi;
|
|
HRESULT hres;
|
|
|
|
Assert(himlIcons); // you must initialize the icon cache first
|
|
|
|
if (psi && psi->lpVtbl->GetIconOf(psi, pidl, flags, piImage) == S_OK)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
*piImage = Shell_GetCachedImageIndex(c_szShell32Dll,
|
|
II_DOCNOASSOC, 0);
|
|
|
|
hres = psf->lpVtbl->GetUIObjectOf(psf,
|
|
NULL, 1, pidl ? &pidl : NULL, &IID_IExtractIcon, NULL, &pxi);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = _GetILIndexGivenPXIcon(pxi, flags, pidl, piImage, FALSE);
|
|
pxi->lpVtbl->Release(pxi);
|
|
}
|
|
#ifdef UNICODE
|
|
else
|
|
{
|
|
//
|
|
// Try the ANSI interface, see if we are dealing with an old set of code
|
|
//
|
|
IExtractIconA *pxiA;
|
|
|
|
hres = psf->lpVtbl->GetUIObjectOf(psf,
|
|
NULL, 1, pidl ? &pidl : NULL, &IID_IExtractIconA, NULL, &pxiA);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = _GetILIndexGivenPXIcon(
|
|
(IExtractIcon *)pxiA, // cast to relieve grief
|
|
flags, pidl, piImage, TRUE ); // indicate Ansi ver.
|
|
pxiA->lpVtbl->Release(pxiA);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return hres;
|
|
}
|
|
|
|
//===========================================================================
|
|
// A common function that given an IShellFolder and and an Idlist that is
|
|
// contained in it, get back the index into the system image list.
|
|
//===========================================================================
|
|
int WINAPI SHMapPIDLToSystemImageListIndex(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int *piIndexSel)
|
|
{
|
|
int iIndex;
|
|
|
|
Assert(himlIcons); // you must initialize the icon cache first
|
|
|
|
if (piIndexSel)
|
|
SHGetIconFromPIDL(psf, NULL, pidl, GIL_OPENICON, piIndexSel);
|
|
|
|
SHGetIconFromPIDL(psf, NULL, pidl, 0, &iIndex);
|
|
return iIndex;
|
|
}
|
|
|
|
// -------------- auto scroll stuff --------------
|
|
|
|
BOOL _AddTimeSample(AUTO_SCROLL_DATA *pad, const POINT *ppt, DWORD dwTime)
|
|
{
|
|
pad->pts[pad->iNextSample] = *ppt;
|
|
pad->dwTimes[pad->iNextSample] = dwTime;
|
|
|
|
pad->iNextSample++;
|
|
|
|
if (pad->iNextSample == ARRAYSIZE(pad->pts))
|
|
pad->bFull = TRUE;
|
|
|
|
pad->iNextSample = pad->iNextSample % ARRAYSIZE(pad->pts);
|
|
|
|
return pad->bFull;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// for debugging, verify we have good averages
|
|
DWORD g_time = 0;
|
|
int g_distance = 0;
|
|
#endif
|
|
|
|
int _CurrentVelocity(AUTO_SCROLL_DATA *pad)
|
|
{
|
|
int i, iStart, iNext;
|
|
int dx, dy, distance;
|
|
DWORD time;
|
|
|
|
Assert(pad->bFull);
|
|
|
|
distance = 0;
|
|
time = 1; // avoid div by zero
|
|
|
|
i = iStart = pad->iNextSample % ARRAYSIZE(pad->pts);
|
|
|
|
do {
|
|
iNext = (i + 1) % ARRAYSIZE(pad->pts);
|
|
|
|
dx = abs(pad->pts[i].x - pad->pts[iNext].x);
|
|
dy = abs(pad->pts[i].y - pad->pts[iNext].y);
|
|
distance += (dx + dy);
|
|
time += abs(pad->dwTimes[i] - pad->dwTimes[iNext]);
|
|
|
|
i = iNext;
|
|
|
|
} while (i != iStart);
|
|
|
|
#ifdef DEBUG
|
|
g_time = time;
|
|
g_distance = distance;
|
|
#endif
|
|
|
|
// scale this so we don't loose accuracy
|
|
return (distance * 1024) / time;
|
|
}
|
|
|
|
|
|
|
|
// NOTE: this is duplicated in shell32.dll
|
|
//
|
|
// checks to see if we are at the end position of a scroll bar
|
|
// to avoid scrolling when not needed (avoid flashing)
|
|
//
|
|
// in:
|
|
// code SB_VERT or SB_HORZ
|
|
// bDown FALSE is up or left
|
|
// TRUE is down or right
|
|
|
|
BOOL CanScroll(HWND hwnd, int code, BOOL bDown)
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
si.cbSize = SIZEOF(SCROLLINFO);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo(hwnd, code, &si);
|
|
|
|
if (bDown)
|
|
{
|
|
if (si.nPage)
|
|
si.nMax -= si.nPage - 1;
|
|
return si.nPos < si.nMax;
|
|
}
|
|
else
|
|
{
|
|
return si.nPos > si.nMin;
|
|
}
|
|
}
|
|
|
|
#define DSD_NONE 0x0000
|
|
#define DSD_UP 0x0001
|
|
#define DSD_DOWN 0x0002
|
|
#define DSD_LEFT 0x0004
|
|
#define DSD_RIGHT 0x0008
|
|
|
|
//---------------------------------------------------------------------------
|
|
DWORD DAD_DragScrollDirection(HWND hwnd, const POINT *ppt)
|
|
{
|
|
RECT rcOuter, rc;
|
|
DWORD dwDSD = DSD_NONE; // 0
|
|
DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
|
|
|
|
// BUGBUG: do these as globals
|
|
#define g_cxVScroll GetSystemMetrics(SM_CXVSCROLL)
|
|
#define g_cyHScroll GetSystemMetrics(SM_CYHSCROLL)
|
|
|
|
GetClientRect(hwnd, &rc);
|
|
|
|
if (dwStyle & WS_HSCROLL)
|
|
rc.bottom -= g_cyHScroll;
|
|
|
|
if (dwStyle & WS_VSCROLL)
|
|
rc.right -= g_cxVScroll;
|
|
|
|
// the explorer forwards us drag/drop things outside of our client area
|
|
// so we need to explictly test for that before we do things
|
|
//
|
|
rcOuter = rc;
|
|
InflateRect(&rcOuter, g_cxSmIcon, g_cySmIcon);
|
|
|
|
InflateRect(&rc, -g_cxIcon, -g_cyIcon);
|
|
|
|
if (!PtInRect(&rc, *ppt) && PtInRect(&rcOuter, *ppt))
|
|
{
|
|
// Yep - can we scroll?
|
|
if (dwStyle & WS_HSCROLL)
|
|
{
|
|
if (ppt->x < rc.left)
|
|
{
|
|
if (CanScroll(hwnd, SB_HORZ, FALSE))
|
|
dwDSD |= DSD_LEFT;
|
|
}
|
|
else if (ppt->x > rc.right)
|
|
{
|
|
if (CanScroll(hwnd, SB_HORZ, TRUE))
|
|
dwDSD |= DSD_RIGHT;
|
|
}
|
|
}
|
|
if (dwStyle & WS_VSCROLL)
|
|
{
|
|
if (ppt->y < rc.top)
|
|
{
|
|
if (CanScroll(hwnd, SB_VERT, FALSE))
|
|
dwDSD |= DSD_UP;
|
|
}
|
|
else if (ppt->y > rc.bottom)
|
|
{
|
|
if (CanScroll(hwnd, SB_VERT, TRUE))
|
|
dwDSD |= DSD_DOWN;
|
|
}
|
|
}
|
|
}
|
|
return dwDSD;
|
|
}
|
|
|
|
|
|
#define SCROLL_FREQUENCY (GetDoubleClickTime()/2) // 1 line scroll every 1/4 second
|
|
#define MIN_SCROLL_VELOCITY 20 // scaled mouse velocity
|
|
|
|
BOOL WINAPI DAD_AutoScroll(HWND hwnd, AUTO_SCROLL_DATA *pad, const POINT *pptNow)
|
|
{
|
|
// first time we've been called, init our state
|
|
int v;
|
|
DWORD dwTimeNow = GetTickCount();
|
|
DWORD dwDSD = DAD_DragScrollDirection(hwnd, pptNow);
|
|
|
|
if (!_AddTimeSample(pad, pptNow, dwTimeNow))
|
|
return dwDSD;
|
|
|
|
v = _CurrentVelocity(pad);
|
|
|
|
if (v <= MIN_SCROLL_VELOCITY)
|
|
{
|
|
// Nope, do some scrolling.
|
|
if ((dwTimeNow - pad->dwLastScroll) < SCROLL_FREQUENCY)
|
|
dwDSD = 0;
|
|
|
|
if (dwDSD & DSD_UP)
|
|
{
|
|
DAD_ShowDragImage(FALSE);
|
|
FORWARD_WM_VSCROLL(hwnd, NULL, SB_LINEUP, 1, SendMessage);
|
|
}
|
|
else if (dwDSD & DSD_DOWN)
|
|
{
|
|
DAD_ShowDragImage(FALSE);
|
|
FORWARD_WM_VSCROLL(hwnd, NULL, SB_LINEDOWN, 1, SendMessage);
|
|
}
|
|
if (dwDSD & DSD_LEFT)
|
|
{
|
|
DAD_ShowDragImage(FALSE);
|
|
FORWARD_WM_HSCROLL(hwnd, NULL, SB_LINEUP, 1, SendMessage);
|
|
}
|
|
else if (dwDSD & DSD_RIGHT)
|
|
{
|
|
DAD_ShowDragImage(FALSE);
|
|
FORWARD_WM_HSCROLL(hwnd, NULL, SB_LINEDOWN, 1, SendMessage);
|
|
}
|
|
|
|
DAD_ShowDragImage(TRUE);
|
|
|
|
if (dwDSD)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("v=%d"), v);
|
|
pad->dwLastScroll = dwTimeNow;
|
|
}
|
|
}
|
|
return dwDSD; // bits set if in scroll region
|
|
}
|
|
|
|
//
|
|
// We need to store this array in per-instance data because we don't
|
|
// want to marshal COPYHOOKINFO data structure across process boundary.
|
|
// However, this implementation does not support multiple instance of
|
|
// the shell.
|
|
//
|
|
#pragma data_seg(DATASEG_PERINSTANCE)
|
|
HDSA g_hdsaDefViewCopyHook = NULL;
|
|
#pragma data_seg()
|
|
|
|
typedef struct _DVCOPYHOOK {
|
|
HWND hwndView;
|
|
LPDEFVIEW pdv;
|
|
} DVCOPYHOOK, *LPDVCOPYHOOK;
|
|
|
|
void DefView_AddCopyHook(LPDEFVIEW this)
|
|
{
|
|
ENTERCRITICAL;
|
|
if (!g_hdsaDefViewCopyHook)
|
|
{
|
|
g_hdsaDefViewCopyHook = DSA_Create(SIZEOF(DVCOPYHOOK), 4);
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_AddCopyHook creating the dsa"));
|
|
}
|
|
|
|
if (g_hdsaDefViewCopyHook)
|
|
{
|
|
DVCOPYHOOK dvch = { this->hwndView, this };
|
|
Assert(dvch.hwndView);
|
|
if (DSA_InsertItem(g_hdsaDefViewCopyHook, INT_MAX, &dvch)!=-1)
|
|
{
|
|
this->sv.lpVtbl->AddRef(&this->sv);
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_AddCopyHook successfully added (total=%d)"),
|
|
DSA_GetItemCount(g_hdsaDefViewCopyHook));
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
int DefView_FindCopyHook(LPDEFVIEW this, BOOL fRemoveInvalid)
|
|
{
|
|
int item;
|
|
ASSERTCRITICAL;
|
|
|
|
if (g_hdsaDefViewCopyHook==NULL) {
|
|
return -1;
|
|
}
|
|
|
|
item = DSA_GetItemCount(g_hdsaDefViewCopyHook);
|
|
|
|
while(--item>=0)
|
|
{
|
|
const DVCOPYHOOK * pdvch=DSA_GetItemPtr(g_hdsaDefViewCopyHook, item);
|
|
if (pdvch)
|
|
{
|
|
if (fRemoveInvalid) {
|
|
if (!IsWindow(pdvch->hwndView))
|
|
{
|
|
DebugMsg(DM_WARNING, TEXT("sh WA - DefView_FindCopyHook: found a invalid element, removing..."));
|
|
DSA_DeleteItem(g_hdsaDefViewCopyHook, item);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ((pdvch->hwndView==this->hwndView) && (pdvch->pdv==this)) {
|
|
return item;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
return -1; // not found
|
|
}
|
|
|
|
void DefView_RemoveCopyHook(LPDEFVIEW this)
|
|
{
|
|
LPSHELLVIEW psv = NULL;
|
|
ENTERCRITICAL;
|
|
if (g_hdsaDefViewCopyHook)
|
|
{
|
|
int item = DefView_FindCopyHook(this, TRUE);
|
|
if (item!=-1)
|
|
{
|
|
LPDVCOPYHOOK pdvch=DSA_GetItemPtr(g_hdsaDefViewCopyHook, item);
|
|
psv = &pdvch->pdv->sv;
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_RemoveCopyHook removing an element"));
|
|
DSA_DeleteItem(g_hdsaDefViewCopyHook, item);
|
|
|
|
//
|
|
// If this is the last guy, destroy it.
|
|
//
|
|
if (DSA_GetItemCount(g_hdsaDefViewCopyHook)==0)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh TR - DefView_RemoveCopyHook destroying hdsa (no element)"));
|
|
DSA_Destroy(g_hdsaDefViewCopyHook);
|
|
g_hdsaDefViewCopyHook=NULL;
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
//
|
|
// Release it outside the critical section.
|
|
//
|
|
if (psv) {
|
|
psv->lpVtbl->Release(psv);
|
|
}
|
|
}
|
|
|
|
|
|
UINT DefView_CopyHook(const COPYHOOKINFO *pchi)
|
|
{
|
|
int item;
|
|
UINT idRet = IDYES;
|
|
|
|
if (g_hdsaDefViewCopyHook==NULL) {
|
|
return idRet;
|
|
}
|
|
|
|
for (item=0;;item++)
|
|
{
|
|
DVCOPYHOOK dvch = { NULL, NULL };
|
|
|
|
//
|
|
// We should minimize this critical section (and must not
|
|
// call pfnCallBack which may popup UI!).
|
|
//
|
|
ENTERCRITICAL;
|
|
if (g_hdsaDefViewCopyHook && DSA_GetItem(g_hdsaDefViewCopyHook, item, &dvch)) {
|
|
dvch.pdv->sv.lpVtbl->AddRef(&dvch.pdv->sv);
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (dvch.pdv)
|
|
{
|
|
if (IsWindow(dvch.hwndView))
|
|
{
|
|
HRESULT hres;
|
|
hres = dvch.pdv->pfnCallback(dvch.pdv->psvOuter, dvch.pdv->pshf,
|
|
dvch.pdv->hwndMain,
|
|
DVM_NOTIFYCOPYHOOK, 0, (LPARAM)pchi);
|
|
|
|
dvch.pdv->sv.lpVtbl->Release(&dvch.pdv->sv);
|
|
if (SUCCEEDED(hres) && (hres != S_OK))
|
|
{
|
|
idRet = SCODE_CODE(hres);
|
|
Assert(idRet==IDYES || idRet==IDCANCEL || idRet==IDNO);
|
|
break;
|
|
}
|
|
item++;
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("sh WA - DefView_CopyHook list has an invalid element"));
|
|
dvch.pdv->sv.lpVtbl->Release(&dvch.pdv->sv);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break; // no more item.
|
|
}
|
|
}
|
|
|
|
return idRet;
|
|
}
|