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