public static void SetupFontsFiles(string[] sSupportedFonts)
        {
            List <FontFileInfo> tempFontInfoList = new List <FontFileInfo>();

            foreach (string fontPathFile in sSupportedFonts)
            {
                try
                {
                    FontFileInfo fontInfo = FontFileInfo.Load(fontPathFile);
                    Debug.WriteLine(fontPathFile);
                    tempFontInfoList.Add(fontInfo);
                }
                catch (System.Exception e)
                {
                    System.Console.Error.WriteLine(e);
                }
            }

            // Deserialize all font families
            foreach (IGrouping <string, FontFileInfo> familyGroup in tempFontInfoList.GroupBy(info => info.FamilyName))
            {
                try
                {
                    string          familyName = familyGroup.Key;
                    FontFamilyModel family     = DeserializeFontFamily(familyName, familyGroup);
                    InstalledFonts.Add(familyName.ToLower(), family);
                }
                catch (System.Exception e)
                {
                    System.Console.Error.WriteLine(e);
                }
            }
        }
        internal override void ProcessData(AmcpParsedData data)
        {
            base.ProcessData(data);

            for (var i = 1; i < data.Data.Count; i++)
            {
                _fontList.Add(FontFileInfo.Parse(data.Data[i]));
            }
        }
Exemplo n.º 3
0
        private bool FindFontFiles(string fontFolder, Dictionary <string, List <AssFontInfo> > fontsInAss,
                                   ref Dictionary <string, FontFileInfo> fontFileInfo)
        {
            var duplicateFontFiles = new Dictionary <string, List <string> >();

            var fontFiles = Directory.EnumerateFiles(fontFolder, "*.*", SearchOption.TopDirectoryOnly);

            string[] fontExtensions = { ".fon", ".otf", ".ttc", ".ttf" };
            foreach (var file in fontFiles)
            {
                if (fontExtensions.Count(e => e == Path.GetExtension(file).ToLower()) == 0)
                {
                    continue;
                }

                int index     = -1;
                var fontNames = new List <string>();

                var parsers = new Action[] {
                    () => {
                        if (Path.GetExtension(file).ToLower() == ".ttc")
                        {
                            return;
                        }
                        try {
                            var typeface = new GlyphTypeface(new Uri("file://" + file));
                            var result   = typeface.Win32FamilyNames.Values.Where(name => fontsInAss.ContainsKey(name));
                            if (result.Count() > 0)
                            {
                                fontNames.AddRange(result.Distinct());
                                return;
                            }
                        } catch (Exception ex) {
                            return;
                        }
                    },
                    () => {
                        if (Path.GetExtension(file).ToLower() == ".otf")
                        {
                            return;
                        }
                        var fontFamilies = Fonts.GetFontFamilies(file).ToList();
                        for (index = 0; index < fontFamilies.Count; index++)
                        {
                            var result = fontFamilies[index].FamilyNames.Values.Where(name => fontsInAss.ContainsKey(name));
                            if (result.Count() > 0)
                            {
                                fontNames.AddRange(result.Distinct());
                                return;
                            }
                        }
                    }, () => {
                        if (Path.GetExtension(file).ToLower() == ".otf")
                        {
                            return;
                        }
                        PrivateFontCollection collection = new PrivateFontCollection();
                        collection.AddFontFile(file);
                        var result = collection.Families.Where(f => fontsInAss.ContainsKey(f.Name)).Select(f => f.Name);
                        if (result.Count() > 0)
                        {
                            fontNames.AddRange(result.Distinct());
                        }
                        RemoveFontResourceEx(file, 16, IntPtr.Zero);
                    },
                };

                for (int i = 0; i < parsers.Length && fontNames.Count == 0; i++)
                {
                    parsers[i]();
                }

                if (fontNames.Count == 0)
                {
                    continue;
                }

                foreach (var fontName in fontNames)
                {
                    if (fontFileInfo.ContainsKey(fontName))
                    {
                        if (!duplicateFontFiles.ContainsKey(fontName))
                        {
                            duplicateFontFiles[fontName] = new List <string> {
                                fontFileInfo[fontName].FileName
                            };
                        }
                        duplicateFontFiles[fontName].Add(file);
                    }

                    fontFileInfo[fontName] = new FontFileInfo {
                        FontNumberInCollection = index, FileName = file
                    };
                }
            }

            if (duplicateFontFiles.Count > 0)
            {
                string text = "找到以下重复字体文件:\r\n";
                foreach (var font in duplicateFontFiles)
                {
                    text += $"    {font.Key}:\r\n";
                    font.Value.Sort();
                    font.Value.ForEach(file => text += $"        {Path.GetFileName(file)}\r\n");
                }
                text += "\r\n";
                text += "将从重复字体文件中随机选取字体,是否继续?";

                var result = MessageBox.Show(text, "找到重复字体文件", MessageBoxButton.YesNo,
                                             MessageBoxImage.Question, MessageBoxResult.No);
                return(result == MessageBoxResult.Yes);
            }

            return(true);
        }