librarian/font-optimizer/ext/Font-TTF/lib/Font/TTF/GSUB.pm

   1 package Font::TTF::GSUB;
   2
   3 =head1 NAME
   4
   5 Font::TTF::GSUB - Module support for the GSUB table in conjunction with TTOpen
   6
   7 =head1 DESCRIPTION
   8
   9 Handles the GSUB subtables in relation to Ttopen tables. Due to the variety of
  10 different lookup types, the data structures are not all that straightforward,
  11 although I have tried to make life easy for myself when using this!
  12
  13 =head1 INSTANCE VARIABLES
  14
  15 The structure of a GSUB table is the same as that given in L<Font::TTF::Ttopen>.
  16 Here we give some of the semantics specific to GSUB lookups.
  17
  18 =over 4
  19
  20 =item ACTION_TYPE
  21
  22 This is a string taking one of 4 values indicating the nature of the information
  23 in the ACTION array of the rule:
  24
  25 =over 8
  26
  27 =item g
  28
  29 The action contains a string of glyphs to replace the match string by
  30
  31 =item l
  32
  33 The action array contains a list of lookups and offsets to run, in order, on
  34 the matched string
  35
  36 =item a
  37
  38 The action array is an unordered set of optional replacements for the matched
  39 glyph. The application should make the selection somehow.
  40
  41 =item o
  42
  43 The action array is empty (in fact there is no rule array for this type of
  44 rule) and the ADJUST value should be added to the glyph id to find the replacement
  45 glyph id value
  46
  47 =back
  48
  49 =item MATCH_TYPE
  50
  51 This indicates which type of information the various MATCH arrays (MATCH, PRE,
  52 POST) hold in the rule:
  53
  54 =over 8
  55
  56 =item g
  57
  58 The array holds a string of glyph ids which should match exactly
  59
  60 =item c
  61
  62 The array holds a sequence of class definitions which each glyph should
  63 correspondingly match to
  64
  65 =item o
  66
  67 The array holds offsets to coverage tables
  68
  69 =back
  70
  71 =back
  72
  73 =head1 CORRESPONDANCE TO LAYOUT TYPES
  74
  75 The following table gives the values for ACTION_TYPE and MATCH_TYPE for each
  76 of the 11 different lookup types found in the GSUB table definition I have:
  77
  78                 1.1 1.2 2   3   4   5.1 5.2 5.3 6.1 6.2 6.3
  79   ACTION_TYPE    o   g  g   a   g    l   l   l   l   l   l
  80   MATCH_TYPE                    g    g   c   o   g   c   o
  81
  82 Hopefully, the rest of the uses of the variables should make sense from this
  83 table.
  84
  85 =head1 METHODS
  86
  87 =cut
  88
  89 use strict;
  90 use vars qw(@ISA);
  91 use Font::TTF::Utils;
  92 use Font::TTF::Ttopen;
  93
  94 @ISA = qw(Font::TTF::Ttopen);
  95
  96 =head2 $t->read_sub($fh, $lookup, $index)
  97
  98 Asked by the superclass to read in from the given file the indexth subtable from
  99 lookup number lookup. The file is positioned ready for the read.
 100
 101 =cut
 102
 103 sub read_sub
 104 {
 105     my ($self, $fh, $main_lookup, $sindex) = @_;
 106     my ($type) = $main_lookup->{'TYPE'};
 107     my ($loc) = $fh->tell();
 108     my ($lookup) = $main_lookup->{'SUB'}[$sindex];
 109     my ($dat, $s, @subst, $t, $fmt, $cover, $count, $mcount, $scount, $i, $gid);
 110     my (@srec);
 111
 112     if ($type == 6)
 113     {
 114         $fh->read($dat, 4);
 115         ($fmt, $cover) = TTF_Unpack('S2', $dat);
 116         if ($fmt < 3)
 117         {
 118             $fh->read($dat, 2);
 119             $count = TTF_Unpack('S', $dat);
 120         }
 121     } else
 122     {
 123         $fh->read($dat, 6);
 124         ($fmt, $cover, $count) = TTF_Unpack("S3", $dat);
 125     }
 126     unless ($fmt == 3 && ($type == 5 || $type == 6))
 127     { $lookup->{'COVERAGE'} = $self->read_cover($cover, $loc, $lookup, $fh, 1); }
 128
 129     $lookup->{'FORMAT'} = $fmt;
 130     if ($type == 1 && $fmt == 1)
 131     {
 132         $count -= 65536 if ($count > 32767);
 133         $lookup->{'ADJUST'} = $count;
 134         $lookup->{'ACTION_TYPE'} = 'o';
 135     } elsif ($type == 1 && $fmt == 2)
 136     {
 137         $fh->read($dat, $count << 1);
 138         @subst = TTF_Unpack('S*', $dat);
 139         foreach $s (@subst)
 140         { push(@{$lookup->{'RULES'}}, [{'ACTION' => [$s]}]); }
 141         $lookup->{'ACTION_TYPE'} = 'g';
 142     } elsif ($type == 2 || $type == 3)
 143     {
 144         $fh->read($dat, $count << 1);       # number of offsets
 145         foreach $s (TTF_Unpack('S*', $dat))
 146         {
 147             $fh->seek($loc + $s, 0);
 148             $fh->read($dat, 2);
 149             $t = TTF_Unpack('S', $dat);
 150             $fh->read($dat, $t << 1);
 151             push(@{$lookup->{'RULES'}}, [{'ACTION' => [TTF_Unpack('S*', $dat)]}]);
 152         }
 153         $lookup->{'ACTION_TYPE'} = ($type == 2 ? 'g' : 'a');
 154     } elsif ($type == 4)
 155     {
 156         $fh->read($dat, $count << 1);
 157         foreach $s (TTF_Unpack('S*', $dat))
 158         {
 159             @subst = ();
 160             $fh->seek($loc + $s, 0);
 161             $fh->read($dat, 2);
 162             $t = TTF_Unpack('S', $dat);
 163             $fh->read($dat, $t << 1);
 164             foreach $t (TTF_Unpack('S*', $dat))
 165             {
 166                 $fh->seek($loc + $s + $t, 0);
 167                 $fh->read($dat, 4);
 168                 ($gid, $mcount) = TTF_Unpack('S2', $dat);
 169                 $fh->read($dat, ($mcount - 1) << 1);
 170                 push(@subst, {'ACTION' => [$gid], 'MATCH' => [TTF_Unpack('S*', $dat)]});
 171             }
 172             push(@{$lookup->{'RULES'}}, [@subst]);
 173         }
 174         $lookup->{'ACTION_TYPE'} = 'g';
 175         $lookup->{'MATCH_TYPE'} = 'g';
 176     } elsif ($type == 5 || $type == 6)
 177     { $self->read_context($lookup, $fh, $type, $fmt, $cover, $count, $loc); }
 178     $lookup;
 179 }
 180
 181
 182 =head2 $t->extension
 183
 184 Returns the table type number for the extension table
 185
 186 =cut
 187
 188 sub extension
 189 { return 7; }
 190
 191
 192 =head2 $t->out_sub($fh, $lookup, $index)
 193
 194 Passed the filehandle to output to, suitably positioned, the lookup and subtable
 195 index, this function outputs the subtable to $fh at that point.
 196
 197 =cut
 198
 199 sub out_sub
 200 {
 201     my ($self, $fh, $main_lookup, $index, $ctables, $base) = @_;
 202     my ($type) = $main_lookup->{'TYPE'};
 203     my ($lookup) = $main_lookup->{'SUB'}[$index];
 204     my ($fmt) = $lookup->{'FORMAT'};
 205     my ($out, $r, $t, $i, $j, $offc, $offd, $numd);
 206     my ($num) = $#{$lookup->{'RULES'}} + 1;
 207
 208     if ($type == 1)
 209     {
 210         $out = pack("nn", $fmt, Font::TTF::Ttopen::ref_cache($lookup->{'COVERAGE'}, $ctables, 2 + $base));
 211         if ($fmt == 1)
 212         { $out .= pack("n", $lookup->{'ADJUST'}); }
 213         else
 214         {
 215             $out .= pack("n", $num);
 216             foreach $r (@{$lookup->{'RULES'}})
 217             { $out .= pack("n", $r->[0]{'ACTION'}[0]); }
 218         }
 219     } elsif ($type == 2 || $type == 3)
 220     {
 221         $out = pack("nnn", $fmt, Font::TTF::Ttopen::ref_cache($lookup->{'COVERAGE'}, $ctables, 2 + $base),
 222                             $num);
 223         $out .= pack('n*', (0) x $num);
 224         $offc = length($out);
 225         for ($i = 0; $i < $num; $i++)
 226         {
 227             $out .= pack("n*", $#{$lookup->{'RULES'}[$i][0]{'ACTION'}} + 1,
 228                                     @{$lookup->{'RULES'}[$i][0]{'ACTION'}});
 229             substr($out, ($i << 1) + 6, 2) = pack('n', $offc);
 230             $offc = length($out);
 231         }
 232     } elsif ($type == 4 || $type == 5 || $type == 6)
 233     { $out = $self->out_context($lookup, $fh, $type, $fmt, $ctables, $out, $num, $base); }
 234 #    Font::TTF::Ttopen::out_final($fh, $out, [[$ctables, 0]]);
 235     $out;
 236 }
 237
 238 =head1 AUTHOR
 239
 240 Martin Hosken Martin_Hosken@sil.org. See L<Font::TTF::Font> for copyright and
 241 licensing.
 242
 243 =cut
 244
 245 1;
 246