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