private void ApplyCustomFilters(FileSystemTreeElement fileSystemTreeElement)
{
fileSystemTreeElement.IsVisible = fileSystemTreeElement.ElementInfo.Extension.Length > 1;
List <string> splitExtensions = this.FileFilterExtensions?
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.ToList()
.Select((filterFileExtension) => filterFileExtension.TrimStart(' ', '.').TrimEnd()).ToList() ?? new List <string>();
if (splitExtensions.Any(
(fileExtension) => fileExtension.Equals("*", StringComparison.OrdinalIgnoreCase)))
{
fileSystemTreeElement.IsVisible =
fileSystemTreeElement.ElementInfo.Extension.Length > 1 &&
!splitExtensions.Any(
(extension) => extension.Equals(fileSystemTreeElement.ElementInfo.Extension.Substring(1),
StringComparison.OrdinalIgnoreCase));
return;
}
fileSystemTreeElement.IsVisible =
fileSystemTreeElement.ElementInfo.Extension.Length > 1 &&
splitExtensions.Any(
(extension) => extension.Equals(fileSystemTreeElement.ElementInfo.Extension.Substring(1),
StringComparison.OrdinalIgnoreCase));
}
private void ReplaceArchiveWithExtractedContents(FileSystemTreeElement archiveFileSystemTreeElement, DirectoryInfo archiveExtractionDirectory)
{
if (archiveFileSystemTreeElement.ParentFileSystemTreeElement.IsDirectory)
{
FileSystemTreeElement parent = archiveFileSystemTreeElement.ParentFileSystemTreeElement;
ObservableCollection <FileSystemTreeElement> parentContainigFileSystemElementCollection = parent.ChildFileSystemTreeElements;
int archiveFileIndex = parentContainigFileSystemElementCollection.IndexOf(archiveFileSystemTreeElement);
var archiveRepresentationNode = new FileSystemTreeElement(
parent.RootFileSystemTreeElement,
parent,
archiveExtractionDirectory)
{
IsArchive = true, AlternativeIElementName = archiveFileSystemTreeElement.ElementInfo.Name.Equals(archiveExtractionDirectory.Name, StringComparison.OrdinalIgnoreCase) ? "" : archiveExtractionDirectory.Name
};
List <FileSystemTreeElement> lazySubdirectories = archiveRepresentationNode.InitializeWithLazyTreeStructure();
archiveRepresentationNode.SortChildren();
FilterFileSystemTree(archiveRepresentationNode);
Application.Current.Dispatcher.Invoke(
() =>
{
parentContainigFileSystemElementCollection.Insert(archiveFileIndex, archiveRepresentationNode);
parentContainigFileSystemElementCollection.Remove(archiveFileSystemTreeElement);
archiveFileSystemTreeElement.ParentFileSystemTreeElement.ChildFileSystemTreeElements =
parentContainigFileSystemElementCollection;
if (archiveRepresentationNode.IsLazyLoading)
{
ObserveVirtualDirectories(lazySubdirectories);
}
archiveRepresentationNode.IsExpanded = true;
},
DispatcherPriority.Send);
}
}
private void UpdateFileSystemElementTreeState(FileSystemTreeElement fileSystemTreeElement)
{
this.IsExplorerInDefaultState = (fileSystemTreeElement.IsEmptyElement ||
fileSystemTreeElement.IsSystemDirectory && !fileSystemTreeElement.IsExpanded) &&
this.VirtualExplorerRootDirectory.ChildFileSystemTreeElements
.All((topLevelElement) => topLevelElement.IsSystemDirectory &&
!topLevelElement.IsExpanded ||
!this.VirtualExplorerRootDirectory.ChildFileSystemTreeElements.Any());
}
private void ApplyDefaultFilters(FileSystemTreeElement fileSystemTreeElement)
{
if (fileSystemTreeElement.ElementInfo.Extension.Length < 2)
{
fileSystemTreeElement.IsVisible = this.defaultFilterFileExtensions.HasFlag(FileExtensions.Any);
return;
}
if (!this.IsShowingArchiveFiles && fileSystemTreeElement.IsArchive)
{
fileSystemTreeElement.IsVisible = false;
return;
}
if (!this.IsShowingTxtFiles && fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Txt.ToString("G"), StringComparison.OrdinalIgnoreCase))
{
fileSystemTreeElement.IsVisible = false;
return;
}
if (!this.IsShowingIniFiles && fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Ini.ToString("G"), StringComparison.OrdinalIgnoreCase))
{
fileSystemTreeElement.IsVisible = false;
return;
}
if (!this.IsShowingLogFiles && fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Log.ToString("G"), StringComparison.OrdinalIgnoreCase))
{
fileSystemTreeElement.IsVisible = false;
return;
}
fileSystemTreeElement.IsVisible = this.IsShowingLogFiles &&
(fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Log.ToString("G"),
StringComparison.OrdinalIgnoreCase) ||
fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Bak.ToString("G"),
StringComparison.OrdinalIgnoreCase)) ||
this.IsShowingTxtFiles &&
fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Txt.ToString("G"),
StringComparison.OrdinalIgnoreCase) ||
this.IsShowingIniFiles &&
fileSystemTreeElement.ElementInfo.Extension.Substring(1).Equals(
FileExtensions.Ini.ToString("G"),
StringComparison.OrdinalIgnoreCase) ||
this.IsShowingArchiveFiles &&
fileSystemTreeElement.IsArchive ||
this.IsShowingAnyFiles;
}
private void CleanUpExtraction(FileSystemTreeElement archiveFileTreeElement)
{
ClearIsExtracting();
lock (this.syncLock)
{
this.HasExtractionsRunning = this.runningExtractionsCount > 0;
this.ArchiveExtractorInstanceTable.Remove(archiveFileTreeElement);
this.ExtractionProgressTable.Remove(archiveFileTreeElement.ElementInfo);
}
ClearIsBusy();
}
private void ApplyFilterOnFileSystemTree(FileSystemTreeElement fileSystemTreeElement)
{
if (fileSystemTreeElement.ElementInfo is DirectoryInfo || fileSystemTreeElement.IsEmptyElement)
{
fileSystemTreeElement.IsVisible = true;
return;
}
if (this.IsFilteringFileSystemTreeByCustomExtensions)
{
ApplyCustomFilters(fileSystemTreeElement);
return;
}
ApplyDefaultFilters(fileSystemTreeElement);
}
private void LazyLoadChildren(FileSystemTreeElement directoryNode)
{
if (!directoryNode.HasLazyChildren)
{
return;
}
directoryNode.HasLazyChildren = false;
Task.Run(
() =>
{
List <FileSystemTreeElement> lazyFileSystemElements = directoryNode.InitializeWithLazyTreeStructure();
directoryNode.SortChildren();
FilterFileSystemTree(directoryNode);
if (directoryNode.IsLazyLoading)
{
ObserveVirtualDirectories(lazyFileSystemElements);
}
}).ConfigureAwait(true);
}
private void AddFilePathInfoToExplorerTree([NotNull] FileSystemInfo pathInfo, bool isRootFolderExpanded)
{
var fileSystemTreeElement = new FileSystemTreeElement(
this.VirtualExplorerRootDirectory,
this.VirtualExplorerRootDirectory,
pathInfo);
fileSystemTreeElement.IsArchive = !fileSystemTreeElement.IsDirectory &&
FileExtractor.FileIsArchive(fileSystemTreeElement.ElementInfo as FileInfo);
fileSystemTreeElement.IsSystemDirectory = DriveInfo.GetDrives().Any((driveInfo) => driveInfo.RootDirectory.FullName.Equals(fileSystemTreeElement.ElementInfo.FullName, StringComparison.OrdinalIgnoreCase));
if (fileSystemTreeElement.IsDirectory || fileSystemTreeElement.IsArchive)
{
List <FileSystemTreeElement> lazyFileSystemElements = fileSystemTreeElement.InitializeWithLazyTreeStructure();
// Observe top level tree directories 'IsExpanded' to show/ hide drag drop hint accordingly
ObserveTopLevelDirectoryIsExpanded(fileSystemTreeElement);
// Observe lazy children
if (fileSystemTreeElement.IsLazyLoading)
{
ObserveVirtualDirectories(lazyFileSystemElements);
fileSystemTreeElement.IsExpanded = isRootFolderExpanded && !fileSystemTreeElement.IsArchive;
}
}
// Validate state including the new item that to this point is still not added to the tree
UpdateFileSystemElementTreeState(fileSystemTreeElement);
Application.Current.Dispatcher.Invoke(
() =>
{
FilterFileSystemTree(fileSystemTreeElement);
this.VirtualExplorerRootDirectory.ChildFileSystemTreeElements.Add(fileSystemTreeElement);
},
DispatcherPriority.Send);
}
private void ToggleDirectoryNodeRecursive(FileSystemTreeElement fileSystemTreeElement, bool isExpanded)
{
fileSystemTreeElement.IsExpanded = isExpanded;
fileSystemTreeElement.ChildFileSystemTreeElements.Where((element) => element.IsDirectory).ToList().ForEach((node) => ToggleDirectoryNodeRecursive(node, isExpanded));
}
public void FilterFileSystemTree(FileSystemTreeElement rootFileSystemTreeElement)
{
rootFileSystemTreeElement.ApplyActionOnSubTree(ApplyFilterOnFileSystemTree, (element) => true);
}
public void ObserveTopLevelDirectoryIsExpanded(FileSystemTreeElement topLevelDirectory) => topLevelDirectory.ExpandedChanged += ToggleDragDropHintOnTopLevelDirectoryExpanded;
public async Task <(bool IsSuccessful, DirectoryInfo DestinationDirectory)> ExtractArchive(FileSystemTreeElement archiveFileTreeElement)
{
if (archiveFileTreeElement.IsDirectory || !archiveFileTreeElement.ElementInfo.Exists)
{
return(false, new DirectoryInfo(@"c:\"));
}
SetIsBusy();
var fileExtractor = new SharpCompressLibArchiveExtractor();
lock (this.syncLock)
{
if (this.ArchiveExtractorInstanceTable.ContainsKey(archiveFileTreeElement))
{
ClearIsBusy();
return(false, new DirectoryInfo(@"c:\"));
}
this.ArchiveExtractorInstanceTable.Add(archiveFileTreeElement, fileExtractor);
}
SetIsExtracting();
var progressReporter = new Progress <ExtractionProgressEventArgs>(ReportExtractionProgress);
(bool IsSuccessful, DirectoryInfo DestinationDirectory)extractionResult = await
fileExtractor.ExtractZipArchiveAsync(archiveFileTreeElement.ElementInfo as FileInfo, progressReporter);
// Replace archive file with directory representation in explorer after extraction completed
if (extractionResult.IsSuccessful)
{
ReplaceArchiveWithExtractedContents(archiveFileTreeElement, extractionResult.DestinationDirectory);
}
CleanUpExtraction(archiveFileTreeElement);
return(extractionResult);
}
