/// <summary> /// Triggers TvFolderUpdateProgressChange event /// </summary> public static void OnUpdateProgressChange(ContentRootFolder sender, bool newContent, int percent, string msg) { if (UpdateProgressChange != null) { UpdateProgressChange(sender, new OrgProgressChangesEventArgs(newContent, percent, msg)); } }
/// <summary> /// Recursively builds list of sub-directories in content folder /// </summary> /// <param name="folder">Current folder</param> /// <param name="subFolders">List of sub-directories</param> /// <param name="clearMoviesFound">Enables clearing of found flag on movie in this folder</param> /// <param name="clearShowsFound">Enables clearing of found flag on shows in this folder</param> private void BuildSubDirectories(ContentRootFolder folder, List <OrgPath> subFolders, bool clearMoviesFound, bool clearShowsFound) { // Clear found flag for all movies if (clearMoviesFound) { for (int i = 0; i < Organization.Movies.Count; i++) { if (Organization.Movies[i].RootFolder == folder.FullPath) { Organization.Movies[i].Found = false; } } } // Clear found flag on all movies if (clearShowsFound) { for (int i = 0; i < Organization.Shows.Count; i++) { if (Organization.Shows[i].RootFolder == folder.FullPath) { Organization.Shows[i].Found = false; } } } // Get each subfolder from the content folder that isn't a sub-content folder if (Directory.Exists(folder.FullPath)) { string[] subFolderList = Directory.GetDirectories(folder.FullPath); foreach (string subFldr in subFolderList) { bool isSubContentFolder = false; foreach (ContentRootFolder subContent in folder.ChildFolders) { if (subFldr == subContent.FullPath) { isSubContentFolder = true; break; } } if (!isSubContentFolder) { subFolders.Add(new OrgPath(subFldr, false, true, folder, null)); } } // Recursively seach sub-content folders foreach (ContentRootFolder subContent in folder.ChildFolders) { subContent.BuildSubDirectories(subContent, subFolders, clearMoviesFound, clearShowsFound); } } }
/// <summary> /// Constructor for file from content folder (movie or tv) /// </summary> /// <param name="path">file's path</param> /// <param name="copy">whether file is allowed to be copied</param> /// <param name="allowDelete">whether file is allowed to be deleted</param> /// <param name="folder">content folder file belongs to</param> public OrgPath(string path, bool copy, bool allowDelete, ContentRootFolder folder, Content content) { this.Path = path; this.Copy = copy; this.AllowDelete = allowDelete; this.RootFolder = folder; this.Content = content; this.SimilarTo = -1; }
/// <summary> /// Recursively gets known files (files that are in a content folder) from a movie root folder and its children. /// </summary> /// <param name="folder">Root folders to look for files in</param> /// <param name="folderPath">Current folder path</param> /// <param name="files">List of files to add to</param> /// <param name="depth">Current depth from root folder</param> /// <param name="movie">Movie current path belongs to</param> private void GetKnownFiles(ContentRootFolder folder, string folderPath, List <OrgPath> files, int depth, Movie movie) { // Match to movie if (depth == 1) { foreach (Movie mov in Organization.Movies) { if (mov.Path == folderPath) { movie = mov; break; } } } // Only get files from folders that allow organization if (folder.AllowOrganizing) { // Get files only from non-content sub-folders if (depth > 0) { string[] fileList = Directory.GetFiles(folderPath); foreach (string file in fileList) { files.Add(new OrgPath(file, true, folder.AllowOrganizing, folder, movie)); } } // Recursion on sub folders string[] subDirs = Directory.GetDirectories(folderPath); foreach (string subDir in subDirs) { ContentRootFolder subDirContent = null; foreach (ContentRootFolder subfolder in folder.ChildFolders) { if (subfolder.FullPath == subDir) { subDirContent = subfolder; break; } } if (subDirContent != null) { GetKnownFiles(subDirContent, subDirContent.FullPath, files, 0, movie); } else { GetKnownFiles(folder, subDir, files, depth + 1, movie); } } } }
/// <summary> /// Set all sub directories to child root folders /// </summary> public void SetAllSubDirsAsChildren() { // Get sub-dirs string[] subDirs = System.IO.Directory.GetDirectories(this.FullPath); for (int i = 0; i < subDirs.Length; i++) { subDirs[i] = Path.GetFileName(subDirs[i]); } // Remove child folders that no longer exists for (int i = this.ChildFolders.Count - 1; i >= 0; i--) { bool exists = false; foreach (string subDir in subDirs) { if (System.IO.Path.Combine(this.FullPath, subDir) == this.ChildFolders[i].fullPath) { exists = true; break; } } if (!exists) { this.ChildFolders.RemoveAt(i); } } // Add all sub-dirs as children foreach (string subDir in subDirs) { string newPath = System.IO.Path.Combine(this.FullPath, subDir); bool exists = false; foreach (ContentRootFolder child in this.ChildFolders) { if (child.FullPath == newPath) { exists = true; break; } } if (!exists) { ContentRootFolder newChild = new ContentRootFolder(this.ContentType, subDir, newPath); this.ChildFolders.Add(newChild); } } }
/// <summary> /// Constructor for cloning instance /// </summary> /// <param name="folder">instance to clone</param> public ContentRootFolder(ContentRootFolder folder) : this(folder.ContentType) { this.SubPath = folder.SubPath; this.FullPath = folder.FullPath; this.AllowOrganizing = folder.AllowOrganizing; this.Default = folder.Default; this.ChildFolders.Clear(); foreach (ContentRootFolder subFolder in folder.ChildFolders) this.ChildFolders.Add(new ContentRootFolder(subFolder)); this.Id = folder.Id; this.Temporary = folder.Temporary; this.AllSubFoldersChildRootFolder = folder.AllSubFoldersChildRootFolder; }
/// <summary> /// Get content folder object from path string. /// </summary> /// <param name="folderPath">Path of content folder</param> /// <param name="folder">Resulting content folder matching path</param> /// <returns>True if folder was found</returns> public static bool GetContentFolderFromPath(string folderPath, out ContentRootFolder folder) { if (GetMovieFolderFromPath(folderPath, out folder)) { return(true); } if (GetTvFolderFromPath(folderPath, out folder)) { return(true); } folder = new ContentRootFolder(ContentType.TvShow); return(false); }
/// <summary> /// Constructor for cloning instance /// </summary> /// <param name="folder">instance to clone</param> public ContentRootFolder(ContentRootFolder folder) : this(folder.ContentType) { this.SubPath = folder.SubPath; this.FullPath = folder.FullPath; this.AllowOrganizing = folder.AllowOrganizing; this.Default = folder.Default; this.ChildFolders.Clear(); foreach (ContentRootFolder subFolder in folder.ChildFolders) { this.ChildFolders.Add(new ContentRootFolder(subFolder)); } this.Id = folder.Id; this.Temporary = folder.Temporary; this.AllSubFoldersChildRootFolder = folder.AllSubFoldersChildRootFolder; }
/// <summary> /// Recursively gets unknown files (files that are not in a content folder) from a movie root folder and its children. /// </summary> /// <param name="folder">Root folders to look for files in</param> /// <param name="files">List of files found to add to</param> private void GetUnknownFiles(ContentRootFolder folder, List <OrgPath> files) { // Only get files from folders that allow organization if (folder.AllowOrganizing) { string[] fileList = Directory.GetFiles(folder.FullPath); foreach (string file in fileList) { files.Add(new OrgPath(file, true, folder.AllowOrganizing, folder, null)); } } // Recursion on sub-content folders foreach (ContentRootFolder subfolder in folder.ChildFolders) { GetUnknownFiles(subfolder, files); } }
/// <summary> /// Recursively gets known files (files that are in a content folder) from a movie root folder and its children. /// </summary> /// <param name="folder">Root folders to look for files in</param> /// <param name="folderPath">Current folder path</param> /// <param name="files">List of files to add to</param> /// <param name="depth">Current depth from root folder</param> /// <param name="movie">Movie current path belongs to</param> private void GetKnownFiles(ContentRootFolder folder, string folderPath, List<OrgPath> files, int depth, Movie movie) { // Match to movie if (depth == 1) { foreach (Movie mov in Organization.Movies) if (mov.Path == folderPath) { movie = mov; break; } } // Only get files from folders that allow organization if (folder.AllowOrganizing) { // Get files only from non-content sub-folders if (depth > 0) { string[] fileList = Directory.GetFiles(folderPath); foreach (string file in fileList) files.Add(new OrgPath(file, true, folder.AllowOrganizing, folder, movie)); } // Recursion on sub folders string[] subDirs = Directory.GetDirectories(folderPath); foreach (string subDir in subDirs) { ContentRootFolder subDirContent = null; foreach (ContentRootFolder subfolder in folder.ChildFolders) if (subfolder.FullPath == subDir) { subDirContent = subfolder; break; } if (subDirContent != null) GetKnownFiles(subDirContent, subDirContent.FullPath, files, 0, movie); else GetKnownFiles(folder, subDir, files, depth + 1, movie); } } }
/// <summary> /// Get root folder that matches path string, recursive search /// </summary> /// <param name="path">Path to match to</param> /// <param name="baseFolder">Current root folder being searches</param> /// <param name="matchedFolder">Resulting matched root folder</param> /// <returns>Whether match was found</returns> public static bool GetMatchingRootFolder(string path, ContentRootFolder baseFolder, out ContentRootFolder matchedFolder) { if (path == baseFolder.FullPath) { matchedFolder = baseFolder; return(true); } else { foreach (ContentRootFolder child in baseFolder.ChildFolders) { if (GetMatchingRootFolder(path, child, out matchedFolder)) { return(true); } } } matchedFolder = null; return(false); }
/// <summary> /// Gets Tv folder that matches path /// </summary> /// <param name="path">The path of folder to match to</param> /// <returns>whether folder was found</returns> public static bool GetTvFolderFromPath(string path, out ContentRootFolder folder) { return TvFolders.GetFolderFromPath(path, out folder); }
/// <summary> /// Recursively builds list of sub-directories in content folder /// </summary> /// <param name="folder">Current folder</param> /// <param name="subFolders">List of sub-directories</param> /// <param name="clearMoviesFound">Enables clearing of found flag on movie in this folder</param> /// <param name="clearShowsFound">Enables clearing of found flag on shows in this folder</param> private void BuildSubDirectories(ContentRootFolder folder, List<OrgPath> subFolders, bool clearMoviesFound, bool clearShowsFound) { // Clear found flag for all movies if (clearMoviesFound) { for (int i = 0; i < Organization.Movies.Count; i++) if (Organization.Movies[i].RootFolder == folder.FullPath) Organization.Movies[i].Found = false; } // Clear found flag on all movies if (clearShowsFound) { for (int i = 0; i < Organization.Shows.Count; i++) if (Organization.Shows[i].RootFolder == folder.FullPath) Organization.Shows[i].Found = false; } // Get each subfolder from the content folder that isn't a sub-content folder if (Directory.Exists(folder.FullPath)) { string[] subFolderList = Directory.GetDirectories(folder.FullPath); foreach (string subFldr in subFolderList) { bool isSubContentFolder = false; foreach (ContentRootFolder subContent in folder.ChildFolders) { if (subFldr == subContent.FullPath) { isSubContentFolder = true; break; } } if (!isSubContentFolder) subFolders.Add(new OrgPath(subFldr, false, true, folder, null)); } // Recursively seach sub-content folders foreach (ContentRootFolder subContent in folder.ChildFolders) subContent.BuildSubDirectories(subContent, subFolders, clearMoviesFound, clearShowsFound); } }
/// <summary> /// Set all sub directories to child root folders /// </summary> public void SetAllSubDirsAsChildren() { // Get sub-dirs string[] subDirs = System.IO.Directory.GetDirectories(this.FullPath); for (int i = 0; i < subDirs.Length; i++) subDirs[i] = Path.GetFileName(subDirs[i]); // Remove child folders that no longer exists for (int i = this.ChildFolders.Count - 1; i >= 0; i--) { bool exists = false; foreach (string subDir in subDirs) if (System.IO.Path.Combine(this.FullPath, subDir) == this.ChildFolders[i].fullPath) { exists = true; break; } if (!exists) this.ChildFolders.RemoveAt(i); } // Add all sub-dirs as children foreach (string subDir in subDirs) { string newPath = System.IO.Path.Combine(this.FullPath, subDir); bool exists = false; foreach(ContentRootFolder child in this.ChildFolders) if(child.FullPath == newPath) { exists = true; break; } if(!exists) { ContentRootFolder newChild = new ContentRootFolder(this.ContentType, subDir, newPath); this.ChildFolders.Add(newChild); } } }
/// <summary> /// Loads properties from XML elements /// </summary> /// <param name="showNode">The XML node containt property elements</param> /// <returns>Whether XML was loaded properly</returns> public bool Load(XmlNode foldersNode) { // Check that we're on the right node if (foldersNode.Name != ROOT_XML) return false; // Go through elements of node foreach (XmlNode propNode in foldersNode.ChildNodes) { // Match the current node to a known element name XmlElements element; if (!Enum.TryParse<XmlElements>(propNode.Name, out element)) continue; // Set appropiate property from value in element string value = propNode.InnerText; switch (element) { case XmlElements.SubPath: this.SubPath = value; break; case XmlElements.FullPath: this.FullPath = value; break; case XmlElements.AllowOrganizing: bool allowOrg; if (bool.TryParse(value, out allowOrg)) this.AllowOrganizing = allowOrg; break; case XmlElements.Default: bool def; if (bool.TryParse(value, out def)) this.Default = def; break; case XmlElements.ChildFolders: this.ChildFolders = new ObservableCollection<ContentRootFolder>(); foreach (XmlNode subContentNode in propNode.ChildNodes) { ContentRootFolder subFolder = new ContentRootFolder(this.ContentType); subFolder.Load(subContentNode); this.ChildFolders.Add(subFolder); } break; case XmlElements.Temporary: bool temp; if (bool.TryParse(value, out temp)) this.Temporary = temp; break; case XmlElements.AllSubFoldersChildRootFolder: bool allSubsChild; if (bool.TryParse(value, out allSubsChild)) this.AllSubFoldersChildRootFolder = allSubsChild; break; } } return true; }
/// <summary> /// Triggers TvFolderUpdateProgressChange event /// </summary> public static void OnUpdateProgressComplete(ContentRootFolder sender) { UpdateProgressComplete?.Invoke(sender, new EventArgs()); }
/// <summary> /// Gets movie folder that matches path /// </summary> /// <param name="path">The path of folder to match to</param> /// <returns>whether folder was found</returns> public static bool GetMovieFolderFromPath(string path, out ContentRootFolder folder) { return(MovieFolders.GetFolderFromPath(path, out folder)); }
/// <summary> /// Get content folder object from path string. /// </summary> /// <param name="folderPath">Path of content folder</param> /// <param name="folder">Resulting content folder matching path</param> /// <returns>True if folder was found</returns> public static bool GetContentFolderFromPath(string folderPath, out ContentRootFolder folder) { if (GetMovieFolderFromPath(folderPath, out folder)) return true; if (GetTvFolderFromPath(folderPath, out folder)) return true; folder = new ContentRootFolder(ContentType.TvShow); return false; }
/// <summary> /// Loads settings from XML. /// </summary> public static void Load() { string basePath = Organization.GetBasePath(false); if (!Directory.Exists(basePath)) { return; } // Initialize file types to defautls VideoFileTypes = new ObservableCollection <string>(); foreach (string type in DefaultVideoFileTypes) { VideoFileTypes.Add(type); } DeleteFileTypes = new ObservableCollection <string>(); foreach (string type in DefaultDeleteFileTypes) { DeleteFileTypes.Add(type); } IgnoreFileTypes = new ObservableCollection <string>(); foreach (string type in DefaultIgnoreFileTypes) { IgnoreFileTypes.Add(type); } // Load settings XML string path = Path.Combine(basePath, ROOT_XML + ".xml"); if (File.Exists(path)) { // Load XML XmlTextReader reader = new XmlTextReader(path); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(reader); foreach (XmlNode propNode in xmlDoc.DocumentElement.ChildNodes) { XmlElements element; if (!Enum.TryParse <XmlElements>(propNode.Name, out element)) { continue; } string value = propNode.InnerText; switch (element) { case XmlElements.ScanDirectories: ScanDirectories = new ObservableCollection <OrgFolder>(); foreach (XmlNode scanDirNode in propNode.ChildNodes) { OrgFolder folder = new OrgFolder(); folder.Load(scanDirNode); ScanDirectories.Add(folder); } break; case XmlElements.TvFileFormat: TvFileFormat.Load(propNode); break; case XmlElements.MovieFileFormat: MovieFileFormat.Load(propNode); break; case XmlElements.MovieFolderColletion: MovieFolders.Load(propNode); break; case XmlElements.TvFolderCollection: TvFolders.Load(propNode); break; case XmlElements.VideoFileTypes: VideoFileTypes = new ObservableCollection <string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string videoType = fileTypeNode.InnerText; if (videoType.StartsWith(".")) { videoType = videoType.Substring(1, videoType.Length - 1); } VideoFileTypes.Add(videoType); } break; case XmlElements.DeleteFileTypes: DeleteFileTypes = new ObservableCollection <string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string delType = fileTypeNode.InnerText; if (delType.StartsWith(".")) { delType = delType.Substring(1, delType.Length - 1); } DeleteFileTypes.Add(delType); } break; case XmlElements.IgnoreFileTypes: IgnoreFileTypes = new ObservableCollection <string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string ignoreType = fileTypeNode.InnerText; if (ignoreType.StartsWith(".")) { ignoreType = ignoreType.Substring(1, ignoreType.Length - 1); } IgnoreFileTypes.Add(ignoreType); } break; case XmlElements.AutoMoveSetups: AutoMoveSetups = new ObservableCollection <AutoMoveFileSetup>(); foreach (XmlNode setupNode in propNode.ChildNodes) { AutoMoveFileSetup setup = new AutoMoveFileSetup(); setup.Load(setupNode); AutoMoveSetups.Add(setup); } break; case XmlElements.Gui: GuiControl.Load(propNode); break; case XmlElements.General: General.Load(propNode); break; case XmlElements.MovieFolders: MovieFolders.Clear(); foreach (XmlNode movieFolderNode in propNode.ChildNodes) { ContentRootFolder folder = new ContentRootFolder(ContentType.Movie); folder.Load(movieFolderNode); MovieFolders.Add(folder); } break; case XmlElements.TvFolders: TvFolders.Clear(); foreach (XmlNode tvFolderNode in propNode.ChildNodes) { ContentRootFolder folder = new ContentRootFolder(ContentType.TvShow); folder.Load(tvFolderNode); TvFolders.Add(folder); } break; } } } OnSettingsModified(true); }
/// <summary> /// Recursively gets unknown files (files that are not in a content folder) from a movie root folder and its children. /// </summary> /// <param name="folder">Root folders to look for files in</param> /// <param name="files">List of files found to add to</param> private void GetUnknownFiles(ContentRootFolder folder, List<OrgPath> files) { // Only get files from folders that allow organization if (folder.AllowOrganizing) { string[] fileList = Directory.GetFiles(folder.FullPath); foreach (string file in fileList) files.Add(new OrgPath(file, true, folder.AllowOrganizing, folder, null)); } // Recursion on sub-content folders foreach (ContentRootFolder subfolder in folder.ChildFolders) GetUnknownFiles(subfolder, files); }
/// <summary> /// Clear default flag on all folders except for one (the new default). /// </summary> /// <param name="exception">Folder to allow default flag to be on.</param> /// <param name="folders">List of content folders to clear default on</param> private void ClearDefault(ContentRootFolder exception, ObservableCollection<ContentRootFolder> folders) { // Go thorough all content folders in list foreach (ContentRootFolder folder in folders) { // Clear default flag if not exception if (folder != exception) folder.Default = false; // Recursion of sub-content folders if (folder.ChildFolders.Count > 0) ClearDefault(exception, folder.ChildFolders); } }
/// <summary> /// Recursive search to remove folder /// </summary> /// <param name="selFolder">Folder to remove</param> /// <param name="folders">List of folders to look for folder to remove in</param> /// <returns>True if folder was removed</returns> private bool RemoveFolder(ContentRootFolder selFolder, ObservableCollection<ContentRootFolder> folders) { // Loop through folders if (folders.Contains(selFolder)) { folders.Remove(selFolder); return true; } for (int i = 0; i < folders.Count; i++) { // Check sub-folders if (RemoveFolder(selFolder, folders[i].ChildFolders)) return true; } // Folder not removed yet return false; }
/// <summary> /// Add item to root folder combo box /// </summary> /// <param name="rootFolder"></param> private void AddRootFolderFilterItems(ContentRootFolder rootFolder) { this.FolderFilters.Add("Non-recursive: " + rootFolder.FullPath); foreach (ContentRootFolder child in rootFolder.ChildFolders) AddRootFolderFilterItems(child); }
private void AddChild() { if (this.SelectedRootFolder != null) { // Get list of sub-directories in content folder string[] subDirs = this.SelectedRootFolder.GetFolderSubDirectoryNamesThatArentChildren().ToArray(); // open selection form to allow user to chose a sub-folder SelectionWindow selForm = new SelectionWindow("Select Folder", subDirs); selForm.ShowDialog(); // If selection is valid set sub-folder as sub-content folder if (!string.IsNullOrEmpty(selForm.Results)) { ContentRootFolder newChild = new ContentRootFolder(this.ContentType, selForm.Results, System.IO.Path.Combine(this.SelectedRootFolder.FullPath, selForm.Results)); newChild.PropertyChanged += cloneFolder_PropertyChanged; this.SelectedRootFolder.ChildFolders.Add(newChild); } UpdateAvailableFolders(); } }
private void AddFolder() { // Open folder browser VistaFolderBrowserDialog folderSel = new VistaFolderBrowserDialog(); // Add folder if valid folder selected if (folderSel.ShowDialog() == true && System.IO.Directory.Exists(folderSel.SelectedPath)) { ContentRootFolder folder = new ContentRootFolder(this.ContentType, folderSel.SelectedPath, folderSel.SelectedPath); if (RootFolders.Count == 0) folder.Default = true; folder.PropertyChanged += cloneFolder_PropertyChanged; RootFolders.Add(folder); UpdateAvailableFolders(); } }
/// <summary> /// Triggers TvFolderUpdateProgressChange event /// </summary> public static void OnUpdateProgressChange(ContentRootFolder sender, bool newContent, int percent, string msg) { if (UpdateProgressChange != null) UpdateProgressChange(sender, new OrgProgressChangesEventArgs(newContent, percent, msg)); }
/// <summary> /// Gets TV folder that is set as default /// </summary> /// <returns></returns> public static bool GetTvFolderForContent(Content content, out ContentRootFolder rootFolder) { rootFolder = TvFolders.GetFolderForContent(content); return rootFolder != null; }
/// <summary> /// Gets TV folder that is set as default /// </summary> /// <returns></returns> public static bool GetTvFolderForContent(Content content, out ContentRootFolder rootFolder) { rootFolder = TvFolders.GetFolderForContent(content); return(rootFolder != null); }
/// <summary> /// Loads settings from XML. /// </summary> public static void Load() { string basePath = Organization.GetBasePath(false); if (!Directory.Exists(basePath)) return; // Initialize file types to defautls VideoFileTypes = new ObservableCollection<string>(); foreach (string type in DefaultVideoFileTypes) VideoFileTypes.Add(type); DeleteFileTypes = new ObservableCollection<string>(); foreach (string type in DefaultDeleteFileTypes) DeleteFileTypes.Add(type); IgnoreFileTypes = new ObservableCollection<string>(); foreach (string type in DefaultIgnoreFileTypes) IgnoreFileTypes.Add(type); // Load settings XML string path = Path.Combine(basePath, ROOT_XML + ".xml"); if (File.Exists(path)) { // Load XML XmlTextReader reader = new XmlTextReader(path); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(reader); foreach (XmlNode propNode in xmlDoc.DocumentElement.ChildNodes) { XmlElements element; if (!Enum.TryParse<XmlElements>(propNode.Name, out element)) continue; string value = propNode.InnerText; switch (element) { case XmlElements.ScanDirectories: ScanDirectories = new ObservableCollection<OrgFolder>(); foreach (XmlNode scanDirNode in propNode.ChildNodes) { OrgFolder folder = new OrgFolder(); folder.Load(scanDirNode); ScanDirectories.Add(folder); } break; case XmlElements.TvFileFormat: TvFileFormat.Load(propNode); break; case XmlElements.MovieFileFormat: MovieFileFormat.Load(propNode); break; case XmlElements.MovieFolderColletion: MovieFolders.Load(propNode); break; case XmlElements.TvFolderCollection: TvFolders.Load(propNode); break; case XmlElements.VideoFileTypes: VideoFileTypes = new ObservableCollection<string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string videoType = fileTypeNode.InnerText; if (videoType.StartsWith(".")) videoType = videoType.Substring(1, videoType.Length - 1); VideoFileTypes.Add(videoType); } break; case XmlElements.DeleteFileTypes: DeleteFileTypes = new ObservableCollection<string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string delType = fileTypeNode.InnerText; if (delType.StartsWith(".")) delType = delType.Substring(1, delType.Length - 1); DeleteFileTypes.Add(delType); } break; case XmlElements.IgnoreFileTypes: IgnoreFileTypes = new ObservableCollection<string>(); foreach (XmlNode fileTypeNode in propNode.ChildNodes) { string ignoreType = fileTypeNode.InnerText; if (ignoreType.StartsWith(".")) ignoreType = ignoreType.Substring(1, ignoreType.Length - 1); IgnoreFileTypes.Add(ignoreType); } break; case XmlElements.AutoMoveSetups: AutoMoveSetups = new ObservableCollection<AutoMoveFileSetup>(); foreach (XmlNode setupNode in propNode.ChildNodes) { AutoMoveFileSetup setup = new AutoMoveFileSetup(); setup.Load(setupNode); AutoMoveSetups.Add(setup); } break; case XmlElements.Gui: GuiControl.Load(propNode); break; case XmlElements.General: General.Load(propNode); break; case XmlElements.MovieFolders: MovieFolders.Clear(); foreach (XmlNode movieFolderNode in propNode.ChildNodes) { ContentRootFolder folder = new ContentRootFolder(ContentType.Movie); folder.Load(movieFolderNode); MovieFolders.Add(folder); } break; case XmlElements.TvFolders: TvFolders.Clear(); foreach (XmlNode tvFolderNode in propNode.ChildNodes) { ContentRootFolder folder = new ContentRootFolder(ContentType.TvShow); folder.Load(tvFolderNode); TvFolders.Add(folder); } break; } } } OnSettingsModified(true); }
/// <summary> /// Loads properties from XML elements /// </summary> /// <param name="showNode">The XML node containt property elements</param> /// <returns>Whether XML was loaded properly</returns> public bool Load(XmlNode foldersNode) { // Check that we're on the right node if (foldersNode.Name != ROOT_XML) { return(false); } // Go through elements of node foreach (XmlNode propNode in foldersNode.ChildNodes) { // Match the current node to a known element name XmlElements element; if (!Enum.TryParse <XmlElements>(propNode.Name, out element)) { continue; } // Set appropiate property from value in element string value = propNode.InnerText; switch (element) { case XmlElements.SubPath: this.SubPath = value; break; case XmlElements.FullPath: this.FullPath = value; break; case XmlElements.AllowOrganizing: bool allowOrg; if (bool.TryParse(value, out allowOrg)) { this.AllowOrganizing = allowOrg; } break; case XmlElements.Default: bool def; if (bool.TryParse(value, out def)) { this.Default = def; } break; case XmlElements.ChildFolders: this.ChildFolders = new ObservableCollection <ContentRootFolder>(); foreach (XmlNode subContentNode in propNode.ChildNodes) { ContentRootFolder subFolder = new ContentRootFolder(this.ContentType); subFolder.Load(subContentNode); this.ChildFolders.Add(subFolder); } break; case XmlElements.Temporary: bool temp; if (bool.TryParse(value, out temp)) { this.Temporary = temp; } break; case XmlElements.AllSubFoldersChildRootFolder: bool allSubsChild; if (bool.TryParse(value, out allSubsChild)) { this.AllSubFoldersChildRootFolder = allSubsChild; } break; } } return(true); }
/// <summary> /// Get root folder that matches path string, recursive search /// </summary> /// <param name="path">Path to match to</param> /// <param name="baseFolder">Current root folder being searches</param> /// <param name="matchedFolder">Resulting matched root folder</param> /// <returns>Whether match was found</returns> public static bool GetMatchingRootFolder(string path, ContentRootFolder baseFolder, out ContentRootFolder matchedFolder) { if (path == baseFolder.FullPath) { matchedFolder = baseFolder; return true; } else foreach (ContentRootFolder child in baseFolder.ChildFolders) { if (GetMatchingRootFolder(path, child, out matchedFolder)) return true; } matchedFolder = null; return false; }
private void UpdateMovieFolderItem(ContentRootFolder folder) { MenuItem item = new MenuItem(); item.Header = folder.FullPath; item.Command = new RelayCommand(param => this.SetMovieFolder(folder.FullPath)); this.MovieFolderItems.Add(item); foreach (ContentRootFolder subFolder in folder.ChildFolders) UpdateMovieFolderItem(subFolder); }