private void LoadSubdirectories()
{
foreach (var dir in Directory.GetDirectories(_rootPath))
{
SubDirectories.Add(Create(dir));
}
}
private async void LoadSubDirectoriesAsync()
{
if (!_isExpanded || !CanAccessDirectory())
{
return;
}
SubDirectories.Clear();
var directoryInfos = _directoryInfo.GetDirectories();
var directories = new List <DirectoryViewModel>();
foreach (var directoryInfo in directoryInfos)
{
await Task.Run(() => directories.Add(new DirectoryViewModel(directoryInfo.FullName)));
if (directories.Count != DIRECTORIES_PACK_LENGTH)
{
continue;
}
foreach (var directory in directories)
{
SubDirectories.Add(directory);
}
directories.Clear();
}
foreach (var directory in directories)
{
SubDirectories.Add(directory);
}
}
private void OnAddFolder(object e)
{
string absoluteFolderPath = ProjectDefinitions.GetAbsolutePath(Path);
string newFolderName = "NewFolder";
string newFolderPath = System.IO.Path.Combine(absoluteFolderPath, newFolderName);
if (Directory.Exists(newFolderPath))
{
bool bFoundName = false;
for (int i = 0; i < 1000; i++)
{
string folderName = newFolderName + i;
newFolderPath = System.IO.Path.Combine(absoluteFolderPath, folderName);
if (!Directory.Exists(newFolderPath))
{
bFoundName = true;
break;
}
}
if (!bFoundName)
{
return;
}
}
Directory.CreateDirectory(newFolderPath);
SubDirectories.Add(new CDirectoryEntry(ProjectDefinitions.GetRelativePath(newFolderPath), m_viewModel, this));
}
public override object GetChild(string key)
{
object ret = null;
if (ret == null)
{
ret = Files.Find(x => x.Name.ToLower() == key.ToLower());
}
if (ret == null && !key.EndsWith(".img"))
{
ret = Files.Find(x => x.Name.ToLower() == (key + ".img").ToLower());
}
if (ret == null)
{
ret = SubDirectories.Find(x => x.Name.ToLower() == key.ToLower());
}
if (ret is NameSpaceFile nsf)
{
ret = nsf.Object;
}
return(ret);
}
public DirInfo(FileInfo fileobj, DirInfo parent, bool isFilterActive)
: this()
{
Parent = parent;
Name = fileobj.Name;
Path = fileobj.FullName;
Root = parent.Root;
DirType = ObjectType.File;
Size = Helpers.GetFormattedFileSize(fileobj.Length); //(fileobj.Length / 1024).ToString() + " KB";
Ext = fileobj.Extension + " File";
SubDirectories.Clear();
SetImage();
if (FileManager.Configuration.Options.FileBrowserOptions.ShowHasExternalSubtitles || isFilterActive)
{
SetHasSubtitles(isFilterActive);
}
if (FileManager.Configuration.Options.FileBrowserOptions.ShowHasMovieInfo || isFilterActive)
{
SetHasMovieInfo(isFilterActive);
}
if (FileManager.Configuration.Options.FileBrowserOptions.ShowHasMoviesheet || isFilterActive)
{
SetHasMoviesheet(isFilterActive);
}
if (FileManager.Configuration.Options.FileBrowserOptions.ShowHasMoviesheetMetadata)
{
SetHasMoviesheetMetadata(isFilterActive);
}
}
private void LoadSubdirectories()
{
foreach (var dir in Directory.GetDirectories(_rootPath))
{
if (_itemOptions.ContainsKey(Path.Combine(_rootPath, dir)) && _itemOptions[dir] == ItemOption.Compress)
{
using (var ms = new MemoryStream())
{
var zip = new FastZip();
ZipOutputStream outZip;
zip.CreateZip(ms, Path.Combine(_rootPath, dir), true, null, null, out outZip);
outZip.Finish();
// IMPORTANT! outZip must be closed after use here
Files.Add(VirtualFile.Create(ms.Length, new DirectoryInfo(dir).Name + ".zip", ms.ToArray(), true));
outZip.Close();
outZip.Dispose();
}
}
else
{
SubDirectories.Add(Create(dir));
}
}
}
private void RemoveItem(FolderViewModel folder)
{
folder.OnOpened -= OnItemOpened;
folder.OnDeleted -= OnItemDeleted;
SubDirectories.Remove(folder);
AllItems.Remove(folder);
}
private void AddItem(FolderViewModel folder)
{
folder.OnOpened += OnItemOpened;
folder.OnDeleted += OnItemDeleted;
SubDirectories.Add(folder);
AllItems.Add(folder);
}
public Project(DirectoryInfo path) : base(path, "project")
{
foreach (var chapterDir in SubDirectories.OrderBy(k => k.Name, new MixedNumbersAndStringsComparer()))
{
var chapter = new Chapter(chapterDir, 1, Path + MetaData.OutputDir);
chapter.Parent = this;
Children.Add(chapter);
}
}
public override void Dispose()
{
base.Dispose();
SubDirectories?.Clear();
SubDirectories = null;
Files?.Clear();
Files = null;
}
public void Clean()
{
foreach (Directory dir in SubDirectories)
{
dir.Clean();
}
SubDirectories.Clear();
Files.Clear();
}
public void LoadAll()
{
if (!SubDirectories.IsLoaded && !SubDirectories.IsLoading)
{
SubDirectories.LoadAsync();
}
if (!Files.IsLoaded && !Files.IsLoading)
{
Files.LoadAsync();
}
}
public void UpdateSubDirectories()
{
SubDirectories.Clear();
string absolutePath = ProjectDefinitions.GetAbsolutePath(Path);
var subDirectories = Directory.GetDirectories(absolutePath);
foreach (string subDirectory in subDirectories)
{
SubDirectories.Add(new CDirectoryEntry(ProjectDefinitions.GetRelativePath(subDirectory), m_viewModel, this));
}
}
public override void ResolveSize()
{
this.Size = SubDirectories.Sum(it => it.Size) + Files.Sum(it => it.Size);
foreach (var dir in SubDirectories)
{
dir.SetPercentage(this.Size, _context.TotalSize);
}
foreach (var fsi in Files)
{
fsi.SetPercentage(this.Size, _context.TotalSize);
}
}
public Chapter(DirectoryInfo path, int level, string outputDir) : base(path, "chapter")
{
OutputDir = outputDir;
Level = level;
// Sections
foreach (var chapterDir in SubDirectories.OrderBy(k => k.Name, new MixedNumbersAndStringsComparer()))
{
var ch = new Chapter(chapterDir, Level + 1, OutputDir);
ch.Parent = this;
Children.Add(ch);
}
}
private void GetSubDirectories(string directory)
{
if (string.IsNullOrWhiteSpace(directory) || directory.Length < 3)
{
if (SubDirectories != null)
{
SubDirectories.Clear();
}
return;
}
Thread thread = new Thread(GetSubDirectoriesAsync);
thread.Start(directory);
}
public void Add(NameSpaceNode node)
{
if (node is NameSpaceDirectory dir)
{
SubDirectories.Add(dir);
}
else if (node is NameSpaceFile file)
{
Files.Add(file);
}
else
{
throw new Exception("Invalid PackageNode");
}
}
public void LoadDirectories(IEnumerable <DirInfo> children)
{
if (!IsLoaded)
{
SubDirectories.Clear();
foreach (DirInfo _child in children)
{
_child.Parent = this;
//_child.SetIsChecked(_child.IsChecked2, this.IsChecked2, true, false);
SubDirectories.Add(_child);
}
//SubDirectories = children.ToList<DirInfo>();
}
IsLoaded = true;
}
private void list(bool forceReload = false)
{
if (!_isSeparator)
{
if (forceReload || !_isInited || _rootModel.Bounty != null || IsFirstItem)
{
if (IsFirstItem)
{
//Exception - "This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread."
//SubDirectories.Clear();
SubDirectories.Load(true);
}
SubDirectories.Load(forceReload);
}
}
}
public override void OnSelected()
{
base.OnSelected();
if (HasSubDirectories && SubDirectories.Count == 1 && SubDirectories[0].Equals(dummyNode))
{
HasSubDirectories = EmbeddedDirectoryModel.EmbeddedDirectoryEntry.HasSubFolder;
if (!HasSubDirectories)
{
SubDirectories.Clear();
}
}
//Fixed DirectoryTree Collapse unrelated directory (1)
//SelectedDirectory now changed from here instead of DirectoryTree.xaml.cs
(RootModel as DirectoryTreeViewModel).SelectedDirectoryModel = this;
}
public string GetAlbumArtist(DirectoryInfo directory)
{
if (SubDirectories.Contains(directory.Name))
{
return(GetAlbumArtist(directory.Parent));
}
else
{
if (IsSpecialtyAlbum)
{
return(SpecialtyAlbumName);
}
else
{
return(directory.Parent.Name);
}
}
}
public string GetAlbumYear(DirectoryInfo directory)
{
if (SubDirectories.Contains(directory.Name))
{
return(GetAlbumYear(directory.Parent));
}
else
{
if (IsSpecialtyAlbum)
{
return("0000");
}
else
{
int endIndex = directory.Name.IndexOf(" - ");
return(directory.Name.Substring(0, endIndex));
}
}
}
protected override void FetchData(bool refresh)
{
base.FetchData(refresh);
if (bgWorker_loadSub == null)
{
return;
}
if (!IsLoaded)
{
refresh = true; //Not loaded before, force refresh.
SubDirectories.Clear();
}
if (refresh)
{
bgWorker_loadSub.RunBackgroundTask();
}
}
private string GetAlbumName(DirectoryInfo directory)
{
if (SubDirectories.Contains(directory.Name))
{
return(GetAlbumName(directory.Parent));
}
else
{
if (IsSpecialtyAlbum)
{
return(directory.Name);
}
else
{
int startIndex = directory.Name.IndexOf(" - ") + 3;
return(directory.Name.Substring(startIndex));
}
}
}
private FileTree SelectDirectory(string[] path)
{
// make the top level directory selectable by passing an empty path
//if ((path.Length == 0) || ((path.Length == 1) && (path[0].Length == 1) && (PathSeparators.Contains(path[0][0]))))
if (path.Length == 0)
{
return(this);
}
FileTree sub = SubDirectories.First(subDir => subDir.Name == path[0]);
if ((sub != null) && (path.Length > 1))
{
return(sub.SelectDirectory(path.Skip(1).ToArray()));
}
else
{
return(sub);
}
}
private void setUpBackgroundWorker()
{
bgWorker_loadSub = new BackgroundTaskManager <DispatcherNotifiedObservableCollection <DirectoryTreeItemViewModel> >(
() =>
{
IsLoading = true;
return(getDirectories());
},
(result) =>
{
List <DirectoryTreeItemViewModel> delList = new List <DirectoryTreeItemViewModel>(SubDirectories.ToArray());
List <DirectoryTreeItemViewModel> addList = new List <DirectoryTreeItemViewModel>();
foreach (DirectoryTreeItemViewModel model in result)
{
if (delList.Contains(model))
{
delList.Remove(model);
}
else
{
addList.Add(model);
}
}
foreach (DirectoryTreeItemViewModel model in delList)
{
SubDirectories.Remove(model);
}
foreach (DirectoryTreeItemViewModel model in addList)
{
SubDirectories.Add(model);
}
HasSubDirectories = SubDirectories.Count > 0;
IsLoading = false;
});
}
/// <summary>
/// Creates a new sub-directory with a default name in this directory.
/// </summary>
/// <param name="editing">Indicates whether the new sub-directory should be put in edit mode immediately when constructed.</param>
/// <returns>A new instance of <see cref="DirectoryViewModel"/> representing the new sub-directory.</returns>
public DirectoryViewModel CreateSubDirectory(bool editing)
{
var newDirectory = new DirectoryViewModel(NamingHelper.ComputeNewName(NewFolderDefaultName, SubDirectories.Cast <DirectoryBaseViewModel>(), x => x.Name), this, true)
{
IsEditing = editing
};
return(newDirectory);
}
bool IAddChildViewModel.CanAddChildren(IReadOnlyCollection <object> children, AddChildModifiers modifiers, out string message)
{
if (children.Any(x => (x is IIsEditableViewModel) && !((IIsEditableViewModel)x).IsEditable))
{
message = "Some source items are read-only";
return(false);
}
if (!Package.IsEditable)
{
message = "Read-only package";
return(false);
}
message = $"Add to {Path}";
foreach (var child in children)
{
var mountPoint = child as MountPointViewModel;
var directory = child as DirectoryViewModel;
var asset = child as AssetViewModel;
if (mountPoint != null)
{
message = DragDropBehavior.InvalidDropAreaMessage;
return(false);
}
if (directory != null)
{
if (directory == this)
{
message = "Can't drop a folder on itself or its children";
return(false);
}
if (directory.Root.GetType() != Root.GetType())
{
message = "Incompatible folder";
return(false);
}
if (directory.Root is ProjectViewModel && Root != directory.Root)
{
message = "Can't move source files between projects";
return(false);
}
if (SubDirectories.Any(x => x.Name == directory.Name))
{
message = $"Directory {((this is DirectoryViewModel) ? Path : Name)} already contains a subfolder named {directory.Name}";
return(false);
}
if (children.OfType <DirectoryViewModel>().Any(x => x != child && string.Compare(x.Name, directory.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
message = "Can't move directories with duplicate names";
return(false);
}
var currentParent = Parent;
while (currentParent != null)
{
if (currentParent == directory)
{
message = "Can't drop a directory on itself or its children";
return(false);
}
currentParent = currentParent.Parent;
}
}
else if (asset != null)
{
if (asset.IsLocked)
{
message = $"Asset {asset.Url} can't be moved";
return(false);
}
if (Assets.Any(x => string.Compare(x.Name, asset.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
message = $"{(!string.IsNullOrEmpty(Path) ? $"Directory {Path}" : "This directory")} already contains an asset named {asset.Name}";
return(false);
}
if (children.OfType <AssetViewModel>().Any(x => x != child && string.Compare(x.Name, asset.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
message = "Can't move assets with duplicate names";
return(false);
}
if (asset.Directory.Root.GetType() != Root.GetType())
{
message = "Incompatible folder";
return(false);
}
if (asset.Directory.Root is ProjectViewModel && Root != asset.Directory.Root)
{
message = "Can't move source files between projects";
return(false);
}
}
else
{
message = "Only folders can be dropped";
return(false);
}
}
return(true);
}
public IEnumerator GetEnumerator()
{
return(SubDirectories.GetEnumerator());
}
public void AddDirectories(IEnumerable <NameSpaceDirectory> directories)
{
SubDirectories.AddRange(directories);
}
