| from fontTools.ttLib.ttFont import TTFont |
| from io import BytesIO |
| import struct |
| import logging |
| from contextlib import contextmanager |
| from fontTools.ttLib.sfnt import TTC_V1, TTC_V2, readTTCHeader, writeTTCHeader |
| from fontTools.ttLib.tables.D_S_I_G_ import table_D_S_I_G_ |
| from fontTools.misc.timeTools import timestampNow |
|
|
| log = logging.getLogger(__name__) |
|
|
|
|
| @contextmanager |
| def _sharedModifiedTimestamp(fonts): |
| """Pin a single ``head.modified`` timestamp across an iterable of TTFonts. |
| |
| When several fonts are saved together with ``recalcTimestamp=True``, each |
| one restamps its own ``head`` table via ``timestampNow()``, whose |
| granularity is one second. If the wall clock ticks between two fonts' |
| ``head.compile()`` calls they get different ``modified`` values, which |
| defeats byte-identical table sharing (``shareTables=True``) and makes the |
| saved size non-deterministic. |
| |
| This reads ``timestampNow()`` once (so ``SOURCE_DATE_EPOCH`` is still |
| honored) and applies it to every font that would have recalculated its own |
| timestamp, suppressing the per-font restamp for the duration. Each font's |
| ``recalcTimestamp`` flag is restored on exit, even if the body raises; the |
| pinned ``modified`` value is left in place, matching a normal recalc save. |
| Fonts with ``recalcTimestamp`` falsy, or without a ``head`` table, are left |
| untouched (their ``head`` is not even loaded). |
| |
| See https://github.com/fonttools/fonttools/issues/4110. |
| """ |
| now = timestampNow() |
| restore = [] |
| try: |
| for font in fonts: |
| if font.recalcTimestamp and "head" in font: |
| |
| |
| restore.append((font, font.recalcTimestamp)) |
| font["head"].modified = now |
| font.recalcTimestamp = False |
| yield now |
| finally: |
| for font, recalcTimestamp in restore: |
| font.recalcTimestamp = recalcTimestamp |
|
|
|
|
| class TTCollection(object): |
| """Object representing a TrueType Collection / OpenType Collection. |
| The main API is self.fonts being a list of TTFont instances. |
| |
| If shareTables is True, then different fonts in the collection |
| might point to the same table object if the data for the table was |
| the same in the font file. Note, however, that this might result |
| in suprises and incorrect behavior if the different fonts involved |
| have different GlyphOrder. Use only if you know what you are doing. |
| """ |
|
|
| def __init__(self, file=None, shareTables=False, **kwargs): |
| fonts = self.fonts = [] |
| if file is None: |
| return |
|
|
| assert "fontNumber" not in kwargs, kwargs |
|
|
| closeStream = False |
| if not hasattr(file, "read"): |
| file = open(file, "rb") |
| closeStream = True |
|
|
| tableCache = {} if shareTables else None |
|
|
| header = readTTCHeader(file) |
| for i in range(header.numFonts): |
| font = TTFont(file, fontNumber=i, _tableCache=tableCache, **kwargs) |
| fonts.append(font) |
|
|
| if header.Version == TTC_V2: |
| self.dsig: table_D_S_I_G_ | None = None |
| if header.ulDsigOffset != 0: |
| self.dsig = table_D_S_I_G_("DSIG") |
| file.seek(header.ulDsigOffset, 0) |
| self.dsig.data = file.read(header.ulDsigLength) |
|
|
| |
| |
| |
| |
| |
| if not kwargs.get("lazy") and closeStream: |
| file.close() |
|
|
| def __enter__(self): |
| return self |
|
|
| def __exit__(self, type, value, traceback): |
| self.close() |
|
|
| def close(self): |
| for font in self.fonts: |
| font.close() |
|
|
| def save(self, file, shareTables=True): |
| """Save the font to disk. Similarly to the constructor, |
| the 'file' argument can be either a pathname or a writable |
| file object. |
| """ |
| if not hasattr(file, "write"): |
| final = None |
| file = open(file, "wb") |
| else: |
| |
| |
| final = file |
| file = BytesIO() |
|
|
| tableCache = {} if shareTables else None |
|
|
| |
| version = TTC_V2 if hasattr(self, "dsig") else TTC_V1 |
|
|
| |
| with _sharedModifiedTimestamp(self.fonts): |
| offsets_offset = writeTTCHeader(file, len(self.fonts), version=version) |
| offsets = [] |
| for font in self.fonts: |
| offsets.append(file.tell()) |
| font._save(file, tableCache=tableCache) |
| file.seek(0, 2) |
|
|
| file.seek(offsets_offset) |
| file.write(struct.pack(">%dL" % len(self.fonts), *offsets)) |
|
|
| if version == TTC_V2 and self.dsig is not None: |
| |
| if hasattr(self.dsig, "data"): |
| data = self.dsig.data |
| else: |
| data = self.dsig.compile(None) |
| |
| |
| dsig_header_fields_offset = file.tell() |
| |
| file.seek(0, 2) |
| dsig_offset = file.tell() |
| |
| file.write(data) |
| |
| file.seek(dsig_header_fields_offset) |
| |
| file.write(b"DSIG") |
| |
| file.write(struct.pack(">2L", len(data), dsig_offset)) |
|
|
| if final: |
| final.write(file.getvalue()) |
| file.close() |
|
|
| def saveXML(self, fileOrPath, newlinestr="\n", writeVersion=True, **kwargs): |
| from fontTools.misc import xmlWriter |
|
|
| writer = xmlWriter.XMLWriter(fileOrPath, newlinestr=newlinestr) |
|
|
| if writeVersion: |
| from fontTools import version |
|
|
| version = ".".join(version.split(".")[:2]) |
| writer.begintag("ttCollection", ttLibVersion=version) |
| else: |
| writer.begintag("ttCollection") |
| writer.newline() |
| writer.newline() |
|
|
| for font in self.fonts: |
| font._saveXML(writer, writeVersion=False, **kwargs) |
| writer.newline() |
|
|
| writer.endtag("ttCollection") |
| writer.newline() |
|
|
| writer.close() |
|
|
| def __getitem__(self, item): |
| return self.fonts[item] |
|
|
| def __setitem__(self, item, value): |
| self.fonts[item] = value |
|
|
| def __delitem__(self, item): |
| return self.fonts[item] |
|
|
| def __len__(self): |
| return len(self.fonts) |
|
|
| def __iter__(self): |
| return iter(self.fonts) |
|
|
