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); } }