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

   1 package Font::TTF::GDEF;
   2
   3 =head1 NAME
   4
   5 Font::TTF::GDEF - Opentype GDEF table support
   6
   7 =head1 DESCRIPTION
   8
   9 The GDEF table contains various global lists of information which are apparantly
  10 used in other places in an OpenType renderer. But precisely where is open to
  11 speculation...
  12
  13 =head1 INSTANCE VARIABLES
  14
  15 There are 4 tables in the GDEF table, each with their own structure:
  16
  17 =over 4
  18
  19 =item GLYPH
  20
  21 This is an L<Font::TTF::Coverage> Class Definition table containing information
  22 as to what type each glyph is.
  23
  24 =item ATTACH
  25
  26 The attach table consists of a coverage table and then attachment points for
  27 each glyph in the coverage table:
  28
  29 =over 8
  30
  31 =item COVERAGE
  32
  33 This is a coverage table
  34
  35 =item POINTS
  36
  37 This is an array of point elements. Each element is an array of curve points
  38 corresponding to the attachment points on that glyph. The order of the curve points
  39 in the array corresponds to the attachment point number specified in the MARKS
  40 coverage table (see below).
  41
  42 =back
  43
  44 =item LIG
  45
  46 This contains the ligature caret positioning information for ligature glyphs
  47
  48 =over 8
  49
  50 =item COVERAGE
  51
  52 A coverage table to say which glyphs are ligatures
  53
  54 =item LIGS
  55
  56 An array of elements for each ligature. Each element is an array of information
  57 for each caret position in the ligature (there being number of components - 1 of
  58 these, generally)
  59
  60 =over 12
  61
  62 =item FMT
  63
  64 This is the format of the information and is important to provide the semantics
  65 for the value. This value must be set correctly before output
  66
  67 =item VAL
  68
  69 The value which has meaning according to FMT
  70
  71 =item DEVICE
  72
  73 For FMT = 3, a device table is also referenced which is stored here
  74
  75 =back
  76
  77 =back
  78
  79 =item MARKS
  80
  81 Due to confusion in the GDEF specification, this field is currently withdrawn until
  82 the confusion is resolved. That way, perhaps this stuff will work!
  83
  84 This class definition table stores the mark attachment point numbers for each
  85 attachment mark, to indicate which attachment point the mark attaches to on its
  86 base glyph.
  87
  88 =back
  89
  90
  91 =head1 METHODS
  92
  93 =cut
  94
  95 use strict;
  96 use Font::TTF::Table;
  97 use Font::TTF::Utils;
  98 use Font::TTF::Ttopen;
  99 use vars qw(@ISA $new_gdef);
 100
 101 @ISA = qw(Font::TTF::Table);
 102 $new_gdef = 1;
 103
 104 =head2 $t->read
 105
 106 Reads the table into the data structure
 107
 108 =cut
 109
 110 sub read
 111 {
 112     my ($self) = @_;
 113     my ($fh) = $self->{' INFILE'};
 114     my ($boff) = $self->{' OFFSET'};
 115     my ($dat, $goff, $loff, $aoff, $moff, $r, $s, $bloc);
 116
 117     $self->SUPER::read or return $self;
 118     $bloc = $fh->tell();
 119     if ($new_gdef)
 120     {
 121         $fh->read($dat, 12);
 122         ($self->{'Version'}, $goff, $aoff, $loff, $moff) = TTF_Unpack('fS4', $dat);
 123     }
 124     else
 125     {
 126         $fh->read($dat, 10);
 127         ($self->{'Version'}, $goff, $aoff, $loff) = TTF_Unpack('fS3', $dat);
 128     }
 129
 130     if ($goff > 0)
 131     {
 132         $fh->seek($goff + $boff, 0);
 133         $self->{'GLYPH'} = Font::TTF::Coverage->new(0)->read($fh);
 134     }
 135
 136     if ($new_gdef && $moff > 0 && $moff < $self->{' LENGTH'})
 137     {
 138         $fh->seek($moff + $boff, 0);
 139         $self->{'MARKS'} = Font::TTF::Coverage->new(0)->read($fh);
 140     }
 141
 142     if ($aoff > 0)
 143     {
 144         my ($off, $gcount, $pcount);
 145
 146         $fh->seek($aoff + $boff, 0);
 147         $fh->read($dat, 4);
 148         ($off, $gcount) = TTF_Unpack('SS', $dat);
 149         $fh->read($dat, $gcount << 1);
 150
 151         $fh->seek($aoff + $boff +  $off, 0);
 152         $self->{'ATTACH'}{'COVERAGE'} = Font::TTF::Coverage->new(1)->read($fh);
 153
 154         foreach $r (TTF_Unpack('S*', $dat))
 155         {
 156             unless ($r)
 157             {
 158                 push (@{$self->{'ATTACH'}{'POINTS'}}, []);
 159                 next;
 160             }
 161             $fh->seek($aoff + $boff + $r, 0);
 162             $fh->read($dat, 2);
 163             $pcount = TTF_Unpack('S', $dat);
 164             $fh->read($dat, $pcount << 1);
 165             push (@{$self->{'ATTACH'}{'POINTS'}}, [TTF_Unpack('S*', $dat)]);
 166         }
 167     }
 168
 169     if ($loff > 0)
 170     {
 171         my ($lcount, $off, $ccount, $srec, $comp);
 172
 173         $fh->seek($loff + $boff, 0);
 174         $fh->read($dat, 4);
 175         ($off, $lcount) = TTF_Unpack('SS', $dat);
 176         $fh->read($dat, $lcount << 1);
 177
 178         $fh->seek($off + $loff + $boff, 0);
 179         $self->{'LIG'}{'COVERAGE'} = Font::TTF::Coverage->new(1)->read($fh);
 180
 181         foreach $r (TTF_Unpack('S*', $dat))
 182         {
 183             $fh->seek($r + $loff + $boff, 0);
 184             $fh->read($dat, 2);
 185             $ccount = TTF_Unpack('S', $dat);
 186             $fh->read($dat, $ccount << 1);
 187
 188             $srec = [];
 189             foreach $s (TTF_Unpack('S*', $dat))
 190             {
 191                 $comp = {};
 192                 $fh->seek($s + $r + $loff + $boff, 0);
 193                 $fh->read($dat, 4);
 194                 ($comp->{'FMT'}, $comp->{'VAL'}) = TTF_Unpack('S*', $dat);
 195                 if ($comp->{'FMT'} == 3)
 196                 {
 197                     $fh->read($dat, 2);
 198                     $off = TTF_Unpack('S', $dat);
 199                     if (defined $self->{' CACHE'}{$off + $s + $r})
 200                     { $comp->{'DEVICE'} = $self->{' CACHE'}{$off + $s + $r}; }
 201                     else
 202                     {
 203                         $fh->seek($off + $s + $r + $loff + $boff, 0);
 204                         $comp->{'DEVICE'} = Font::TTF::Delta->new->read($fh);
 205                         $self->{' CACHE'}{$off + $s + $r} = $comp->{'DEVICE'};
 206                     }
 207                 }
 208                 push (@$srec, $comp);
 209             }
 210             push (@{$self->{'LIG'}{'LIGS'}}, $srec);
 211         }
 212     }
 213
 214     $self;
 215 }
 216
 217
 218 =head2 $t->out($fh)
 219
 220 Writes out this table.
 221
 222 =cut
 223
 224 sub out
 225 {
 226     my ($self, $fh) = @_;
 227     my ($goff, $aoff, $loff, $moff, @offs, $loc1, $coff, $loc);
 228
 229     return $self->SUPER::out($fh) unless $self->{' read'};
 230
 231     $loc = $fh->tell();
 232     if ($new_gdef)
 233     { $fh->print(TTF_Pack('fSSSS', $self->{'Version'}, 0, 0, 0, 0)); }
 234     else
 235     { $fh->print(TTF_Pack('fSSS', $self->{'Version'}, 0, 0, 0)); }
 236
 237     if (defined $self->{'GLYPH'})
 238     {
 239         $goff = $fh->tell() - $loc;
 240         $self->{'GLYPH'}->out($fh);
 241     }
 242
 243     if (defined $self->{'ATTACH'})
 244     {
 245         my ($r);
 246
 247         $aoff = $fh->tell() - $loc;
 248         $fh->print(pack('n*', (0) x ($#{$self->{'ATTACH'}{'POINTS'}} + 3)));
 249         foreach $r (@{$self->{'ATTACH'}{'POINTS'}})
 250         {
 251             push (@offs, $fh->tell() - $loc - $aoff);
 252             $fh->print(pack('n*', $#{$r} + 1, @$r));
 253         }
 254         $coff = $fh->tell() - $loc - $aoff;
 255         $self->{'ATTACH'}{'COVERAGE'}->out($fh);
 256         $loc1 = $fh->tell();
 257         $fh->seek($aoff + $loc, 0);
 258         $fh->print(pack('n*', $coff, $#offs + 1, @offs));
 259         $fh->seek($loc1, 0);
 260     }
 261
 262     if (defined $self->{'LIG'})
 263     {
 264         my (@reftables, $ltables, $i, $j, $out, $r, $s);
 265
 266         $ltables = {};
 267         $loff = $fh->tell() - $loc;
 268         $out = pack('n*',
 269                         Font::TTF::Ttopen::ref_cache($self->{'LIG'}{'COVERAGE'}, $ltables, 0),
 270                         $#{$self->{'LIG'}{'LIGS'}} + 1,
 271                         (0) x ($#{$self->{'LIG'}{'LIGS'}} + 1));
 272         push (@reftables, [$ltables, 0]);
 273         $i = 0;
 274         foreach $r (@{$self->{'LIG'}{'LIGS'}})
 275         {
 276             $ltables = {};
 277             $loc1 = length($out);
 278             substr($out, ($i << 1) + 4, 2) = TTF_Pack('S', $loc1);
 279             $out .= pack('n*', $#{$r} + 1, (0) x ($#{$r} + 1));
 280             @offs = (); $j = 0;
 281             foreach $s (@$r)
 282             {
 283                 substr($out, ($j << 1) + 2 + $loc1, 2) =
 284                         TTF_Pack('S', length($out) - $loc1);
 285                 $out .= TTF_Pack('SS', $s->{'FMT'}, $s->{'VAL'});
 286                 $out .= pack('n', Font::TTF::Ttopen::ref_cache($s->{'DEVICE'},
 287                         $ltables, length($out))) if ($s->{'FMT'} == 3);
 288                 $j++;
 289             }
 290             push (@reftables, [$ltables, $loc1]);
 291             $i++;
 292         }
 293         Font::TTF::Ttopen::out_final($fh, $out, \@reftables);
 294     }
 295
 296     if ($new_gdef && defined $self->{'MARKS'})
 297     {
 298         $moff = $fh->tell() - $loc;
 299         $self->{'MARKS'}->out($fh);
 300     }
 301
 302     $loc1 = $fh->tell();
 303     $fh->seek($loc + 4, 0);
 304     if ($new_gdef)
 305     { $fh->print(TTF_Pack('S4', $goff, $aoff, $loff, $moff)); }
 306     else
 307     { $fh->print(TTF_Pack('S3', $goff, $aoff, $loff)); }
 308     $fh->seek($loc1, 0);
 309     $self;
 310 }
 311
 312 1;
 313