freetype-commit
[Top][All Lists]
Advanced
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Git][freetype/freetype][gsoc-craig-2023] Add tilde correction as an ent

From: Craig White (@gerzytet)
Subject: [Git][freetype/freetype][gsoc-craig-2023] Add tilde correction as an entry to the adjustment database. Add comment...
Date: Sun, 15 Oct 2023 05:15:59 +0000

Craig White pushed to branch gsoc-craig-2023 at FreeType / FreeType

Commits:

  • 23daa690
    by Craig White at 2023-10-15T01:12:42-04:00 
    Add tilde correction as an entry to the adjustment database.  Add comment block about glyph variants algorithm

3 changed files:

Changes:

  • src/autofit/afadjust.c
    ... ... @@ -21,121 +21,123 @@
    21 21 
     FT_LOCAL_ARRAY_DEF( AF_AdjustmentDatabaseEntry )
    22 22 
     adjustment_database[] =
    23 23 
     {
    24 
    -    {0x21,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* ! */
    25 
    -    {0x69,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* i */
    26 
    -    {0x6A,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* j */
    27 
    -    {0xA1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*Inverted Exclamation Mark*/
    28 
    -    {0xBF,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*Inverted Question Mark*/
    29 
    -    {0xC0,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with grave*/
    30 
    -    {0xC1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with acute*/
    31 
    -    {0xC2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with circumflex*/
    32 
    -    {0xC3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with tilde*/
    33 
    -    {0xC8,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*E with grave*/
    34 
    -    {0xCC,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*I with grave*/
    35 
    -    {0xCD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    36 
    -    {0xCE,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    37 
    -    {0xD1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    38 
    -    {0xD2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    39 
    -    {0xD3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    40 
    -    {0xD4,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    41 
    -    {0xD5,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    42 
    -    {0xD9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    43 
    -    {0xD1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    44 
    -    {0xDB,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    45 
    -    {0xDD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    46 
    -    {0xE0,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    47 
    -    {0xE1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    48 
    -    {0xE2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    49 
    -    {0xE3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    50 
    -    {0xE8,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    51 
    -    {0xE9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    52 
    -    {0xEA,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    53 
    -    {0xEC,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    54 
    -    {0xED,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    55 
    -    {0xEE,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    56 
    -    {0xF1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    57 
    -    {0xF2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    58 
    -    {0xF3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    59 
    -    {0xF4,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    60 
    -    {0xF5,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    61 
    -    {0xF9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    62 
    -    {0xFA,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    63 
    -    {0xFB,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    64 
    -    {0xFD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    65 
    -    {0x100, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    66 
    -    {0x101, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    67 
    -    {0x102, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    68 
    -    {0x103, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    69 
    -    {0x106, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    70 
    -    {0x108, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    71 
    -    {0x109, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    72 
    -    {0x10A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    73 
    -    {0x10B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    74 
    -    {0x10C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    75 
    -    {0x10D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    76 
    -    {0x10E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    77 
    -    {0x112, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    78 
    -    {0x113, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    79 
    -    {0x114, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    80 
    -    {0x115, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    81 
    -    {0x116, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    82 
    -    {0x117, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    83 
    -    {0x11B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    84 
    -    {0x11C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    85 
    -    {0x11D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    86 
    -    {0x11E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    87 
    -    {0x11F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    88 
    -    {0x120, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    89 
    -    {0x121, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    90 
    -    {0x123, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    91 
    -    {0x124, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    92 
    -    {0x125, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    93 
    -    {0x128, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    94 
    -    {0x129, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    95 
    -    {0x12A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    96 
    -    {0x12B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    97 
    -    {0x12C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    98 
    -    {0x12D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    99 
    -    {0x12F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    100 
    -    {0x130, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    101 
    -    {0x134, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    102 
    -    {0x135, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    103 
    -    {0x139, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    104 
    -    {0x13A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    105 
    -    {0x143, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    106 
    -    {0x144, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    107 
    -    {0x147, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    108 
    -    {0x14C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    109 
    -    {0x14D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    110 
    -    {0x14E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    111 
    -    {0x14F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    112 
    -    {0x154, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    113 
    -    {0x155, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    114 
    -    {0x158, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    115 
    -    {0x159, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    116 
    -    {0x15A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    117 
    -    {0x15B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    118 
    -    {0x15C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    119 
    -    {0x15D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    120 
    -    {0x160, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    121 
    -    {0x161, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    122 
    -    {0x164, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    123 
    -    {0x168, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    124 
    -    {0x169, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    125 
    -    {0x16A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    126 
    -    {0x16B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    127 
    -    {0x16C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    128 
    -    {0x16D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    129 
    -    {0x174, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    130 
    -    {0x175, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    131 
    -    {0x176, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    132 
    -    {0x177, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    133 
    -    {0x179, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    134 
    -    {0x17A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    135 
    -    {0x17B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    136 
    -    {0x17C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    137 
    -    {0x17D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
    138 
    -    {0x17E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}
    24 
    +    {0x21,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* ! */
    25 
    +    {0x69,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* i */
    26 
    +    {0x6A,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* j */
    27 
    +    {0xA1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Exclamation Mark*/
    28 
    +    {0xBF,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* j */
    29 
    +    {0xA1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Exclamation Mark*/
    30 
    +    {0xBF,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Question Mark*/
    31 
    +    {0xC0,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with grave*/
    32 
    +    {0xC1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with acute*/
    33 
    +    {0xC2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with circumflex*/
    34 
    +    {0xC3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with tilde*/
    35 
    +    {0xC8,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*E with grave*/
    36 
    +    {0xCC,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*I with grave*/
    37 
    +    {0xCD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    38 
    +    {0xCE,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    39 
    +    {0xD1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    40 
    +    {0xD2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    41 
    +    {0xD3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    42 
    +    {0xD4,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    43 
    +    {0xD5,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    44 
    +    {0xD9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    45 
    +    {0xD1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    46 
    +    {0xDB,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    47 
    +    {0xDD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    48 
    +    {0xE0,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    49 
    +    {0xE1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    50 
    +    {0xE2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    51 
    +    {0xE3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*a with tilde*/
    52 
    +    {0xE8,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    53 
    +    {0xE9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    54 
    +    {0xEA,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    55 
    +    {0xEC,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    56 
    +    {0xED,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    57 
    +    {0xEE,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    58 
    +    {0xF1,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*n with tilde*/
    59 
    +    {0xF2,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    60 
    +    {0xF3,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    61 
    +    {0xF4,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    62 
    +    {0xF5,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*o with tilde*/
    63 
    +    {0xF9,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    64 
    +    {0xFA,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    65 
    +    {0xFB,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    66 
    +    {0xFD,  AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    67 
    +    {0x100, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    68 
    +    {0x101, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    69 
    +    {0x102, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    70 
    +    {0x103, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    71 
    +    {0x106, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    72 
    +    {0x108, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    73 
    +    {0x109, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    74 
    +    {0x10A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    75 
    +    {0x10B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    76 
    +    {0x10C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    77 
    +    {0x10D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    78 
    +    {0x10E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    79 
    +    {0x112, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    80 
    +    {0x113, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    81 
    +    {0x114, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    82 
    +    {0x115, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    83 
    +    {0x116, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    84 
    +    {0x117, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    85 
    +    {0x11B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    86 
    +    {0x11C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    87 
    +    {0x11D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    88 
    +    {0x11E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    89 
    +    {0x11F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    90 
    +    {0x120, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    91 
    +    {0x121, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    92 
    +    {0x123, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    93 
    +    {0x124, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    94 
    +    {0x125, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    95 
    +    {0x128, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    96 
    +    {0x129, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*i with tilde*/
    97 
    +    {0x12A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    98 
    +    {0x12B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    99 
    +    {0x12C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    100 
    +    {0x12D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    101 
    +    {0x12F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    102 
    +    {0x130, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    103 
    +    {0x134, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    104 
    +    {0x135, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    105 
    +    {0x139, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    106 
    +    {0x13A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    107 
    +    {0x143, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    108 
    +    {0x144, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    109 
    +    {0x147, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    110 
    +    {0x14C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    111 
    +    {0x14D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    112 
    +    {0x14E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    113 
    +    {0x14F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    114 
    +    {0x154, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    115 
    +    {0x155, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    116 
    +    {0x158, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    117 
    +    {0x159, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    118 
    +    {0x15A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    119 
    +    {0x15B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    120 
    +    {0x15C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    121 
    +    {0x15D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    122 
    +    {0x160, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    123 
    +    {0x161, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    124 
    +    {0x164, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    125 
    +    {0x168, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    126 
    +    {0x169, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*u with tilde*/
    127 
    +    {0x16A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    128 
    +    {0x16B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    129 
    +    {0x16C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    130 
    +    {0x16D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    131 
    +    {0x174, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    132 
    +    {0x175, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    133 
    +    {0x176, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    134 
    +    {0x177, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    135 
    +    {0x179, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    136 
    +    {0x17A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    137 
    +    {0x17B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    138 
    +    {0x17C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    139 
    +    {0x17D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
    140 
    +    {0x17E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}
    139 141 
     };
    140 142
    141 143 
     /*FT_LOCAL_DEF( FT_Bool )
    ... ... @@ -182,24 +184,17 @@ af_lookup_vertical_seperation_type( AF_ReverseCharacterMap map, FT_Int glyph_ind
    182 184 
         return entry->vertical_separation_adjustment_type;
    183 185 
     }
    184 186
    185 
    -/*TODO: this is a testing placeholder
    186 
    -  it only returns 1 for n with tilde*/
    187 
    -FT_LOCAL_DEF( FT_Int )
    187 
    +/*1 if tilde correction should be applied to the topmost contour
    188 
    +else 0*/
    189 
    +FT_LOCAL_DEF( FT_Bool )
    188 190 
     af_lookup_tilde_correction_type( AF_ReverseCharacterMap map, FT_Int glyph_index ) {
    189 191 
         FT_UInt32 codepoint = af_reverse_character_map_lookup( map, glyph_index );
    190 
    -    /* bits are: apply stretch, apply segment removal */
    191 
    -    if ( codepoint == 0xF1 ) { /*n tilde*/
    192 
    -        return 0b01;
    193 
    -    }
    194 
    -    else if ( codepoint == 0xE3 ) /*a tilde*/
    195 
    -    {
    196 
    -        return 0b11;
    197 
    -    }
    198 
    -    else if ( codepoint == 0xF5 ) /*o tilde*/
    192 
    +    const AF_AdjustmentDatabaseEntry *entry = af_adjustment_database_lookup( codepoint );
    193 
    +    if ( entry == NULL )
    199 194 
         {
    200 
    -        return 0b10;
    195 
    +        return 0;
    201 196 
         }
    202 
    -    return 0;
    197 
    +    return entry->apply_tilde;
    203 198 
     }
    204 199
    205 200 
     typedef struct AF_ReverseMapEntry_
    ... ... @@ -283,12 +278,47 @@ af_reverse_character_map_entry_compare( const void *a, const void *b ) {
    283 278 
     }
    284 279
    285 280 
     #ifdef FT_CONFIG_OPTION_USE_HARFBUZZ
    286 
    -/*Recursive algorithm to find all glyphs that a codepoint could turn into from the GSUB table.
    281 
    +/*
    282 
    +Recursive algorithm to find all glyphs that a codepoint could turn into from the GSUB table.
    283 
    +
    287 284 
     buffer: a buffer containing only the input codepoint
    288 285 
     feature_tag_pool: the current list of features under consideration
    289 286 
     current_features: the current list of features being applied
    290 287 
     num_features: length of current_features
    291 
    -result: the set of glyphs in the answer
    288 
    +result: the set of glyphs that the input codepoint can map to.
    289 
    +
    290 
    +The algorithm works by running the hb_ot_shape_glyphs_closure function on different lists of features
    291 
    +to see which features will map to glyph onto something different.  This functions returns
    292 
    +the result of transforming a glyph using a list of features as well as all intermediate
    293 
    +forms if the glyph was transformed multiple times.
    294 
    +With no features enabled, hb_ot_shape_glyphs_closure will only return the glyph given by cmap.
    295 
    +This character will be the first to be placed into the results set.
    296 
    +Next, the algorithm will test the same lookup enabline one feature at a time
    297 
    +and see if any of those features change the result.
    298 
    +If any new glyph variants are found this way, they are added to the results set
    299 
    +and the algorithm will recurce, trying that feature in combination will every other feature
    300 
    +to look for further glyph variants.
    301 
    +
    302 
    +example:
    303 
    +suppose we have the following features in the GSUB table:
    304 
    +f1:
    305 
    +a -> b
    306 
    +
    307 
    +f2:
    308 
    +b -> c
    309 
    +
    310 
    +f3:
    311 
    +d -> e
    312 
    +
    313 
    +The algorithm will take the following steps to find all variants of "a":
    314 
    +- a is added to the results
    315 
    +- lookup with feature list {f1}, yielding {a, b}. b is added to the results list and the algorithm recurses
    316 
    +- - lookup with feature list {f1, f2}, yielding {a, b, c}.  c is added to the results list and the algorithm recurses
    317 
    +- - - lookup with feature list {f1, f2, f3} yielding {a, b, c}.  No new glyphs
    318 
    +- - lookup with feature list {f1, f3}, yielding {a, b}.  No new glyphs
    319 
    +- lookup with feature list {f2}, yielding {a}. No new glyphs
    320 
    +- lookup with feature list {f3}, yielding {a}. No new glyphs
    321 
    +
    292 322 
     */
    293 323 
     FT_LOCAL_DEF( FT_Error )
    294 324 
     af_all_glyph_variants_helper( hb_font_t *font,
    ... ... @@ -300,7 +330,7 @@ af_all_glyph_variants_helper( hb_font_t *font,
    300 330 
     {
    301 331 
         FT_Error error;
    302 332 
         /*get the list of glyphs that are created by only transforming based on the
    303 
    -    features in current features*/
    333 
    +    features in current_features*/
    304 334 
         hb_set_t *baseline_glyphs = NULL, *new_glyphs = NULL;
    305 335 
         baseline_glyphs = hb_set_create();
    306 336 
         if ( !hb_set_allocation_successful( baseline_glyphs ) )

  • src/autofit/afadjust.h
    ... ... @@ -27,12 +27,13 @@ typedef struct AF_AdjustmentDatabaseEntry_
    27 27 
     {
    28 28 
       FT_UInt32 codepoint;
    29 29 
       AF_VerticalSeparationAdjustmentType vertical_separation_adjustment_type;
    30 
    +  FT_Bool apply_tilde;
    30 31 
     } AF_AdjustmentDatabaseEntry;
    31 32
    32 33 
     FT_LOCAL(AF_VerticalSeparationAdjustmentType)
    33 34 
     af_lookup_vertical_seperation_type( AF_ReverseCharacterMap map, FT_Int glyph_index );
    34 35
    35 
    -FT_LOCAL( FT_Int )
    36 
    +FT_LOCAL( FT_Bool )
    36 37 
     af_lookup_tilde_correction_type( AF_ReverseCharacterMap map, FT_Int glyph_index );
    37 38
    38 39 
     FT_LOCAL( FT_UInt32 )

  • src/autofit/aflatin.c
    ... ... @@ -2855,158 +2855,154 @@ af_remove_segments_containing_point(AF_GlyphHints hints, AF_Point point)
    2855 2855 
       }
    2856 2856 
     }
    2857 2857
    2858 
    +/*remove all segments containing points on the tilde contour*/
    2858 2859 
     static void
    2859 
    -af_latin_stretch_tildes_step_2( AF_GlyphHints hints,
    2860 
    -                                FT_Int glyph_index,
    2861 
    -                                AF_ReverseCharacterMap reverse_charmap )
    2860 
    +af_latin_remove_tilde_points_from_edges( AF_GlyphHints hints,
    2861 
    +                                         FT_Int glyph_index )
    2862 2862 
     {
    2863 
    -  if (af_lookup_tilde_correction_type(reverse_charmap, glyph_index) & 1) {
    2864 
    -    FT_Int highest_contour = af_find_highest_contour(hints);
    2865 
    -    AF_Point first_point = hints->contours[highest_contour];
    2863 
    +  FT_Int highest_contour = af_find_highest_contour(hints);
    2864 
    +  AF_Point first_point = hints->contours[highest_contour];
    2866 2865
    2867 
    -    /* search for any curve tips that are on a y extrema, and delete any
    2868 
    -      segments that contain this point.*/
    2869 
    -    AF_Point p = first_point;
    2866 
    +  /* search for any curve tips that are on a y extrema, and delete any
    2867 
    +    segments that contain this point.*/
    2868 
    +  AF_Point p = first_point;
    2870 2869
    2871 
    -    do
    2870 
    +  do
    2871 
    +  {
    2872 
    +    p = p->next;
    2873 
    +    if ( /*!(p->flags & AF_FLAG_CONTROL)
    2874 
    +          && p->prev->y == p->y && p->next->y == p->y
    2875 
    +          && p->prev->flags & AF_FLAG_CONTROL
    2876 
    +          && p->next->flags & AF_FLAG_CONTROL*/ 1 )
    2872 2877 
         {
    2873 
    -      p = p->next;
    2874 
    -      if ( /*!(p->flags & AF_FLAG_CONTROL)
    2875 
    -            && p->prev->y == p->y && p->next->y == p->y
    2876 
    -            && p->prev->flags & AF_FLAG_CONTROL
    2877 
    -            && p->next->flags & AF_FLAG_CONTROL*/ 1 )
    2878 
    -      {
    2879 
    -        FT_TRACE4(("%p", p));
    2880 
    -        af_remove_segments_containing_point( hints, p );
    2881 
    -      }
    2882 
    -    } while ( p != first_point );
    2883 
    -  }
    2878 
    +      FT_TRACE4(("%p", p));
    2879 
    +      af_remove_segments_containing_point( hints, p );
    2880 
    +    }
    2881 
    +  } while ( p != first_point );
    2884 2882 
     }
    2885 2883 
     void
    2886 2884 
     af_latin_stretch_tildes( AF_GlyphHints hints,
    2887 
    -                         FT_Int glyph_index,
    2888 
    -                         AF_ReverseCharacterMap reverse_charmap ) {
    2889 
    -  if ( af_lookup_tilde_correction_type( reverse_charmap, glyph_index ) & 2 ) {
    2890 
    -    FT_Int highest_contour = af_find_highest_contour( hints );
    2891 
    -    AF_Point p = hints->contours[highest_contour];
    2892 
    -    AF_Point first_point = p;
    2885 
    +                         FT_Int glyph_index )
    2886 
    +{
    2887 
    +  FT_Int highest_contour = af_find_highest_contour( hints );
    2888 
    +  AF_Point p = hints->contours[highest_contour];
    2889 
    +  AF_Point first_point = p;
    2890 
    +
    2891 
    +  FT_Pos min_y, max_y;
    2892 
    +  min_y = max_y = p->y;
    2893 2893
    2894 
    -    FT_Pos min_y, max_y;
    2895 
    -    min_y = max_y = p->y;
    2894 
    +  FT_Short min_fy, max_fy;
    2895 
    +  min_fy = max_fy = p->fy;
    2896 2896
    2897 
    -    FT_Short min_fy, max_fy;
    2898 
    -    min_fy = max_fy = p->fy;
    2897 
    +  do
    2898 
    +  {
    2899 
    +    p = p->next;
    2900 
    +    if ( p->y < min_y )
    2901 
    +    {
    2902 
    +      min_y = p->y;
    2903 
    +    }
    2904 
    +    if ( p->y > max_y )
    2905 
    +    {
    2906 
    +      max_y = p->y;
    2907 
    +    }
    2899 2908
    2900 
    -    do
    2909 
    +    if ( p->fy < min_fy )
    2901 2910 
         {
    2902 
    -      p = p->next;
    2903 
    -      if ( p->y < min_y )
    2911 
    +      min_fy = p->fy;
    2912 
    +    }
    2913 
    +
    2914 
    +    if ( p->fy > max_fy )
    2915 
    +    {
    2916 
    +      max_fy = p->fy;
    2917 
    +    }
    2918 
    +
    2919 
    +  }
    2920 
    +  while ( p != first_point );
    2921 
    +
    2922 
    +  FT_Pos min_measurement = 32000;
    2923 
    +  FT_UInt measurements_taken = 0;
    2924 
    +
    2925 
    +  do
    2926 
    +  {
    2927 
    +    p = p->next;
    2928 
    +    if ( !(p->flags & AF_FLAG_CONTROL)
    2929 
    +          && p->prev->y == p->y && p->next->y == p->y
    2930 
    +          && p->y != min_y && p->y != max_y
    2931 
    +          && p->prev->flags & AF_FLAG_CONTROL
    2932 
    +          && p->next->flags & AF_FLAG_CONTROL )
    2933 
    +    {
    2934 
    +      /* This point could be a candidate.  Find the next and previous on-curve */
    2935 
    +      /* points, and make sure they are both either above or below the point, */
    2936 
    +      /* Then make the measurement */
    2937 
    +      AF_Point prevOn = p->prev;
    2938 
    +      AF_Point nextOn = p->next;
    2939 
    +      while ( prevOn->flags & AF_FLAG_CONTROL )
    2904 2940 
           {
    2905 
    -        min_y = p->y;
    2941 
    +        prevOn = prevOn->prev;
    2906 2942 
           }
    2907 
    -      if ( p->y > max_y )
    2943 
    +      while ( nextOn->flags & AF_FLAG_CONTROL )
    2908 2944 
           {
    2909 
    -        max_y = p->y;
    2945 
    +        nextOn = nextOn->next;
    2910 2946 
           }
    2911 
    -
    2912 
    -      if ( p->fy < min_fy )
    2947 
    +      FT_Pos measurement;
    2948 
    +      if ( nextOn->y > p->y && prevOn->y > p->y )
    2913 2949 
           {
    2914 
    -        min_fy = p->fy;
    2950 
    +        measurement = p->y - min_y;
    2915 2951 
           }
    2916 
    -
    2917 
    -      if ( p->fy > max_fy )
    2952 
    +      else if ( nextOn->y < p->y && prevOn->y < p->y )
    2918 2953 
           {
    2919 
    -        max_fy = p->fy;
    2954 
    +        measurement = max_y - p->y;
    2955 
    +      }
    2956 
    +      else
    2957 
    +      {
    2958 
    +        continue;
    2920 2959 
           }
    2921 2960
    2961 
    +      if (measurement < min_measurement)
    2962 
    +      {
    2963 
    +        min_measurement = measurement;
    2964 
    +      }
    2965 
    +      measurements_taken++;
    2922 2966 
         }
    2923 
    -    while ( p != first_point );
    2924 2967
    2925 
    -    FT_Pos min_measurement = 32000;
    2926 
    -    FT_UInt measurements_taken = 0;
    2927 
    -
    2928 
    -    do
    2929 
    -    {
    2930 
    -      p = p->next;
    2931 
    -      if ( !(p->flags & AF_FLAG_CONTROL)
    2932 
    -           && p->prev->y == p->y && p->next->y == p->y
    2933 
    -           && p->y != min_y && p->y != max_y
    2934 
    -           && p->prev->flags & AF_FLAG_CONTROL
    2935 
    -           && p->next->flags & AF_FLAG_CONTROL )
    2936 
    -      {
    2937 
    -        /* This point could be a candidate.  Find the next and previous on-curve */
    2938 
    -        /* points, and make sure they are both either above or below the point, */
    2939 
    -        /* Then make the measurement */
    2940 
    -        AF_Point prevOn = p->prev;
    2941 
    -        AF_Point nextOn = p->next;
    2942 
    -        while ( prevOn->flags & AF_FLAG_CONTROL )
    2943 
    -        {
    2944 
    -          prevOn = prevOn->prev;
    2945 
    -        }
    2946 
    -        while ( nextOn->flags & AF_FLAG_CONTROL )
    2947 
    -        {
    2948 
    -          nextOn = nextOn->next;
    2949 
    -        }
    2950 
    -        FT_Pos measurement;
    2951 
    -        if ( nextOn->y > p->y && prevOn->y > p->y )
    2952 
    -        {
    2953 
    -          measurement = p->y - min_y;
    2954 
    -        }
    2955 
    -        else if ( nextOn->y < p->y && prevOn->y < p->y )
    2956 
    -        {
    2957 
    -          measurement = max_y - p->y;
    2958 
    -        }
    2959 
    -        else
    2960 
    -        {
    2961 
    -          continue;
    2962 
    -        }
    2968 
    +  }
    2969 
    +  while ( p != first_point );
    2963 2970
    2964 
    -        if (measurement < min_measurement)
    2965 
    -        {
    2966 
    -          min_measurement = measurement;
    2967 
    -        }
    2968 
    -        measurements_taken++;
    2969 
    -      }
    2971 
    +  FT_Pos height = max_y - min_y;
    2970 2972
    2971 
    -    }
    2972 
    -    while ( p != first_point );
    2973 
    +  FT_Pos target_height = min_measurement + 64;
    2974 
    +  if ( height >= target_height )
    2975 
    +  {
    2976 
    +    return;
    2977 
    +  }
    2973 2978
    2974 
    -    FT_Pos height = max_y - min_y;
    2979 
    +  p = first_point;
    2980 
    +  do
    2981 
    +  {
    2982 
    +    p = p->next;
    2983 
    +    p->y = ((p->y - min_y) * target_height / height) + min_y;
    2984 
    +    p->fy = ((p->fy - min_fy) * target_height / height) + min_fy;
    2985 
    +    p->oy = p->y;
    2986 
    +    if ( !(p->flags & AF_FLAG_CONTROL) )
    2987 
    +      p->flags |= AF_FLAG_TOUCH_Y;
    2988 
    +  }
    2989 
    +  while ( p != first_point );
    2975 2990
    2976 
    -    FT_Pos target_height = min_measurement + 64;
    2977 
    -    if ( height >= target_height )
    2991 
    +  FT_Pos new_min_y, new_max_y;
    2992 
    +  new_min_y = new_max_y = first_point->y;
    2993 
    +  p = first_point;
    2994 
    +  do {
    2995 
    +    p = p->next;
    2996 
    +    if ( p->y < new_min_y )
    2978 2997 
         {
    2979 
    -      return;
    2998 
    +      new_min_y = p->y;
    2980 2999 
         }
    2981 
    -
    2982 
    -    p = first_point;
    2983 
    -    do
    3000 
    +    if ( p->y > new_max_y )
    2984 3001 
         {
    2985 
    -      p = p->next;
    2986 
    -      p->y = ((p->y - min_y) * target_height / height) + min_y;
    2987 
    -      p->fy = ((p->fy - min_fy) * target_height / height) + min_fy;
    2988 
    -      p->oy = p->y;
    2989 
    -      if ( !(p->flags & AF_FLAG_CONTROL) )
    2990 
    -        p->flags |= AF_FLAG_TOUCH_Y;
    3002 
    +      new_max_y = p->y;
    2991 3003 
         }
    2992 
    -    while ( p != first_point );
    2993 
    -
    2994 
    -    FT_Pos new_min_y, new_max_y;
    2995 
    -    new_min_y = new_max_y = first_point->y;
    2996 
    -    p = first_point;
    2997 
    -    do {
    2998 
    -      p = p->next;
    2999 
    -      if ( p->y < new_min_y )
    3000 
    -      {
    3001 
    -        new_min_y = p->y;
    3002 
    -      }
    3003 
    -      if ( p->y > new_max_y )
    3004 
    -      {
    3005 
    -        new_max_y = p->y;
    3006 
    -      }
    3007 
    -    }
    3008 
    -    while ( p != first_point );
    3009 3004 
       }
    3005 
    +  while ( p != first_point );
    3010 3006 
     }
    3011 3007
    3012 3008 
     /*True if the given contour overlaps horizontally with the bounding box
    ... ... @@ -4060,33 +4056,7 @@ af_glyph_hints_apply_vertical_separation_adjustments( AF_GlyphHints hints,
    4060 4056 
     #endif
    4061 4057 
       }
    4062 4058
    4063 
    -/*Print the height of the topmost contour for debugging purposes.
    4064 
    -  TODO: remove this once the tilde unflattening works.*/
    4065 
    -static void traceheight(FT_UInt num, AF_GlyphHints hints) {
    4066 
    -  AF_Point p = hints->contours[af_find_highest_contour(hints)];
    4067 
    -  AF_Point first_point = p;
    4068 
    -
    4069 
    -  FT_Pos min_y, max_y;
    4070 
    -  min_y = max_y = p->y;
    4071 
    -
    4072 
    -  do {
    4073 
    -    p = p->next;
    4074 
    -    if ( !(p->flags & AF_FLAG_CONTROL) ) {
    4075 
    -      if ( p->y < min_y ) {
    4076 
    -        min_y = p->y;
    4077 
    -      }
    4078 
    -      if ( p->y > max_y ) {
    4079 
    -        max_y = p->y;
    4080 
    -      }
    4081 
    -    }
    4082 
    -  } while ( p != first_point );
    4083 
    -
    4084 
    -  FT_Pos height = max_y - min_y;
    4085 
    -  FT_TRACE4(( "height %d: %d\n", num, height ));
    4086 
    -}
    4087 
    -
    4088 4059 
       /* Apply the complete hinting algorithm to a latin glyph. */
    4089 
    -
    4090 4060 
       static FT_Error
    4091 4061 
       af_latin_hints_apply( FT_UInt          glyph_index,
    4092 4062 
                             AF_GlyphHints    hints,
    ... ... @@ -4119,13 +4089,18 @@ static void traceheight(FT_UInt num, AF_GlyphHints hints) {
    4119 4089
    4120 4090 
         if ( AF_HINTS_DO_VERTICAL( hints ) )
    4121 4091 
         {
    4122 
    -      af_latin_stretch_tildes( hints, glyph_index, metrics->root.reverse_charmap );
    4092 
    +      FT_Bool is_tilde = af_lookup_tilde_correction_type( metrics->root.reverse_charmap, glyph_index );
    4093 
    +      if ( is_tilde ) {
    4094 
    +        af_latin_stretch_tildes( hints, glyph_index );
    4095 
    +      }
    4123 4096 
           axis  = &metrics->axis[AF_DIMENSION_VERT];
    4124 4097 
           error = af_latin_hints_detect_features( hints,
    4125 4098 
                                                   axis->width_count,
    4126 4099 
                                                   axis->widths,
    4127 4100 
                                                   AF_DIMENSION_VERT );
    4128 
    -      af_latin_stretch_tildes_step_2( hints, glyph_index, metrics->root.reverse_charmap );
    4101 
    +      if ( is_tilde ) {
    4102 
    +        af_latin_remove_tilde_points_from_edges( hints, glyph_index );
    4103 
    +      }
    4129 4104 
           if ( error )
    4130 4105 
             goto Exit;
    4131 4106

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.freedesktop.org. Manage all notifications · Help

    reply via email to
    [Prev in Thread] Current Thread [Next in Thread]