folder.cpp File Reference

#include "cabview.h"
#include "util.h"
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for folder.cpp:

Go to the source code of this file.

Classes
struct	FOLDERCOLUMN
struct	CABITEM
struct	FILLCALLBACKDATA
struct	EXTRACTFILESDATA

Enumerations
enum	FOLDERCOLUMNS {   COL_NAME , COL_SIZE , COL_TYPE , COL_MDATE ,   COL_PATH , COL_ATT , COLCOUNT }

Functions
static CABITEM *	CreateItem (LPCWSTR Path, UINT Attrib, UINT Size, UINT DateTime)
static CABITEM *	CreateItem (LPCSTR Path, UINT Attrib, UINT Size=0, UINT DateTime=0)
static HRESULT CALLBACK	ItemMenuCallback (IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
static HRESULT CALLBACK	FolderBackgroundMenuCallback (IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
static HRESULT CALLBACK	EnumFillCallback (EXTRACTCALLBACKMSG msg, const EXTRACTCALLBACKDATA &ecd, LPVOID cookie)
static HRESULT	GetFsPathFromIDList (PCIDLIST_ABSOLUTE pidl, PWSTR pszPath)
static int CALLBACK	FolderBrowseCallback (HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
static HWND	GetUiOwner (const EXTRACTFILESDATA &data)
static HRESULT CALLBACK	ExtractFilesCallback (EXTRACTCALLBACKMSG msg, const EXTRACTCALLBACKDATA &ecd, LPVOID cookie)
static void	Free (EXTRACTFILESDATA &data)
static DWORD CALLBACK	ExtractFilesThread (LPVOID pParam)

Variables
static const struct FOLDERCOLUMN	g_Columns []

Enumeration Type Documentation

FOLDERCOLUMNS

enum FOLDERCOLUMNS

Enumerator
COL_NAME
COL_SIZE
COL_TYPE
COL_MDATE
COL_PATH
COL_ATT
COLCOUNT

Definition at line 11 of file folder.cpp.

{
    COL_NAME,   // PKEY_ItemNameDisplay
    COL_SIZE,   // PKEY_Size
    COL_TYPE,   // PKEY_ItemTypeText
    COL_MDATE,  // PKEY_DateModified
    COL_PATH,   // PKEY_?: Archive-relative path
    COL_ATT,    // PKEY_FileAttributes
    COLCOUNT
};

Function Documentation

CreateItem() [1/2]

static CABITEM * CreateItem ( LPCSTR  Path, UINT  Attrib, UINT  Size = 0, UINT  DateTime = 0  )

static

Definition at line 102 of file folder.cpp.

{
    WCHAR buf[MAX_PATH * 2];
    UINT codepage = (Attrib & _A_NAME_IS_UTF) ? CP_UTF8 : CP_ACP;
    if (MultiByteToWideChar(codepage, 0, Path, -1, buf, _countof(buf)))
        return CreateItem(buf, Attrib, Size, DateTime);
    return NULL;
}

CreateItem() [2/2]

static CABITEM * CreateItem ( LPCWSTR  Path, UINT  Attrib, UINT  Size, UINT  DateTime  )

static

Definition at line 69 of file folder.cpp.

{
    const SIZE_T len = lstrlenW(Path), cb = FIELD_OFFSET(CABITEM, Path[len + 1]);
    if (cb > 0xffff)
        return NULL;
    CABITEM *p = (CABITEM*)SHAlloc(cb + sizeof(USHORT));
    if (p)
    {
        p->cb = (USHORT)cb;
        p->Unknown = 0;
        p->Size = Size;
        p->Attrib = Attrib;
        p->Date = HIWORD(DateTime);
        p->Time = LOWORD(DateTime);
        p->NameOffset = 0;
        for (UINT i = 0;; ++i)
        {
            WCHAR c = Path[i];
            if (c == L':') // Don't allow absolute paths
                c = L'_';
            if (c == L'/') // Normalize
                c = L'\\';
            if (c == '\\')
                p->NameOffset = i + 1;
            p->Path[i] = c;
            if (!c)
                break;
        }
        ((SHITEMID*)((BYTE*)p + cb))->cb = 0;
    }
    return p;
}

Referenced by CreateItem(), DispatchCreateKMix(), DispatchCreateSysAudio(), EnumFillCallback(), ExtractFilesCallback(), IKsFilter_DispatchCreatePin(), IKsFilterFactory_Create(), IKsFilterFactory_fnInitialize(), IKsFilterFactory_ItemFreeCb(), IKsPin_DispatchCreateClock(), InitializeFilterWithKs(), KMixAllocateDeviceHeader(), KopAddDevice(), KsAllocateObjectCreateItem(), KsDispatchQuerySecurity(), KsDispatchSetSecurity(), KsFilterFactoryAddCreateItem(), KsFreeObjectCreateItem(), KspCreateFilter(), KspCreatePin(), NewDispatchObject(), PcCreateItemDispatch(), PcCreatePinDispatch(), and SysAudioAllocateDeviceHeader().

EnumFillCallback()

static HRESULT CALLBACK EnumFillCallback ( EXTRACTCALLBACKMSG  msg, const EXTRACTCALLBACKDATA &  ecd, LPVOID  cookie  )

static

Definition at line 189 of file folder.cpp.

{
    FILLCALLBACKDATA &data = *(FILLCALLBACKDATA*)cookie;
 
    switch ((UINT)msg)
    {
        case ECM_FILE:
        {
            const FDINOTIFICATION &fdin = *ecd.pfdin;
            HRESULT hr = S_FALSE;
            SFGAOF attr = MapFSToSFAttributes(fdin.attribs & CABITEM::FSATTS);
            if (IncludeInEnumIDList(data.ContF, attr))
            {
                UINT datetime = MAKELONG(fdin.time, fdin.date);
                CABITEM *item = CreateItem(fdin.psz1, fdin.attribs, fdin.cb, datetime);
                if (!item)
                    return E_OUTOFMEMORY;
                if (FAILED(hr = data.pEIDL->Append((LPCITEMIDLIST)item)))
                    SHFree(item);
            }
            return SUCCEEDED(hr) ? S_FALSE : hr; // Never extract
        }
    }
    return E_NOTIMPL;
}

Referenced by CEnumIDList::Fill().

ExtractFilesCallback()

static HRESULT CALLBACK ExtractFilesCallback ( EXTRACTCALLBACKMSG  msg, const EXTRACTCALLBACKDATA &  ecd, LPVOID  cookie  )

static

Definition at line 717 of file folder.cpp.

{
    EXTRACTFILESDATA &data = *(EXTRACTFILESDATA*)cookie;
    switch ((UINT)msg)
    {
        case ECM_BEGIN:
        {
            data.cabfiles = (UINT)(SIZE_T)ecd.pfdin->hf;
            return S_OK;
        }
 
        case ECM_FILE:
        {
            if (data.pPD && data.pPD->HasUserCancelled())
                return HRESULT_FROM_WIN32(ERROR_CANCELLED);
            HRESULT hr = data.pCIDA ? S_FALSE : S_OK; // Filtering or all items?
            if (hr != S_OK)
            {
                CABITEM *needle = CreateItem(ecd.pfdin->psz1, ecd.pfdin->attribs);
                if (!needle)
                    return E_OUTOFMEMORY;
                for (UINT i = 0; i < data.pCIDA->cidl && hr == S_FALSE; ++i)
                {
                    C_ASSERT(FLATFOLDER);
                    LPCITEMIDLIST pidlChild = ILFindLastID(HIDA_GetPIDLItem(data.pCIDA, i));
                    CABITEM *haystack = CABITEM::Validate(pidlChild);
                    if (!haystack && FAILED_UNEXPECTEDLY(hr = E_FAIL))
                        break;
                    if (!lstrcmpiW(needle->Path, haystack->Path))
                    {
                        if (data.pPD)
                            data.pPD->SetLine(1, needle->Path, TRUE, NULL);
                        hr = S_OK; // Found it in the list of files to extract
                    }
                }
                SHFree(needle);
            }
            if (data.pPD)
                data.pPD->SetProgress(data.completed++, data.cabfiles);
            return hr;
        }
 
        case ECM_PREPAREPATH:
        {
            UINT flags = SHPPFW_DIRCREATE | SHPPFW_IGNOREFILENAME;
            return SHPathPrepareForWriteW(GetUiOwner(data), NULL, ecd.Path, flags);
        }
 
        case ECM_ERROR:
        {
            return ErrorBox(GetUiOwner(data), ecd.hr);
        }
    }
    return E_NOTIMPL;
}

Referenced by ExtractFilesThread().

ExtractFilesThread()

static DWORD CALLBACK ExtractFilesThread ( LPVOID  pParam )

static

Definition at line 787 of file folder.cpp.

{
    EXTRACTFILESDATA &data = *(EXTRACTFILESDATA*)pParam;
    HRESULT hr = S_OK;
    if (SUCCEEDED(SHCoCreateInstance(NULL, &CLSID_ProgressDialog, NULL, IID_PPV_ARG(IProgressDialog, &data.pPD))))
    {
        // TODO: IActionProgress SPACTION_COPYING
        if (SUCCEEDED(data.pPD->StartProgressDialog(data.hWndOwner, NULL, PROGDLG_NOTIME, NULL)))
        {
            data.pPD->SetTitle(data.cab);
            data.pPD->SetLine(2, data.path, TRUE, NULL);
            data.pPD->SetAnimation(GetModuleHandleW(L"SHELL32"), 161);
            data.pPD->SetProgress(0, 0);
        }
    }
    if (data.pMarshalDO)
    {
        hr = CoGetInterfaceAndReleaseStream(data.pMarshalDO, IID_PPV_ARG(IDataObject, &data.pDO));
        data.pMarshalDO = NULL;
        if (SUCCEEDED(hr))
            hr = CDataObjectHIDA::CreateCIDA(data.pDO, &data.pCIDA, data.cidamedium);
    }
    if (SUCCEEDED(hr))
    {
        ExtractCabinet(data.cab, data.path, ExtractFilesCallback, &data);
    }
    Free(data);
    return 0;
}

Referenced by CCabFolder::ExtractFilesUI().

FolderBackgroundMenuCallback()

static HRESULT CALLBACK FolderBackgroundMenuCallback ( IShellFolder *  psf, HWND  hwnd, IDataObject *  pdtobj, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 164 of file folder.cpp.

{
    return ItemMenuCallback(psf, hwnd, NULL, uMsg, wParam, lParam);
}

Referenced by CCabFolder::CreateViewObject().

FolderBrowseCallback()

static int CALLBACK FolderBrowseCallback ( HWND  hwnd, UINT  uMsg, LPARAM  lParam, LPARAM  lpData  )

static

Definition at line 645 of file folder.cpp.

{
    WCHAR buf[MAX_PATH];
    switch (uMsg)
    {
        case BFFM_INITIALIZED:
        {
            if (LoadStringW(_AtlBaseModule.GetResourceInstance(), IDS_EXTRACT, buf, _countof(buf)))
            {
                // Remove leading and trailing dots
                WCHAR *s = buf, *e = s + lstrlenW(s);
                while (*s == '.') ++s;
                while (e > s && e[-1] == '.') *--e = UNICODE_NULL;
                SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)s);
                SendMessageW(GetDlgItem(hwnd, IDOK), WM_SETTEXT, 0, (LPARAM)s);
            }
            if (lpData)
            {
                SendMessageW(hwnd, BFFM_SETEXPANDED, FALSE, lpData);
                SendMessageW(hwnd, BFFM_SETSELECTION, FALSE, lpData);
            }
            break;
        }
 
        case BFFM_SELCHANGED:
        {
            SFGAOF wanted = SFGAO_FILESYSTEM | SFGAO_FOLDER, query = wanted | SFGAO_STREAM;
            PCIDLIST_ABSOLUTE pidl = (PCIDLIST_ABSOLUTE)lParam;
            BOOL enable = ILIsEmpty(pidl); // Allow the desktop
            PCUITEMID_CHILD child;
            IShellFolder *pSF;
            if (SUCCEEDED(SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &pSF), &child)))
            {
                SFGAOF attrib = query;
                if (SUCCEEDED(pSF->GetAttributesOf(1, &child, &attrib)))
                    enable = (attrib & query) == wanted;
                pSF->Release();
            }
            if (enable)
            {
                // We don't trust .zip folders, check the file-system to make sure
                UINT attrib = SUCCEEDED(GetFsPathFromIDList(pidl, buf)) ? GetFileAttributesW(buf) : 0;
                enable = (attrib & FILE_ATTRIBUTE_DIRECTORY) && attrib != INVALID_FILE_ATTRIBUTES;
            }
            PostMessageW(hwnd, BFFM_ENABLEOK, 0, enable);
            break;
        }
    }
    return 0;
}

Referenced by CCabFolder::ExtractFilesUI().

Free()

static void Free ( EXTRACTFILESDATA &  data )

static

Definition at line 773 of file folder.cpp.

{
    if (data.pPD)
    {
        data.pPD->StopProgressDialog();
        data.pPD->Release();
    }
    CDataObjectHIDA::DestroyCIDA(data.pCIDA, data.cidamedium);
    IUnknown_Set((IUnknown**)&data.pDO, NULL);
    IUnknown_Set((IUnknown**)&data.pMarshalDO, NULL);
    IUnknown_Set((IUnknown**)&data.pLifetimeCF, NULL);
    SHFree(&data);
}

GetFsPathFromIDList()

static HRESULT GetFsPathFromIDList ( PCIDLIST_ABSOLUTE  pidl, PWSTR  pszPath  )

static

Definition at line 637 of file folder.cpp.

{
    BOOL ret = SHGetPathFromIDListW(pidl, pszPath);
    if (!ret && ILIsEmpty(pidl))
        ret = SHGetSpecialFolderPathW(NULL, pszPath, CSIDL_DESKTOPDIRECTORY, TRUE);
    return ret ? S_OK : HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}

Referenced by CCabFolder::ExtractFilesUI(), and FolderBrowseCallback().

GetUiOwner()

static HWND GetUiOwner ( const EXTRACTFILESDATA &  data )

static

Definition at line 709 of file folder.cpp.

{
    HWND hWnd;
    if (SUCCEEDED(IUnknown_GetWindow(data.pPD, &hWnd)) && IsWindowVisible(hWnd))
        return hWnd;
    return IsWindowVisible(data.hWndOwner) ? data.hWndOwner : NULL;
}

Referenced by ExtractFilesCallback().

ItemMenuCallback()

static HRESULT CALLBACK ItemMenuCallback ( IShellFolder *  psf, HWND  hwnd, IDataObject *  pdtobj, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 111 of file folder.cpp.

{
    enum { IDC_EXTRACT, IDC_EXTRACTALL };
    HRESULT hr = E_NOTIMPL;
    const BOOL Background = !pdtobj;
 
    switch (uMsg)
    {
        case DFM_MODIFYQCMFLAGS:
        {
            *((UINT*)lParam) = wParam | CMF_NOVERBS | (Background ? 0 : CMF_VERBSONLY);
            return S_OK;
        }
 
        case DFM_MERGECONTEXTMENU:
        {
            QCMINFO &qcmi = *(QCMINFO*)lParam;
            UINT pos = qcmi.indexMenu, id = 0;
            if (Background || SUCCEEDED(hr = InsertMenuItem(qcmi, pos, id, IDC_EXTRACT, IDS_EXTRACT, MFS_DEFAULT)))
            {
                hr = InsertMenuItem(qcmi, pos, id, IDC_EXTRACTALL, IDS_EXTRACTALL);
                if (SUCCEEDED(hr) && !Background)
                {
                    --pos;
                    InsertMenuItem(qcmi, pos, id, 0, -1); // Separator
                }
            }
            if (SUCCEEDED(hr))
            {
                qcmi.idCmdFirst = id + 1;
                hr = S_FALSE; // Don't add verbs
            }
            break;
        }
 
        case DFM_INVOKECOMMAND:
        {
            hr = S_FALSE;
            CCabFolder *pCabFolder = static_cast<CCabFolder*>(psf);
            switch (wParam)
            {
                case IDC_EXTRACT:
                case IDC_EXTRACTALL:
                    hr = pCabFolder->ExtractFilesUI(hwnd, wParam == IDC_EXTRACT ? pdtobj : NULL);
                    break;
            }
            break;
        }
    }
    return hr;
}

Referenced by FolderBackgroundMenuCallback(), and CCabFolder::GetUIObjectOf().

Variable Documentation

g_Columns

const struct FOLDERCOLUMN g_Columns[]

static

Initial value:

=
{
    { IDS_COL_NAME, LVCFMT_LEFT, 20, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, &FMTID_Storage, PID_STG_NAME },
    { IDS_COL_SIZE, LVCFMT_RIGHT, 16, SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT, &FMTID_Storage, PID_STG_SIZE },
    { IDS_COL_TYPE, LVCFMT_LEFT, 20, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, &FMTID_Storage, PID_STG_STORAGETYPE },
    { IDS_COL_MDATE, LVCFMT_LEFT, 20, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, &FMTID_Storage, PID_STG_WRITETIME },
    { IDS_COL_PATH, LVCFMT_LEFT, 30, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, &CLSID_CabFolder, 0 },
    { IDS_COL_ATT, LVCFMT_RIGHT, 10, SHCOLSTATE_TYPE_STR, &FMTID_Storage, PID_STG_ATTRIBUTES },
}

Referenced by CCabFolder::GetDefaultColumnState(), CCabFolder::GetDetailsOf(), CCabFolder::MapColumnToSCID(), and CCabFolder::MapSCIDToColumn().