mirror of
https://github.com/reactos/reactos.git
synced 2024-08-16 16:39:08 +00:00
784 lines
17 KiB
C++
784 lines
17 KiB
C++
/*
|
|
* Copyright 2003, 2004, 2005 Martin Fuchs
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
|
|
//
|
|
// Explorer clone
|
|
//
|
|
// entries.cpp
|
|
//
|
|
// Martin Fuchs, 23.07.2003
|
|
//
|
|
|
|
|
|
#include <precomp.h>
|
|
|
|
//#include "entries.h"
|
|
|
|
|
|
// allocate and initialise a directory entry
|
|
Entry::Entry(ENTRY_TYPE etype)
|
|
: _etype(etype)
|
|
{
|
|
_up = NULL;
|
|
_next = NULL;
|
|
_down = NULL;
|
|
_expanded = false;
|
|
_scanned = false;
|
|
_bhfi_valid = false;
|
|
_level = 0;
|
|
_icon_id = ICID_UNKNOWN;
|
|
_display_name = _data.cFileName;
|
|
_type_name = NULL;
|
|
_content = NULL;
|
|
}
|
|
|
|
Entry::Entry(Entry* parent, ENTRY_TYPE etype)
|
|
: _up(parent),
|
|
_etype(etype)
|
|
{
|
|
_next = NULL;
|
|
_down = NULL;
|
|
_expanded = false;
|
|
_scanned = false;
|
|
_bhfi_valid = false;
|
|
_level = 0;
|
|
_icon_id = ICID_UNKNOWN;
|
|
_shell_attribs = 0;
|
|
_display_name = _data.cFileName;
|
|
_type_name = NULL;
|
|
_content = NULL;
|
|
}
|
|
|
|
Entry::Entry(const Entry& other)
|
|
{
|
|
_next = NULL;
|
|
_down = NULL;
|
|
_up = NULL;
|
|
|
|
assert(!other._next);
|
|
assert(!other._down);
|
|
assert(!other._up);
|
|
|
|
_expanded = other._expanded;
|
|
_scanned = other._scanned;
|
|
_level = other._level;
|
|
|
|
_data = other._data;
|
|
|
|
_shell_attribs = other._shell_attribs;
|
|
_display_name = other._display_name==other._data.cFileName? _data.cFileName: _tcsdup(other._display_name);
|
|
_type_name = other._type_name? _tcsdup(other._type_name): NULL;
|
|
_content = other._content? _tcsdup(other._content): NULL;
|
|
|
|
_etype = other._etype;
|
|
_icon_id = other._icon_id;
|
|
|
|
_bhfi = other._bhfi;
|
|
_bhfi_valid = other._bhfi_valid;
|
|
}
|
|
|
|
// free a directory entry
|
|
Entry::~Entry()
|
|
{
|
|
free_subentries();
|
|
|
|
if (_icon_id > ICID_NONE)
|
|
g_Globals._icon_cache.free_icon(_icon_id);
|
|
|
|
if (_display_name != _data.cFileName)
|
|
free(_display_name);
|
|
|
|
if (_type_name)
|
|
free(_type_name);
|
|
|
|
if (_content)
|
|
free(_content);
|
|
|
|
if (_down)
|
|
delete _down;
|
|
}
|
|
|
|
|
|
// read directory tree and expand to the given location
|
|
Entry* Entry::read_tree(const void* path, SORT_ORDER sortOrder, int scan_flags)
|
|
{
|
|
CONTEXT("Entry::read_tree()");
|
|
|
|
WaitCursor wait;
|
|
|
|
Entry* entry = this;
|
|
|
|
for(const void*p=path; p && entry; ) {
|
|
entry->smart_scan(sortOrder, scan_flags);
|
|
|
|
if (entry->_down)
|
|
entry->_expanded = true;
|
|
|
|
Entry* found = entry->find_entry(p);
|
|
p = entry->get_next_path_component(p);
|
|
|
|
entry = found;
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
void Entry::read_directory_base(SORT_ORDER sortOrder, int scan_flags)
|
|
{
|
|
CONTEXT("Entry::read_directory_base()");
|
|
|
|
// call into subclass
|
|
read_directory(scan_flags);
|
|
|
|
#ifndef ROSSHELL
|
|
if (g_Globals._prescan_nodes) { ///@todo _prescan_nodes should not be used for reading the start menu.
|
|
for(Entry*entry=_down; entry; entry=entry->_next)
|
|
if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
entry->read_directory(scan_flags);
|
|
entry->sort_directory(sortOrder);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
sort_directory(sortOrder);
|
|
}
|
|
|
|
|
|
Root::Root()
|
|
{
|
|
memset(this, 0, sizeof(Root));
|
|
}
|
|
|
|
Root::~Root()
|
|
{
|
|
if (_entry) {
|
|
_entry->free_subentries();
|
|
delete _entry;
|
|
}
|
|
}
|
|
|
|
|
|
// sort order for different directory/file types
|
|
enum TYPE_ORDER {
|
|
TO_DIR,
|
|
TO_DOT,
|
|
TO_DOTDOT,
|
|
TO_OTHER_DIR,
|
|
TO_VIRTUAL_FOLDER,
|
|
TO_FILE
|
|
};
|
|
|
|
// distinguish between ".", ".." and any other directory names
|
|
static TYPE_ORDER TypeOrderFromDirname(LPCTSTR name)
|
|
{
|
|
if (name[0] == '.') {
|
|
if (name[1] == '\0')
|
|
return TO_DOT; // "."
|
|
|
|
if (name[1]=='.' && name[2]=='\0')
|
|
return TO_DOTDOT; // ".."
|
|
}
|
|
|
|
return TO_OTHER_DIR; // any other directory
|
|
}
|
|
|
|
// directories first...
|
|
static int compareType(const Entry* entry1, const Entry* entry2)
|
|
{
|
|
const WIN32_FIND_DATA* fd1 = &entry1->_data;
|
|
const WIN32_FIND_DATA* fd2 = &entry2->_data;
|
|
|
|
TYPE_ORDER order1 = fd1->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;
|
|
TYPE_ORDER order2 = fd2->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;
|
|
|
|
// Handle "." and ".." as special case and move them at the very first beginning.
|
|
if (order1==TO_DIR && order2==TO_DIR) {
|
|
order1 = TypeOrderFromDirname(fd1->cFileName);
|
|
order2 = TypeOrderFromDirname(fd2->cFileName);
|
|
|
|
// Move virtual folders after physical folders
|
|
if (!(entry1->_shell_attribs & SFGAO_FILESYSTEM))
|
|
order1 = TO_VIRTUAL_FOLDER;
|
|
|
|
if (!(entry2->_shell_attribs & SFGAO_FILESYSTEM))
|
|
order2 = TO_VIRTUAL_FOLDER;
|
|
}
|
|
|
|
return order2==order1? 0: order1<order2? -1: 1;
|
|
}
|
|
|
|
|
|
static int compareNothing(const void* arg1, const void* arg2)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static int compareName(const void* arg1, const void* arg2)
|
|
{
|
|
const Entry* entry1 = *(const Entry**)arg1;
|
|
const Entry* entry2 = *(const Entry**)arg2;
|
|
|
|
int cmp = compareType(entry1, entry2);
|
|
if (cmp)
|
|
return cmp;
|
|
|
|
return lstrcmpi(entry1->_data.cFileName, entry2->_data.cFileName);
|
|
}
|
|
|
|
static int compareExt(const void* arg1, const void* arg2)
|
|
{
|
|
const Entry* entry1 = *(const Entry**)arg1;
|
|
const Entry* entry2 = *(const Entry**)arg2;
|
|
const TCHAR *name1, *name2, *ext1, *ext2;
|
|
|
|
int cmp = compareType(entry1, entry2);
|
|
if (cmp)
|
|
return cmp;
|
|
|
|
name1 = entry1->_data.cFileName;
|
|
name2 = entry2->_data.cFileName;
|
|
|
|
ext1 = _tcsrchr(name1, TEXT('.'));
|
|
ext2 = _tcsrchr(name2, TEXT('.'));
|
|
|
|
if (ext1)
|
|
++ext1;
|
|
else
|
|
ext1 = TEXT("");
|
|
|
|
if (ext2)
|
|
++ext2;
|
|
else
|
|
ext2 = TEXT("");
|
|
|
|
cmp = lstrcmpi(ext1, ext2);
|
|
if (cmp)
|
|
return cmp;
|
|
|
|
return lstrcmpi(name1, name2);
|
|
}
|
|
|
|
static int compareSize(const void* arg1, const void* arg2)
|
|
{
|
|
const Entry* entry1 = *(const Entry**)arg1;
|
|
const Entry* entry2 = *(const Entry**)arg2;
|
|
|
|
int cmp = compareType(entry1, entry2);
|
|
if (cmp)
|
|
return cmp;
|
|
|
|
cmp = entry2->_data.nFileSizeHigh - entry1->_data.nFileSizeHigh;
|
|
|
|
if (cmp < 0)
|
|
return -1;
|
|
else if (cmp > 0)
|
|
return 1;
|
|
|
|
cmp = entry2->_data.nFileSizeLow - entry1->_data.nFileSizeLow;
|
|
|
|
return cmp<0? -1: cmp>0? 1: 0;
|
|
}
|
|
|
|
static int compareDate(const void* arg1, const void* arg2)
|
|
{
|
|
const Entry* entry1 = *(const Entry**)arg1;
|
|
const Entry* entry2 = *(const Entry**)arg2;
|
|
|
|
int cmp = compareType(entry1, entry2);
|
|
if (cmp)
|
|
return cmp;
|
|
|
|
return CompareFileTime(&entry2->_data.ftLastWriteTime, &entry1->_data.ftLastWriteTime);
|
|
}
|
|
|
|
|
|
static int (*sortFunctions[])(const void* arg1, const void* arg2) = {
|
|
compareNothing, // SORT_NONE
|
|
compareName, // SORT_NAME
|
|
compareExt, // SORT_EXT
|
|
compareSize, // SORT_SIZE
|
|
compareDate // SORT_DATE
|
|
};
|
|
|
|
|
|
void Entry::sort_directory(SORT_ORDER sortOrder)
|
|
{
|
|
if (sortOrder != SORT_NONE) {
|
|
Entry* entry = _down;
|
|
Entry** array, **p;
|
|
int len;
|
|
|
|
len = 0;
|
|
for(entry=_down; entry; entry=entry->_next)
|
|
++len;
|
|
|
|
if (len) {
|
|
array = (Entry**) alloca(len*sizeof(Entry*));
|
|
|
|
p = array;
|
|
for(entry=_down; entry; entry=entry->_next)
|
|
*p++ = entry;
|
|
|
|
// call qsort with the appropriate compare function
|
|
qsort(array, len, sizeof(array[0]), sortFunctions[sortOrder]);
|
|
|
|
_down = array[0];
|
|
|
|
for(p=array; --len; p++)
|
|
(*p)->_next = p[1];
|
|
|
|
(*p)->_next = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Entry::smart_scan(SORT_ORDER sortOrder, int scan_flags)
|
|
{
|
|
CONTEXT("Entry::smart_scan()");
|
|
|
|
if (!_scanned) {
|
|
free_subentries();
|
|
read_directory_base(sortOrder, scan_flags); ///@todo We could use IShellFolder2::GetDefaultColumn to determine sort order.
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int Entry::extract_icon(ICONCACHE_FLAGS flags)
|
|
{
|
|
TCHAR path[MAX_PATH];
|
|
|
|
ICON_ID icon_id = ICID_NONE;
|
|
|
|
if (_etype!=ET_SHELL && get_path(path, COUNTOF(path))) // not for ET_SHELL to display the correct desktop icon
|
|
if (!(flags & ICF_MIDDLE)) // not for ICF_MIDDLE to extract 24x24 icons because SHGetFileInfo() doesn't support this icon size
|
|
icon_id = g_Globals._icon_cache.extract(path, flags);
|
|
|
|
if (icon_id == ICID_NONE) {
|
|
if (!(flags & ICF_OVERLAYS)) {
|
|
IExtractIcon* pExtract;
|
|
if (SUCCEEDED(GetUIObjectOf(0, IID_IExtractIcon, (LPVOID*)&pExtract))) {
|
|
unsigned gil_flags = 0;
|
|
int idx;
|
|
|
|
if (flags & ICF_OPEN)
|
|
gil_flags |= GIL_OPENICON;
|
|
|
|
if (SUCCEEDED(pExtract->GetIconLocation(GIL_FORSHELL, path, COUNTOF(path), &idx, &gil_flags))) {
|
|
if (gil_flags & GIL_NOTFILENAME)
|
|
icon_id = g_Globals._icon_cache.extract(pExtract, path, idx, flags);
|
|
else {
|
|
if (idx == -1)
|
|
idx = 0; // special case for some control panel applications ("System")
|
|
|
|
icon_id = g_Globals._icon_cache.extract(path, idx, flags);
|
|
}
|
|
|
|
/* using create_absolute_pidl() [see below] results in more correct icons for some control panel applets (NVidia display driver).
|
|
if (icon_id == ICID_NONE) {
|
|
SHFILEINFO sfi;
|
|
|
|
if (SHGetFileInfo(path, 0, &sfi, sizeof(sfi), SHGFI_ICON|SHGFI_SMALLICON))
|
|
icon_id = g_Globals._icon_cache.add(sfi.hIcon)._id;
|
|
} */
|
|
/*
|
|
if (icon_id == ICID_NONE) {
|
|
LPBYTE b = (LPBYTE) alloca(0x10000);
|
|
SHFILEINFO sfi;
|
|
|
|
FILE* file = fopen(path, "rb");
|
|
if (file) {
|
|
int l = fread(b, 1, 0x10000, file);
|
|
fclose(file);
|
|
|
|
if (l)
|
|
icon_id = g_Globals._icon_cache.add(CreateIconFromResourceEx(b, l, TRUE, 0x00030000, 16, 16, LR_DEFAULTCOLOR));
|
|
}
|
|
} */
|
|
}
|
|
}
|
|
}
|
|
|
|
if (icon_id == ICID_NONE) {
|
|
const ShellPath& pidl_abs = create_absolute_pidl();
|
|
LPCITEMIDLIST pidl = pidl_abs;
|
|
|
|
icon_id = g_Globals._icon_cache.extract(pidl, flags);
|
|
}
|
|
}
|
|
|
|
return icon_id;
|
|
}
|
|
|
|
int Entry::safe_extract_icon(ICONCACHE_FLAGS flags)
|
|
{
|
|
try {
|
|
return extract_icon(flags);
|
|
} catch(COMException&) {
|
|
// ignore unexpected exceptions while extracting icons
|
|
}
|
|
|
|
return ICID_NONE;
|
|
}
|
|
|
|
|
|
BOOL Entry::launch_entry(HWND hwnd, UINT nCmdShow)
|
|
{
|
|
TCHAR cmd[MAX_PATH];
|
|
|
|
if (!get_path(cmd, COUNTOF(cmd)))
|
|
return FALSE;
|
|
|
|
// add path to the recent file list
|
|
SHAddToRecentDocs(SHARD_PATH, cmd);
|
|
|
|
// start program, open document...
|
|
return launch_file(hwnd, cmd, nCmdShow);
|
|
}
|
|
|
|
|
|
// local replacement implementation for SHBindToParent()
|
|
// (derived from http://www.geocities.com/SiliconValley/2060/articles/shell-helpers.html)
|
|
static HRESULT my_SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, VOID** ppv, LPCITEMIDLIST* ppidlLast)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (!ppv)
|
|
return E_POINTER;
|
|
|
|
// There must be at least one item ID.
|
|
if (!pidl || !pidl->mkid.cb)
|
|
return E_INVALIDARG;
|
|
|
|
// Get the desktop folder as root.
|
|
ShellFolder desktop;
|
|
/* IShellFolderPtr desktop;
|
|
hr = SHGetDesktopFolder(&desktop);
|
|
if (FAILED(hr))
|
|
return hr; */
|
|
|
|
// Walk to the penultimate item ID.
|
|
LPCITEMIDLIST marker = pidl;
|
|
for (;;)
|
|
{
|
|
LPCITEMIDLIST next = reinterpret_cast<LPCITEMIDLIST>(
|
|
marker->mkid.abID - sizeof(marker->mkid.cb) + marker->mkid.cb);
|
|
if (!next->mkid.cb)
|
|
break;
|
|
marker = next;
|
|
}
|
|
|
|
if (marker == pidl)
|
|
{
|
|
// There was only a single item ID, so bind to the root folder.
|
|
hr = desktop->QueryInterface(riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
// Copy the ID list, truncating the last item.
|
|
int length = marker->mkid.abID - pidl->mkid.abID;
|
|
if (LPITEMIDLIST parent_id = reinterpret_cast<LPITEMIDLIST>(
|
|
malloc(length + sizeof(pidl->mkid.cb))))
|
|
{
|
|
LPBYTE raw_data = reinterpret_cast<LPBYTE>(parent_id);
|
|
memcpy(raw_data, pidl, length);
|
|
memset(raw_data + length, 0, sizeof(pidl->mkid.cb));
|
|
hr = desktop->BindToObject(parent_id, 0, riid, ppv);
|
|
free(parent_id);
|
|
}
|
|
else
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// Return a pointer to the last item ID.
|
|
if (ppidlLast)
|
|
*ppidlLast = marker;
|
|
|
|
return hr;
|
|
}
|
|
#define USE_MY_SHBINDTOPARENT
|
|
|
|
HRESULT Entry::do_context_menu(HWND hwnd, const POINT& pos, CtxMenuInterfaces& cm_ifs)
|
|
{
|
|
ShellPath shell_path = create_absolute_pidl();
|
|
LPCITEMIDLIST pidl_abs = shell_path;
|
|
|
|
if (!pidl_abs)
|
|
return S_FALSE; // no action for registry entries, etc.
|
|
|
|
#ifdef USE_MY_SHBINDTOPARENT
|
|
IShellFolder* parentFolder;
|
|
LPCITEMIDLIST pidlLast;
|
|
|
|
// get and use the parent folder to display correct context menu in all cases -> correct "Properties" dialog for directories, ...
|
|
HRESULT hr = my_SHBindToParent(pidl_abs, IID_IShellFolder, (LPVOID*)&parentFolder, &pidlLast);
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
hr = ShellFolderContextMenu(parentFolder, hwnd, 1, &pidlLast, pos.x, pos.y, cm_ifs);
|
|
|
|
parentFolder->Release();
|
|
}
|
|
|
|
return hr;
|
|
#else
|
|
static DynamicFct<HRESULT(WINAPI*)(LPCITEMIDLIST, REFIID, LPVOID*, LPCITEMIDLIST*)> SHBindToParent(TEXT("SHELL32"), "SHBindToParent");
|
|
|
|
if (SHBindToParent) {
|
|
IShellFolder* parentFolder;
|
|
LPCITEMIDLIST pidlLast;
|
|
|
|
// get and use the parent folder to display correct context menu in all cases -> correct "Properties" dialog for directories, ...
|
|
HRESULT hr = (*SHBindToParent)(pidl_abs, IID_IShellFolder, (LPVOID*)&parentFolder, &pidlLast);
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
hr = ShellFolderContextMenu(parentFolder, hwnd, 1, &pidlLast, pos.x, pos.y, cm_ifs);
|
|
|
|
parentFolder->Release();
|
|
}
|
|
|
|
return hr;
|
|
} else {
|
|
/**@todo use parent folder instead of desktop folder
|
|
Entry* dir = _up;
|
|
|
|
ShellPath parent_path;
|
|
|
|
if (dir)
|
|
parent_path = dir->create_absolute_pidl();
|
|
else
|
|
parent_path = DesktopFolderPath();
|
|
|
|
ShellPath shell_path = create_relative_pidl(parent_path);
|
|
LPCITEMIDLIST pidl = shell_path;
|
|
|
|
ShellFolder parent_folder = parent_path;
|
|
return ShellFolderContextMenu(parent_folder, hwnd, 1, &pidl, pos.x, pos.y);
|
|
*/
|
|
return ShellFolderContextMenu(GetDesktopFolder(), hwnd, 1, &pidl_abs, pos.x, pos.y, cm_ifs);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
HRESULT Entry::GetUIObjectOf(HWND hWnd, REFIID riid, LPVOID* ppvOut)
|
|
{
|
|
TCHAR path[MAX_PATH];
|
|
/*
|
|
if (!get_path(path, COUNTOF(path)))
|
|
return E_FAIL;
|
|
|
|
ShellPath shell_path(path);
|
|
|
|
IShellFolder* pFolder;
|
|
LPCITEMIDLIST pidl_last = NULL;
|
|
|
|
static DynamicFct<HRESULT(WINAPI*)(LPCITEMIDLIST, REFIID, LPVOID*, LPCITEMIDLIST*)> SHBindToParent(TEXT("SHELL32"), "SHBindToParent");
|
|
|
|
if (!SHBindToParent)
|
|
return E_NOTIMPL;
|
|
|
|
HRESULT hr = (*SHBindToParent)(shell_path, IID_IShellFolder, (LPVOID*)&pFolder, &pidl_last);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
ShellFolder shell_folder(pFolder);
|
|
|
|
shell_folder->Release();
|
|
|
|
return shell_folder->GetUIObjectOf(hWnd, 1, &pidl_last, riid, NULL, ppvOut);
|
|
*/
|
|
if (!_up)
|
|
return E_INVALIDARG;
|
|
|
|
if (!_up->get_path(path, COUNTOF(path)))
|
|
return E_FAIL;
|
|
|
|
ShellPath shell_path(path);
|
|
ShellFolder shell_folder(shell_path);
|
|
|
|
#ifdef UNICODE
|
|
LPWSTR wname = _data.cFileName;
|
|
#else
|
|
WCHAR wname[MAX_PATH];
|
|
MultiByteToWideChar(CP_ACP, 0, _data.cFileName, -1, wname, COUNTOF(wname));
|
|
#endif
|
|
|
|
LPITEMIDLIST pidl_last = NULL;
|
|
HRESULT hr = shell_folder->ParseDisplayName(hWnd, NULL, wname, NULL, &pidl_last, NULL);
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = shell_folder->GetUIObjectOf(hWnd, 1, (LPCITEMIDLIST*)&pidl_last, riid, NULL, ppvOut);
|
|
|
|
ShellMalloc()->Free((void*)pidl_last);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// get full path of specified directory entry
|
|
bool Entry::get_path_base ( PTSTR path, size_t path_count, ENTRY_TYPE etype ) const
|
|
{
|
|
int level = 0;
|
|
size_t len = 0;
|
|
size_t l = 0;
|
|
LPCTSTR name = NULL;
|
|
TCHAR buffer[MAX_PATH];
|
|
|
|
if (!path || path_count==0)
|
|
return false;
|
|
|
|
const Entry* entry;
|
|
if ( path_count > 1 )
|
|
{
|
|
for(entry=this; entry; level++) {
|
|
l = 0;
|
|
|
|
if (entry->_etype == etype) {
|
|
name = entry->_data.cFileName;
|
|
|
|
for(LPCTSTR s=name; *s && *s!=TEXT('/') && *s!=TEXT('\\'); s++)
|
|
++l;
|
|
|
|
if (!entry->_up)
|
|
break;
|
|
} else {
|
|
if (entry->get_path(buffer, COUNTOF(buffer))) {
|
|
l = _tcslen(buffer);
|
|
name = buffer;
|
|
|
|
/* special handling of drive names */
|
|
if (l>0 && buffer[l-1]=='\\' && path[0]=='\\')
|
|
--l;
|
|
|
|
if ( len+l >= path_count )
|
|
{
|
|
if ( l + 1 > path_count )
|
|
len = 0;
|
|
else
|
|
len = path_count - l - 1;
|
|
}
|
|
memmove(path+l, path, len*sizeof(TCHAR));
|
|
if ( l+1 >= path_count )
|
|
l = path_count - 1;
|
|
memcpy(path, name, l*sizeof(TCHAR));
|
|
len += l;
|
|
}
|
|
|
|
entry = NULL;
|
|
break;
|
|
}
|
|
|
|
if (l > 0) {
|
|
if ( len+l+1 >= path_count )
|
|
{
|
|
/* compare to 2 here because of terminator plus the '\\' we prepend */
|
|
if ( l + 2 > path_count )
|
|
len = 0;
|
|
else
|
|
len = path_count - l - 2;
|
|
}
|
|
memmove(path+l+1, path, len*sizeof(TCHAR));
|
|
/* compare to 2 here because of terminator plus the '\\' we prepend */
|
|
if ( l+2 >= path_count )
|
|
l = path_count - 2;
|
|
memcpy(path+1, name, l*sizeof(TCHAR));
|
|
len += l+1;
|
|
|
|
#ifndef _NO_WIN_FS
|
|
if (etype == ET_WINDOWS && entry->_up && !(entry->_up->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) // a NTFS stream?
|
|
path[0] = TEXT(':');
|
|
else
|
|
#endif
|
|
path[0] = TEXT('\\');
|
|
}
|
|
|
|
entry = entry->_up;
|
|
}
|
|
|
|
if (entry) {
|
|
if ( len+l >= path_count )
|
|
{
|
|
if ( l + 1 > path_count )
|
|
len = 0;
|
|
else
|
|
len = path_count - l - 1;
|
|
}
|
|
memmove(path+l, path, len*sizeof(TCHAR));
|
|
if ( l+1 >= path_count )
|
|
l = path_count - 1;
|
|
memcpy(path, name, l*sizeof(TCHAR));
|
|
len += l;
|
|
}
|
|
|
|
if ( !level && (len+1 < path_count) )
|
|
path[len++] = TEXT('\\');
|
|
}
|
|
|
|
path[len] = TEXT('\0');
|
|
|
|
return true;
|
|
}
|
|
|
|
// recursively free all child entries
|
|
void Entry::free_subentries()
|
|
{
|
|
Entry *entry, *next=_down;
|
|
|
|
if (next) {
|
|
_down = 0;
|
|
|
|
do {
|
|
entry = next;
|
|
next = entry->_next;
|
|
|
|
entry->free_subentries();
|
|
delete entry;
|
|
} while(next);
|
|
}
|
|
}
|
|
|
|
|
|
Entry* Root::read_tree(LPCTSTR path, int scan_flags)
|
|
{
|
|
Entry* entry;
|
|
|
|
if (path && *path)
|
|
entry = _entry->read_tree(path, _sort_order);
|
|
else {
|
|
entry = _entry->read_tree(NULL, _sort_order);
|
|
|
|
_entry->smart_scan();
|
|
|
|
if (_entry->_down)
|
|
_entry->_expanded = true;
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
Entry* Root::read_tree(LPCITEMIDLIST pidl, int scan_flags)
|
|
{
|
|
return _entry->read_tree(pidl, _sort_order);
|
|
}
|