dll/shellext/zipfldr/CZipFolder.hpp

   1 /*
   2  * PROJECT:     ReactOS Zip Shell Extension
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     Main class
   5  * COPYRIGHT:   Copyright 2017 Mark Jansen (mark.jansen@reactos.org)
   6  */
   7
   8
   9 EXTERN_C HRESULT WINAPI SHCreateFileExtractIconW(LPCWSTR pszPath, DWORD dwFileAttributes, REFIID riid, void **ppv);
  10
  11
  12 struct FolderViewColumns
  13 {
  14     int iResource;
  15     DWORD dwDefaultState;
  16     int cxChar;
  17     int fmt;
  18 };
  19
  20 static FolderViewColumns g_ColumnDefs[] =
  21 {
  22     { IDS_COL_NAME,      SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   25, LVCFMT_LEFT },
  23     { IDS_COL_TYPE,      SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   20, LVCFMT_LEFT },
  24     { IDS_COL_COMPRSIZE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   10, LVCFMT_RIGHT },
  25     { IDS_COL_PASSWORD,  SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   10, LVCFMT_LEFT },
  26     { IDS_COL_SIZE,      SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   10, LVCFMT_RIGHT },
  27     { IDS_COL_RATIO,     SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,   10, LVCFMT_LEFT },
  28     { IDS_COL_DATE_MOD,  SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT,  15, LVCFMT_LEFT },
  29 };
  30
  31
  32 class CZipFolder :
  33     public CComCoClass<CZipFolder, &CLSID_ZipFolderStorageHandler>,
  34     public CComObjectRootEx<CComMultiThreadModelNoCS>,
  35     public IShellFolder2,
  36     //public IStorage,
  37     public IContextMenu,
  38     public IShellExtInit,
  39     //public IPersistFile,
  40     public IPersistFolder2,
  41     public IZip
  42 {
  43     CStringW m_ZipFile;
  44     CStringA m_ZipDir;
  45     CComHeapPtr<ITEMIDLIST> m_CurDir;
  46     unzFile m_UnzipFile;
  47
  48 public:
  49     CZipFolder()
  50         :m_UnzipFile(NULL)
  51     {
  52     }
  53
  54     ~CZipFolder()
  55     {
  56         Close();
  57     }
  58
  59     void Close()
  60     {
  61         if (m_UnzipFile)
  62             unzClose(m_UnzipFile);
  63         m_UnzipFile = NULL;
  64     }
  65
  66     // *** IZip methods ***
  67     STDMETHODIMP_(unzFile) getZip()
  68     {
  69         if (!m_UnzipFile)
  70         {
  71             m_UnzipFile = unzOpen2_64(m_ZipFile, &g_FFunc);
  72         }
  73
  74         return m_UnzipFile;
  75     }
  76
  77     // *** IShellFolder2 methods ***
  78     STDMETHODIMP GetDefaultSearchGUID(GUID *pguid)
  79     {
  80         UNIMPLEMENTED;
  81         return E_NOTIMPL;
  82     }
  83     STDMETHODIMP EnumSearches(IEnumExtraSearch **ppenum)
  84     {
  85         UNIMPLEMENTED;
  86         return E_NOTIMPL;
  87     }
  88     STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
  89     {
  90         UNIMPLEMENTED;
  91         return E_NOTIMPL;
  92     }
  93     STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
  94     {
  95         if (!pcsFlags || iColumn >= _countof(g_ColumnDefs))
  96             return E_INVALIDARG;
  97         *pcsFlags = g_ColumnDefs[iColumn].dwDefaultState;
  98         return S_OK;
  99     }
 100     STDMETHODIMP GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 101     {
 102         UNIMPLEMENTED;
 103         return E_NOTIMPL;
 104     }
 105     // Adapted from CFileDefExt::GetFileTimeString
 106     BOOL _GetFileTimeString(LPFILETIME lpFileTime, LPWSTR pwszResult, UINT cchResult)
 107     {
 108         SYSTEMTIME st;
 109
 110         if (!FileTimeToSystemTime(lpFileTime, &st))
 111             return FALSE;
 112
 113         size_t cchRemaining = cchResult;
 114         LPWSTR pwszEnd = pwszResult;
 115         int cchWritten = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, pwszEnd, cchRemaining);
 116         if (cchWritten)
 117             --cchWritten; // GetDateFormatW returns count with terminating zero
 118         else
 119             return FALSE;
 120         cchRemaining -= cchWritten;
 121         pwszEnd += cchWritten;
 122
 123         StringCchCopyExW(pwszEnd, cchRemaining, L" ", &pwszEnd, &cchRemaining, 0);
 124
 125         cchWritten = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, pwszEnd, cchRemaining);
 126         if (cchWritten)
 127             --cchWritten; // GetTimeFormatW returns count with terminating zero
 128         else
 129             return FALSE;
 130
 131         return TRUE;
 132     }
 133     STDMETHODIMP GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
 134     {
 135         if (iColumn >= _countof(g_ColumnDefs))
 136             return E_FAIL;
 137
 138         psd->cxChar = g_ColumnDefs[iColumn].cxChar;
 139         psd->fmt = g_ColumnDefs[iColumn].fmt;
 140
 141         if (pidl == NULL)
 142         {
 143             return SHSetStrRet(&psd->str, _AtlBaseModule.GetResourceInstance(), g_ColumnDefs[iColumn].iResource);
 144         }
 145
 146         PCUIDLIST_RELATIVE curpidl = ILGetNext(pidl);
 147         if (curpidl->mkid.cb != 0)
 148         {
 149             DPRINT1("ERROR, unhandled PIDL!\n");
 150             return E_FAIL;
 151         }
 152
 153         const ZipPidlEntry* zipEntry = _ZipFromIL(pidl);
 154         if (!zipEntry)
 155             return E_INVALIDARG;
 156
 157         WCHAR Buffer[100];
 158         bool isDir = zipEntry->ZipType == ZIP_PIDL_DIRECTORY;
 159         switch (iColumn)
 160         {
 161         case 0: /* Name, ReactOS specific? */
 162             return GetDisplayNameOf(pidl, 0, &psd->str);
 163         case 1: /* Type */
 164         {
 165             SHFILEINFOA shfi;
 166             DWORD dwAttributes = isDir ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL;
 167             ULONG_PTR firet = SHGetFileInfoA(zipEntry->Name, dwAttributes, &shfi, sizeof(shfi), SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME);
 168             if (!firet)
 169                 return E_FAIL;
 170             return SHSetStrRet(&psd->str, shfi.szTypeName);
 171         }
 172         case 2: /* Compressed size */
 173         case 4: /* Size */
 174         {
 175             ULONG64 Size = iColumn == 2 ? zipEntry->CompressedSize : zipEntry->UncompressedSize;
 176             if (!StrFormatByteSizeW(Size, Buffer, _countof(Buffer)))
 177                 return E_FAIL;
 178             return SHSetStrRet(&psd->str, Buffer);
 179         }
 180         case 3: /* Password */
 181             if (isDir)
 182                 return SHSetStrRet(&psd->str, L"");
 183             return SHSetStrRet(&psd->str, _AtlBaseModule.GetResourceInstance(), zipEntry->Password ? IDS_YES : IDS_NO);
 184         case 5: /* Ratio */
 185         {
 186             int ratio = 0;
 187             if (zipEntry->UncompressedSize && !isDir)
 188                 ratio = 100 - (int)((zipEntry->CompressedSize*100)/zipEntry->UncompressedSize);
 189             StringCchPrintfW(Buffer, _countof(Buffer), L"%d%%", ratio);
 190             return SHSetStrRet(&psd->str, Buffer);
 191         }
 192         case 6: /* Date */
 193         {
 194             if (isDir)
 195                 return SHSetStrRet(&psd->str, L"");
 196             FILETIME ftLocal;
 197             DosDateTimeToFileTime((WORD)(zipEntry->DosDate>>16), (WORD)zipEntry->DosDate, &ftLocal);
 198             if (!_GetFileTimeString(&ftLocal, Buffer, _countof(Buffer)))
 199                 return E_FAIL;
 200             return SHSetStrRet(&psd->str, Buffer);
 201         }
 202         }
 203
 204         UNIMPLEMENTED;
 205         return E_NOTIMPL;
 206     }
 207     STDMETHODIMP MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
 208     {
 209         UNIMPLEMENTED;
 210         return E_NOTIMPL;
 211     }
 212
 213     // *** IShellFolder methods ***
 214     STDMETHODIMP ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl, ULONG *pdwAttributes)
 215     {
 216         UNIMPLEMENTED;
 217         return E_NOTIMPL;
 218     }
 219     STDMETHODIMP EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 220     {
 221         return _CEnumZipContents_CreateInstance(this, dwFlags, m_ZipDir, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
 222     }
 223     STDMETHODIMP BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 224     {
 225         if (riid == IID_IShellFolder)
 226         {
 227             CStringA newZipDir = m_ZipDir;
 228             PCUIDLIST_RELATIVE curpidl = pidl;
 229             while (curpidl->mkid.cb)
 230             {
 231                 const ZipPidlEntry* zipEntry = _ZipFromIL(curpidl);
 232                 if (!zipEntry)
 233                 {
 234                     return E_FAIL;
 235                 }
 236                 newZipDir += zipEntry->Name;
 237                 newZipDir += '/';
 238
 239                 curpidl = ILGetNext(curpidl);
 240             }
 241             return ShellObjectCreatorInit<CZipFolder>(m_ZipFile, newZipDir, m_CurDir, pidl, riid, ppvOut);
 242         }
 243         DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__, guid2string(riid));
 244         return E_NOTIMPL;
 245     }
 246     STDMETHODIMP BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 247     {
 248         UNIMPLEMENTED;
 249         return E_NOTIMPL;
 250     }
 251     STDMETHODIMP CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 252     {
 253         const ZipPidlEntry* zipEntry1 = _ZipFromIL(pidl1);
 254         const ZipPidlEntry* zipEntry2 = _ZipFromIL(pidl2);
 255
 256         if (!zipEntry1 || !zipEntry2)
 257             return E_INVALIDARG;
 258
 259         int result = 0;
 260         if (zipEntry1->ZipType != zipEntry2->ZipType)
 261             result = zipEntry1->ZipType - zipEntry2->ZipType;
 262         else
 263             result = stricmp(zipEntry1->Name, zipEntry2->Name);
 264
 265         if (!result && zipEntry1->ZipType == ZIP_PIDL_DIRECTORY)
 266         {
 267             PCUIDLIST_RELATIVE child1 = ILGetNext(pidl1);
 268             PCUIDLIST_RELATIVE child2 = ILGetNext(pidl2);
 269
 270             if (child1->mkid.cb && child2->mkid.cb)
 271                 return CompareIDs(lParam, child1, child2);
 272             else if (child1->mkid.cb)
 273                 result = 1;
 274             else if (child2->mkid.cb)
 275                 result = -1;
 276         }
 277
 278         return MAKE_COMPARE_HRESULT(result);
 279     }
 280     STDMETHODIMP CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
 281     {
 282         static const GUID UnknownIID = // {93F81976-6A0D-42C3-94DD-AA258A155470}
 283         {0x93F81976, 0x6A0D, 0x42C3, {0x94, 0xDD, 0xAA, 0x25, 0x8A, 0x15, 0x54, 0x70}};
 284         if (riid == IID_IShellView)
 285         {
 286             SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this};
 287             CComPtr<IShellFolderViewCB> pcb;
 288
 289             HRESULT hr = _CFolderViewCB_CreateInstance(IID_PPV_ARG(IShellFolderViewCB, &pcb));
 290             if (FAILED_UNEXPECTEDLY(hr))
 291                 return hr;
 292
 293             sfvparams.psfvcb = pcb;
 294             hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppvOut);
 295
 296             return hr;
 297         }
 298         if (riid == IID_IExplorerCommandProvider)
 299         {
 300             return _CExplorerCommandProvider_CreateInstance(this, riid, ppvOut);
 301         }
 302         if (UnknownIID != riid)
 303             DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__, guid2string(riid));
 304         return E_NOTIMPL;
 305     }
 306     STDMETHODIMP GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut)
 307     {
 308         if (!rgfInOut || !cidl || !apidl)
 309             return E_INVALIDARG;
 310
 311         *rgfInOut = 0;
 312
 313         //static DWORD dwFileAttrs = SFGAO_STREAM | SFGAO_HASPROPSHEET | SFGAO_CANDELETE | SFGAO_CANCOPY | SFGAO_CANMOVE;
 314         //static DWORD dwFolderAttrs = SFGAO_FOLDER | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANDELETE | SFGAO_STORAGE | SFGAO_CANCOPY | SFGAO_CANMOVE;
 315         static DWORD dwFileAttrs = SFGAO_STREAM;
 316         static DWORD dwFolderAttrs = SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_BROWSABLE;
 317
 318
 319         while (cidl > 0 && *apidl)
 320         {
 321             const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl);
 322
 323             if (zipEntry)
 324             {
 325                 if (zipEntry->ZipType == ZIP_PIDL_FILE)
 326                     *rgfInOut |= dwFileAttrs;
 327                 else
 328                     *rgfInOut |= dwFolderAttrs;
 329             }
 330             else
 331             {
 332                 *rgfInOut = 0;
 333             }
 334
 335             apidl++;
 336             cidl--;
 337         }
 338
 339         *rgfInOut &= ~SFGAO_VALIDATE;
 340         return S_OK;
 341     }
 342     static HRESULT CALLBACK ZipFolderMenuCallback(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj,
 343                                                   UINT uMsg, WPARAM wParam, LPARAM lParam)
 344     {
 345         switch (uMsg)
 346         {
 347         case DFM_MERGECONTEXTMENU:
 348             DPRINT1("FIXME: Add menu items for DFM_MERGECONTEXTMENU\n");
 349             return S_OK;
 350         case DFM_INVOKECOMMAND:
 351         case DFM_INVOKECOMMANDEX:
 352         case DFM_GETDEFSTATICID: // Required for Windows 7 to pick a default
 353             return S_FALSE;
 354         }
 355         return E_NOTIMPL;
 356     }
 357     STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT * prgfInOut, LPVOID * ppvOut)
 358     {
 359         if ((riid == IID_IExtractIconA || riid == IID_IExtractIconW) && cidl == 1)
 360         {
 361             const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl);
 362             if (zipEntry)
 363             {
 364                 CComHeapPtr<WCHAR> pathW;
 365
 366                 int len = MultiByteToWideChar(CP_ACP, 0, zipEntry->Name, -1, NULL, 0);
 367                 pathW.Allocate(len);
 368                 MultiByteToWideChar(CP_ACP, 0, zipEntry->Name, -1, pathW, len);
 369
 370                 DWORD dwAttributes = (zipEntry->ZipType == ZIP_PIDL_DIRECTORY) ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL;
 371                 return SHCreateFileExtractIconW(pathW, dwAttributes, riid, ppvOut);
 372             }
 373         }
 374         else if (riid == IID_IContextMenu && cidl >= 0)
 375         {
 376             const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl);
 377             if (zipEntry)
 378             {
 379                 HKEY keys[1] = {0};
 380                 int nkeys = 0;
 381                 if (zipEntry->ZipType == ZIP_PIDL_DIRECTORY)
 382                 {
 383                     LSTATUS res = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Folder", 0, KEY_READ | KEY_QUERY_VALUE, keys);
 384                     if (res != ERROR_SUCCESS)
 385                         return E_FAIL;
 386                     nkeys++;
 387                 }
 388                 return CDefFolderMenu_Create2(NULL, hwndOwner, cidl, apidl, this, ZipFolderMenuCallback, nkeys, keys, (IContextMenu**)ppvOut);
 389             }
 390         }
 391         else if (riid == IID_IDataObject && cidl >= 1)
 392         {
 393             return CIDLData_CreateFromIDArray(m_CurDir, cidl, apidl, (IDataObject**)ppvOut);
 394         }
 395
 396         DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__ , guid2string(riid));
 397         return E_NOINTERFACE;
 398     }
 399     STDMETHODIMP GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
 400     {
 401         if (!pidl)
 402             return S_FALSE;
 403
 404         PCUIDLIST_RELATIVE curpidl = ILGetNext(pidl);
 405         if (curpidl->mkid.cb != 0)
 406         {
 407             DPRINT1("ERROR, unhandled PIDL!\n");
 408             return E_FAIL;
 409         }
 410
 411         const ZipPidlEntry* zipEntry = _ZipFromIL(pidl);
 412         if (!zipEntry)
 413             return E_FAIL;
 414
 415         return SHSetStrRet(strRet, (LPCSTR)zipEntry->Name);
 416     }
 417     STDMETHODIMP SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
 418     {
 419         UNIMPLEMENTED;
 420         return E_NOTIMPL;
 421     }
 422     //// IStorage
 423     //STDMETHODIMP CreateStream(LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStream **ppstm);
 424     //STDMETHODIMP OpenStream(LPCOLESTR pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm);
 425     //STDMETHODIMP CreateStorage(LPCOLESTR pwcsName, DWORD grfMode, DWORD dwStgFmt, DWORD reserved2, IStorage **ppstg);
 426     //STDMETHODIMP OpenStorage(LPCOLESTR pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg);
 427     //STDMETHODIMP CopyTo(DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest);
 428     //STDMETHODIMP MoveElementTo(LPCOLESTR pwcsName, IStorage *pstgDest, LPCOLESTR pwcsNewName, DWORD grfFlags);
 429     //STDMETHODIMP Commit(DWORD grfCommitFlags);
 430     //STDMETHODIMP Revert();
 431     //STDMETHODIMP EnumElements(DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum);
 432     //STDMETHODIMP DestroyElement(LPCOLESTR pwcsName);
 433     //STDMETHODIMP RenameElement(LPCOLESTR pwcsOldName, LPCOLESTR pwcsNewName);
 434     //STDMETHODIMP SetElementTimes(LPCOLESTR pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime);
 435     //STDMETHODIMP SetClass(REFCLSID clsid);
 436     //STDMETHODIMP SetStateBits(DWORD grfStateBits, DWORD grfMask);
 437     //STDMETHODIMP Stat(STATSTG *pstatstg, DWORD grfStatFlag);
 438
 439     // *** IContextMenu methods ***
 440     STDMETHODIMP GetCommandString(UINT_PTR idCmd, UINT uFlags, UINT *pwReserved, LPSTR pszName, UINT cchMax)
 441     {
 442         if (idCmd != 0)
 443             return E_INVALIDARG;
 444
 445         switch (uFlags)
 446         {
 447         case GCS_VERBA:
 448             return StringCchCopyA(pszName, cchMax, EXTRACT_VERBA);
 449         case GCS_VERBW:
 450             return StringCchCopyW((LPWSTR)pszName, cchMax, EXTRACT_VERBW);
 451         case GCS_HELPTEXTA:
 452         {
 453             CStringA helpText(MAKEINTRESOURCEA(IDS_HELPTEXT));
 454             return StringCchCopyA(pszName, cchMax, helpText);
 455         }
 456         case GCS_HELPTEXTW:
 457         {
 458             CStringW helpText(MAKEINTRESOURCEA(IDS_HELPTEXT));
 459             return StringCchCopyW((LPWSTR)pszName, cchMax, helpText);
 460         }
 461         case GCS_VALIDATEA:
 462         case GCS_VALIDATEW:
 463             return S_OK;
 464         }
 465
 466         return E_INVALIDARG;
 467     }
 468     STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO pici)
 469     {
 470         if (!pici || pici->cbSize != sizeof(*pici))
 471             return E_INVALIDARG;
 472
 473         if (pici->lpVerb == MAKEINTRESOURCEA(0) || (HIWORD(pici->lpVerb) && !strcmp(pici->lpVerb, EXTRACT_VERBA)))
 474         {
 475             BSTR ZipFile = m_ZipFile.AllocSysString();
 476             InterlockedIncrement(&g_ModuleRefCnt);
 477
 478             DWORD tid;
 479             HANDLE hThread = CreateThread(NULL, 0, s_ExtractProc, ZipFile, NULL, &tid);
 480             if (hThread)
 481             {
 482                 CloseHandle(hThread);
 483                 return S_OK;
 484             }
 485         }
 486         return E_INVALIDARG;
 487     }
 488     STDMETHODIMP QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
 489     {
 490         int Entries = 0;
 491
 492         CStringW menuText(MAKEINTRESOURCEW(IDS_MENUITEM));
 493
 494         InsertMenuW(hmenu, indexMenu++, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
 495         Entries++;
 496         InsertMenuW(hmenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst++, menuText);
 497         Entries++;
 498
 499         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, Entries);
 500     }
 501
 502     // *** IShellExtInit methods ***
 503     STDMETHODIMP Initialize(LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hkeyProgID)
 504     {
 505         FORMATETC etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
 506         STGMEDIUM stg;
 507
 508         HRESULT hr = pDataObj->GetData(&etc, &stg);
 509         if (FAILED_UNEXPECTEDLY(hr))
 510         {
 511             return hr;
 512         }
 513         hr = E_FAIL;
 514         HDROP hdrop = (HDROP)GlobalLock(stg.hGlobal);
 515         if (hdrop)
 516         {
 517             UINT uNumFiles = DragQueryFileW(hdrop, 0xFFFFFFFF, NULL, 0);
 518             if (uNumFiles == 1)
 519             {
 520                 WCHAR szFile[MAX_PATH * 2];
 521                 if (DragQueryFileW(hdrop, 0, szFile, _countof(szFile)))
 522                 {
 523                     CComHeapPtr<ITEMIDLIST> pidl;
 524                     hr = SHParseDisplayName(szFile, NULL, &pidl, 0, NULL);
 525                     if (!FAILED_UNEXPECTEDLY(hr))
 526                     {
 527                         hr = Initialize(pidl);
 528                     }
 529                 }
 530                 else
 531                 {
 532                     DbgPrint("Failed to query the file.\r\n");
 533                 }
 534             }
 535             else
 536             {
 537                 DbgPrint("Invalid number of files: %d\r\n", uNumFiles);
 538             }
 539             GlobalUnlock(stg.hGlobal);
 540         }
 541         else
 542         {
 543             DbgPrint("Could not lock stg.hGlobal\r\n");
 544         }
 545         ReleaseStgMedium(&stg);
 546         return hr;
 547
 548     }
 549
 550     //// IPersistFile
 551     ////STDMETHODIMP GetClassID(CLSID *pclsid);
 552     //STDMETHODIMP IsDirty();
 553     //STDMETHODIMP Load(LPCOLESTR pszFileName, DWORD dwMode);
 554     //STDMETHODIMP Save(LPCOLESTR pszFileName, BOOL fRemember);
 555     //STDMETHODIMP SaveCompleted(LPCOLESTR pszFileName);
 556     //STDMETHODIMP GetCurFile(LPOLESTR *ppszFileName);
 557
 558     //// *** IPersistFolder2 methods ***
 559     STDMETHODIMP GetCurFolder(LPITEMIDLIST * pidl)
 560     {
 561         *pidl = ILClone(m_CurDir);
 562         return S_OK;
 563     }
 564
 565     // *** IPersistFolder methods ***
 566     STDMETHODIMP Initialize(LPCITEMIDLIST pidl)
 567     {
 568         WCHAR tmpPath[MAX_PATH];
 569
 570         if (SHGetPathFromIDListW(pidl, tmpPath))
 571         {
 572             m_ZipFile = tmpPath;
 573             m_CurDir.Attach(ILClone(pidl));
 574             return S_OK;
 575         }
 576         DbgPrint("%s() => Unable to parse pidl\n", __FUNCTION__);
 577         return E_INVALIDARG;
 578     }
 579
 580     // *** IPersist methods ***
 581     STDMETHODIMP GetClassID(CLSID *lpClassId)
 582     {
 583         DbgPrint("%s\n", __FUNCTION__);
 584         return E_NOTIMPL;
 585     }
 586
 587
 588     STDMETHODIMP Initialize(PCWSTR zipFile, PCSTR zipDir, PCUIDLIST_ABSOLUTE curDir, PCUIDLIST_RELATIVE pidl)
 589     {
 590         m_ZipFile = zipFile;
 591         m_ZipDir = zipDir;
 592
 593         m_CurDir.Attach(ILCombine(curDir, pidl));
 594         return S_OK;
 595     }
 596     static DWORD WINAPI s_ExtractProc(LPVOID arg)
 597     {
 598         CComBSTR ZipFile;
 599         ZipFile.Attach((BSTR)arg);
 600
 601         _CZipExtract_runWizard(ZipFile);
 602
 603         InterlockedDecrement(&g_ModuleRefCnt);
 604         return 0;
 605     }
 606
 607 public:
 608     DECLARE_NO_REGISTRY()   // Handled manually because this object is exposed via multiple clsid's
 609     DECLARE_NOT_AGGREGATABLE(CZipFolder)
 610
 611     DECLARE_PROTECT_FINAL_CONSTRUCT()
 612
 613     BEGIN_COM_MAP(CZipFolder)
 614         COM_INTERFACE_ENTRY_IID(IID_IShellFolder2, IShellFolder2)
 615         COM_INTERFACE_ENTRY_IID(IID_IShellFolder, IShellFolder)
 616 //        COM_INTERFACE_ENTRY_IID(IID_IStorage, IStorage)
 617         COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
 618         COM_INTERFACE_ENTRY_IID(IID_IShellExtInit, IShellExtInit)
 619         //COM_INTERFACE_ENTRY_IID(IID_IPersistFile, IPersistFile)
 620         COM_INTERFACE_ENTRY_IID(IID_IPersistFolder2, IPersistFolder2)
 621         COM_INTERFACE_ENTRY_IID(IID_IPersistFolder, IPersistFolder)
 622         COM_INTERFACE_ENTRY_IID(IID_IPersist, IPersist)
 623     END_COM_MAP()
 624 };
 625