Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
bitbcksf.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 97k
Category:

Windows Kernel

Development Platform:

Visual C++

bitbcksf.c：Code Content
  1. #include "shellprv.h"
  2. #pragma hdrstop
  4. #include "bitbuck.h"
  5. #include "fstreex.h"
  6. #include "util.h"
  7. #include "copy.h"
  8. #include "mrsw.h"
  9. #include "prop.h" // for COL_DATA
  11. #include "datautil.h"
  13. STDAPI_(LPITEMIDLIST) ILResize(LPITEMIDLIST pidl, UINT cbRequired, UINT cbExtra);
  15. // mulprsht.c
  16. void SetDateTimeText(HWND hdlg, int id, const FILETIME *pftUTC);
  18. // defext.c
  19. STDMETHODIMP CCommonShellPropSheetExt_ReplacePage(IShellPropSheetExt * pspx, UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam);
  21. // fstreex.c
  22. int  FS_CreateMoveCopyList(IDataObject *pdtobj, void *hNameMappings, LPITEMIDLIST **pppidl);
  23. void FS_PositionItems(HWND hwndOwner, UINT cidl, const LPITEMIDLIST *ppidl, IDataObject *pdtobj, POINT *pptOrigin, BOOL fMove);
  24. void FS_FreeMoveCopyList(LPITEMIDLIST *ppidl, UINT cidl);
  25. HRESULT CFSIDLData_QueryGetData(IDataObject * pdtobj, FORMATETC * pformatetc); // subclass member function to support CF_HDROP and CF_NETRESOURCE
  28. //
  29. // Prototypes
  30. //
  31. void BBGetDisplayName(LPCIDFOLDER pidf, LPTSTR pszPath);
  32. void BBGetItemPath(LPCIDFOLDER pidf, LPTSTR pszPath);
  33. STDMETHODIMP CBitBucket_PS_AddPages(IShellPropSheetExt * pspx, LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam);
  34. LPITEMIDLIST DeletedFilePathToBBPidl(LPTSTR lpszPath);
  36. //
  37. // structs
  38. //
  39. typedef struct _bbpropsheetinfo
  40. {
  41.     PROPSHEETPAGE psp;
  43.     int idDrive;
  45.     BOOL fNukeOnDelete;
  46.     BOOL fOriginalNukeOnDelete;
  48.     int iPercent;
  49.     int iOriginalPercent;
  51.     // the following two fields are valid only for the "global" tab, where they represent the state
  52.     // of the "Configure drives independently" / "Use one setting for all drives" checkbox
  53.     BOOL fUseGlobalSettings;
  54.     BOOL fOriginalUseGlobalSettings;
  56.     // this is a pointer to the global property sheet page after it has been copied somewhere by the 
  57.     // CreatePropertySheetPage(), we use this to get to the global state of the % slider and fNukeOnDelete
  58.     // from the other tabs
  59.     struct _bbpropsheetinfo* pGlobal;
  61. } BBPROPSHEETINFO, *LPBBPROPSHEETINFO;
  64. const static DWORD aBitBucketPropHelpIDs[] = {  // Context Help IDs
  65.     IDD_ATTR_GROUPBOX,  IDH_COMM_GROUPBOX,
  66.     IDC_INDEPENDENT,    IDH_RECYCLE_CONFIG_INDEP,
  67.     IDC_GLOBAL,         IDH_RECYCLE_CONFIG_ALL,
  68.     IDC_DISKSIZE,       IDH_RECYCLE_DRIVE_SIZE,
  69.     IDC_DISKSIZEDATA,   IDH_RECYCLE_DRIVE_SIZE,
  70.     IDC_BYTESIZE,       IDH_RECYCLE_BIN_SIZE,
  71.     IDC_BYTESIZEDATA,   IDH_RECYCLE_BIN_SIZE,
  72.     IDC_NUKEONDELETE,   IDH_RECYCLE_PURGE_ON_DEL,
  73.     IDC_BBSIZE,         IDH_RECYCLE_MAX_SIZE,
  74.     IDC_BBSIZETEXT,     IDH_RECYCLE_MAX_SIZE,
  75.     IDC_CONFIRMDELETE,  IDH_DELETE_CONFIRM_DLG,
  76.     IDC_TEXT,           NO_HELP,
  77.     0, 0
  78. };
  80. const static DWORD aBitBucketHelpIDs[] = {  // Context Help IDs
  81.     IDD_LINE_1,        NO_HELP,
  82.     IDD_LINE_2,        NO_HELP,
  83.     IDD_ITEMICON,      IDH_FPROP_GEN_ICON,
  84.     IDD_NAME,          IDH_FPROP_GEN_NAME,
  85.     IDD_FILETYPE_TXT,  IDH_FPROP_GEN_TYPE,
  86.     IDD_FILETYPE,      IDH_FPROP_GEN_TYPE,
  87.     IDD_FILESIZE_TXT,  IDH_FPROP_GEN_SIZE,
  88.     IDD_FILESIZE,      IDH_FPROP_GEN_SIZE,
  89.     IDD_LOCATION_TXT,  IDH_FCAB_DELFILEPROP_LOCATION,
  90.     IDD_LOCATION,      IDH_FCAB_DELFILEPROP_LOCATION,
  91.     IDD_DELETED_TXT,   IDH_FCAB_DELFILEPROP_DELETED,
  92.     IDD_DELETED,       IDH_FCAB_DELFILEPROP_DELETED,
  93.     IDD_CREATED_TXT,   IDH_FPROP_GEN_DATE_CREATED,
  94.     IDD_CREATED,       IDH_FPROP_GEN_DATE_CREATED,
  95.     IDD_READONLY,      IDH_FCAB_DELFILEPROP_READONLY,
  96.     IDD_HIDDEN,        IDH_FCAB_DELFILEPROP_HIDDEN,
  97.     IDD_ARCHIVE,       IDH_FCAB_DELFILEPROP_ARCHIVE,
  98.     IDD_ATTR_GROUPBOX, IDH_COMM_GROUPBOX,
  99.     0, 0
  100. };
  102. //
  103. // for the pidls
  104. //
  105. enum
  106. {
  107.     ICOL_NAME = 0,
  108.     ICOL_ORIGINAL,
  109.     ICOL_MODIFIED,
  110.     ICOL_TYPE,
  111.     ICOL_SIZE,
  112. };
  114. const COL_DATA c_bb_cols[] = {
  115.     {ICOL_NAME,     IDS_NAME_COL,           20, LVCFMT_LEFT,    &SCID_NAME},
  116.     {ICOL_ORIGINAL, IDS_DELETEDFROM_COL,    20, LVCFMT_LEFT,    &SCID_ORIGINALLOCATION},
  117.     {ICOL_MODIFIED, IDS_DATEDELETED_COL,    18, LVCFMT_LEFT,    &SCID_DATEDELETED},
  118.     {ICOL_TYPE,     IDS_TYPE_COL,           20, LVCFMT_LEFT,    &SCID_TYPE},
  119.     {ICOL_SIZE,     IDS_SIZE_COL,           8,  LVCFMT_RIGHT,   &SCID_SIZE}
  120. };
  122. //========================================================================
  123. // CBitBucket members
  124. //========================================================================
  125. STDMETHODIMP CBitBucket_SF_QueryInterface(IShellFolder2 *psf, REFIID riid, void **ppvObj)
  126. {
  127.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  130.     if (IsEqualIID(riid, &IID_IShellFolder)  ||
  131.         IsEqualIID(riid, &IID_IShellFolder2) ||
  132.         IsEqualIID(riid, &IID_IUnknown))
  133.     {
  134.         *ppvObj = &this->isf;
  135.     }
  136.     else if (IsEqualIID(riid, &IID_IPersistFolder) ||
  137.              IsEqualIID(riid, &IID_IPersistFolder2) ||
  138.              IsEqualIID(riid, &IID_IPersist))
  139.     {
  140.         *ppvObj = &this->ipf;
  141.     }
  142.     else if (IsEqualIID(riid, &IID_IContextMenu) )
  143.     {
  144.         *ppvObj = &this->icm;
  145.     }
  146.     else if (IsEqualIID(riid, &IID_IShellPropSheetExt))
  147.     {
  148.         *ppvObj = &this->ips;
  149.     }
  150.     else if (IsEqualIID(riid, &IID_IShellExtInit))
  151.     {
  152.         *ppvObj = &this->isei;
  153.     }
  154.     else
  155.     {
  156.         *ppvObj = NULL;
  157.         return E_NOINTERFACE;
  158.     }
  160.     this->cRef++;
  161.     return NOERROR;
  162. }
  165. STDMETHODIMP_(ULONG) CBitBucket_SF_Release(IShellFolder2 *psf)
  166. {
  167.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  168.     if (InterlockedDecrement(&this->cRef))
  169.         return this->cRef;
  171.     ILFree(this->pidl);
  172.     LocalFree((HLOCAL)this);
  173.     return 0;
  174. }
  177. STDMETHODIMP_(ULONG) CBitBucket_SF_AddRef(IShellFolder2 *psf)
  178. {
  179.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  180.     return InterlockedIncrement(&this->cRef);
  181. }
  184. BOOL BBGetOriginalPath(LPBBDATAENTRYIDA pbbidl, TCHAR *pszOrig, UINT cch)
  185. {
  186. #ifdef UNICODE
  187.     if (pbbidl->cb == SIZEOF(BBDATAENTRYIDW)) 
  188.     {
  189.         LPBBDATAENTRYIDW pbbidlw = DATAENTRYIDATOW(pbbidl);
  190.         ualstrcpyn(pszOrig, pbbidlw->wszOriginal, cch);
  191.         return (BOOL)*pszOrig;
  192.     }
  193. #endif
  194.     SHAnsiToTChar(pbbidl->bbde.szOriginal, pszOrig, cch);
  195.     return (BOOL)*pszOrig;
  196. }
  199. //
  200. // We need to be able to compare the names of two bbpidls.  Since either of
  201. // them could be a unicode name, we might have to convert both to unicode.
  202. //
  203. int _BBCompareOriginal(LPBBDATAENTRYIDA lpbbidl1, LPBBDATAENTRYIDA lpbbidl2 )
  204. {
  205.     TCHAR szOrig1[MAX_PATH];
  206.     TCHAR szOrig2[MAX_PATH];
  207.     BBGetOriginalPath(lpbbidl1, szOrig1, ARRAYSIZE(szOrig1));
  208.     BBGetOriginalPath(lpbbidl2, szOrig2, ARRAYSIZE(szOrig2));
  210.     PathRemoveFileSpec(szOrig1);
  211.     PathRemoveFileSpec(szOrig2);
  212.     return lstrcmpi(szOrig1,szOrig2);
  213. }
  216. STDMETHODIMP CBitBucket_SF_CompareIDs(IShellFolder2 *psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
  217. {
  218.     HRESULT hres = ResultFromShort(-1);
  219.     LPBBDATAENTRYIDA pbbidl1, pbbidl2;
  220.     LPCIDFOLDER pidf1 = FS_IsValidID(pidl1);
  221.     LPCIDFOLDER pidf2 = FS_IsValidID(pidl2);
  222.     short nCmp;
  224.     if (!pidf1 || !pidf2)
  225.     {
  226.         ASSERT(0);
  227.         return E_INVALIDARG;
  228.     }
  229.     
  230.     pbbidl1 = PIDLTODATAENTRYID(pidl1);
  231.     pbbidl2 = PIDLTODATAENTRYID(pidl2);
  233.     // don't worry about recursing down because we don't have children.
  234.     switch (lParam) 
  235.     {
  236.         case ICOL_TYPE:
  237.             nCmp = _CompareFileTypes((IShellFolder *)psf, pidf1, pidf2);
  238.             if (nCmp)
  239.             {
  240.                 return ResultFromShort(nCmp);
  241.             }
  242.             else
  243.             {
  244.                 goto CompareNames;
  245.             }
  246.             break;
  248.         case ICOL_SIZE:
  249.         {
  250.             ULONGLONG qw1, qw2;
  252.             // BUGBUG (reinerf) - directories are not dealt with properly
  253.             // when sorting by size.
  255.             FS_GetSize(NULL, pidf1, &qw1);
  256.             FS_GetSize(NULL, pidf2, &qw2);
  258.             if (qw1 < qw2)
  259.             {
  260.                 return ResultFromShort(-1);
  261.             }
  262.             if (qw1 > qw2)
  263.             {
  264.                 return ResultFromShort(1);
  265.             }
  266.         } // else fall through
  268. CompareNames:
  269.         case ICOL_NAME:
  270.             hres = FS_CompareNamesCase(pidf1, pidf2);
  271.             // compare the real filenames first, if they are different,
  272.             // try comparing the display name
  273.             if ((hres != ResultFromShort(0)) && (BB_IsRealID(pidl1) && BB_IsRealID(pidl2)))
  274.             {
  275.                 HRESULT hresOld = hres;
  276.                 TCHAR szName1[MAX_PATH], szName2[MAX_PATH];
  278.                 BBGetDisplayName(pidf1, szName1);
  279.                 BBGetDisplayName(pidf2, szName2);
  281.                 hres = ResultFromShort(lstrcmpi(szName1, szName2));
  282.                 // if they are from the same location, sort them by delete times
  283.                 if (hres == ResultFromShort(0))
  284.                 {
  285.                     // if the items are same in title, sort by drive
  286.                     hres = ResultFromShort(pbbidl1->bbde.idDrive - pbbidl2->bbde.idDrive);
  288.                     if (hres == ResultFromShort(0))
  289.                     {
  290.                         // if the items are still the same, sort by index
  291.                         hres = ResultFromShort(pbbidl1->bbde.iIndex - pbbidl2->bbde.iIndex);
  293.                         // once we're not equal, we can never be equal again
  294.                         ASSERT(hres != ResultFromShort(0));
  295.                         if (hres == ResultFromShort(0))
  296.                         {
  297.                             hres = hresOld;
  298.                         }
  299.                     }
  300.                 }
  301.             }
  302.             break;
  304.         case ICOL_ORIGINAL:
  305.             hres = ResultFromShort(_BBCompareOriginal(pbbidl1, pbbidl2));
  306.             break;
  308.         case ICOL_MODIFIED:
  309.             if (pbbidl1->bbde.ft.dwHighDateTime < pbbidl2->bbde.ft.dwHighDateTime) 
  310.             {
  311.                 hres = ResultFromShort(-1);
  312.             }
  313.             else if (pbbidl1->bbde.ft.dwHighDateTime > pbbidl2->bbde.ft.dwHighDateTime)
  314.             {
  315.                 hres = ResultFromShort(1);
  316.             }
  317.             else
  318.             {
  319.                 if (pbbidl1->bbde.ft.dwLowDateTime < pbbidl2->bbde.ft.dwLowDateTime) 
  320.                 {
  321.                     hres = ResultFromShort(-1);
  322.                 }
  323.                 else if (pbbidl1->bbde.ft.dwLowDateTime > pbbidl2->bbde.ft.dwLowDateTime)
  324.                 {
  325.                     hres = ResultFromShort(1);
  326.                 }
  327.                 else
  328.                 {
  329.                     return 0;
  330.                 }
  331.             }
  332.             break;
  333.     }
  334.     return hres;
  335. }
  338. STDMETHODIMP CBitBucket_SF_GetAttributesOf(IShellFolder2 *psf, UINT cidl, LPCITEMIDLIST * apidl, ULONG * rgfOut)
  339. {
  340.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  341.     ULONG gfOut = *rgfOut;
  343.     // asking about the root itself
  344.     if (cidl == 0)
  345.     {
  346.         gfOut = SFGAO_HASPROPSHEET;
  347.     }
  348.     else
  349.     {
  350.         LPCIDFOLDER pidf = FS_IsValidID(apidl[0]);
  352.         gfOut &= (SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM);
  354.         if (*rgfOut & SFGAO_LINK)
  355.         {
  356.             if (SHGetClassFlags(pidf) & SHCF_IS_LINK)
  357.             {
  358.                 gfOut |= SFGAO_LINK;
  359.             }
  360.         }
  361.     }
  363.     *rgfOut = gfOut;
  365.     return NOERROR;
  366. }
  369. int DataObjToFileOpString(IDataObject * pdtobj, LPTSTR * ppszSrc, LPTSTR * ppszDest)
  370. {
  371.     int cItems = 0;
  372.     STGMEDIUM medium;
  373.     LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
  374.     
  375.     if (pida)
  376.     {
  377.         LPTSTR lpszSrc, lpszDest;
  378.         int i, cchSrc, cchDest;
  380.         cItems = pida->cidl;
  382.         // start with null terminated strings
  383.         cchSrc = cchDest = 1;
  384.         
  385.         if (ppszSrc)
  386.             lpszSrc = (void*)LocalAlloc(LPTR, cchSrc * SIZEOF(TCHAR));
  388.         if (ppszDest)
  389.             lpszDest = (void*)LocalAlloc(LPTR, cchDest * SIZEOF(TCHAR));
  391.         for (i = 0 ; i < cItems ; i++) 
  392.         {
  393.             LPCITEMIDLIST pidl = IDA_GetIDListPtr(pida, i);
  394.             LPBBDATAENTRYIDA pbbidl = PIDLTODATAENTRYID(pidl);
  396.             if (ppszSrc) 
  397.             {
  398.                 TCHAR szSrc[MAX_PATH];
  399.                 int cchSrcFile;
  400.                 LPTSTR psz;
  402.                 BBGetItemPath((LPIDFOLDER)pidl, szSrc);
  404.                 cchSrcFile = lstrlen(szSrc) + 1;
  405.                 psz = (LPTSTR)LocalReAlloc((HLOCAL)lpszSrc, (cchSrc + cchSrcFile) * SIZEOF(TCHAR), LMEM_MOVEABLE | LMEM_ZEROINIT);
  406.                 if (!psz)
  407.                 {
  408.                     // out of memory!
  409.                     // bugbug: do something real
  410.                     LocalFree((HLOCAL)lpszSrc);
  411.                     if (ppszDest)
  412.                         LocalFree((HLOCAL)lpszDest);
  413.                     cItems = 0;
  414.                     goto Bail;
  415.                 }
  416.                 lpszSrc = psz;
  417.                 lstrcpy(lpszSrc + cchSrc - 1, szSrc);
  418.                 cchSrc += cchSrcFile;
  419.             }
  421.             if (ppszDest) 
  422.             {
  423.                 TCHAR szOrig[MAX_PATH];
  424.                 int cchDestFile;
  425.                 LPTSTR psz;
  427.                 BBGetOriginalPath(pbbidl, szOrig, ARRAYSIZE(szOrig));
  429.                 cchDestFile = lstrlen(szOrig) + 1;
  431.                 psz = (LPTSTR)LocalReAlloc((HLOCAL)lpszDest, (cchDest + cchDestFile) * SIZEOF(TCHAR), LMEM_MOVEABLE | LMEM_ZEROINIT);
  432.                 if (!psz)
  433.                 {
  434.                     // out of memory!
  435.                     LocalFree((HLOCAL)lpszDest);
  436.                     if (ppszSrc) 
  437.                         LocalFree((HLOCAL)lpszSrc);
  438.                     cItems = 0;
  439.                     goto Bail;
  440.                 }
  441.                 lpszDest = psz;
  442.                 lstrcpy(lpszDest + cchDest - 1, szOrig);
  443.                 cchDest += cchDestFile;
  444.             }
  445.         }
  447.         if (ppszSrc)
  448.             *ppszSrc = lpszSrc;
  450.         if (ppszDest)
  451.             *ppszDest = lpszDest;
  453. Bail:
  454.         HIDA_ReleaseStgMedium(pida, &medium);
  455.     }
  456.     return cItems;
  457. }
  460. //
  461. // restores the list of files in the IDataObject
  462. //
  463. void BBRestoreFileList(CBitBucket *this, HWND hwndOwner, IDataObject * pdtobj)
  464. {
  465.     LPTSTR pszSrc, pszDest;
  467.     if (DataObjToFileOpString(pdtobj, &pszSrc, &pszDest))
  468.     {
  469.         // now do the actual restore.
  470.         SHFILEOPSTRUCT sFileOp = {hwndOwner,
  471.                                   FO_MOVE,
  472.                                   pszSrc,
  473.                                   pszDest,
  474.                                   FOF_MULTIDESTFILES | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR,
  475.                                   FALSE,
  476.                                   NULL,
  477.                                   MAKEINTRESOURCE(IDS_BB_RESTORINGFILES)};
  479.         DECLAREWAITCURSOR;
  481.         SetWaitCursor();
  483.         if (SHFileOperation(&sFileOp) == ERROR_SUCCESS)
  484.         {
  485.             // success!;
  486.             SHChangeNotifyHandleEvents();
  488.             BBCheckRestoredFiles(pszSrc);
  489.         }
  491.         LocalFree((HLOCAL)pszSrc);
  492.         LocalFree((HLOCAL)pszDest);
  494.         ResetWaitCursor();
  495.     }
  496. }
  499. //
  500. // nukes the list of files in the IDataObject
  501. //
  502. void BBNukeFileList(CBitBucket *this, HWND hwndOwner, IDataObject * pdtobj)
  503. {
  504.     LPTSTR lpszSrc, lpszDest;
  505.     int nFiles = DataObjToFileOpString(pdtobj, &lpszSrc, &lpszDest);
  506.     
  507.     if (nFiles)
  508.     {
  509.         // now do the actual nuke.
  510.         int iItems;
  511.         WIN32_FIND_DATA fd;
  512.         CONFIRM_DATA cd = {CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_PROGRAM_FILE | CONFIRM_MULTIPLE, 0};
  513.         SHFILEOPSTRUCT sFileOp ={hwndOwner,
  514.                                  FO_DELETE,
  515.                                  lpszSrc,
  516.                                  NULL,
  517.                                  FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS,
  518.                                  FALSE,
  519.                                  NULL,
  520.                                  MAKEINTRESOURCE(IDS_BB_DELETINGWASTEBASKETFILES)};
  522.         DECLAREWAITCURSOR;
  524.         SetWaitCursor();
  526.         fd.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
  527.         if (ConfirmFileOp(hwndOwner, NULL, &cd, nFiles, 0, CONFIRM_DELETE_FILE | CONFIRM_WASTEBASKET_PURGE, lpszDest, &fd, NULL, &fd, NULL) == IDYES)
  528.         {
  529.             SHFileOperation(&sFileOp);
  530.             
  531.             SHChangeNotifyHandleEvents();
  533.             // update the icon if there are objects left in the list
  534.             iItems = (int) ShellFolderView_GetObjectCount(hwndOwner);
  535.             UpdateIcon(iItems);
  536.         }
  538.         LocalFree((HLOCAL)lpszSrc);
  539.         LocalFree((HLOCAL)lpszDest);
  541.         ResetWaitCursor();
  542.     }
  543. }
  546. void EnableTrackbarAndFamily(HWND hDlg, BOOL f)
  547. {
  548.     EnableWindow(GetDlgItem(hDlg, IDC_BBSIZE), f);
  549.     EnableWindow(GetDlgItem(hDlg, IDC_BBSIZETEXT), f);
  550.     EnableWindow(GetDlgItem(hDlg, IDC_TEXT), f);
  551. }
  554. void BBGlobalPropOnCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify)
  555. {
  556.     LPBBPROPSHEETINFO ppsi = (LPBBPROPSHEETINFO)GetWindowLongPtr(hDlg, DWLP_USER);
  557.     BOOL fNukeOnDelete;
  559.     switch (id)
  560.     {
  561.         case IDC_GLOBAL:
  562.         case IDC_INDEPENDENT:
  563.             fNukeOnDelete = IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE);
  565.             ppsi->fUseGlobalSettings = (IsDlgButtonChecked(hDlg, IDC_GLOBAL) == BST_CHECKED) ? TRUE : FALSE;
  566.             EnableWindow(GetDlgItem(hDlg, IDC_NUKEONDELETE), ppsi->fUseGlobalSettings);
  567.             EnableTrackbarAndFamily(hDlg, ppsi->fUseGlobalSettings && !fNukeOnDelete);
  569.             SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0);
  570.             break;
  572.         case IDC_NUKEONDELETE:
  573.             fNukeOnDelete = IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE);
  575.     if (fNukeOnDelete)
  576.             {                
  577.         // In order to help protect users, when they turn on "Remove files immedately" we also
  578.         // check the "show delete confimation" box automatically for them. Thus, they will have
  579.         // to explicitly uncheck it if they do not want confimation that their files will be nuked.
  580. CheckDlgButton(hDlg, IDC_CONFIRMDELETE, BST_CHECKED);
  581.             }
  583.             EnableTrackbarAndFamily(hDlg, !fNukeOnDelete);
  584.             // fall through
  585.         case IDC_CONFIRMDELETE:
  586.             SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
  587.             break;
  589.     }
  590. }
  593. void  RelayMessageToChildren(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
  594. {
  595.     HWND hwndChild;
  597.     for (hwndChild = GetWindow(hwnd, GW_CHILD); hwndChild != NULL; hwndChild = GetWindow(hwndChild, GW_HWNDNEXT))
  598.     {
  599.         SendMessage(hwndChild, uMessage, wParam, lParam);
  600.     }
  601. }
  604. //
  605. // This is the dlg proc for the "Global" tab on the recycle bin
  606. //
  607. BOOL_PTR CALLBACK BBGlobalPropDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  608. {
  609.     LPBBPROPSHEETINFO ppsi = (LPBBPROPSHEETINFO)GetWindowLongPtr(hDlg, DWLP_USER);
  611.     switch (uMsg) 
  612.     {
  613.     HANDLE_MSG(hDlg, WM_COMMAND, BBGlobalPropOnCommand);
  615.     case WM_INITDIALOG: 
  616.     {
  617.         HWND  hwndTrack = GetDlgItem(hDlg, IDC_BBSIZE);
  618. SHELLSTATE ss;
  620. // make sure the info we have is current
  621. RefreshAllBBDriveSettings();
  623.         ppsi = (LPBBPROPSHEETINFO)lParam;
  624.         SetWindowLongPtr(hDlg, DWLP_USER, lParam);
  626.         SendMessage(hwndTrack, TBM_SETTICFREQ, 10, 0);
  627.         SendMessage(hwndTrack, TBM_SETRANGE, FALSE, MAKELONG(0, 100));
  628.         SendMessage(hwndTrack, TBM_SETPOS, TRUE, ppsi->iOriginalPercent);
  630.         EnableWindow(GetDlgItem(hDlg, IDC_NUKEONDELETE), ppsi->fUseGlobalSettings);
  631.         EnableTrackbarAndFamily(hDlg, ppsi->fUseGlobalSettings && !ppsi->fNukeOnDelete);
  632.         CheckDlgButton(hDlg, IDC_NUKEONDELETE, ppsi->fNukeOnDelete);
  633.         CheckRadioButton(hDlg, IDC_INDEPENDENT, IDC_GLOBAL, ppsi->fUseGlobalSettings ? IDC_GLOBAL : IDC_INDEPENDENT);
  635.         SHGetSetSettings(&ss, SSF_NOCONFIRMRECYCLE, FALSE);
  636.         CheckDlgButton(hDlg, IDC_CONFIRMDELETE, !ss.fNoConfirmRecycle);
  637.     }
  638.     // fall through to set iGlobalPercent
  639.     case WM_HSCROLL: 
  640.     {
  641.         TCHAR szPercent[20];
  642.         HWND hwndTrack = GetDlgItem(hDlg, IDC_BBSIZE);
  644.         ppsi->iPercent = (int) SendMessage(hwndTrack, TBM_GETPOS, 0, 0);
  645.         wsprintf(szPercent, TEXT("%d%%"), ppsi->iPercent);
  646.         SetDlgItemText(hDlg, IDC_BBSIZETEXT, szPercent);
  648.         if (ppsi->iPercent != ppsi->iOriginalPercent)
  649.         {
  650.             SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
  652.     if (ppsi->iPercent == 0)
  653.             {
  654.         // In order to help protect users, when they set the % slider to zero we also
  655.         // check the "show delete confimation" box automatically for them. Thus, they will have
  656.         // to explicitly uncheck it if they do not want confimation that their files will be nuked.
  657. CheckDlgButton(hDlg, IDC_CONFIRMDELETE, BST_CHECKED);
  658.             }
  659. }
  661.         return TRUE;
  662.     }
  664.     case WM_HELP:
  665.         WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL,
  666.             HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aBitBucketPropHelpIDs);
  667.         return TRUE;
  669.     case WM_CONTEXTMENU:
  670.         WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
  671.             (ULONG_PTR)(LPVOID) aBitBucketPropHelpIDs);
  672.         return TRUE;
  674.     case WM_WININICHANGE:
  675.     case WM_SYSCOLORCHANGE:
  676.     case WM_DISPLAYCHANGE:
  677.         RelayMessageToChildren(hDlg, uMsg, wParam, lParam);
  678.         break;
  680.     case WM_DESTROY:
  681.         CheckCompactAndPurge();
  682.         SHUpdateRecycleBinIcon();
  683.         break;
  685.     case WM_NOTIFY:
  686.         switch (((NMHDR *)lParam)->code)
  687.         {
  688.             case PSN_APPLY:
  689.             {
  690.                 SHELLSTATE ss;
  692.                 ss.fNoConfirmRecycle = !IsDlgButtonChecked(hDlg, IDC_CONFIRMDELETE);
  693.                 SHGetSetSettings(&ss, SSF_NOCONFIRMRECYCLE, TRUE);
  694.                 
  695.                 ppsi->fNukeOnDelete = (IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE) == BST_CHECKED) ? TRUE : FALSE;
  696.                 ppsi->fUseGlobalSettings = (IsDlgButtonChecked(hDlg, IDC_INDEPENDENT) == BST_CHECKED) ? FALSE : TRUE;
  698. // if anything on the global tab changed, update all the drives
  699. if (ppsi->fUseGlobalSettings != ppsi->fOriginalUseGlobalSettings    ||
  700.                     ppsi->fNukeOnDelete != ppsi->fOriginalNukeOnDelete              ||
  701.                     ppsi->iPercent != ppsi->iOriginalPercent)
  702.                 {
  703.                     int i;
  705.                     // NOTE: We get a PSN_APPLY after all the drive tabs. This has to be this way so that
  706.                     // if global settings change, then the global tab will re-apply all the most current settings
  707.                     // bassed on the global variables that get set above.
  709.                     // this sets the new global settings in the registry
  710.                     if (!PersistGlobalSettings(ppsi->fUseGlobalSettings, ppsi->fNukeOnDelete, ppsi->iPercent))
  711.                     {
  712.                         // we failed, so show the error dialog and bail
  713.                         ShellMessageBox(HINST_THISDLL,
  714.                                         hDlg,
  715.                                         MAKEINTRESOURCE(IDS_BB_CANNOTCHANGESETTINGS),
  716.                                         MAKEINTRESOURCE(IDS_WASTEBASKET),
  717.                                         MB_OK | MB_ICONEXCLAMATION);
  719.                         SetDlgMsgResult(hDlg, WM_NOTIFY, PSNRET_INVALID_NOCHANGEPAGE);
  720.                         return TRUE;
  721.                     }
  723.                     for (i = 0; i < MAX_BITBUCKETS ; i++)
  724.                     {
  725.                         if (MakeBitBucket(i))
  726.                         {
  727.                             BOOL bPurge = TRUE;
  729.                             // we need to purge all the drives in this case
  730.                             RegSetValueEx(g_pBitBucket[i]->hkeyPerUser, TEXT("NeedToPurge"), 0, REG_DWORD, (LPBYTE)&bPurge, SIZEOF(bPurge));
  732.                             RefreshBBDriveSettings(i);
  733.                         }
  734.                     }
  736.                     ppsi->fOriginalUseGlobalSettings = ppsi->fUseGlobalSettings;
  737.                     ppsi->fOriginalNukeOnDelete = ppsi->fNukeOnDelete; 
  738.                     ppsi->iOriginalPercent = ppsi->iPercent;
  739.                 }
  740.             }
  741.         }
  742.         break;
  744.         SetDlgMsgResult(hDlg, WM_NOTIFY, 0);
  745.         return TRUE;
  746.     }
  748.     return FALSE;
  749. }
  751. BOOL_PTR CALLBACK BBDriveDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  752. {
  753.     LPBBPROPSHEETINFO ppsi = (LPBBPROPSHEETINFO)GetWindowLongPtr(hDlg, DWLP_USER);
  754.     TCHAR szDiskSpace[40];
  755.     HWND hwndTrack;
  757.     switch (uMsg) 
  758.     {
  760.         case WM_INITDIALOG: 
  761.         {
  762.             hwndTrack = GetDlgItem(hDlg, IDC_BBSIZE);
  764.             ppsi = (LPBBPROPSHEETINFO)lParam;
  765.             SetWindowLongPtr(hDlg, DWLP_USER, lParam);
  767.             SendMessage(hwndTrack, TBM_SETTICFREQ, 10, 0);
  768.             SendMessage(hwndTrack, TBM_SETRANGE, FALSE, MAKELONG(0, 100));
  769.             SendMessage(hwndTrack, TBM_SETPOS, TRUE, ppsi->iPercent);
  770.             CheckDlgButton(hDlg, IDC_NUKEONDELETE, ppsi->fNukeOnDelete);
  772.             // set the disk space info
  773.             StrFormatByteSize64(g_pBitBucket[ppsi->idDrive]->qwDiskSize, szDiskSpace, ARRAYSIZE(szDiskSpace));
  774.             SetDlgItemText(hDlg, IDC_DISKSIZEDATA, szDiskSpace);
  775.             wParam = 0;
  776.         }
  777.         // fall through
  779.         case WM_HSCROLL:
  780.         {
  781.             ULARGE_INTEGER ulBucketSize;
  782.             HWND hwndTrack = GetDlgItem(hDlg, IDC_BBSIZE);
  783.             ppsi->iPercent = (int)SendMessage(hwndTrack, TBM_GETPOS, 0, 0);
  785.             wsprintf(szDiskSpace, TEXT("%d%%"), ppsi->iPercent);
  786.             SetDlgItemText(hDlg, IDC_BBSIZETEXT, szDiskSpace);
  787.                        
  788.             if (ppsi->iPercent != ppsi->iOriginalPercent) 
  789.             {
  790.                 SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0);
  791.             }
  793.             // we peg the max size of the recycle bin to 4 gig
  794.             ulBucketSize.QuadPart = (ppsi->pGlobal->fUseGlobalSettings ? ppsi->pGlobal->iPercent : ppsi->iPercent) * (g_pBitBucket[ppsi->idDrive]->qwDiskSize / 100);
  795.             StrFormatByteSize64(ulBucketSize.HighPart ? (DWORD)-1 : ulBucketSize.LowPart, szDiskSpace, ARRAYSIZE(szDiskSpace));
  796.             SetDlgItemText(hDlg, IDC_BYTESIZEDATA, szDiskSpace);
  797.             return TRUE;
  798.         }
  800.         case WM_HELP:
  801.             WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL,
  802.                 HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aBitBucketPropHelpIDs);
  803.             return TRUE;
  805.         case WM_CONTEXTMENU:
  806.             WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
  807.                 (ULONG_PTR)(LPVOID) aBitBucketPropHelpIDs);
  808.             return TRUE;
  810.         case WM_COMMAND:
  811.         {
  812.             WORD wCommandID = GET_WM_COMMAND_ID(wParam, lParam);
  813.             
  814.             if (wCommandID == IDC_NUKEONDELETE)
  815.             {
  816.                 SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
  817.                 EnableTrackbarAndFamily(hDlg, !IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE));
  818.                 EnableWindow(GetDlgItem(hDlg, IDC_BYTESIZE), !IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE));
  819.                 EnableWindow(GetDlgItem(hDlg, IDC_BYTESIZEDATA), !IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE));
  820.             }
  821.             break;
  822.         }
  824.         case WM_NOTIFY:
  825.             switch (((NMHDR *)lParam)->code) 
  826.             {
  827.                 case PSN_APPLY:
  828.                 {
  829.                     ppsi->fNukeOnDelete = (IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE) == BST_CHECKED) ? TRUE : FALSE;
  831.                     // update the info in the registry
  832.                     if (!PersistBBDriveSettings(ppsi->idDrive, ppsi->iPercent, ppsi->fNukeOnDelete))
  833.                     {
  834.                         // we failed, so show the error dialog and bail
  835.                         ShellMessageBox(HINST_THISDLL,
  836.                                         hDlg,
  837.                                         MAKEINTRESOURCE(IDS_BB_CANNOTCHANGESETTINGS),
  838.                                         MAKEINTRESOURCE(IDS_WASTEBASKET),
  839.                                         MB_OK | MB_ICONEXCLAMATION);
  841.                         SetDlgMsgResult(hDlg, WM_NOTIFY, PSNRET_INVALID_NOCHANGEPAGE);
  842.                         return TRUE;
  843.                     }
  844.                     
  845.                     // only purge this drive if the user set the slider to a smaller value       
  846.                     if (ppsi->iPercent < ppsi->iOriginalPercent)
  847.                     {
  848.                         BOOL bPurge = TRUE;
  850.                         // since this drive just shrunk, we need to purge the files in it
  851.                         RegSetValueEx(g_pBitBucket[ppsi->idDrive]->hkeyPerUser, TEXT("NeedToPurge"), 0, REG_DWORD, (LPBYTE)&bPurge, SIZEOF(bPurge));
  852.                     }
  854.                     ppsi->iOriginalPercent = ppsi->iPercent;
  855.                     ppsi->fOriginalNukeOnDelete = ppsi->fNukeOnDelete;
  856.                     
  857.                     // update the g_pBitBucket[] for this drive
  859.                     // NOTE: We get a PSN_APPLY before the global tab does. This has to be this way so that
  860.                     // if global settings change, then the global tab will re-apply all the most current settings
  861.                     // bassed on the global variables that get set in his tab.
  862.                     RefreshBBDriveSettings(ppsi->idDrive);
  863.                 }
  864.                 break;
  866.                 case PSN_SETACTIVE:
  867.                 {   
  868.                     BOOL fNukeOnDelete = IsDlgButtonChecked(hDlg, IDC_NUKEONDELETE);
  870.                     EnableWindow(GetDlgItem(hDlg, IDC_NUKEONDELETE), !ppsi->pGlobal->fUseGlobalSettings);
  871.                     EnableTrackbarAndFamily(hDlg, !ppsi->pGlobal->fUseGlobalSettings && !fNukeOnDelete);
  872.                     EnableWindow(GetDlgItem(hDlg, IDC_BYTESIZE), !fNukeOnDelete);
  873.                     EnableWindow(GetDlgItem(hDlg, IDC_BYTESIZEDATA), !fNukeOnDelete);
  875.                     // send this to make sure that the "space reserved" field is accurate when using global settings
  876.                     SendMessage(hDlg, WM_HSCROLL, 0, 0);
  877.                 }
  878.                 break;
  879.             }
  881.             SetDlgMsgResult(hDlg, WM_NOTIFY, 0);
  882.             return TRUE;
  883.     }
  885.     return FALSE;
  886. }
  889. //
  890. // this is the property sheet page for a file/folder in the bitbucket
  891. //
  892. BOOL_PTR CALLBACK BBFilePropDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  893. {
  894.     BBFILEPROPINFO * pbbfpi = (BBFILEPROPINFO *)GetWindowLongPtr(hDlg, DWLP_USER);
  895.     TCHAR szTemp[MAX_PATH];
  897.     switch (uMsg)
  898.     {
  900.         case WM_INITDIALOG:
  901.         {
  902.             LPCITEMIDLIST pidl;
  903.             LPBBDATAENTRYIDA pbbidl;
  904.             HICON hIcon;
  905.             ULONGLONG cbSize;
  907.             pbbfpi = (BBFILEPROPINFO *)lParam;
  908.             SetWindowLongPtr(hDlg, DWLP_USER, lParam);
  910.             pidl = pbbfpi->pidl;
  911.             pbbidl = PIDLTODATAENTRYID(pidl);
  913.             BBGetOriginalPath(pbbidl, szTemp, ARRAYSIZE(szTemp));
  915. #ifdef WINNT
  916.             //
  917.             // We don't allow user to change compression attribute on a deleted file
  918.             // but we do show the current compressed state
  919.             //
  920.             {
  921.                TCHAR szRoot[_MAX_PATH + 1];
  922.                DWORD dwVolumeFlags = 0;
  923.                DWORD dwFileAttributes;
  924.                TCHAR szFSName[12];
  926.                //
  927.                // If file's volume doesn't support compression, don't show
  928.                // "Compressed" checkbox.
  929.                // If compression is supported, show the checkbox and check/uncheck
  930.                // it to indicate compression state of the file.
  931.                // Perform this operation while szTemp contains complete path name.
  932.                //
  933.                lstrcpy(szRoot, szTemp);
  934.                PathQualify(szRoot);
  935.                PathStripToRoot(szRoot);
  937.                dwFileAttributes = GetFileAttributes(szTemp);
  939.                if (GetVolumeInformation(szRoot, NULL, 0, NULL, NULL, &dwVolumeFlags, szFSName, ARRAYSIZE(szFSName)) &&
  940.                    (dwFileAttributes != (DWORD)-1))
  941.                {
  942.                     if (dwVolumeFlags & FS_FILE_COMPRESSION)
  943.                     {
  944.                         if (dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
  945.                         {
  946.                             CheckDlgButton(hDlg, IDD_COMPRESS, 1);
  947.                         }
  948.                         ShowWindow(GetDlgItem(hDlg, IDD_COMPRESS), SW_SHOW);
  949.                     }
  951.                     if (g_bRunOnNT5)
  952.                     {
  953.                      // BUGBUG (ccteng) - HACK
  954.                      // Before NTFS implements FS_FILE_ENCRYPTION, we check the compression
  955.                      // flag instead, which works as long as we also check for g_bRunOnNT5.
  956.                      // After we switch to FS_FILE_ENCRYPTION,
  957.                      // we can also remove if (g_bRunOnNT5).
  959.                         // if (dwVolumeFlags & FS_FILE_ENCRYPTION)
  960.                         if (dwVolumeFlags & FS_FILE_COMPRESSION)
  961.                         {
  962.                             if (dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)
  963.                             {
  964.                                 CheckDlgButton(hDlg, IDD_ENCRYPT, 1);
  965.                             }
  966.                             ShowWindow(GetDlgItem(hDlg, IDD_ENCRYPT), SW_SHOW);
  967.                         }
  968.                     }
  969.                }
  970.             }
  971. #else
  972.             //
  973.             // Win95 doesn't support compression/encryption
  974.             //
  975. #endif
  977.             PathRemoveExtension(szTemp);
  978.             SetDlgItemText(hDlg, IDD_NAME, PathFindFileName(szTemp));
  980.             // origin
  981.             PathRemoveFileSpec(szTemp);
  982.             SetDlgItemText(hDlg, IDD_LOCATION, PathFindFileName(szTemp));
  984.             // Type
  985.             FS_GetTypeName((LPIDFOLDER)pidl, szTemp, ARRAYSIZE(szTemp));
  986.             SetDlgItemText(hDlg, IDD_FILETYPE, szTemp);
  988.             // Size
  989.             if (FS_IsFolder((LPIDFOLDER)pidl))
  990.                 cbSize = pbbidl->bbde.dwSize;
  991.             else
  992.                 FS_GetSize(NULL, (LPIDFOLDER)pidl, &cbSize);
  994.             StrFormatByteSize64(cbSize, szTemp, ARRAYSIZE(szTemp));
  995.             SetDlgItemText(hDlg, IDD_FILESIZE, szTemp);
  997.             // deleted time
  998.             {
  999.                 FILETIME ft = pbbidl->bbde.ft;
  1000.                 SetDateTimeText(hDlg, IDD_DELETED, &ft);
  1001.             }
  1003.             {
  1004.                 HANDLE hfind;
  1005.                 WIN32_FIND_DATA fd;
  1007.                 BBGetItemPath((LPIDFOLDER)pidl, szTemp);
  1009.                 hfind = FindFirstFile(szTemp, &fd);
  1010.                 if (hfind != INVALID_HANDLE_VALUE)
  1011.                 {
  1012.                     SetDateTimeText(hDlg, IDD_CREATED, &fd.ftCreationTime);
  1013.                     FindClose(hfind);
  1014.                 }
  1016.                 // file attributes
  1017.                 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
  1018.                     CheckDlgButton(hDlg, IDD_READONLY, 1);
  1019.                 if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
  1020.                     CheckDlgButton(hDlg, IDD_ARCHIVE, 1);
  1021.                 if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
  1022.                     CheckDlgButton(hDlg, IDD_HIDDEN, 1);
  1024.                 // icon
  1025.                 hIcon = SHGetFileIcon(NULL, szTemp, fd.dwFileAttributes, SHGFI_LARGEICON|SHGFI_USEFILEATTRIBUTES);
  1026.                 if (hIcon)
  1027.                 {
  1028.                     hIcon = (HICON)SendDlgItemMessage(hDlg, IDD_ITEMICON, STM_SETICON, (WPARAM)hIcon, 0L);
  1029.                     if (hIcon)
  1030.                         DestroyIcon(hIcon);
  1031.                 }
  1032.             }
  1033.             break;
  1034.         }
  1036.         case WM_WININICHANGE:
  1037.         case WM_SYSCOLORCHANGE:
  1038.         case WM_DISPLAYCHANGE:
  1039.             RelayMessageToChildren(hDlg, uMsg, wParam, lParam);
  1040.             break;
  1042.         case WM_NOTIFY:
  1043.             switch (((NMHDR *)lParam)->code) 
  1044.             {
  1045.                 case PSN_APPLY:
  1046.                 case PSN_SETACTIVE:
  1047.                 case PSN_KILLACTIVE:
  1048.                     return TRUE;
  1049.             }
  1050.             break;
  1052.         case WM_HELP:
  1053.             WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL,
  1054.                 HELP_WM_HELP, (ULONG_PTR)(LPTSTR) aBitBucketHelpIDs);
  1055.             return TRUE;
  1057.         case WM_CONTEXTMENU:
  1058.             WinHelp((HWND) wParam, NULL, HELP_CONTEXTMENU,
  1059.                 (ULONG_PTR)(LPVOID) aBitBucketHelpIDs);
  1060.             return TRUE;
  1061.     }
  1063.     return FALSE;
  1064. }
  1066. void BBGetDriveDisplayName(int idDrive, LPTSTR pszName, UINT cchSize)
  1067. {
  1068.     TCHAR szDrive[MAX_PATH];
  1069.     SHFILEINFO sfi;
  1071.     VDATEINPUTBUF(pszName, TCHAR, cchSize);
  1073.     DriveIDToBBRoot(idDrive, szDrive);
  1075.     if (SHGetFileInfo(szDrive, 0, &sfi, SIZEOF(sfi), SHGFI_DISPLAYNAME)) 
  1076.     {
  1077.         lstrcpyn(pszName, sfi.szDisplayName, cchSize);
  1078.     }
  1079.     
  1080.     // If SERVERDRIVE, attempt to overwrite the default display name with the display
  1081.     // name for the mydocs folder on the desktop, since SERVERDRIVE==mydocs for now
  1082.     if (idDrive == SERVERDRIVE) 
  1083.     {
  1084.         GetMyDocumentsDisplayName(pszName, cchSize);
  1085.     }
  1086. }
  1089. BOOL CALLBACK _BB_AddPage(HPROPSHEETPAGE psp, LPARAM lParam)
  1090. {
  1091.     LPPROPSHEETHEADER ppsh = (LPPROPSHEETHEADER)lParam;
  1093.     ppsh->phpage[ppsh->nPages++] = psp;
  1094.     return TRUE;
  1095. }
  1098. DWORD CALLBACK _BB_PropertiesThread(IDataObject * pdtobj)
  1099. {
  1100.     HPROPSHEETPAGE ahpage[MAXPROPPAGES];
  1101.     TCHAR szTitle[80];
  1102.     PROPSHEETHEADER psh;
  1103.     UNIQUESTUBINFO usi;
  1104.     LPITEMIDLIST pidlBitBucket = SHCloneSpecialIDList(NULL, CSIDL_BITBUCKET, FALSE);
  1105.     BOOL fUnique;
  1107.     psh.dwSize = SIZEOF(psh);
  1108.     psh.dwFlags = PSH_PROPTITLE;
  1109.     psh.hInstance = HINST_THISDLL;
  1110. //  psh.hwndParent = NULL;      // will be filled in later
  1111.     psh.nStartPage = 0;
  1112.     psh.phpage = ahpage;
  1113.     psh.nPages = 0;
  1115.     if (pdtobj)
  1116.     {
  1117.         // this is the recycled file properties case, 
  1118.         // we only show the proeprties for the first file if
  1119.         // there is a multiple selection
  1120.         BBFILEPROPINFO bbfpi;
  1121.         STGMEDIUM medium;
  1122.         LPITEMIDLIST pidlSave;
  1123.         TCHAR szTemp[MAX_PATH];
  1124.         LPBBDATAENTRYIDA lpbbidl;
  1125.         LPIDA pida;
  1127.         pida = DataObj_GetHIDA(pdtobj, &medium);
  1129.         pidlSave = ILCombine(pidlBitBucket, IDA_GetIDListPtr(pida, 0));
  1130.         fUnique = EnsureUniqueStub(pidlSave, STUBCLASS_PROPSHEET, NULL, &usi);
  1131.         ILFree(pidlSave);
  1133.         if (!fUnique) // found other window
  1134.             goto Cleanup;
  1136.         bbfpi.psp.dwFlags = 0;
  1137.         bbfpi.psp.dwSize = SIZEOF(bbfpi);
  1138.         bbfpi.psp.hInstance = HINST_THISDLL;
  1139.         bbfpi.psp.pszTemplate = MAKEINTRESOURCE(DLG_DELETEDFILEPROP);
  1140.         bbfpi.psp.pfnDlgProc = BBFilePropDlgProc;
  1141.         bbfpi.psp.pszTitle = szTitle;
  1142.         bbfpi.hida = medium.hGlobal;
  1143.         bbfpi.pidl = IDA_GetIDListPtr(pida, 0);
  1145.         lpbbidl = PIDLTODATAENTRYID(bbfpi.pidl);
  1147.         BBGetOriginalPath(lpbbidl, szTemp, ARRAYSIZE(szTemp));
  1149.         lstrcpyn(szTitle, PathFindFileName(szTemp), ARRAYSIZE(szTitle));
  1150.         PathRemoveExtension(szTitle);
  1152.         psh.phpage[0] = CreatePropertySheetPage(&bbfpi.psp);
  1154.         HIDA_ReleaseStgMedium(pida, &medium);
  1156.         psh.nPages = 1;
  1157.         psh.pszCaption = szTitle;
  1158.     }
  1159.     else
  1160.     {
  1161.         // this is the recycle bin property sheet case
  1162.         fUnique = EnsureUniqueStub(pidlBitBucket, STUBCLASS_PROPSHEET, NULL, &usi);
  1164.         if (!fUnique)
  1165.             goto Cleanup;
  1167.         CBitBucket_PS_AddPages(NULL, _BB_AddPage, (LPARAM)&psh);
  1169.         psh.pszCaption = MAKEINTRESOURCE(IDS_WASTEBASKET);
  1170.     }
  1172.     psh.hwndParent = usi.hwndStub;
  1173.     PropertySheet(&psh);
  1175. Cleanup:
  1177.     if (pidlBitBucket)
  1178.         ILFree(pidlBitBucket);
  1180.     FreeUniqueStub(&usi);
  1182.     return TRUE;
  1183. }
  1185. typedef struct _bb_threaddata {
  1186.     CBitBucket* pbb;
  1187.     HWND hwndOwner;
  1188.     IDataObject * pdtobj;
  1189.     IStream *pstmDataObj;
  1190.     ULONG_PTR idCmd;
  1191.     POINT ptDrop;
  1192.     BOOL fSameHwnd;
  1193.     BOOL fDragDrop;
  1194. } BBTHREADDATA;
  1196. DWORD WINAPI BB_DropThreadInit(BBTHREADDATA *pbbtd)
  1197. {
  1198.     STGMEDIUM medium;
  1199.     FORMATETC fmte = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  1201.     if (SUCCEEDED(pbbtd->pdtobj->lpVtbl->GetData(pbbtd->pdtobj, &fmte, &medium))) 
  1202.     {
  1203.         // call delete here so that files will be moved in
  1204.         // their respective bins, not necessarily this one.
  1205.         DRAGINFO di;
  1207.         di.uSize = SIZEOF(DRAGINFO);
  1209.         if (DragQueryInfo(medium.hGlobal, &di))
  1210.         {
  1211.             // Since BBWillRecycle() can return true even when the file will NOT be
  1212.             // recycled (eg the file will be nuked), we want to warn the user when we 
  1213.             // are going to nuke something that they initiall thought that it would
  1214.             // be recycled
  1215.             UINT fOptions = SD_WARNONNUKE; 
  1217.             if (!BBWillRecycle(di.lpFileList, NULL) ||
  1218.                 (di.lpFileList && (di.lpFileList[lstrlen(di.lpFileList)+1] == 0)
  1219.                  && PathIsShortcutToProgram(di.lpFileList)))
  1220.                 fOptions = SD_USERCONFIRMATION; 
  1222.             if (IsFileInBitBucket(di.lpFileList)) 
  1223.             {
  1224.                 LPITEMIDLIST *ppidl = NULL;
  1225.                 int cidl = FS_CreateMoveCopyList(pbbtd->pdtobj, NULL, &ppidl);
  1226.                 if (ppidl) 
  1227.                 {
  1228.                     FS_PositionItems(pbbtd->hwndOwner, cidl, ppidl, pbbtd->pdtobj, &pbbtd->ptDrop, pbbtd->fDragDrop);
  1229.                     FS_FreeMoveCopyList(ppidl, cidl);
  1230.                 }
  1231.             } 
  1232.             else 
  1233.             {
  1234.                 TransferDelete(pbbtd->hwndOwner, medium.hGlobal, fOptions);
  1235.             }
  1237.             SHChangeNotifyHandleEvents();
  1238.             SHFree(di.lpFileList);
  1239.         }
  1240.         ReleaseStgMedium(&medium);
  1241.     }
  1242.     return 0;
  1243. }
  1246. DWORD CALLBACK _BB_DispatchThreadProc(void *pv)
  1247. {
  1248.     BBTHREADDATA *pbbtd = (BBTHREADDATA *)pv;
  1250.     if (pbbtd->pstmDataObj)
  1251.     {
  1252.         CoGetInterfaceAndReleaseStream(pbbtd->pstmDataObj, &IID_IDataObject, (void **)&pbbtd->pdtobj);
  1253.         pbbtd->pstmDataObj = NULL;  // this is dead
  1254.     }
  1256.     switch(pbbtd->idCmd)
  1257.     {
  1258.     case DFM_CMD_MOVE:
  1259.         if (pbbtd->pdtobj)
  1260.             BB_DropThreadInit(pbbtd);
  1261.         break;
  1263.     case DFM_CMD_PROPERTIES:
  1264.     case FSIDM_PROPERTIESBG:    // NULL pdtobj is valid
  1266.         _BB_PropertiesThread(pbbtd->pdtobj);
  1267.         break;
  1269.     case DFM_CMD_DELETE:
  1270.         if (pbbtd->pdtobj)
  1271.             BBNukeFileList(pbbtd->pbb, pbbtd->hwndOwner, pbbtd->pdtobj);
  1272.         break;
  1274.     case FSIDM_RESTORE:
  1275.         if (pbbtd->pdtobj)
  1276.             BBRestoreFileList(pbbtd->pbb, pbbtd->hwndOwner, pbbtd->pdtobj);
  1277.         break;
  1278.     }
  1280.     if (pbbtd->pdtobj)
  1281.         pbbtd->pdtobj->lpVtbl->Release(pbbtd->pdtobj);
  1283.     if (pbbtd->pbb)
  1284.         pbbtd->pbb->isf.lpVtbl->Release(&pbbtd->pbb->isf);
  1286.     LocalFree((HLOCAL)pbbtd);
  1288.     return 0;
  1289. }
  1292. HRESULT BB_LaunchThread(CBitBucket *this, HWND hwndOwner, IDataObject * pdtobj, WPARAM idCmd)
  1293. {
  1294.     HRESULT hr = E_OUTOFMEMORY;
  1295.     BBTHREADDATA *pbbtd = (BBTHREADDATA *)LocalAlloc(LPTR, SIZEOF(*pbbtd));
  1296.     if (pbbtd)
  1297.     {
  1298.         pbbtd->pbb = this;
  1299.         pbbtd->hwndOwner = hwndOwner;
  1300.         pbbtd->idCmd = idCmd;
  1302.         if (idCmd == DFM_CMD_MOVE)
  1303.         {
  1304.             pbbtd->fDragDrop = (BOOL) ShellFolderView_GetDropPoint(hwndOwner, &pbbtd->ptDrop);
  1305.         }
  1307.         if (this)
  1308.             this->isf.lpVtbl->AddRef(&this->isf);
  1310.         if (pdtobj)
  1311.             CoMarshalInterThreadInterfaceInStream(&IID_IDataObject, (IUnknown *)pdtobj, &pbbtd->pstmDataObj);
  1313.         if (SHCreateThread(_BB_DispatchThreadProc, pbbtd, CTF_COINIT, NULL))
  1314.         {
  1315.             hr = NOERROR;
  1316.         }
  1317.         else
  1318.         {
  1319.             if (pbbtd->pstmDataObj)
  1320.                 pbbtd->pstmDataObj->lpVtbl->Release(pbbtd->pstmDataObj);
  1322.             if (this)
  1323.                 this->isf.lpVtbl->Release(&this->isf);
  1325.             LocalFree((HLOCAL)pbbtd);
  1326.         }
  1327.     }
  1328.     return hr;
  1329. }
  1331. const TCHAR c_szUnDelete[] = TEXT("undelete");
  1332. const TCHAR c_szPurgeAll[] = TEXT("empty");
  1334. HRESULT GetVerb(UINT_PTR idCmd, LPSTR pszName, UINT cchMax, BOOL bUnicode)
  1335. {
  1336.     HRESULT hres;
  1337.     LPCTSTR pszNameT;
  1339.     switch (idCmd)
  1340.     {
  1341.         case FSIDM_RESTORE:
  1342.             pszNameT = c_szUnDelete;
  1343.             break;
  1344.         case FSIDM_PURGEALL:
  1345.             pszNameT = c_szPurgeAll;
  1346.             break;
  1347.         default:
  1348.             return E_NOTIMPL;
  1349.     }
  1351.     if (bUnicode)
  1352.         hres = SHTCharToUnicode(pszNameT, (LPWSTR)pszName, cchMax);
  1353.     else
  1354.         hres = SHTCharToAnsi(pszNameT, (LPSTR)pszName, cchMax);
  1356.     return hres;
  1357. }
  1359. //
  1360. // Callback from DefCM
  1361. //
  1362. HRESULT CALLBACK CBitBucket_DFMCallBack(IShellFolder *psf, HWND hwndOwner,
  1363.                 IDataObject * pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1364. {
  1365.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  1366.     HRESULT hres = NOERROR;     // assume no error
  1368.     switch(uMsg)
  1369.     {
  1370.         case DFM_MERGECONTEXTMENU:
  1371.             CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_BITBUCKET_ITEM, 0, (LPQCMINFO)lParam);
  1372.             hres = ResultFromShort(-1); // return 1 so default reg commands won't be added
  1373.             break;
  1375.         case DFM_MAPCOMMANDNAME:
  1376.             if (lstrcmpi((LPCTSTR)lParam, c_szUnDelete) == 0)
  1377.             {
  1378.                 *(int *)wParam = FSIDM_RESTORE;
  1379.             }
  1380.             else
  1381.             {
  1382.                 // command not found
  1383.                 hres = E_FAIL;
  1384.             }
  1385.             break;
  1387.         case DFM_INVOKECOMMAND:
  1388.             switch (wParam) 
  1389.             {
  1390.                 case FSIDM_RESTORE:
  1391.                 case DFM_CMD_DELETE:
  1392.                 case DFM_CMD_PROPERTIES:
  1393.                     hres = BB_LaunchThread(this, hwndOwner, pdtobj, wParam);
  1394.                     break;
  1396.                 default:
  1397.                     hres = S_FALSE;
  1398.                     break;
  1399.             }
  1400.             break;
  1402.         case DFM_GETHELPTEXT:
  1403.             LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));;
  1404.             break;
  1406.         case DFM_GETHELPTEXTW:
  1407.             LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));;
  1408.             break;
  1410.         case DFM_GETVERBA:
  1411.         case DFM_GETVERBW:
  1412.             hres = GetVerb((UINT_PTR)(LOWORD(wParam)), (LPSTR)lParam, (UINT)(HIWORD(wParam)), uMsg == DFM_GETVERBW);
  1413.             break;
  1415.         default:
  1416.             hres = E_NOTIMPL;
  1417.             break;
  1418.     }
  1420.     return hres;
  1421. }
  1425. //
  1426. // CBitBucketIDLDropTarget::DragEnter
  1427. //
  1428. //  This function puts DROPEFFECT_LINK in *pdwEffect, only if the data object
  1429. //  contains one or more net resource.
  1430. //
  1431. STDMETHODIMP CBitBucketIDLDropTarget_DragEnter(IDropTarget *pdropt, IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
  1432. {
  1433.     CIDLDropTarget *this = IToClass(CIDLDropTarget, dropt, pdropt);
  1435.     TraceMsg(TF_BITBUCKET, "Bitbucket: CBitBucketIDLDropTarget::DragEnter");
  1437.     // Call the base class first
  1438.     CIDLDropTarget_DragEnter(pdropt, pDataObj, grfKeyState, pt, pdwEffect);
  1440.     // we don't really care what is in the data object, as long as move
  1441.     // is supported by the source we say you can move it to the wastbasket
  1442.     // in the case of files we will do the regular recycle bin stuff, if
  1443.     // it is not files we will just say it is moved and let the source delete it
  1444.     *pdwEffect &= DROPEFFECT_MOVE;
  1446.     this->dwEffectLastReturned = *pdwEffect;
  1448.     return NOERROR;
  1449. }
  1452. //
  1453. // CBitBucketIDLDropTarget::Drop
  1454. //
  1455. //  This function creates a connection to a dropped net resource object.
  1456. //
  1457. STDMETHODIMP CBitBucketIDLDropTarget_Drop(IDropTarget * pdropt, IDataObject * pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
  1458. {
  1459.     CIDLDropTarget *this = IToClass(CIDLDropTarget, dropt, pdropt);
  1460.     HRESULT hres;
  1461.     BOOL fWebFoldersHack;
  1463.     // only move operation is allowed
  1464.     *pdwEffect &= DROPEFFECT_MOVE;
  1465.     fWebFoldersHack = FALSE;
  1467.     if (*pdwEffect)
  1468.     {
  1469.         hres = CIDLDropTarget_DragDropMenu(this, DROPEFFECT_MOVE, pDataObj,
  1470.                 pt, pdwEffect, NULL, NULL, POPUP_NONDEFAULTDD, grfKeyState);
  1472.         if (hres == S_FALSE)
  1473.         {
  1474.             // let callers know where this is about to go
  1475.             // Defview cares where it went so it can handle non-filesys items
  1476.             // SHScrap cares because it needs to close the file so we can delete it
  1477.             DataObj_SetDropTarget(pDataObj, &CLSID_RecycleBin);
  1479.             if (DataObj_GetDWORD(pDataObj, g_cfNotRecyclable, 0))
  1480.             {
  1481.                 if (ShellMessageBox(HINST_THISDLL, NULL,
  1482.                                     MAKEINTRESOURCE(IDS_CONFIRMNOTRECYCLABLE),
  1483.                                     MAKEINTRESOURCE(IDS_RECCLEAN_NAMETEXT),
  1484.                                     MB_SETFOREGROUND | MB_ICONQUESTION | MB_YESNO) == IDNO)
  1485.                 {
  1486.                     *pdwEffect = DROPEFFECT_NONE;
  1487.                     goto lCancel;
  1488.                 }
  1489.             }
  1491.             if (this->dwData & DTID_HDROP)  // CF_HDROP
  1492.             {
  1493.                 BB_LaunchThread(NULL, this->hwndOwner, pDataObj, DFM_CMD_MOVE);
  1495.                 // since we will move the file ourself, known as an optimised move, 
  1496.                 // we return zero here. this is per the OLE spec
  1498.                 *pdwEffect = DROPEFFECT_NONE;
  1499.             }
  1500.             else
  1501.             {
  1502.                 // if it was not files, we just say we moved the data, letting the
  1503.                 // source deleted it. lets hope they support undo...
  1505.                 *pdwEffect = DROPEFFECT_MOVE;
  1507.                 // HACK: Put up a "you can't undo this" warning for web folders.
  1508.                 {
  1509.                     LPIDA pida;
  1510.                     STGMEDIUM stgmed;
  1511.                     pida = DataObj_GetHIDA (pDataObj, &stgmed);
  1512.                     if (pida)
  1513.                     {
  1514.                         CLSID clsidSource;
  1515.                         IPersist *pPers;
  1516.                         LPCITEMIDLIST pidl;
  1518.                         pidl = IDA_GetIDListPtr (pida, -1);
  1519.                         if (pidl)
  1520.                         {
  1521.                             hres = SHBindToIDListParent (pidl, &IID_IPersist, (void **) &pPers, NULL);
  1522.                             if (FAILED(hres))
  1523.                             {
  1524.                                 IShellFolder *psf;
  1525.                                 hres = SHBindToObject(NULL, &IID_IShellFolder, pidl, (void **) &psf);
  1526.                                 if (SUCCEEDED(hres))
  1527.                                 {
  1528.                                     hres = psf->lpVtbl->QueryInterface (psf, &IID_IPersist, (void **) &pPers);
  1529.                                     psf->lpVtbl->Release(psf);
  1530.                                 }
  1531.                             }
  1532.                             if (SUCCEEDED(hres))
  1533.                             {
  1534.                                 hres = pPers->lpVtbl->GetClassID (pPers, &clsidSource);
  1535.                                 if (SUCCEEDED(hres) &&
  1536.                                     IsEqualGUID (&clsidSource, &CLSID_WebFolders))
  1537.                                 {
  1538.                                     if (ShellMessageBox(HINST_THISDLL, NULL,
  1539.                                                         MAKEINTRESOURCE(IDS_CONFIRMNOTRECYCLABLE),
  1540.                                                         MAKEINTRESOURCE(IDS_RECCLEAN_NAMETEXT),
  1541.                                                         MB_SETFOREGROUND | MB_ICONQUESTION | MB_YESNO) == IDNO)
  1542.                                     {
  1543.                                         *pdwEffect = DROPEFFECT_NONE;
  1544.                                         pPers->lpVtbl->Release(pPers);
  1545.                                         HIDA_ReleaseStgMedium (pida, &stgmed);
  1546.                                         goto lCancel;
  1547.                                     }
  1548.                                     else
  1549.                                     {
  1550.                                         fWebFoldersHack = TRUE;
  1551.                                     }
  1552.                                 }
  1553.                                 pPers->lpVtbl->Release(pPers);
  1554.                             }
  1555.                         }
  1556.                         HIDA_ReleaseStgMedium (pida, &stgmed);
  1557.                     }
  1558.                 }
  1559.             }
  1560. lCancel:
  1561.             if (!fWebFoldersHack)
  1562.             {
  1563.                 DataObj_SetDWORD(pDataObj, g_cfPerformedDropEffect, *pdwEffect);
  1564.                 DataObj_SetDWORD(pDataObj, g_cfLogicalPerformedDropEffect, DROPEFFECT_MOVE);
  1565.             }
  1566.             else
  1567.             {
  1568.                 // Make web folders really delete its source file.
  1569.                 DataObj_SetDWORD (pDataObj, g_cfPerformedDropEffect, 0);
  1570.             }
  1571.         }
  1572.     }
  1574.     CIDLDropTarget_DragLeave(pdropt);
  1576.     return S_OK;
  1577. }
  1580. const IDropTargetVtbl c_CBBDropTargetVtbl =
  1581. {
  1582.     CIDLDropTarget_QueryInterface, CIDLDropTarget_AddRef, CIDLDropTarget_Release,
  1583.     CBitBucketIDLDropTarget_DragEnter,
  1584.     CIDLDropTarget_DragOver,
  1585.     CIDLDropTarget_DragLeave,
  1586.     CBitBucketIDLDropTarget_Drop,
  1587. };
  1590. void BBInitializeViewWindow(HWND hwndView)
  1591. {
  1592.     int i;
  1594.     for (i = 0 ; i < MAX_BITBUCKETS; i++)
  1595.     {
  1596.         SHChangeNotifyEntry fsne;
  1598.         fsne.fRecursive = FALSE;
  1600.         // make it if it's there so that we'll get any events
  1601.         if (MakeBitBucket(i))
  1602.         {
  1603.             UINT u;
  1604.             fsne.pidl = g_pBitBucket[i]->pidl;
  1606.             u = SHChangeNotifyRegister(hwndView,
  1607.                                        SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel,
  1608.                                        SHCNE_DISKEVENTS,
  1609.                                        WM_DSV_FSNOTIFY, 
  1610.                                        1, 
  1611.                                        &fsne);
  1613. #ifdef DEBUG
  1614.             {
  1615.                 TCHAR szTemp[MAX_PATH];
  1617.                 SHGetPathFromIDList(fsne.pidl, szTemp);
  1618.                 TraceMsg(TF_BITBUCKET, "Bitbucket: SHChangeNotifyRegister returned %d on path %s", u ,szTemp);
  1619.             }
  1620. #endif
  1621.         }
  1622.     }
  1623. }
  1626. HRESULT BBHandleFSNotify(HWND hwnd, LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
  1627. {
  1628.     HRESULT hres = S_OK;
  1629.     TCHAR szPath[MAX_PATH];
  1630.     LPTSTR pszFileName;
  1632.     // pidls must be child of drives or network
  1633.     // (actually only drives work for right now)
  1634.     // that way we won't get duplicate events
  1635.     if ((!ILIsParent((LPCITEMIDLIST)&c_idlDrives, pidl1, FALSE) && !ILIsParent((LPCITEMIDLIST)&c_idlNet, pidl1, FALSE)) ||
  1636.         (pidl2 && !ILIsParent((LPCITEMIDLIST)&c_idlDrives, pidl2, FALSE) && !ILIsParent((LPCITEMIDLIST)&c_idlNet, pidl2, FALSE)))
  1637.     {
  1638.         return S_FALSE;
  1639.     }
  1641.     SHGetPathFromIDList(pidl1, szPath);
  1642.     pszFileName = PathFindFileName(szPath);
  1644.     if (!lstrcmpi(pszFileName, c_szInfo2) ||
  1645.         !lstrcmpi(pszFileName, c_szInfo) ||
  1646.         !lstrcmpi(pszFileName, c_szDesktopIni))
  1647.     {
  1648.         // we ignore changes to these files because they mean we were simply doing bookeeping 
  1649.         // (eg updating the info file, re-creating the desktop.ini, etc)
  1650.         return S_FALSE;
  1651.     }
  1653.     TraceMsg(TF_BITBUCKET, "Bitbucket: BBHandleFSNotify event %x on path %s", lEvent, szPath);
  1656.     switch (lEvent)
  1657.     {
  1658.         case SHCNE_RENAMEFOLDER:
  1659.         case SHCNE_RENAMEITEM:
  1660.         {
  1661.             int idDrive;
  1663.             // if the rename's target is in a bitbucket, then do a create.
  1664.             // otherwise, return NOERROR..
  1666.             idDrive = DriveIDFromBBPath(szPath);
  1668.             if (MakeBitBucket(idDrive) && ILIsParent(g_pBitBucket[idDrive]->pidl, pidl1, TRUE))
  1669.             {
  1670.                 hres = BBHandleFSNotify(hwnd, (lEvent == SHCNE_RENAMEITEM) ? SHCNE_DELETE : SHCNE_RMDIR, pidl1, NULL);
  1671.             }
  1672.         }
  1673.         break;
  1675.         case SHCNE_CREATE:
  1676.         case SHCNE_MKDIR:
  1677.         {
  1678.             LPITEMIDLIST pidl;
  1680.             pidl = DeletedFilePathToBBPidl(szPath);
  1681.             
  1682.             if (pidl)
  1683.             {
  1684.                 ShellFolderView_AddObject(hwnd, pidl);
  1685.                 hres = S_FALSE;
  1686.             }
  1687.         }
  1688.         break;
  1690.         case SHCNE_DELETE:
  1691.         case SHCNE_RMDIR: 
  1692.         {
  1693.             // if this was a delete into the recycle bin, pidl2 will exist
  1694.             if (pidl2)
  1695.             {
  1696.                 hres = BBHandleFSNotify(hwnd, (lEvent == SHCNE_DELETE) ? SHCNE_CREATE : SHCNE_MKDIR, pidl2, NULL);
  1697.             }
  1698.             else
  1699.             {
  1700.                 ShellFolderView_RemoveObject(hwnd, ILFindLastID(pidl1));
  1701.                 hres = S_FALSE;
  1702.             }
  1703.         }
  1704.         break;
  1706.         case SHCNE_UPDATEDIR:
  1707.         {
  1708.             // we recieved an updatedir, which means we probably had more than 10 fsnotify events come in,
  1709.             // so we just refresh our brains out.
  1710.             ShellFolderView_RefreshAll(hwnd);
  1711.         }
  1712.         break;
  1714.         default:
  1715.         {
  1716.             // didn't handle this message
  1717.             hres = S_FALSE;
  1718.         }
  1719.         break;
  1720.     }
  1722.     return hres;
  1723. }
  1726. void BBSort(HWND hwndOwner, int id)
  1727. {
  1728.     switch(id) 
  1729.     {
  1730.         case FSIDM_SORTBYNAME:
  1731.             ShellFolderView_ReArrange(hwndOwner, 0);
  1732.             break;
  1734.         case FSIDM_SORTBYORIGIN:
  1735.             ShellFolderView_ReArrange(hwndOwner, 1);
  1736.             break;
  1738.         case FSIDM_SORTBYDELETEDDATE:
  1739.             ShellFolderView_ReArrange(hwndOwner, 2);
  1740.             break;
  1742.         case FSIDM_SORTBYTYPE:
  1743.             ShellFolderView_ReArrange(hwndOwner, 3);
  1744.             break;
  1746.         case FSIDM_SORTBYSIZE:
  1747.             ShellFolderView_ReArrange(hwndOwner, 4);
  1748.             break;
  1749.     }
  1750. }
  1753. HRESULT CALLBACK CBitBucket_DFMCallBackBG(IShellFolder *psf, HWND hwndOwner,
  1754.                 IDataObject * pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1755. {
  1756.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  1757.     HRESULT hres = NOERROR;
  1759.     switch(uMsg)
  1760.     {
  1761.         case DFM_MERGECONTEXTMENU:
  1762.             if (!(wParam & CMF_DVFILE)) //In the case of the file menu
  1763.                 CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_BITBUCKET_BACKGROUND, POPUP_BITBUCKET_POPUPMERGE, (LPQCMINFO)lParam);
  1764.             break;
  1766.         case DFM_GETHELPTEXT:
  1767.             LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));
  1768.             break;
  1770.         case DFM_GETHELPTEXTW:
  1771.             LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));
  1772.             break;
  1774.         case DFM_INVOKECOMMAND:
  1775.             switch(wParam)
  1776.             {
  1777.                 case FSIDM_SORTBYNAME:
  1778.                 case FSIDM_SORTBYORIGIN:
  1779.                 case FSIDM_SORTBYDELETEDDATE:
  1780.                 case FSIDM_SORTBYTYPE:
  1781.                 case FSIDM_SORTBYSIZE:
  1782.                     BBSort(hwndOwner, (int) wParam);
  1783.                     break;
  1785.                 case FSIDM_PROPERTIESBG:
  1786.                     hres = BB_LaunchThread(NULL, hwndOwner, NULL, FSIDM_PROPERTIESBG);
  1787.                     break;
  1789.                 case DFM_CMD_PASTE:
  1790.                 case DFM_CMD_PROPERTIES:
  1791.                     // GetAttributesOf cidl==0 has SFGAO_HASPROPSHEET,
  1792.                     // let defcm handle this
  1793.                     hres = S_FALSE;
  1794.                     break;
  1797.                 default:
  1798.                     // GetAttributesOf cidl==0 does not set _CANMOVE, _CANDELETE, etc,
  1799.                     // BUT accelerator keys will get these unavailable menu items...
  1800.                     // so we need to return failure here
  1801.                     hres = E_NOTIMPL;
  1802.                     break;
  1803.             }
  1804.             break;
  1806.         default:
  1807.             hres = E_NOTIMPL;
  1808.             break;
  1809.     }
  1811.     return hres;
  1812. }
  1815. STDMETHODIMP CBitBucket_SF_CreateViewObject(IShellFolder2 *psf, HWND hwnd, REFIID riid, void **ppvOut)
  1816. {
  1817.     HRESULT hres;
  1818.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  1820.     if (IsEqualIID(riid, &IID_IShellView))
  1821.     {
  1822.         SFV_CREATE sSFV;
  1824.         sSFV.cbSize   = sizeof(sSFV);
  1825.         sSFV.pshf     = (IShellFolder *)psf;
  1826.         sSFV.psvOuter = NULL;
  1827.         sSFV.psfvcb   = BitBucket_CreateSFVCB((IShellFolder *)psf, this);
  1829.         hres = SHCreateShellFolderView(&sSFV, (IShellView**)ppvOut);
  1831.         if (sSFV.psfvcb)
  1832.             sSFV.psfvcb->lpVtbl->Release(sSFV.psfvcb);
  1834.     }
  1835.     else if (IsEqualIID(riid, &IID_IDropTarget))
  1836.     {
  1837.         hres = CIDLDropTarget_Create(hwnd, &c_CBBDropTargetVtbl, this->pidl, (IDropTarget **)ppvOut);
  1838.     }
  1839.     else if (IsEqualIID(riid, &IID_IContextMenu))
  1840.     {
  1841.         hres = CDefFolderMenu_Create(NULL, hwnd, 0, NULL, (IShellFolder *)psf, CBitBucket_DFMCallBackBG,
  1842.                                      NULL, NULL, (IContextMenu **)ppvOut);
  1843.     }
  1844.     else
  1845.     {
  1846.         *ppvOut = NULL;
  1847.         hres = E_NOINTERFACE;
  1848.     }
  1850.     return hres;
  1851. }
  1854. STDMETHODIMP CBitBucket_SF_ParseDisplayName(IShellFolder2 *psf, HWND hwnd, LPBC pbc, 
  1855.                                             LPOLESTR pwszDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG * pdwAttributes)
  1856. {
  1857.     *ppidl = NULL;
  1858.     return E_NOTIMPL;
  1859. }
  1862. STDMETHODIMP CBBIDLData_QueryGetData(IDataObject * pdtobj, FORMATETC * pformatetc)
  1863. {
  1864.     ASSERT(g_cfFileNameMap);
  1866.     if (pformatetc->cfFormat == g_cfFileNameMap && (pformatetc->tymed & TYMED_HGLOBAL))
  1867.     {
  1868.         return NOERROR; // same as S_OK
  1869.     }
  1870.     return CFSIDLData_QueryGetData(pdtobj, pformatetc);
  1871. }
  1873. // subclass member function to support CF_HDROP and CF_NETRESOURCE
  1874. // in:
  1875. //      hida    bitbucket id array
  1876. //
  1877. // out:
  1878. //      HGLOBAL with double NULL terminated string list of destination names
  1879. //
  1881. HGLOBAL BuildDestSpecs(LPIDA pida)
  1882. {
  1883.     LPCITEMIDLIST pidl;
  1884.     LPBBDATAENTRYIDA pbbidl;
  1885.     LPTSTR pszRet;
  1886.     TCHAR szTemp[MAX_PATH];
  1887.     UINT i, cbAlloc = SIZEOF(TCHAR);    // for double NULL termination
  1889.     for (i = 0; pidl = IDA_GetIDListPtr(pida, i); i++)
  1890.     {
  1891.         pbbidl = PIDLTODATAENTRYID(pidl);
  1893.         BBGetOriginalPath(pbbidl, szTemp, ARRAYSIZE(szTemp));
  1895.         cbAlloc += lstrlen(PathFindFileName(szTemp)) * SIZEOF(TCHAR) + SIZEOF(TCHAR);
  1896.     }
  1897.     pszRet = LocalAlloc(LPTR, cbAlloc);
  1898.     if (pszRet)
  1899.     {
  1900.         LPTSTR pszDest = pszRet;
  1901.         for (i = 0; pidl = IDA_GetIDListPtr(pida, i); i++)
  1902.         {
  1903.             pbbidl = PIDLTODATAENTRYID(pidl);
  1904.             BBGetOriginalPath(pbbidl, szTemp, ARRAYSIZE(szTemp));
  1905.             lstrcpy(pszDest, PathFindFileName(szTemp));
  1906.             pszDest += lstrlen(pszDest) + 1;
  1908.             ASSERT((ULONG_PTR)((LPBYTE)pszDest - (LPBYTE)pszRet) < cbAlloc);
  1909.             ASSERT(*(pszDest) == 0);    // zero init alloc
  1910.         }
  1911.         ASSERT((LPTSTR)((LPBYTE)pszRet + cbAlloc - SIZEOF(TCHAR)) == pszDest);
  1912.         ASSERT(*pszDest == 0);  // zero init alloc
  1913.     }
  1914.     return pszRet;
  1915. }
  1917. extern HRESULT CFSIDLData_GetData(IDataObject * pdtobj, FORMATETC * pformatetcIn, STGMEDIUM * pmedium);
  1919. STDMETHODIMP CBBIDLData_GetData(IDataObject * pdtobj, FORMATETC * pformatetcIn, STGMEDIUM * pmedium)
  1920. {
  1921.     HRESULT hres = E_INVALIDARG;
  1923.     ASSERT(g_cfFileNameMap);
  1925.     if (pformatetcIn->cfFormat == g_cfFileNameMap && (pformatetcIn->tymed & TYMED_HGLOBAL))
  1926.     {
  1927.         STGMEDIUM medium;
  1929.         LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
  1930.         if (medium.hGlobal)
  1931.         {
  1932.             pmedium->hGlobal = BuildDestSpecs(pida);
  1933.             pmedium->tymed = TYMED_HGLOBAL;
  1934.             pmedium->pUnkForRelease = NULL;
  1936.             HIDA_ReleaseStgMedium(pida, &medium);
  1938.             hres = pmedium->hGlobal ? NOERROR : E_OUTOFMEMORY;
  1939.         }
  1940.     }
  1941.     else
  1942.     {
  1943.         hres = CFSIDLData_GetData(pdtobj, pformatetcIn, pmedium);
  1944.     }
  1946.     return hres;
  1947. }
  1950. const IDataObjectVtbl c_CBBIDLDataVtbl = {
  1951.     CIDLData_QueryInterface, CIDLData_AddRef, CIDLData_Release,
  1952.     CBBIDLData_GetData,
  1953.     CIDLData_GetDataHere,
  1954.     CBBIDLData_QueryGetData,
  1955.     CIDLData_GetCanonicalFormatEtc,
  1956.     CIDLData_SetData,
  1957.     CIDLData_EnumFormatEtc,
  1958.     CIDLData_Advise,
  1959.     CIDLData_Unadvise,
  1960.     CIDLData_EnumAdvise
  1961. };
  1964. HRESULT _CreateDefExtIcon(LPCIDFOLDER pidf, REFIID riid, void **ppxicon)
  1965. {
  1966.     HRESULT hres = E_OUTOFMEMORY;
  1968.     if (FS_IsFileFolder(pidf))
  1969.     {
  1970.         return SHCreateDefExtIcon(NULL, II_FOLDER, II_FOLDEROPEN, GIL_PERCLASS, riid, ppxicon);
  1971.     }
  1972.     else
  1973.     {
  1974.         DWORD dwFlags = SHGetClassFlags(pidf);
  1975.         if (dwFlags & SHCF_ICON_PERINSTANCE)
  1976.         {
  1977.             TCHAR szPath[MAX_PATH];
  1978.              
  1979.             BBGetItemPath(pidf, szPath);
  1981.             if (dwFlags & SHCF_HAS_ICONHANDLER)
  1982.             {
  1983.                 LPITEMIDLIST pidlFull = SHSimpleIDListFromPath(szPath);
  1984.                 if (pidlFull)
  1985.                 {
  1986.                     // We hit this case for .lnk files in the recycle bin. We used to call FSLoadHandler
  1987.                     // but guz decided he only wanted the fstree code using that function (and it takes a fs psf
  1988.                     // nowdays anyway). So we just bind our brains out.
  1989.                     hres = SHGetUIObjectFromFullPIDL(pidlFull, NULL, riid, ppxicon);
  1990.                     ILFree(pidlFull);
  1991.                 }
  1992.                 else
  1993.                 {
  1994.                     hres = E_OUTOFMEMORY;
  1995.                 }
  1996.             }
  1997.             else
  1998.             {
  1999.                 DWORD uid = FS_GetUID(pidf);
  2001.                 hres = SHCreateDefExtIcon(szPath, uid, uid, GIL_PERINSTANCE | GIL_NOTFILENAME, riid, ppxicon);
  2002.             }
  2003.         }
  2004.         else
  2005.         {
  2006.             UINT iIcon = (dwFlags & SHCF_ICON_INDEX);
  2007.             hres = SHCreateDefExtIcon(c_szStar, iIcon, iIcon, GIL_PERCLASS | GIL_NOTFILENAME, riid, ppxicon);
  2008.         }
  2009.         return hres;
  2010.     }
  2011. }
  2014. STDMETHODIMP CBitBucket_GetUIObjectOf(IShellFolder2 *psf, HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl,
  2015.                                       REFIID riid, UINT *prgfInOut, void **ppvOut)
  2016. {
  2017.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  2018.     HRESULT hres;
  2020.     *ppvOut = NULL;
  2022.     if (cidl && IsEqualIID(riid, &IID_IDataObject))
  2023.     {
  2024.         hres = CIDLData_CreateFromIDArray2(&c_CBBIDLDataVtbl, this->pidl, cidl, apidl, (IDataObject **)ppvOut);
  2025.     }
  2026.     else if ((cidl == 1) && 
  2027.         (IsEqualIID(riid, &IID_IExtractIconA) || IsEqualIID(riid, &IID_IExtractIconW)))
  2028.     {
  2029.         hres = _CreateDefExtIcon(FS_IsValidID(apidl[0]), riid, ppvOut);
  2030.     }
  2031.     else if (IsEqualIID(riid, &IID_IContextMenu))
  2032.     {
  2033.         hres = CDefFolderMenu_Create(this->pidl, hwnd, cidl, apidl,
  2034.             (IShellFolder *)psf, CBitBucket_DFMCallBack, NULL, NULL, (IContextMenu**)ppvOut);
  2035.     }
  2036.     else
  2037.     {
  2038.         hres = E_NOTIMPL;
  2039.     }
  2040.     return hres;
  2041. }
  2043. HRESULT FindDataFromBBPidl(LPCITEMIDLIST bbpidl, WIN32_FIND_DATAW *pfd)
  2044. {
  2045.     LPBBDATAENTRYIDA pbbdei = PIDLTODATAENTRYID(bbpidl);
  2046.     LPIDFOLDER pidf = (LPIDFOLDER)bbpidl;
  2047.     ULONGLONG cbSize;                       // 64 bits
  2049.     ZeroMemory(pfd, sizeof(*pfd));
  2051.     if (bbpidl->mkid.cb < sizeof(BBDATAENTRYIDA))
  2052.         return E_INVALIDARG;
  2054.     // this code copied from the size column in details view, so webview will match that
  2055.     if (FS_IsFolder(pidf))
  2056.     {
  2057.         cbSize = pbbdei->bbde.dwSize;       // we cache the size of the folder, rounded to cluster
  2058.     }
  2059.     else
  2060.     {
  2061.         FS_GetSize(NULL, pidf, &cbSize);
  2062.     }
  2064.     pfd->nFileSizeHigh = HIDWORD(cbSize);
  2065.     pfd->nFileSizeLow = LODWORD(cbSize);
  2066.     pfd->dwFileAttributes = pidf->fs.wAttrs; // right?
  2068.     DosDateTimeToFileTime(pidf->fs.dateModified, pidf->fs.timeModified, &pfd->ftLastWriteTime);
  2070.     return S_OK;
  2071. }
  2073. LPITEMIDLIST BBDataEntryToPidl(int idDrive, LPBBDATAENTRYW pbbde)
  2074. {
  2075.     WIN32_FIND_DATA fd;
  2076.     TCHAR chDrive;
  2077.     TCHAR szPath[MAX_PATH];
  2078.     TCHAR szDeletedPath[MAX_PATH];
  2079.     TCHAR szOriginalFileName[MAX_PATH];
  2080.     LPITEMIDLIST pidl = NULL;
  2081.     LPITEMIDLIST pidlRet = NULL;
  2082.     BBDATAENTRYIDW bbpidl;
  2083.     void *lpv;
  2085.     if (g_pBitBucket[idDrive]->fIsUnicode)
  2086.     {
  2087.         WCHAR szTemp[MAX_PATH];
  2089.         // save off the original filename so we have the extension (needed to construct the delete file name)
  2090.         SHUnicodeToTChar(pbbde->szOriginal, szOriginalFileName, ARRAYSIZE(szOriginalFileName));
  2092.         bbpidl.bbde.iIndex  = pbbde->iIndex;
  2093.         bbpidl.bbde.idDrive = pbbde->idDrive;
  2094.         bbpidl.bbde.ft      = pbbde->ft;
  2095.         bbpidl.bbde.dwSize  = pbbde->dwSize;
  2097.         SHAnsiToUnicode(pbbde->szShortName, szTemp, ARRAYSIZE(szTemp));
  2098.         
  2099.         if (StrCmpW(pbbde->szOriginal, szTemp) == 0)
  2100.         {
  2101.             // The short and long names match, so we can use an ansi pidl
  2102.             bbpidl.cb = SIZEOF(BBDATAENTRYIDA);
  2103.             lpv = &bbpidl.cb;
  2104.         }
  2105.         else
  2106.         {
  2107.             // The short and long names DO NOT match, so create a full 
  2108.             // blown unicode pidl (both ansi and unicode names)
  2109.             bbpidl.cb = SIZEOF(BBDATAENTRYIDW);
  2110.             StrCpyW(bbpidl.wszOriginal, pbbde->szOriginal);
  2111.             lpv = &bbpidl;
  2112.         }
  2114.         bbpidl.bbde = *((LPBBDATAENTRYA)pbbde);
  2115.     }
  2116.     else
  2117.     {
  2118.         LPBBDATAENTRYA pbbdea = (LPBBDATAENTRYA)pbbde;
  2120.         // save off the original filename so we have the extension (needed to construct the delete file name)
  2121.         SHAnsiToTChar(pbbdea->szOriginal, szOriginalFileName, ARRAYSIZE(szOriginalFileName));
  2123.         // just create an ansi pidl
  2124.         bbpidl.cb = SIZEOF(BBDATAENTRYIDA);
  2125.         bbpidl.bbde = *pbbdea;
  2126.         lpv = &bbpidl.cb;
  2127.     }
  2129.     chDrive = TEXT('a') + pbbde->idDrive;
  2131.     if (chDrive == (TEXT('a') + SERVERDRIVE))
  2132.     {
  2133.         chDrive = TEXT('@');
  2134.     }
  2136.     DriveIDToBBPath(idDrive, szPath);
  2137.     lstrcpyn(szDeletedPath, szPath, ARRAYSIZE(szDeletedPath));
  2139.     // create the full path to the delete file so we can get its attributes
  2140.     wsprintf(&szDeletedPath[lstrlen(szDeletedPath)], TEXT("\D%c%d%s"), chDrive, pbbde->iIndex, PathFindExtension(szOriginalFileName));
  2141.     
  2142.     fd.dwFileAttributes = GetFileAttributes(szDeletedPath);
  2143.     
  2144.     if (fd.dwFileAttributes == -1)
  2145.     {
  2146.         TraceMsg(TF_BITBUCKET, "Bitbucket: unable to get file attributes for path %s , cannot create pidl!!", szDeletedPath);
  2147.         return NULL;
  2148.     }
  2150.     fd.ftCreationTime = pbbde->ft;
  2151.     fd.ftLastAccessTime = pbbde->ft;
  2152.     fd.ftLastWriteTime = pbbde->ft;
  2153.     fd.nFileSizeHigh = 0;
  2154.     fd.nFileSizeLow = pbbde->dwSize;
  2155.     fd.dwReserved0 = 0;
  2156.     fd.dwReserved1 = 0;
  2157.     lstrcpyn(fd.cFileName, PathFindFileName(szDeletedPath), ARRAYSIZE(fd.cFileName));  
  2158.     fd.cAlternateFileName[0] = TEXT(''); // no one uses this anyway...
  2160.     SHCreateFSIDList(szPath, &fd, &pidl);
  2162.     if (pidl)
  2163.     {
  2164.         UINT cbSize = ILGetSize(pidl);
  2165.         pidlRet = ILResize(pidl, cbSize + bbpidl.cb,0);
  2166.         if (pidlRet)
  2167.         {
  2168.             // Append this BBDATAENTRYID (A or W) onto the end
  2169.             memcpy(_ILSkip(pidlRet,cbSize - SIZEOF(pidl->mkid.cb)), lpv, bbpidl.cb);
  2170.             // And 0 terminate the thing
  2171.             _ILSkip(pidlRet, cbSize + bbpidl.cb - SIZEOF(pidl->mkid.cb))->mkid.cb = 0;
  2172.             // Now edit it into one larger id
  2173.             pidlRet->mkid.cb += bbpidl.cb;
  2174.             ASSERT(ILGetSize(pidlRet) == cbSize + bbpidl.cb);
  2175.         }
  2176.     }
  2177.     return pidlRet;
  2178. }
  2181. __inline int CALLBACK BBFDCompare(void *p1, void *p2, LPARAM lParam)
  2182. {
  2183.     return ((LPBBFINDDATA)p1)->iIndex - ((LPBBFINDDATA)p2)->iIndex;
  2184. }
  2187. __inline int CALLBACK BBFDIndexCompare(void *iIndex, void *p2, LPARAM lParam)
  2188. {
  2189.     return (int)((INT_PTR)iIndex - ((LPBBFINDDATA)p2)->iIndex);
  2190. }
  2192. BOOL CALLBACK BBEnumDPADestroyCallback(LPVOID pidl, LPVOID pData)
  2193. {
  2194.     ILFree(pidl);
  2195.     return TRUE;
  2196. }
  2198. LPITEMIDLIST BBEnum_GetNextPidl(LPENUMDELETED ped)
  2199. {
  2200.     LPITEMIDLIST pidlRet = FALSE;
  2202.     ASSERT(NULL != ped);
  2203.     if (NULL == ped->hdpa)
  2204.     {
  2205.         // This is the first Next() call - so snapshot the info files:
  2206.         if (NULL != (ped->hdpa = DPA_CreateEx(0, NULL)))
  2207.         {
  2208.             int iBitBucket;
  2209.             int nItem = 0;
  2210.             // loop through the bitbucket drives to find an info file
  2211.             for (iBitBucket = 0; iBitBucket < MAX_BITBUCKETS; iBitBucket++)
  2212.             {
  2213.                 if (MakeBitBucket(iBitBucket)) 
  2214.                 {
  2215.                     HANDLE hFile;
  2216.                     int cDeleted = 0;
  2217.                     // since we are going to start reading this bitbucket, we take the mrsw
  2218. #ifdef BB_USE_MRSW
  2219.                     MRSW_EnterRead(g_pBitBucket[iBitBucket]->pmrsw);
  2220. #endif // BB_USE_MRSW
  2221.                     hFile = OpenBBInfoFile(iBitBucket, OPENBBINFO_WRITE, 0);
  2223.                     if (INVALID_HANDLE_VALUE != hFile)
  2224.                     {
  2225.                         BBDATAENTRYW bbdew;
  2226.                         DWORD dwDataEntrySize = g_pBitBucket[iBitBucket]->fIsUnicode ? SIZEOF(BBDATAENTRYW) : SIZEOF(BBDATAENTRYA);
  2228.                         while (ReadNextDataEntry(hFile, &bbdew, FALSE, dwDataEntrySize, iBitBucket))
  2229.                         {
  2230.                             LPITEMIDLIST pidl = NULL;
  2232.                             if (IsDeletedEntry(&bbdew))
  2233.                             {
  2234.                                 cDeleted++;
  2235.                             }
  2236.                             else
  2237.                             {
  2238.                                 pidl = BBDataEntryToPidl(iBitBucket, &bbdew);
  2239.                             }
  2241.                             if (pidl)
  2242.                             {
  2243.                                 DPA_SetPtr(ped->hdpa, nItem++, pidl);
  2244.                             }
  2245.                         }
  2247.                         if (cDeleted > BB_DELETED_ENTRY_MAX)
  2248.                         {
  2249.                             BOOL bTrue = TRUE;
  2251.                             // set the registry key so that we will compact the info file after the next delete operation
  2252.                             RegSetValueEx(g_pBitBucket[iBitBucket]->hkeyPerUser, TEXT("NeedToCompact"), 0, REG_DWORD, (LPBYTE)&bTrue, SIZEOF(bTrue));
  2253.                         }
  2254.                         CloseBBInfoFile(hFile, iBitBucket);
  2255.                     }
  2256. #ifdef BB_USE_MRSW
  2257.                     MRSW_LeaveRead(g_pBitBucket[iBitBucket]->pmrsw);
  2258. #endif // BB_USE_MRSW
  2259.                 }
  2260.             }
  2261.         }
  2262.     }
  2264.     if (NULL != ped->hdpa)
  2265.     {
  2266.         pidlRet = DPA_GetPtr(ped->hdpa, ped->nItem);
  2267.         if (NULL != pidlRet)
  2268.         {
  2269.             // We're returning an allocated pidl, so replace the pointer
  2270.             // in the DPA with NULL so that we don't free it later:
  2271.             DPA_SetPtr(ped->hdpa, ped->nItem, NULL);
  2272.         }
  2273.         else
  2274.         {
  2275.             // We've reached the end, so destroy our snapshot:
  2276.             DPA_DestroyCallback(ped->hdpa, BBEnumDPADestroyCallback, NULL);
  2277.             ped->hdpa = NULL;
  2278.         }
  2279.         ped->nItem++;
  2280.     }
  2282.     return pidlRet;
  2283. }
  2285. //
  2286. // To be called back from within SHCreateEnumObjects
  2287. //
  2288. HRESULT CALLBACK CBitBucket_EnumCallBack(LPARAM lParam, void *pvData, UINT ecid, UINT index)
  2289. {
  2290.     HRESULT hres = NOERROR;
  2291.     ENUMDELETED * ped = (ENUMDELETED *)pvData;
  2293.     switch (ecid)
  2294.     {
  2295.         case ECID_SETNEXTID:
  2296.         {
  2297.             LPITEMIDLIST pidl;
  2299.             if (!(ped->grfFlags & SHCONTF_NONFOLDERS))
  2300.                 return S_FALSE; //  "no more element"
  2302.             pidl = BBEnum_GetNextPidl(ped);
  2304.             if (!pidl)
  2305.             {
  2306.                 hres = S_FALSE; //  "no more element"
  2307.             }
  2308.             else
  2309.             {
  2310.                 CDefEnum_SetReturn(lParam, pidl);
  2312.                 TraceMsg(TF_BITBUCKET, "Bitbucket: EnumCallBack,  returns %S", PIDLTODATAENTRYID(pidl)->bbde.szOriginal);
  2313.                 
  2314.                 //hres = NOERROR; // in success
  2315.             }
  2316.             break;
  2317.         }
  2318.         
  2319.         case ECID_RESET:
  2320.             if (NULL != ped->hdpa)
  2321.             {
  2322.                 DPA_DestroyCallback(ped->hdpa, BBEnumDPADestroyCallback, NULL);
  2323.                 ped->hdpa = NULL;
  2324.             }
  2325.             ped->nItem = 0;
  2326.             break;
  2328.         case ECID_RELEASE:
  2329.             if (NULL != ped->hdpa)
  2330.             {
  2331.                 DPA_DestroyCallback(ped->hdpa, BBEnumDPADestroyCallback, NULL);
  2332.             }
  2334.             LocalFree((HLOCAL)ped);
  2335.             break;
  2336.     }
  2338.     return hres;
  2339. }
  2342. STDMETHODIMP CBitBucket_SF_EnumObjects(IShellFolder2 *psf, HWND hwndOwner,
  2343.             DWORD grfFlags, LPENUMIDLIST * ppenumUnknown)
  2344. {
  2345.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  2346.     ENUMDELETED * ped = (void*)LocalAlloc(LPTR, SIZEOF(ENUMDELETED));
  2347.     if (ped) 
  2348.     {
  2349.         ped->grfFlags = grfFlags;
  2350.         ped->pbb = this;
  2351.         return SHCreateEnumObjects(hwndOwner, ped, CBitBucket_EnumCallBack, ppenumUnknown);
  2352.     }
  2353.     return E_OUTOFMEMORY;
  2354. }
  2357. STDMETHODIMP CBitBucket_BindToObject(IShellFolder2 *psf, LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvOut)
  2358. {
  2359.     *ppvOut = NULL;
  2360.     return E_NOTIMPL;
  2361. }
  2364. STDMETHODIMP CBitBucket_BindToStorage(IShellFolder2 *psf, LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvOut)
  2365. {
  2366.     *ppvOut = NULL;
  2367.     return E_NOTIMPL;
  2368. }
  2371. // get the path name of the file in the file system
  2372. void BBGetItemPath(LPCIDFOLDER pidf, LPTSTR pszPath)
  2373. {
  2374.     TCHAR szFile[MAX_PATH];
  2375.     LPBBDATAENTRYIDA pbbidl = PIDLTODATAENTRYID(pidf);
  2377.     DriveIDToBBPath(pbbidl->bbde.idDrive, pszPath);
  2378.     PathAppend(pszPath, FS_CopyName(pidf, szFile, ARRAYSIZE(szFile)));
  2379. }
  2382. // get the friendly looking name of this file
  2383. void BBGetDisplayName(LPCIDFOLDER pidf, LPTSTR pszName)
  2384. {
  2385.     TCHAR szTemp[MAX_PATH];
  2386.     LPBBDATAENTRYIDA pbbid = PIDLTODATAENTRYID(pidf);
  2388.     BBGetOriginalPath(pbbid, szTemp, ARRAYSIZE(szTemp));
  2389.     lstrcpy(pszName, PathFindFileName(szTemp));
  2391.     if (!FS_ShowExtension(pidf))
  2392.         PathRemoveExtension(pszName);
  2393. }
  2396. STDMETHODIMP CBitBucket_SF_GetDisplayNameOf(IShellFolder2 *psf, LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET pStrRet)
  2397. {
  2398.     LPCIDFOLDER pidf;
  2400.     pStrRet->uType = STRRET_CSTR;
  2401.     pStrRet->cStr[0] = 0;
  2403.     pidf = FS_IsValidID(pidl);
  2404.     if (pidf)
  2405.     {
  2406.         TCHAR szName[MAX_PATH];
  2408.         if (uFlags & SHGDN_FORPARSING)
  2409.             BBGetItemPath(pidf, szName);
  2410.         else
  2411.             BBGetDisplayName(pidf, szName);
  2413.         return StringToStrRet(szName, pStrRet);
  2414.     }
  2415.     return E_INVALIDARG;
  2416. }
  2419. STDMETHODIMP CBitBucket_SetNameOf(IShellFolder2 *psf, HWND hwnd,
  2420.         LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD dwReserved, LPITEMIDLIST * ppidlOut)
  2421. {
  2422.     return E_FAIL;
  2423. }
  2426. STDMETHODIMP CBitBucket_EnumSearches(IShellFolder2 *psf, LPENUMEXTRASEARCH *ppenum)
  2427. {
  2428.     *ppenum = NULL;
  2429.     return E_NOTIMPL;
  2430. }
  2433. STDMETHODIMP CBitBucket_GetDefaultColumn(IShellFolder2 *psf, DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
  2434. {
  2435.     return E_NOTIMPL;
  2436. }
  2439. STDMETHODIMP CBitBucket_GetDefaultColumnState(IShellFolder2 *psf, UINT iColumn, DWORD *pbState)
  2440. {
  2441.     return E_NOTIMPL;
  2442. }
  2445. STDMETHODIMP CBitBucket_GetDetailsEx(IShellFolder2 *psf, LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
  2446. {
  2447.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  2448.     HRESULT hres = E_NOTIMPL;
  2449.     if (IsEqualSCID(*pscid, SCID_FINDDATA))
  2450.     {
  2451.         WIN32_FIND_DATAW wfd;
  2452.         hres = FindDataFromBBPidl(pidl, &wfd);
  2454.         if (SUCCEEDED(hres))
  2455.         {
  2456.             hres = InitVariantFromBuffer(pv, (PVOID)&wfd, sizeof(wfd));
  2457.         }
  2458.     }
  2459.     return hres;
  2460. }
  2463. STDMETHODIMP CBitBucket_GetDetailsOf(IShellFolder2 *psf, LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails)
  2464. {
  2465.     CBitBucket *this = IToClass(CBitBucket, isf, psf);
  2466.     HRESULT hres = NOERROR;
  2468.     if (iColumn >= ARRAYSIZE(c_bb_cols))
  2469.         return E_NOTIMPL;
  2471.     pDetails->str.uType = STRRET_CSTR;
  2472.     pDetails->str.cStr[0] = 0;
  2474.     if (!pidl) 
  2475.     {
  2476.         // getting the headers
  2477.         hres = ResToStrRet(c_bb_cols[iColumn].ids, &pDetails->str);
  2478.         pDetails->fmt = c_bb_cols[iColumn].iFmt;
  2479.         pDetails->cxChar = c_bb_cols[iColumn].cchCol;
  2480.     } 
  2481.     else 
  2482.     {
  2483.         TCHAR  szTemp[MAX_PATH];
  2484.         LPCIDFOLDER pidf = FS_IsValidID(pidl);
  2485.         UNALIGNED BBDATAENTRYIDA * pbbidl = PIDLTODATAENTRYID(pidl);
  2487.         switch (iColumn) {
  2488.         case ICOL_NAME:
  2489.             BBGetDisplayName(pidf, szTemp);
  2490.             hres = StringToStrRet(szTemp, &pDetails->str);
  2491.             break;
  2493.         case ICOL_SIZE:
  2494.             {
  2495.                 ULONGLONG cbSize;
  2497.                 if (FS_IsFolder(pidf))
  2498.                     cbSize = pbbidl->bbde.dwSize;
  2499.                 else
  2500.                     FS_GetSize(NULL, pidf, &cbSize);
  2502.                 StrFormatKBSize(cbSize, szTemp, ARRAYSIZE(szTemp));
  2503.                 hres = StringToStrRet(szTemp, &pDetails->str);
  2504.             }
  2505.             break;
  2507.         case ICOL_ORIGINAL:
  2508.             BBGetOriginalPath(pbbidl, szTemp, ARRAYSIZE(szTemp));
  2509.             PathRemoveFileSpec(szTemp);
  2510.             hres = StringToStrRet(szTemp, &pDetails->str);
  2511.             break;
  2513.         case ICOL_TYPE:
  2514.             FS_GetTypeName(pidf, szTemp, ARRAYSIZE(szTemp));
  2515.             hres = StringToStrRet(szTemp, &pDetails->str);
  2516.             break;
  2518.         case ICOL_MODIFIED:
  2519.             {
  2520.             // need stack ft since pbbidl is UNALIGNED
  2521.             FILETIME ft = pbbidl->bbde.ft;
  2522.             DWORD dwFlags = FDTF_DEFAULT;
  2524.             switch (pDetails->fmt)
  2525.             {
  2526.                 case LVCFMT_LEFT_TO_RIGHT :
  2527.                     dwFlags |= FDTF_LTRDATE;
  2528.                 break;
  2530.                 case LVCFMT_RIGHT_TO_LEFT :
  2531.                     dwFlags |= FDTF_RTLDATE;
  2532.                 break;
  2533.             }
  2535.             SHFormatDateTime(&ft, &dwFlags, szTemp, ARRAYSIZE(szTemp));
  2536.             hres = StringToStrRet(szTemp, &pDetails->str);
  2537.             break;
  2538.             }
  2539.         }
  2540.     }
  2541.     return hres;
  2542. }
  2545. STDMETHODIMP CBitBucket_MapColumnToSCID(IShellFolder2 *psf, UINT iColumn, SHCOLUMNID *pscid)
  2546. {
  2547.     return MapColumnToSCIDImpl(c_bb_cols, ARRAYSIZE(c_bb_cols), iColumn, pscid);
  2548. }
  2551. IShellFolder2Vtbl c_CBitBucketSFVtbl =
  2552. {
  2553.     CBitBucket_SF_QueryInterface, CBitBucket_SF_AddRef, CBitBucket_SF_Release,
  2554.     CBitBucket_SF_ParseDisplayName,
  2555.     CBitBucket_SF_EnumObjects,
  2556.     CBitBucket_BindToObject,
  2557.     CBitBucket_BindToStorage,
  2558.     CBitBucket_SF_CompareIDs,
  2559.     CBitBucket_SF_CreateViewObject,
  2560.     CBitBucket_SF_GetAttributesOf,
  2561.     CBitBucket_GetUIObjectOf,
  2562.     CBitBucket_SF_GetDisplayNameOf,
  2563.     CBitBucket_SetNameOf,
  2564.     FindFileOrFolders_GetDefaultSearchGUID,
  2565.     CBitBucket_EnumSearches,
  2566.     CBitBucket_GetDefaultColumn,
  2567.     CBitBucket_GetDefaultColumnState,
  2568.     CBitBucket_GetDetailsEx,
  2569.     CBitBucket_GetDetailsOf,
  2570.     CBitBucket_MapColumnToSCID,
  2571. };
  2573. //========================================================================
  2574. // CBitBucket's PersistFile  members
  2575. //========================================================================
  2577. STDMETHODIMP CBitBucket_PF_QueryInterface(IPersistFolder2 *ppf, REFIID riid, void **ppvObj)
  2578. {
  2579.     CBitBucket *this = IToClass(CBitBucket, ipf, ppf);
  2580.     return CBitBucket_SF_QueryInterface(&this->isf, riid, ppvObj);
  2581. }
  2583. STDMETHODIMP_(ULONG) CBitBucket_PF_Release(IPersistFolder2 *ppf)
  2584. {
  2585.     CBitBucket *this = IToClass(CBitBucket, ipf, ppf);
  2586.     return CBitBucket_SF_Release(&this->isf);
  2587. }
  2589. STDMETHODIMP_(ULONG) CBitBucket_PF_AddRef(IPersistFolder2 *ppf)
  2590. {
  2591.     CBitBucket *this = IToClass(CBitBucket, ipf, ppf);
  2592.     return CBitBucket_SF_AddRef(&this->isf);
  2593. }
  2595. STDMETHODIMP CBitBucket_PF_GetClassID(IPersistFolder2 *ppf, LPCLSID lpClassID)
  2596. {
  2597.     *lpClassID = CLSID_RecycleBin;
  2598.     return NOERROR;
  2599. }
  2601. STDMETHODIMP CBitBucket_PF_Initialize(IPersistFolder2 *ppf, LPCITEMIDLIST pidl)
  2602. {
  2603.     CBitBucket *this = IToClass(CBitBucket, ipf, ppf);
  2604.     ASSERT(this->pidl == NULL);
  2605.     this->pidl = ILClone(pidl);
  2606.     return this->pidl ? S_OK : E_OUTOFMEMORY;
  2607. }
  2609. STDMETHODIMP CBitBucket_PF_GetCurFolder(IPersistFolder2 *ppf, LPITEMIDLIST *ppidl)
  2610. {
  2611.     CBitBucket *this = IToClass(CBitBucket, ipf, ppf);
  2612.     return GetCurFolderImpl(this->pidl, ppidl);
  2613. }
  2615. IPersistFolder2Vtbl c_CBitBucketPFVtbl =
  2616. {
  2617.     CBitBucket_PF_QueryInterface, CBitBucket_PF_AddRef, CBitBucket_PF_Release,
  2618.     CBitBucket_PF_GetClassID,
  2619.     CBitBucket_PF_Initialize,
  2620.     CBitBucket_PF_GetCurFolder
  2621. };
  2624. STDMETHODIMP CBitBucket_SEI_QueryInterface(IShellExtInit* psei, REFIID riid, void **ppvObj)
  2625. {
  2626.     CBitBucket *this = IToClass(CBitBucket, isei, psei);
  2627.     return CBitBucket_SF_QueryInterface(&this->isf, riid, ppvObj);
  2628. }
  2630. STDMETHODIMP_(ULONG) CBitBucket_SEI_Release(IShellExtInit* psei)
  2631. {
  2632.     CBitBucket *this = IToClass(CBitBucket, isei, psei);
  2633.     return CBitBucket_SF_Release(&this->isf);
  2634. }
  2636. STDMETHODIMP_(ULONG) CBitBucket_SEI_AddRef(IShellExtInit* psei)
  2637. {
  2638.     CBitBucket *this = IToClass(CBitBucket, isei, psei);
  2639.     return CBitBucket_SF_AddRef(&this->isf);
  2640. }
  2642. STDMETHODIMP_(ULONG) CBitBucket_SEI_Initialize(IShellExtInit* psei,
  2643.                                                     LPCITEMIDLIST pidlFolder,
  2644.                                                     IDataObject * pdtobj, HKEY hkeyProgID)
  2645. {
  2646.     return NOERROR;
  2647. }
  2651. STDMETHODIMP CBitBucket_CM_QueryInterface(IContextMenu* pcm, REFIID riid, void **ppvObj)
  2652. {
  2653.     CBitBucket *this = IToClass(CBitBucket, icm, pcm);
  2654.     return CBitBucket_SF_QueryInterface(&this->isf, riid, ppvObj);
  2655. }
  2657. STDMETHODIMP_(ULONG) CBitBucket_CM_Release(IContextMenu* pcm)
  2658. {
  2659.     CBitBucket *this = IToClass(CBitBucket, icm, pcm);
  2660.     return CBitBucket_SF_Release(&this->isf);
  2661. }
  2663. STDMETHODIMP_(ULONG) CBitBucket_CM_AddRef(IContextMenu* pcm)
  2664. {
  2665.     CBitBucket *this = IToClass(CBitBucket, icm, pcm);
  2666.     return CBitBucket_SF_AddRef(&this->isf);
  2667. }
  2670. STDMETHODIMP CBitBucket_QueryContextMenu(IContextMenu * pcm,
  2671.         HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast,
  2672.         UINT uFlags)
  2673. {
  2674.     int idMax = idCmdFirst;
  2675.     HMENU hmMerge = SHLoadPopupMenu(HINST_THISDLL, POPUP_BITBUCKET_POPUPMERGE);
  2676.     
  2677.     if (hmMerge)
  2678.     {
  2679.         idMax = Shell_MergeMenus(hmenu, hmMerge, indexMenu, idCmdFirst, idCmdLast, 0);
  2680.         
  2681.         if (IsRecycleBinEmpty())
  2682.         {
  2683.             EnableMenuItem(hmenu, idCmdFirst + FSIDM_PURGEALL, MF_GRAYED | MF_BYCOMMAND);
  2684.         }
  2686.         DestroyMenu(hmMerge);
  2687.     }
  2689.     return ResultFromShort(idMax - idCmdFirst);
  2690. }
  2692. STDMETHODIMP CBitBucket_InvokeCommand(IContextMenu* pcm,
  2693.                                            LPCMINVOKECOMMANDINFO pici)
  2694. {
  2695.     CBitBucket *this = IToClass(CBitBucket, icm, pcm);
  2697.     TraceMsg(TF_BITBUCKET, "Bitbucket: BitBucket_invokeCommand %d %d", pici->lpVerb, FSIDM_PURGEALL);
  2699.     switch ((ULONG_PTR)pici->lpVerb)
  2700.     {
  2701.     case FSIDM_PURGEALL:
  2702.         BBPurgeAll(this, pici->hwnd, 0);
  2703.         break;
  2704.     }
  2705.     return NOERROR;
  2706. }
  2708. STDMETHODIMP CBitBucket_GetCommandString(IContextMenu *pcm,
  2709.         UINT_PTR idCmd, UINT  wFlags, UINT * pwReserved, LPSTR pszName, UINT cchMax)
  2710. {
  2711.     TraceMsg(TF_BITBUCKET, "Bitbucket: GetCommandString, idCmd = %d", idCmd);
  2713.     switch(wFlags)
  2714.     {
  2715.         case GCS_VERBA:
  2716.         case GCS_VERBW:
  2717.             return GetVerb(idCmd, pszName, cchMax, wFlags == GCS_VERBW);
  2719.         case GCS_HELPTEXTA:
  2720.             return LoadStringA(HINST_THISDLL,
  2721.                               (UINT)(idCmd + IDS_MH_FSIDM_FIRST),
  2722.                               pszName, cchMax) ? NOERROR : E_OUTOFMEMORY;
  2723.         case GCS_HELPTEXTW:
  2724.             return LoadStringW(HINST_THISDLL,
  2725.                               (UINT)(idCmd + IDS_MH_FSIDM_FIRST),
  2726.                               (LPWSTR)pszName, cchMax) ? NOERROR : E_OUTOFMEMORY;
  2727.         default:
  2728.             return E_NOTIMPL;
  2729.     }
  2730. }
  2732. STDMETHODIMP CBitBucket_PS_QueryInterface(LPSHELLPROPSHEETEXT pps, REFIID riid,
  2733.                                         void **ppvObj)
  2734. {
  2735.     CBitBucket *this = IToClass(CBitBucket, ips, pps);
  2736.     return CBitBucket_SF_QueryInterface(&this->isf, riid, ppvObj);
  2737. }
  2739. STDMETHODIMP_(ULONG) CBitBucket_PS_Release(LPSHELLPROPSHEETEXT pps)
  2740. {
  2741.     CBitBucket *this = IToClass(CBitBucket, ips, pps);
  2742.     return CBitBucket_SF_Release(&this->isf);
  2743. }
  2745. STDMETHODIMP_(ULONG) CBitBucket_PS_AddRef(LPSHELLPROPSHEETEXT pps)
  2746. {
  2747.     CBitBucket *this = IToClass(CBitBucket, ips, pps);
  2748.     return CBitBucket_SF_AddRef(&this->isf);
  2749. }
  2751. //
  2752. //  Callback function that saves the location of the HPROPSHEETPAGE's
  2753. //  LPPROPSHEETPAGE so we can pass it to other propsheet pages.
  2754. //
  2755. UINT CALLBACK BBGlobalSettingsCalback(HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
  2756. {
  2757.     LPBBPROPSHEETINFO ppsiTemplate;
  2758.     LPBBPROPSHEETINFO ppsiGlobal;
  2760.     switch (uMsg)
  2761.     {
  2762.         case PSPCB_ADDREF:
  2763.             // we save off the address of the "real" ppsi in the pGlobal param of the
  2764.             // the template, so that the other drives can get to the global page information
  2765.             ppsiGlobal = (LPBBPROPSHEETINFO)ppsp;
  2766.             ppsiTemplate = (LPBBPROPSHEETINFO)ppsp->lParam;
  2767.             ppsiTemplate->pGlobal = ppsiGlobal;
  2768.             ppsiGlobal->pGlobal = ppsiGlobal;
  2769.             break;
  2771.         case PSPCB_CREATE:
  2772.             return TRUE;                    // Yes, please create me
  2773.     }
  2774.     return 0;
  2775. }
  2777. STDMETHODIMP CBitBucket_PS_AddPages(IShellPropSheetExt * pspx,
  2778.                                     LPFNADDPROPSHEETPAGE lpfnAddPage,
  2779.                                     LPARAM lParam)
  2780. {
  2781.     HPROPSHEETPAGE hpage;
  2782.     int idDrive;
  2783.     int iPage;
  2784.     BBPROPSHEETINFO bbpsp;
  2785.     TCHAR szTitle[MAX_PATH];
  2786.     DWORD dwSize1, dwSize2, dwSize3;
  2787.     
  2788.     // read in the global settings
  2789.     dwSize1 = SIZEOF(bbpsp.fUseGlobalSettings);
  2790.     dwSize2 = SIZEOF(bbpsp.iOriginalPercent);
  2791.     dwSize3 = SIZEOF(bbpsp.fOriginalNukeOnDelete);
  2792.     if (RegQueryValueEx(g_hkBitBucket, TEXT("UseGlobalSettings"), NULL, NULL, (LPBYTE)&bbpsp.fOriginalUseGlobalSettings, &dwSize1) != ERROR_SUCCESS ||
  2793.         RegQueryValueEx(g_hkBitBucket, TEXT("Percent"), NULL, NULL, (LPBYTE)&bbpsp.iOriginalPercent, &dwSize2) != ERROR_SUCCESS ||
  2794.         RegQueryValueEx(g_hkBitBucket, TEXT("NukeOnDelete"), NULL, NULL, (LPBYTE)&bbpsp.fOriginalNukeOnDelete, &dwSize3) != ERROR_SUCCESS)
  2795.     {
  2796.         ASSERTMSG(FALSE, "Bitbucket: could not read global settings from the registry, re-regsvr32 shell32.dll!!");
  2797.         bbpsp.fUseGlobalSettings = TRUE;
  2798.         bbpsp.iOriginalPercent = 10;
  2799.         bbpsp.fOriginalNukeOnDelete = FALSE;
  2800.     }
  2802.     bbpsp.fUseGlobalSettings = bbpsp.fOriginalUseGlobalSettings;
  2803.     bbpsp.fNukeOnDelete = bbpsp.fOriginalNukeOnDelete;
  2804.     bbpsp.iPercent = bbpsp.iOriginalPercent;
  2806.     bbpsp.psp.dwSize = SIZEOF(bbpsp);
  2807.     bbpsp.psp.dwFlags = PSP_DEFAULT | PSP_USECALLBACK;
  2808.     bbpsp.psp.hInstance = HINST_THISDLL;
  2809.     bbpsp.psp.pszTemplate = MAKEINTRESOURCE(DLG_BITBUCKET_GENCONFIG);
  2810.     bbpsp.psp.pfnDlgProc = BBGlobalPropDlgProc;
  2811.     bbpsp.psp.lParam = (LPARAM)&bbpsp;
  2812.     // the callback will fill the bbpsp.pGlobal with the pointer to the "real" psp after it has been copied
  2813.     // so that the other drive pages can get to the global information
  2814.     bbpsp.psp.pfnCallback = BBGlobalSettingsCalback;
  2816.     // add the "Global" settings page
  2817.     hpage = CreatePropertySheetPage(&bbpsp.psp);
  2819. #ifdef UNICODE
  2820.     // If this assertion fires, it means that comctl32 lost
  2821.     // backwards-compatibility with Win95 shell, WinNT4 shell,
  2822.     // and IE4 shell, all of which relied on this undocumented
  2823.     // behavior.
  2824.     ASSERT(bbpsp.pGlobal == (LPBBPROPSHEETINFO)((LPBYTE)hpage + 2 * sizeof(LPVOID)));
  2825. #else
  2826.     ASSERT(bbpsp.pGlobal == (LPBBPROPSHEETINFO)hpage);
  2827. #endif
  2829.     lpfnAddPage(hpage, lParam);
  2831.     // now create the pages for the individual drives
  2832.     bbpsp.psp.dwFlags = PSP_USETITLE;
  2833.     bbpsp.psp.pszTemplate = MAKEINTRESOURCE(DLG_BITBUCKET_CONFIG);
  2834.     bbpsp.psp.pfnDlgProc = BBDriveDlgProc;
  2835.     bbpsp.psp.pszTitle = szTitle;
  2837.     for (idDrive = 0, iPage = 1; (idDrive < MAX_BITBUCKETS) && (iPage < MAXPROPPAGES); idDrive++)
  2838.     {
  2839.         if (MakeBitBucket(idDrive))
  2840.         {
  2841.             dwSize1 = SIZEOF(bbpsp.iOriginalPercent);
  2842.             dwSize2 = SIZEOF(bbpsp.fOriginalNukeOnDelete);
  2843.             if (RegQueryValueEx(g_pBitBucket[idDrive]->hkey, TEXT("Percent"), NULL, NULL, (LPBYTE)&bbpsp.iOriginalPercent, &dwSize1) != ERROR_SUCCESS ||
  2844.                 RegQueryValueEx(g_pBitBucket[idDrive]->hkey, TEXT("NukeOnDelete"), NULL, NULL, (LPBYTE)&bbpsp.fOriginalNukeOnDelete, &dwSize2) != ERROR_SUCCESS)
  2845.             {
  2846.                 TraceMsg(TF_BITBUCKET, "Bitbucket: could not read settings from the registry for drive %d, using lame defaults", idDrive);
  2847.                 bbpsp.iOriginalPercent = 10;
  2848.                 bbpsp.fNukeOnDelete = FALSE;
  2849.             }
  2851.             bbpsp.iPercent = bbpsp.iOriginalPercent;
  2852.             bbpsp.fNukeOnDelete = bbpsp.fOriginalNukeOnDelete;
  2854.             bbpsp.idDrive = idDrive;
  2856.             BBGetDriveDisplayName(idDrive, szTitle, ARRAYSIZE(szTitle));
  2857.             hpage = CreatePropertySheetPage(&bbpsp.psp);
  2858.             lpfnAddPage(hpage, lParam);
  2859.         }
  2860.     }
  2862.     return NOERROR;
  2863. }
  2866. IContextMenuVtbl c_CBitBucketCMVtbl =
  2867. {
  2868.     CBitBucket_CM_QueryInterface,
  2869.     CBitBucket_CM_AddRef,
  2870.     CBitBucket_CM_Release,
  2871.     CBitBucket_QueryContextMenu,
  2872.     CBitBucket_InvokeCommand,
  2873.     CBitBucket_GetCommandString
  2874. };
  2876. IShellPropSheetExtVtbl c_CBitBucketPSVtbl =
  2877. {
  2878.     CBitBucket_PS_QueryInterface,
  2879.     CBitBucket_PS_AddRef,
  2880.     CBitBucket_PS_Release,
  2881.     CBitBucket_PS_AddPages,
  2882.     CCommonShellPropSheetExt_ReplacePage,
  2883. };
  2885. IShellExtInitVtbl c_CBitBucketSEIVtbl =
  2886. {
  2887.     CBitBucket_SEI_QueryInterface,
  2888.     CBitBucket_SEI_AddRef,
  2889.     CBitBucket_SEI_Release,
  2890.     CBitBucket_SEI_Initialize
  2891. };
  2893. HRESULT CBitBucket_CreateInstance(IUnknown* punkOuter, REFIID riid, void **ppvOut)
  2894. {
  2895.     HRESULT hres;
  2896.     CBitBucket *pbb = (void*)LocalAlloc(LPTR, SIZEOF(CBitBucket));
  2897.     if (pbb && InitBBGlobals())
  2898.     {
  2899.         pbb->isf.lpVtbl  = &c_CBitBucketSFVtbl;
  2900.         pbb->ipf.lpVtbl  = &c_CBitBucketPFVtbl;
  2901.         pbb->icm.lpVtbl  = &c_CBitBucketCMVtbl;
  2902.         pbb->isei.lpVtbl = &c_CBitBucketSEIVtbl;
  2903.         pbb->ips.lpVtbl  = &c_CBitBucketPSVtbl;
  2904.         pbb->cRef = 1;
  2905.         hres = CBitBucket_SF_QueryInterface(&pbb->isf, riid, ppvOut);
  2906.         CBitBucket_SF_Release(&pbb->isf);
  2907.     }
  2908.     else
  2909.     {
  2910.         *ppvOut = NULL;
  2911.         hres = E_OUTOFMEMORY;
  2912.     }
  2913.     return hres;
  2914. }
  2917. //
  2918. // takes a full path to a file in a bucket and creates a pidl for it.
  2919. //
  2920. LPITEMIDLIST DeletedFilePathToBBPidl(LPTSTR pszPath)
  2921. {
  2922.     BBDATAENTRYW bbdew;
  2924.     LPITEMIDLIST pidl = NULL;
  2925.     int idDrive = DriveIDFromBBPath(pszPath);
  2926.     int iIndex;
  2927.     DWORD dwDataEntrySize;
  2928.     HANDLE hFile;
  2930.     ASSERT(idDrive >= 0);       // general UNC case will generate -1
  2932.     iIndex = BBPathToIndex(pszPath);
  2934.     if (iIndex == -1)
  2935.         return NULL;
  2937.     dwDataEntrySize = g_pBitBucket[idDrive]->fIsUnicode ? SIZEOF(BBDATAENTRYW) : SIZEOF(BBDATAENTRYA);
  2939. #ifdef BB_USE_MRSW
  2940.     MRSW_EnterRead(g_pBitBucket[idDrive]->pmrsw);
  2941. #endif // BB_USE_MRSW
  2942.     
  2943.     hFile = OpenBBInfoFile(idDrive, OPENBBINFO_WRITE, 0);
  2944.     if (hFile != INVALID_HANDLE_VALUE)
  2945.     {
  2946.         // read records (skipping deleted)
  2947.         // until we find an index match
  2948.         while(ReadNextDataEntry(hFile, &bbdew, TRUE, dwDataEntrySize, idDrive))
  2949.         {
  2950.             if (bbdew.iIndex == iIndex)
  2951.             {
  2952.                 pidl = BBDataEntryToPidl(idDrive, &bbdew);
  2953.                 break;
  2954.             }
  2955.         }
  2956.         CloseBBInfoFile(hFile, idDrive);
  2957.     }
  2958.     
  2959. #ifdef BB_USE_MRSW
  2960.     MRSW_LeaveRead(g_pBitBucket[idDrive]->pmrsw);
  2961. #endif // BB_USE_MRSW
  2963.     return pidl;
  2964. }
  2967. BOOL_PTR CALLBACK NewDiskFullDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
  2968. {
  2969.     switch (wMsg) {
  2970.     case WM_INITDIALOG:
  2971.     {
  2972.         int idDrive = (int)lParam;
  2973.         TCHAR szNewText[MAX_PATH];
  2974.         TCHAR szText[MAX_PATH];
  2976.         GetDlgItemText(hDlg, IDD_TEXT, szText, ARRAYSIZE(szText));
  2977.         wsprintf(szNewText, szText, TEXT('A') + idDrive);
  2978.         SetDlgItemText(hDlg, IDD_TEXT, szNewText);
  2980.         break;
  2981.     }
  2983.     case WM_COMMAND:
  2984.         switch (GET_WM_COMMAND_ID(wParam, lParam)) {
  2985.         case IDC_DISKFULL_CLEANUP:
  2986.         case IDCANCEL:
  2987.             EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
  2988.             break;
  2989.         }
  2990.         break;
  2992.     default:
  2993.         return FALSE;
  2994.     }
  2995.     return TRUE;
  2996. }
  2999. void WINAPI HandleDiskFull(HWND hwnd, int idDrive)
  3000. {
  3001.     INT_PTR ret;
  3002.     if ((idDrive >= 0) && (idDrive < MAX_DRIVES))
  3003.     {
  3004.        if (IsBitBucketableDrive(idDrive)) 
  3005.        {
  3006.           ret = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_DISKFULL_NEW),
  3007.                             hwnd, NewDiskFullDlgProc, (LPARAM)idDrive);
  3008.           switch(ret)
  3009.           {
  3010.              case IDC_DISKFULL_CLEANUP:
  3011.                 LaunchDiskCleanup(hwnd, idDrive);
  3012.                 break;
  3015.              default:
  3016.                 break;
  3017.            }
  3018.        }
  3019.     }
  3020. }
  3023. STDAPI_(void) SHHandleDiskFull(HWND hwnd, int idDrive)
  3024. {
  3026.     // We will only do anything if noone has created the following named event 
  3027.     HANDLE hDisable = OpenEvent(EVENT_ALL_ACCESS, FALSE, TEXT("DisableLowDiskWarning"));
  3028.     if (!hDisable)
  3029.     {
  3030.         if (GetDiskCleanupPath(NULL, 0) && IsBitBucketableDrive(idDrive))
  3031.         {
  3032.             HandleDiskFull(hwnd, idDrive);
  3033.         }
  3034.     }
  3035.     else
  3036.     {
  3037.        CloseHandle(hDisable);
  3038.     }
  3039. }