Пример #1
0
	def decompile(self, data, ttFont):
		# Get the version but don't advance the slice.
		# Most of the lookup for this table is done relative
		# to the begining so slice by the offsets provided
		# in the EBLC table.
		sstruct.unpack2(ebdtTableVersionFormat, data, self)

		# Keep a dict of glyphs that have been seen so they aren't remade.
		# This dict maps intervals of data to the BitmapGlyph.
		glyphDict = {}

		# Pull out the EBLC table and loop through glyphs.
		# A strike is a concept that spans both tables.
		# The actual bitmap data is stored in the EBDT.
		locator = ttFont[self.__class__.locatorName]
		self.strikeData = []
		for curStrike in locator.strikes:
			bitmapGlyphDict = {}
			self.strikeData.append(bitmapGlyphDict)
			for indexSubTable in curStrike.indexSubTables:
				dataIter = itertools.izip(indexSubTable.names, indexSubTable.locations)
				for curName, curLoc in dataIter:
					# Don't create duplicate data entries for the same glyphs.
					# Instead just use the structures that already exist if they exist.
					if curLoc in glyphDict:
						curGlyph = glyphDict[curLoc]
					else:
						curGlyphData = data[slice(*curLoc)]
						imageFormatClass = self.getImageFormatClass(indexSubTable.imageFormat)
						curGlyph = imageFormatClass(curGlyphData, ttFont)
						glyphDict[curLoc] = curGlyph
					bitmapGlyphDict[curName] = curGlyph
Пример #2
0
	def decompile(self, data, ttFont):
		dummy, newData = sstruct.unpack2(METAHeaderFormat, data, self)
		self.glyphRecords = []
		for i in range(self.nMetaRecs):
			glyphRecord, newData = sstruct.unpack2(METAGlyphRecordFormat, newData, GlyphRecord())
			if self.metaFlags == 0:
				[glyphRecord.offset] = struct.unpack(">H", newData[:2])
				newData = newData[2:]
			elif self.metaFlags == 1:
				[glyphRecord.offset] = struct.unpack(">H", newData[:4])
				newData = newData[4:]
			else:
				assert 0, "The metaFlags field in the META table header has a value other than 0 or 1 :" + str(self.metaFlags)
			glyphRecord.stringRecs = []
			newData = data[glyphRecord.offset:]
			for j in range(glyphRecord.nMetaEntry):
				stringRec, newData = sstruct.unpack2(METAStringRecordFormat, newData, StringRecord())
				if self.metaFlags == 0:
					[stringRec.offset] = struct.unpack(">H", newData[:2])
					newData = newData[2:]
				else:
					[stringRec.offset] = struct.unpack(">H", newData[:4])
					newData = newData[4:]
				stringRec.string = data[stringRec.offset:stringRec.offset + stringRec.stringLen]
				glyphRecord.stringRecs.append(stringRec)
			self.glyphRecords.append(glyphRecord)	
Пример #3
0
 def decompile(self, data, ttFont):
     dummy, newData = sstruct.unpack2(METAHeaderFormat, data, self)
     self.glyphRecords = []
     for i in range(self.nMetaRecs):
         glyphRecord, newData = sstruct.unpack2(METAGlyphRecordFormat,
                                                newData, GlyphRecord())
         if self.metaFlags == 0:
             [glyphRecord.offset] = struct.unpack(">H", newData[:2])
             newData = newData[2:]
         elif self.metaFlags == 1:
             [glyphRecord.offset] = struct.unpack(">H", newData[:4])
             newData = newData[4:]
         else:
             assert 0, "The metaFlags field in the META table header has a value other than 0 or 1 :" + str(
                 self.metaFlags)
         glyphRecord.stringRecs = []
         newData = data[glyphRecord.offset:]
         for j in range(glyphRecord.nMetaEntry):
             stringRec, newData = sstruct.unpack2(METAStringRecordFormat,
                                                  newData, StringRecord())
             if self.metaFlags == 0:
                 [stringRec.offset] = struct.unpack(">H", newData[:2])
                 newData = newData[2:]
             else:
                 [stringRec.offset] = struct.unpack(">H", newData[:4])
                 newData = newData[4:]
             stringRec.string = data[stringRec.offset:stringRec.offset +
                                     stringRec.stringLen]
             glyphRecord.stringRecs.append(stringRec)
         self.glyphRecords.append(glyphRecord)
Пример #4
0
    def decompile(self, data, ttFont):
        # Get the version but don't advance the slice.
        # Most of the lookup for this table is done relative
        # to the begining so slice by the offsets provided
        # in the EBLC table.
        sstruct.unpack2(ebdtTableVersionFormat, data, self)

        # Keep a dict of glyphs that have been seen so they aren't remade.
        # This dict maps intervals of data to the BitmapGlyph.
        glyphDict = {}

        # Pull out the EBLC table and loop through glyphs.
        # A strike is a concept that spans both tables.
        # The actual bitmap data is stored in the EBDT.
        locator = ttFont[self.__class__.locatorName]
        self.strikeData = []
        for curStrike in locator.strikes:
            bitmapGlyphDict = {}
            self.strikeData.append(bitmapGlyphDict)
            for indexSubTable in curStrike.indexSubTables:
                dataIter = itertools.izip(indexSubTable.names,
                                          indexSubTable.locations)
                for curName, curLoc in dataIter:
                    # Don't create duplicate data entries for the same glyphs.
                    # Instead just use the structures that already exist if they exist.
                    if curLoc in glyphDict:
                        curGlyph = glyphDict[curLoc]
                    else:
                        curGlyphData = data[slice(*curLoc)]
                        imageFormatClass = self.getImageFormatClass(
                            indexSubTable.imageFormat)
                        curGlyph = imageFormatClass(curGlyphData, ttFont)
                        glyphDict[curLoc] = curGlyph
                    bitmapGlyphDict[curName] = curGlyph
Пример #5
0
	def decompile(self):
		(self.imageSize,) = struct.unpack(">L", self.data[:4])
		self.metrics = BigGlyphMetrics()
		sstruct.unpack2(bigGlyphMetricsFormat, self.data[4:], self.metrics)
		glyphIds = range(self.firstGlyphIndex, self.lastGlyphIndex+1)
		offsets = [self.imageSize * i + self.imageDataOffset for i in xrange(len(glyphIds)+1)]
		self.locations = zip(offsets, offsets[1:])
		self.names = map(self.ttFont.getGlyphName, glyphIds)
Пример #6
0
	def decompile(self, data, ttFont):
		dummy, newData = sstruct.unpack2(GMAPFormat, data, self)
		self.psFontName = newData[:self.fontNameLength]
		assert (self.recordsOffset % 4) == 0, "GMAP error: recordsOffset is not 32 bit aligned."
		newData = data[self.recordsOffset:]
		self.gmapRecords = []
		for i in range (self.recordsCount):
			gmapRecord, newData = sstruct.unpack2(GMAPRecordFormat1, newData, GMAPRecord())
			gmapRecord.name = gmapRecord.name.strip('\0')
			self.gmapRecords.append(gmapRecord)
Пример #7
0
	def decompile(self):
		self.metrics = BigGlyphMetrics()
		dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
		(numComponents,) = struct.unpack(">H", data[:2])
		data = data[2:]
		self.componentArray = []
		for i in xrange(numComponents):
			curComponent = EbdtComponent()
			dummy, data = sstruct.unpack2(ebdtComponentFormat, data, curComponent)
			curComponent.name = self.ttFont.getGlyphName(curComponent.glyphCode)
			self.componentArray.append(curComponent)
Пример #8
0
 def decompile(self):
     (self.imageSize, ) = struct.unpack(">L", self.data[:4])
     self.metrics = BigGlyphMetrics()
     sstruct.unpack2(bigGlyphMetricsFormat, self.data[4:], self.metrics)
     glyphIds = range(self.firstGlyphIndex, self.lastGlyphIndex + 1)
     offsets = [
         self.imageSize * i + self.imageDataOffset
         for i in xrange(len(glyphIds) + 1)
     ]
     self.locations = zip(offsets, offsets[1:])
     self.names = map(self.ttFont.getGlyphName, glyphIds)
Пример #9
0
 def decompile(self, data, ttFont):
     dummy, newData = sstruct.unpack2(GMAPFormat, data, self)
     self.psFontName = newData[:self.fontNameLength]
     assert (self.recordsOffset %
             4) == 0, "GMAP error: recordsOffset is not 32 bit aligned."
     newData = data[self.recordsOffset:]
     self.gmapRecords = []
     for i in range(self.recordsCount):
         gmapRecord, newData = sstruct.unpack2(GMAPRecordFormat1, newData,
                                               GMAPRecord())
         gmapRecord.name = gmapRecord.name.strip('\0')
         self.gmapRecords.append(gmapRecord)
Пример #10
0
	def decompile(self, data, ttFont):
		dummy, data = sstruct.unpack2(OS2_format_0, data, self)
		if self.version == 1 and not data:
			# workaround for buggy Apple fonts
			self.version = 0
		if self.version == 1:
			sstruct.unpack2(OS2_format_1_addition, data, self)
		elif self.version in (2, 3, 4):
			sstruct.unpack2(OS2_format_2_addition, data, self)
		elif self.version != 0:
			from fontTools import ttLib
			raise ttLib.TTLibError("unknown format for OS/2 table: version %s" % self.version)
		self.panose = sstruct.unpack(panoseFormat, self.panose, Panose())
Пример #11
0
 def decompile(self, data, ttFont):
     dummy, data = sstruct.unpack2(OS2_format_0, data, self)
     if self.version == 1 and not data:
         # workaround for buggy Apple fonts
         self.version = 0
     if self.version == 1:
         sstruct.unpack2(OS2_format_1_addition, data, self)
     elif self.version in (2, 3, 4):
         sstruct.unpack2(OS2_format_2_addition, data, self)
     elif self.version <> 0:
         from fontTools import ttLib
         raise ttLib.TTLibError, "unknown format for OS/2 table: version %s" % self.version
     self.panose = sstruct.unpack(panoseFormat, self.panose, Panose())
Пример #12
0
 def decompile(self):
     self.metrics = BigGlyphMetrics()
     dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data,
                                   self.metrics)
     (numComponents, ) = struct.unpack(">H", data[:2])
     data = data[2:]
     self.componentArray = []
     for i in xrange(numComponents):
         curComponent = EbdtComponent()
         dummy, data = sstruct.unpack2(ebdtComponentFormat, data,
                                       curComponent)
         curComponent.name = self.ttFont.getGlyphName(
             curComponent.glyphCode)
         self.componentArray.append(curComponent)
Пример #13
0
 def decompile(self, data, ttFont):
     dummy, newData = sstruct.unpack2(DSIG_HeaderFormat, data, self)
     assert self.ulVersion == 1, "DSIG ulVersion must be 1"
     assert self.usFlag & ~1 == 0, "DSIG usFlag must be 0x1 or 0x0"
     self.signatureRecords = sigrecs = []
     for n in range(self.usNumSigs):
         sigrec, newData = sstruct.unpack2(DSIG_SignatureFormat, newData, SignatureRecord())
         assert sigrec.ulFormat == 1, "DSIG signature record #%d ulFormat must be 1" % n
         sigrecs.append(sigrec)
     for sigrec in sigrecs:
         dummy, newData = sstruct.unpack2(DSIG_SignatureBlockFormat, data[sigrec.ulOffset :], sigrec)
         assert sigrec.usReserved1 == 0, "DSIG signature record #%d usReserverd1 must be 0" % n
         assert sigrec.usReserved2 == 0, "DSIG signature record #%d usReserverd2 must be 0" % n
         sigrec.pkcs7 = newData[: sigrec.cbSignature]
Пример #14
0
	def decompile(self, data, ttFont):
		dummy, newData = sstruct.unpack2(DSIG_HeaderFormat, data, self)
		assert self.ulVersion == 1, "DSIG ulVersion must be 1"
		assert self.usFlag & ~1 == 0, "DSIG usFlag must be 0x1 or 0x0"
		self.signatureRecords = sigrecs = []
		for n in range(self.usNumSigs):
			sigrec, newData = sstruct.unpack2(DSIG_SignatureFormat, newData, SignatureRecord())
			assert sigrec.ulFormat == 1, "DSIG signature record #%d ulFormat must be 1" % n
			sigrecs.append(sigrec)
		for sigrec in sigrecs:
			dummy, newData = sstruct.unpack2(DSIG_SignatureBlockFormat, data[sigrec.ulOffset:], sigrec)
			assert sigrec.usReserved1 == 0, "DSIG signature record #%d usReserverd1 must be 0" % n
			assert sigrec.usReserved2 == 0, "DSIG signature record #%d usReserverd2 must be 0" % n
			sigrec.pkcs7 = newData[:sigrec.cbSignature]
Пример #15
0
    def decompile(self, data, ttFont):

        # Save the original data because offsets are from the start of the table.
        origData = data

        dummy, data = sstruct.unpack2(eblcHeaderFormat, data, self)

        self.strikes = []
        for curStrikeIndex in xrange(self.numSizes):
            curStrike = Strike()
            self.strikes.append(curStrike)
            curTable = curStrike.bitmapSizeTable
            dummy, data = sstruct.unpack2(bitmapSizeTableFormatPart1, data,
                                          curTable)
            for metric in ('hori', 'vert'):
                metricObj = SbitLineMetrics()
                vars(curTable)[metric] = metricObj
                dummy, data = sstruct.unpack2(sbitLineMetricsFormat, data,
                                              metricObj)
            dummy, data = sstruct.unpack2(bitmapSizeTableFormatPart2, data,
                                          curTable)

        for curStrike in self.strikes:
            curTable = curStrike.bitmapSizeTable
            for subtableIndex in xrange(curTable.numberOfIndexSubTables):
                lowerBound = curTable.indexSubTableArrayOffset + subtableIndex * indexSubTableArraySize
                upperBound = lowerBound + indexSubTableArraySize
                data = origData[lowerBound:upperBound]

                tup = struct.unpack(indexSubTableArrayFormat, data)
                (firstGlyphIndex, lastGlyphIndex,
                 additionalOffsetToIndexSubtable) = tup
                offsetToIndexSubTable = curTable.indexSubTableArrayOffset + additionalOffsetToIndexSubtable
                data = origData[offsetToIndexSubTable:]

                tup = struct.unpack(indexSubHeaderFormat,
                                    data[:indexSubHeaderSize])
                (indexFormat, imageFormat, imageDataOffset) = tup

                indexFormatClass = self.getIndexFormatClass(indexFormat)
                indexSubTable = indexFormatClass(data[indexSubHeaderSize:],
                                                 ttFont)
                indexSubTable.firstGlyphIndex = firstGlyphIndex
                indexSubTable.lastGlyphIndex = lastGlyphIndex
                indexSubTable.additionalOffsetToIndexSubtable = additionalOffsetToIndexSubtable
                indexSubTable.indexFormat = indexFormat
                indexSubTable.imageFormat = imageFormat
                indexSubTable.imageDataOffset = imageDataOffset
                curStrike.indexSubTables.append(indexSubTable)
Пример #16
0
 def decompile(self, data, ttFont):
     dummy, rest = sstruct.unpack2(headFormat, data, self)
     if rest:
         # this is quite illegal, but there seem to be fonts out there that do this
         assert rest == "\0\0"
     self.unitsPerEm = int(self.unitsPerEm)
     self.flags = int(self.flags)
     self.strings2dates()
Пример #17
0
    def decompile_format_0(self, data, ttFont):
        dummy, data2 = sstruct.unpack2(SVG_format_0, data, self)
        # read in SVG Documents Index
        pos = self.offsetToSVGDocIndex
        self.numEntries = numEntries = struct.unpack(">H",
                                                     data[pos:pos + 2])[0]
        self.decompileEntryList(data, pos + 2)

        # read in colorPalettes table.
        self.colorPalettes = colorPalettes = ColorPalettes()
        pos = self.offsetToColorPalettes
        if pos > 0:
            colorPalettes.numColorParams = numColorParams = struct.unpack(
                ">H", data[pos:pos + 2])[0]
            if numColorParams > 0:
                colorPalettes.colorParamUINameIDs = colorParamUINameIDs = []
                pos = pos + 2
                i = 0
                while i < numColorParams:
                    nameID = struct.unpack(">H", data[pos:pos + 2])[0]
                    colorParamUINameIDs.append(nameID)
                    pos = pos + 2
                    i += 1

                colorPalettes.numColorPalettes = numColorPalettes = struct.unpack(
                    ">H", data[pos:pos + 2])[0]
                pos = pos + 2
                if numColorPalettes > 0:
                    colorPalettes.colorPaletteList = colorPaletteList = []
                    i = 0
                    while i < numColorPalettes:
                        colorPalette = ColorPalette()
                        colorPaletteList.append(colorPalette)
                        colorPalette.uiNameID = struct.unpack(
                            ">H", data[pos:pos + 2])[0]
                        pos = pos + 2
                        colorPalette.paletteColors = paletteColors = []
                        j = 0
                        while j < numColorParams:
                            colorRecord, colorPaletteData = sstruct.unpack2(
                                colorRecord_format_0, data[pos:],
                                ColorRecord())
                            paletteColors.append(colorRecord)
                            j += 1
                            pos += 4
                        i += 1
Пример #18
0
	def decompile(self, data, ttFont):
		dummy, rest = sstruct.unpack2(headFormat, data, self)
		if rest:
			# this is quite illegal, but there seem to be fonts out there that do this
			assert rest == "\0\0"
		self.unitsPerEm = int(self.unitsPerEm)
		self.flags = int(self.flags)
		self.strings2dates()
Пример #19
0
	def decompile(self, data, ttFont):

		# Save the original data because offsets are from the start of the table.
		origData = data

		dummy, data = sstruct.unpack2(eblcHeaderFormat, data, self)

		self.strikes = []
		for curStrikeIndex in xrange(self.numSizes):
			curStrike = Strike()
			self.strikes.append(curStrike)
			curTable = curStrike.bitmapSizeTable
			dummy, data = sstruct.unpack2(bitmapSizeTableFormatPart1, data, curTable)
			for metric in ('hori', 'vert'):
				metricObj = SbitLineMetrics()
				vars(curTable)[metric] = metricObj
				dummy, data = sstruct.unpack2(sbitLineMetricsFormat, data, metricObj)
			dummy, data = sstruct.unpack2(bitmapSizeTableFormatPart2, data, curTable)

		for curStrike in self.strikes:
			curTable = curStrike.bitmapSizeTable
			for subtableIndex in xrange(curTable.numberOfIndexSubTables):
				lowerBound = curTable.indexSubTableArrayOffset + subtableIndex * indexSubTableArraySize
				upperBound = lowerBound + indexSubTableArraySize
				data = origData[lowerBound:upperBound]

				tup = struct.unpack(indexSubTableArrayFormat, data)
				(firstGlyphIndex, lastGlyphIndex, additionalOffsetToIndexSubtable) = tup
				offsetToIndexSubTable = curTable.indexSubTableArrayOffset + additionalOffsetToIndexSubtable
				data = origData[offsetToIndexSubTable:]

				tup = struct.unpack(indexSubHeaderFormat, data[:indexSubHeaderSize])
				(indexFormat, imageFormat, imageDataOffset) = tup

				indexFormatClass = self.getIndexFormatClass(indexFormat)
				indexSubTable = indexFormatClass(data[indexSubHeaderSize:], ttFont)
				indexSubTable.firstGlyphIndex = firstGlyphIndex
				indexSubTable.lastGlyphIndex = lastGlyphIndex
				indexSubTable.additionalOffsetToIndexSubtable = additionalOffsetToIndexSubtable
				indexSubTable.indexFormat = indexFormat
				indexSubTable.imageFormat = imageFormat
				indexSubTable.imageDataOffset = imageDataOffset
				curStrike.indexSubTables.append(indexSubTable)
Пример #20
0
    def decompile(self):
        self.metrics = BigGlyphMetrics()
        dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data,
                                      self.metrics)
        (dataLen, ) = struct.unpack(">L", data[:4])
        data = data[4:]

        # For the image data cut it to the size specified by dataLen.
        assert dataLen <= len(data), "Data overun in format 18"
        self.imageData = data[:dataLen]
Пример #21
0
	def decompile(self, data, ttFont):
		dummy, data = sstruct.unpack2(OS2_format_0, data, self)
		# workarounds for buggy fonts (Apple, mona)
		if not data:
			self.version = 0
		elif len(data) == sstruct.calcsize(OS2_format_1_addition):
			self.version = 1
		elif len(data) == sstruct.calcsize(OS2_format_2_addition):
			if self.version not in (2, 3, 4):
				self.version = 1
		else:
			from fontTools import ttLib
			raise ttLib.TTLibError, "unknown format for OS/2 table (incorrect length): version %s" % (self.version, len(data))
		if self.version == 1:
			sstruct.unpack2(OS2_format_1_addition, data, self)
		elif self.version in (2, 3, 4):
			sstruct.unpack2(OS2_format_2_addition, data, self)
		elif self.version <> 0:
			from fontTools import ttLib
			raise ttLib.TTLibError, "unknown format for OS/2 table: version %s" % self.version
		self.panose = sstruct.unpack(panoseFormat, self.panose, Panose())
Пример #22
0
	def decompile(self, data, ttFont):
		dummy, rest = sstruct.unpack2(SINGFormat, data, self)
		self.uniqueName = self.decompileUniqueName(self.uniqueName)
		self.nameLength = ord(self.nameLength)
		assert len(rest) == self.nameLength
		self.baseGlyphName = rest
		
		rawMETAMD5 = self.METAMD5
		self.METAMD5 = "[" + hex(ord(self.METAMD5[0]))
		for char in rawMETAMD5[1:]:
			self.METAMD5 = self.METAMD5 + ", " + hex(ord(char))
		self.METAMD5 = self.METAMD5 + "]"
Пример #23
0
	def decompile(self):
		self.origDataLen = 0
		(self.imageSize,) = struct.unpack(">L", self.data[:4])
		data = self.data[4:]
		self.metrics, data = sstruct.unpack2(bigGlyphMetricsFormat, data, BigGlyphMetrics())
		(numGlyphs,) = struct.unpack(">L", data[:4])
		data = data[4:]
		glyphIds = [struct.unpack(">H", data[2*i:2*(i+1)])[0] for i in xrange(numGlyphs)]

		offsets = [self.imageSize * i + self.imageDataOffset for i in xrange(len(glyphIds)+1)]
		self.locations = zip(offsets, offsets[1:])
		self.names = map(self.ttFont.getGlyphName, glyphIds)
Пример #24
0
    def decompile(self, data, ttFont):
        dummy, rest = sstruct.unpack2(SINGFormat, data, self)
        self.uniqueName = self.decompileUniqueName(self.uniqueName)
        self.nameLength = ord(self.nameLength)
        assert len(rest) == self.nameLength
        self.baseGlyphName = rest

        rawMETAMD5 = self.METAMD5
        self.METAMD5 = "[" + hex(ord(self.METAMD5[0]))
        for char in rawMETAMD5[1:]:
            self.METAMD5 = self.METAMD5 + ", " + hex(ord(char))
        self.METAMD5 = self.METAMD5 + "]"
Пример #25
0
	def decompile_format_0(self, data, ttFont):
		dummy, data2 = sstruct.unpack2(SVG_format_0, data, self)
		# read in SVG Documents Index
		pos = self.offsetToSVGDocIndex
		self.numEntries = numEntries = struct.unpack(">H", data[pos:pos+2])[0]
		self.decompileEntryList(data, pos+2)

		# read in colorPalettes table.
		self.colorPalettes = colorPalettes = ColorPalettes()
		pos = self.offsetToColorPalettes
		if pos > 0:
			colorPalettes.numColorParams = numColorParams = struct.unpack(">H", data[pos:pos+2])[0]
			if numColorParams > 0:
				colorPalettes.colorParamUINameIDs = colorParamUINameIDs = []
				pos = pos + 2
				i = 0
				while i < numColorParams:
					nameID = struct.unpack(">H", data[pos:pos+2])[0]
					colorParamUINameIDs.append(nameID)
					pos = pos + 2
					i += 1

				colorPalettes.numColorPalettes = numColorPalettes = struct.unpack(">H", data[pos:pos+2])[0]
				pos = pos + 2
				if numColorPalettes > 0:
					colorPalettes.colorPaletteList = colorPaletteList = []
					i = 0
					while i < numColorPalettes:
						colorPalette = ColorPalette()
						colorPaletteList.append(colorPalette)
						colorPalette.uiNameID = struct.unpack(">H", data[pos:pos+2])[0]
						pos = pos + 2
						colorPalette.paletteColors = paletteColors = []
						j = 0
						while j < numColorParams:
							colorRecord, colorPaletteData = sstruct.unpack2(colorRecord_format_0, data[pos:], ColorRecord())
							paletteColors.append(colorRecord)
							j += 1
							pos += 4
						i += 1
Пример #26
0
 def decompile(self, data, ttFont):
     dummy, data = sstruct.unpack2(OS2_format_0, data, self)
     # workarounds for buggy fonts (Apple, mona)
     if not data:
         self.version = 0
     elif len(data) == sstruct.calcsize(OS2_format_1_addition):
         self.version = 1
     elif len(data) == sstruct.calcsize(OS2_format_2_addition):
         if self.version not in (2, 3, 4):
             self.version = 1
     else:
         from fontTools import ttLib
         raise ttLib.TTLibError, "unknown format for OS/2 table (incorrect length): version %s" % (
             self.version, len(data))
     if self.version == 1:
         sstruct.unpack2(OS2_format_1_addition, data, self)
     elif self.version in (2, 3, 4):
         sstruct.unpack2(OS2_format_2_addition, data, self)
     elif self.version <> 0:
         from fontTools import ttLib
         raise ttLib.TTLibError, "unknown format for OS/2 table: version %s" % self.version
     self.panose = sstruct.unpack(panoseFormat, self.panose, Panose())
Пример #27
0
	def expand(self, glyfTable):
		if not hasattr(self, "data"):
			# already unpacked
			return
		if not self.data:
			# empty char
			self.numberOfContours = 0
			return
		dummy, data = sstruct.unpack2(glyphHeaderFormat, self.data, self)
		del self.data
		if self.isComposite():
			self.decompileComponents(data, glyfTable)
		else:
			self.decompileCoordinates(data)
Пример #28
0
	def expand(self, glyfTable):
		if not hasattr(self, "data"):
			# already unpacked
			return
		if not self.data:
			# empty char
			self.numberOfContours = 0
			return
		dummy, data = sstruct.unpack2(glyphHeaderFormat, self.data, self)
		del self.data
		if self.isComposite():
			self.decompileComponents(data, glyfTable)
		else:
			self.decompileCoordinates(data)
Пример #29
0
	def decompile(self, data, ttFont):
		numGlyphs = ttFont['maxp'].numGlyphs
		glyphOrder = ttFont.getGlyphOrder()
		dummy, data = sstruct.unpack2(hdmxHeaderFormat, data, self)
		self.hdmx = {}
		for i in range(self.numRecords):
			ppem = ord(data[0])
			maxSize = ord(data[1])
			widths = {}
			for glyphID in range(numGlyphs):
				widths[glyphOrder[glyphID]] = ord(data[glyphID+2])
			self.hdmx[ppem] = widths
			data = data[self.recordSize:]
		assert len(data) == 0, "too much hdmx data"
Пример #30
0
 def decompile(self, data, ttFont):
     numGlyphs = ttFont['maxp'].numGlyphs
     glyphOrder = ttFont.getGlyphOrder()
     dummy, data = sstruct.unpack2(hdmxHeaderFormat, data, self)
     self.hdmx = {}
     for i in range(self.numRecords):
         ppem = ord(data[0])
         maxSize = ord(data[1])
         widths = {}
         for glyphID in range(numGlyphs):
             widths[glyphOrder[glyphID]] = ord(data[glyphID + 2])
         self.hdmx[ppem] = widths
         data = data[self.recordSize:]
     assert len(data) == 0, "too much hdmx data"
Пример #31
0
	def decompileEntryList(self, data, pos):
		# data starts with the first entry of the entry list.
		if self.numEntries > 0:
			data2 = data[pos:]
			self.docList = []
			self.entries = entries = []
			i = 0
			while i < self.numEntries:
				docIndexEntry, data2 = sstruct.unpack2(doc_index_entry_format_0, data2, DocumentIndexEntry())
				entries.append(docIndexEntry)
				i += 1

			for entry in entries:
				start = entry.svgDocOffset
				end = start + entry.svgDocLength
				doc = data[start:end]
				self.docList.append( [doc, entry.startGlyphID, entry.endGlyphID] )
Пример #32
0
    def decompileEntryList(self, data, pos):
        # data starts with the first entry of the entry list.
        if self.numEntries > 0:
            data2 = data[pos:]
            self.docList = []
            self.entries = entries = []
            i = 0
            while i < self.numEntries:
                docIndexEntry, data2 = sstruct.unpack2(
                    doc_index_entry_format_0, data2, DocumentIndexEntry())
                entries.append(docIndexEntry)
                i += 1

            for entry in entries:
                start = entry.svgDocOffset
                end = start + entry.svgDocLength
                doc = data[start:end]
                self.docList.append(
                    [doc, entry.startGlyphID, entry.endGlyphID])
Пример #33
0
    def decompile(self):
        self.origDataLen = 0
        (self.imageSize, ) = struct.unpack(">L", self.data[:4])
        data = self.data[4:]
        self.metrics, data = sstruct.unpack2(bigGlyphMetricsFormat, data,
                                             BigGlyphMetrics())
        (numGlyphs, ) = struct.unpack(">L", data[:4])
        data = data[4:]
        glyphIds = [
            struct.unpack(">H", data[2 * i:2 * (i + 1)])[0]
            for i in xrange(numGlyphs)
        ]

        offsets = [
            self.imageSize * i + self.imageDataOffset
            for i in xrange(len(glyphIds) + 1)
        ]
        self.locations = zip(offsets, offsets[1:])
        self.names = map(self.ttFont.getGlyphName, glyphIds)
Пример #34
0
	def decompile(self, data, ttFont):
		format, n, stringOffset = struct.unpack(">HHH", data[:6])
		expectedStringOffset = 6 + n * nameRecordSize
		if stringOffset != expectedStringOffset:
			# XXX we need a warn function
			print "Warning: 'name' table stringOffset incorrect.",
			print "Expected: %s; Actual: %s" % (expectedStringOffset, stringOffset)
		stringData = data[stringOffset:]
		data = data[6:]
		self.names = []
		for i in range(n):
			if len(data) < 12:
				# compensate for buggy font
				break
			name, data = sstruct.unpack2(nameRecordFormat, data, NameRecord())
			name.string = stringData[name.offset:name.offset+name.length]
			assert len(name.string) == name.length
			#if (name.platEncID, name.platformID) in ((0, 0), (1, 3)):
			#	if len(name.string) % 2:
			#		print "2-byte string doesn't have even length!"
			#		print name.__dict__
			del name.offset, name.length
			self.names.append(name)
Пример #35
0
	def decompile(self, data, ttFont):
		format, n, stringOffset = struct.unpack(">HHH", data[:6])
		expectedStringOffset = 6 + n * nameRecordSize
		if stringOffset != expectedStringOffset:
			# XXX we need a warn function
			print "Warning: 'name' table stringOffset incorrect.",
			print "Expected: %s; Actual: %s" % (expectedStringOffset, stringOffset)
		stringData = data[stringOffset:]
		data = data[6:]
		self.names = []
		for i in range(n):
			if len(data) < 12:
				# compensate for buggy font
				break
			name, data = sstruct.unpack2(nameRecordFormat, data, NameRecord())
			name.string = stringData[name.offset:name.offset+name.length]
			assert len(name.string) == name.length
			#if (name.platEncID, name.platformID) in ((0, 0), (1, 3)):
			#	if len(name.string) % 2:
			#		print "2-byte string doesn't have even length!"
			#		print name.__dict__
			del name.offset, name.length
			self.names.append(name)
Пример #36
0
	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])
Пример #37
0
	def decompile(self):
		self.metrics = BigGlyphMetrics()
		dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
		self.imageData = data
Пример #38
0
 def decompile(self, data, ttFont):
     dummy, data = sstruct.unpack2(maxpFormat_0_5, data, self)
     self.numGlyphs = int(self.numGlyphs)
     if self.tableVersion != 0x00005000:
         dummy, data = sstruct.unpack2(maxpFormat_1_0_add, data, self)
     assert len(data) == 0
Пример #39
0
	def decompile(self, data, ttFont):
		dummy, data = sstruct.unpack2(maxpFormat_0_5, data, self)
		self.numGlyphs = int(self.numGlyphs)
		if self.tableVersion != 0x00005000:
			dummy, data = sstruct.unpack2(maxpFormat_1_0_add, data, self)
		assert len(data) == 0
Пример #40
0
 def decompile(self):
     self.metrics = BigGlyphMetrics()
     dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data,
                                   self.metrics)
     self.imageData = data