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)
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, 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, 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)
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)
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, 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 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, 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)
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)
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))