28233cf9161d4c83ced3481404223206b56dd969
[librarian.git] / librarian / font-optimizer / ext / Font-TTF / lib / Font / TTF / Glyph.pm
1 package Font::TTF::Glyph;
2
3 =head1 NAME
4
5 Font::TTF::Glyph - Holds a single glyph's information
6
7 =head1 DESCRIPTION
8
9 This is a single glyph description as held in a TT font. On creation only its
10 header is read. Thus you can get the bounding box of each glyph without having
11 to read all the other information.
12
13 =head1 INSTANCE VARIABLES
14
15 In addition to the named variables in a glyph header (C<xMin> etc.), there are
16 also all capital instance variables for holding working information, mostly
17 from the location table.
18
19 The standard attributes each glyph has are:
20
21  numberOfContours
22  xMin
23  yMin
24  xMax
25  yMax
26
27 There are also other, derived, instance variables for each glyph which are read
28 when the whole glyph is read (via C<read_dat>):
29
30 =over 4
31
32 =item instLen
33
34 Number of bytes in the hinting instructions (Warning this variable is deprecated,
35 use C<length($g->{'hints'})> instead).
36
37 =item hints
38
39 The string containing the hinting code for the glyph
40
41 =back
42
43 In addition there are other attribute like instance variables for simple glyphs:
44
45 =over 4
46
47 For each contour there is:
48
49 =over 4
50
51 =item endPoints
52
53 An array of endpoints for each contour in the glyph. There are
54 C<numberOfContours> contours in a glyph. The number of points in a glyph is
55 equal to the highest endpoint of a contour.
56
57 =back
58
59 There are also a number of arrays indexed by point number
60
61 =over 4
62
63 =item flags
64
65 The flags associated with reading this point. The flags for a point are
66 recalculated for a point when it is C<update>d. Thus the flags are not very
67 useful. The only important bit is bit 0 which indicates whether the point is
68 an 'on' curve point, or an 'off' curve point.
69
70 =item x
71
72 The absolute x co-ordinate of the point.
73
74 =item y
75
76 The absolute y co-ordinate of the point
77
78 =back
79
80 =back
81
82 For composite glyphs there are other variables
83
84 =over 4
85
86 =item metric
87
88 This holds the component number (not its glyph number) of the component from
89 which the metrics for this glyph should be taken.
90
91 =item comps
92
93 This is an array of hashes for each component. Each hash has a number of
94 elements:
95
96 =over 4
97
98 =item glyph
99
100 The glyph number of the glyph which comprises this component of the composite.
101 NOTE: In some badly generated fonts, C<glyph> may contain a numerical value
102 but that glyph might not actually exist in the font file.  This could
103 occur in any glyph, but is particularly likely for glyphs that have
104 no strokes, such as SPACE, U+00A0 NO-BREAK SPACE, or 
105 U+200B ZERO WIDTH SPACE.
106
107 =item args
108
109 An array of two arguments which may be an x, y co-ordinate or two attachment
110 points (one on the base glyph the other on the component). See flags for details.
111
112 =item flag
113
114 The flag for this component
115
116 =item scale
117
118 A 4 number array for component scaling. This allows stretching, rotating, etc.
119 Note that scaling applies to placement co-ordinates (rather than attachment points)
120 before locating rather than after.
121
122 =back
123
124 =item numPoints
125
126 This is a generated value which contains the number of components read in for this
127 compound glyph.
128
129 =back
130
131 The private instance variables are:
132
133 =over 4
134
135 =item INFILE (P)
136
137 The input file form which to read any information
138
139 =item LOC (P)
140
141 Location relative to the start of the glyf table in the read file
142
143 =item BASE (P)
144
145 The location of the glyf table in the read file
146
147 =item LEN (P)
148
149 This is the number of bytes required by the glyph. It should be kept up to date
150 by calling the C<update> method whenever any of the glyph content changes.
151
152 =item OUTLOC (P)
153
154 Location relative to the start of the glyf table. This variable is only active
155 whilst the output process is going on. It is used to inform the location table
156 where the glyph's location is, since the glyf table is output before the loca
157 table due to alphabetical ordering.
158
159 =item OUTLEN (P)
160
161 This indicates the length of the glyph data when it is output. This more
162 accurately reflects the internal memory form than the C<LEN> variable which
163 only reflects the read file length. The C<OUTLEN> variable is only set after
164 calling C<out> or C<out_dat>.
165
166 =back
167
168 =head2 Editing
169
170 If you want to edit a glyph in some way, then you should read_dat the glyph, then
171 make your changes and then update the glyph or set the $g->{' isdirty'} variable.
172 It is the application's duty to ensure that the following instance variables are
173 correct, from which update will calculate the rest, including the bounding box
174 information.
175
176     numPoints
177     numberOfContours
178     endPoints
179     x, y, flags         (only flags bit 0)
180     instLen
181     hints
182
183 For components, the numPoints, x, y, endPoints & flags are not required but
184 the following information is required for each component.
185
186     flag                (bits 2, 10, 11, 12)
187     glyph
188     args
189     scale
190     metric              (glyph instance variable)
191     
192
193 =head1 METHODS
194
195 =cut
196
197 use strict;
198 use vars qw(%fields @field_info);
199 use Font::TTF::Utils;
200 use Font::TTF::Table;
201
202 @field_info = (
203     'numberOfContours' => 's', 
204     'xMin' => 's', 
205     'yMin' => 's',
206     'xMax' => 's',
207     'yMax' => 's');
208
209 sub init
210 {
211     my ($k, $v, $c, $i);
212     for ($i = 0; $i < $#field_info; $i += 2)
213     {
214         ($k, $v, $c) = TTF_Init_Fields($field_info[$i], $c, $field_info[$i + 1]);
215         next unless defined $k && $k ne "";
216         $fields{$k} = $v;
217     }
218 }
219
220
221 =head1 Font::TTF::Glyph->new(%parms)
222
223 Creates a new glyph setting various instance variables
224
225 =cut
226
227 sub new
228 {
229     my ($class, %parms) = @_;
230     my ($self) = {};
231     my ($p);
232
233     bless $self, $class;
234     foreach $p (keys %parms)
235     { $self->{" $p"} = $parms{$p}; }
236     init unless defined $fields{'xMin'};
237     $self;
238 }
239
240
241 =head2 $g->read
242
243 Reads the header component of the glyph (bounding box, etc.) and also the
244 glyph content, but into a data field rather than breaking it down into
245 its constituent structures. Use read_dat for this.
246
247 =cut
248
249 sub read
250 {
251     my ($self) = @_;
252     my ($fh) = $self->{' INFILE'};
253     my ($dat);
254
255     return $self if $self->{' read'};
256     $self->{' read'} = 1;
257     $fh->seek($self->{' LOC'} + $self->{' BASE'}, 0);
258     $fh->read($self->{' DAT'}, $self->{' LEN'});
259     TTF_Read_Fields($self, $self->{' DAT'}, \%fields);
260     $self;
261 }
262
263
264 =head2 $g->read_dat
265
266 Reads the contents of the glyph (components and curves, etc.) from the memory
267 store C<DAT> into structures within the object. Then, to indicate where the
268 master form of the data is, it deletes the C<DAT> instance variable.
269
270 =cut
271
272 sub read_dat
273 {
274     my ($self) = @_;
275     my ($dat, $num, $max, $i, $flag, $len, $val, $val1, $fp);
276
277     return $self if (defined $self->{' read'} && $self->{' read'} > 1);
278     $self->read unless $self->{' read'};
279     $dat = $self->{' DAT'};
280     $fp = 10;
281     $num = $self->{'numberOfContours'};
282     if ($num > 0)
283     {
284         $self->{'endPoints'} = [unpack("n*", substr($dat, $fp, $num << 1))];
285         $fp += $num << 1;
286         $max = 0;
287         foreach (@{$self->{'endPoints'}})
288         { $max = $_ if $_ > $max; }
289 #        print STDERR join(",", unpack('C*', $self->{" DAT"}));
290 #        printf STDERR ("(%d,%d in %d=%d @ %d)", scalar @{$self->{'endPoints'}}, $max, length($dat), $self->{' LEN'}, $fp);
291         $max++ if (@{$self->{'endPoints'}});
292         $self->{'numPoints'} = $max;
293         $self->{'instLen'} = unpack("n", substr($dat, $fp));
294         $self->{'hints'} = substr($dat, $fp + 2, $self->{'instLen'});
295         $fp += 2 + $self->{'instLen'};
296 # read the flags array
297         for ($i = 0; $i < $max; $i++)                   
298         {
299             $flag = unpack("C", substr($dat, $fp++));
300             $self->{'flags'}[$i] = $flag;
301             if ($flag & 8)
302             {
303                 $len = unpack("C", substr($dat, $fp++));
304                 while ($len-- > 0)
305                 {
306                     $i++;
307                     $self->{'flags'}[$i] = $flag;
308                 }
309             }
310         }
311 #read the x array
312         for ($i = 0; $i < $max; $i++)
313         {
314             $flag = $self->{'flags'}[$i];
315             if ($flag & 2)
316             {
317                 $val = unpack("C", substr($dat, $fp++));
318                 $val = -$val unless ($flag & 16);
319             } elsif ($flag & 16)
320             { $val = 0; }
321             else
322             {
323                 $val = TTF_Unpack("s", substr($dat, $fp));
324                 $fp += 2;
325             }
326             $self->{'x'}[$i] = $i == 0 ? $val : $self->{'x'}[$i - 1] + $val;
327         }
328 #read the y array
329         for ($i = 0; $i < $max; $i++)
330         {
331             $flag = $self->{'flags'}[$i];
332             if ($flag & 4)
333             {
334                 $val = unpack("C", substr($dat, $fp++));
335                 $val = -$val unless ($flag & 32);
336             } elsif ($flag & 32)
337             { $val = 0; }
338             else
339             {
340                 $val = TTF_Unpack("s", substr($dat, $fp));
341                 $fp += 2;
342             }
343             $self->{'y'}[$i] = $i == 0 ? $val : $self->{'y'}[$i - 1] + $val;
344         }
345     }
346     
347 # compound glyph
348     elsif ($num < 0)
349     {
350         $flag = 1 << 5;             # cheat to get the loop going
351         for ($i = 0; $flag & 32; $i++)
352         {
353             ($flag, $self->{'comps'}[$i]{'glyph'}) = unpack("n2", substr($dat, $fp));
354             $fp += 4;
355             $self->{'comps'}[$i]{'flag'} = $flag;
356             if ($flag & 1)              # ARGS1_AND_2_ARE_WORDS
357             {
358                 $self->{'comps'}[$i]{'args'} = [TTF_Unpack("s2", substr($dat, $fp))];
359                 $fp += 4;
360             } else
361             {
362                 $self->{'comps'}[$i]{'args'} = [unpack("c2", substr($dat, $fp))];
363                 $fp += 2;
364             }
365             
366             if ($flag & 8)
367             {
368                 $val = TTF_Unpack("F", substr($dat, $fp));
369                 $fp += 2;
370                 $self->{'comps'}[$i]{'scale'} = [$val, 0, 0, $val];
371             } elsif ($flag & 64)
372             {
373                 ($val, $val1) = TTF_Unpack("F2", substr($dat, $fp));
374                 $fp += 4;
375                 $self->{'comps'}[$i]{'scale'} = [$val, 0, 0, $val1];
376             } elsif ($flag & 128)
377             {
378                 $self->{'comps'}[$i]{'scale'} = [TTF_Unpack("F4", substr($dat, $fp))];
379                 $fp += 8;
380             }
381             $self->{'metric'} = $i if ($flag & 512);
382         }
383         $self->{'numPoints'} = $i;
384         if ($flag & 256)            # HAVE_INSTRUCTIONS
385         {
386             $self->{'instLen'} = unpack("n", substr($dat, $fp));
387             $self->{'hints'} = substr($dat, $fp + 2, $self->{'instLen'});
388             $fp += 2 + $self->{'instLen'};
389         }
390     }
391     return undef if ($fp > length($dat));
392     $self->{' read'} = 2;
393     $self;
394 }
395
396
397 =head2 $g->out($fh)
398
399 Writes the glyph data to outfile
400
401 =cut
402
403 sub out
404 {
405     my ($self, $fh) = @_;
406
407     $self->read unless $self->{' read'};
408     $self->update if $self->{' isDirty'};
409     $fh->print($self->{' DAT'});
410     $self->{' OUTLEN'} = length($self->{' DAT'});
411     $self;
412 }
413
414
415 =head2 $g->out_xml($context, $depth)
416
417 Outputs an XML description of the glyph
418
419 =cut
420
421 sub out_xml
422 {
423     my ($self, $context, $depth) = @_;
424     my ($addr) = ($self =~ m/\((.+)\)$/o);
425     my ($k, $ndepth);
426
427     if ($context->{'addresses'}{$addr})
428     {
429         $context->{'fh'}->printf("%s<glyph gid='%s' id_ref='%s'/>\n", $depth, $context->{'gid'}, $addr);
430         return $self;
431     }
432     else
433     {
434         $context->{'fh'}->printf("%s<glyph gid='%s' id='%s'>\n", $depth, $context->{'gid'}, $addr);
435     }
436     
437     $ndepth = $depth . $context->{'indent'};
438     $self->read_dat;
439     foreach $k (sort grep {$_ !~ m/^\s/o} keys %{$self})
440     {
441         $self->XML_element($context, $ndepth, $k, $self->{$k});
442     }
443     $context->{'fh'}->print("$depth</glyph>\n");
444     delete $context->{'done_points'};
445     $self;
446 }
447     
448
449 sub XML_element
450 {
451     my ($self, $context, $depth, $key, $val) = @_;
452     my ($fh) = $context->{'fh'};
453     my ($dind) = $depth . $context->{'indent'};
454     my ($i);
455     
456     if ($self->{'numberOfContours'} >= 0 && ($key eq 'x' || $key eq 'y' || $key eq 'flags'))
457     {
458         return $self if ($context->{'done_points'});
459         $context->{'done_points'} = 1;
460
461         $fh->print("$depth<points>\n");
462         for ($i = 0; $i <= $#{$self->{'flags'}}; $i++)
463         { $fh->printf("%s<point x='%s' y='%s' flags='0x%02X'/>\n", $dind,
464                 $self->{'x'}[$i], $self->{'y'}[$i], $self->{'flags'}[$i]); }
465         $fh->print("$depth</points>\n");
466     }
467     elsif ($key eq 'hints')
468     {
469         my ($dat);
470         $fh->print("$depth<hints>\n");
471 #        Font::TTF::Utils::XML_hexdump($context, $depth . $context->{'indent'}, $self->{'hints'});
472         $dat = Font::TTF::Utils::XML_binhint($self->{'hints'}) || "";
473         $dat =~ s/\n(?!$)/\n$depth$context->{'indent'}/mg;
474         $fh->print("$depth$context->{'indent'}$dat");
475         $fh->print("$depth</hints>\n");
476     }
477     else
478     { return Font::TTF::Table::XML_element(@_); }
479
480     $self;    
481 }
482
483
484 =head2 $g->update
485
486 Generates a C<$self->{'DAT'}> from the internal structures, if the data has
487 been read into structures in the first place. If you are building a glyph
488 from scratch you will need to set the instance variable C<' read'> to 2 (or
489 something > 1) for the update to work.
490
491 =cut
492
493 sub update
494 {
495     my ($self) = @_;
496     my ($dat, $loc, $len, $flag, $x, $y, $i, $comp, $num);
497
498     return $self unless (defined $self->{' read'} && $self->{' read'} > 1);
499     $self->update_bbox;
500     $self->{' DAT'} = TTF_Out_Fields($self, \%fields, 10);
501     $num = $self->{'numberOfContours'};
502     if ($num > 0)
503     {
504         $self->{' DAT'} .= pack("n*", @{$self->{'endPoints'}});
505         $len = $self->{'instLen'};
506         $self->{' DAT'} .= pack("n", $len);
507         $self->{' DAT'} .= pack("a" . $len, substr($self->{'hints'}, 0, $len)) if ($len > 0);
508         for ($i = 0; $i < $self->{'numPoints'}; $i++)
509         {
510             $flag = $self->{'flags'}[$i] & 1;
511             if ($i == 0)
512             {
513                 $x = $self->{'x'}[$i];
514                 $y = $self->{'y'}[$i];
515             } else
516             {
517                 $x = $self->{'x'}[$i] - $self->{'x'}[$i - 1];
518                 $y = $self->{'y'}[$i] - $self->{'y'}[$i - 1];
519             }
520             $flag |= 16 if ($x == 0);
521             $flag |= 32 if ($y == 0);
522             if (($flag & 16) == 0 && $x < 256 && $x > -256)
523             {
524                 $flag |= 2;
525                 $flag |= 16 if ($x >= 0);
526             }
527             if (($flag & 32) == 0 && $y < 256 && $y > -256)
528             {
529                 $flag |= 4;
530                 $flag |= 32 if ($y >= 0);
531             }
532             $self->{' DAT'} .= pack("C", $flag);                    # sorry no repeats
533             $self->{'flags'}[$i] = $flag;
534         }
535         for ($i = 0; $i < $self->{'numPoints'}; $i++)
536         {
537             $flag = $self->{'flags'}[$i];
538             $x = $self->{'x'}[$i] - (($i == 0) ? 0 : $self->{'x'}[$i - 1]);
539             if (($flag & 18) == 0)
540             { $self->{' DAT'} .= TTF_Pack("s", $x); }
541             elsif (($flag & 18) == 18)
542             { $self->{' DAT'} .= pack("C", $x); }
543             elsif (($flag & 18) == 2)
544             { $self->{' DAT'} .= pack("C", -$x); }
545         }
546         for ($i = 0; $i < $self->{'numPoints'}; $i++)
547         {
548             $flag = $self->{'flags'}[$i];
549             $y = $self->{'y'}[$i] - (($i == 0) ? 0 : $self->{'y'}[$i - 1]);
550             if (($flag & 36) == 0)
551             { $self->{' DAT'} .= TTF_Pack("s", $y); }
552             elsif (($flag & 36) == 36)
553             { $self->{' DAT'} .= pack("C", $y); }
554             elsif (($flag & 36) == 4)
555             { $self->{' DAT'} .= pack("C", -$y); }
556         }
557     }
558
559     elsif ($num < 0)
560     {
561         for ($i = 0; $i <= $#{$self->{'comps'}}; $i++)
562         {
563             $comp = $self->{'comps'}[$i];
564             $flag = $comp->{'flag'} & 7158;        # bits 2,10,11,12
565             $flag |= 1 unless ($comp->{'args'}[0] > -129 && $comp->{'args'}[0] < 128
566                     && $comp->{'args'}[1] > -129 && $comp->{'args'}[1] < 128);
567             if (defined $comp->{'scale'})
568             {
569                 if ($comp->{'scale'}[1] == 0 && $comp->{'scale'}[2] == 0)
570                 {
571                     if ($comp->{'scale'}[0] == $comp->{'scale'}[3])
572                     { $flag |= 8 unless ($comp->{'scale'}[0] == 0
573                                     || $comp->{'scale'}[0] == 1); }
574                     else
575                     { $flag |= 64; }
576                 } else
577                 { $flag |= 128; }
578             }
579             
580             $flag |= 512 if (defined $self->{'metric'} && $self->{'metric'} == $i);
581             if ($i == $#{$self->{'comps'}})
582             { $flag |= 256 if (defined $self->{'instLen'} && $self->{'instLen'} > 0); }
583             else
584             { $flag |= 32; }
585             
586             $self->{' DAT'} .= pack("n", $flag);
587             $self->{' DAT'} .= pack("n", $comp->{'glyph'});
588             $comp->{'flag'} = $flag;
589
590             if ($flag & 1)
591             { $self->{' DAT'} .= TTF_Pack("s2", @{$comp->{'args'}}); }
592             else
593             { $self->{' DAT'} .= pack("CC", @{$comp->{'args'}}); }
594
595             if ($flag & 8)
596             { $self->{' DAT'} .= TTF_Pack("F", $comp->{'scale'}[0]); }
597             elsif ($flag & 64)
598             { $self->{' DAT'} .= TTF_Pack("F2", $comp->{'scale'}[0], $comp->{'scale'}[3]); }
599             elsif ($flag & 128)
600             { $self->{' DAT'} .= TTF_Pack("F4", @{$comp->{'scale'}}); }
601         }
602         if (defined $self->{'instLen'} && $self->{'instLen'} > 0)
603         {
604             $len = $self->{'instLen'};
605             $self->{' DAT'} .= pack("n", $len);
606             $self->{' DAT'} .= pack("a" . $len, substr($self->{'hints'}, 0, $len));
607         }
608     }
609     my ($olen) = length($self->{' DAT'});
610     $self->{' DAT'} .= ("\000") x (4 - ($olen & 3)) if ($olen & 3);
611     $self->{' OUTLEN'} = length($self->{' DAT'});
612     $self->{' read'} = 2;           # changed from 1 to 2 so we don't read_dat() again
613 # we leave numPoints and instLen since maxp stats use this
614     $self;
615 }
616
617
618 =head2 $g->update_bbox
619
620 Updates the bounding box for this glyph according to the points in the glyph
621
622 =cut
623
624 sub update_bbox
625 {
626     my ($self) = @_;
627     my ($num, $maxx, $minx, $maxy, $miny, $i, $comp, $x, $y, $compg);
628
629     return $self unless $self->{' read'} > 1;       # only if read_dat done
630     $miny = $minx = 65537; $maxx = $maxy = -65537;
631     $num = $self->{'numberOfContours'};
632     if ($num > 0)
633     {
634         for ($i = 0; $i < $self->{'numPoints'}; $i++)
635         {
636             ($x, $y) = ($self->{'x'}[$i], $self->{'y'}[$i]);
637
638             $maxx = $x if ($x > $maxx);
639             $minx = $x if ($x < $minx);
640             $maxy = $y if ($y > $maxy);
641             $miny = $y if ($y < $miny);
642         }
643     }
644
645     elsif ($num < 0)
646     {
647         foreach $comp (@{$self->{'comps'}})
648         {
649             my ($gnx, $gny, $gxx, $gxy);
650             my ($sxx, $sxy, $syx, $syy);
651             
652             my $otherg = $self->{' PARENT'}{'loca'}{'glyphs'}[$comp->{'glyph'}];
653             # work around bad fonts: see documentation for 'comps' above
654             next unless (defined $otherg);
655             $compg = $otherg->read->update_bbox;
656             ($gnx, $gny, $gxx, $gxy) = @{$compg}{'xMin', 'yMin', 'xMax', 'yMax'};
657             if (defined $comp->{'scale'})
658             {
659                 ($sxx, $sxy, $syx, $syy) = @{$comp->{'scale'}};
660                 ($gnx, $gny, $gxx, $gxy) = ($gnx*$sxx+$gny*$syx + $comp->{'args'}[0],
661                                             $gnx*$sxy+$gny*$syy + $comp->{'args'}[1],
662                                             $gxx*$sxx+$gxy*$syx + $comp->{'args'}[0],
663                                             $gxx*$sxy+$gxy*$syy + $comp->{'args'}[1]);
664             } elsif ($comp->{'args'}[0] || $comp->{'args'}[1])
665             {
666                 $gnx += $comp->{'args'}[0];
667                 $gny += $comp->{'args'}[1];
668                 $gxx += $comp->{'args'}[0];
669                 $gxy += $comp->{'args'}[1];
670             }
671             ($gnx, $gxx) = ($gxx, $gnx) if $gnx > $gxx;
672             ($gny, $gxy) = ($gxy, $gny) if $gny > $gxy;
673             $maxx = $gxx if $gxx > $maxx;
674             $minx = $gnx if $gnx < $minx;
675             $maxy = $gxy if $gxy > $maxy;
676             $miny = $gny if $gny < $miny;
677         }
678     }
679     $self->{'xMax'} = $maxx;
680     $self->{'xMin'} = $minx;
681     $self->{'yMax'} = $maxy;
682     $self->{'yMin'} = $miny;
683     $self;
684 }
685
686             
687 =head2 $g->maxInfo
688
689 Returns lots of information about a glyph so that the C<maxp> table can update
690 itself. Returns array containing contributions of this glyph to maxPoints, maxContours, 
691 maxCompositePoints, maxCompositeContours, maxSizeOfInstructions, maxComponentElements, 
692 and maxComponentDepth.
693
694 =cut
695
696 sub maxInfo
697 {
698     my ($self) = @_;
699     my (@res, $i, @n);
700
701     $self->read_dat;            # make sure we've read some data
702     $res[4] = length($self->{'hints'}) if defined $self->{'hints'};
703     $res[6] = 1;
704     if ($self->{'numberOfContours'} > 0)
705     {
706         $res[0] = $self->{'numPoints'};
707         $res[1] = $self->{'numberOfContours'};
708     } elsif ($self->{'numberOfContours'} < 0)
709     {
710         for ($i = 0; $i <= $#{$self->{'comps'}}; $i++)
711         {
712             my $otherg = 
713                 $self->{' PARENT'}{'loca'}{'glyphs'}
714                     [$self->{'comps'}[$i]{'glyph'}];
715             
716             # work around bad fonts: see documentation for 'comps' above
717             next unless (defined $otherg );
718             
719             @n = $otherg->maxInfo;
720
721             $res[2] += $n[2] == 0 ? $n[0] : $n[2];
722             $res[3] += $n[3] == 0 ? $n[1] : $n[3];
723             $res[5]++;
724             $res[6] = $n[6] + 1 if ($n[6] >= $res[6]);
725         }
726     }
727     @res;
728 }
729
730 =head2 $g->empty
731
732 Empties the glyph of all information to the level of not having been read.
733 Useful for saving memory in apps with many glyphs being read
734
735 =cut
736
737 sub empty
738 {
739     my ($self) = @_;
740     my (%keep) = map {(" $_" => 1)} ('LOC', 'OUTLOC', 'PARENT', 'INFILE', 'BASE',
741                                 'OUTLEN', 'LEN');
742     map {delete $self->{$_} unless $keep{$_}} keys %$self;
743     
744     $self;
745 }
746
747
748 =head2 $g->get_points
749
750 This method creates point information for a compound glyph. The information is
751 stored in the same place as if the glyph was not a compound, but since
752 numberOfContours is negative, the glyph is still marked as being a compound
753
754 =cut
755
756 sub get_points
757 {
758     my ($self) = @_;
759     my ($comp, $compg, $nump, $e, $i);
760
761     $self->read_dat;
762     return undef unless ($self->{'numberOfContours'} < 0);
763
764     foreach $comp (@{$self->{'comps'}})
765     {
766         $compg = $self->{' PARENT'}{'loca'}{'glyphs'}[$comp->{'glyph'}];
767         # work around bad fonts: see documentation for 'comps' above
768         next unless (defined $compg );
769         $compg->get_points;
770
771         for ($i = 0; $i < $compg->{'numPoints'}; $i++)
772         {
773             my ($x, $y) = ($compg->{'x'}[$i], $compg->{'y'}[$i]);
774             if (defined $comp->{'scale'})
775             {
776                 ($x, $y) = ($x * $comp->{'scale'}[0] + $y * $comp->{'scale'}[2],
777                             $x * $comp->{'scale'}[1] + $y * $comp->{'scale'}[3]);
778             }
779             if (defined $comp->{'args'})
780             { ($x, $y) = ($x + $comp->{'args'}[0], $y + $comp->{'args'}[1]); }
781             push (@{$self->{'x'}}, $x);
782             push (@{$self->{'y'}}, $y);
783             push (@{$self->{'flags'}}, $compg->{'flags'}[$i]);
784         }
785         foreach $e (@{$compg->{'endPoints'}})
786         { push (@{$self->{'endPoints'}}, $e + $nump); }
787         $nump += $compg->{'numPoints'};
788     }
789     $self->{'numPoints'} = $nump;
790     $self;
791 }
792
793
794 =head2 $g->get_refs
795
796 Returns an array of all the glyph ids that are used to make up this glyph. That
797 is all the compounds and their references and so on. If this glyph is not a
798 compound, then returns an empty array.
799
800 Please note the warning about bad fonts that reference nonexistant glyphs
801 under INSTANCE VARIABLES above.  This function will not attempt to 
802 filter out nonexistant glyph numbers.
803
804 =cut
805
806 sub get_refs
807 {
808     my ($self) = @_;
809     my (@res, $g);
810
811     $self->read_dat;
812     return unless ($self->{'numberOfContours'} < 0);
813     foreach $g (@{$self->{'comps'}})
814     {
815         push (@res, $g->{'glyph'});
816         my $otherg = $self->{' PARENT'}{'loca'}{'glyphs'}[$g->{'glyph'}];
817         # work around bad fonts: see documentation for 'comps' above
818         next unless (defined $otherg);
819         my @list = $otherg->get_refs;
820         push(@res, @list);
821     }
822     return @res;
823 }
824
825 1;
826
827 =head1 BUGS
828
829 =over 4
830
831 =item *
832
833 The instance variables used here are somewhat clunky and inconsistent with
834 the other tables.
835
836 =item *
837
838 C<update> doesn't re-calculate the bounding box or C<numberOfContours>.
839
840 =back
841
842 =head1 AUTHOR
843
844 Martin Hosken Martin_Hosken@sil.org. See L<Font::TTF::Font> for copyright and
845 licensing.
846
847 =cut