CFindFolder.cpp File Reference

#include "CFindFolder.h"
#include <exdispid.h>

Include dependency graph for CFindFolder.cpp:

Go to the source code of this file.

Classes
struct	FolderViewColumns
struct	_SearchData
class	CFindFolderContextMenu

Macros
#define	IS_TEXT_UNKNOWN_FLAGS_MASK   ((7 << 13) | (1 << 11))
#define	IS_DOTS(psz)   ((psz)[0] == L'.' && ((psz)[1] == 0 || ((psz)[1] == L'.' && (psz)[2] == 0)))

Enumerations
enum	ENCODING {   ENCODING_ANSI = 0 , ENCODING_UTF16LE = 1 , ENCODING_UTF16BE = 2 , ENCODING_UTF8 = 3 ,   ENCODING_AUTO = -1 , ENCODING_ANSI = 0 , ENCODING_UTF16LE = 1 , ENCODING_UTF16BE = 2 ,   ENCODING_UTF8 = 3 , ENCODING_UTF8BOM = 4 , ENCODING_ANSI = 0 , ENCODING_UTF16LE = 1 ,   ENCODING_UTF16BE = 2 , ENCODING_UTF8 = 3 , ENCODING_ANSI = 1 , ENCODING_UTF8 ,   ENCODING_UTF16LE , ENCODING_UTF16BE }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shellfind)
static HRESULT	SHELL32_CoCreateInitSF (LPCITEMIDLIST pidlRoot, PERSIST_FOLDER_TARGET_INFO *ppfti, LPCITEMIDLIST pidlChild, const GUID *clsid, REFIID riid, LPVOID *ppvOut)
static void WINAPI	_InsertMenuItemW (HMENU hMenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
static LPITEMIDLIST	_ILCreate (LPCWSTR lpszPath)
static LPCWSTR	_ILGetPath (LPCITEMIDLIST pidl)
static LPCITEMIDLIST	_ILGetFSPidl (LPCITEMIDLIST pidl)
template<typename TChar , typename TString , int(&)(const TChar *, const TChar *, size_t) StrNCmp>
static const TChar *	StrStrN (const TChar *lpFirst, const TString &lpSrch, UINT cchMax)
static BOOL	StrFindNIA (const CHAR *lpFirst, const CStringA &lpSrch, UINT cchMax)
static BOOL	StrFindNIW (const WCHAR *lpFirst, const CStringW &lpSrch, UINT cchMax)
static BOOL	IsDataUnicode (IN PVOID Buffer, IN DWORD BufferSize, OUT ENCODING *Encoding OPTIONAL, OUT PDWORD SkipBytes OPTIONAL)
static BOOL	SearchFile (LPCWSTR lpFilePath, _SearchData *pSearchData)
static BOOL	FileNameMatch (LPCWSTR FindDataFileName, _SearchData *pSearchData)
static BOOL	ContentsMatch (LPCWSTR szPath, _SearchData *pSearchData)
static BOOL	AttribHiddenMatch (DWORD FileAttributes, _SearchData *pSearchData)
static UINT	RecursiveFind (LPCWSTR lpPath, _SearchData *pSearchData)

Variables
static FolderViewColumns	g_ColumnDefs []

Macro Definition Documentation

IS_DOTS

#define IS_DOTS

(

psz

)

((psz)[0] == L'.' && ((psz)[1] == 0 || ((psz)[1] == L'.' && (psz)[2] == 0)))

IS_TEXT_UNKNOWN_FLAGS_MASK

#define IS_TEXT_UNKNOWN_FLAGS_MASK   ((7 << 13) | (1 << 11))

Enumeration Type Documentation

ENCODING

enum ENCODING

Enumerator
ENCODING_ANSI
ENCODING_UTF16LE
ENCODING_UTF16BE
ENCODING_UTF8
ENCODING_AUTO
ENCODING_ANSI
ENCODING_UTF16LE
ENCODING_UTF16BE
ENCODING_UTF8
ENCODING_UTF8BOM
ENCODING_ANSI
ENCODING_UTF16LE
ENCODING_UTF16BE
ENCODING_UTF8
ENCODING_ANSI
ENCODING_UTF8
ENCODING_UTF16LE
ENCODING_UTF16BE

Definition at line 191 of file CFindFolder.cpp.

{
    ENCODING_ANSI    =  0,
    ENCODING_UTF16LE =  1,
    ENCODING_UTF16BE =  2,
    ENCODING_UTF8    =  3
} ENCODING;

Function Documentation

_ILCreate()

static LPITEMIDLIST _ILCreate ( LPCWSTR  lpszPath )

static

Definition at line 99 of file CFindFolder.cpp.

{
    CComHeapPtr<ITEMIDLIST> lpFSPidl(ILCreateFromPathW(lpszPath));
    if (!lpFSPidl)
    {
        ERR("Failed to create pidl from path\n");
        return NULL;
    }
    LPITEMIDLIST lpLastFSPidl = ILFindLastID(lpFSPidl);
 
    int pathLen = (PathFindFileNameW(lpszPath) - lpszPath) * sizeof(WCHAR);
    int cbData = sizeof(WORD) + pathLen + lpLastFSPidl->mkid.cb;
    LPITEMIDLIST pidl = (LPITEMIDLIST) SHAlloc(cbData + sizeof(WORD));
    if (!pidl)
        return NULL;
 
    LPBYTE p = (LPBYTE) pidl;
    *((WORD *) p) = cbData;
    p += sizeof(WORD);
 
    memcpy(p, lpszPath, pathLen);
    p += pathLen - sizeof(WCHAR);
    *((WCHAR *) p) = '\0';
    p += sizeof(WCHAR);
 
    memcpy(p, lpLastFSPidl, lpLastFSPidl->mkid.cb);
    p += lpLastFSPidl->mkid.cb;
 
    *((WORD *) p) = 0;
 
    return pidl;
}

_ILGetFSPidl()

static LPCITEMIDLIST _ILGetFSPidl ( LPCITEMIDLIST  pidl )

static

Definition at line 139 of file CFindFolder.cpp.

{
    if (!pidl || !pidl->mkid.cb)
        return pidl;
    return (LPCITEMIDLIST) ((LPBYTE) pidl->mkid.abID
                            + ((wcslen((LPCWSTR) pidl->mkid.abID) + 1) * sizeof(WCHAR)));
}

Referenced by CFindFolder::CompareIDs(), CFindFolder::GetAttributesOf(), CFindFolder::GetDetailsOf(), CFindFolder::GetDisplayNameOf(), CFindFolder::GetUIObjectOf(), and CFindFolderContextMenu::InvokeCommand().

_ILGetPath()

static LPCWSTR _ILGetPath ( LPCITEMIDLIST  pidl )

static

Definition at line 132 of file CFindFolder.cpp.

{
    if (!pidl || !pidl->mkid.cb)
        return NULL;
    return (LPCWSTR) pidl->mkid.abID;
}

Referenced by CFindFolder::CompareIDs(), CFindFolder::GetDetailsOf(), CFindFolder::GetUIObjectOf(), and CFindFolderContextMenu::InvokeCommand().

_InsertMenuItemW()

static void WINAPI _InsertMenuItemW ( HMENU  hMenu, UINT  indexMenu, BOOL  fByPosition, UINT  wID, UINT  fType, LPCWSTR  dwTypeData, UINT  fState  )

static

Definition at line 40 of file CFindFolder.cpp.

{
    MENUITEMINFOW mii;
    WCHAR wszText[100];
 
    ZeroMemory(&mii, sizeof(mii));
    mii.cbSize = sizeof(mii);
    if (fType == MFT_SEPARATOR)
        mii.fMask = MIIM_ID | MIIM_TYPE;
    else if (fType == MFT_STRING)
    {
        mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;
        if (IS_INTRESOURCE(dwTypeData))
        {
            if (LoadStringW(_AtlBaseModule.GetResourceInstance(), LOWORD((ULONG_PTR)dwTypeData), wszText, _countof(wszText)))
                mii.dwTypeData = wszText;
            else
            {
                ERR("failed to load string %p\n", dwTypeData);
                return;
            }
        }
        else
            mii.dwTypeData = (LPWSTR)dwTypeData;
        mii.fState = fState;
    }
 
    mii.wID = wID;
    mii.fType = fType;
    InsertMenuItemW(hMenu, indexMenu, fByPosition, &mii);
}

Referenced by CFindFolderContextMenu::QueryContextMenu().

AttribHiddenMatch()

static BOOL AttribHiddenMatch ( DWORD  FileAttributes, _SearchData *  pSearchData  )

static

Definition at line 392 of file CFindFolder.cpp.

{
    if (!(FileAttributes & FILE_ATTRIBUTE_HIDDEN) || (pSearchData->SearchHidden))
    {
        return TRUE;
    }
    return FALSE;
}

Referenced by RecursiveFind().

ContentsMatch()

static BOOL ContentsMatch ( LPCWSTR  szPath, _SearchData *  pSearchData  )

static

Definition at line 383 of file CFindFolder.cpp.

{
    if (pSearchData->szQueryA.IsEmpty() || SearchFile(szPath, pSearchData))
    {
        return TRUE;
    }
    return FALSE;
}

Referenced by RecursiveFind().

FileNameMatch()

static BOOL FileNameMatch ( LPCWSTR  FindDataFileName, _SearchData *  pSearchData  )

static

Definition at line 374 of file CFindFolder.cpp.

{
    if (pSearchData->szFileName.IsEmpty() || PathMatchSpecW(FindDataFileName, pSearchData->szFileName))
    {
        return TRUE;
    }
    return FALSE;
}

Referenced by RecursiveFind().

IsDataUnicode()

static BOOL IsDataUnicode ( IN PVOID  Buffer, IN DWORD  BufferSize, OUT ENCODING *Encoding  OPTIONAL, OUT PDWORD SkipBytes  OPTIONAL  )

static

Definition at line 200 of file CFindFolder.cpp.

{
    PBYTE pBytes = (PBYTE)Buffer;
    ENCODING encFile = ENCODING_ANSI;
    DWORD dwPos = 0;
 
    /*
     * See http://archives.miloush.net/michkap/archive/2007/04/22/2239345.html
     * for more details about the algorithm and the pitfalls behind it.
     * Of course it would be actually great to make a nice function that
     * would work, once and for all, and put it into a library.
     */
 
    /* Look for Byte Order Marks */
    if ((BufferSize >= 2) && (pBytes[0] == 0xFF) && (pBytes[1] == 0xFE))
    {
        encFile = ENCODING_UTF16LE;
        dwPos = 2;
    }
    else if ((BufferSize >= 2) && (pBytes[0] == 0xFE) && (pBytes[1] == 0xFF))
    {
        encFile = ENCODING_UTF16BE;
        dwPos = 2;
    }
    else if ((BufferSize >= 3) && (pBytes[0] == 0xEF) && (pBytes[1] == 0xBB) && (pBytes[2] == 0xBF))
    {
        encFile = ENCODING_UTF8;
        dwPos = 3;
    }
    else
    {
        /*
         * Try using statistical analysis. Do not rely on the return value of
         * IsTextUnicode as we can get FALSE even if the text is in UTF-16 BE
         * (i.e. we have some of the IS_TEXT_UNICODE_REVERSE_MASK bits set).
         * Instead, set all the tests we want to perform, then just check
         * the passed tests and try to deduce the string properties.
         */
 
/*
 * This mask contains the 3 highest bits from IS_TEXT_UNICODE_NOT_ASCII_MASK
 * and the 1st highest bit from IS_TEXT_UNICODE_NOT_UNICODE_MASK.
 */
#define IS_TEXT_UNKNOWN_FLAGS_MASK  ((7 << 13) | (1 << 11))
 
        /* Flag out the unknown flags here, the passed tests will not have them either */
        INT Tests = (IS_TEXT_UNICODE_NOT_ASCII_MASK   |
                     IS_TEXT_UNICODE_NOT_UNICODE_MASK |
                     IS_TEXT_UNICODE_REVERSE_MASK | IS_TEXT_UNICODE_UNICODE_MASK)
                        & ~IS_TEXT_UNKNOWN_FLAGS_MASK;
        INT Results;
 
        IsTextUnicode(Buffer, BufferSize, &Tests);
        Results = Tests;
 
        /*
         * As the IS_TEXT_UNICODE_NULL_BYTES or IS_TEXT_UNICODE_ILLEGAL_CHARS
         * flags are expected to be potentially present in the result without
         * modifying our expectations, filter them out now.
         */
        Results &= ~(IS_TEXT_UNICODE_NULL_BYTES | IS_TEXT_UNICODE_ILLEGAL_CHARS);
 
        /*
         * NOTE: The flags IS_TEXT_UNICODE_ASCII16 and
         * IS_TEXT_UNICODE_REVERSE_ASCII16 are not reliable.
         *
         * NOTE2: Check for potential "bush hid the facts" effect by also
         * checking the original results (in 'Tests') for the absence of
         * the IS_TEXT_UNICODE_NULL_BYTES flag, as we may presumably expect
         * that in UTF-16 text there will be at some point some NULL bytes.
         * If not, fall back to ANSI. This shows the limitations of using the
         * IsTextUnicode API to perform such tests, and the usage of a more
         * improved encoding detection algorithm would be really welcome.
         */
        if (!(Results & IS_TEXT_UNICODE_NOT_UNICODE_MASK) &&
            !(Results & IS_TEXT_UNICODE_REVERSE_MASK)     &&
             (Results & IS_TEXT_UNICODE_UNICODE_MASK)     &&
             (Tests   & IS_TEXT_UNICODE_NULL_BYTES))
        {
            encFile = ENCODING_UTF16LE;
            dwPos = (Results & IS_TEXT_UNICODE_SIGNATURE) ? 2 : 0;
        }
        else
        if (!(Results & IS_TEXT_UNICODE_NOT_UNICODE_MASK) &&
            !(Results & IS_TEXT_UNICODE_UNICODE_MASK)     &&
             (Results & IS_TEXT_UNICODE_REVERSE_MASK)     &&
             (Tests   & IS_TEXT_UNICODE_NULL_BYTES))
        {
            encFile = ENCODING_UTF16BE;
            dwPos = (Results & IS_TEXT_UNICODE_REVERSE_SIGNATURE) ? 2 : 0;
        }
        else
        {
            /*
             * Either 'Results' has neither of those masks set, as it can be
             * the case for UTF-8 text (or ANSI), or it has both as can be the
             * case when analysing pure binary data chunk. This is therefore
             * invalid and we fall back to ANSI encoding.
             * FIXME: In case of failure, assume ANSI (as long as we do not have
             * correct tests for UTF8, otherwise we should do them, and at the
             * very end, assume ANSI).
             */
            encFile = ENCODING_ANSI; // ENCODING_UTF8;
            dwPos = 0;
        }
    }
 
    if (Encoding)
        *Encoding = encFile;
    if (SkipBytes)
        *SkipBytes = dwPos;
 
    return (encFile != ENCODING_ANSI);
}

Referenced by SearchFile().

RecursiveFind()

static UINT RecursiveFind ( LPCWSTR  lpPath, _SearchData *  pSearchData  )

static

Definition at line 401 of file CFindFolder.cpp.

{
    if (WaitForSingleObject(pSearchData->hStopEvent, 0) != WAIT_TIMEOUT)
        return 0;
 
    WCHAR szPath[MAX_PATH];
    WIN32_FIND_DATAW FindData;
    HANDLE hFindFile;
    BOOL bMoreFiles = TRUE;
    UINT uTotalFound = 0;
 
    PathCombineW(szPath, lpPath, L"*");
 
    for (hFindFile = FindFirstFileW(szPath, &FindData);
        bMoreFiles && hFindFile != INVALID_HANDLE_VALUE;
        bMoreFiles = FindNextFileW(hFindFile, &FindData))
    {
#define IS_DOTS(psz) ((psz)[0] == L'.' && ((psz)[1] == 0 || ((psz)[1] == L'.' && (psz)[2] == 0)))
        if (IS_DOTS(FindData.cFileName))
            continue;
 
        PathCombineW(szPath, lpPath, FindData.cFileName);
 
        if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            CStringW status;
            if (pSearchData->szQueryW.IsEmpty() &&
                FileNameMatch(FindData.cFileName, pSearchData) &&
                AttribHiddenMatch(FindData.dwFileAttributes, pSearchData))
            {
                LPWSTR pszPathDup;
                SHStrDupW(szPath, &pszPathDup);
                PostMessageW(pSearchData->hwnd, WM_SEARCH_ADD_RESULT, 0, (LPARAM)pszPathDup);
                uTotalFound++;
            }
            status.Format(IDS_SEARCH_FOLDER, FindData.cFileName);
            LPWSTR pszStatusDup;
            SHStrDupW(status.GetBuffer(), &pszStatusDup);
            PostMessageW(pSearchData->hwnd, WM_SEARCH_UPDATE_STATUS, 0, (LPARAM)pszStatusDup);
 
            uTotalFound += RecursiveFind(szPath, pSearchData);
        }
        else if (FileNameMatch(FindData.cFileName, pSearchData)
                && AttribHiddenMatch(FindData.dwFileAttributes, pSearchData)
                && ContentsMatch(szPath, pSearchData))
        {
            uTotalFound++;
            LPWSTR pszPathDup;
            SHStrDupW(szPath, &pszPathDup);
            PostMessageW(pSearchData->hwnd, WM_SEARCH_ADD_RESULT, 0, (LPARAM)pszPathDup);
        }
    }
 
    if (hFindFile != INVALID_HANDLE_VALUE)
        FindClose(hFindFile);
 
    return uTotalFound;
}

Referenced by RecursiveFind(), and CFindFolder::SearchThreadProc().

SearchFile()

static BOOL SearchFile ( LPCWSTR  lpFilePath, _SearchData *  pSearchData  )

static

Definition at line 319 of file CFindFolder.cpp.

{
    HANDLE hFile = CreateFileW(lpFilePath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
        return FALSE;
 
    // FIXME: support large file
    DWORD size = GetFileSize(hFile, NULL);
    if (size == 0 || size == INVALID_FILE_SIZE)
    {
        CloseHandle(hFile);
        return FALSE;
    }
 
    HANDLE hFileMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, size, NULL);
    CloseHandle(hFile);
    if (hFileMap == INVALID_HANDLE_VALUE)
        return FALSE;
 
    LPBYTE pbContents = (LPBYTE)MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, size);
    CloseHandle(hFileMap);
    if (!pbContents)
        return FALSE;
 
    ENCODING encoding;
    IsDataUnicode(pbContents, size, &encoding, NULL);
 
    BOOL bFound;
    switch (encoding)
    {
        case ENCODING_UTF16LE:
            // UTF-16
            bFound = StrFindNIW((LPCWSTR)pbContents, pSearchData->szQueryW, size / sizeof(WCHAR));
            break;
        case ENCODING_UTF16BE:
            // UTF-16 BE
            bFound = StrFindNIW((LPCWSTR)pbContents, pSearchData->szQueryU16BE, size / sizeof(WCHAR));
            break;
        case ENCODING_UTF8:
            // UTF-8
            bFound = StrFindNIA((LPCSTR)pbContents, pSearchData->szQueryU8, size / sizeof(CHAR));
            break;
        case ENCODING_ANSI:
        default:
            // ANSI or UTF-8 without BOM
            bFound = StrFindNIA((LPCSTR)pbContents, pSearchData->szQueryA, size / sizeof(CHAR));
            if (!bFound && pSearchData->szQueryA != pSearchData->szQueryU8)
                bFound = StrFindNIA((LPCSTR)pbContents, pSearchData->szQueryU8, size / sizeof(CHAR));
            break;
    }
 
    UnmapViewOfFile(pbContents);
    return bFound;
}

Referenced by ContentsMatch().

SHELL32_CoCreateInitSF()

static HRESULT SHELL32_CoCreateInitSF ( LPCITEMIDLIST  pidlRoot, PERSIST_FOLDER_TARGET_INFO *  ppfti, LPCITEMIDLIST  pidlChild, const GUID *  clsid, REFIID  riid, LPVOID *  ppvOut  )

static

Definition at line 13 of file CFindFolder.cpp.

{
    HRESULT hr;
    CComPtr<IShellFolder> pShellFolder;
 
    hr = SHCoCreateInstance(NULL, clsid, NULL, IID_PPV_ARG(IShellFolder, &pShellFolder));
    if (FAILED(hr))
        return hr;
 
    LPITEMIDLIST pidlAbsolute = ILCombine (pidlRoot, pidlChild);
    CComPtr<IPersistFolder> ppf;
    CComPtr<IPersistFolder3> ppf3;
 
    if (ppfti && SUCCEEDED(pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3))))
    {
        ppf3->InitializeEx(NULL, pidlAbsolute, ppfti);
    }
    else if (SUCCEEDED(pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder, &ppf))))
    {
        ppf->Initialize(pidlAbsolute);
    }
    ILFree (pidlAbsolute);
 
    return pShellFolder->QueryInterface(riid, ppvOut);
}

Referenced by CMyDocsFolder::EnsureFolder(), CDesktopFolder::FinalConstruct(), CFindFolder::Initialize(), CAdminToolsFolder::Initialize(), and CFontsFolder::Initialize().

StrFindNIA()

static BOOL StrFindNIA ( const CHAR *  lpFirst, const CStringA &  lpSrch, UINT  cchMax  )

inlinestatic

Definition at line 177 of file CFindFolder.cpp.

{
    return StrStrN<CHAR, CStringA, _strnicmp>(lpFirst, lpSrch, cchMax) != NULL;
}

Referenced by SearchFile().

StrFindNIW()

static BOOL StrFindNIW ( const WCHAR *  lpFirst, const CStringW &  lpSrch, UINT  cchMax  )

inlinestatic

Definition at line 183 of file CFindFolder.cpp.

{
    return StrStrN<WCHAR, CStringW, _wcsnicmp>(lpFirst, lpSrch, cchMax) != NULL;
}

Referenced by SearchFile().

StrStrN()

template<typename TChar , typename TString , int(&)(const TChar *, const TChar *, size_t) StrNCmp>

static const TChar * StrStrN ( const TChar *  lpFirst, const TString &  lpSrch, UINT  cchMax  )

static

Definition at line 162 of file CFindFolder.cpp.

{
    if (!lpFirst || lpSrch.IsEmpty() || !cchMax)
        return NULL;
 
    for (UINT i = cchMax; i > 0 && *lpFirst; i--, lpFirst++)
    {
        if (!StrNCmp(lpFirst, lpSrch, lpSrch.GetLength()))
            return (const TChar*)lpFirst;
    }
 
    return NULL;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shellfind

)

Variable Documentation

g_ColumnDefs

FolderViewColumns g_ColumnDefs[]

static

Initial value:

=
{
    {IDS_COL_NAME,      SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 30},
    {IDS_COL_LOCATION,  SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 30},
    {IDS_COL_RELEVANCE, SHCOLSTATE_TYPE_STR,                          LVCFMT_LEFT, 0}
}

Definition at line 87 of file CFindFolder.cpp.