# Source code for fontTools.ttLib.tables.sbixStrike

    from fontTools.misc import sstruct
    from fontTools.misc.textTools import safeEval
    from .sbixGlyph import Glyph
    import struct

    sbixStrikeHeaderFormat = """
    	>
    	ppem:          H	# The PPEM for which this strike was designed (e.g., 9,
    						# 12, 24)
    	resolution:    H	# The screen resolution (in dpi) for which this strike
    						# was designed (e.g., 72)
    """

    sbixGlyphDataOffsetFormat = """
    	>
    	glyphDataOffset:   L	# Offset from the beginning of the strike data record
    							# to data for the individual glyph
    """

    sbixStrikeHeaderFormatSize = sstruct.calcsize(sbixStrikeHeaderFormat)
    sbixGlyphDataOffsetFormatSize = sstruct.calcsize(sbixGlyphDataOffsetFormat)

    class Strike(object):
    	def __init__(self, rawdata=None, ppem=0, resolution=72):
    		self.data = rawdata
    		self.ppem = ppem
    		self.resolution = resolution
    		self.glyphs = {}

    	def decompile(self, ttFont):
    		if self.data is None:
    			from fontTools import ttLib
    			raise ttLib.TTLibError
    		if len(self.data) < sbixStrikeHeaderFormatSize:
    			from fontTools import ttLib
    			raise(ttLib.TTLibError, "Strike header too short: Expected %x, got %x.") \
    				% (sbixStrikeHeaderFormatSize, len(self.data))

    		# read Strike header from raw data
    		sstruct.unpack(sbixStrikeHeaderFormat, self.data[:sbixStrikeHeaderFormatSize], self)

    		# calculate number of glyphs
    		firstGlyphDataOffset, = struct.unpack(">L", \
    			self.data[sbixStrikeHeaderFormatSize:sbixStrikeHeaderFormatSize + sbixGlyphDataOffsetFormatSize])
    		self.numGlyphs = (firstGlyphDataOffset - sbixStrikeHeaderFormatSize) // sbixGlyphDataOffsetFormatSize - 1
    		# ^ -1 because there's one more offset than glyphs

    		# build offset list for single glyph data offsets
    		self.glyphDataOffsets = []
    		for i in range(self.numGlyphs + 1): # + 1 because there's one more offset than glyphs
    			start = i * sbixGlyphDataOffsetFormatSize + sbixStrikeHeaderFormatSize
    			current_offset, = struct.unpack(">L", self.data[start:start + sbixGlyphDataOffsetFormatSize])
    			self.glyphDataOffsets.append(current_offset)

    		# iterate through offset list and slice raw data into glyph data records
    		for i in range(self.numGlyphs):
    			current_glyph = Glyph(rawdata=self.data[self.glyphDataOffsets[i]:self.glyphDataOffsets[i+1]], gid=i)
    			current_glyph.decompile(ttFont)
    			self.glyphs[current_glyph.glyphName] = current_glyph
    		del self.glyphDataOffsets
    		del self.numGlyphs
    		del self.data

    	def compile(self, ttFont):
    		self.glyphDataOffsets = b""
    		self.bitmapData = b""

    		glyphOrder = ttFont.getGlyphOrder()

    		# first glyph starts right after the header
    		currentGlyphDataOffset = sbixStrikeHeaderFormatSize + sbixGlyphDataOffsetFormatSize * (len(glyphOrder) + 1)
    		for glyphName in glyphOrder:
    			if glyphName in self.glyphs:
    				# we have glyph data for this glyph
    				current_glyph = self.glyphs[glyphName]
    			else:
    				# must add empty glyph data record for this glyph
    				current_glyph = Glyph(glyphName=glyphName)
    			current_glyph.compile(ttFont)
    			current_glyph.glyphDataOffset = currentGlyphDataOffset
    			self.bitmapData += current_glyph.rawdata
    			currentGlyphDataOffset += len(current_glyph.rawdata)
    			self.glyphDataOffsets += sstruct.pack(sbixGlyphDataOffsetFormat, current_glyph)

    		# add last "offset", really the end address of the last glyph data record
    		dummy = Glyph()
    		dummy.glyphDataOffset = currentGlyphDataOffset
    		self.glyphDataOffsets += sstruct.pack(sbixGlyphDataOffsetFormat, dummy)

    		# pack header
    		self.data = sstruct.pack(sbixStrikeHeaderFormat, self)
    		# add offsets and image data after header
    		self.data += self.glyphDataOffsets + self.bitmapData

    	def toXML(self, xmlWriter, ttFont):
    		xmlWriter.begintag("strike")
    		xmlWriter.newline()
    		xmlWriter.simpletag("ppem", value=self.ppem)
    		xmlWriter.newline()
    		xmlWriter.simpletag("resolution", value=self.resolution)
    		xmlWriter.newline()
    		glyphOrder = ttFont.getGlyphOrder()
    		for i in range(len(glyphOrder)):
    			if glyphOrder[i] in self.glyphs:
    				self.glyphs[glyphOrder[i]].toXML(xmlWriter, ttFont)
    				# TODO: what if there are more glyph data records than (glyf table) glyphs?
    		xmlWriter.endtag("strike")
    		xmlWriter.newline()

    	def fromXML(self, name, attrs, content, ttFont):
    		if name in ["ppem", "resolution"]:
    			setattr(self, name, safeEval(attrs["value"]))
    		elif name == "glyph":
    			if "graphicType" in attrs:
    				myFormat = safeEval("'''" + attrs["graphicType"] + "'''")
    			else:
    				myFormat = None
    			if "glyphname" in attrs:
    				myGlyphName = safeEval("'''" + attrs["glyphname"] + "'''")
    			elif "name" in attrs:
    				myGlyphName = safeEval("'''" + attrs["name"] + "'''")
    			else:
    				from fontTools import ttLib
    				raise ttLib.TTLibError("Glyph must have a glyph name.")
    			if "originOffsetX" in attrs:
    				myOffsetX = safeEval(attrs["originOffsetX"])
    			else:
    				myOffsetX = 0
    			if "originOffsetY" in attrs:
    				myOffsetY = safeEval(attrs["originOffsetY"])
    			else:
    				myOffsetY = 0
    			current_glyph = Glyph(
    				glyphName=myGlyphName,
    				graphicType=myFormat,
    				originOffsetX=myOffsetX,
    				originOffsetY=myOffsetY,
    			)
    			for element in content:
    				if isinstance(element, tuple):
    					name, attrs, content = element
    					current_glyph.fromXML(name, attrs, content, ttFont)
    					current_glyph.compile(ttFont)
    			self.glyphs[current_glyph.glyphName] = current_glyph
    		else:
    			from fontTools import ttLib
    			raise ttLib.TTLibError("can't handle '%s' element" % name)