def fromXML(self, xxx_todo_changeme, ttFont):
(name, attrs, content) = xxx_todo_changeme
if name == "GMAPs":
if not hasattr(self, "GMAPs"):
self.GMAPs = []
for element in content:
if type(element) is str:
continue
itemName, itemAttrs, itemContent = element
if itemName == "hexdata":
self.GMAPs.append(readHex(itemContent))
elif name == "glyphlets":
if not hasattr(self, "glyphlets"):
self.glyphlets = []
for element in content:
if type(element) is str:
continue
itemName, itemAttrs, itemContent = element
if itemName == "hexdata":
self.glyphlets.append(readHex(itemContent))
else:
value = attrs["value"]
try:
value = safeEval(value)
except OverflowError:
value = int(value)
setattr(self, name, value)
def fromXML(self, xxx_todo_changeme, ttFont): (name, attrs, content) = xxx_todo_changeme if name == "GMAPs": if not hasattr(self, "GMAPs"): self.GMAPs = [] for element in content: if isinstance(element, StringType): continue itemName, itemAttrs, itemContent = element if itemName == "hexdata": self.GMAPs.append(readHex(itemContent)) elif name == "glyphlets": if not hasattr(self, "glyphlets"): self.glyphlets = [] for element in content: if isinstance(element, StringType): continue itemName, itemAttrs, itemContent = element if itemName == "hexdata": self.glyphlets.append(readHex(itemContent)) else: value = attrs["value"] try: value = safeEval(value) except OverflowError: value = int(value) setattr(self, name, value)
def fromXML(self, name, attrs, content):
from fontTools.misc.textTools import binary2num, readHex
if attrs.get("raw"):
self.setBytecode(readHex(content))
return
content = strjoin(content)
content = content.split()
program = []
end = len(content)
i = 0
while i < end:
token = content[i]
i = i + 1
try:
token = int(token)
except ValueError:
try:
token = float(token)
except ValueError:
program.append(token)
if token in ('hintmask', 'cntrmask'):
mask = content[i]
maskBytes = b""
for j in range(0, len(mask), 8):
maskBytes = maskBytes + bytechr(binary2num(mask[j:j+8]))
program.append(maskBytes)
i = i + 1
else:
program.append(token)
else:
program.append(token)
self.setProgram(program)
def fromXML(self, name, attrs, content, ttFont):
from fontTools.misc.textTools import readHex
from fontTools import ttLib
if name != "hexdata":
raise ttLib.TTLibError("can't handle '%s' element" % name)
self.decompile(readHex(content), ttFont)
def fromXML(self, name, attrs, content, ttFont):
from fontTools.misc.textTools import readHex
from fontTools import ttLib
if name != "hexdata":
raise ttLib.TTLibError("can't handle '%s' element" % name)
self.decompile(readHex(content), ttFont)
class DefaultTable:
dependencies = []
def __init__(self, tag):
self.tableTag = tag
def decompile(self, data, ttFont):
self.data = data
def compile(self, ttFont):
return self.data
def toXML(self, writer, ttFont):
if hasattr(self, "ERROR"):
writer.comment(
"An error occurred during the decompilation of this table")
writer.newline()
writer.comment(self.ERROR)
writer.newline()
writer.begintag("hexdata")
writer.newline()
writer.dumphex(self.compile(ttFont))
writer.endtag("hexdata")
writer.newline()
def fromXML(self, (name, attrs, content), ttFont):
from fontTools.misc.textTools import readHex
from fontTools import ttLib
if name <> "hexdata":
raise ttLib.TTLibError, "can't handle '%s' element" % name
self.decompile(readHex(content), ttFont)
def fromXML(self, name, attrs, content, ttFont):
if name == "hexdata":
self.data[attrs["tag"]] = readHex(content)
elif name == "text" and attrs["tag"] in ["dlng", "slng"]:
self.data[attrs["tag"]] = strjoin(content).strip()
else:
raise TTLibError("can't handle '%s' element" % name)
def fromXML(self, name, attrs, content):
from fontTools.misc.textTools import binary2num, readHex
if attrs.get("raw"):
self.setBytecode(readHex(content))
return
content = strjoin(content)
content = content.split()
program = []
end = len(content)
i = 0
while i < end:
token = content[i]
i = i + 1
try:
token = int(token)
except ValueError:
try:
token = float(token)
except ValueError:
program.append(token)
if token in ('hintmask', 'cntrmask'):
mask = content[i]
maskBytes = b""
for j in range(0, len(mask), 8):
maskBytes = maskBytes + bytechr(binary2num(mask[j:j+8]))
program.append(maskBytes)
i = i + 1
else:
program.append(token)
else:
program.append(token)
self.setProgram(program)
def fromXML(self, name, attrs, content, ttFont):
if name == "hexdata":
self.data[attrs["tag"]] = readHex(content)
elif name == "text" and attrs["tag"] in ["dlng", "slng"]:
self.data[attrs["tag"]] = strjoin(content).strip()
else:
raise TTLibError("can't handle '%s' element" % name)
def fromXML(self, name, attrs, content, ttFont, preserveWidths=False):
if name == "assembly":
self.fromAssembly(strjoin(content))
self._assemble(preserveWidths)
del self.assembly
else:
assert name == "bytecode"
self.fromBytecode(readHex(content))
def fromXML(self, name, attrs, content, ttFont): if name == "assembly": self.fromAssembly(strjoin(content)) self._assemble() del self.assembly else: assert name == "bytecode" self.fromBytecode(readHex(content))
def fromXML(self, xxx_todo_changeme, ttFont): (name, attrs, content) = xxx_todo_changeme if name == "assembly": self.fromAssembly(content) self._assemble() del self.assembly else: assert name == "bytecode" self.fromBytecode(readHex(content))
def fromXML(self, xxx_todo_changeme, ttFont):
(name, attrs, content) = xxx_todo_changeme
if name == "assembly":
self.fromAssembly(content)
self._assemble()
del self.assembly
else:
assert name == "bytecode"
self.fromBytecode(readHex(content))
def fromXML(self, name, attrs, content, ttFont):
if name == "ref":
# glyph is a "dupe", i.e. a reference to another glyph's image data.
# in this case imageData contains the glyph id of the reference glyph
# get glyph id from glyphname
self.imageData = struct.pack(">H", ttFont.getGlyphID(safeEval("'''" + attrs["glyphname"] + "'''")))
elif name == "hexdata":
self.imageData = readHex(content)
else:
from fontTools import ttLib
raise ttLib.TTLibError("can't handle '%s' element" % name)
def fromXML(self, name, attrs, content, ttFont):
if name == "ref":
# glyph is a "dupe", i.e. a reference to another glyph's image data.
# in this case imageData contains the glyph id of the reference glyph
# get glyph id from glyphname
self.imageData = struct.pack(">H", ttFont.getGlyphID(safeEval("'''" + attrs["glyphname"] + "'''")))
elif name == "hexdata":
self.imageData = readHex(content)
else:
from fontTools import ttLib
raise ttLib.TTLibError("can't handle '%s' element" % name)
def fromXML(self, name, attrs, content, ttFont): if name == "GMAPs": if not hasattr(self, "GMAPs"): self.GMAPs = [] for element in content: if isinstance(element, basestring): continue itemName, itemAttrs, itemContent = element if itemName == "hexdata": self.GMAPs.append(readHex(itemContent)) elif name == "glyphlets": if not hasattr(self, "glyphlets"): self.glyphlets = [] for element in content: if isinstance(element, basestring): continue itemName, itemAttrs, itemContent = element if itemName == "hexdata": self.glyphlets.append(readHex(itemContent)) else: setattr(self, name, safeEval(attrs["value"]))
def fromXML(self, name, attrs, content, ttFont):
#if name in ["usReserved1", "usReserved2"]:
# setattr(self, name, int(attrs["value"]))
#elif
if name == "ref":
# bitmap is a "dupe", i.e. a reference to another bitmap.
# in this case imageData contains the glyph id of the reference glyph
# get glyph id from glyphname
self.imageData = struct.pack(">H", ttFont.getGlyphID(attrs["glyphname"]))
elif name == "hexdata":
self.imageData = readHex(content)
else:
from fontTools import ttLib
raise ttLib.TTLibError("can't handle '%s' element" % name)
def fromXML(self, name, attrs, content, ttFont):
#if name in ["usReserved1", "usReserved2"]:
# setattr(self, name, int(attrs["value"]))
#elif
if name == "ref":
# bitmap is a "dupe", i.e. a reference to another bitmap.
# in this case imageData contains the glyph id of the reference glyph
# get glyph id from glyphname
self.imageData = struct.pack(">H",
ttFont.getGlyphID(attrs["glyphname"]))
elif name == "hexdata":
self.imageData = readHex(content)
else:
from fontTools import ttLib
raise ttLib.TTLibError("can't handle '%s' element" % name)
class KernTable_format_2:
def decompile(self, data, ttFont):
self.data = data
def compile(self, ttFont):
return self.data
def toXML(self, writer):
writer.begintag("kernsubtable", format=2)
writer.newline()
writer.dumphex(self.data)
writer.endtag("kernsubtable")
writer.newline()
def fromXML(self, (name, attrs, content), ttFont):
self.decompile(readHex(content), ttFont)
def fromXML(self, name, attrs, content, ttFont):
if name not in ("psNames", "extraNames", "hexdata"):
setattr(self, name, safeEval(attrs["value"]))
elif name == "psNames":
self.mapping = {}
for element in content:
if not isinstance(element, tuple):
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if not isinstance(element, tuple):
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
def fromXML(self, name, attrs, content, ttFont):
if name not in ("psNames", "extraNames", "hexdata"):
setattr(self, name, safeEval(attrs["value"]))
elif name == "psNames":
self.mapping = {}
for element in content:
if not isinstance(element, tuple):
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if not isinstance(element, tuple):
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
class KernTable_format_unkown:
def __init__(self, format):
self.format = format
def decompile(self, data, ttFont):
self.data = data
def compile(self, ttFont):
return self.data
def toXML(self, writer, ttFont):
writer.begintag("kernsubtable", format=self.format)
writer.newline()
writer.comment("unknown 'kern' subtable format")
writer.newline()
writer.dumphex(self.data)
writer.endtag("kernsubtable")
writer.newline()
def fromXML(self, (name, attrs, content), ttFont):
self.decompile(readHex(content), ttFont)
def fromXML(self, xxx_todo_changeme, ttFont):
(name, attrs, content) = xxx_todo_changeme
if name not in ("psNames", "extraNames", "hexdata"):
setattr(self, name, safeEval(attrs["value"]))
elif name == "psNames":
self.mapping = {}
for element in content:
if type(element) is not tuple:
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if type(element) is not tuple:
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
def fromXML(self, xxx_todo_changeme, ttFont):
(name, attrs, content) = xxx_todo_changeme
if name not in ("psNames", "extraNames", "hexdata"):
setattr(self, name, safeEval(attrs["value"]))
elif name == "psNames":
self.mapping = {}
for element in content:
if type(element) is not tuple:
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if type(element) is not tuple:
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
def fromXML(self, name, attrs, content, ttFont):
if name == "hexdata":
self.data[attrs["tag"]] = readHex(content)
else:
raise TTLibError("can't handle '%s' element" % name)
def fromXML(self, xxx_todo_changeme7, ttFont):
(name, attrs, content) = xxx_todo_changeme7
self.data = readHex(content)
self.cmap = {}
class T2CharString(ByteCodeBase):
operandEncoding = t2OperandEncoding
operators, opcodes = buildOperatorDict(t2Operators)
def __init__(self, bytecode=None, program=None, private=None, globalSubrs=None):
if program is None:
program = []
self.bytecode = bytecode
self.program = program
self.private = private
self.globalSubrs = globalSubrs
def __repr__(self):
if self.bytecode is None:
return "<%s (source) at %x>" % (self.__class__.__name__, id(self))
else:
return "<%s (bytecode) at %x>" % (self.__class__.__name__, id(self))
def getIntEncoder(self):
return encodeIntT2
def getFixedEncoder(self):
return encodeFixed
def decompile(self):
if not self.needsDecompilation():
return
subrs = getattr(self.private, "Subrs", [])
decompiler = SimpleT2Decompiler(subrs, self.globalSubrs)
decompiler.execute(self)
def draw(self, pen):
subrs = getattr(self.private, "Subrs", [])
extractor = T2OutlineExtractor(pen, subrs, self.globalSubrs,
self.private.nominalWidthX, self.private.defaultWidthX)
extractor.execute(self)
self.width = extractor.width
def compile(self):
if self.bytecode is not None:
return
assert self.program, "illegal CharString: decompiled to empty program"
assert self.program[-1] in ("endchar", "return", "callsubr", "callgsubr",
"seac"), "illegal CharString"
bytecode = []
opcodes = self.opcodes
program = self.program
encodeInt = self.getIntEncoder()
encodeFixed = self.getFixedEncoder()
i = 0
end = len(program)
while i < end:
token = program[i]
i = i + 1
tp = type(token)
if tp == types.StringType:
try:
bytecode.extend(map(chr, opcodes[token]))
except KeyError:
raise CharStringCompileError, "illegal operator: %s" % token
if token in ('hintmask', 'cntrmask'):
bytecode.append(program[i]) # hint mask
i = i + 1
elif tp == types.IntType:
bytecode.append(encodeInt(token))
elif tp == types.FloatType:
bytecode.append(encodeFixed(token))
else:
assert 0, "unsupported type: %s" % tp
try:
bytecode = "".join(bytecode)
except TypeError:
print bytecode
raise
self.setBytecode(bytecode)
def needsDecompilation(self):
return self.bytecode is not None
def setProgram(self, program):
self.program = program
self.bytecode = None
def setBytecode(self, bytecode):
self.bytecode = bytecode
self.program = None
def getToken(self, index,
len=len, ord=ord, getattr=getattr, type=type, StringType=types.StringType):
if self.bytecode is not None:
if index >= len(self.bytecode):
return None, 0, 0
b0 = ord(self.bytecode[index])
index = index + 1
code = self.operandEncoding[b0]
handler = getattr(self, code)
token, index = handler(b0, self.bytecode, index)
else:
if index >= len(self.program):
return None, 0, 0
token = self.program[index]
index = index + 1
isOperator = type(token) == StringType
return token, isOperator, index
def getBytes(self, index, nBytes):
if self.bytecode is not None:
newIndex = index + nBytes
bytes = self.bytecode[index:newIndex]
index = newIndex
else:
bytes = self.program[index]
index = index + 1
assert len(bytes) == nBytes
return bytes, index
def do_operator(self, b0, data, index):
if b0 == 12:
op = (b0, ord(data[index]))
index = index+1
else:
op = b0
operator = self.operators[op]
return operator, index
def toXML(self, xmlWriter):
from fontTools.misc.textTools import num2binary
if self.bytecode is not None:
xmlWriter.dumphex(self.bytecode)
else:
index = 0
args = []
while 1:
token, isOperator, index = self.getToken(index)
if token is None:
break
if isOperator:
args = map(str, args)
if token in ('hintmask', 'cntrmask'):
hintMask, isOperator, index = self.getToken(index)
bits = []
for byte in hintMask:
bits.append(num2binary(ord(byte), 8))
hintMask = string.join(bits, "")
line = string.join(args + [token, hintMask], " ")
else:
line = string.join(args + [token], " ")
xmlWriter.write(line)
xmlWriter.newline()
args = []
else:
args.append(token)
def fromXML(self, (name, attrs, content)):
from fontTools.misc.textTools import binary2num, readHex
if attrs.get("raw"):
self.setBytecode(readHex(content))
return
content = "".join(content)
content = content.split()
program = []
end = len(content)
i = 0
while i < end:
token = content[i]
i = i + 1
try:
token = int(token)
except ValueError:
try:
token = float(token)
except ValueError:
program.append(token)
if token in ('hintmask', 'cntrmask'):
mask = content[i]
maskBytes = ""
for j in range(0, len(mask), 8):
maskBytes = maskBytes + chr(binary2num(mask[j:j+8]))
program.append(maskBytes)
i = i + 1
else:
program.append(token)
else:
program.append(token)
self.setProgram(program)
def _readRawImageData(bitmapObject, name, attrs, content, ttFont): bitmapObject.imageData = readHex(content)
def _readRawImageData(bitmapObject, name, attrs, content, ttFont):
bitmapObject.imageData = readHex(content)
def fromXML(self, xxx_todo_changeme3, ttFont): (name, attrs, content) = xxx_todo_changeme3 self.decompile(readHex(content), ttFont)
class Bitmap(object):
def __init__(self,
glyphName=None,
referenceGlyphName=None,
usReserved1=0,
usReserved2=0,
imageFormatTag=None,
imageData=None,
rawdata=None,
gid=0):
self.gid = gid
self.glyphName = glyphName
self.referenceGlyphName = referenceGlyphName
self.usReserved1 = usReserved1
self.usReserved2 = usReserved2
self.rawdata = rawdata
self.imageFormatTag = imageFormatTag
self.imageData = imageData
def decompile(self, ttFont):
self.glyphName = ttFont.getGlyphName(self.gid)
if self.rawdata is None:
from fontTools import ttLib
raise (ttLib.TTLibError, "No table data to decompile.")
if len(self.rawdata) > 0:
if len(self.rawdata) < sbixBitmapHeaderFormatSize:
from fontTools import ttLib
#print "Bitmap %i header too short: Expected %x, got %x." % (self.gid, sbixBitmapHeaderFormatSize, len(self.rawdata))
raise (ttLib.TTLibError, "Bitmap header too short.")
sstruct.unpack(sbixBitmapHeaderFormat,
self.rawdata[:sbixBitmapHeaderFormatSize], self)
if self.imageFormatTag == "dupe":
# bitmap is a reference to another glyph's bitmap
gid, = struct.unpack(">H",
self.rawdata[sbixBitmapHeaderFormatSize:])
self.referenceGlyphName = ttFont.getGlyphName(gid)
else:
self.imageData = self.rawdata[sbixBitmapHeaderFormatSize:]
self.referenceGlyphName = None
# clean up
del self.rawdata
del self.gid
def compile(self, ttFont):
if self.glyphName is None:
from fontTools import ttLib
raise ttLib.TTLibError, "Can't compile bitmap without glyph name"
# TODO: if ttFont has no maxp, cmap etc., ignore glyph names and compile by index?
# (needed if you just want to compile the sbix table on its own)
self.gid = struct.pack(">H", ttFont.getGlyphID(self.glyphName))
if self.imageFormatTag is None:
self.rawdata = ""
else:
self.rawdata = sstruct.pack(sbixBitmapHeaderFormat,
self) + self.imageData
def toXML(self, xmlWriter, ttFont):
if self.imageFormatTag == None:
# TODO: ignore empty bitmaps?
# a bitmap entry is required for each glyph,
# but empty ones can be calculated at compile time
xmlWriter.simpletag("bitmap", glyphname=self.glyphName)
xmlWriter.newline()
return
xmlWriter.begintag("bitmap",
format=self.imageFormatTag,
glyphname=self.glyphName)
xmlWriter.newline()
#xmlWriter.simpletag("usReserved1", value=self.usReserved1)
#xmlWriter.newline()
#xmlWriter.simpletag("usReserved2", value=self.usReserved2)
#xmlWriter.newline()
if self.imageFormatTag == "dupe":
# format == "dupe" is apparently a reference to another glyph id.
xmlWriter.simpletag("ref", glyphname=self.referenceGlyphName)
else:
xmlWriter.begintag("hexdata")
xmlWriter.newline()
xmlWriter.dumphex(self.imageData)
xmlWriter.endtag("hexdata")
xmlWriter.newline()
xmlWriter.endtag("bitmap")
xmlWriter.newline()
def fromXML(self, (name, attrs, content), ttFont):
#if name in ["usReserved1", "usReserved2"]:
# setattr(self, name, int(attrs["value"]))
#elif
if name == "ref":
# bitmap is a "dupe", i.e. a reference to another bitmap.
# in this case imageData contains the glyph id of the reference glyph
# get glyph id from glyphname
self.imageData = struct.pack(">H",
ttFont.getGlyphID(attrs["glyphname"]))
elif name == "hexdata":
self.imageData = readHex(content)
else:
from fontTools import ttLib
raise ttLib.TTLibError, "can't handle '%s' element" % name
def fromXML(self, xxx_todo_changeme7, ttFont):
(name, attrs, content) = xxx_todo_changeme7
self.data = readHex(content)
self.cmap = {}
def fromXML(self, name, attrs, content, ttFont):
self.data = readHex(content)
self.cmap = {}
for element in content: if type(element) <> TupleType: continue name, attrs, content = element if name == "psName": self.mapping[attrs["name"]] = attrs["psName"] elif name == "extraNames": self.extraNames = [] for element in content: if type(element) <> TupleType: continue name, attrs, content = element if name == "psName": self.extraNames.append(attrs["name"]) else: self.data = readHex(content) def unpackPStrings(data): strings = [] index = 0 dataLen = len(data) while index < dataLen: length = ord(data[index]) strings.append(data[index+1:index+1+length]) index = index + 1 + length return strings def packPStrings(strings): data = ""
class table__p_o_s_t(DefaultTable.DefaultTable):
def decompile(self, data, ttFont):
sstruct.unpack(postFormat, data[:postFormatSize], self)
data = data[postFormatSize:]
if self.formatType == 1.0:
self.decode_format_1_0(data, ttFont)
elif self.formatType == 2.0:
self.decode_format_2_0(data, ttFont)
elif self.formatType == 3.0:
self.decode_format_3_0(data, ttFont)
else:
# supported format
raise ttLib.TTLibError, "'post' table format %f not supported" % self.formatType
def compile(self, ttFont):
data = sstruct.pack(postFormat, self)
if self.formatType == 1.0:
pass # we're done
elif self.formatType == 2.0:
data = data + self.encode_format_2_0(ttFont)
elif self.formatType == 3.0:
pass # we're done
else:
# supported format
raise ttLib.TTLibError, "'post' table format %f not supported" % self.formatType
return data
def getGlyphOrder(self):
"""This function will get called by a ttLib.TTFont instance.
Do not call this function yourself, use TTFont().getGlyphOrder()
or its relatives instead!
"""
if not hasattr(self, "glyphOrder"):
raise ttLib.TTLibError, "illegal use of getGlyphOrder()"
glyphOrder = self.glyphOrder
del self.glyphOrder
return glyphOrder
def decode_format_1_0(self, data, ttFont):
self.glyphOrder = standardGlyphOrder[:ttFont["maxp"].numGlyphs]
def decode_format_2_0(self, data, ttFont):
numGlyphs, = struct.unpack(">H", data[:2])
numGlyphs = int(numGlyphs)
if numGlyphs > ttFont['maxp'].numGlyphs:
# Assume the numGlyphs field is bogus, so sync with maxp.
# I've seen this in one font, and if the assumption is
# wrong elsewhere, well, so be it: it's hard enough to
# work around _one_ non-conforming post format...
numGlyphs = ttFont['maxp'].numGlyphs
data = data[2:]
indices = array.array("H")
indices.fromstring(data[:2 * numGlyphs])
if sys.byteorder <> "big":
indices.byteswap()
data = data[2 * numGlyphs:]
self.extraNames = extraNames = unpackPStrings(data)
self.glyphOrder = glyphOrder = [None] * int(ttFont['maxp'].numGlyphs)
for glyphID in range(numGlyphs):
index = indices[glyphID]
if index > 257:
name = extraNames[index - 258]
else:
# fetch names from standard list
name = standardGlyphOrder[index]
glyphOrder[glyphID] = name
#AL990511: code added to handle the case of new glyphs without
# entries into the 'post' table
if numGlyphs < ttFont['maxp'].numGlyphs:
for i in range(numGlyphs, ttFont['maxp'].numGlyphs):
glyphOrder[i] = "glyph#%.5d" % i
self.extraNames.append(glyphOrder[i])
self.build_psNameMapping(ttFont)
def build_psNameMapping(self, ttFont):
mapping = {}
allNames = {}
for i in range(ttFont['maxp'].numGlyphs):
glyphName = psName = self.glyphOrder[i]
if allNames.has_key(glyphName):
# make up a new glyphName that's unique
n = allNames[glyphName]
allNames[glyphName] = n + 1
glyphName = glyphName + "#" + ` n `
self.glyphOrder[i] = glyphName
mapping[glyphName] = psName
else:
allNames[glyphName] = 1
self.mapping = mapping
def decode_format_3_0(self, data, ttFont):
# Setting self.glyphOrder to None will cause the TTFont object
# try and construct glyph names from a Unicode cmap table.
self.glyphOrder = None
def encode_format_2_0(self, ttFont):
numGlyphs = ttFont['maxp'].numGlyphs
glyphOrder = ttFont.getGlyphOrder()
assert len(glyphOrder) == numGlyphs
indices = array.array("H")
extraDict = {}
extraNames = self.extraNames
for i in range(len(extraNames)):
extraDict[extraNames[i]] = i
for glyphID in range(numGlyphs):
glyphName = glyphOrder[glyphID]
if self.mapping.has_key(glyphName):
psName = self.mapping[glyphName]
else:
psName = glyphName
if extraDict.has_key(psName):
index = 258 + extraDict[psName]
elif psName in standardGlyphOrder:
index = standardGlyphOrder.index(psName)
else:
index = 258 + len(extraNames)
extraDict[psName] = len(extraNames)
extraNames.append(psName)
indices.append(index)
if sys.byteorder <> "big":
indices.byteswap()
return struct.pack(
">H", numGlyphs) + indices.tostring() + packPStrings(extraNames)
def toXML(self, writer, ttFont):
formatstring, names, fixes = sstruct.getformat(postFormat)
for name in names:
value = getattr(self, name)
writer.simpletag(name, value=value)
writer.newline()
if hasattr(self, "mapping"):
writer.begintag("psNames")
writer.newline()
writer.comment(
"This file uses unique glyph names based on the information\n"
"found in the 'post' table. Since these names might not be unique,\n"
"we have to invent artificial names in case of clashes. In order to\n"
"be able to retain the original information, we need a name to\n"
"ps name mapping for those cases where they differ. That's what\n"
"you see below.\n")
writer.newline()
items = self.mapping.items()
items.sort()
for name, psName in items:
writer.simpletag("psName", name=name, psName=psName)
writer.newline()
writer.endtag("psNames")
writer.newline()
if hasattr(self, "extraNames"):
writer.begintag("extraNames")
writer.newline()
writer.comment(
"following are the name that are not taken from the standard Mac glyph order"
)
writer.newline()
for name in self.extraNames:
writer.simpletag("psName", name=name)
writer.newline()
writer.endtag("extraNames")
writer.newline()
if hasattr(self, "data"):
writer.begintag("hexdata")
writer.newline()
writer.dumphex(self.data)
writer.endtag("hexdata")
writer.newline()
def fromXML(self, (name, attrs, content), ttFont):
if name not in ("psNames", "extraNames", "hexdata"):
setattr(self, name, safeEval(attrs["value"]))
elif name == "psNames":
self.mapping = {}
for element in content:
if type(element) <> TupleType:
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if type(element) <> TupleType:
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
for element in content:
if type(element) <> TupleType:
continue
name, attrs, content = element
if name == "psName":
self.mapping[attrs["name"]] = attrs["psName"]
elif name == "extraNames":
self.extraNames = []
for element in content:
if type(element) <> TupleType:
continue
name, attrs, content = element
if name == "psName":
self.extraNames.append(attrs["name"])
else:
self.data = readHex(content)
def unpackPStrings(data):
strings = []
index = 0
dataLen = len(data)
while index < dataLen:
length = ord(data[index])
strings.append(data[index + 1:index + 1 + length])
index = index + 1 + length
return strings
def packPStrings(strings):
data = ""
def fromXML(self, name, attrs, content, ttFont): self.decompile(readHex(content), ttFont)
def fromXML(self, xxx_todo_changeme3, ttFont):
(name, attrs, content) = xxx_todo_changeme3
self.decompile(readHex(content), ttFont)
return chr(result)
# This section of code is for reading and writing image data to/from XML.
def _writeRawImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
writer.begintag('rawimagedata')
writer.newline()
writer.dumphex(bitmapObject.imageData)
writer.endtag('rawimagedata')
writer.newline()
def _readRawImageData(bitmapObject, (name, attrs, content), ttFont):
bitmapObject.imageData = readHex(content)
def _writeRowImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
metrics = bitmapObject.exportMetrics
del bitmapObject.exportMetrics
bitDepth = bitmapObject.exportBitDepth
del bitmapObject.exportBitDepth
writer.begintag('rowimagedata',
bitDepth=bitDepth,
width=metrics.width,
height=metrics.height)
writer.newline()
for curRow in xrange(metrics.height):
rowData = bitmapObject.getRow(curRow,
class table_G_P_K_G_(DefaultTable.DefaultTable):
def decompile(self, data, ttFont):
dummy, newData = sstruct.unpack2(GPKGFormat, data, self)
GMAPoffsets = array.array("L")
endPos = (self.numGMAPs+1) * 4
GMAPoffsets.fromstring(newData[:endPos])
if sys.byteorder <> "big":
GMAPoffsets.byteswap()
self.GMAPs = []
for i in range(self.numGMAPs):
start = GMAPoffsets[i]
end = GMAPoffsets[i+1]
self.GMAPs.append(data[start:end])
pos = endPos
endPos = pos + (self.numGlyplets + 1)*4
glyphletOffsets = array.array("L")
glyphletOffsets.fromstring(newData[pos:endPos])
if sys.byteorder <> "big":
glyphletOffsets.byteswap()
self.glyphlets = []
for i in range(self.numGlyplets):
start = glyphletOffsets[i]
end = glyphletOffsets[i+1]
self.glyphlets.append(data[start:end])
def compile(self, ttFont):
self.numGMAPs = len(self.GMAPs)
self.numGlyplets = len(self.glyphlets)
GMAPoffsets = [0]*(self.numGMAPs + 1)
glyphletOffsets = [0]*(self.numGlyplets + 1)
dataList =[ sstruct.pack(GPKGFormat, self)]
pos = len(dataList[0]) + (self.numGMAPs + 1)*4 + (self.numGlyplets + 1)*4
GMAPoffsets[0] = pos
for i in range(1, self.numGMAPs +1):
pos += len(self.GMAPs[i-1])
GMAPoffsets[i] = pos
gmapArray = numpy.array(GMAPoffsets, numpy.uint32)
if sys.byteorder <> "big":
gmapArray = gmapArray.byteswap()
dataList.append(gmapArray.tostring())
glyphletOffsets[0] = pos
for i in range(1, self.numGlyplets +1):
pos += len(self.glyphlets[i-1])
glyphletOffsets[i] = pos
glyphletArray = numpy.array(glyphletOffsets, numpy.uint32)
if sys.byteorder <> "big":
glyphletArray = glyphletArray.byteswap()
dataList.append(glyphletArray.tostring())
dataList += self.GMAPs
dataList += self.glyphlets
data = "".join(dataList)
return data
def toXML(self, writer, ttFont):
writer.comment("Most of this table will be recalculated by the compiler")
writer.newline()
formatstring, names, fixes = sstruct.getformat(GPKGFormat)
for name in names:
value = getattr(self, name)
writer.simpletag(name, value=value)
writer.newline()
writer.begintag("GMAPs")
writer.newline()
for gmapData in self.GMAPs:
writer.begintag("hexdata")
writer.newline()
writer.dumphex(gmapData)
writer.endtag("hexdata")
writer.newline()
writer.endtag("GMAPs")
writer.newline()
writer.begintag("glyphlets")
writer.newline()
for glyphletData in self.glyphlets:
writer.begintag("hexdata")
writer.newline()
writer.dumphex(glyphletData)
writer.endtag("hexdata")
writer.newline()
writer.endtag("glyphlets")
writer.newline()
def fromXML(self, (name, attrs, content), ttFont):
if name == "GMAPs":
if not hasattr(self, "GMAPs"):
self.GMAPs = []
for element in content:
if isinstance(element, StringType):
continue
itemName, itemAttrs, itemContent = element
if itemName == "hexdata":
self.GMAPs.append(readHex(itemContent))
elif name == "glyphlets":
if not hasattr(self, "glyphlets"):
self.glyphlets = []
for element in content:
if isinstance(element, StringType):
continue
itemName, itemAttrs, itemContent = element
if itemName == "hexdata":
self.glyphlets.append(readHex(itemContent))
else:
value = attrs["value"]
try:
value = safeEval(value)
except OverflowError:
value = long(value)
setattr(self, name, value)
def fromXML(self, name, attrs, content, ttFont):
self.decompile(readHex(content), ttFont)
result = result << 1
result |= byte & 1
byte = byte >> 1
return chr(result)
# This section of code is for reading and writing image data to/from XML.
def _writeRawImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
writer.begintag('rawimagedata')
writer.newline()
writer.dumphex(bitmapObject.imageData)
writer.endtag('rawimagedata')
writer.newline()
def _readRawImageData(bitmapObject, (name, attrs, content), ttFont):
bitmapObject.imageData = readHex(content)
def _writeRowImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
metrics = bitmapObject.exportMetrics
del bitmapObject.exportMetrics
bitDepth = bitmapObject.exportBitDepth
del bitmapObject.exportBitDepth
writer.begintag('rowimagedata', bitDepth=bitDepth, width=metrics.width, height=metrics.height)
writer.newline()
for curRow in xrange(metrics.height):
rowData = bitmapObject.getRow(curRow, bitDepth=bitDepth, metrics=metrics)
writer.simpletag('row', value=hexStr(rowData))
writer.newline()
writer.endtag('rowimagedata')
writer.newline()
class Program:
def __init__(self):
pass
def fromBytecode(self, bytecode):
self.bytecode = array.array("B", bytecode)
if hasattr(self, "assembly"):
del self.assembly
def fromAssembly(self, assembly):
self.assembly = assembly
if hasattr(self, "bytecode"):
del self.bytecode
def getBytecode(self):
if not hasattr(self, "bytecode"):
self._assemble()
return self.bytecode.tostring()
def getAssembly(self):
if not hasattr(self, "assembly"):
self._disassemble()
return self.assembly
def toXML(self, writer, ttFont):
if ttFont.disassembleInstructions:
assembly = self.getAssembly()
writer.begintag("assembly")
writer.newline()
i = 0
nInstr = len(assembly)
while i < nInstr:
instr = assembly[i]
writer.write(instr)
writer.newline()
m = _pushCountPat.match(instr)
i = i + 1
if m:
nValues = int(m.group(1))
line = []
j = 0
for j in range(nValues):
if j and not (j % 25):
writer.write(string.join(line, " "))
writer.newline()
line = []
line.append(assembly[i+j])
writer.write(string.join(line, " "))
writer.newline()
i = i + j + 1
writer.endtag("assembly")
else:
writer.begintag("bytecode")
writer.newline()
writer.dumphex(self.getBytecode())
writer.endtag("bytecode")
def fromXML(self, (name, attrs, content), ttFont):
if name == "assembly":
self.fromAssembly(content)
self._assemble()
del self.assembly
else:
assert name == "bytecode"
self.fromBytecode(readHex(content))
def fromXML(self, name, attrs, content, ttFont):
if name == "hexdata":
self.data[attrs["tag"]] = readHex(content)
else:
raise TTLibError("can't handle '%s' element" % name)
