コード例 #1
0
        private void FillOpenType(TinyFont font)
        {
            HashSet <ushort> userGlyphs = new HashSet <ushort>();

            foreach (CharacterImportInfo info in EnumerateAllImports())
            {
                if (info.Mapping.Glyph.HasValue)
                {
                    userGlyphs.Add(info.Mapping.Glyph.Value);
                }
            }

            Dictionary <ushort, BuilderState> allGeneratedGlyphs = new Dictionary <ushort, BuilderState>();

            foreach (FeatureImportInfo feature in _features.Where(f => f.Type == FeatureImportType.Substitution))
            {
                foreach (ushort generatedGlyph in _compiler.GetGeneratedGlyphIds(feature.BuilderState.GlyphTypeface, feature.Script, feature.Language, feature.Feature))
                {
                    allGeneratedGlyphs[generatedGlyph] = feature.BuilderState;
                }
            }

            GlyphClassesAppendix classes      = font.GetOrAddNewAppendix <GlyphClassesAppendix>();
            SubstitutionAppendix substitution = font.GetOrAddNewAppendix <SubstitutionAppendix>();
            PositioningAppendix  positioning  = font.GetOrAddNewAppendix <PositioningAppendix>();

            Dictionary <ushort, BuilderState> glyphsToAdd = new Dictionary <ushort, BuilderState>();

            foreach (FeatureImportInfo feature in _features.Where(f => f.Type == FeatureImportType.Substitution))
            {
                foreach (ushort generatedGlyph in _compiler.CompileFeature(feature.BuilderState.GlyphTypeface, feature.Script, feature.Language, feature.Feature, substitution, classes, allGeneratedGlyphs.Keys.Concat(userGlyphs)))
                {
                    glyphsToAdd[generatedGlyph] = feature.BuilderState;
                }
            }

            foreach (KeyValuePair <ushort, BuilderState> toAddPair in glyphsToAdd)
            {
                if (!userGlyphs.Contains(toAddPair.Key))
                {
                    int character;

                    if (toAddPair.Value.GlyphToCharacterMap.TryGetValue(toAddPair.Key, out character))
                    {
                        _characterImportList[character] = new CharacterImportInfo(toAddPair.Value, new CharacterGlyphPair(character, toAddPair.Key));
                    }
                    else if (toAddPair.Key < toAddPair.Value.GlyphTypeface.GlyphCount)
                    {
                        _glyphImportList.Add(new CharacterImportInfo(toAddPair.Value, new CharacterGlyphPair(null, toAddPair.Key)));
                    }

                    userGlyphs.Add(toAddPair.Key);
                }
            }

            foreach (FeatureImportInfo feature in _features.Where(f => f.Type == FeatureImportType.Positioning))
            {
                _compiler.CompileFeature(feature.BuilderState.GlyphTypeface, feature.Script, feature.Language, feature.Feature, positioning, classes, allGeneratedGlyphs.Keys.Concat(userGlyphs), feature.BuilderState.EmSize);
            }
        }
コード例 #2
0
            /// <summary>
            /// Gets glyphs within this coverage.
            /// </summary>
            /// <param name="appendix"><see cref="GlyphClassesAppendix"/> containing this coverage.</param>
            /// <returns>Glyph's ID.</returns>
            public IEnumerable <int> GetGlyphs(GlyphClassesAppendix appendix)
            {
                if (_offset < 0 || _offset + _count > appendix.CoverageGlyphs.Count)
                {
                    throw new InvalidOperationException("Out of range.");
                }

                for (int i = 0; i < _count; i++)
                {
                    yield return(appendix.CoverageGlyphs[i + _offset]);
                }
            }