fonttools/Lib/fontTools/ttLib/tables/otCommon.py

"""ttLib.tables.otCommon.py -- Various data structures used by various OpenType tables.
"""

import struct, sstruct
import DefaultTable
from fontTools import ttLib


class base_GPOS_GSUB(DefaultTable.DefaultTable):
	
	"""Base class for GPOS and GSUB tables; they share the same high-level structure."""
	
	version = 0x00010000
	
	def decompile(self, data, otFont):
		reader = OTTableReader(data)
		self.version = reader.readLong()
		if self.version <> 0x00010000:
			raise ttLib.TTLibError, "unknown table version: 0x%8x" % self.version
		
		self.scriptList = reader.readTable(ScriptList, otFont, self.tableTag)
		self.featureList = reader.readTable(FeatureList, otFont, self.tableTag)
		self.lookupList = reader.readTable(LookupList, otFont, self.tableTag)
	
	def compile(self, otFont):
		XXXXXX
	
	def toXML(self, xmlWriter, otFont):
		names = [("ScriptList", "scriptList"), 
				("FeatureList", "featureList"), 
				("LookupList", "lookupList")]
		for name, attr in names:
			xmlWriter.newline()
			xmlWriter.begintag(name)
			xmlWriter.newline()
			table = getattr(self, attr)
			table.toXML(xmlWriter, otFont)
			xmlWriter.endtag(name)
			xmlWriter.newline()
		xmlWriter.newline()
	
	def fromXML(self, (name, attrs, content), otFont):
		xxx


#
# Script List and subtables
#

class ScriptList:
	
	def __init__(self, parentTag):
		self.parentTag = parentTag
	
	def decompile(self, reader, otFont):
		scriptCount = reader.readUShort()
		self.scripts = reader.readTagList(scriptCount, Script, otFont)
	
	def compile(self, otFont):
		XXXXXX
	
	def toXML(self, xmlWriter, otFont):
		for tag, script in self.scripts:
			xmlWriter.begintag("Script", tag=tag)
			xmlWriter.newline()
			script.toXML(xmlWriter, otFont)
			xmlWriter.endtag("Script")
			xmlWriter.newline()
	
	def fromXML(self, (name, attrs, content), otFont):
		xxx


class Script:
	
	def decompile(self, reader, otFont):
		self.defaultLangSystem = None
		self.defaultLangSystem = reader.readTable(LanguageSystem, otFont)
		langSysCount = reader.readUShort()
		self.languageSystems = reader.readTagList(langSysCount, LanguageSystem, otFont)
	
	def compile(self, otFont):
		XXXXX
	
	def toXML(self, xmlWriter, otFont):
		xmlWriter.begintag("DefaultLanguageSystem")
		xmlWriter.newline()
		self.defaultLangSystem.toXML(xmlWriter, otFont)
		xmlWriter.endtag("DefaultLanguageSystem")
		xmlWriter.newline()
		for tag, langSys in self.languageSystems:
			xmlWriter.begintag("LanguageSystem", tag=tag)
			xmlWriter.newline()
			langSys.toXML(xmlWriter, otFont)
			xmlWriter.endtag("LanguageSystem")
			xmlWriter.newline()


class LanguageSystem:
	
	def decompile(self, reader, otFont):
		self.lookupOrder = reader.readUShort()
		self.reqFeatureIndex = reader.readUShort()
		featureCount = reader.readUShort()
		self.featureIndex = reader.readUShortArray(featureCount)
	
	def compile(self, otFont):
		xxx
	
	def toXML(self, xmlWriter, otFont):
		xmlWriter.simpletag("LookupOrder", value=self.lookupOrder)
		xmlWriter.newline()
		xmlWriter.simpletag("ReqFeature", index=hex(self.reqFeatureIndex))
		xmlWriter.newline()
		for index in self.featureIndex:
			xmlWriter.simpletag("Feature", index=index)
			xmlWriter.newline()


#
# Feature List and subtables
#

class FeatureList:
	
	def __init__(self, parentTag):
		self.parentTag = parentTag
	
	def decompile(self, reader, otFont):
		featureCount = reader.readUShort()
		self.features = reader.readTagList(featureCount, Feature, otFont)
	
	def compile(self, otFont):
		XXXXX
	
	def toXML(self, xmlWriter, otFont):
		for index in range(len(self.features)):
			tag, feature = self.features[index]
			xmlWriter.begintag("Feature", index=index, tag=tag)
			xmlWriter.newline()
			feature.toXML(xmlWriter, otFont)
			xmlWriter.endtag("Feature")
			xmlWriter.newline()
			
	def fromXML(self, (name, attrs, content), otFont):
		xxx


class Feature:
	
	def decompile(self, reader, otFont):
		self.featureParams = reader.readUShort()
		lookupCount = reader.readUShort()
		self.lookupListIndex = reader.readUShortArray(lookupCount)
	
	def compile(self, otFont):
		XXXXX
	
	def toXML(self, xmlWriter, otFont):
		xmlWriter.simpletag("FeatureParams", value=hex(self.featureParams))
		xmlWriter.newline()
		for lookupIndex in self.lookupListIndex:
			xmlWriter.simpletag("LookupTable", index=lookupIndex)
			xmlWriter.newline()
	
	def fromXML(self, (name, attrs, content), otFont):
		xxx


#
# Lookup List and subtables
#

class LookupList:
	
	def __init__(self, parentTag):
		self.parentTag = parentTag
	
	def decompile(self, reader, otFont):
		lookupCount = reader.readUShort()
		self.lookup = lookup = []
		for i in range(lookupCount):
			lookup.append(reader.readTable(LookupTable, otFont, self.parentTag))
	
	def compile(self, otFont):
		XXXXX
	
	def toXML(self, xmlWriter, otFont):
		for i in range(len(self.lookup)):
			xmlWriter.newline()
			lookupTable = self.lookup[i]
			xmlWriter.begintag("LookupTable", index=i)
			xmlWriter.newline()
			lookupTable.toXML(xmlWriter, otFont)
			xmlWriter.endtag("LookupTable")
			xmlWriter.newline()
		xmlWriter.newline()
		
	def fromXML(self, (name, attrs, content), otFont):
		xxx


class LookupTable:
	
	def __init__(self, parentTag):
		self.parentTag = parentTag
	
	def decompile(self, reader, otFont):
		parentTable = otFont[self.parentTag]
		self.lookupType = reader.readUShort()
		self.lookupFlag = reader.readUShort()
		subTableCount = reader.readUShort()
		self.subTables = subTables = []
		lookupTypeClass = parentTable.getLookupTypeClass(self.lookupType)
		for i in range(subTableCount):
			subTables.append(reader.readTable(lookupTypeClass, otFont))
	
	def compile(self, otFont):
		XXXXXX
	
	def __repr__(self):
		if not hasattr(self, "lookupTypeName"):
			m = ttLib.getTableModule(self.parentTag)
			self.lookupTypeName = m.lookupTypeClasses[self.lookupType].__name__
		return "<%s LookupTable at %x>" % (self.lookupTypeName, id(self))
	
	def toXML(self, xmlWriter, otFont):
		xmlWriter.simpletag("LookupFlag", value=hex(self.lookupFlag))
		xmlWriter.newline()
		for subTable in self.subTables:
			name = subTable.__class__.__name__
			xmlWriter.begintag(name)
			xmlWriter.newline()
			subTable.toXML(xmlWriter, otFont)
			xmlWriter.endtag(name)
			xmlWriter.newline()
	
	def fromXML(self, (name, attrs, content), otFont):
		xxx


#
# Other common formats
#

class CoverageTable:
	
	def getGlyphIDs(self):
		return self.glyphIDs
	
	def getGlyphNames(self):
		return self.glyphNames
	
	def makeGlyphNames(self, otFont):
		self.glyphNames = map(lambda i, o=otFont.getGlyphOrder(): o[i], self.glyphIDs)
	
	def decompile(self, reader, otFont):
		format = reader.readUShort()
		if format == 1:
			self.decompileFormat1(reader, otFont)
		elif format == 2:
			self.decompileFormat2(reader, otFont)
		else:
			raise ttLib.TTLibError, "unknown Coverage table format: %d" % format
		self.makeGlyphNames(otFont)
	
	def decompileFormat1(self, reader, otFont):
		glyphCount = reader.readUShort()
		self.glyphIDs = glyphIDs = []
		for i in range(glyphCount):
			glyphID = reader.readUShort()
			glyphIDs.append(glyphID)
	
	def decompileFormat2(self, reader, otFont):
		rangeCount = reader.readUShort()
		self.glyphIDs = glyphIDs = []
		for i in range(rangeCount):
			startID = reader.readUShort()
			endID = reader.readUShort()
			startCoverageIndex = reader.readUShort()
			for glyphID in range(startID, endID + 1):
				glyphIDs.append(glyphID)
	
	def compile(self, otFont):
		# brute force ;-)
		data1 = self.compileFormat1(otFont)
		data2 = self.compileFormat2(otFont)
		if len(data1) <= len(data2):
			format = 1
			reader = data1
		else:
			format = 2
			reader = data2
		return struct.pack(">H", format) + reader
	
	def compileFormat1(self, otFont):
		xxxxx
		glyphIDs = map(otFont.getGlyphID, self.glyphNames)
		data = pack(">H", len(glyphIDs))
		pack = struct.pack
		for glyphID in glyphIDs:
			data = data + pack(">H", glyphID)
		return data
	
	def compileFormat2(self, otFont):
		xxxxx
		glyphIDs = map(otFont.getGlyphID, self.glyphNames)
		ranges = []
		lastID = startID = glyphIDs[0]
		startCoverageIndex = 0
		glyphCount = len(glyphIDs)
		for i in range(1, glyphCount+1):
			if i == glyphCount:
				glyphID = 0x1ffff  # arbitrary, but larger than 0x10000
			else:
				glyphID = glyphIDs[i]
			if glyphID <> (lastID + 1):
				ranges.append((startID, lastID, startCoverageIndex))
				startCoverageIndex = i
				startID = glyphID
			lastID = glyphID
		ranges.sort()  # sort by startID
		rangeData = ""
		for startID, endID, startCoverageIndex in ranges:
			rangeData = rangeData + struct.pack(">HHH", startID, endID, startCoverageIndex)
		return pack(">H", len(ranges)) + rangeData


class ClassDefinitionTable:
	
	def decompile(self, reader, otFont):
		format = reader.readUShort()
		if format == 1:
			self.decompileFormat1(reader, otFont)
		elif format == 2:
			self.decompileFormat2(reader, otFont)
		else:
			raise ttLib.TTLibError, "unknown Class table format: %d" % format
		self.reverse()
	
	def reverse(self):
		classDefs = {}
		for glyphName, classCode in self.classDefs:
			try:
				classDefs[classCode].append(glyphName)
			except KeyError:
				classDefs[classCode] = [glyphName]
		self.classDefs = classDefs
	
	def decompileFormat1(self, reader, otFont):
		self.classDefs = classDefs = []
		startGlyphID = reader.readUShort()
		glyphCount = reader.readUShort()
		for i in range(glyphCount):
			glyphName = otFont.getglyphName(startGlyphID + i)
			classValue = reader.readUShort()
			if classValue:
				classDefs.append((glyphName, classValue))
	
	def decompileFormat2(self, reader, otFont):
		self.classDefs = classDefs = []
		classRangeCount = reader.readUShort()
		for i in range(classRangeCount):
			startID = reader.readUShort()
			endID = reader.readUShort()
			classValue = reader.readUShort()
			for glyphID in range(startID, endID + 1):
				if classValue:
					glyphName = otFont.getGlyphName(glyphID)
					classDefs.append((glyphName, classValue))
	
	def compile(self, otFont):
		# brute force again
		data1 = self.compileFormat1(otFont)
		data2 = self.compileFormat2(otFont)
		if len(data1) <= len(data2):
			format = 1
			data = data1
		else:
			format = 2
			data = data2
		return struct.pack(">H", format) + data
	
	def compileFormat1(self, otFont):
		items = map(lambda (glyphName, classValue), getGlyphID=otFont.getGlyphID:
				(getGlyphID(glyphName), classValue), self.glyphs.items())
		items.sort()
		startGlyphID = items[0][0]
		endGlyphID = items[-1][0]
		data = ""
		lastID = startGlyphID
		for glyphID, classValue in items:
			for i in range(lastID + 1, glyphID - 1):
				data = data + "\0\0"  # 0 == default class
			data = data + struct.pack(">H", classValue)
			lastID = glyphID
		return struct.pack(">H", endGlyphID - startGlyphID + 1) + data
	
	def compileFormat2(self, otFont):
		items = map(lambda (glyphName, classValue), getGlyphID=otFont.getGlyphID:
				(getGlyphID(glyphName), classValue), self.glyphs.items())
		items.sort()
		ranges = []
		lastID, lastClassValue = items[0][0]
		startID = lastID
		itemCount = len(items)
		for i in range(1, itemCount+1):
			if i == itemCount:
				glyphID = 0x1ffff  # arbitrary, but larger than 0x10000
				classValue = 0
			else:
				glyphID, classValue = items[i]
			if glyphID <> (lastID + 1) or lastClassValue <> classValue:
				ranges.append((startID, lastID, lastClassValue))
				startID = glyphID
				lastClassValue = classValue
			lastID = glyphID
			lastClassValue = classValue
		rangeData = ""
		for startID, endID, classValue in ranges:
			rangeData = rangeData + struct.pack(">HHH", startID, endID, classValue)
		return pack(">H", len(ranges)) + rangeData
	
	def __getitem__(self, glyphName):
		if self.glyphs.has_key(glyphName):
			return self.glyphs[glyphName]
		else:
			return 0  # default class


class DeviceTable:
	
	def decompile(self, reader, otFont):
		xxxxxx
		self.startSize = unpack_uint16(reader[:2])
		endSize = unpack_uint16(reader[2:4])
		deltaFormat = unpack_uint16(reader[4:6])
		reader = reader[6:]
		if deltaFormat == 1:
			bits = 2
		elif deltaFormat == 2:
			bits = 4
		elif deltaFormat == 3:
			bits = 8
		else:
			raise ttLib.TTLibError, "unknown Device table delta format: %d" % deltaFormat
		numCount = 16 / bits
		deltaCount = endSize - self.startSize + 1
		deltaValues = []
		mask = (1 << bits) - 1
		threshold = (1 << bits) / 2
		shift = 1 << bits
		for i in range(0, deltaCount, numCount):
			offset = 2*i/numCount
			chunk = unpack_uint16(reader[offset:offset+2])
			deltas = []
			for j in range(numCount):
				delta = chunk & mask
				if delta >= threshold:
					delta = delta - shift
				deltas.append(delta)
				chunk = chunk >> bits
			deltas.reverse()
			deltaValues = deltaValues + deltas
		self.deltaValues = deltaValues[:deltaCount]
	
	def compile(self, otFont):
		deltaValues = self.deltaValues
		startSize = self.startSize
		endSize = startSize + len(deltaValues) - 1
		smallestDelta = min(deltas)
		largestDelta = ma(deltas)
		if smallestDelta >= -2 and largestDelta < 2:
			deltaFormat = 1
			bits = 2
		elif smallestDelta >= -8 and largestDelta < 8:
			deltaFormat = 2
			bits = 4
		elif smallestDelta >= -128 and largestDelta < 128:
			deltaFormat = 3
			bits = 8
		else:
			raise ttLib.TTLibError, "delta value too large: min=%d, max=%d" % (smallestDelta, largestDelta)
		data = struct.pack(">HHH", startSize, endSize, deltaFormat)
		numCount = 16 / bits
		# pad the list to a multiple of numCount values
		remainder = len(deltaValues) % numCount
		if remainder:
			deltaValues = deltaValues + [0] * (numCount - remainder)
		deltaData = ""
		for i in range(0, len(deltaValues), numCount):
			chunk = 0
			for j in range(numCount):
				chunk = chunk << bits
				chunk = chunk | deltaValues[i+j]
			deltaData = deltaData + struct.pack(">H", chunk)
		return data + deltaData


#
# Miscelaneous helper routines and classes
#

class OTTableReader:
	
	"""Data wrapper, mostly designed to make reading OT data less cumbersome."""
	
	def __init__(self, data, offset=0):
		self.data = data
		self.offset = offset
		self.pos = offset
	
	def readUShort(self):
		pos = self.pos
		newpos = pos + 2
		value = int(struct.unpack(">H", self.data[pos:newpos])[0])
		self.pos = newpos
		return value
	
	readOffset = readUShort
	
	def readShort(self):
		pos = self.pos
		newpos = pos + 2
		value = int(struct.unpack(">h", self.data[pos:newpos])[0])
		self.pos = newpos
		return value
	
	def readLong(self):
		pos = self.pos
		newpos = pos + 4
		value = int(struct.unpack(">l", self.data[pos:newpos])[0])
		self.pos = newpos
		return value
	
	def readTag(self):
		pos = self.pos
		newpos = pos + 4
		value = self.data[pos:newpos]
		assert len(value) == 4
		self.pos = newpos
		return value
	
	def readUShortArray(self, count):
		return self.readArray(count, "H")
	
	readOffsetArray = readUShortArray
	
	def readShortArray(self, count):
		return self.readArray(count, "h")
	
	def readArray(self, count, format):
		assert format in "Hh"
		from array import array
		pos = self.pos
		newpos = pos + 2 * count
		a = array(format)
		a.fromstring(self.data[pos:newpos])
		if ttLib.endian <> 'big':
			a.byteswap()
		self.pos = newpos
		return a.tolist()
	
	def readTable(self, tableClass, otFont, *args):
		offset = self.readOffset()
		if offset == 0:
			return None
		newReader = self.getSubString(offset)
		table = apply(tableClass, args)
		table.decompile(newReader, otFont)
		return table
	
	def readTableArray(self, count, tableClass, otFont, *args):
		list = []
		for i in range(count):
			list.append(apply(self.readTable, (tableClass, otFont) + args))
		return list
	
	def readTagList(self, count, tableClass, otFont, *args):
		list = []
		for i in range(count):
			tag = self.readTag()
			table = apply(self.readTable, (tableClass, otFont) + args)
			list.append((tag, table))
		return list
	
	def readStruct(self, format, size=None):
		if size is None:
			size = struct.calcsize(format)
		else:
			assert size == struct.calcsize(format)
		pos = self.pos
		newpos = pos + size
		values = struct.unpack(format, self.data[pos:newpos])
		self.pos = newpos
		return values
	
	def getSubString(self, offset):
		return self.__class__(self.data, self.offset+offset)
	
	def seek(self, n):
		"""Relative seek."""
		self.pos = self.pos + n