void uwTreeList::ExpandPlaceholder( const wxTreeItemId& parent )
{
unDataTree& tree = GetDataTree( parent );
if( tree.Expand() )
{
AddChildren( tree );
if( tree.ShouldSort() )
SortChildren( tree.GetTreeID() );
wxTreeItemIdValue cookie = 0;
wxTreeItemId child = GetFirstChild(parent, cookie);
while( child.IsOk() )
{
unDataTree& tree_child = GetDataTree( child );
if( tree_child.GetAutoExpand() )
{
Expand(child);
}
child = GetNextChild(parent, cookie);
}
}
}
// Recursively sorts a node and its children
void CMyTreeCtrl::SortNodeAndChildren(HTREEITEM hItem)
{
// Sort the node
SortChildren(hItem);
// Determine if this item has children
if (ItemHasChildren(hItem))
{
// Get the first child item
HTREEITEM hChild=GetChildItem(hItem);
// Sort the child
SortNodeAndChildren(hChild);
// Sort the rest of the children
HTREEITEM hSibling=GetNextSiblingItem(hChild);
while (hSibling)
{
SortNodeAndChildren(hSibling);
hSibling=GetNextSiblingItem(hSibling);
}
}
}
void CRemoteTreeView::DisplayItem(wxTreeItemId parent, const CDirectoryListing& listing)
{
DeleteChildren(parent);
const wxString path = listing.path.GetPath();
CFilterDialog filter;
for (unsigned int i = 0; i < listing.GetCount(); i++)
{
if (!listing[i].is_dir())
continue;
if (filter.FilenameFiltered(listing[i].name, path, true, -1, false, 0, listing[i].has_date() ? &listing[i].time : 0))
continue;
const wxString& name = listing[i].name;
CServerPath subdir = listing.path;
subdir.AddSegment(name);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(subdir, subListing) == FZ_REPLY_OK)
{
wxTreeItemId child = AppendItem(parent, name, 0, 2, 0);
SetItemImages(child, false);
if (HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
}
else
{
wxTreeItemId child = AppendItem(parent, name, 1, 3, 0);
SetItemImages(child, true);
}
}
SortChildren(parent);
}
void CVirtualTreeCtrl::OnDropFiles(HDROP hDropInfo)
{
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
INDEX ctFiles = DragQueryFile( hDropInfo, 0xFFFFFFFF, NULL, 0);
// get dropped coordinates
CPoint point;
DragQueryPoint( hDropInfo, &point);
CVirtualTreeNode *pVTNDst = ItemForCoordinate(point);
if( pVTNDst!=NULL)
{
for( INDEX i=0; i<ctFiles; i++)
{
char chrFile[ 256];
DragQueryFile( hDropInfo, i, chrFile, 256);
CTString strAddr = CTString(chrFile);
if( strAddr != "")
{
CVirtualTreeNode *pVTNSrc;
strAddr.ScanF("VTN%d", &pVTNSrc);
if(pVTNSrc==pVTNDst) return;
pVTNSrc->MoveToDirectory( pVTNDst);
// delete all items
DeleteAllItems();
m_pBrowser->AddDirectoryRecursiv( &m_pBrowser->m_VirtualTree, TVI_ROOT); // Fill CTreeCtrl using recursion
SortChildren( NULL);
SelectItem( (HTREEITEM) pVTNSrc->vtn_Handle);
m_pBrowser->m_bVirtualTreeChanged = TRUE;
m_pBrowser->OpenSelectedDirectory();
}
}
}
CTreeCtrl::OnDropFiles(hDropInfo);
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterManager filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
// Step 1: Check if directory exists
CLocalFileSystem local_filesystem;
if (!local_filesystem.BeginFindFiles(dir.dir, true))
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
// Step 2: Enumerate subdirectories on disk and sort them
std::list<wxString> dirs;
wxString file;
const wxLongLong size(-1);
bool was_link;
bool is_dir;
int attributes;
wxDateTime date;
while (local_filesystem.GetNextFile(file, was_link, is_dir, 0, &date, &attributes))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
if (filter.FilenameFiltered(file, dir.dir, true, size, true, attributes, date.IsValid() ? &date : 0))
continue;
dirs.push_back(file);
}
dirs.sort(sortfunc);
bool inserted = false;
// Step 3: Merge list of subdirectories with subtree.
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child || iter != dirs.rend())
{
int cmp;
if (child && iter != dirs.rend())
#ifdef __WXMSW__
cmp = GetItemText(child).CmpNoCase(*iter);
#else
cmp = GetItemText(child).Cmp(*iter);
#endif
else if (child)
cmp = 1;
else
cmp = -1;
if (!cmp)
{
// Found item with same name. Mark it for further processing
if (!IsExpanded(child))
{
wxString path = dir.dir + *iter + separator;
if (!CheckSubdirStatus(child, path))
{
t_dir subdir;
subdir.dir = path;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
++iter;
}
else if (cmp > 0)
{
// Subdirectory currently in tree no longer exists.
// Delete child from tree, unless current selection
// is in the subtree.
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
// New subdirectory, add treeitem
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
++iter;
inserted = true;
}
}
if (inserted)
SortChildren(dir.item);
}
void CLocalTreeView::DisplayDir(wxTreeItemId parent, const wxString& dirname, const wxString& knownSubdir /*=_T("")*/)
{
CLocalFileSystem local_filesystem;
{
wxLogNull log;
if (!local_filesystem.BeginFindFiles(dirname, true))
{
if (knownSubdir != _T(""))
{
wxTreeItemId item = GetSubdir(parent, knownSubdir);
if (item != wxTreeItemId())
return;
const wxString fullName = dirname + knownSubdir;
item = AppendItem(parent, knownSubdir, GetIconIndex(::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
else
{
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
}
return;
}
}
wxASSERT(parent);
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
CFilterManager filter;
bool matchedKnown = false;
wxString file;
bool wasLink;
int attributes;
bool is_dir;
const wxLongLong size(-1);
wxDateTime date;
while (local_filesystem.GetNextFile(file, wasLink, is_dir, 0, &date, &attributes))
{
wxASSERT(is_dir);
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
wxString fullName = dirname + file;
#ifdef __WXMSW__
if (file.CmpNoCase(knownSubdir))
#else
if (file != knownSubdir)
#endif
{
if (filter.FilenameFiltered(file, dirname, true, size, true, attributes, date.IsValid() ? &date : 0))
continue;
}
else
matchedKnown = true;
wxTreeItemId item = AppendItem(parent, file, GetIconIndex(::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
if (!matchedKnown && knownSubdir != _T(""))
{
const wxString fullName = dirname + knownSubdir;
wxTreeItemId item = AppendItem(parent, knownSubdir, GetIconIndex(::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
SortChildren(parent);
}
bool CLocalTreeView::DisplayDrives(wxTreeItemId parent)
{
wxGetApp().AddStartupProfileRecord(_T("CLocalTreeView::DisplayDrives"));
long drivesToHide = 0;
// Adhere to the NODRIVES group policy
wxRegKey key(_T("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"));
if (key.Exists())
{
if (!key.HasValue(_T("NoDrives")) || !key.QueryValue(_T("NoDrives"), &drivesToHide))
drivesToHide = 0;
}
int len = GetLogicalDriveStrings(0, 0);
if (!len)
return false;
wxChar* drives = new wxChar[len + 1];
if (!GetLogicalDriveStrings(len, drives))
{
delete [] drives;
return false;
}
m_pVolumeEnumeratorThread = new CVolumeDescriptionEnumeratorThread(this);
if (m_pVolumeEnumeratorThread->Failed())
{
delete m_pVolumeEnumeratorThread;
m_pVolumeEnumeratorThread = 0;
}
const wxChar* pDrive = drives;
while (*pDrive)
{
// Check if drive should be hidden by default
if (pDrive[0] != 0 && pDrive[1] == ':')
{
int bit = 0;
char letter = pDrive[0];
if (letter >= 'A' && letter <= 'Z')
bit = 1 << (letter - 'A');
if (letter >= 'a' && letter <= 'z')
bit = 1 << (letter - 'a');
if (drivesToHide & bit)
{
pDrive += wxStrlen(pDrive) + 1;
continue;
}
}
wxString drive = pDrive;
if (drive.Right(1) == _T("\\"))
drive = drive.RemoveLast();
wxGetApp().AddStartupProfileRecord(wxString::Format(_T("CLocalTreeView::DisplayDrives adding drive %s"), drive.c_str()));
wxTreeItemId item = AppendItem(parent, drive, GetIconIndex(dir, pDrive));
AppendItem(item, _T(""));
SortChildren(parent);
pDrive += wxStrlen(pDrive) + 1;
}
wxGetApp().AddStartupProfileRecord(_T("CLocalTreeView::DisplayDrives adding drives done"));
delete [] drives;
return true;
}
void CRemoteTreeView::RefreshItem(wxTreeItemId parent, const CDirectoryListing& listing, bool will_select_parent)
{
SetItemImages(parent, false);
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild(parent, cookie);
if (!child || GetItemText(child).empty()) {
DisplayItem(parent, listing);
return;
}
CFilterManager filter;
wxString const path = listing.path.GetPath();
wxArrayString dirs;
for (unsigned int i = 0; i < listing.GetCount(); ++i) {
if (!listing[i].is_dir())
continue;
if (!filter.FilenameFiltered(listing[i].name, path, true, -1, false, 0, listing[i].time))
dirs.push_back(listing[i].name);
}
auto const& sortFunc = CFileListCtrlSortBase::GetCmpFunction(m_nameSortMode);
dirs.Sort(sortFunc);
bool inserted = false;
child = GetLastChild(parent);
wxArrayString::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend()) {
int cmp = sortFunc(GetItemText(child), *iter);
if (!cmp) {
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
if (!GetLastChild(child) && HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
SetItemImages(child, false);
}
else
SetItemImages(child, true);
child = GetPrevSibling(child);
++iter;
}
else if (cmp > 0) {
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
else if (cmp < 0) {
// New directory
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
wxTreeItemId childItem = AppendItem(parent, *iter, 0, 2, 0);
if (childItem) {
SetItemImages(childItem, false);
if (HasSubdirs(subListing, filter)) {
AppendItem(childItem, _T(""), -1, -1);
}
}
}
else {
wxTreeItemId childItem = AppendItem(parent, *iter, 1, 3, 0);
if (childItem) {
SetItemImages(childItem, true);
}
}
++iter;
inserted = true;
}
}
while (child) {
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
while (iter != dirs.rend()) {
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
wxTreeItemId childItem = AppendItem(parent, *iter, 0, 2, 0);
if (childItem) {
SetItemImages(childItem, false);
if (HasSubdirs(subListing, filter)) {
AppendItem(childItem, _T(""), -1, -1);
}
}
}
else {
wxTreeItemId childItem = AppendItem(parent, *iter, 1, 3, 0);
if (childItem) {
SetItemImages(childItem, true);
}
}
++iter;
inserted = true;
}
if (inserted)
SortChildren(parent);
}
wxTreeItemId CRemoteTreeView::MakeParent(CServerPath path, bool select)
{
std::vector<wxString> pieces;
pieces.reserve(path.SegmentCount() + 1);
while (path.HasParent()) {
pieces.push_back(path.GetLastSegment());
path = path.GetParent();
}
wxASSERT(!path.GetPath().empty());
pieces.push_back(path.GetPath());
const wxTreeItemId root = GetRootItem();
wxTreeItemId parent = root;
for (std::vector<wxString>::const_reverse_iterator iter = pieces.rbegin(); iter != pieces.rend(); ++iter) {
if (iter != pieces.rbegin())
path.AddSegment(*iter);
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild(parent, cookie);
if (child && GetItemText(child).empty()) {
Delete(child);
child = wxTreeItemId();
if (parent != root)
ListExpand(parent);
}
for (child = GetFirstChild(parent, cookie); child; child = GetNextSibling(child)) {
const wxString& text = GetItemText(child);
if (text == *iter)
break;
}
if (!child) {
CDirectoryListing listing;
if (m_pState->m_pEngine->CacheLookup(path, listing) == FZ_REPLY_OK) {
child = AppendItem(parent, *iter, 0, 2, path.HasParent() ? 0 : new CItemData(path));
SetItemImages(child, false);
}
else {
child = AppendItem(parent, *iter, 1, 3, path.HasParent() ? 0 : new CItemData(path));
SetItemImages(child, true);
}
SortChildren(parent);
auto nextIter = iter;
++nextIter;
if (nextIter != pieces.rend())
DisplayItem(child, listing);
}
if (select && iter != pieces.rbegin()) {
#ifndef __WXMSW__
// Prevent CalculatePositions from being called
wxGenericTreeItem *anchor = m_anchor;
m_anchor = 0;
#endif
Expand(parent);
#ifndef __WXMSW__
m_anchor = anchor;
#endif
}
parent = child;
}
return parent;
}
void CRemoteTreeView::ApplyFilters(bool resort)
{
std::list<struct _parents> parents;
const wxTreeItemId root = GetRootItem();
wxTreeItemIdValue cookie;
for (wxTreeItemId child = GetFirstChild(root, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
CFilterManager filter;
while (!parents.empty()) {
struct _parents parent = parents.back();
parents.pop_back();
if (resort) {
SortChildren(parent.item);
}
CDirectoryListing listing;
if (m_pState->m_pEngine->CacheLookup(parent.path, listing) == FZ_REPLY_OK)
RefreshItem(parent.item, listing, false);
else if (filter.HasActiveFilters()) {
for (wxTreeItemId child = GetFirstChild(parent.item, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
if (filter.FilenameFiltered(GetItemText(child), path.GetPath(), true, -1, false, 0, CDateTime())) {
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
if (!sel) {
Delete(child);
continue;
}
}
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
// The stuff below has already been done above in this one case
continue;
}
for (wxTreeItemId child = GetFirstChild(parent.item, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
}
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterManager filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
CLocalFileSystem local_filesystem;
if (!local_filesystem.BeginFindFiles(dir.dir, true))
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
std::list<wxString> dirs;
wxString file;
const wxLongLong size(-1);
bool was_link;
bool is_dir;
int attributes;
while (local_filesystem.GetNextFile(file, was_link, is_dir, 0, 0, &attributes))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
if (filter.FilenameFiltered(file, dir.dir, true, size, true, attributes))
continue;
dirs.push_back(file);
}
dirs.sort(sortfunc);
bool inserted = false;
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
#ifdef __WXMSW__
int cmp = GetItemText(child).CmpNoCase(*iter);
#else
int cmp = GetItemText(child).Cmp(*iter);
#endif
if (!cmp)
{
if (!IsExpanded(child))
{
wxString path = dir.dir + *iter + separator;
if (!CheckSubdirStatus(child, path))
{
t_dir subdir;
subdir.dir = path;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
iter++;
inserted = true;
}
}
while (child)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
iter++;
inserted = true;
}
if (inserted)
SortChildren(dir.item);
}
#ifdef __WXMSW__
SetErrorMode(prevErrorMode);
#endif
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterDialog filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
wxDir find(dir.dir);
if (!find.IsOpened())
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
wxString file;
bool found = find.GetFirst(&file, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
std::list<wxString> dirs;
while (found)
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
found = find.GetNext(&file);
continue;
}
wxFileName fn(dir.dir + file);
const bool isDir = fn.DirExists();
wxLongLong size;
wxStructStat buf;
int result = wxStat(fn.GetFullPath(), &buf);
if (!isDir && !result)
size = buf.st_size;
else
size = -1;
int attributes;
#ifdef __WXMSW__
DWORD tmp = GetFileAttributes(fn.GetFullPath());
if (tmp == INVALID_FILE_ATTRIBUTES)
attributes = 0;
else
attributes = tmp;
#else
if (!result)
attributes = buf.st_mode & 0x777;
else
attributes = -1;
#endif //__WXMSW__
if (!filter.FilenameFiltered(file, isDir, size , true, attributes))
dirs.push_back(file);
found = find.GetNext(&file);
}
dirs.sort(sortfunc);
bool inserted = false;
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
#ifdef __WXMSW__
int cmp = GetItemText(child).CmpNoCase(*iter);
#else
int cmp = GetItemText(child).Cmp(*iter);
#endif
if (!cmp)
{
if (!IsExpanded(child))
{
wxTreeItemId subchild = GetLastChild(child);
if (subchild && GetItemText(subchild) == _T(""))
{
if (!HasSubdir(dir.dir + *iter + separator))
Delete(subchild);
}
else if (!subchild)
{
if (HasSubdir(dir.dir + *iter + separator))
AppendItem(child, _T(""));
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname), GetIconIndex(opened_dir, fullname));
if (HasSubdir(fullname))
AppendItem(newItem, _T(""));
iter++;
inserted = true;
}
}
while (child)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname), GetIconIndex(opened_dir, fullname));
if (HasSubdir(fullname))
AppendItem(newItem, _T(""));
iter++;
inserted = true;
}
if (inserted)
SortChildren(dir.item);
}
#ifdef __WXMSW__
SetErrorMode(prevErrorMode);
#endif
}
void CLocalTreeView::DisplayDir(wxTreeItemId parent, const wxString& dirname, const wxString& knownSubdir /*=_T("")*/)
{
fz::local_filesys local_filesys;
{
wxLogNull log;
if (!local_filesys.begin_find_files(fz::to_native(dirname), true)) {
if (!knownSubdir.empty()) {
wxTreeItemId item = GetSubdir(parent, knownSubdir);
if (item != wxTreeItemId())
return;
const wxString fullName = dirname + knownSubdir;
item = AppendItem(parent, knownSubdir, GetIconIndex(iconType::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(iconType::opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
else
{
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
}
return;
}
}
wxASSERT(parent);
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
CFilterManager filter;
bool matchedKnown = false;
fz::native_string file;
bool wasLink;
int attributes;
bool is_dir;
static int64_t const size(-1);
fz::datetime date;
while (local_filesys.get_next_file(file, wasLink, is_dir, 0, &date, &attributes)) {
wxASSERT(is_dir);
if (file.empty()) {
wxGetApp().DisplayEncodingWarning();
continue;
}
wxString file_wx = file;
wxString fullName = dirname + file_wx;
#ifdef __WXMSW__
if (file_wx.CmpNoCase(knownSubdir))
#else
if (file_wx != knownSubdir)
#endif
{
if (filter.FilenameFiltered(file_wx, dirname, true, size, true, attributes, date))
continue;
}
else
matchedKnown = true;
wxTreeItemId item = AppendItem(parent, file_wx, GetIconIndex(iconType::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(iconType::opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
if (!matchedKnown && !knownSubdir.empty()) {
const wxString fullName = dirname + knownSubdir;
wxTreeItemId item = AppendItem(parent, knownSubdir, GetIconIndex(iconType::dir, fullName),
#ifdef __WXMSW__
-1
#else
GetIconIndex(iconType::opened_dir, fullName)
#endif
);
CheckSubdirStatus(item, fullName);
}
SortChildren(parent);
}
BOOL CZoneTree::MenuSelect(UINT id)
{
HTREEITEM it, par;
room_data *room;
int index;
CPoint pos;
CWinDEDlg *parent = (CWinDEDlg*)GetParent();
switch(id) {
case ID_TREE_GOTO:
par = GetSelectedItem();
room = (room_data*)GetItemData(par);
parent->in_room = room;
parent->ShowRoom();
break;
case ID_TREE_EDIT_AREA:
case ID_TREE_EDIT_ROOM:
case ID_TREE_EDIT_MINDEX:
case ID_TREE_EDIT_OINDEX:
case ID_TREE_EDIT_MOB:
case ID_TREE_EDIT_OBJ:
GetCursorPos(&pos);
OnLButtonDblClk(0, pos);
break;
case ID_TREE_DELETE_ROOM:
case ID_TREE_DELETE_MOB:
case ID_TREE_DELETE_OBJ:
case ID_TREE_DELETE_OINDEX:
case ID_TREE_DELETE_MINDEX:
OnKeyUp(VK_DELETE, 1, 0);
break;
case ID_TREE_NEW_AREA:
parent->OnNewArea();
break;
case ID_TREE_SAVE_AREA:
parent->OnSave();
break;
case ID_TREE_OPEN_AREA:
parent->OnOpen();
break;
case ID_TREE_DELETE_ROOMS:
parent->DeleteAllRooms();
break;
case ID_TREE_DELETE_MOBS:
parent->DeleteAllMobs();
break;
case ID_TREE_DELETE_OBJS:
parent->DeleteAllObjs();
break;
case ID_TREE_ROOM_GRID:
parent->OnCreateGrid();
break;
case ID_TREE_FRIENDS: {
mob_index *mob;
DlgEditFriends friends;
it = GetSelectedItem();
mob = (mob_index*)GetItemData(it);
friends.mob = mob;
friends.DoModal();
}
break;
case ID_TREE_REMOVE_PEOPLE:
it = GetSelectedItem();
par = GetParentItem(it);
room = (room_data*)GetItemData(par);
DeleteItem(it);
if(room) {
room->m_tPeople = parent->InsertItem(CString("Occupants"), room->m_tThis, NULL, PEOPLE);
room->RemoveEveryone();
}
SortChildren(par);
break;
case ID_TREE_EDIT_EQUIP: {
mob_index *mob;
DlgEquipMob dlg_eq;
it = GetSelectedItem();
mob = (mob_index*)GetItemData(it);
dlg_eq.mob = mob;
dlg_eq.DoModal();
}
break;
case ID_TREE_NEW_MOB:
parent->OnNewMob();
break;
case ID_TREE_NEW_OBJ:
parent->OnNewObject();
break;
case ID_TREE_NEW_ROOM:
parent->OnNewRoom();
break;
case ID_TREE_EDIT_CONTENTS:
{
DlgEditContents dlg_inv(this);
par = GetSelectedItem();
dlg_inv.obj= (obj_index*)GetItemData(par);
dlg_inv.DoModal();
}
break;
case ID_TREE_REMOVE_CONTENTS:
it = GetSelectedItem();
par = GetParentItem(it);
GetItemImage(par, index, index);
switch(index) {
case ROOM_DATA:
room = (room_data*)GetItemData(par);
DeleteItem(it);
if(room) {
room->m_tContents = parent->InsertItem(CString("Contents"), room->m_tThis, NULL, CONTENTS);
room->RemoveContents();
}
SortChildren(par);
break;
case OBJECT_DATA: {
object_data *obj = (object_data*)GetItemData(par);
DeleteItem(it);
if(obj) {
obj->RemoveContents();
}
break;
}
case OBJ_INDEX: {
obj_index *obj = (obj_index*)GetItemData(par);
DeleteItem(it);
if(obj)
obj->RemoveContents();
break;
}
case MOB_INDEX:
break;
case MOB_DATA:
break;
}
break;
}
return true;
}
void CFileTreeCtrl::expandingItem(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
HTREEITEM hItem = pNMTreeView->itemNew.hItem;
UINT uiAction = pNMTreeView->action;
HTREEITEM hChildItem = GetChildItem(hItem);
CString sItemText = GetItemText(hItem);
CString sChildText = GetItemText(hChildItem);
if(uiAction == TVE_EXPAND)
{
if(GetParentItem(hItem) != NULL)
setImage(hItem, sItemText, uiAction);
if(sChildText.CompareNoCase(EMPTYITEM) == 0)
{
// Prepare for update
SetRedraw(FALSE);
SetCursor(LoadCursor(NULL, IDC_WAIT));
HTREEITEM hParent = GetParentItem(hItem);
DeleteItem(hChildItem);
std::wstring sPath;
if(getPath(hItem, sPath))
{
CFileSystem fileio;
HTREEITEM hNewItem = NULL;
PathInfo info;
bool bContinue = fileio.findFirst(sPath, info);
while(bContinue)
{
if(info.Attributes & FILE_ATTRIBUTE_DIRECTORY)
{
hNewItem = InsertItem(info.sName.c_str(), hItem, TVI_LAST);
setImage(hNewItem, CString(info.sName.c_str()), uiAction);
if(fileio.hasDirectories(sPath + info.sName))
{
InsertItem(EMPTYITEM, hNewItem, TVI_LAST);
}
// Set item state to required colour
if(info.bCovert)
SetItemData(hNewItem, FILE_COVERT);
else
SetItemData(hNewItem, info.Attributes);
}
bContinue = fileio.findNext(info);
}
SortChildren(hItem);
Expand(hItem, TVE_EXPAND);
}
// Update complete
SetCursor(LoadCursor (NULL, IDC_ARROW));
SetRedraw(TRUE);
}
}
else if(uiAction == TVE_COLLAPSE)
{
if(GetParentItem(hItem) != NULL)
setImage(hItem, sItemText, uiAction);
}
*pResult = 0;
}
//adds a newly created item to the tree after belonging to the specified parent
// If the parent is NULLITEM it is added as a sibling to the root. It will fail
// if it cannot find the appropriate parent. This object is then orphaned, and
// it is the tree manager's responsibility to release the memory. Due to this
// all the items MUST be created on the heap using new. The return value is the
// key for the new item, which uniquely identifies it. Keys CANNOT be
// transferred between trees
CLTWinTreeKey CLTWinTreeMgr::AddItem( CLTWinTreeItem* pNewItem,
CLTWinTreeKey Parent,
BOOL bSortChildren)
{
//sanity check
if(pNewItem == NULL)
{
return NULLITEM;
}
//first add into the tree heiarchy
//create a pointer to the parent
CLTWinTreeItem* pParent = KeyToItem(Parent);
HTREEITEM hParent = TVI_ROOT;
//see if it belongs to the root
if(pParent == NULL)
{
//setup the item
pNewItem->m_pNextSibling = m_pRoot;
pNewItem->m_pPrevSibling = NULL;
pNewItem->m_pParent = NULL;
pNewItem->m_pFirstChild = NULL;
//setup the back link from the first root item
if(m_pRoot)
{
m_pRoot->m_pPrevSibling = pNewItem;
}
//setup the owner
m_pRoot = pNewItem;
}
else
{
//doesn't belong to root, so add it to the parent item
//setup the item
pNewItem->m_pNextSibling = pParent->m_pFirstChild;
pNewItem->m_pPrevSibling = NULL;
pNewItem->m_pParent = pParent;
pNewItem->m_pFirstChild = NULL;
//setup the link of the first sibling back to this one
if(pParent->m_pFirstChild)
{
pParent->m_pFirstChild->m_pPrevSibling = pNewItem;
}
//setup the owner
pParent->m_pFirstChild = pNewItem;
hParent = pParent->m_hTreeItem;
}
//add it to the control, use different methods depending on
//if it has an icon or not
if(pNewItem->GetIcon() >= 0)
{
pNewItem->m_hTreeItem = InsertItem( pNewItem->GetText(),
pNewItem->GetIcon(),
pNewItem->GetIcon(),
hParent);
}
else
{
pNewItem->m_hTreeItem = InsertItem( pNewItem->GetText(), hParent);
}
//set the item data as a pointer to the list item
SetItemData(pNewItem->m_hTreeItem, (DWORD)pNewItem);
if(bSortChildren)
{
//make sure the children are in alphabetacal ordering
SortChildren(hParent);
}
//now give the user the key back
return ItemToKey(pNewItem);
}
void CEditTreeCtrl::SortCurrentLevel(HTREEITEM hItem) {
if(!hItem)
hItem = GetSelectedItem();
if(CanSortLevel(hItem))
SortChildren(hItem ? GetParentItem(hItem) : hItem);
}
void CRemoteTreeView::RefreshItem(wxTreeItemId parent, const CDirectoryListing& listing, bool will_select_parent)
{
SetItemImages(parent, false);
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild(parent, cookie);
if (!child || GetItemText(child) == _T(""))
{
DisplayItem(parent, listing);
return;
}
CFilterManager filter;
const wxString path = listing.path.GetPath();
std::list<wxString> dirs;
for (unsigned int i = 0; i < listing.GetCount(); i++)
{
if (!listing[i].is_dir())
continue;
if (!filter.FilenameFiltered(listing[i].name, path, true, -1, false, 0, listing[i].has_date() ? &listing[i].time : 0))
dirs.push_back(listing[i].name);
}
dirs.sort(sortfunc);
bool inserted = false;
child = GetLastChild(parent);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
int cmp = GetItemText(child).CmpNoCase(*iter);
if (!cmp)
cmp = GetItemText(child).Cmp(*iter);
if (!cmp)
{
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
if (!GetLastChild(child) && HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
SetItemImages(child, false);
}
else
SetItemImages(child, true);
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
// New directory
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
wxTreeItemId child = AppendItem(parent, *iter, 0, 2, 0);
SetItemImages(child, false);
if (HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
}
else
{
wxTreeItemId child = AppendItem(parent, *iter, 1, 3, 0);
if (child)
SetItemImages(child, true);
}
iter++;
inserted = true;
}
}
while (child)
{
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
wxTreeItemId child = AppendItem(parent, *iter, 0, 2, 0);
SetItemImages(child, false);
if (HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
}
else
{
wxTreeItemId child = AppendItem(parent, *iter, 1, 3, 0);
SetItemImages(child, true);
}
iter++;
inserted = true;
}
if (inserted)
SortChildren(parent);
}
void CLocalTreeView::DisplayDir(wxTreeItemId parent, const wxString& dirname, const wxString& knownSubdir /*=_T("")*/)
{
wxDir dir;
{
wxLogNull log;
if (!dir.Open(dirname))
{
if (knownSubdir != _T(""))
{
wxTreeItemId item = GetSubdir(parent, knownSubdir);
if (item != wxTreeItemId())
return;
const wxString fullName = dirname + knownSubdir;
item = AppendItem(parent, knownSubdir, GetIconIndex(::dir, fullName), GetIconIndex(opened_dir, fullName));
if (HasSubdir(fullName))
AppendItem(item, _T(""));
}
else
{
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
}
return;
}
}
wxASSERT(parent);
m_setSelection = true;
DeleteChildren(parent);
m_setSelection = false;
wxString file;
CFilterDialog filter;
bool matchedKnown = false;
for (bool found = dir.GetFirst(&file, _T(""), wxDIR_DIRS | wxDIR_HIDDEN); found; found = dir.GetNext(&file))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
wxString fullName = dirname + file;
#ifdef __WXMSW__
if (file.CmpNoCase(knownSubdir))
#else
if (file != knownSubdir)
#endif
{
wxFileName fn(fullName);
const bool isDir = fn.DirExists();
wxLongLong size;
const wxString& fullName = fn.GetFullPath();
wxStructStat buf;
int result = wxStat(fullName, &buf);
if (!isDir && !result)
size = buf.st_size;
else
size = -1;
int attributes;
#ifdef __WXMSW__
DWORD tmp = GetFileAttributes(fullName);
if (tmp == INVALID_FILE_ATTRIBUTES)
attributes = 0;
else
attributes = tmp;
#else
if (!result)
attributes = buf.st_mode & 0x777;
else
attributes = -1;
#endif //__WXMSW__
if (filter.FilenameFiltered(file, isDir, size, true, attributes))
continue;
}
else
matchedKnown = true;
wxTreeItemId item = AppendItem(parent, file, GetIconIndex(::dir, fullName), GetIconIndex(opened_dir, fullName));
if (HasSubdir(fullName))
AppendItem(item, _T(""));
}
if (!matchedKnown && knownSubdir != _T(""))
{
const wxString fullName = dirname + knownSubdir;
wxTreeItemId item = AppendItem(parent, knownSubdir, GetIconIndex(::dir, fullName), GetIconIndex(opened_dir, fullName));
if (HasSubdir(fullName))
AppendItem(item, _T(""));
}
SortChildren(parent);
}
wxTreeItemId CLocalTreeView::AddDrive(wxChar drive)
{
// Adhere to the NODRIVES group policy
long drivesToHide = 0;
wxRegKey key(_T("HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"));
if (key.Exists())
{
if (!key.HasValue(_T("NoDrives")) || !key.QueryValue(_T("NoDrives"), &drivesToHide))
drivesToHide = 0;
}
int bit = 0;
if (drive >= 'A' && drive <= 'Z')
bit = 1 << (drive - 'A');
else if (drive >= 'a' && drive <= 'z')
bit = 1 << (drive - 'a');
if (drivesToHide & bit)
return wxTreeItemId();
wxString driveName = drive;
driveName += _T(":");
// Get the label of the drive
wxChar volumeName[501];
int oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
BOOL res = GetVolumeInformation(driveName + _T("\\"), volumeName, 500, 0, 0, 0, 0, 0);
SetErrorMode(oldErrorMode);
wxString itemLabel = driveName;
if (res && volumeName[0])
{
itemLabel += _T(" (");
itemLabel += volumeName;
itemLabel += _T(")");
}
wxTreeItemIdValue value;
wxTreeItemId driveItem = GetFirstChild(m_drives, value);
while (driveItem)
{
if (!GetItemText(driveItem).Left(2).CmpNoCase(driveName))
break;
driveItem = GetNextSibling(driveItem);
}
if (driveItem)
{
SetItemText(driveItem, itemLabel);
int icon = GetIconIndex(dir, driveName + _T("\\"));
SetItemImage(driveItem, icon, wxTreeItemIcon_Normal);
SetItemImage(driveItem, icon, wxTreeItemIcon_Selected);
SetItemImage(driveItem, icon, wxTreeItemIcon_Expanded);
SetItemImage(driveItem, icon, wxTreeItemIcon_SelectedExpanded);
return driveItem;
}
wxTreeItemId item = AppendItem(m_drives, itemLabel, GetIconIndex(dir, driveName + _T("\\")));
AppendItem(item, _T(""));
SortChildren(m_drives);
return item;
}
