private string buildImageDestinationFilePath(ThreadParameters parameters, string sourcePath, System.Drawing.Image image) { if (parameters.DestinationRootDirectory.Length == 0 || parameters.DestinationSubDirectories.Length == 0 || parameters.FileNameComponent.Length == 0 || sourcePath.Length == 0) { return(null); } for (int i = 0; i < parameters.DestinationSubDirectories.Length && i < parameters.FileNameComponent.Length; i++) { string directoryPath = fillParameter(parameters.DestinationSubDirectories[i], sourcePath, image); if (directoryPath == null) { continue; } string fileName = fillParameter(parameters.FileNameComponent[i], sourcePath, image); if (fileName == null) { continue; } string destinationPath = normalizeDirectoryPath(parameters.DestinationRootDirectory) + normalizeDirectoryPath(directoryPath) + fileName + System.IO.Path.GetExtension(sourcePath); string destinationFileName = System.IO.Path.GetFileNameWithoutExtension(destinationPath); if (destinationFileName.EndsWith(CultureStrings.MarkerSemicolon) && parameters.FileNameComponent[i].IndexOf(CultureStrings.ComponentOriginalFileName) != -1) { string newDestinationFileName = destinationFileName.Remove(destinationFileName.LastIndexOf(CultureStrings.MarkerSemicolon)); destinationPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(destinationPath), newDestinationFileName + System.IO.Path.GetExtension(destinationPath)); } return(destinationPath); } return(null); }
private void backgroundWorker_Filter_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e) { backgroundWorker_Filter.RunWorkerCompleted -= backgroundWorker_Filter_RunWorkerCompleted; ThreadParameters parameters = e.Result as ThreadParameters; if (parameters.LogFilePath_ThreadResult != null && System.IO.File.Exists(parameters.LogFilePath_ThreadResult)) { richTextBox_SourcePaths.Clear(); richTextBox_LoadFile(ref richTextBox_SourcePaths, parameters.LogFilePath_ThreadResult); richTextBox_SourcePaths.AppendLine(parameters.LogFilePath_ThreadResult); } richTextBox_ExcludeFileExtensions.Lines = parameters.ExcludeFileExtensions; richTextBox_ImageFileExtensions.Lines = parameters.ImageFileExtensions; groupBox_SourcePaths.Text = CultureStrings.TextSourcePaths; button_FilterSourcePaths.Enabled = true; progressBar.Value = 100; if (checkBox_AutoStart.Checked || !button_Start.Enabled) { tabControl.SelectTab(tabPage_Copy); lock (copyFilesJobs) { copyFilesJobs.Push(getThreadParameters()); } button_Start_Click(null, e); } }
private void DeleteDirectoryWithoutException(string directoryPath,ThreadParameters parameters) { try { FileWriterWithAppendMode.GlobalWrite(CultureStrings.TryDeleting+" "+singleQuoteText(directoryPath)); string[]subDirectories=System.IO.Directory.GetDirectories(directoryPath); foreach(string subDirectory in subDirectories) { if(!parameters.SourceDirectories.Any(sourceDirectory=>sourceDirectory.StartsWith(subDirectory))) { DeleteDirectoryWithoutException(subDirectory,parameters); } } subDirectories=System.IO.Directory.GetDirectories(directoryPath); string[]files=System.IO.Directory.GetFiles(directoryPath); if(onlyOneThumbsDbFile(files)) { deleteFileWithoutException(files[0],parameters); } files=System.IO.Directory.GetFiles(directoryPath); if(subDirectories.Length==0&&files.Length==0) { System.IO.Directory.Delete(directoryPath); FileWriterWithAppendMode.GlobalWrite(CultureStrings.TextDeleted+" "+singleQuoteText(directoryPath)); } } catch(System.Exception ex) { FileWriterWithAppendMode.GlobalWrite(CultureStrings.TextFailedInDeleting+" "+singleQuoteText(directoryPath)); logException(ex); } }
private void backgroundWorker_Search_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e) { backgroundWorker_Search.RunWorkerCompleted -= backgroundWorker_Search_RunWorkerCompleted; ThreadParameters parameters = e.Result as ThreadParameters; if (parameters.LogFilePath_ThreadResult != null && System.IO.File.Exists(parameters.LogFilePath_ThreadResult)) { richTextBox_SourcePaths.Clear(); richTextBox_LoadFile(ref richTextBox_SourcePaths, parameters.LogFilePath_ThreadResult); richTextBox_SourcePaths.AppendLine(parameters.LogFilePath_ThreadResult); } groupBox_SourcePaths.Text = CultureStrings.TextSourcePaths; if (e.Cancelled) { richTextBox_SourceDirectories_TextChanged(sender, e); } else { previousSearchThreadParameters = parameters; if (isThreadParametersChanged(parameters, getThreadParameters())) { richTextBox_SourceDirectories_TextChanged(sender, e); } else if (!button_FilterSourcePaths.Enabled && !backgroundWorker_Filter.IsBusy) { backgroundWorker_Filter.RunWorkerCompleted += backgroundWorker_Filter_RunWorkerCompleted; backgroundWorker_Filter.RunWorkerAsync(getThreadParameters()); } } }
private ThreadParameters filterSourcePaths(ThreadParameters parameters) { System.Collections.Generic.List <string> sourcePaths = new System.Collections.Generic.List <string>(); if (parameters.LogFilePath_ThreadResult != null) { if (System.IO.File.Exists(parameters.LogFilePath_ThreadResult)) { sourcePaths = System.IO.File.ReadAllLines(parameters.LogFilePath_ThreadResult, System.Text.Encoding.Unicode).ToList(); } } if (sourcePaths.Count == 0) { return(parameters); } lock (copyFilesJobs) { parameters.LogFilePath_ThreadResult = buildCollectPhotoDataFilePath(parameters.DestinationRootDirectory, CultureStrings.ResultFileFilter); } FileWriterWithAppendMode logger = FileWriterWithAppendMode.Open(parameters.LogFilePath_ThreadResult); for (int i = 0; i < sourcePaths.Count; i++) { string filePath = sourcePaths[i]; if (backgroundWorker_Filter.IsBusy) { backgroundWorker_Filter.ReportProgress(calculatePercentage(sourcePaths.Count, i), filePath); } if (isMatchingFilePath(filePath, parameters.IncludeFileExtensions) || isMatchingFilePath(filePath, parameters.IncludeFileExtensionAndFileNameMap)) { logger.WriteLine(filePath); continue; } if (isMatchingFilePath(filePath, parameters.ExcludeFileExtensions) || isMatchingFilePath(filePath, parameters.IncludeFileExtensionAndFileNameMap.Keys.ToArray())) { continue; } if (isMatchingFilePath(filePath, parameters.ImageFileExtensions)) { logger.WriteLine(filePath); continue; } string extension = System.IO.Path.GetExtension(filePath); if (extension.Length == 0) { continue; } if (parameters.AutoDetermine && isImageFile(filePath)) { parameters.ImageFileExtensions = parameters.ImageFileExtensions.Concat(new string[] { extension }).ToArray(); logger.WriteLine(filePath); continue; } parameters.ExcludeFileExtensions = parameters.ExcludeFileExtensions.Concat(new string[] { extension }).ToArray(); } logger.Close(); return(parameters); }
private void backgroundWorker_Search_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { ThreadParameters parameters = e.Argument as ThreadParameters; if (previousSearchThreadParameters != null) { if (!isThreadParametersChanged(parameters, previousSearchThreadParameters)) { e.Result = previousSearchThreadParameters; return; } } e.Result = searchDirectories(parameters); }
private ThreadParameters[] splitCopyFilesJob(ThreadParameters threadParameters) { System.Collections.Generic.List <ThreadParameters> jobs = new System.Collections.Generic.List <ThreadParameters>(); foreach (string sourceDirectory in threadParameters.SourceDirectories) { ThreadParameters newJob = deepCopy(threadParameters); newJob.SourceDirectories = threadParameters.SourceDirectories.Where(directory => sourceDirectory == directory).ToArray(); if (threadParameters.CreateSubDestinationRootDirectory) { newJob.DestinationRootDirectory = string.Copy(newJob.DestinationRootDirectory); string subDestinationRootDirectory = sourceDirectory.Replace(System.IO.Path.AltDirectorySeparatorChar, '_').Replace(System.IO.Path.DirectorySeparatorChar, '_').Replace(System.IO.Path.VolumeSeparatorChar, '_'); newJob.DestinationRootDirectory = System.IO.Path.Combine(newJob.DestinationRootDirectory, subDestinationRootDirectory.Trim(new char[] { '_' })); } jobs.Add(newJob); } return(jobs.ToArray()); }
private ThreadParameters searchDirectories(ThreadParameters parameters) { try { lock (copyFilesJobs) { parameters.LogFilePath_ThreadResult = buildCollectPhotoDataFilePath(parameters.DestinationRootDirectory, CultureStrings.ResultFileSearch); } foreach (string directory in parameters.SourceDirectories) { getFiles(normalizeDirectoryPath(directory), "*", System.IO.SearchOption.AllDirectories, parameters.SearchDirectoryDeepnessLimitation > 0?parameters.SearchDirectoryDeepnessLimitation:int.MaxValue, parameters); } } catch (System.Exception cancellation) { logException(cancellation); } return(parameters); }
private void DeleteFileAndRelatedDirectoriesWithoutException(string filePath,ThreadParameters parameters) { try { deleteFileWithoutException(filePath,parameters); string directoryPath=System.IO.Path.GetDirectoryName(filePath); while(System.IO.Directory.GetFiles(directoryPath).Length<=1) { DeleteDirectoryWithoutException(directoryPath,parameters); directoryPath=System.IO.Path.GetDirectoryName(directoryPath); if(parameters.SourceDirectories.Any(sourceDirectory=>sourceDirectory.StartsWith(directoryPath))) { break; } } } catch(System.Exception ex) { logException(ex); } }
private void deleteFileWithoutException(string filePath,ThreadParameters parameters) { try { System.IO.FileInfo fileInfo=new System.IO.FileInfo(filePath); if(fileInfo.IsReadOnly&¶meters.DeleteReadOnly) { fileInfo.IsReadOnly=false; } if(fileInfo.Exists) { fileInfo.Delete(); } FileWriterWithAppendMode.GlobalWrite(CultureStrings.TextDeleted+" "+singleQuoteText(filePath)); } catch(System.Exception ex) { FileWriterWithAppendMode.GlobalWrite(CultureStrings.TextFailedInDeleting+" "+singleQuoteText(filePath)); logException(ex); } }
private void button_Start_Click(object sender, System.EventArgs e) { lock (copyFilesJobs) { button_Start.Enabled = false; ClearImageViewer(); if (sender is System.Windows.Forms.Button) { ThreadParameters threadParameters = getThreadParameters(); if (checkBox_MultipleJobs.Checked == true) { ThreadParameters[] jobs = splitCopyFilesJob(threadParameters); for (int i = jobs.Length - 1; i >= 0; i--) { copyFilesJobs.Push(jobs[i]); } } else { copyFilesJobs.Push(threadParameters); } } if (!backgroundWorker_Copy.IsBusy && copyFilesJobs.Count > 0) { richTextBox_CollectedSourcePaths.Clear(); richTextBox_CollectedDestinationPaths.Clear(); backgroundWorker_Copy.DoWork += backgroundWorker_Copy_DoWork; if (checkBox_MultipleJobs.Checked == true) { backgroundWorker_Copy.RunWorkerAsync(null); } else { backgroundWorker_Copy.RunWorkerAsync(copyFilesJobs.Pop()); } } } }
private void preCopyFile(ThreadParameters parameters,string sourcePath,ref string destinationPath,ref bool alreadyExists,ref bool isCopy) { isCopy=false; alreadyExists=false; string alreadyExistsDestinationPath=getDuplicateAutoRenamedFile(sourcePath,destinationPath); if(alreadyExistsDestinationPath!=null) { destinationPath=alreadyExistsDestinationPath; alreadyExists=true; } else if(isOneCopy(sourcePath,destinationPath)) { } else if(parameters.AutoRename) { destinationPath=getUnusedFilePath(destinationPath); isCopy=true; } else { isCopy=true; } }
private string buildUniqueDestinationFilePath(ThreadParameters parameters, string sourcePath) { MediaInfoLib.MediaInfo mediaInfo = new MediaInfoLib.MediaInfo(); string taggedDate = null; if (mediaInfo.Open(sourcePath) == 1) { taggedDate = mediaInfo.Get(MediaInfoLib.StreamKind.General, 0, CultureStrings.TextTaggedDate); } mediaInfo.Close(); string uniqueDestinationFilePath = null; if (taggedDate != null && taggedDate.Length > 0) { try { System.DateTime dateTime = parseTaggedDate(taggedDate); uniqueDestinationFilePath = normalizeDirectoryPath(parameters.DestinationRootDirectory) + normalizeDirectoryPath(System.IO.Path.GetExtension(sourcePath).ToUpper().Substring(1)) + normalizeDirectoryPath(dateTime.ToString("yyyy")) + normalizeDirectoryPath(dateTime.ToString("MMMM")) + getCollectPhotoOriginalFileName(sourcePath); } catch (System.Exception ex) { logException(ex); } } if (uniqueDestinationFilePath == null) { uniqueDestinationFilePath = normalizeDirectoryPath(parameters.DestinationRootDirectory) + normalizeDirectoryPath(System.IO.Path.GetExtension(sourcePath).ToUpper().Substring(1)) + getCollectPhotoOriginalFileName(sourcePath); } if (getDuplicateAutoRenamedFile(sourcePath, uniqueDestinationFilePath) != null) { return(getDuplicateAutoRenamedFile(sourcePath, uniqueDestinationFilePath)); } else { return(getUnusedFilePath(uniqueDestinationFilePath)); } }
private void getFiles(string directoryPath, string searchPattern, System.IO.SearchOption searchOption, int deepnessLimitation, ThreadParameters parameters) { FileWriterWithAppendMode.GlobalWrite(string.Format("getFiles, directory path: {0}, deepness limitation: {1}.", doubleQuoteText(directoryPath), deepnessLimitation)); string[] fileExtensions = parameters.FilterWhileSearching?parameters.ImageFileExtensions.Concat(parameters.IncludeFileExtensions).ToArray():null; string resultFilePath = parameters.LogFilePath_ThreadResult; if (backgroundWorker_Search.CancellationPending) { throw new System.Exception("Cancel getFiles!"); } if (backgroundWorker_Search.IsBusy) { backgroundWorker_Search.ReportProgress(0, directoryPath); } if (deepnessLimitation <= 0) { return; } string[] topDirectoryFiles = getFiles(directoryPath, searchPattern); if (topDirectoryFiles != null) { appendLines(resultFilePath, filterFilePaths(topDirectoryFiles, fileExtensions)); } if (searchOption == System.IO.SearchOption.AllDirectories) { string[] directories = getDirectories(directoryPath); if (directories != null) { foreach (string directory in directories) { if (isMatchingDirectoryPath(directory, parameters.BypassRegexes)) { continue; } getFiles(directory, searchPattern, searchOption, deepnessLimitation - 1, parameters); } } } }
private ThreadParameters executeCommands(ThreadParameters parameters) { System.Collections.Generic.List <string> sourcePaths = new System.Collections.Generic.List <string>(); if (parameters.SourcePaths != null) { sourcePaths.AddRange(parameters.SourcePaths); } if (parameters.LogFilePath_ThreadResult != null && System.IO.File.Exists(parameters.LogFilePath_ThreadResult)) { sourcePaths.AddRange(System.IO.File.ReadAllLines(parameters.LogFilePath_ThreadResult, System.Text.Encoding.Unicode)); } else if (parameters.SourceDirectories != null && parameters.SourceDirectories.Length > 0) { parameters = filterSourcePaths(searchDirectories(parameters)); sourcePaths.AddRange(System.IO.File.ReadAllLines(parameters.LogFilePath_ThreadResult, System.Text.Encoding.Unicode)); } lock (copyFilesJobs) { parameters.LogFilePath_ThreadResult = buildCollectPhotoDataFilePath(parameters.DestinationRootDirectory, CultureStrings.LogFileExecuteCommandsResult); } FileWriterWithAppendMode logger = FileWriterWithAppendMode.Open(parameters.LogFilePath_ThreadResult); string sourcePathTemplate = fillCommandParameter(fillCommandParameter(parameters.CommandOptions, CommandParameterKey_Command, parameters.Command, 0), CommandParameterKey_DestinationRootDirectory, parameters.DestinationRootDirectory, 0); string commandName = System.IO.Path.GetFileNameWithoutExtension(parameters.Command); if (sourcePathTemplate.IndexOf(commandName, System.StringComparison.InvariantCultureIgnoreCase) == -1) { sourcePathTemplate = doubleQuoteText(parameters.Command) + " " + sourcePathTemplate; } for (int i = 0; i < sourcePaths.Count; i++) { string command = fillCommandParameter(sourcePathTemplate, CommandParameterKey_SourcePath, sourcePaths[i], 0); command = fillCommandParameter(fillCommandParameter(command, fileSizeId, getFileSize(sourcePaths[i]).ToString(), 0), originalFileNameId, getCollectPhotoOriginalFileName(sourcePaths[i]), 0); if (backgroundWorker_ExecuteCommands.CancellationPending) { return(parameters); } else { logger.WriteLine(command); if (backgroundWorker_ExecuteCommands.IsBusy) { backgroundWorker_ExecuteCommands.ReportProgress(calculatePercentage(sourcePaths.Count, i), command); } try { System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo(command); info.CreateNoWindow = true; info.UseShellExecute = false; info.RedirectStandardOutput = true; info.RedirectStandardError = true; System.Diagnostics.Process process = new System.Diagnostics.Process(); process.StartInfo = info; process.Start(); string stdout = process.StandardOutput.ReadToEnd(); string stderr = process.StandardError.ReadToEnd(); backgroundWorker_ExecuteCommands.ReportProgress(calculatePercentage(sourcePaths.Count, i), stdout); backgroundWorker_ExecuteCommands.ReportProgress(calculatePercentage(sourcePaths.Count, i), stderr); logger.WriteLine(stdout); logger.WriteLine(stderr); } catch (System.Exception ex) { logException(ex); } } } logger.Close(); return(parameters); }
private ThreadParameters copyFiles(ThreadParameters parameters) { System.Collections.Generic.List <string> sourcePaths = new System.Collections.Generic.List <string>(); if (parameters.SourcePaths != null) { sourcePaths.AddRange(parameters.SourcePaths); } FileWriterWithAppendMode sourcePathLogger = null; FileWriterWithAppendMode deletedSourcePathLogger = null; FileWriterWithAppendMode destinationPathLogger = null; lock (copyFilesJobs) { sourcePathLogger = FileWriterWithAppendMode.Open(buildCollectPhotoLogFilePath(parameters.DestinationRootDirectory, CultureStrings.LogFileCopiedSourcePaths)); } lock (copyFilesJobs) { destinationPathLogger = FileWriterWithAppendMode.Open(buildCollectPhotoLogFilePath(parameters.DestinationRootDirectory, CultureStrings.LogFileCopiedDestinationPaths)); } lock (copyFilesJobs) { deletedSourcePathLogger = FileWriterWithAppendMode.Open(buildCollectPhotoLogFilePath(parameters.DestinationRootDirectory, CultureStrings.LogFileToBeDeletedSourcePaths)); } ThreadProgress threadProgress = new ThreadProgress(); resetThreadProgress(ref threadProgress, sourcePaths.Count, sourcePathLogger.FilePath, deletedSourcePathLogger.FilePath, destinationPathLogger.FilePath); if (parameters.LogFilePath_ThreadResult == null) { threadProgress.ProgressBarStyle = System.Windows.Forms.ProgressBarStyle.Marquee; backgroundWorker_Copy.ReportProgress(0, threadProgress); parameters = filterSourcePaths(searchDirectories(parameters)); } if (System.IO.File.Exists(parameters.LogFilePath_ThreadResult)) { sourcePaths.AddRange(System.IO.File.ReadAllLines(parameters.LogFilePath_ThreadResult, System.Text.Encoding.Unicode).ToList()); } threadProgress.CountTotal = sourcePaths.Count; threadProgress.ProgressBarStyle = System.Windows.Forms.ProgressBarStyle.Blocks; for (int i = 0; i < sourcePaths.Count; i++) { string sourcePath = sourcePaths[i]; string destinationPath = null; threadProgress.SourcePath = sourcePath; bool isCopy = false; bool isOverwriteCopy = false; bool alreadyExists = false; try { if (isMatchingFilePath(sourcePath, parameters.IncludeFileExtensions) || isMatchingFilePath(sourcePath, parameters.IncludeFileExtensionAndFileNameMap)) { destinationPath = buildImageDestinationFilePath(parameters, sourcePath, null); preCopyFile(parameters, sourcePath, ref destinationPath, ref alreadyExists, ref isCopy); } else if (isMatchingFilePath(sourcePath, parameters.ExcludeFileExtensions) || isMatchingFilePath(sourcePath, parameters.IncludeFileExtensionAndFileNameMap.Keys.ToArray())) { } else if (isImageFile(sourcePath)) { bool isLowGradeImage = false; using (System.Drawing.Image image = getImage(sourcePath)) { isLowGradeImage = !isImageLargerThanMinDimension(parameters.FileNameComponent, image); destinationPath = buildImageDestinationFilePath(parameters, sourcePath, image); } if (parameters.CopyLowGradeImage && (isLowGradeImage || destinationPath == null)) { destinationPath = buildUniqueDestinationFilePath(parameters, sourcePath); preCopyFile(parameters, sourcePath, ref destinationPath, ref alreadyExists, ref isCopy); } else if (destinationPath != null) { preCopyFile(parameters, sourcePath, ref destinationPath, ref alreadyExists, ref isCopy); if (!alreadyExists && isCopy && System.IO.File.Exists(destinationPath) && getFileSize(destinationPath) < getFileSize(sourcePath)) { isOverwriteCopy = true; } } } if (parameters.DeleteSourceIfDestinationAlreadyExists && alreadyExists && areTwoCopies(sourcePath, destinationPath)) { deletedSourcePathLogger.WriteLine(sourcePath); deletedSourcePathLogger.WriteLine(destinationPath); DeleteFileAndRelatedDirectoriesWithoutException(sourcePath, parameters); reportSkippedCopy(ref threadProgress, destinationPath, i); } else if (isCopy) { if (isOverwriteCopy) { overwriteFile(sourcePath, destinationPath); } else if (parameters.DeleteAfterCopy) { createDirectoryForFile(destinationPath); System.IO.File.Move(sourcePath, destinationPath); DeleteFileAndRelatedDirectoriesWithoutException(sourcePath, parameters); } else { copyFile(sourcePath, destinationPath); } sourcePathLogger.WriteLine(sourcePath); destinationPathLogger.WriteLine(destinationPath); reportSuccessCopy(ref threadProgress, destinationPath, i); } else { reportSkippedCopy(ref threadProgress, destinationPath, i); } } catch (System.Exception ex) { logException(ex); reportSkippedCopy(ref threadProgress, destinationPath, i); } sourcePathLogger.Flush(); destinationPathLogger.Flush(); deletedSourcePathLogger.Flush(); } sourcePathLogger.Close(); destinationPathLogger.Close(); deletedSourcePathLogger.Close(); FileWriterWithAppendMode.GlobalWrite(threadProgress.ToString()); return(parameters); }
private void backgroundWorker_ExecuteCommands_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { ThreadParameters parameters = e.Argument as ThreadParameters; e.Result = executeCommands(parameters); }
private bool isThreadParametersChanged(ThreadParameters p1, ThreadParameters p2) { return(GetConfigContent(p1) != GetConfigContent(p2)); }
private string GetConfigContent(ThreadParameters parameters) { return(("*** Source Directories ***\r\n" + convertStringsToText(parameters.SourceDirectories)) + ("\r\n*** Image File Extensions ***\r\n" + convertStringsToText(parameters.ImageFileExtensions)) + ("\r\n*** Exclude File Extensions ***\r\n" + convertStringsToText(parameters.ExcludeFileExtensions)) + ("\r\n*** Include File Extensions ***\r\n" + convertStringsToText(parameters.IncludeFileExtensions)) + ("\r\n*** Search Directories Bypass Patterns ***\r\n" + convertStringsToText(parameters.SearchDirectoriesBypassPatterns)) + ("\r\n*** Source Paths ***\r\n" + convertStringsToText(parameters.SourcePaths)) + ("\r\n*** Destination Root Directory ***\r\n" + parameters.DestinationRootDirectory) + ("\r\n*** Destination Sub Directories ***\r\n" + parameters.DestinationSubDirectories) + ("\r\n*** File Name Component ***\r\n" + parameters.FileNameComponent) + ("\r\n*** Search Directory Deepness Limitation ***\r\n" + parameters.SearchDirectoryDeepnessLimitation.ToString()) + ("\r\n*** Auto Start ***\r\n" + parameters.AutoStart.ToString()) + ("\r\n*** Auto Determine ***\r\n" + parameters.AutoDetermine.ToString()) + ("\r\n*** Filter While Searching ***\r\n" + parameters.FilterWhileSearching.ToString()) + ("\r\n*** Copy Low Grade Image ***\r\n" + parameters.CopyLowGradeImage.ToString()) + ("\r\n*** Delete After Copy ***\r\n" + parameters.DeleteAfterCopy.ToString()) + ("\r\n*** Delete Already Exists ***\r\n" + parameters.DeleteSourceIfDestinationAlreadyExists.ToString()) + ("\r\n*** Delete Read Only ***\r\n" + parameters.DeleteReadOnly.ToString()) + ("\r\n*** Auto Rename ***\r\n" + parameters.AutoRename.ToString()) + ("\r\n*** Multiple Jobs ***\r\n" + parameters.MultipleJobs.ToString()) + ("\r\n*** Create Sub Destination Root Directory ***\r\n" + parameters.CreateSubDestinationRootDirectory.ToString())); }
private ThreadParameters getThreadParameters() { ThreadParameters parameters = new ThreadParameters(); parameters.SourceDirectories = stripBlankLines(richTextBox_SourceDirectories.Lines); parameters.ImageFileExtensions = stripBlankLines(richTextBox_ImageFileExtensions.Lines); parameters.ExcludeFileExtensions = stripBlankLines(richTextBox_ExcludeFileExtensions.Lines); System.Collections.Generic.List <string> includeFileExtensions = new System.Collections.Generic.List <string>(); System.Collections.Generic.List <string> includeFileNameExtensions = new System.Collections.Generic.List <string>(); foreach (string line in richTextBox_IncludeFileExtensions.Lines) { if (line.Length > 0 && fileExtensionPattern.IsMatch(line)) { includeFileExtensions.Add(line); } else { includeFileNameExtensions.Add(line); } } parameters.IncludeFileExtensions = includeFileExtensions.ToArray(); parameters.IncludeFileExtensionAndFileNameMap = new System.Collections.Generic.Dictionary <string, System.Text.RegularExpressions.Regex>(); foreach (string includeFileName in includeFileNameExtensions) { string pattern = System.IO.Path.GetFileNameWithoutExtension(includeFileName); if (pattern == "*") { includeFileExtensions.Add(System.IO.Path.GetExtension(includeFileName)); parameters.IncludeFileExtensions = includeFileExtensions.ToArray(); continue; } else if (pattern.Length == 0) { continue; } if (!parameters.IncludeFileExtensionAndFileNameMap.ContainsKey(System.IO.Path.GetExtension(includeFileName))) { parameters.IncludeFileExtensionAndFileNameMap.Add(System.IO.Path.GetExtension(includeFileName), new System.Text.RegularExpressions.Regex(pattern)); } } parameters.SearchDirectoriesBypassPatterns = stripBlankLines(richTextBox_SearchDirectoriesBypassPatterns.Lines); System.Collections.Generic.List <System.Text.RegularExpressions.Regex> regexList = new System.Collections.Generic.List <System.Text.RegularExpressions.Regex>(); foreach (string bypassPattern in parameters.SearchDirectoriesBypassPatterns) { regexList.Add(new System.Text.RegularExpressions.Regex(bypassPattern)); } parameters.BypassRegexes = regexList.ToArray(); if (richTextBox_SourcePaths.Text.EndsWith(getCollectPhotoDataExtension())) { parameters.LogFilePath_ThreadResult = richTextBox_SourcePaths.Lines[richTextBox_SourcePaths.Lines.Length - 1]; } else { parameters.SourcePaths = richTextBox_SourcePaths.Lines; } parameters.DestinationRootDirectory = richTextBox_DestinationRootDirectory.Text; parameters.DestinationSubDirectories = stripBlankLines(richTextBox_DestinationSubDirectories.Lines); parameters.FileNameComponent = stripBlankLines(richTextBox_FileNameComponent.Lines); parameters.Command = richTextBox_Command.Text; parameters.CommandOptions = richTextBox_CommandOptions.Text; parameters.SearchDirectoryDeepnessLimitation = getSearchDirectoryDeepnessLimitation(); parameters.AutoStart = checkBox_AutoStart.Checked; parameters.AutoDetermine = checkBox_AutoDetermine.Checked; parameters.FilterWhileSearching = checkBox_FilterWhileSearching.Checked; parameters.CopyLowGradeImage = checkBox_CopyLowGradeImage.Checked; parameters.DeleteAfterCopy = checkBox_DeleteAfterCopy.Checked; parameters.DeleteSourceIfDestinationAlreadyExists = checkBox_DeleteAlreadyExists.Checked; parameters.DeleteReadOnly = checkBox_DeleteReadOnly.Checked; parameters.AutoRename = checkBox_AutoRename.Checked; parameters.MultipleJobs = checkBox_MultipleJobs.Checked; parameters.CreateSubDestinationRootDirectory = checkBox_CreateSubDestinationRootDirectory.Checked; try { FileWriterWithAppendMode logger = FileWriterWithAppendMode.Open(buildCollectPhotoLogFilePath(richTextBox_DestinationRootDirectory.Text, CultureStrings.TextTaskParameters)); string configContent = GetConfigContent(parameters); logger.Write(configContent); logger.Close(); } catch (System.Exception ex) { logException(ex); } return(parameters); }