public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            string name = value as string;

            if (name != null)
            {
                if (name.IndexOfAny(new char[] { '*', '?' }) >= 0)
                {
                    TokenizerExpandCollection <FileInfo> fsi = new TokenizerExpandCollection <FileInfo>();
                    List <string> items = new List <string>();
                    items.Add(name);

                    FileExpandArgs args = new FileExpandArgs();
                    args.FileExpandMode         = FileExpandMode.DirectoryWildCards;
                    args.RemoveNonExistingFiles = true;
                    if (Tokenizer.TryExpandFileList(items, args))
                    {
                        foreach (string file in items)
                        {
                            fsi.Add(new FileInfo(file));
                        }
                    }

                    return(fsi);
                }
                else
                {
                    return(new FileInfo(name));
                }
            }

            return(base.ConvertFrom(context, culture, value));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Tries the expand file list.
        /// </summary>
        /// <param name="fileList">The file list.</param>
        /// <param name="args">The args.</param>
        /// <returns></returns>
        public static bool TryExpandFileList(IList <string> fileList, FileExpandArgs args)
        {
            if (fileList == null)
            {
                throw new ArgumentNullException("fileList");
            }
            else if (args == null)
            {
                throw new ArgumentNullException("args");
            }

            for (int i = 0; i < fileList.Count; i++)
            {
                string word = fileList[i];

                int firstMask = word.IndexOfAny(new char[] { '*', '?' });
                if (firstMask >= 0)
                {
                    word = word.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);

                    DirectoryInfo rootDir;
                    string        rest      = null;
                    int           lastSlash = word.LastIndexOf(Path.DirectorySeparatorChar, firstMask);
                    if (lastSlash < 0)
                    {
                        rootDir = new DirectoryInfo(args.BaseDirectory);
                        rest    = word;
                    }
                    else
                    {
                        string dir = word.Substring(0, lastSlash);
                        rootDir = new DirectoryInfo(QQnPath.Combine(args.BaseDirectory, dir));
                        rest    = word.Substring(lastSlash + 1);
                    }

                    Regex fileRegex = ParseFileEx(rootDir, rest, args.FileExpandMode);

                    bool checkAttr = !args.MatchHiddenFiles || !args.MatchSystemFiles;

                    FileAttributes attrMask = (FileAttributes)0;
                    if (!args.MatchHiddenFiles)
                    {
                        attrMask |= FileAttributes.Hidden;
                    }
                    if (!args.MatchSystemFiles)
                    {
                        attrMask |= FileAttributes.System;
                    }

                    SearchOption si       = (args.FileExpandMode == FileExpandMode.DirectoryWildCards) ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
                    bool         foundOne = true;

                    SortedList <string, DirectoryInfo> visibleDirs = new SortedList <string, DirectoryInfo>(QQnPath.PathStringComparer);

                    if (args.MatchDirectories)
                    {
                        foreach (DirectoryInfo fsi in rootDir.GetDirectories("*", si))
                        {
                            if (fileRegex.Match(fsi.FullName).Success)
                            {
                                if (checkAttr && 0 != (fsi.Attributes & attrMask))
                                {
                                    continue;
                                }
                                else if (checkAttr && !DirectoryVisible(fsi, attrMask, visibleDirs))
                                {
                                    continue;
                                }

                                fileList.Insert(i++, fsi.FullName);
                                foundOne = true;
                            }
                        }
                    }
                    if (args.MatchFiles)
                    {
                        foreach (FileInfo fsi in rootDir.GetFiles("*", si))
                        {
                            if (fileRegex.Match(fsi.FullName).Success)
                            {
                                if (checkAttr && 0 != (fsi.Attributes & attrMask))
                                {
                                    continue;
                                }
                                else if (checkAttr && !DirectoryVisible(fsi, attrMask, visibleDirs))
                                {
                                    continue;
                                }

                                fileList.Insert(i++, fsi.FullName);
                                foundOne = true;
                            }
                        }
                    }

                    if (!foundOne && !args.RemoveNonExistingFiles)
                    {
                        return(false);
                    }

                    fileList.RemoveAt(i--);
                }
                else if (args.RemoveNonExistingFiles && !(args.MatchDirectories ? Directory.Exists(word) : File.Exists(word)))
                {
                    return(false);
                }
            }
            return(true);
        }