private FileSystemTreeNode AddFileNode(EntryInfo info)
{
FileSystemTreeNode node = FileSystemTreeNode.CreateFileNode(info);
Nodes.Add(node);
return(node);
}
private TreeNode AddLazyLoadingNode()
{
FileSystemTreeNode node = FileSystemTreeNode.CreateLoadingNode();
Nodes.Add(node);
return(node);
}
private FileSystemTreeNode AddDriveNode(TreeView view, EntryInfo info)
{
FileSystemTreeNode node = FileSystemTreeNode.CreateDriveNode(info);
view.Nodes.Add(node);
return(node);
}
private void RestoreNodeState(FileSystemTreeNode node)
{
if (CheckedDataSource == null)
{
return;
}
switch (node.Data.Type)
{
default:
throw new ArgumentException("Unhandled TypeEnum", "type");
case TypeEnum.LOADING:
// Ignore this node.
break;
case TypeEnum.DRIVE:
case TypeEnum.FOLDER:
case TypeEnum.FILE:
{
string path = node.Data.Path;
FileSystemTreeNodeData match;
bool found = CheckedDataSource.TryGetValue(path, out match);
if (found && match.Type == node.Data.Type)
{
node.Data = match;
SetStateImage(node, (int)match.State);
}
break;
}
}
}
public static FileSystemTreeNode CreateFileNode(EntryInfo info)
{
FileSystemTreeNode node = new FileSystemTreeNode(info.Name, 0, 0);
node.ImageKey = "file";
node.Data.InfoObject = info;
return(node);
}
public static FileSystemTreeNode CreateLoadingNode()
{
FileSystemTreeNode node = new FileSystemTreeNode("Retrieving data...", 0, 0);
node.Data.Type = TypeEnum.LOADING;
node.ImageKey = "loading";
return(node);
}
public static FileSystemTreeNode CreateFolderNode(EntryInfo info)
{
FileSystemTreeNode node = new FileSystemTreeNode(info.Name, 0, 0);
node.ImageKey = "folder";
node.Data.InfoObject = info;
node.AddLazyLoadingNode();
return(node);
}
private void BuildTagDataDict(FileSystemTreeNode node, Dictionary <string, FileSystemTreeNodeData> dict)
{
// Skip over loading nodes and nodes without a tag.
if (node == null || node.Data.Type == TypeEnum.LOADING)
{
return;
}
CheckState state = GetCheckState(node);
switch (state)
{
case CheckState.Unchecked:
// If it's unchecked, ignore it and its child nodes.
return;
case CheckState.Checked:
// If it's checked, add it and ignore its child nodes.
// This means the entire folder is checked - regardless of what it contains.
if (CheckedDataSource != null)
{
string path = node.Data.Path;
FileSystemTreeNodeData match;
bool found = dict.TryGetValue(path, out match);
match = found ? match : node.Data;
match.State = CheckState.Checked;
node.Data = match;
if (!dict.ContainsKey(match.Path))
{
dict.Add(match.Path, match);
}
}
else
{
FileSystemTreeNodeData tag = node.Data;
tag.State = CheckState.Checked;
if (!dict.ContainsKey(tag.Path))
{
dict.Add(tag.Path, tag);
}
}
break;
case CheckState.Mixed:
// Ignore it, but verify its child nodes.
foreach (FileSystemTreeNode child in node.Nodes)
{
BuildTagDataDict(child, dict);
}
break;
}
}
private void RemoveLazyLoadingNode()
{
FileSystemTreeNode node = FirstNode as FileSystemTreeNode;
if (node == null)
{
return;
}
if (node.Data.Type == TypeEnum.LOADING)
{
node.Remove();
}
}
private void RestoreNodeStateRecursively(FileSystemTreeNode node)
{
//if (GetCheckState(parentNode) == CheckState.Checked)
//{
// //SetCheckState(node, CheckState.Checked);
//}
//else
//{
RestoreNodeState(node);
//}
foreach (FileSystemTreeNode subNode in node.Nodes)
{
RestoreNodeStateRecursively(subNode);
}
}
private void RestoreNodeStateRemove(FileSystemTreeNode node)
{
if (CheckedDataSource == null)
{
return;
}
if (node.Data == null)
{
return;
}
if (node.Data.Type != TypeEnum.LOADING)
{
string path = node.Data.Path;
if (CheckedDataSource.ContainsKey(path))
{
CheckedDataSource.Remove(path);
}
}
}
public static FileSystemTreeNode CreateDriveNode(EntryInfo info)
{
//string nodeName = null;
// TODO: Support showing drive label!
//try
//{
// string driveLabel = info.VolumeLabel;
// if (string.IsNullOrEmpty(driveLabel))
// nodeName = info.Name;
// else
// nodeName = string.Format("{0} ({1})", info.Name, driveLabel);
//}
//catch (Exception)
//{
// nodeName = info.Name;
//}
FileSystemTreeNode node = new FileSystemTreeNode(info.Name, 0, 0);
node.ImageKey = "drive";
node.Data.InfoObject = info;
node.AddLazyLoadingNode();
return(node);
}
// May throw System.SystemException
private void PopuplateDirectory(EntryInfo info)
{
if (info.Type != TypeEnum.DRIVE && info.Type != TypeEnum.FOLDER)
{
throw new ArgumentException("Unexpected TypeEnum", "info.Type");
}
ZetaLongPaths.ZlpDirectoryInfo dir = info.Type == TypeEnum.DRIVE
? new ZetaLongPaths.ZlpDirectoryInfo(new DriveInfo(info.Path).RootDirectory.FullName)
: new ZetaLongPaths.ZlpDirectoryInfo(info.Path);
ZetaLongPaths.ZlpDirectoryInfo[] subDirs = dir.GetDirectories();
ZetaLongPaths.ZlpFileInfo[] subFiles = dir.GetFiles();
foreach (ZetaLongPaths.ZlpDirectoryInfo subDir in subDirs)
{
EntryInfo subInfo = new EntryInfo(TypeEnum.FOLDER, subDir.Name, subDir.FullName + System.IO.Path.DirectorySeparatorChar);
FileSystemTreeNode subFolderNode = AddFolderNode(subInfo);
}
foreach (var file in subFiles)
{
EntryInfo subInfo = new EntryInfo(TypeEnum.FILE, file.Name, file.FullName);
FileSystemTreeNode subFileNode = AddFileNode(subInfo);
}
}
public void PopulateDrives()
{
try
{
DriveInfo[] drives = DriveInfo.GetDrives();
foreach (var drive in drives)
{
string infoName = null;
try
{
string driveLabel = drive.VolumeLabel;
if (string.IsNullOrEmpty(driveLabel))
{
infoName = drive.Name;
}
else
{
infoName = string.Format("{0} ({1})", drive.Name, driveLabel);
}
}
catch (Exception)
{
infoName = drive.Name;
}
EntryInfo info = new EntryInfo(TypeEnum.DRIVE, infoName, drive.Name);
FileSystemTreeNode driveNode = FileSystemTreeNode.CreateDriveNode(info);
this.Nodes.Add(driveNode);
RestoreNodeState(driveNode);
}
}
catch (System.SystemException e)
{
ShowErrorMessage(e, null);
}
}
