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