859 lines
24 KiB
Python
859 lines
24 KiB
Python
from __future__ import print_function, division, absolute_import
|
|
from fontTools.misc.py23 import *
|
|
from .DefaultTable import DefaultTable
|
|
import struct
|
|
|
|
class OverflowErrorRecord(object):
|
|
def __init__(self, overflowTuple):
|
|
self.tableType = overflowTuple[0]
|
|
self.LookupListIndex = overflowTuple[1]
|
|
self.SubTableIndex = overflowTuple[2]
|
|
self.itemName = overflowTuple[3]
|
|
self.itemIndex = overflowTuple[4]
|
|
|
|
def __repr__(self):
|
|
return str((self.tableType, "LookupIndex:", self.LookupListIndex, "SubTableIndex:", self.SubTableIndex, "ItemName:", self.itemName, "ItemIndex:", self.itemIndex))
|
|
|
|
class OTLOffsetOverflowError(Exception):
|
|
def __init__(self, overflowErrorRecord):
|
|
self.value = overflowErrorRecord
|
|
|
|
def __str__(self):
|
|
return repr(self.value)
|
|
|
|
|
|
class BaseTTXConverter(DefaultTable):
|
|
|
|
"""Generic base class for TTX table converters. It functions as an
|
|
adapter between the TTX (ttLib actually) table model and the model
|
|
we use for OpenType tables, which is necessarily subtly different.
|
|
"""
|
|
|
|
def decompile(self, data, font):
|
|
from . import otTables
|
|
cachingStats = None if True else {}
|
|
class GlobalState(object):
|
|
def __init__(self, tableType, cachingStats):
|
|
self.tableType = tableType
|
|
self.cachingStats = cachingStats
|
|
globalState = GlobalState(tableType=self.tableTag,
|
|
cachingStats=cachingStats)
|
|
reader = OTTableReader(data, globalState)
|
|
tableClass = getattr(otTables, self.tableTag)
|
|
self.table = tableClass()
|
|
self.table.decompile(reader, font)
|
|
if cachingStats:
|
|
stats = sorted([(v, k) for k, v in cachingStats.items()])
|
|
stats.reverse()
|
|
print("cachingsstats for ", self.tableTag)
|
|
for v, k in stats:
|
|
if v < 2:
|
|
break
|
|
print(v, k)
|
|
print("---", len(stats))
|
|
|
|
def compile(self, font):
|
|
""" Create a top-level OTFWriter for the GPOS/GSUB table.
|
|
Call the compile method for the the table
|
|
for each 'converter' record in the table converter list
|
|
call converter's write method for each item in the value.
|
|
- For simple items, the write method adds a string to the
|
|
writer's self.items list.
|
|
- For Struct/Table/Subtable items, it add first adds new writer to the
|
|
to the writer's self.items, then calls the item's compile method.
|
|
This creates a tree of writers, rooted at the GUSB/GPOS writer, with
|
|
each writer representing a table, and the writer.items list containing
|
|
the child data strings and writers.
|
|
call the getAllData method
|
|
call _doneWriting, which removes duplicates
|
|
call _gatherTables. This traverses the tables, adding unique occurences to a flat list of tables
|
|
Traverse the flat list of tables, calling getDataLength on each to update their position
|
|
Traverse the flat list of tables again, calling getData each get the data in the table, now that
|
|
pos's and offset are known.
|
|
|
|
If a lookup subtable overflows an offset, we have to start all over.
|
|
"""
|
|
class GlobalState(object):
|
|
def __init__(self, tableType):
|
|
self.tableType = tableType
|
|
globalState = GlobalState(tableType=self.tableTag)
|
|
overflowRecord = None
|
|
|
|
while True:
|
|
try:
|
|
writer = OTTableWriter(globalState)
|
|
self.table.compile(writer, font)
|
|
return writer.getAllData()
|
|
|
|
except OTLOffsetOverflowError as e:
|
|
|
|
if overflowRecord == e.value:
|
|
raise # Oh well...
|
|
|
|
overflowRecord = e.value
|
|
print("Attempting to fix OTLOffsetOverflowError", e)
|
|
lastItem = overflowRecord
|
|
|
|
ok = 0
|
|
if overflowRecord.itemName is None:
|
|
from .otTables import fixLookupOverFlows
|
|
ok = fixLookupOverFlows(font, overflowRecord)
|
|
else:
|
|
from .otTables import fixSubTableOverFlows
|
|
ok = fixSubTableOverFlows(font, overflowRecord)
|
|
if not ok:
|
|
raise
|
|
|
|
def toXML(self, writer, font):
|
|
self.table.toXML2(writer, font)
|
|
|
|
def fromXML(self, name, attrs, content, font):
|
|
from . import otTables
|
|
if not hasattr(self, "table"):
|
|
tableClass = getattr(otTables, self.tableTag)
|
|
self.table = tableClass()
|
|
self.table.fromXML(name, attrs, content, font)
|
|
|
|
|
|
class OTTableReader(object):
|
|
|
|
"""Helper class to retrieve data from an OpenType table."""
|
|
|
|
__slots__ = ('data', 'offset', 'pos', 'globalState', 'localState')
|
|
|
|
def __init__(self, data, globalState={}, localState=None, offset=0):
|
|
self.data = data
|
|
self.offset = offset
|
|
self.pos = offset
|
|
self.globalState = globalState
|
|
self.localState = localState
|
|
|
|
def getSubReader(self, offset):
|
|
offset = self.offset + offset
|
|
cachingStats = self.globalState.cachingStats
|
|
if cachingStats is not None:
|
|
cachingStats[offset] = cachingStats.get(offset, 0) + 1
|
|
return self.__class__(self.data, self.globalState, self.localState, offset)
|
|
|
|
def readUShort(self):
|
|
pos = self.pos
|
|
newpos = pos + 2
|
|
value, = struct.unpack(">H", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readShort(self):
|
|
pos = self.pos
|
|
newpos = pos + 2
|
|
value, = struct.unpack(">h", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readLong(self):
|
|
pos = self.pos
|
|
newpos = pos + 4
|
|
value, = struct.unpack(">l", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readUInt24(self):
|
|
pos = self.pos
|
|
newpos = pos + 3
|
|
value, = struct.unpack(">l", b'\0'+self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readULong(self):
|
|
pos = self.pos
|
|
newpos = pos + 4
|
|
value, = struct.unpack(">L", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readTag(self):
|
|
pos = self.pos
|
|
newpos = pos + 4
|
|
value = Tag(self.data[pos:newpos])
|
|
assert len(value) == 4
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def __setitem__(self, name, value):
|
|
state = self.localState.copy() if self.localState else dict()
|
|
state[name] = value
|
|
self.localState = state
|
|
|
|
def __getitem__(self, name):
|
|
return self.localState[name]
|
|
|
|
|
|
class OTTableWriter(object):
|
|
|
|
"""Helper class to gather and assemble data for OpenType tables."""
|
|
|
|
def __init__(self, globalState, localState=None):
|
|
self.items = []
|
|
self.pos = None
|
|
self.globalState = globalState
|
|
self.localState = localState
|
|
self.parent = None
|
|
|
|
def __setitem__(self, name, value):
|
|
state = self.localState.copy() if self.localState else dict()
|
|
state[name] = value
|
|
self.localState = state
|
|
|
|
def __getitem__(self, name):
|
|
return self.localState[name]
|
|
|
|
# assembler interface
|
|
|
|
def getAllData(self):
|
|
"""Assemble all data, including all subtables."""
|
|
self._doneWriting()
|
|
tables, extTables = self._gatherTables()
|
|
tables.reverse()
|
|
extTables.reverse()
|
|
# Gather all data in two passes: the absolute positions of all
|
|
# subtable are needed before the actual data can be assembled.
|
|
pos = 0
|
|
for table in tables:
|
|
table.pos = pos
|
|
pos = pos + table.getDataLength()
|
|
|
|
for table in extTables:
|
|
table.pos = pos
|
|
pos = pos + table.getDataLength()
|
|
|
|
data = []
|
|
for table in tables:
|
|
tableData = table.getData()
|
|
data.append(tableData)
|
|
|
|
for table in extTables:
|
|
tableData = table.getData()
|
|
data.append(tableData)
|
|
|
|
return bytesjoin(data)
|
|
|
|
def getDataLength(self):
|
|
"""Return the length of this table in bytes, without subtables."""
|
|
l = 0
|
|
for item in self.items:
|
|
if hasattr(item, "getData") or hasattr(item, "getCountData"):
|
|
if item.longOffset:
|
|
l = l + 4 # sizeof(ULong)
|
|
else:
|
|
l = l + 2 # sizeof(UShort)
|
|
else:
|
|
l = l + len(item)
|
|
return l
|
|
|
|
def getData(self):
|
|
"""Assemble the data for this writer/table, without subtables."""
|
|
items = list(self.items) # make a shallow copy
|
|
pos = self.pos
|
|
numItems = len(items)
|
|
for i in range(numItems):
|
|
item = items[i]
|
|
|
|
if hasattr(item, "getData"):
|
|
if item.longOffset:
|
|
items[i] = packULong(item.pos - pos)
|
|
else:
|
|
try:
|
|
items[i] = packUShort(item.pos - pos)
|
|
except struct.error:
|
|
# provide data to fix overflow problem.
|
|
# If the overflow is to a lookup, or from a lookup to a subtable,
|
|
# just report the current item. Otherwise...
|
|
if self.name not in [ 'LookupList', 'Lookup']:
|
|
# overflow is within a subTable. Life is more complicated.
|
|
# If we split the sub-table just before the current item, we may still suffer overflow.
|
|
# This is because duplicate table merging is done only within an Extension subTable tree;
|
|
# when we split the subtable in two, some items may no longer be duplicates.
|
|
# Get worst case by adding up all the item lengths, depth first traversal.
|
|
# and then report the first item that overflows a short.
|
|
def getDeepItemLength(table):
|
|
if hasattr(table, "getDataLength"):
|
|
length = 0
|
|
for item in table.items:
|
|
length = length + getDeepItemLength(item)
|
|
else:
|
|
length = len(table)
|
|
return length
|
|
|
|
length = self.getDataLength()
|
|
if hasattr(self, "sortCoverageLast") and item.name == "Coverage":
|
|
# Coverage is first in the item list, but last in the table list,
|
|
# The original overflow is really in the item list. Skip the Coverage
|
|
# table in the following test.
|
|
items = items[i+1:]
|
|
|
|
for j in range(len(items)):
|
|
item = items[j]
|
|
length = length + getDeepItemLength(item)
|
|
if length > 65535:
|
|
break
|
|
overflowErrorRecord = self.getOverflowErrorRecord(item)
|
|
|
|
raise OTLOffsetOverflowError(overflowErrorRecord)
|
|
|
|
return bytesjoin(items)
|
|
|
|
def __hash__(self):
|
|
# only works after self._doneWriting() has been called
|
|
return hash(self.items)
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
def __eq__(self, other):
|
|
if type(self) != type(other):
|
|
return NotImplemented
|
|
return self.items == other.items
|
|
|
|
def _doneWriting(self, internedTables=None):
|
|
# Convert CountData references to data string items
|
|
# collapse duplicate table references to a unique entry
|
|
# "tables" are OTTableWriter objects.
|
|
|
|
# For Extension Lookup types, we can
|
|
# eliminate duplicates only within the tree under the Extension Lookup,
|
|
# as offsets may exceed 64K even between Extension LookupTable subtables.
|
|
if internedTables is None:
|
|
internedTables = {}
|
|
items = self.items
|
|
iRange = list(range(len(items)))
|
|
|
|
if hasattr(self, "Extension"):
|
|
newTree = 1
|
|
else:
|
|
newTree = 0
|
|
for i in iRange:
|
|
item = items[i]
|
|
if hasattr(item, "getCountData"):
|
|
items[i] = item.getCountData()
|
|
elif hasattr(item, "getData"):
|
|
if newTree:
|
|
item._doneWriting()
|
|
else:
|
|
item._doneWriting(internedTables)
|
|
internedItem = internedTables.get(item)
|
|
if internedItem:
|
|
items[i] = item = internedItem
|
|
else:
|
|
internedTables[item] = item
|
|
self.items = tuple(items)
|
|
|
|
def _gatherTables(self, tables=None, extTables=None, done=None):
|
|
# Convert table references in self.items tree to a flat
|
|
# list of tables in depth-first traversal order.
|
|
# "tables" are OTTableWriter objects.
|
|
# We do the traversal in reverse order at each level, in order to
|
|
# resolve duplicate references to be the last reference in the list of tables.
|
|
# For extension lookups, duplicate references can be merged only within the
|
|
# writer tree under the extension lookup.
|
|
if tables is None: # init call for first time.
|
|
tables = []
|
|
extTables = []
|
|
done = {}
|
|
|
|
done[self] = 1
|
|
|
|
numItems = len(self.items)
|
|
iRange = list(range(numItems))
|
|
iRange.reverse()
|
|
|
|
if hasattr(self, "Extension"):
|
|
appendExtensions = 1
|
|
else:
|
|
appendExtensions = 0
|
|
|
|
# add Coverage table if it is sorted last.
|
|
sortCoverageLast = 0
|
|
if hasattr(self, "sortCoverageLast"):
|
|
# Find coverage table
|
|
for i in range(numItems):
|
|
item = self.items[i]
|
|
if hasattr(item, "name") and (item.name == "Coverage"):
|
|
sortCoverageLast = 1
|
|
break
|
|
if item not in done:
|
|
item._gatherTables(tables, extTables, done)
|
|
else:
|
|
# We're a new parent of item
|
|
pass
|
|
|
|
for i in iRange:
|
|
item = self.items[i]
|
|
if not hasattr(item, "getData"):
|
|
continue
|
|
|
|
if sortCoverageLast and (i==1) and item.name == 'Coverage':
|
|
# we've already 'gathered' it above
|
|
continue
|
|
|
|
if appendExtensions:
|
|
assert extTables is not None, "Program or XML editing error. Extension subtables cannot contain extensions subtables"
|
|
newDone = {}
|
|
item._gatherTables(extTables, None, newDone)
|
|
|
|
elif item not in done:
|
|
item._gatherTables(tables, extTables, done)
|
|
else:
|
|
# We're a new parent of item
|
|
pass
|
|
|
|
tables.append(self)
|
|
return tables, extTables
|
|
|
|
# interface for gathering data, as used by table.compile()
|
|
|
|
def getSubWriter(self):
|
|
subwriter = self.__class__(self.globalState, self.localState)
|
|
subwriter.parent = self # because some subtables have idential values, we discard
|
|
# the duplicates under the getAllData method. Hence some
|
|
# subtable writers can have more than one parent writer.
|
|
# But we just care about first one right now.
|
|
return subwriter
|
|
|
|
def writeUShort(self, value):
|
|
assert 0 <= value < 0x10000
|
|
self.items.append(struct.pack(">H", value))
|
|
|
|
def writeShort(self, value):
|
|
self.items.append(struct.pack(">h", value))
|
|
|
|
def writeUInt24(self, value):
|
|
assert 0 <= value < 0x1000000
|
|
b = struct.pack(">L", value)
|
|
self.items.append(b[1:])
|
|
|
|
def writeLong(self, value):
|
|
self.items.append(struct.pack(">l", value))
|
|
|
|
def writeULong(self, value):
|
|
self.items.append(struct.pack(">L", value))
|
|
|
|
def writeTag(self, tag):
|
|
tag = Tag(tag).tobytes()
|
|
assert len(tag) == 4
|
|
self.items.append(tag)
|
|
|
|
def writeSubTable(self, subWriter):
|
|
self.items.append(subWriter)
|
|
|
|
def writeCountReference(self, table, name):
|
|
ref = CountReference(table, name)
|
|
self.items.append(ref)
|
|
return ref
|
|
|
|
def writeStruct(self, format, values):
|
|
data = struct.pack(*(format,) + values)
|
|
self.items.append(data)
|
|
|
|
def writeData(self, data):
|
|
self.items.append(data)
|
|
|
|
def getOverflowErrorRecord(self, item):
|
|
LookupListIndex = SubTableIndex = itemName = itemIndex = None
|
|
if self.name == 'LookupList':
|
|
LookupListIndex = item.repeatIndex
|
|
elif self.name == 'Lookup':
|
|
LookupListIndex = self.repeatIndex
|
|
SubTableIndex = item.repeatIndex
|
|
else:
|
|
itemName = item.name
|
|
if hasattr(item, 'repeatIndex'):
|
|
itemIndex = item.repeatIndex
|
|
if self.name == 'SubTable':
|
|
LookupListIndex = self.parent.repeatIndex
|
|
SubTableIndex = self.repeatIndex
|
|
elif self.name == 'ExtSubTable':
|
|
LookupListIndex = self.parent.parent.repeatIndex
|
|
SubTableIndex = self.parent.repeatIndex
|
|
else: # who knows how far below the SubTable level we are! Climb back up to the nearest subtable.
|
|
itemName = ".".join([self.name, item.name])
|
|
p1 = self.parent
|
|
while p1 and p1.name not in ['ExtSubTable', 'SubTable']:
|
|
itemName = ".".join([p1.name, item.name])
|
|
p1 = p1.parent
|
|
if p1:
|
|
if p1.name == 'ExtSubTable':
|
|
LookupListIndex = p1.parent.parent.repeatIndex
|
|
SubTableIndex = p1.parent.repeatIndex
|
|
else:
|
|
LookupListIndex = p1.parent.repeatIndex
|
|
SubTableIndex = p1.repeatIndex
|
|
|
|
return OverflowErrorRecord( (self.globalState.tableType, LookupListIndex, SubTableIndex, itemName, itemIndex) )
|
|
|
|
|
|
class CountReference(object):
|
|
"""A reference to a Count value, not a count of references."""
|
|
def __init__(self, table, name):
|
|
self.table = table
|
|
self.name = name
|
|
def setValue(self, value):
|
|
table = self.table
|
|
name = self.name
|
|
if table[name] is None:
|
|
table[name] = value
|
|
else:
|
|
assert table[name] == value, (name, table[name], value)
|
|
def getCountData(self):
|
|
return packUShort(self.table[self.name])
|
|
|
|
|
|
def packUShort(value):
|
|
return struct.pack(">H", value)
|
|
|
|
|
|
def packULong(value):
|
|
assert 0 <= value < 0x100000000, value
|
|
return struct.pack(">L", value)
|
|
|
|
|
|
class BaseTable(object):
|
|
|
|
"""Generic base class for all OpenType (sub)tables."""
|
|
|
|
def __getattr__(self, attr):
|
|
reader = self.__dict__.get("reader")
|
|
if reader:
|
|
del self.reader
|
|
font = self.font
|
|
del self.font
|
|
self.decompile(reader, font)
|
|
return getattr(self, attr)
|
|
|
|
raise AttributeError(attr)
|
|
|
|
def ensureDecompiled(self):
|
|
reader = self.__dict__.get("reader")
|
|
if reader:
|
|
del self.reader
|
|
font = self.font
|
|
del self.font
|
|
self.decompile(reader, font)
|
|
|
|
def getConverters(self):
|
|
return self.converters
|
|
|
|
def getConverterByName(self, name):
|
|
return self.convertersByName[name]
|
|
|
|
def decompile(self, reader, font):
|
|
self.readFormat(reader)
|
|
table = {}
|
|
self.__rawTable = table # for debugging
|
|
converters = self.getConverters()
|
|
for conv in converters:
|
|
if conv.name == "SubTable":
|
|
conv = conv.getConverter(reader.globalState.tableType,
|
|
table["LookupType"])
|
|
if conv.name == "ExtSubTable":
|
|
conv = conv.getConverter(reader.globalState.tableType,
|
|
table["ExtensionLookupType"])
|
|
if conv.name == "FeatureParams":
|
|
conv = conv.getConverter(reader["FeatureTag"])
|
|
if conv.repeat:
|
|
if conv.repeat in table:
|
|
countValue = table[conv.repeat]
|
|
else:
|
|
# conv.repeat is a propagated count
|
|
countValue = reader[conv.repeat]
|
|
countValue += conv.aux
|
|
table[conv.name] = conv.readArray(reader, font, table, countValue)
|
|
else:
|
|
if conv.aux and not eval(conv.aux, None, table):
|
|
continue
|
|
table[conv.name] = conv.read(reader, font, table)
|
|
if conv.isPropagated:
|
|
reader[conv.name] = table[conv.name]
|
|
|
|
self.postRead(table, font)
|
|
|
|
del self.__rawTable # succeeded, get rid of debugging info
|
|
|
|
def compile(self, writer, font):
|
|
self.ensureDecompiled()
|
|
table = self.preWrite(font)
|
|
|
|
if hasattr(self, 'sortCoverageLast'):
|
|
writer.sortCoverageLast = 1
|
|
|
|
if hasattr(self.__class__, 'LookupType'):
|
|
writer['LookupType'].setValue(self.__class__.LookupType)
|
|
|
|
self.writeFormat(writer)
|
|
for conv in self.getConverters():
|
|
value = table.get(conv.name)
|
|
if conv.repeat:
|
|
if value is None:
|
|
value = []
|
|
countValue = len(value) - conv.aux
|
|
if conv.repeat in table:
|
|
CountReference(table, conv.repeat).setValue(countValue)
|
|
else:
|
|
# conv.repeat is a propagated count
|
|
writer[conv.repeat].setValue(countValue)
|
|
conv.writeArray(writer, font, table, value)
|
|
elif conv.isCount:
|
|
# Special-case Count values.
|
|
# Assumption: a Count field will *always* precede
|
|
# the actual array(s).
|
|
# We need a default value, as it may be set later by a nested
|
|
# table. We will later store it here.
|
|
# We add a reference: by the time the data is assembled
|
|
# the Count value will be filled in.
|
|
ref = writer.writeCountReference(table, conv.name)
|
|
table[conv.name] = None
|
|
if conv.isPropagated:
|
|
writer[conv.name] = ref
|
|
elif conv.isLookupType:
|
|
ref = writer.writeCountReference(table, conv.name)
|
|
table[conv.name] = None
|
|
writer['LookupType'] = ref
|
|
else:
|
|
if conv.aux and not eval(conv.aux, None, table):
|
|
continue
|
|
conv.write(writer, font, table, value)
|
|
if conv.isPropagated:
|
|
writer[conv.name] = value
|
|
|
|
def readFormat(self, reader):
|
|
pass
|
|
|
|
def writeFormat(self, writer):
|
|
pass
|
|
|
|
def postRead(self, table, font):
|
|
self.__dict__.update(table)
|
|
|
|
def preWrite(self, font):
|
|
return self.__dict__.copy()
|
|
|
|
def toXML(self, xmlWriter, font, attrs=None, name=None):
|
|
tableName = name if name else self.__class__.__name__
|
|
if attrs is None:
|
|
attrs = []
|
|
if hasattr(self, "Format"):
|
|
attrs = attrs + [("Format", self.Format)]
|
|
xmlWriter.begintag(tableName, attrs)
|
|
xmlWriter.newline()
|
|
self.toXML2(xmlWriter, font)
|
|
xmlWriter.endtag(tableName)
|
|
xmlWriter.newline()
|
|
|
|
def toXML2(self, xmlWriter, font):
|
|
# Simpler variant of toXML, *only* for the top level tables (like GPOS, GSUB).
|
|
# This is because in TTX our parent writes our main tag, and in otBase.py we
|
|
# do it ourselves. I think I'm getting schizophrenic...
|
|
for conv in self.getConverters():
|
|
if conv.repeat:
|
|
value = getattr(self, conv.name)
|
|
for i in range(len(value)):
|
|
item = value[i]
|
|
conv.xmlWrite(xmlWriter, font, item, conv.name,
|
|
[("index", i)])
|
|
else:
|
|
if conv.aux and not eval(conv.aux, None, vars(self)):
|
|
continue
|
|
value = getattr(self, conv.name)
|
|
conv.xmlWrite(xmlWriter, font, value, conv.name, [])
|
|
|
|
def fromXML(self, name, attrs, content, font):
|
|
try:
|
|
conv = self.getConverterByName(name)
|
|
except KeyError:
|
|
raise # XXX on KeyError, raise nice error
|
|
value = conv.xmlRead(attrs, content, font)
|
|
if conv.repeat:
|
|
seq = getattr(self, conv.name, None)
|
|
if seq is None:
|
|
seq = []
|
|
setattr(self, conv.name, seq)
|
|
seq.append(value)
|
|
else:
|
|
setattr(self, conv.name, value)
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
def __eq__(self, other):
|
|
if type(self) != type(other):
|
|
return NotImplemented
|
|
|
|
self.ensureDecompiled()
|
|
other.ensureDecompiled()
|
|
|
|
return self.__dict__ == other.__dict__
|
|
|
|
|
|
class FormatSwitchingBaseTable(BaseTable):
|
|
|
|
"""Minor specialization of BaseTable, for tables that have multiple
|
|
formats, eg. CoverageFormat1 vs. CoverageFormat2."""
|
|
|
|
def getConverters(self):
|
|
return self.converters[self.Format]
|
|
|
|
def getConverterByName(self, name):
|
|
return self.convertersByName[self.Format][name]
|
|
|
|
def readFormat(self, reader):
|
|
self.Format = reader.readUShort()
|
|
assert self.Format != 0, (self, reader.pos, len(reader.data))
|
|
|
|
def writeFormat(self, writer):
|
|
writer.writeUShort(self.Format)
|
|
|
|
def toXML(self, xmlWriter, font, attrs=None, name=None):
|
|
BaseTable.toXML(self, xmlWriter, font, attrs, name=self.__class__.__name__)
|
|
|
|
|
|
#
|
|
# Support for ValueRecords
|
|
#
|
|
# This data type is so different from all other OpenType data types that
|
|
# it requires quite a bit of code for itself. It even has special support
|
|
# in OTTableReader and OTTableWriter...
|
|
#
|
|
|
|
valueRecordFormat = [
|
|
# Mask Name isDevice signed
|
|
(0x0001, "XPlacement", 0, 1),
|
|
(0x0002, "YPlacement", 0, 1),
|
|
(0x0004, "XAdvance", 0, 1),
|
|
(0x0008, "YAdvance", 0, 1),
|
|
(0x0010, "XPlaDevice", 1, 0),
|
|
(0x0020, "YPlaDevice", 1, 0),
|
|
(0x0040, "XAdvDevice", 1, 0),
|
|
(0x0080, "YAdvDevice", 1, 0),
|
|
# reserved:
|
|
(0x0100, "Reserved1", 0, 0),
|
|
(0x0200, "Reserved2", 0, 0),
|
|
(0x0400, "Reserved3", 0, 0),
|
|
(0x0800, "Reserved4", 0, 0),
|
|
(0x1000, "Reserved5", 0, 0),
|
|
(0x2000, "Reserved6", 0, 0),
|
|
(0x4000, "Reserved7", 0, 0),
|
|
(0x8000, "Reserved8", 0, 0),
|
|
]
|
|
|
|
def _buildDict():
|
|
d = {}
|
|
for mask, name, isDevice, signed in valueRecordFormat:
|
|
d[name] = mask, isDevice, signed
|
|
return d
|
|
|
|
valueRecordFormatDict = _buildDict()
|
|
|
|
|
|
class ValueRecordFactory(object):
|
|
|
|
"""Given a format code, this object convert ValueRecords."""
|
|
|
|
def __init__(self, valueFormat):
|
|
format = []
|
|
for mask, name, isDevice, signed in valueRecordFormat:
|
|
if valueFormat & mask:
|
|
format.append((name, isDevice, signed))
|
|
self.format = format
|
|
|
|
def readValueRecord(self, reader, font):
|
|
format = self.format
|
|
if not format:
|
|
return None
|
|
valueRecord = ValueRecord()
|
|
for name, isDevice, signed in format:
|
|
if signed:
|
|
value = reader.readShort()
|
|
else:
|
|
value = reader.readUShort()
|
|
if isDevice:
|
|
if value:
|
|
from . import otTables
|
|
subReader = reader.getSubReader(value)
|
|
value = getattr(otTables, name)()
|
|
value.decompile(subReader, font)
|
|
else:
|
|
value = None
|
|
setattr(valueRecord, name, value)
|
|
return valueRecord
|
|
|
|
def writeValueRecord(self, writer, font, valueRecord):
|
|
for name, isDevice, signed in self.format:
|
|
value = getattr(valueRecord, name, 0)
|
|
if isDevice:
|
|
if value:
|
|
subWriter = writer.getSubWriter()
|
|
writer.writeSubTable(subWriter)
|
|
value.compile(subWriter, font)
|
|
else:
|
|
writer.writeUShort(0)
|
|
elif signed:
|
|
writer.writeShort(value)
|
|
else:
|
|
writer.writeUShort(value)
|
|
|
|
|
|
class ValueRecord(object):
|
|
|
|
# see ValueRecordFactory
|
|
|
|
def getFormat(self):
|
|
format = 0
|
|
for name in self.__dict__.keys():
|
|
format = format | valueRecordFormatDict[name][0]
|
|
return format
|
|
|
|
def toXML(self, xmlWriter, font, valueName, attrs=None):
|
|
if attrs is None:
|
|
simpleItems = []
|
|
else:
|
|
simpleItems = list(attrs)
|
|
for mask, name, isDevice, format in valueRecordFormat[:4]: # "simple" values
|
|
if hasattr(self, name):
|
|
simpleItems.append((name, getattr(self, name)))
|
|
deviceItems = []
|
|
for mask, name, isDevice, format in valueRecordFormat[4:8]: # device records
|
|
if hasattr(self, name):
|
|
device = getattr(self, name)
|
|
if device is not None:
|
|
deviceItems.append((name, device))
|
|
if deviceItems:
|
|
xmlWriter.begintag(valueName, simpleItems)
|
|
xmlWriter.newline()
|
|
for name, deviceRecord in deviceItems:
|
|
if deviceRecord is not None:
|
|
deviceRecord.toXML(xmlWriter, font)
|
|
xmlWriter.endtag(valueName)
|
|
xmlWriter.newline()
|
|
else:
|
|
xmlWriter.simpletag(valueName, simpleItems)
|
|
xmlWriter.newline()
|
|
|
|
def fromXML(self, name, attrs, content, font):
|
|
from . import otTables
|
|
for k, v in attrs.items():
|
|
setattr(self, k, int(v))
|
|
for element in content:
|
|
if not isinstance(element, tuple):
|
|
continue
|
|
name, attrs, content = element
|
|
value = getattr(otTables, name)()
|
|
for elem2 in content:
|
|
if not isinstance(elem2, tuple):
|
|
continue
|
|
name2, attrs2, content2 = elem2
|
|
value.fromXML(name2, attrs2, content2, font)
|
|
setattr(self, name, value)
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
def __eq__(self, other):
|
|
if type(self) != type(other):
|
|
return NotImplemented
|
|
return self.__dict__ == other.__dict__
|