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