/// <summary>
/// Adds several rules to the filter
/// </summary>
/// <param name="Rules">List of patterns to match.</param>
/// <param name="Type">Whether the rules are include or exclude rules</param>
public void AddRules(IEnumerable <string> Rules, FileFilterType Type)
{
foreach (string Rule in Rules)
{
AddRule(Rule, Type);
}
}
/// <summary>
/// Default constructor
/// </summary>
public FileFilter(FileFilterType DefaultType = FileFilterType.Exclude)
{
RootNode = new FileFilterNode(null, "");
DefaultNode = new FileFilterNode(RootNode, "...");
DefaultNode.Type = DefaultType;
}
private void Init(FileFilterType filterType)
{
Gtk.FileFilter libs = new Gtk.FileFilter ();
Gtk.FileFilter all = new Gtk.FileFilter ();
switch (filterType) {
case FileFilterType.DFiles:
libs.AddPattern ("*.d");
libs.AddPattern ("*.di");
libs.Name = "D Files";
break;
case FileFilterType.LibraryFiles:
libs.AddPattern ("*.a");
libs.AddPattern ("*.lib");
libs.AddPattern ("*.so");
libs.AddPattern ("*.dylib");
libs.Name = "Libraries";
break;
}
all.AddPattern ("*.*");
all.Name = "All Files";
file_chooser_widget.AddFilter (libs);
file_chooser_widget.AddFilter (all);
if (Environment.OSVersion.Platform == PlatformID.Unix)
file_chooser_widget.SetCurrentFolder ("/usr/share/d/di");
}
/// <summary>
/// Default constructor.
/// </summary>
public FileFilterNode(FileFilterNode InParent, string InPattern)
{
Parent = InParent;
Pattern = InPattern;
RuleNumber = -1;
Type = FileFilterType.Exclude;
}
private void Init(FileFilterType filterType)
{
Gtk.FileFilter libs = new Gtk.FileFilter();
Gtk.FileFilter all = new Gtk.FileFilter();
switch (filterType)
{
case FileFilterType.DFiles:
libs.AddPattern("*.d");
libs.AddPattern("*.di");
libs.Name = "D Files";
break;
case FileFilterType.LibraryFiles:
libs.AddPattern("*.a");
libs.AddPattern("*.lib");
libs.AddPattern("*.so");
libs.AddPattern("*.dylib");
libs.Name = "Libraries";
break;
}
all.AddPattern("*.*");
all.Name = "All Files";
file_chooser_widget.AddFilter(libs);
file_chooser_widget.AddFilter(all);
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
file_chooser_widget.SetCurrentFolder("/usr/share/d/di");
}
}
/// <summary>
/// Default constructor
/// </summary>
public FileFilter(FileFilterType DefaultType = FileFilterType.Exclude)
{
RootNode = new FileFilterNode(null, "");
DefaultNode = new FileFilterNode(RootNode, "...");
DefaultNode.Type = DefaultType;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a filter specification for a single file type for SaveFileDialog or
/// OpenFileDialog.
/// </summary>
/// <param name="type">The type of files to include in the filter. Do not use any of the
/// enumeration values starting with "All" for a filter intended to be used in a
/// SaveFileDialog.</param>
/// <returns>A string suitable for setting the Filter property of a SaveFileDialog or
/// OpenFileDialog</returns>
/// ------------------------------------------------------------------------------------
public static string FileFilter(FileFilterType type)
{
string filter = String.Format("{0} ({1})|{1}",
GetResourceString("kstid" + type.ToString()),
s_fileFilterExtensions[type]);
return(FileUtils.FileDialogFilterCaseInsensitiveCombinations(filter));
}
public AddLibraryDialog(FileFilterType filterType)
{
this.Build();
Init(filterType);
}
public FileFilter(string name, FileFilterType type)
{
Name = name;
Type = type;
}
/// <summary>
/// Adds several rules to the filter
/// </summary>
/// <param name="Rules">List of patterns to match.</param>
/// <param name="Type">Whether the rules are include or exclude rules</param>
public void AddRules(IEnumerable<string> Rules, FileFilterType Type)
{
foreach(string Rule in Rules)
{
AddRule(Rule, Type);
}
}
static void UnzipAndAddRuleForHeaders(string ZipFileName, FileFilter Filter, FileFilterType Type)
{
IEnumerable<string> FileNames = CommandUtils.UnzipFiles(ZipFileName, CommandUtils.CmdEnv.LocalRoot);
Filter.AddRuleForFiles(FileNames, CommandUtils.CmdEnv.LocalRoot, FileFilterType.Include);
}
/// <summary>
/// Adds a rule which matches a filename relative to a given base directory.
/// </summary>
/// <param name="FileName">The filename to add a rule for</param>
/// <param name="BaseDirectoryName">Base directory for the rule</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFile(FileReference File, DirectoryReference BaseDirectory, FileFilterType Type)
{
AddRuleForFiles(new FileReference[] { File }, BaseDirectory, Type);
}
/// <summary>
/// Default constructor.
/// </summary>
public FileFilterNode(FileFilterNode InParent, string InPattern)
{
Parent = InParent;
Pattern = InPattern;
RuleNumber = -1;
Type = FileFilterType.Exclude;
}
/// <summary>
/// Adds an include or exclude rule to the filter
/// </summary>
/// <param name="Pattern">The pattern which the rule should match</param>
/// <param name="bInclude">Whether to include or exclude files matching this rule</param>
public void AddRule(string Pattern, FileFilterType Type)
{
string NormalizedPattern = Pattern.Replace('\\', '/');
// Remove the slash from the start of the pattern. Any exclude pattern that doesn't contain a directory separator is assumed to apply to any directory (eg. *.cpp), otherwise it's
// taken relative to the root.
if (NormalizedPattern.StartsWith("/"))
{
NormalizedPattern = NormalizedPattern.Substring(1);
}
else if(!NormalizedPattern.Contains("/") && !NormalizedPattern.StartsWith("..."))
{
NormalizedPattern = ".../" + NormalizedPattern;
}
// All directories indicate a wildcard match
if (NormalizedPattern.EndsWith("/"))
{
NormalizedPattern += "...";
}
// Replace any directory wildcards mid-string
for (int Idx = NormalizedPattern.IndexOf("..."); Idx != -1; Idx = NormalizedPattern.IndexOf("...", Idx))
{
if (Idx > 0 && NormalizedPattern[Idx - 1] != '/')
{
NormalizedPattern = NormalizedPattern.Insert(Idx, "*/");
Idx++;
}
Idx += 3;
if (Idx < NormalizedPattern.Length && NormalizedPattern[Idx] != '/')
{
NormalizedPattern = NormalizedPattern.Insert(Idx, "/*");
Idx += 2;
}
}
// Split the pattern into fragments
string[] BranchPatterns = NormalizedPattern.Split('/');
// Add it into the tree
FileFilterNode LastNode = RootNode;
foreach (string BranchPattern in BranchPatterns)
{
FileFilterNode NextNode = LastNode.Branches.FirstOrDefault(x => x.Pattern == BranchPattern);
if (NextNode == null)
{
NextNode = new FileFilterNode(LastNode, BranchPattern);
LastNode.Branches.Add(NextNode);
}
LastNode = NextNode;
}
// We've reached the end of the pattern, so mark it as a leaf node
Rules.Add(LastNode);
LastNode.RuleNumber = Rules.Count - 1;
LastNode.Type = Type;
// Update the maximums along that path
for (FileFilterNode UpdateNode = LastNode; UpdateNode != null; UpdateNode = UpdateNode.Parent)
{
if (Type == FileFilterType.Include)
{
UpdateNode.MaxIncludeRuleNumber = LastNode.RuleNumber;
}
else
{
UpdateNode.MaxExcludeRuleNumber = LastNode.RuleNumber;
}
}
}
/// <summary>
/// Adds rules for files which match the given names
/// </summary>
/// <param name="FileName">The filenames to rules for</param>
/// <param name="BaseDirectoryName">Base directory for the rules</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFiles(IEnumerable<FileReference> Files, DirectoryReference BaseDirectory, FileFilterType Type)
{
foreach (FileReference File in Files)
{
AddRule("/" + File.MakeRelativeTo(BaseDirectory), Type);
}
}
/// <summary>
/// Adds rules for files which match the given names
/// </summary>
/// <param name="FileName">The filenames to rules for</param>
/// <param name="BaseDirectoryName">Base directory for the rules</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFiles(IEnumerable<string> FileNames, string BaseDirectoryName, FileFilterType Type)
{
string FullBaseDirectoryName = Path.GetFullPath(BaseDirectoryName);
foreach (string FileName in FileNames)
{
AddRule("/" + CommandUtils.StripBaseDirectory(Path.GetFullPath(FileName), FullBaseDirectoryName), Type);
}
}
/// <summary>
/// Adds a rule which matches a filename relative to a given base directory.
/// </summary>
/// <param name="FileName">The filename to add a rule for</param>
/// <param name="BaseDirectoryName">Base directory for the rule</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFile(string FileName, string BaseDirectoryName, FileFilterType Type)
{
AddRuleForFiles(new string[]{ FileName }, BaseDirectoryName, Type);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a filter specification for a single file type for SaveFileDialog or
/// OpenFileDialog.
/// </summary>
/// <param name="type">The type of files to include in the filter. Do not use any of the
/// enumeration values starting with "All" for a filter intended to be used in a
/// SaveFileDialog.</param>
/// <returns>A string suitable for setting the Filter property of a SaveFileDialog or
/// OpenFileDialog</returns>
/// ------------------------------------------------------------------------------------
public static string FileFilter(FileFilterType type)
{
return String.Format("{0} ({1})|{1}",
GetResourceString("kstid" + type.ToString()),
m_fileFilterExtensions[type]);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a filter specification for a single file type for SaveFileDialog or
/// OpenFileDialog.
/// </summary>
/// <param name="type">The type of files to include in the filter. Do not use any of the
/// enumeration values starting with "All" for a filter intended to be used in a
/// SaveFileDialog.</param>
/// <returns>A string suitable for setting the Filter property of a SaveFileDialog or
/// OpenFileDialog</returns>
/// ------------------------------------------------------------------------------------
public static string FileFilter(FileFilterType type)
{
string filter = String.Format("{0} ({1})|{1}",
GetResourceString("kstid" + type.ToString()),
s_fileFilterExtensions[type]);
return FileUtils.FileDialogFilterCaseInsensitiveCombinations(filter);
}
/// <summary>
/// Adds rules for files which match the given names
/// </summary>
/// <param name="FileName">The filenames to rules for</param>
/// <param name="BaseDirectoryName">Base directory for the rules</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFiles(IEnumerable <FileReference> Files, DirectoryReference BaseDirectory, FileFilterType Type)
{
foreach (FileReference File in Files)
{
AddRule("/" + File.MakeRelativeTo(BaseDirectory), Type);
}
}
/// <summary>
/// Adds a rule which matches a filename relative to a given base directory.
/// </summary>
/// <param name="File">The filename to add a rule for</param>
/// <param name="BaseDirectory">Base directory for the rule</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFile(FileReference File, DirectoryReference BaseDirectory, FileFilterType Type)
{
AddRule("/" + File.MakeRelativeTo(BaseDirectory), Type);
}
static void AddRuleForBuildProducts(FileFilter Filter, GUBP bp, string NodeName, FileFilterType Type)
{
GUBP.GUBPNode Node = bp.FindNode(NodeName);
if(Node == null)
{
throw new AutomationException("Couldn't find node '{0}'", NodeName);
}
Filter.AddRuleForFiles(Node.BuildProducts, CommandUtils.CmdEnv.LocalRoot, Type);
}
/// <summary>
/// Adds an include or exclude rule to the filter
/// </summary>
/// <param name="Pattern">The pattern which the rule should match</param>
/// <param name="Type">Whether to include or exclude files matching this rule</param>
public void AddRule(string Pattern, FileFilterType Type)
{
string NormalizedPattern = Pattern.Replace('\\', '/');
// Remove the slash from the start of the pattern. Any exclude pattern that doesn't contain a directory separator is assumed to apply to any directory (eg. *.cpp), otherwise it's
// taken relative to the root.
if (NormalizedPattern.StartsWith("/"))
{
NormalizedPattern = NormalizedPattern.Substring(1);
}
else if (!NormalizedPattern.Contains("/") && !NormalizedPattern.StartsWith("..."))
{
NormalizedPattern = ".../" + NormalizedPattern;
}
// All directories indicate a wildcard match
if (NormalizedPattern.EndsWith("/"))
{
NormalizedPattern += "...";
}
// Replace any directory wildcards mid-string
for (int Idx = NormalizedPattern.IndexOf("..."); Idx != -1; Idx = NormalizedPattern.IndexOf("...", Idx))
{
if (Idx > 0 && NormalizedPattern[Idx - 1] != '/')
{
NormalizedPattern = NormalizedPattern.Insert(Idx, "*/");
Idx++;
}
Idx += 3;
if (Idx < NormalizedPattern.Length && NormalizedPattern[Idx] != '/')
{
NormalizedPattern = NormalizedPattern.Insert(Idx, "/*");
Idx += 2;
}
}
// Split the pattern into fragments
string[] BranchPatterns = NormalizedPattern.Split('/');
// Add it into the tree
FileFilterNode LastNode = RootNode;
foreach (string BranchPattern in BranchPatterns)
{
FileFilterNode NextNode = LastNode.Branches.FirstOrDefault(x => x.Pattern == BranchPattern);
if (NextNode == null)
{
NextNode = new FileFilterNode(LastNode, BranchPattern);
LastNode.Branches.Add(NextNode);
}
LastNode = NextNode;
}
// We've reached the end of the pattern, so mark it as a leaf node
Rules.Add(LastNode);
LastNode.RuleNumber = Rules.Count - 1;
LastNode.Type = Type;
// Update the maximums along that path
for (FileFilterNode UpdateNode = LastNode; UpdateNode != null; UpdateNode = UpdateNode.Parent)
{
if (Type == FileFilterType.Include)
{
UpdateNode.MaxIncludeRuleNumber = LastNode.RuleNumber;
}
else
{
UpdateNode.MaxExcludeRuleNumber = LastNode.RuleNumber;
}
}
}
/// <summary>
/// Adds a rule which matches a filename relative to a given base directory.
/// </summary>
/// <param name="FileName">The filename to add a rule for</param>
/// <param name="BaseDirectoryName">Base directory for the rule</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFile(string FileName, string BaseDirectoryName, FileFilterType Type)
{
AddRuleForFiles(new string[] { FileName }, BaseDirectoryName, Type);
}
private string GetFile(string currentFile, string pathForInitialDirectory,
FileFilterType[] types, bool checkFileExists, string title, Func<string, bool> isValidFile)
{
using (var openFileDialog = new OpenFileDialogAdapter())
{
openFileDialog.Filter = ResourceHelper.BuildFileFilter(types);
openFileDialog.CheckFileExists = checkFileExists;
openFileDialog.Multiselect = false;
bool done = false;
while (!done)
{
// LT-6620 : putting in an invalid path was causing an exception in the openFileDialog.ShowDialog()
// Now we make sure parts are valid before setting the values in the openfile dialog.
string dir = string.Empty;
try
{
dir = Path.GetDirectoryName(pathForInitialDirectory);
}
catch
{
}
if (Directory.Exists(dir))
openFileDialog.InitialDirectory = dir;
if (File.Exists(currentFile))
openFileDialog.FileName = currentFile;
else
openFileDialog.FileName = "";
openFileDialog.Title = title;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
if (!(isValidFile(openFileDialog.FileName)))
{
string msg = String.Format(ITextStrings.ksInvalidFileAreYouSure,
openFileDialog.FileName);
DialogResult dr = MessageBox.Show(this, msg,
ITextStrings.ksPossibleInvalidFile,
MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning);
if (dr == DialogResult.Yes)
return openFileDialog.FileName;
else if (dr == DialogResult.No)
continue;
else
break; // exit with current still
}
return openFileDialog.FileName;
}
else
done = true;
}
return currentFile;
}
}
/// <summary>
/// Adds rules for files which match the given names
/// </summary>
/// <param name="Files">The filenames to rules for</param>
/// <param name="BaseDirectory">Base directory for the rules</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFiles(IEnumerable <FileReference> Files, DirectoryReference BaseDirectory, FileFilterType Type)
{
foreach (FileReference File in Files)
{
AddRuleForFile(File, BaseDirectory, Type);
}
}
/// <summary>
/// Adds rules for files which match the given names
/// </summary>
/// <param name="FileName">The filenames to rules for</param>
/// <param name="BaseDirectoryName">Base directory for the rules</param>
/// <param name="Type">Whether to add an include or exclude rule</param>
public void AddRuleForFiles(IEnumerable <string> FileNames, string BaseDirectoryName, FileFilterType Type)
{
string FullBaseDirectoryName = Path.GetFullPath(BaseDirectoryName);
foreach (string FileName in FileNames)
{
AddRule("/" + CommandUtils.StripBaseDirectory(Path.GetFullPath(FileName), FullBaseDirectoryName), Type);
}
}
public AddLibraryDialog(FileFilterType filterType)
{
this.Build ();
Init (filterType);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Builds a filter specification for a single file type for SaveFileDialog or
/// OpenFileDialog.
/// </summary>
/// <param name="type">The type of files to include in the filter. Do not use any of the
/// enumeration values starting with "All" for a filter intended to be used in a
/// SaveFileDialog.</param>
/// <returns>A string suitable for setting the Filter property of a SaveFileDialog or
/// OpenFileDialog</returns>
/// ------------------------------------------------------------------------------------
public static string FileFilter(FileFilterType type)
{
return(String.Format("{0} ({1})|{1}",
GetResourceString("kstid" + type.ToString()),
m_fileFilterExtensions[type]));
}
