subset.py revision 98769437cdd2c04f14b81a80dd4aa45e3d9f282c 
1# Copyright 2013 Google, Inc. All Rights Reserved.
2#
3# Google Author(s): Behdad Esfahbod
4
5"""Python OpenType Layout Subsetter.
6
7Later grown into full OpenType subsetter, supporting all standard tables.
8"""
9
10import sys
11import struct
12import time
13import array
14
15from fontTools import ttLib
16from fontTools.ttLib.tables import otTables
17from fontTools.misc import psCharStrings
18from fontTools.pens import basePen
19
20
21def _add_method(*clazzes):
22  """Returns a decorator function that adds a new method to one or
23  more classes."""
24  def wrapper(method):
25    for clazz in clazzes:
26      assert clazz.__name__ != 'DefaultTable', 'Oops, table class not found.'
27      assert not hasattr(clazz, method.func_name), \
28          "Oops, class '%s' has method '%s'." % (clazz.__name__,
29                                                 method.func_name)
30      setattr(clazz, method.func_name, method)
31    return None
32  return wrapper
33
34def _uniq_sort(l):
35  return sorted(set(l))
36
37def _set_update(s, *others):
38  # Jython's set.update only takes one other argument.
39  # Emulate real set.update...
40  for other in others:
41    s.update(other)
42
43
44@_add_method(otTables.Coverage)
45def intersect(self, glyphs):
46  "Returns ascending list of matching coverage values."
47  return [i for i,g in enumerate(self.glyphs) if g in glyphs]
48
49@_add_method(otTables.Coverage)
50def intersect_glyphs(self, glyphs):
51  "Returns set of intersecting glyphs."
52  return set(g for g in self.glyphs if g in glyphs)
53
54@_add_method(otTables.Coverage)
55def subset(self, glyphs):
56  "Returns ascending list of remaining coverage values."
57  indices = self.intersect(glyphs)
58  self.glyphs = [g for g in self.glyphs if g in glyphs]
59  return indices
60
61@_add_method(otTables.Coverage)
62def remap(self, coverage_map):
63  "Remaps coverage."
64  self.glyphs = [self.glyphs[i] for i in coverage_map]
65
66@_add_method(otTables.ClassDef)
67def intersect(self, glyphs):
68  "Returns ascending list of matching class values."
69  return _uniq_sort(
70     ([0] if any(g not in self.classDefs for g in glyphs) else []) +
71      [v for g,v in self.classDefs.iteritems() if g in glyphs])
72
73@_add_method(otTables.ClassDef)
74def intersect_class(self, glyphs, klass):
75  "Returns set of glyphs matching class."
76  if klass == 0:
77    return set(g for g in glyphs if g not in self.classDefs)
78  return set(g for g,v in self.classDefs.iteritems()
79              if v == klass and g in glyphs)
80
81@_add_method(otTables.ClassDef)
82def subset(self, glyphs, remap=False):
83  "Returns ascending list of remaining classes."
84  self.classDefs = dict((g,v) for g,v in self.classDefs.iteritems() if g in glyphs)
85  # Note: while class 0 has the special meaning of "not matched",
86  # if no glyph will ever /not match/, we can optimize class 0 out too.
87  indices = _uniq_sort(
88     ([0] if any(g not in self.classDefs for g in glyphs) else []) +
89      self.classDefs.values())
90  if remap:
91    self.remap(indices)
92  return indices
93
94@_add_method(otTables.ClassDef)
95def remap(self, class_map):
96  "Remaps classes."
97  self.classDefs = dict((g,class_map.index(v))
98                         for g,v in self.classDefs.iteritems())
99
100@_add_method(otTables.SingleSubst)
101def closure_glyphs(self, s, cur_glyphs=None):
102  if cur_glyphs == None: cur_glyphs = s.glyphs
103  if self.Format in [1, 2]:
104    s.glyphs.update(v for g,v in self.mapping.iteritems() if g in cur_glyphs)
105  else:
106    assert 0, "unknown format: %s" % self.Format
107
108@_add_method(otTables.SingleSubst)
109def subset_glyphs(self, s):
110  if self.Format in [1, 2]:
111    self.mapping = dict((g,v) for g,v in self.mapping.iteritems()
112                        if g in s.glyphs and v in s.glyphs)
113    return bool(self.mapping)
114  else:
115    assert 0, "unknown format: %s" % self.Format
116
117@_add_method(otTables.MultipleSubst)
118def closure_glyphs(self, s, cur_glyphs=None):
119  if cur_glyphs == None: cur_glyphs = s.glyphs
120  if self.Format == 1:
121    indices = self.Coverage.intersect(cur_glyphs)
122    _set_update(s.glyphs, *(self.Sequence[i].Substitute for i in indices))
123  else:
124    assert 0, "unknown format: %s" % self.Format
125
126@_add_method(otTables.MultipleSubst)
127def subset_glyphs(self, s):
128  if self.Format == 1:
129    indices = self.Coverage.subset(s.glyphs)
130    self.Sequence = [self.Sequence[i] for i in indices]
131    # Now drop rules generating glyphs we don't want
132    indices = [i for i,seq in enumerate(self.Sequence)
133         if all(sub in s.glyphs for sub in seq.Substitute)]
134    self.Sequence = [self.Sequence[i] for i in indices]
135    self.Coverage.remap(indices)
136    self.SequenceCount = len(self.Sequence)
137    return bool(self.SequenceCount)
138  else:
139    assert 0, "unknown format: %s" % self.Format
140
141@_add_method(otTables.AlternateSubst)
142def closure_glyphs(self, s, cur_glyphs=None):
143  if cur_glyphs == None: cur_glyphs = s.glyphs
144  if self.Format == 1:
145    _set_update(s.glyphs, *(vlist for g,vlist in self.alternates.iteritems()
146                            if g in cur_glyphs))
147  else:
148    assert 0, "unknown format: %s" % self.Format
149
150@_add_method(otTables.AlternateSubst)
151def subset_glyphs(self, s):
152  if self.Format == 1:
153    self.alternates = dict((g,vlist)
154                           for g,vlist in self.alternates.iteritems()
155                           if g in s.glyphs and
156                              all(v in s.glyphs for v in vlist))
157    return bool(self.alternates)
158  else:
159    assert 0, "unknown format: %s" % self.Format
160
161@_add_method(otTables.LigatureSubst)
162def closure_glyphs(self, s, cur_glyphs=None):
163  if cur_glyphs == None: cur_glyphs = s.glyphs
164  if self.Format == 1:
165    _set_update(s.glyphs, *([seq.LigGlyph for seq in seqs
166                             if all(c in s.glyphs for c in seq.Component)]
167                            for g,seqs in self.ligatures.iteritems()
168                            if g in cur_glyphs))
169  else:
170    assert 0, "unknown format: %s" % self.Format
171
172@_add_method(otTables.LigatureSubst)
173def subset_glyphs(self, s):
174  if self.Format == 1:
175    self.ligatures = dict((g,v) for g,v in self.ligatures.iteritems()
176                          if g in s.glyphs)
177    self.ligatures = dict((g,[seq for seq in seqs
178                              if seq.LigGlyph in s.glyphs and
179                                 all(c in s.glyphs for c in seq.Component)])
180                           for g,seqs in self.ligatures.iteritems())
181    self.ligatures = dict((g,v) for g,v in self.ligatures.iteritems() if v)
182    return bool(self.ligatures)
183  else:
184    assert 0, "unknown format: %s" % self.Format
185
186@_add_method(otTables.ReverseChainSingleSubst)
187def closure_glyphs(self, s, cur_glyphs=None):
188  if cur_glyphs == None: cur_glyphs = s.glyphs
189  if self.Format == 1:
190    indices = self.Coverage.intersect(cur_glyphs)
191    if(not indices or
192        not all(c.intersect(s.glyphs)
193                 for c in self.LookAheadCoverage + self.BacktrackCoverage)):
194      return
195    s.glyphs.update(self.Substitute[i] for i in indices)
196  else:
197    assert 0, "unknown format: %s" % self.Format
198
199@_add_method(otTables.ReverseChainSingleSubst)
200def subset_glyphs(self, s):
201  if self.Format == 1:
202    indices = self.Coverage.subset(s.glyphs)
203    self.Substitute = [self.Substitute[i] for i in indices]
204    # Now drop rules generating glyphs we don't want
205    indices = [i for i,sub in enumerate(self.Substitute)
206         if sub in s.glyphs]
207    self.Substitute = [self.Substitute[i] for i in indices]
208    self.Coverage.remap(indices)
209    self.GlyphCount = len(self.Substitute)
210    return bool(self.GlyphCount and
211                 all(c.subset(s.glyphs)
212                      for c in self.LookAheadCoverage+self.BacktrackCoverage))
213  else:
214    assert 0, "unknown format: %s" % self.Format
215
216@_add_method(otTables.SinglePos)
217def subset_glyphs(self, s):
218  if self.Format == 1:
219    return len(self.Coverage.subset(s.glyphs))
220  elif self.Format == 2:
221    indices = self.Coverage.subset(s.glyphs)
222    self.Value = [self.Value[i] for i in indices]
223    self.ValueCount = len(self.Value)
224    return bool(self.ValueCount)
225  else:
226    assert 0, "unknown format: %s" % self.Format
227
228@_add_method(otTables.SinglePos)
229def prune_post_subset(self, options):
230  if not options.hinting:
231    # Drop device tables
232    self.ValueFormat &= ~0x00F0
233  return True
234
235@_add_method(otTables.PairPos)
236def subset_glyphs(self, s):
237  if self.Format == 1:
238    indices = self.Coverage.subset(s.glyphs)
239    self.PairSet = [self.PairSet[i] for i in indices]
240    for p in self.PairSet:
241      p.PairValueRecord = [r for r in p.PairValueRecord
242                           if r.SecondGlyph in s.glyphs]
243      p.PairValueCount = len(p.PairValueRecord)
244    self.PairSet = [p for p in self.PairSet if p.PairValueCount]
245    self.PairSetCount = len(self.PairSet)
246    return bool(self.PairSetCount)
247  elif self.Format == 2:
248    class1_map = self.ClassDef1.subset(s.glyphs, remap=True)
249    class2_map = self.ClassDef2.subset(s.glyphs, remap=True)
250    self.Class1Record = [self.Class1Record[i] for i in class1_map]
251    for c in self.Class1Record:
252      c.Class2Record = [c.Class2Record[i] for i in class2_map]
253    self.Class1Count = len(class1_map)
254    self.Class2Count = len(class2_map)
255    return bool(self.Class1Count and
256                 self.Class2Count and
257                 self.Coverage.subset(s.glyphs))
258  else:
259    assert 0, "unknown format: %s" % self.Format
260
261@_add_method(otTables.PairPos)
262def prune_post_subset(self, options):
263  if not options.hinting:
264    # Drop device tables
265    self.ValueFormat1 &= ~0x00F0
266    self.ValueFormat2 &= ~0x00F0
267  return True
268
269@_add_method(otTables.CursivePos)
270def subset_glyphs(self, s):
271  if self.Format == 1:
272    indices = self.Coverage.subset(s.glyphs)
273    self.EntryExitRecord = [self.EntryExitRecord[i] for i in indices]
274    self.EntryExitCount = len(self.EntryExitRecord)
275    return bool(self.EntryExitCount)
276  else:
277    assert 0, "unknown format: %s" % self.Format
278
279@_add_method(otTables.Anchor)
280def prune_hints(self):
281  # Drop device tables / contour anchor point
282  self.Format = 1
283
284@_add_method(otTables.CursivePos)
285def prune_post_subset(self, options):
286  if not options.hinting:
287    for rec in self.EntryExitRecord:
288      if rec.EntryAnchor: rec.EntryAnchor.prune_hints()
289      if rec.ExitAnchor: rec.ExitAnchor.prune_hints()
290  return True
291
292@_add_method(otTables.MarkBasePos)
293def subset_glyphs(self, s):
294  if self.Format == 1:
295    mark_indices = self.MarkCoverage.subset(s.glyphs)
296    self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
297                                 for i in mark_indices]
298    self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
299    base_indices = self.BaseCoverage.subset(s.glyphs)
300    self.BaseArray.BaseRecord = [self.BaseArray.BaseRecord[i]
301                                 for i in base_indices]
302    self.BaseArray.BaseCount = len(self.BaseArray.BaseRecord)
303    # Prune empty classes
304    class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
305    self.ClassCount = len(class_indices)
306    for m in self.MarkArray.MarkRecord:
307      m.Class = class_indices.index(m.Class)
308    for b in self.BaseArray.BaseRecord:
309      b.BaseAnchor = [b.BaseAnchor[i] for i in class_indices]
310    return bool(self.ClassCount and
311                 self.MarkArray.MarkCount and
312                 self.BaseArray.BaseCount)
313  else:
314    assert 0, "unknown format: %s" % self.Format
315
316@_add_method(otTables.MarkBasePos)
317def prune_post_subset(self, options):
318    if not options.hinting:
319      for m in self.MarkArray.MarkRecord:
320        if m.MarkAnchor:
321          m.MarkAnchor.prune_hints()
322      for b in self.BaseArray.BaseRecord:
323        for a in b.BaseAnchor:
324          if a:
325            a.prune_hints()
326    return True
327
328@_add_method(otTables.MarkLigPos)
329def subset_glyphs(self, s):
330  if self.Format == 1:
331    mark_indices = self.MarkCoverage.subset(s.glyphs)
332    self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
333                                 for i in mark_indices]
334    self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
335    ligature_indices = self.LigatureCoverage.subset(s.glyphs)
336    self.LigatureArray.LigatureAttach = [self.LigatureArray.LigatureAttach[i]
337                                         for i in ligature_indices]
338    self.LigatureArray.LigatureCount = len(self.LigatureArray.LigatureAttach)
339    # Prune empty classes
340    class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
341    self.ClassCount = len(class_indices)
342    for m in self.MarkArray.MarkRecord:
343      m.Class = class_indices.index(m.Class)
344    for l in self.LigatureArray.LigatureAttach:
345      for c in l.ComponentRecord:
346        c.LigatureAnchor = [c.LigatureAnchor[i] for i in class_indices]
347    return bool(self.ClassCount and
348                 self.MarkArray.MarkCount and
349                 self.LigatureArray.LigatureCount)
350  else:
351    assert 0, "unknown format: %s" % self.Format
352
353@_add_method(otTables.MarkLigPos)
354def prune_post_subset(self, options):
355    if not options.hinting:
356      for m in self.MarkArray.MarkRecord:
357        if m.MarkAnchor:
358          m.MarkAnchor.prune_hints()
359      for l in self.LigatureArray.LigatureAttach:
360        for c in l.ComponentRecord:
361          for a in c.LigatureAnchor:
362            if a:
363              a.prune_hints()
364    return True
365
366@_add_method(otTables.MarkMarkPos)
367def subset_glyphs(self, s):
368  if self.Format == 1:
369    mark1_indices = self.Mark1Coverage.subset(s.glyphs)
370    self.Mark1Array.MarkRecord = [self.Mark1Array.MarkRecord[i]
371                                  for i in mark1_indices]
372    self.Mark1Array.MarkCount = len(self.Mark1Array.MarkRecord)
373    mark2_indices = self.Mark2Coverage.subset(s.glyphs)
374    self.Mark2Array.Mark2Record = [self.Mark2Array.Mark2Record[i]
375                                   for i in mark2_indices]
376    self.Mark2Array.MarkCount = len(self.Mark2Array.Mark2Record)
377    # Prune empty classes
378    class_indices = _uniq_sort(v.Class for v in self.Mark1Array.MarkRecord)
379    self.ClassCount = len(class_indices)
380    for m in self.Mark1Array.MarkRecord:
381      m.Class = class_indices.index(m.Class)
382    for b in self.Mark2Array.Mark2Record:
383      b.Mark2Anchor = [b.Mark2Anchor[i] for i in class_indices]
384    return bool(self.ClassCount and
385                 self.Mark1Array.MarkCount and
386                 self.Mark2Array.MarkCount)
387  else:
388    assert 0, "unknown format: %s" % self.Format
389
390@_add_method(otTables.MarkMarkPos)
391def prune_post_subset(self, options):
392    if not options.hinting:
393      # Drop device tables or contour anchor point
394      for m in self.Mark1Array.MarkRecord:
395        if m.MarkAnchor:
396          m.MarkAnchor.prune_hints()
397      for b in self.Mark2Array.Mark2Record:
398        for m in b.Mark2Anchor:
399          if m:
400            m.prune_hints()
401    return True
402
403@_add_method(otTables.SingleSubst,
404             otTables.MultipleSubst,
405             otTables.AlternateSubst,
406             otTables.LigatureSubst,
407             otTables.ReverseChainSingleSubst,
408             otTables.SinglePos,
409             otTables.PairPos,
410             otTables.CursivePos,
411             otTables.MarkBasePos,
412             otTables.MarkLigPos,
413             otTables.MarkMarkPos)
414def subset_lookups(self, lookup_indices):
415  pass
416
417@_add_method(otTables.SingleSubst,
418             otTables.MultipleSubst,
419             otTables.AlternateSubst,
420             otTables.LigatureSubst,
421             otTables.ReverseChainSingleSubst,
422             otTables.SinglePos,
423             otTables.PairPos,
424             otTables.CursivePos,
425             otTables.MarkBasePos,
426             otTables.MarkLigPos,
427             otTables.MarkMarkPos)
428def collect_lookups(self):
429  return []
430
431@_add_method(otTables.SingleSubst,
432             otTables.MultipleSubst,
433             otTables.AlternateSubst,
434             otTables.LigatureSubst,
435             otTables.ContextSubst,
436             otTables.ChainContextSubst,
437             otTables.ReverseChainSingleSubst,
438             otTables.SinglePos,
439             otTables.PairPos,
440             otTables.CursivePos,
441             otTables.MarkBasePos,
442             otTables.MarkLigPos,
443             otTables.MarkMarkPos,
444             otTables.ContextPos,
445             otTables.ChainContextPos)
446def prune_pre_subset(self, options):
447  return True
448
449@_add_method(otTables.SingleSubst,
450             otTables.MultipleSubst,
451             otTables.AlternateSubst,
452             otTables.LigatureSubst,
453             otTables.ReverseChainSingleSubst,
454             otTables.ContextSubst,
455             otTables.ChainContextSubst,
456             otTables.ContextPos,
457             otTables.ChainContextPos)
458def prune_post_subset(self, options):
459  return True
460
461@_add_method(otTables.SingleSubst,
462             otTables.AlternateSubst,
463             otTables.ReverseChainSingleSubst)
464def may_have_non_1to1(self):
465  return False
466
467@_add_method(otTables.MultipleSubst,
468             otTables.LigatureSubst,
469             otTables.ContextSubst,
470             otTables.ChainContextSubst)
471def may_have_non_1to1(self):
472  return True
473
474@_add_method(otTables.ContextSubst,
475             otTables.ChainContextSubst,
476             otTables.ContextPos,
477             otTables.ChainContextPos)
478def __classify_context(self):
479
480  class ContextHelper(object):
481    def __init__(self, klass, Format):
482      if klass.__name__.endswith('Subst'):
483        Typ = 'Sub'
484        Type = 'Subst'
485      else:
486        Typ = 'Pos'
487        Type = 'Pos'
488      if klass.__name__.startswith('Chain'):
489        Chain = 'Chain'
490      else:
491        Chain = ''
492      ChainTyp = Chain+Typ
493
494      self.Typ = Typ
495      self.Type = Type
496      self.Chain = Chain
497      self.ChainTyp = ChainTyp
498
499      self.LookupRecord = Type+'LookupRecord'
500
501      if Format == 1:
502        Coverage = lambda r: r.Coverage
503        ChainCoverage = lambda r: r.Coverage
504        ContextData = lambda r:(None,)
505        ChainContextData = lambda r:(None, None, None)
506        RuleData = lambda r:(r.Input,)
507        ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead)
508        SetRuleData = None
509        ChainSetRuleData = None
510      elif Format == 2:
511        Coverage = lambda r: r.Coverage
512        ChainCoverage = lambda r: r.Coverage
513        ContextData = lambda r:(r.ClassDef,)
514        ChainContextData = lambda r:(r.LookAheadClassDef,
515                                      r.InputClassDef,
516                                      r.BacktrackClassDef)
517        RuleData = lambda r:(r.Class,)
518        ChainRuleData = lambda r:(r.LookAhead, r.Input, r.Backtrack)
519        def SetRuleData(r, d):(r.Class,) = d
520        def ChainSetRuleData(r, d):(r.LookAhead, r.Input, r.Backtrack) = d
521      elif Format == 3:
522        Coverage = lambda r: r.Coverage[0]
523        ChainCoverage = lambda r: r.InputCoverage[0]
524        ContextData = None
525        ChainContextData = None
526        RuleData = lambda r: r.Coverage
527        ChainRuleData = lambda r:(r.LookAheadCoverage +
528                                   r.InputCoverage +
529                                   r.BacktrackCoverage)
530        SetRuleData = None
531        ChainSetRuleData = None
532      else:
533        assert 0, "unknown format: %s" % Format
534
535      if Chain:
536        self.Coverage = ChainCoverage
537        self.ContextData = ChainContextData
538        self.RuleData = ChainRuleData
539        self.SetRuleData = ChainSetRuleData
540      else:
541        self.Coverage = Coverage
542        self.ContextData = ContextData
543        self.RuleData = RuleData
544        self.SetRuleData = SetRuleData
545
546      if Format == 1:
547        self.Rule = ChainTyp+'Rule'
548        self.RuleCount = ChainTyp+'RuleCount'
549        self.RuleSet = ChainTyp+'RuleSet'
550        self.RuleSetCount = ChainTyp+'RuleSetCount'
551        self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else []
552      elif Format == 2:
553        self.Rule = ChainTyp+'ClassRule'
554        self.RuleCount = ChainTyp+'ClassRuleCount'
555        self.RuleSet = ChainTyp+'ClassSet'
556        self.RuleSetCount = ChainTyp+'ClassSetCount'
557        self.Intersect = lambda glyphs, c, r: c.intersect_class(glyphs, r)
558
559        self.ClassDef = 'InputClassDef' if Chain else 'ClassDef'
560        self.ClassDefIndex = 1 if Chain else 0
561        self.Input = 'Input' if Chain else 'Class'
562
563  if self.Format not in [1, 2, 3]:
564    return None  # Don't shoot the messenger; let it go
565  if not hasattr(self.__class__, "__ContextHelpers"):
566    self.__class__.__ContextHelpers = {}
567  if self.Format not in self.__class__.__ContextHelpers:
568    helper = ContextHelper(self.__class__, self.Format)
569    self.__class__.__ContextHelpers[self.Format] = helper
570  return self.__class__.__ContextHelpers[self.Format]
571
572@_add_method(otTables.ContextSubst,
573             otTables.ChainContextSubst)
574def closure_glyphs(self, s, cur_glyphs=None):
575  if cur_glyphs == None: cur_glyphs = s.glyphs
576  c = self.__classify_context()
577
578  indices = c.Coverage(self).intersect(s.glyphs)
579  if not indices:
580    return []
581  cur_glyphs = c.Coverage(self).intersect_glyphs(s.glyphs);
582
583  if self.Format == 1:
584    ContextData = c.ContextData(self)
585    rss = getattr(self, c.RuleSet)
586    rssCount = getattr(self, c.RuleSetCount)
587    for i in indices:
588      if i >= rssCount or not rss[i]: continue
589      for r in getattr(rss[i], c.Rule):
590        if not r: continue
591        if all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
592          for cd,klist in zip(ContextData, c.RuleData(r))):
593          chaos = False
594          for ll in getattr(r, c.LookupRecord):
595            if not ll: continue
596            seqi = ll.SequenceIndex
597            if chaos:
598              pos_glyphs = s.glyphs
599            else:
600              if seqi == 0:
601                pos_glyphs = set([c.Coverage(self).glyphs[i]])
602              else:
603                pos_glyphs = set([r.Input[seqi - 1]])
604            lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
605            chaos = chaos or lookup.may_have_non_1to1()
606            lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
607  elif self.Format == 2:
608    ClassDef = getattr(self, c.ClassDef)
609    indices = ClassDef.intersect(cur_glyphs)
610    ContextData = c.ContextData(self)
611    rss = getattr(self, c.RuleSet)
612    rssCount = getattr(self, c.RuleSetCount)
613    for i in indices:
614      if i >= rssCount or not rss[i]: continue
615      for r in getattr(rss[i], c.Rule):
616        if not r: continue
617        if all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
618          for cd,klist in zip(ContextData, c.RuleData(r))):
619          chaos = False
620          for ll in getattr(r, c.LookupRecord):
621            if not ll: continue
622            seqi = ll.SequenceIndex
623            if chaos:
624              pos_glyphs = s.glyphs
625            else:
626              if seqi == 0:
627                pos_glyphs = ClassDef.intersect_class(cur_glyphs, i)
628              else:
629                pos_glyphs = ClassDef.intersect_class(s.glyphs,
630                                                      getattr(r, c.Input)[seqi - 1])
631            lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
632            chaos = chaos or lookup.may_have_non_1to1()
633            lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
634  elif self.Format == 3:
635    if not all(x.intersect(s.glyphs) for x in c.RuleData(self)):
636      return []
637    r = self
638    chaos = False
639    for ll in getattr(r, c.LookupRecord):
640      if not ll: continue
641      seqi = ll.SequenceIndex
642      if chaos:
643        pos_glyphs = s.glyphs
644      else:
645        if seqi == 0:
646          pos_glyphs = cur_glyphs
647        else:
648          pos_glyphs = r.InputCoverage[seqi].intersect_glyphs(s.glyphs)
649      lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
650      chaos = chaos or lookup.may_have_non_1to1()
651      lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
652  else:
653    assert 0, "unknown format: %s" % self.Format
654
655@_add_method(otTables.ContextSubst,
656             otTables.ContextPos,
657             otTables.ChainContextSubst,
658             otTables.ChainContextPos)
659def subset_glyphs(self, s):
660  c = self.__classify_context()
661
662  if self.Format == 1:
663    indices = self.Coverage.subset(s.glyphs)
664    rss = getattr(self, c.RuleSet)
665    rss = [rss[i] for i in indices]
666    for rs in rss:
667      if not rs: continue
668      ss = getattr(rs, c.Rule)
669      ss = [r for r in ss
670            if r and all(all(g in s.glyphs for g in glist)
671              for glist in c.RuleData(r))]
672      setattr(rs, c.Rule, ss)
673      setattr(rs, c.RuleCount, len(ss))
674    # Prune empty subrulesets
675    rss = [rs for rs in rss if rs and getattr(rs, c.Rule)]
676    setattr(self, c.RuleSet, rss)
677    setattr(self, c.RuleSetCount, len(rss))
678    return bool(rss)
679  elif self.Format == 2:
680    if not self.Coverage.subset(s.glyphs):
681      return False
682    ContextData = c.ContextData(self)
683    klass_maps = [x.subset(s.glyphs, remap=True) for x in ContextData]
684
685    # Keep rulesets for class numbers that survived.
686    indices = klass_maps[c.ClassDefIndex]
687    rss = getattr(self, c.RuleSet)
688    rssCount = getattr(self, c.RuleSetCount)
689    rss = [rss[i] for i in indices if i < rssCount]
690    del rssCount
691    # Delete, but not renumber, unreachable rulesets.
692    indices = getattr(self, c.ClassDef).intersect(self.Coverage.glyphs)
693    rss = [rss if i in indices else None for i,rss in enumerate(rss)]
694    while rss and rss[-1] == None:
695      del rss[-1]
696
697    for rs in rss:
698      if not rs: continue
699      ss = getattr(rs, c.Rule)
700      ss = [r for r in ss
701            if r and all(all(k in klass_map for k in klist)
702              for klass_map,klist in zip(klass_maps, c.RuleData(r)))]
703      setattr(rs, c.Rule, ss)
704      setattr(rs, c.RuleCount, len(ss))
705
706      # Remap rule classes
707      for r in ss:
708        c.SetRuleData(r, [[klass_map.index(k) for k in klist]
709               for klass_map,klist in zip(klass_maps, c.RuleData(r))])
710    return bool(rss)
711  elif self.Format == 3:
712    return all(x.subset(s.glyphs) for x in c.RuleData(self))
713  else:
714    assert 0, "unknown format: %s" % self.Format
715
716@_add_method(otTables.ContextSubst,
717             otTables.ChainContextSubst,
718             otTables.ContextPos,
719             otTables.ChainContextPos)
720def subset_lookups(self, lookup_indices):
721  c = self.__classify_context()
722
723  if self.Format in [1, 2]:
724    for rs in getattr(self, c.RuleSet):
725      if not rs: continue
726      for r in getattr(rs, c.Rule):
727        if not r: continue
728        setattr(r, c.LookupRecord,
729                 [ll for ll in getattr(r, c.LookupRecord)
730                  if ll and ll.LookupListIndex in lookup_indices])
731        for ll in getattr(r, c.LookupRecord):
732          if not ll: continue
733          ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
734  elif self.Format == 3:
735    setattr(self, c.LookupRecord,
736             [ll for ll in getattr(self, c.LookupRecord)
737              if ll and ll.LookupListIndex in lookup_indices])
738    for ll in getattr(self, c.LookupRecord):
739      if not ll: continue
740      ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
741  else:
742    assert 0, "unknown format: %s" % self.Format
743
744@_add_method(otTables.ContextSubst,
745             otTables.ChainContextSubst,
746             otTables.ContextPos,
747             otTables.ChainContextPos)
748def collect_lookups(self):
749  c = self.__classify_context()
750
751  if self.Format in [1, 2]:
752    return [ll.LookupListIndex
753      for rs in getattr(self, c.RuleSet) if rs
754      for r in getattr(rs, c.Rule) if r
755      for ll in getattr(r, c.LookupRecord) if ll]
756  elif self.Format == 3:
757    return [ll.LookupListIndex
758      for ll in getattr(self, c.LookupRecord) if ll]
759  else:
760    assert 0, "unknown format: %s" % self.Format
761
762@_add_method(otTables.ExtensionSubst)
763def closure_glyphs(self, s, cur_glyphs=None):
764  if self.Format == 1:
765    self.ExtSubTable.closure_glyphs(s, cur_glyphs)
766  else:
767    assert 0, "unknown format: %s" % self.Format
768
769@_add_method(otTables.ExtensionSubst)
770def may_have_non_1to1(self):
771  if self.Format == 1:
772    return self.ExtSubTable.may_have_non_1to1()
773  else:
774    assert 0, "unknown format: %s" % self.Format
775
776@_add_method(otTables.ExtensionSubst,
777             otTables.ExtensionPos)
778def prune_pre_subset(self, options):
779  if self.Format == 1:
780    return self.ExtSubTable.prune_pre_subset(options)
781  else:
782    assert 0, "unknown format: %s" % self.Format
783
784@_add_method(otTables.ExtensionSubst,
785             otTables.ExtensionPos)
786def subset_glyphs(self, s):
787  if self.Format == 1:
788    return self.ExtSubTable.subset_glyphs(s)
789  else:
790    assert 0, "unknown format: %s" % self.Format
791
792@_add_method(otTables.ExtensionSubst,
793             otTables.ExtensionPos)
794def prune_post_subset(self, options):
795  if self.Format == 1:
796    return self.ExtSubTable.prune_post_subset(options)
797  else:
798    assert 0, "unknown format: %s" % self.Format
799
800@_add_method(otTables.ExtensionSubst,
801             otTables.ExtensionPos)
802def subset_lookups(self, lookup_indices):
803  if self.Format == 1:
804    return self.ExtSubTable.subset_lookups(lookup_indices)
805  else:
806    assert 0, "unknown format: %s" % self.Format
807
808@_add_method(otTables.ExtensionSubst,
809             otTables.ExtensionPos)
810def collect_lookups(self):
811  if self.Format == 1:
812    return self.ExtSubTable.collect_lookups()
813  else:
814    assert 0, "unknown format: %s" % self.Format
815
816@_add_method(otTables.Lookup)
817def closure_glyphs(self, s, cur_glyphs=None):
818  for st in self.SubTable:
819    if not st: continue
820    st.closure_glyphs(s, cur_glyphs)
821
822@_add_method(otTables.Lookup)
823def prune_pre_subset(self, options):
824  ret = False
825  for st in self.SubTable:
826    if not st: continue
827    if st.prune_pre_subset(options): ret = True
828  return ret
829
830@_add_method(otTables.Lookup)
831def subset_glyphs(self, s):
832  self.SubTable = [st for st in self.SubTable if st and st.subset_glyphs(s)]
833  self.SubTableCount = len(self.SubTable)
834  return bool(self.SubTableCount)
835
836@_add_method(otTables.Lookup)
837def prune_post_subset(self, options):
838  ret = False
839  for st in self.SubTable:
840    if not st: continue
841    if st.prune_post_subset(options): ret = True
842  return ret
843
844@_add_method(otTables.Lookup)
845def subset_lookups(self, lookup_indices):
846  for s in self.SubTable:
847    s.subset_lookups(lookup_indices)
848
849@_add_method(otTables.Lookup)
850def collect_lookups(self):
851  return _uniq_sort(sum((st.collect_lookups() for st in self.SubTable
852                         if st), []))
853
854@_add_method(otTables.Lookup)
855def may_have_non_1to1(self):
856  return any(st.may_have_non_1to1() for st in self.SubTable if st)
857
858@_add_method(otTables.LookupList)
859def prune_pre_subset(self, options):
860  ret = False
861  for l in self.Lookup:
862    if not l: continue
863    if l.prune_pre_subset(options): ret = True
864  return ret
865
866@_add_method(otTables.LookupList)
867def subset_glyphs(self, s):
868  "Returns the indices of nonempty lookups."
869  return [i for i,l in enumerate(self.Lookup) if l and l.subset_glyphs(s)]
870
871@_add_method(otTables.LookupList)
872def prune_post_subset(self, options):
873  ret = False
874  for l in self.Lookup:
875    if not l: continue
876    if l.prune_post_subset(options): ret = True
877  return ret
878
879@_add_method(otTables.LookupList)
880def subset_lookups(self, lookup_indices):
881  self.Lookup = [self.Lookup[i] for i in lookup_indices
882                 if i < self.LookupCount]
883  self.LookupCount = len(self.Lookup)
884  for l in self.Lookup:
885    l.subset_lookups(lookup_indices)
886
887@_add_method(otTables.LookupList)
888def closure_lookups(self, lookup_indices):
889  lookup_indices = _uniq_sort(lookup_indices)
890  recurse = lookup_indices
891  while True:
892    recurse_lookups = sum((self.Lookup[i].collect_lookups()
893                            for i in recurse if i < self.LookupCount), [])
894    recurse_lookups = [l for l in recurse_lookups
895                       if l not in lookup_indices and l < self.LookupCount]
896    if not recurse_lookups:
897      return _uniq_sort(lookup_indices)
898    recurse_lookups = _uniq_sort(recurse_lookups)
899    lookup_indices.extend(recurse_lookups)
900    recurse = recurse_lookups
901
902@_add_method(otTables.Feature)
903def subset_lookups(self, lookup_indices):
904  self.LookupListIndex = [l for l in self.LookupListIndex
905                          if l in lookup_indices]
906  # Now map them.
907  self.LookupListIndex = [lookup_indices.index(l)
908                          for l in self.LookupListIndex]
909  self.LookupCount = len(self.LookupListIndex)
910  return self.LookupCount
911
912@_add_method(otTables.Feature)
913def collect_lookups(self):
914  return self.LookupListIndex[:]
915
916@_add_method(otTables.FeatureList)
917def subset_lookups(self, lookup_indices):
918  "Returns the indices of nonempty features."
919  feature_indices = [i for i,f in enumerate(self.FeatureRecord)
920                     if f.Feature.subset_lookups(lookup_indices)]
921  self.subset_features(feature_indices)
922  return feature_indices
923
924@_add_method(otTables.FeatureList)
925def collect_lookups(self, feature_indices):
926  return _uniq_sort(sum((self.FeatureRecord[i].Feature.collect_lookups()
927                         for i in feature_indices
928                          if i < self.FeatureCount), []))
929
930@_add_method(otTables.FeatureList)
931def subset_features(self, feature_indices):
932  self.FeatureRecord = [self.FeatureRecord[i] for i in feature_indices]
933  self.FeatureCount = len(self.FeatureRecord)
934  return bool(self.FeatureCount)
935
936@_add_method(otTables.DefaultLangSys,
937             otTables.LangSys)
938def subset_features(self, feature_indices):
939  if self.ReqFeatureIndex in feature_indices:
940    self.ReqFeatureIndex = feature_indices.index(self.ReqFeatureIndex)
941  else:
942    self.ReqFeatureIndex = 65535
943  self.FeatureIndex = [f for f in self.FeatureIndex if f in feature_indices]
944  # Now map them.
945  self.FeatureIndex = [feature_indices.index(f) for f in self.FeatureIndex
946                       if f in feature_indices]
947  self.FeatureCount = len(self.FeatureIndex)
948  return bool(self.FeatureCount or self.ReqFeatureIndex != 65535)
949
950@_add_method(otTables.DefaultLangSys,
951             otTables.LangSys)
952def collect_features(self):
953  feature_indices = self.FeatureIndex[:]
954  if self.ReqFeatureIndex != 65535:
955    feature_indices.append(self.ReqFeatureIndex)
956  return _uniq_sort(feature_indices)
957
958@_add_method(otTables.Script)
959def subset_features(self, feature_indices):
960  if(self.DefaultLangSys and
961      not self.DefaultLangSys.subset_features(feature_indices)):
962    self.DefaultLangSys = None
963  self.LangSysRecord = [l for l in self.LangSysRecord
964                        if l.LangSys.subset_features(feature_indices)]
965  self.LangSysCount = len(self.LangSysRecord)
966  return bool(self.LangSysCount or self.DefaultLangSys)
967
968@_add_method(otTables.Script)
969def collect_features(self):
970  feature_indices = [l.LangSys.collect_features() for l in self.LangSysRecord]
971  if self.DefaultLangSys:
972    feature_indices.append(self.DefaultLangSys.collect_features())
973  return _uniq_sort(sum(feature_indices, []))
974
975@_add_method(otTables.ScriptList)
976def subset_features(self, feature_indices):
977  self.ScriptRecord = [s for s in self.ScriptRecord
978                       if s.Script.subset_features(feature_indices)]
979  self.ScriptCount = len(self.ScriptRecord)
980  return bool(self.ScriptCount)
981
982@_add_method(otTables.ScriptList)
983def collect_features(self):
984  return _uniq_sort(sum((s.Script.collect_features()
985                         for s in self.ScriptRecord), []))
986
987@_add_method(ttLib.getTableClass('GSUB'))
988def closure_glyphs(self, s):
989  s.table = self.table
990  feature_indices = self.table.ScriptList.collect_features()
991  if self.table.FeatureList:
992    lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
993  else:
994    lookup_indices = []
995  if self.table.LookupList:
996    while True:
997      orig_glyphs = s.glyphs.copy()
998      for i in lookup_indices:
999        if i >= self.table.LookupList.LookupCount: continue
1000        if not self.table.LookupList.Lookup[i]: continue
1001        self.table.LookupList.Lookup[i].closure_glyphs(s)
1002      if orig_glyphs == s.glyphs:
1003        break
1004  del s.table
1005
1006@_add_method(ttLib.getTableClass('GSUB'),
1007             ttLib.getTableClass('GPOS'))
1008def subset_glyphs(self, s):
1009  s.glyphs = s.glyphs_gsubed
1010  if self.table.LookupList:
1011    lookup_indices = self.table.LookupList.subset_glyphs(s)
1012  else:
1013    lookup_indices = []
1014  self.subset_lookups(lookup_indices)
1015  self.prune_lookups()
1016  return True
1017
1018@_add_method(ttLib.getTableClass('GSUB'),
1019             ttLib.getTableClass('GPOS'))
1020def subset_lookups(self, lookup_indices):
1021  """Retrains specified lookups, then removes empty features, language
1022     systems, and scripts."""
1023  if self.table.LookupList:
1024    self.table.LookupList.subset_lookups(lookup_indices)
1025  if self.table.FeatureList:
1026    feature_indices = self.table.FeatureList.subset_lookups(lookup_indices)
1027  else:
1028    feature_indices = []
1029  self.table.ScriptList.subset_features(feature_indices)
1030
1031@_add_method(ttLib.getTableClass('GSUB'),
1032             ttLib.getTableClass('GPOS'))
1033def prune_lookups(self):
1034  "Remove unreferenced lookups"
1035  feature_indices = self.table.ScriptList.collect_features()
1036  if self.table.FeatureList:
1037    lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
1038  else:
1039    lookup_indices = []
1040  if self.table.LookupList:
1041    lookup_indices = self.table.LookupList.closure_lookups(lookup_indices)
1042  else:
1043    lookup_indices = []
1044  self.subset_lookups(lookup_indices)
1045
1046@_add_method(ttLib.getTableClass('GSUB'),
1047             ttLib.getTableClass('GPOS'))
1048def subset_feature_tags(self, feature_tags):
1049  if self.table.FeatureList:
1050    feature_indices = [i for i,f in
1051                       enumerate(self.table.FeatureList.FeatureRecord)
1052                       if f.FeatureTag in feature_tags]
1053    self.table.FeatureList.subset_features(feature_indices)
1054  else:
1055    feature_indices = []
1056  self.table.ScriptList.subset_features(feature_indices)
1057
1058@_add_method(ttLib.getTableClass('GSUB'),
1059             ttLib.getTableClass('GPOS'))
1060def prune_pre_subset(self, options):
1061  if '*' not in options.layout_features:
1062    self.subset_feature_tags(options.layout_features)
1063  self.prune_lookups()
1064  if self.table.LookupList:
1065    self.table.LookupList.prune_pre_subset(options);
1066  return True
1067
1068@_add_method(ttLib.getTableClass('GSUB'),
1069             ttLib.getTableClass('GPOS'))
1070def prune_post_subset(self, options):
1071  if self.table.LookupList:
1072    self.table.LookupList.prune_post_subset(options);
1073  return True
1074
1075@_add_method(ttLib.getTableClass('GDEF'))
1076def subset_glyphs(self, s):
1077  glyphs = s.glyphs_gsubed
1078  table = self.table
1079  if table.LigCaretList:
1080    indices = table.LigCaretList.Coverage.subset(glyphs)
1081    table.LigCaretList.LigGlyph = [table.LigCaretList.LigGlyph[i]
1082                                   for i in indices]
1083    table.LigCaretList.LigGlyphCount = len(table.LigCaretList.LigGlyph)
1084    if not table.LigCaretList.LigGlyphCount:
1085      table.LigCaretList = None
1086  if table.MarkAttachClassDef:
1087    table.MarkAttachClassDef.classDefs = dict((g,v) for g,v in
1088                                              table.MarkAttachClassDef.
1089                                                classDefs.iteritems()
1090                                              if g in glyphs)
1091    if not table.MarkAttachClassDef.classDefs:
1092      table.MarkAttachClassDef = None
1093  if table.GlyphClassDef:
1094    table.GlyphClassDef.classDefs = dict((g,v) for g,v in
1095                                         table.GlyphClassDef.
1096                                           classDefs.iteritems()
1097                                         if g in glyphs)
1098    if not table.GlyphClassDef.classDefs:
1099      table.GlyphClassDef = None
1100  if table.AttachList:
1101    indices = table.AttachList.Coverage.subset(glyphs)
1102    GlyphCount = table.AttachList.GlyphCount
1103    table.AttachList.AttachPoint = [table.AttachList.AttachPoint[i]
1104                                    for i in indices
1105                                    if i < GlyphCount]
1106    table.AttachList.GlyphCount = len(table.AttachList.AttachPoint)
1107    if not table.AttachList.GlyphCount:
1108      table.AttachList = None
1109  return bool(table.LigCaretList or
1110               table.MarkAttachClassDef or
1111               table.GlyphClassDef or
1112               table.AttachList)
1113
1114@_add_method(ttLib.getTableClass('kern'))
1115def prune_pre_subset(self, options):
1116  # Prune unknown kern table types
1117  self.kernTables = [t for t in self.kernTables if hasattr(t, 'kernTable')]
1118  return bool(self.kernTables)
1119
1120@_add_method(ttLib.getTableClass('kern'))
1121def subset_glyphs(self, s):
1122  glyphs = s.glyphs_gsubed
1123  for t in self.kernTables:
1124    t.kernTable = dict(((a,b),v) for (a,b),v in t.kernTable.iteritems()
1125                       if a in glyphs and b in glyphs)
1126  self.kernTables = [t for t in self.kernTables if t.kernTable]
1127  return bool(self.kernTables)
1128
1129@_add_method(ttLib.getTableClass('vmtx'))
1130def subset_glyphs(self, s):
1131  self.metrics = dict((g,v) for g,v in self.metrics.iteritems() if g in s.glyphs)
1132  return bool(self.metrics)
1133
1134@_add_method(ttLib.getTableClass('hmtx'))
1135def subset_glyphs(self, s):
1136  self.metrics = dict((g,v) for g,v in self.metrics.iteritems() if g in s.glyphs)
1137  return True # Required table
1138
1139@_add_method(ttLib.getTableClass('hdmx'))
1140def subset_glyphs(self, s):
1141  self.hdmx = dict((sz,dict((g,v) for g,v in l.iteritems() if g in s.glyphs))
1142                   for sz,l in self.hdmx.iteritems())
1143  return bool(self.hdmx)
1144
1145@_add_method(ttLib.getTableClass('VORG'))
1146def subset_glyphs(self, s):
1147  self.VOriginRecords = dict((g,v) for g,v in self.VOriginRecords.iteritems()
1148                             if g in s.glyphs)
1149  self.numVertOriginYMetrics = len(self.VOriginRecords)
1150  return True  # Never drop; has default metrics
1151
1152@_add_method(ttLib.getTableClass('post'))
1153def prune_pre_subset(self, options):
1154  if not options.glyph_names:
1155    self.formatType = 3.0
1156  return True # Required table
1157
1158@_add_method(ttLib.getTableClass('post'))
1159def subset_glyphs(self, s):
1160  self.extraNames = []  # This seems to do it
1161  return True # Required table
1162
1163@_add_method(ttLib.getTableModule('glyf').Glyph)
1164def remapComponentsFast(self, indices):
1165  if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0:
1166    return  # Not composite
1167  data = array.array("B", self.data)
1168  i = 10
1169  more = 1
1170  while more:
1171    flags =(data[i] << 8) | data[i+1]
1172    glyphID =(data[i+2] << 8) | data[i+3]
1173    # Remap
1174    glyphID = indices.index(glyphID)
1175    data[i+2] = glyphID >> 8
1176    data[i+3] = glyphID & 0xFF
1177    i += 4
1178    flags = int(flags)
1179
1180    if flags & 0x0001: i += 4  # ARG_1_AND_2_ARE_WORDS
1181    else: i += 2
1182    if flags & 0x0008: i += 2  # WE_HAVE_A_SCALE
1183    elif flags & 0x0040: i += 4  # WE_HAVE_AN_X_AND_Y_SCALE
1184    elif flags & 0x0080: i += 8  # WE_HAVE_A_TWO_BY_TWO
1185    more = flags & 0x0020  # MORE_COMPONENTS
1186
1187  self.data = data.tostring()
1188
1189@_add_method(ttLib.getTableClass('glyf'))
1190def closure_glyphs(self, s):
1191  decompose = s.glyphs
1192  while True:
1193    components = set()
1194    for g in decompose:
1195      if g not in self.glyphs:
1196        continue
1197      gl = self.glyphs[g]
1198      for c in gl.getComponentNames(self):
1199        if c not in s.glyphs:
1200          components.add(c)
1201    components = set(c for c in components if c not in s.glyphs)
1202    if not components:
1203      break
1204    decompose = components
1205    s.glyphs.update(components)
1206
1207@_add_method(ttLib.getTableClass('glyf'))
1208def prune_pre_subset(self, options):
1209  if options.notdef_glyph and not options.notdef_outline:
1210    g = self[self.glyphOrder[0]]
1211    # Yay, easy!
1212    g.__dict__.clear()
1213    g.data = ""
1214  return True
1215
1216@_add_method(ttLib.getTableClass('glyf'))
1217def subset_glyphs(self, s):
1218  self.glyphs = dict((g,v) for g,v in self.glyphs.iteritems() if g in s.glyphs)
1219  indices = [i for i,g in enumerate(self.glyphOrder) if g in s.glyphs]
1220  for v in self.glyphs.itervalues():
1221    if hasattr(v, "data"):
1222      v.remapComponentsFast(indices)
1223    else:
1224      pass  # No need
1225  self.glyphOrder = [g for g in self.glyphOrder if g in s.glyphs]
1226  # Don't drop empty 'glyf' tables, otherwise 'loca' doesn't get subset.
1227  return True
1228
1229@_add_method(ttLib.getTableClass('glyf'))
1230def prune_post_subset(self, options):
1231  if not options.hinting:
1232    for v in self.glyphs.itervalues():
1233      v.removeHinting()
1234  return True
1235
1236@_add_method(ttLib.getTableClass('CFF '))
1237def prune_pre_subset(self, options):
1238  cff = self.cff
1239  # CFF table must have one font only
1240  cff.fontNames = cff.fontNames[:1]
1241
1242  if options.notdef_glyph and not options.notdef_outline:
1243    for fontname in cff.keys():
1244      font = cff[fontname]
1245      c,_ = font.CharStrings.getItemAndSelector('.notdef')
1246      # XXX we should preserve the glyph width
1247      c.bytecode = '\x0e' # endchar
1248      c.program = None
1249
1250  return True # bool(cff.fontNames)
1251
1252@_add_method(ttLib.getTableClass('CFF '))
1253def subset_glyphs(self, s):
1254  cff = self.cff
1255  for fontname in cff.keys():
1256    font = cff[fontname]
1257    cs = font.CharStrings
1258
1259    # Load all glyphs
1260    for g in font.charset:
1261      if g not in s.glyphs: continue
1262      c,sel = cs.getItemAndSelector(g)
1263
1264    if cs.charStringsAreIndexed:
1265      indices = [i for i,g in enumerate(font.charset) if g in s.glyphs]
1266      csi = cs.charStringsIndex
1267      csi.items = [csi.items[i] for i in indices]
1268      csi.count = len(csi.items)
1269      del csi.file, csi.offsets
1270      if hasattr(font, "FDSelect"):
1271        sel = font.FDSelect
1272        sel.format = None
1273        sel.gidArray = [sel.gidArray[i] for i in indices]
1274      cs.charStrings = dict((g,indices.index(v))
1275                            for g,v in cs.charStrings.iteritems()
1276                            if g in s.glyphs)
1277    else:
1278      cs.charStrings = dict((g,v)
1279                            for g,v in cs.charStrings.iteritems()
1280                            if g in s.glyphs)
1281    font.charset = [g for g in font.charset if g in s.glyphs]
1282    font.numGlyphs = len(font.charset)
1283
1284  return True # any(cff[fontname].numGlyphs for fontname in cff.keys())
1285
1286@_add_method(psCharStrings.T2CharString)
1287def subset_subroutines(self, subrs, gsubrs):
1288  p = self.program
1289  assert len(p)
1290  for i in xrange(1, len(p)):
1291    if p[i] == 'callsubr':
1292      assert type(p[i-1]) is int
1293      p[i-1] = subrs._used.index(p[i-1] + subrs._old_bias) - subrs._new_bias
1294    elif p[i] == 'callgsubr':
1295      assert type(p[i-1]) is int
1296      p[i-1] = gsubrs._used.index(p[i-1] + gsubrs._old_bias) - gsubrs._new_bias
1297
1298@_add_method(psCharStrings.T2CharString)
1299def drop_hints(self):
1300  hints = self._hints
1301
1302  if hints.has_hint:
1303    self.program = self.program[hints.last_hint:]
1304    if hasattr(self, 'width'):
1305      # Insert width back if needed
1306      if self.width != self.private.defaultWidthX:
1307        self.program.insert(0, self.width - self.private.nominalWidthX)
1308
1309  if hints.has_hintmask:
1310    i = 0
1311    p = self.program
1312    while i < len(p):
1313      if p[i] in ['hintmask', 'cntrmask']:
1314        assert i + 1 <= len(p)
1315        del p[i:i+2]
1316        continue
1317      i += 1
1318
1319  # TODO: we currently don't drop calls to "empty" subroutines.
1320
1321  assert len(self.program)
1322
1323  del self._hints
1324
1325class _MarkingT2Decompiler(psCharStrings.SimpleT2Decompiler):
1326
1327  def __init__(self, localSubrs, globalSubrs):
1328    psCharStrings.SimpleT2Decompiler.__init__(self,
1329                                              localSubrs,
1330                                              globalSubrs)
1331    for subrs in [localSubrs, globalSubrs]:
1332      if subrs and not hasattr(subrs, "_used"):
1333        subrs._used = set()
1334
1335  def op_callsubr(self, index):
1336    self.localSubrs._used.add(self.operandStack[-1]+self.localBias)
1337    psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
1338
1339  def op_callgsubr(self, index):
1340    self.globalSubrs._used.add(self.operandStack[-1]+self.globalBias)
1341    psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
1342
1343class _DehintingT2Decompiler(psCharStrings.SimpleT2Decompiler):
1344
1345  class Hints:
1346    def __init__(self):
1347      # Whether calling this charstring produces any hint stems
1348      self.has_hint = False
1349      # Index to start at to drop all hints
1350      self.last_hint = 0
1351      # Index up to which we know more hints are possible.  Only
1352      # relevant if status is 0 or 1.
1353      self.last_checked = 0
1354      # The status means:
1355      # 0: after dropping hints, this charstring is empty
1356      # 1: after dropping hints, there may be more hints continuing after this
1357      # 2: no more hints possible after this charstring
1358      self.status = 0
1359      # Has hintmask instructions; not recursive
1360      self.has_hintmask = False
1361    pass
1362
1363  def __init__(self, css, localSubrs, globalSubrs):
1364    self._css = css
1365    psCharStrings.SimpleT2Decompiler.__init__(self,
1366                                              localSubrs,
1367                                              globalSubrs)
1368
1369  def execute(self, charString):
1370    old_hints = charString._hints if hasattr(charString, '_hints') else None
1371    charString._hints = self.Hints()
1372
1373    psCharStrings.SimpleT2Decompiler.execute(self, charString)
1374
1375    hints = charString._hints
1376
1377    if hints.has_hint or hints.has_hintmask:
1378      self._css.add(charString)
1379
1380    if hints.status != 2:
1381      # Check from last_check, make sure we didn't have any operators.
1382      for i in xrange(hints.last_checked, len(charString.program) - 1):
1383        if type(charString.program[i]) == str:
1384          hints.status = 2
1385          break;
1386        else:
1387          hints.status = 1 # There's *something* here
1388      hints.last_checked = len(charString.program)
1389
1390    if old_hints:
1391      assert hints.__dict__ == old_hints.__dict__
1392
1393  def op_callsubr(self, index):
1394    subr = self.localSubrs[self.operandStack[-1]+self.localBias]
1395    psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
1396    self.processSubr(index, subr)
1397
1398  def op_callgsubr(self, index):
1399    subr = self.globalSubrs[self.operandStack[-1]+self.globalBias]
1400    psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
1401    self.processSubr(index, subr)
1402
1403  def op_hstem(self, index):
1404    psCharStrings.SimpleT2Decompiler.op_hstem(self, index)
1405    self.processHint(index)
1406  def op_vstem(self, index):
1407    psCharStrings.SimpleT2Decompiler.op_vstem(self, index)
1408    self.processHint(index)
1409  def op_hstemhm(self, index):
1410    psCharStrings.SimpleT2Decompiler.op_hstemhm(self, index)
1411    self.processHint(index)
1412  def op_vstemhm(self, index):
1413    psCharStrings.SimpleT2Decompiler.op_vstemhm(self, index)
1414    self.processHint(index)
1415  def op_hintmask(self, index):
1416    psCharStrings.SimpleT2Decompiler.op_hintmask(self, index)
1417    self.processHintmask(index)
1418  def op_cntrmask(self, index):
1419    psCharStrings.SimpleT2Decompiler.op_cntrmask(self, index)
1420    self.processHintmask(index)
1421
1422  def processHintmask(self, index):
1423    cs = self.callingStack[-1]
1424    hints = cs._hints
1425    hints.has_hintmask = True
1426    if hints.status != 2 and hints.has_hint:
1427      # Check from last_check, see if we may be an implicit vstem
1428      for i in xrange(hints.last_checked, index - 1):
1429        if type(cs.program[i]) == str:
1430          hints.status = 2
1431          break;
1432      if hints.status != 2:
1433        # We are an implicit vstem
1434        hints.last_hint = index + 1
1435        hints.status = 0
1436    hints.last_checked = index + 1
1437
1438  def processHint(self, index):
1439    cs = self.callingStack[-1]
1440    hints = cs._hints
1441    hints.has_hint = True
1442    hints.last_hint = index
1443    hints.last_checked = index
1444
1445  def processSubr(self, index, subr):
1446    cs = self.callingStack[-1]
1447    hints = cs._hints
1448    subr_hints = subr._hints
1449
1450    if subr_hints.has_hint:
1451      if hints.status != 2:
1452        hints.has_hint = True
1453        hints.last_checked = index
1454        hints.status = subr_hints.status
1455        # Decide where to chop off from
1456        if subr_hints.status == 0:
1457          hints.last_hint = index
1458        else:
1459          hints.last_hint = index - 2 # Leave the subr call in
1460      else:
1461        # In my understanding, this is a font bug.  Ie. it has hint stems
1462        # *after* path construction.  I've seen this in widespread fonts.
1463        # Best to ignore the hints I suppose...
1464        pass
1465        #assert 0
1466    else:
1467      hints.status = max(hints.status, subr_hints.status)
1468      if hints.status != 2:
1469        # Check from last_check, make sure we didn't have
1470        # any operators.
1471        for i in xrange(hints.last_checked, index - 1):
1472          if type(cs.program[i]) == str:
1473            hints.status = 2
1474            break;
1475        hints.last_checked = index
1476      if hints.status != 2:
1477        # Decide where to chop off from
1478        if subr_hints.status == 0:
1479          hints.last_hint = index
1480        else:
1481          hints.last_hint = index - 2 # Leave the subr call in
1482
1483@_add_method(ttLib.getTableClass('CFF '))
1484def prune_post_subset(self, options):
1485  cff = self.cff
1486  for fontname in cff.keys():
1487    font = cff[fontname]
1488    cs = font.CharStrings
1489
1490
1491    #
1492    # Drop unused FontDictionaries
1493    #
1494    if hasattr(font, "FDSelect"):
1495      sel = font.FDSelect
1496      indices = _uniq_sort(sel.gidArray)
1497      sel.gidArray = [indices.index (ss) for ss in sel.gidArray]
1498      arr = font.FDArray
1499      arr.items = [arr[i] for i in indices]
1500      arr.count = len(arr.items)
1501      del arr.file, arr.offsets
1502
1503
1504    #
1505    # Drop hints if not needed
1506    #
1507    if not options.hinting:
1508
1509      #
1510      # This can be tricky, but doesn't have to.  What we do is:
1511      #
1512      # - Run all used glyph charstrings and recurse into subroutines,
1513      # - For each charstring (including subroutines), if it has any
1514      #   of the hint stem operators, we mark it as such.  Upon returning,
1515      #   for each charstring we note all the subroutine calls it makes
1516      #   that (recursively) contain a stem,
1517      # - Dropping hinting then consists of the following two ops:
1518      #   * Drop the piece of the program in each charstring before the
1519      #     last call to a stem op or a stem-calling subroutine,
1520      #   * Drop all hintmask operations.
1521      # - It's trickier... A hintmask right after hints and a few numbers
1522      #   will act as an implicit vstemhm.  As such, we track whether
1523      #   we have seen any non-hint operators so far and do the right
1524      #   thing, recursively...  Good luck understanding that :(
1525      #
1526      css = set()
1527      for g in font.charset:
1528        c,sel = cs.getItemAndSelector(g)
1529        # Make sure it's decompiled.  We want our "decompiler" to walk
1530        # the program, not the bytecode.
1531        c.draw(basePen.NullPen())
1532        subrs = getattr(c.private, "Subrs", [])
1533        decompiler = _DehintingT2Decompiler(css, subrs, c.globalSubrs)
1534        decompiler.execute(c)
1535      for charstring in css:
1536        charstring.drop_hints()
1537
1538      # Drop font-wide hinting values
1539      all_privs = []
1540      if hasattr(font, 'FDSelect'):
1541        all_privs.extend(fd.Private for fd in font.FDArray)
1542      else:
1543        all_privs.append(font.Private)
1544      for priv in all_privs:
1545        for k in ['BlueValues', 'OtherBlues', 'FamilyBlues', 'FamilyOtherBlues',
1546                  'BlueScale', 'BlueShift', 'BlueFuzz',
1547                  'StemSnapH', 'StemSnapV', 'StdHW', 'StdVW']:
1548          if hasattr(priv, k):
1549            setattr(priv, k, None)
1550
1551
1552    #
1553    # Renumber subroutines to remove unused ones
1554    #
1555
1556    # Mark all used subroutines
1557    for g in font.charset:
1558      c,sel = cs.getItemAndSelector(g)
1559      subrs = getattr(c.private, "Subrs", [])
1560      decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs)
1561      decompiler.execute(c)
1562
1563    all_subrs = [font.GlobalSubrs]
1564    if hasattr(font, 'FDSelect'):
1565      all_subrs.extend(fd.Private.Subrs for fd in font.FDArray if hasattr(fd.Private, 'Subrs') and fd.Private.Subrs)
1566    elif hasattr(font.Private, 'Subrs') and font.Private.Subrs:
1567      all_subrs.append(font.Private.Subrs)
1568
1569    subrs = set(subrs) # Remove duplicates
1570
1571    # Prepare
1572    for subrs in all_subrs:
1573      if not hasattr(subrs, '_used'):
1574        subrs._used = set()
1575      subrs._used = _uniq_sort(subrs._used)
1576      subrs._old_bias = psCharStrings.calcSubrBias(subrs)
1577      subrs._new_bias = psCharStrings.calcSubrBias(subrs._used)
1578
1579    # Renumber glyph charstrings
1580    for g in font.charset:
1581      c,sel = cs.getItemAndSelector(g)
1582      subrs = getattr(c.private, "Subrs", [])
1583      c.subset_subroutines (subrs, font.GlobalSubrs)
1584
1585    # Renumber subroutines themselves
1586    for subrs in all_subrs:
1587
1588      if subrs == font.GlobalSubrs:
1589        if not hasattr(font, 'FDSelect') and hasattr(font.Private, 'Subrs'):
1590          local_subrs = font.Private.Subrs
1591        else:
1592          local_subrs = []
1593      else:
1594        local_subrs = subrs
1595
1596      subrs.items = [subrs.items[i] for i in subrs._used]
1597      subrs.count = len(subrs.items)
1598      del subrs.file
1599      if hasattr(subrs, 'offsets'):
1600        del subrs.offsets
1601
1602      for i in xrange (subrs.count):
1603        subrs[i].subset_subroutines (local_subrs, font.GlobalSubrs)
1604
1605    # Cleanup
1606    for subrs in all_subrs:
1607      del subrs._used, subrs._old_bias, subrs._new_bias
1608
1609  return True
1610
1611@_add_method(ttLib.getTableClass('cmap'))
1612def closure_glyphs(self, s):
1613  tables = [t for t in self.tables
1614            if t.platformID == 3 and t.platEncID in [1, 10]]
1615  for u in s.unicodes_requested:
1616    found = False
1617    for table in tables:
1618      if u in table.cmap:
1619        s.glyphs.add(table.cmap[u])
1620        found = True
1621        break
1622    if not found:
1623      s.log("No glyph for Unicode value %s; skipping." % u)
1624
1625@_add_method(ttLib.getTableClass('cmap'))
1626def prune_pre_subset(self, options):
1627  if not options.legacy_cmap:
1628    # Drop non-Unicode / non-Symbol cmaps
1629    self.tables = [t for t in self.tables
1630                   if t.platformID == 3 and t.platEncID in [0, 1, 10]]
1631  if not options.symbol_cmap:
1632    self.tables = [t for t in self.tables
1633                   if t.platformID == 3 and t.platEncID in [1, 10]]
1634  # TODO(behdad) Only keep one subtable?
1635  # For now, drop format=0 which can't be subset_glyphs easily?
1636  self.tables = [t for t in self.tables if t.format != 0]
1637  self.numSubTables = len(self.tables)
1638  return True # Required table
1639
1640@_add_method(ttLib.getTableClass('cmap'))
1641def subset_glyphs(self, s):
1642  s.glyphs = s.glyphs_cmaped
1643  for t in self.tables:
1644    # For reasons I don't understand I need this here
1645    # to force decompilation of the cmap format 14.
1646    try:
1647      getattr(t, "asdf")
1648    except AttributeError:
1649      pass
1650    if t.format == 14:
1651      # TODO(behdad) XXX We drop all the default-UVS mappings(g==None).
1652      t.uvsDict = dict((v,[(u,g) for u,g in l if g in s.glyphs])
1653                       for v,l in t.uvsDict.iteritems())
1654      t.uvsDict = dict((v,l) for v,l in t.uvsDict.iteritems() if l)
1655    else:
1656      t.cmap = dict((u,g) for u,g in t.cmap.iteritems()
1657                    if g in s.glyphs_requested or u in s.unicodes_requested)
1658  self.tables = [t for t in self.tables
1659                 if (t.cmap if t.format != 14 else t.uvsDict)]
1660  self.numSubTables = len(self.tables)
1661  # TODO(behdad) Convert formats when needed.
1662  # In particular, if we have a format=12 without non-BMP
1663  # characters, either drop format=12 one or convert it
1664  # to format=4 if there's not one.
1665  return True # Required table
1666
1667@_add_method(ttLib.getTableClass('name'))
1668def prune_pre_subset(self, options):
1669  if '*' not in options.name_IDs:
1670    self.names = [n for n in self.names if n.nameID in options.name_IDs]
1671  if not options.name_legacy:
1672    self.names = [n for n in self.names
1673                  if n.platformID == 3 and n.platEncID == 1]
1674  if '*' not in options.name_languages:
1675    self.names = [n for n in self.names if n.langID in options.name_languages]
1676  return True  # Required table
1677
1678
1679# TODO(behdad) OS/2 ulUnicodeRange / ulCodePageRange?
1680# TODO(behdad) Drop AAT tables.
1681# TODO(behdad) Drop unneeded GSUB/GPOS Script/LangSys entries.
1682# TODO(behdad) Drop empty GSUB/GPOS, and GDEF if no GSUB/GPOS left
1683# TODO(behdad) Drop GDEF subitems if unused by lookups
1684# TODO(behdad) Avoid recursing too much (in GSUB/GPOS and in CFF)
1685# TODO(behdad) Text direction considerations.
1686# TODO(behdad) Text script / language considerations.
1687
1688class Options(object):
1689
1690  class UnknownOptionError(Exception):
1691    pass
1692
1693  _drop_tables_default = ['BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC', 'EBSC', 'SVG ',
1694                          'PCLT', 'LTSH']
1695  _drop_tables_default += ['Feat', 'Glat', 'Gloc', 'Silf', 'Sill']  # Graphite
1696  _drop_tables_default += ['CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL']  # Color
1697  _no_subset_tables_default = ['gasp', 'head', 'hhea', 'maxp', 'vhea', 'OS/2',
1698                               'loca', 'name', 'cvt ', 'fpgm', 'prep']
1699  _hinting_tables_default = ['cvt ', 'fpgm', 'prep', 'hdmx', 'VDMX']
1700
1701  # Based on HarfBuzz shapers
1702  _layout_features_groups = {
1703    # Default shaper
1704    'common': ['ccmp', 'liga', 'locl', 'mark', 'mkmk', 'rlig'],
1705    'horizontal': ['calt', 'clig', 'curs', 'kern', 'rclt'],
1706    'vertical':  ['valt', 'vert', 'vkrn', 'vpal', 'vrt2'],
1707    'ltr': ['ltra', 'ltrm'],
1708    'rtl': ['rtla', 'rtlm'],
1709    # Complex shapers
1710    'arabic': ['init', 'medi', 'fina', 'isol', 'med2', 'fin2', 'fin3',
1711               'cswh', 'mset'],
1712    'hangul': ['ljmo', 'vjmo', 'tjmo'],
1713    'tibetan': ['abvs', 'blws', 'abvm', 'blwm'],
1714    'indic': ['nukt', 'akhn', 'rphf', 'rkrf', 'pref', 'blwf', 'half',
1715              'abvf', 'pstf', 'cfar', 'vatu', 'cjct', 'init', 'pres',
1716              'abvs', 'blws', 'psts', 'haln', 'dist', 'abvm', 'blwm'],
1717  }
1718  _layout_features_default = _uniq_sort(sum(
1719      _layout_features_groups.itervalues(), []))
1720
1721  drop_tables = _drop_tables_default
1722  no_subset_tables = _no_subset_tables_default
1723  hinting_tables = _hinting_tables_default
1724  layout_features = _layout_features_default
1725  hinting = True
1726  glyph_names = False
1727  legacy_cmap = False
1728  symbol_cmap = False
1729  name_IDs = [1, 2]  # Family and Style
1730  name_legacy = False
1731  name_languages = [0x0409]  # English
1732  notdef_glyph = True # gid0 for TrueType / .notdef for CFF
1733  notdef_outline = False # No need for notdef to have an outline really
1734  recommended_glyphs = False  # gid1, gid2, gid3 for TrueType
1735  recalc_bounds = False # Recalculate font bounding boxes
1736  canonical_order = False # Order tables as recommended
1737  flavor = None # May be 'woff'
1738
1739  def __init__(self, **kwargs):
1740
1741    self.set(**kwargs)
1742
1743  def set(self, **kwargs):
1744    for k,v in kwargs.iteritems():
1745      if not hasattr(self, k):
1746        raise self.UnknownOptionError("Unknown option '%s'" % k)
1747      setattr(self, k, v)
1748
1749  def parse_opts(self, argv, ignore_unknown=False):
1750    ret = []
1751    opts = {}
1752    for a in argv:
1753      orig_a = a
1754      if not a.startswith('--'):
1755        ret.append(a)
1756        continue
1757      a = a[2:]
1758      i = a.find('=')
1759      op = '='
1760      if i == -1:
1761        if a.startswith("no-"):
1762          k = a[3:]
1763          v = False
1764        else:
1765          k = a
1766          v = True
1767      else:
1768        k = a[:i]
1769        if k[-1] in "-+":
1770          op = k[-1]+'='  # Ops is '-=' or '+=' now.
1771          k = k[:-1]
1772        v = a[i+1:]
1773      k = k.replace('-', '_')
1774      if not hasattr(self, k):
1775        if ignore_unknown == True or k in ignore_unknown:
1776          ret.append(orig_a)
1777          continue
1778        else:
1779          raise self.UnknownOptionError("Unknown option '%s'" % a)
1780
1781      ov = getattr(self, k)
1782      if isinstance(ov, bool):
1783        v = bool(v)
1784      elif isinstance(ov, int):
1785        v = int(v)
1786      elif isinstance(ov, list):
1787        vv = v.split(',')
1788        if vv == ['']:
1789          vv = []
1790        vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv]
1791        if op == '=':
1792          v = vv
1793        elif op == '+=':
1794          v = ov
1795          v.extend(vv)
1796        elif op == '-=':
1797          v = ov
1798          for x in vv:
1799            if x in v:
1800              v.remove(x)
1801        else:
1802          assert 0
1803
1804      opts[k] = v
1805    self.set(**opts)
1806
1807    return ret
1808
1809
1810class Subsetter(object):
1811
1812  def __init__(self, options=None, log=None):
1813
1814    if not log:
1815      log = Logger()
1816    if not options:
1817      options = Options()
1818
1819    self.options = options
1820    self.log = log
1821    self.unicodes_requested = set()
1822    self.glyphs_requested = set()
1823    self.glyphs = set()
1824
1825  def populate(self, glyphs=[], unicodes=[], text=""):
1826    self.unicodes_requested.update(unicodes)
1827    if isinstance(text, str):
1828      text = text.decode("utf8")
1829    for u in text:
1830      self.unicodes_requested.add(ord(u))
1831    self.glyphs_requested.update(glyphs)
1832    self.glyphs.update(glyphs)
1833
1834  def _prune_pre_subset(self, font):
1835
1836    for tag in font.keys():
1837      if tag == 'GlyphOrder': continue
1838
1839      if(tag in self.options.drop_tables or
1840         (tag in self.options.hinting_tables and not self.options.hinting)):
1841        self.log(tag, "dropped")
1842        del font[tag]
1843        continue
1844
1845      clazz = ttLib.getTableClass(tag)
1846
1847      if hasattr(clazz, 'prune_pre_subset'):
1848        table = font[tag]
1849        self.log.lapse("load '%s'" % tag)
1850        retain = table.prune_pre_subset(self.options)
1851        self.log.lapse("prune  '%s'" % tag)
1852        if not retain:
1853          self.log(tag, "pruned to empty; dropped")
1854          del font[tag]
1855          continue
1856        else:
1857          self.log(tag, "pruned")
1858
1859  def _closure_glyphs(self, font):
1860
1861    self.glyphs = self.glyphs_requested.copy()
1862
1863    if 'cmap' in font:
1864      font['cmap'].closure_glyphs(self)
1865    self.glyphs_cmaped = self.glyphs
1866
1867    if self.options.notdef_glyph:
1868      if 'glyf' in font:
1869        self.glyphs.add(font.getGlyphName(0))
1870        self.log("Added gid0 to subset")
1871      else:
1872        self.glyphs.add('.notdef')
1873        self.log("Added .notdef to subset")
1874    if self.options.recommended_glyphs:
1875      if 'glyf' in font:
1876        for i in range(4):
1877          self.glyphs.add(font.getGlyphName(i))
1878        self.log("Added first four glyphs to subset")
1879
1880    if 'GSUB' in font:
1881      self.log("Closing glyph list over 'GSUB': %d glyphs before" %
1882                len(self.glyphs))
1883      self.log.glyphs(self.glyphs, font=font)
1884      font['GSUB'].closure_glyphs(self)
1885      self.log("Closed  glyph list over 'GSUB': %d glyphs after" %
1886                len(self.glyphs))
1887      self.log.glyphs(self.glyphs, font=font)
1888      self.log.lapse("close glyph list over 'GSUB'")
1889    self.glyphs_gsubed = self.glyphs.copy()
1890
1891    if 'glyf' in font:
1892      self.log("Closing glyph list over 'glyf': %d glyphs before" %
1893                len(self.glyphs))
1894      self.log.glyphs(self.glyphs, font=font)
1895      font['glyf'].closure_glyphs(self)
1896      self.log("Closed  glyph list over 'glyf': %d glyphs after" %
1897                len(self.glyphs))
1898      self.log.glyphs(self.glyphs, font=font)
1899      self.log.lapse("close glyph list over 'glyf'")
1900    self.glyphs_glyfed = self.glyphs.copy()
1901
1902    self.glyphs_all = self.glyphs.copy()
1903
1904    self.log("Retaining %d glyphs: " % len(self.glyphs_all))
1905
1906  def _subset_glyphs(self, font):
1907    for tag in font.keys():
1908      if tag == 'GlyphOrder': continue
1909      clazz = ttLib.getTableClass(tag)
1910
1911      if tag in self.options.no_subset_tables:
1912        self.log(tag, "subsetting not needed")
1913      elif hasattr(clazz, 'subset_glyphs'):
1914        table = font[tag]
1915        self.glyphs = self.glyphs_all
1916        retain = table.subset_glyphs(self)
1917        self.glyphs = self.glyphs_all
1918        self.log.lapse("subset '%s'" % tag)
1919        if not retain:
1920          self.log(tag, "subsetted to empty; dropped")
1921          del font[tag]
1922        else:
1923          self.log(tag, "subsetted")
1924      else:
1925        self.log(tag, "NOT subset; don't know how to subset; dropped")
1926        del font[tag]
1927
1928    glyphOrder = font.getGlyphOrder()
1929    glyphOrder = [g for g in glyphOrder if g in self.glyphs_all]
1930    font.setGlyphOrder(glyphOrder)
1931    font._buildReverseGlyphOrderDict()
1932    self.log.lapse("subset GlyphOrder")
1933
1934  def _prune_post_subset(self, font):
1935    for tag in font.keys():
1936      if tag == 'GlyphOrder': continue
1937      clazz = ttLib.getTableClass(tag)
1938      if hasattr(clazz, 'prune_post_subset'):
1939        table = font[tag]
1940        retain = table.prune_post_subset(self.options)
1941        self.log.lapse("prune  '%s'" % tag)
1942        if not retain:
1943          self.log(tag, "pruned to empty; dropped")
1944          del font[tag]
1945        else:
1946          self.log(tag, "pruned")
1947
1948  def subset(self, font):
1949
1950    self._prune_pre_subset(font)
1951    self._closure_glyphs(font)
1952    self._subset_glyphs(font)
1953    self._prune_post_subset(font)
1954
1955
1956class Logger(object):
1957
1958  def __init__(self, verbose=False, xml=False, timing=False):
1959    self.verbose = verbose
1960    self.xml = xml
1961    self.timing = timing
1962    self.last_time = self.start_time = time.time()
1963
1964  def parse_opts(self, argv):
1965    argv = argv[:]
1966    for v in ['verbose', 'xml', 'timing']:
1967      if "--"+v in argv:
1968        setattr(self, v, True)
1969        argv.remove("--"+v)
1970    return argv
1971
1972  def __call__(self, *things):
1973    if not self.verbose:
1974      return
1975    print ' '.join(str(x) for x in things)
1976
1977  def lapse(self, *things):
1978    if not self.timing:
1979      return
1980    new_time = time.time()
1981    print "Took %0.3fs to %s" %(new_time - self.last_time,
1982                                 ' '.join(str(x) for x in things))
1983    self.last_time = new_time
1984
1985  def glyphs(self, glyphs, font=None):
1986    self("Names: ", sorted(glyphs))
1987    if font:
1988      reverseGlyphMap = font.getReverseGlyphMap()
1989      self("Gids : ", sorted(reverseGlyphMap[g] for g in glyphs))
1990
1991  def font(self, font, file=sys.stdout):
1992    if not self.xml:
1993      return
1994    from fontTools.misc import xmlWriter
1995    writer = xmlWriter.XMLWriter(file)
1996    font.disassembleInstructions = False  # Work around ttLib bug
1997    for tag in font.keys():
1998      writer.begintag(tag)
1999      writer.newline()
2000      font[tag].toXML(writer, font)
2001      writer.endtag(tag)
2002      writer.newline()
2003
2004
2005def load_font(fontFile,
2006              options,
2007              checkChecksums=False,
2008              dontLoadGlyphNames=False):
2009
2010  font = ttLib.TTFont(fontFile,
2011                                checkChecksums=checkChecksums,
2012                                recalcBBoxes=options.recalc_bounds)
2013
2014  # Hack:
2015  #
2016  # If we don't need glyph names, change 'post' class to not try to
2017  # load them.  It avoid lots of headache with broken fonts as well
2018  # as loading time.
2019  #
2020  # Ideally ttLib should provide a way to ask it to skip loading
2021  # glyph names.  But it currently doesn't provide such a thing.
2022  #
2023  if dontLoadGlyphNames:
2024    post = ttLib.getTableClass('post')
2025    saved = post.decode_format_2_0
2026    post.decode_format_2_0 = post.decode_format_3_0
2027    f = font['post']
2028    if f.formatType == 2.0:
2029      f.formatType = 3.0
2030    post.decode_format_2_0 = saved
2031
2032  return font
2033
2034def save_font(font, outfile, options):
2035  if options.flavor and not hasattr(font, 'flavor'):
2036    raise Exception("fonttools version does not support flavors.")
2037  font.flavor = options.flavor
2038  font.save(outfile, reorderTables=options.canonical_order)
2039
2040def main(args):
2041
2042  log = Logger()
2043  args = log.parse_opts(args)
2044
2045  options = Options()
2046  args = options.parse_opts(args, ignore_unknown=['text'])
2047
2048  if len(args) < 2:
2049    print >>sys.stderr, "usage: pyftsubset font-file glyph... [--text=ABC]... [--option=value]..."
2050    sys.exit(1)
2051
2052  fontfile = args[0]
2053  args = args[1:]
2054
2055  dontLoadGlyphNames =(not options.glyph_names and
2056         all(any(g.startswith(p)
2057             for p in ['gid', 'glyph', 'uni', 'U+'])
2058              for g in args))
2059
2060  font = load_font(fontfile, options, dontLoadGlyphNames=dontLoadGlyphNames)
2061  subsetter = Subsetter(options=options, log=log)
2062  log.lapse("load font")
2063
2064  names = font.getGlyphNames()
2065  log.lapse("loading glyph names")
2066
2067  glyphs = []
2068  unicodes = []
2069  text = ""
2070  for g in args:
2071    if g == '*':
2072      glyphs.extend(font.getGlyphOrder())
2073      continue
2074    if g in names:
2075      glyphs.append(g)
2076      continue
2077    if g.startswith('--text='):
2078      text += g[7:]
2079      continue
2080    if g.startswith('uni') or g.startswith('U+'):
2081      if g.startswith('uni') and len(g) > 3:
2082        g = g[3:]
2083      elif g.startswith('U+') and len(g) > 2:
2084        g = g[2:]
2085      u = int(g, 16)
2086      unicodes.append(u)
2087      continue
2088    if g.startswith('gid') or g.startswith('glyph'):
2089      if g.startswith('gid') and len(g) > 3:
2090        g = g[3:]
2091      elif g.startswith('glyph') and len(g) > 5:
2092        g = g[5:]
2093      try:
2094        glyphs.append(font.getGlyphName(int(g), requireReal=1))
2095      except ValueError:
2096        raise Exception("Invalid glyph identifier: %s" % g)
2097      continue
2098    raise Exception("Invalid glyph identifier: %s" % g)
2099  log.lapse("compile glyph list")
2100  log("Unicodes:", unicodes)
2101  log("Glyphs:", glyphs)
2102
2103  subsetter.populate(glyphs=glyphs, unicodes=unicodes, text=text)
2104  subsetter.subset(font)
2105
2106  outfile = fontfile + '.subset'
2107
2108  save_font (font, outfile, options)
2109  log.lapse("compile and save font")
2110
2111  log.last_time = log.start_time
2112  log.lapse("make one with everything(TOTAL TIME)")
2113
2114  if log.verbose:
2115    import os
2116    log("Input  font: %d bytes" % os.path.getsize(fontfile))
2117    log("Subset font: %d bytes" % os.path.getsize(outfile))
2118
2119  log.font(font)
2120
2121  font.close()
2122
2123
2124__all__ = [
2125  'Options',
2126  'Subsetter',
2127  'Logger',
2128  'load_font',
2129  'save_font',
2130  'main'
2131]
2132
2133if __name__ == '__main__':
2134  main(sys.argv[1:])
2135