public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(36); // populate the buffer newbuf.SetFixed(m_TableVersionNumber, (uint)Table_hhea.FieldOffsets.TableVersionNumber); newbuf.SetShort(m_Ascender, (uint)Table_hhea.FieldOffsets.Ascender); newbuf.SetShort(m_Descender, (uint)Table_hhea.FieldOffsets.Descender); newbuf.SetShort(m_LineGap, (uint)Table_hhea.FieldOffsets.LineGap); newbuf.SetUshort(m_advanceWidthMax, (uint)Table_hhea.FieldOffsets.advanceWidthMax); newbuf.SetShort(m_minLeftSideBearing, (uint)Table_hhea.FieldOffsets.minLeftSideBearing); newbuf.SetShort(m_minRightSideBearing, (uint)Table_hhea.FieldOffsets.minRightSideBearing); newbuf.SetShort(m_xMaxExtent, (uint)Table_hhea.FieldOffsets.xMaxExtent); newbuf.SetShort(m_caretSlopeRise, (uint)Table_hhea.FieldOffsets.caretSlopeRise); newbuf.SetShort(m_caretSlopeRun, (uint)Table_hhea.FieldOffsets.caretSlopeRun); newbuf.SetShort(m_caretOffset, (uint)Table_hhea.FieldOffsets.caretOffset); newbuf.SetShort(m_reserved1, (uint)Table_hhea.FieldOffsets.reserved1); newbuf.SetShort(m_reserved2, (uint)Table_hhea.FieldOffsets.reserved2); newbuf.SetShort(m_reserved3, (uint)Table_hhea.FieldOffsets.reserved3); newbuf.SetShort(m_reserved4, (uint)Table_hhea.FieldOffsets.reserved4); newbuf.SetShort(m_metricDataFormat, (uint)Table_hhea.FieldOffsets.metricDataFormat); newbuf.SetUshort(m_numberOfHMetrics, (uint)Table_hhea.FieldOffsets.numberOfHMetrics); // put the buffer into a Table_vhea object and return it Table_hhea hheaTable = new Table_hhea("hhea", newbuf); return(hheaTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(54); // populate the buffer newbuf.SetFixed(m_TableVersion, (uint)Table_head.FieldOffsets.TableVersionNumber); newbuf.SetFixed(m_fontRevision, (uint)Table_head.FieldOffsets.fontRevision); newbuf.SetUint(m_checkSumAdjustment, (uint)Table_head.FieldOffsets.checkSumAdjustment); newbuf.SetUint(m_magicNumber, (uint)Table_head.FieldOffsets.magicNumber); newbuf.SetUshort(m_flags, (uint)Table_head.FieldOffsets.flags); newbuf.SetUshort(m_unitsPerEm, (uint)Table_head.FieldOffsets.unitsPerEm); newbuf.SetLong(m_created, (uint)Table_head.FieldOffsets.created); newbuf.SetLong(m_modified, (uint)Table_head.FieldOffsets.modified); newbuf.SetShort(m_xMin, (uint)Table_head.FieldOffsets.xMin); newbuf.SetShort(m_yMin, (uint)Table_head.FieldOffsets.yMin); newbuf.SetShort(m_xMax, (uint)Table_head.FieldOffsets.xMax); newbuf.SetShort(m_yMax, (uint)Table_head.FieldOffsets.yMax); newbuf.SetUshort(m_macStyle, (uint)Table_head.FieldOffsets.macStyle); newbuf.SetUshort(m_lowestRecPPEM, (uint)Table_head.FieldOffsets.lowestRecPPEM); newbuf.SetShort(m_fontDirectionHint, (uint)Table_head.FieldOffsets.fontDirectionHint); newbuf.SetShort(m_indexToLocFormat, (uint)Table_head.FieldOffsets.indexToLocFormat); newbuf.SetShort(m_glyphDataFormat, (uint)Table_head.FieldOffsets.glyphDataFormat); // put the buffer into a Table_head object and return it Table_head headTable = new Table_head("head", newbuf); return(headTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(36); // populate the buffer newbuf.SetFixed(m_version, (uint)Table_vhea.FieldOffsets.version); newbuf.SetShort(m_vertTypoAscender, (uint)Table_vhea.FieldOffsets.vertTypoAscender); newbuf.SetShort(m_vertTypoDescender, (uint)Table_vhea.FieldOffsets.vertTypoDescender); newbuf.SetShort(m_vertTypoLineGap, (uint)Table_vhea.FieldOffsets.vertTypoLineGap); newbuf.SetShort(m_advanceHeightMax, (uint)Table_vhea.FieldOffsets.advanceHeightMax); newbuf.SetShort(m_minTopSideBearing, (uint)Table_vhea.FieldOffsets.minTopSideBearing); newbuf.SetShort(m_minBottomSideBearing, (uint)Table_vhea.FieldOffsets.minBottomSideBearing); newbuf.SetShort(m_yMaxExtent, (uint)Table_vhea.FieldOffsets.yMaxExtent); newbuf.SetShort(m_caretSlopeRise, (uint)Table_vhea.FieldOffsets.caretSlopeRise); newbuf.SetShort(m_caretSlopeRun, (uint)Table_vhea.FieldOffsets.caretSlopeRun); newbuf.SetShort(m_caretOffset, (uint)Table_vhea.FieldOffsets.caretOffset); newbuf.SetShort(m_reserved1, (uint)Table_vhea.FieldOffsets.reserved1); newbuf.SetShort(m_reserved2, (uint)Table_vhea.FieldOffsets.reserved2); newbuf.SetShort(m_reserved3, (uint)Table_vhea.FieldOffsets.reserved3); newbuf.SetShort(m_reserved4, (uint)Table_vhea.FieldOffsets.reserved4); newbuf.SetShort(m_metricDataFormat, (uint)Table_vhea.FieldOffsets.metricDataFormat); newbuf.SetUshort(m_numOfLongVerMetrics, (uint)Table_vhea.FieldOffsets.numOfLongVerMetrics); // put the buffer into a Table_vhea object and return it Table_vhea vheaTable = new Table_vhea("vhea", newbuf); return(vheaTable); }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(8 + (uint)(SizeofDeviceRecord * m_NumberDeviceRecords)); // populate the buffer newbuf.SetUshort(m_TableVersionNumber, (uint)Table_hdmx.FieldOffsets.TableVersionNumber); newbuf.SetShort(m_NumberDeviceRecords, (uint)Table_hdmx.FieldOffsets.NumberDeviceRecords); newbuf.SetInt(SizeofDeviceRecord, (uint)Table_hdmx.FieldOffsets.SizeofDeviceRecord); for (short i = 0; i < m_NumberDeviceRecords; i++) { newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).PixelSize, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord) + (uint)DeviceRecord.FieldOffsets.PixelSize); newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).MaxWidth, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord) + (uint)DeviceRecord.FieldOffsets.MaxWidth); for (ushort ii = 0; ii < m_NumGlyphs; ii++) { newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).getWidth(ii), (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord) + (uint)(DeviceRecord.FieldOffsets.Widths + ii)); } // Pad the end with zeros for (uint ii = 0; ii < getNumPadBytes(); ii++) { newbuf.SetByte(0, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord) + (uint)DeviceRecord.FieldOffsets.Widths + m_NumGlyphs + ii); } } // put the buffer into a Table_hdmx object and return it Table_hdmx hdmxTable = new Table_hdmx("hdmx", newbuf); return(hdmxTable); }
public override OTTable GenerateTable() { ArrayList bytesNameString = new ArrayList(); ushort nLengthOfStrings = 0; ushort nStartOfStringStorage = (ushort)(6 + (m_nameRecords.Count * 12)); for (ushort i = 0; i < m_nameRecords.Count; i++) { NameRecordCache nrc = (NameRecordCache)m_nameRecords[i]; byte[] byteString = EncodeString(nrc.sNameString, nrc.platformID, nrc.encodingID); bytesNameString.Add(byteString); nLengthOfStrings += (ushort)byteString.Length; } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(Table_name.FieldOffsets.NameRecords + (m_nameRecords.Count * 12) + nLengthOfStrings)); // populate the buffer newbuf.SetUshort(m_format, (uint)Table_name.FieldOffsets.FormatSelector); newbuf.SetUshort((ushort)m_nameRecords.Count, (uint)Table_name.FieldOffsets.NumberNameRecords); newbuf.SetUshort(nStartOfStringStorage, (uint)Table_name.FieldOffsets.OffsetToStrings); ushort nOffset = 0; // Write the NameRecords and Strings for (ushort i = 0; i < m_nameRecords.Count; i++) { byte[] bString = (byte[])bytesNameString[i]; newbuf.SetUshort(((NameRecordCache)m_nameRecords[i]).platformID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12))); newbuf.SetUshort(((NameRecordCache)m_nameRecords[i]).encodingID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 2)); newbuf.SetUshort(((NameRecordCache)m_nameRecords[i]).languageID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 4)); newbuf.SetUshort(((NameRecordCache)m_nameRecords[i]).nameID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 6)); newbuf.SetUshort((ushort)bString.Length, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 8)); newbuf.SetUshort(nOffset, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 10)); //Write the string to the buffer for (int ii = 0; ii < bString.Length; ii++) { newbuf.SetByte(bString[ii], (uint)(nStartOfStringStorage + nOffset + ii)); } nOffset += (ushort)bString.Length; } // put the buffer into a Table_name object and return it Table_name nameTable = new Table_name("name", newbuf); return(nameTable); }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(4 + ((uint)m_numRanges * 4)); newbuf.SetUshort(m_version, (uint)Table_gasp.FieldOffsets.version); newbuf.SetUshort(m_numRanges, (uint)Table_gasp.FieldOffsets.numRanges); for (ushort i = 0; i < m_numRanges; i++) { newbuf.SetUshort(((GaspRange)m_GaspRange[i]).rangeMaxPPEM, (uint)(Table_gasp.FieldOffsets.gaspRange + (i * 4))); newbuf.SetUshort(((GaspRange)m_GaspRange[i]).rangeGaspBehavior, (uint)(Table_gasp.FieldOffsets.gaspRange + (i * 4) + 2)); } // put the buffer into a Table_vhmtx object and return it Table_gasp gaspTable = new Table_gasp("gasp", newbuf); return(gaspTable); }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(Table_LTSH.FieldOffsets.yPels + m_numGlyphs)); newbuf.SetUshort(m_version, (uint)Table_LTSH.FieldOffsets.version); newbuf.SetUshort(m_numGlyphs, (uint)Table_LTSH.FieldOffsets.numGlyphs); // Fill the buffer with the yPels for (int i = 0; i < m_numGlyphs; i++) { newbuf.SetByte(m_yPels[i], (uint)(Table_LTSH.FieldOffsets.yPels + i)); } // put the buffer into a Table_maxp object and return it Table_LTSH LTSHTable = new Table_LTSH("LTSH", newbuf); return(LTSHTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf; if (m_TableVersionNumber.GetUint() == 0x00000000) { newbuf = new MBOBuffer(6); newbuf.SetFixed(m_TableVersionNumber, (uint)Table_maxp.FieldOffsets.TableVersionNumber); newbuf.SetUshort(m_NumGlyphs, (uint)Table_maxp.FieldOffsets.NumGlyphs); } else { newbuf = new MBOBuffer(32); newbuf.SetFixed(m_TableVersionNumber, (uint)Table_maxp.FieldOffsets.TableVersionNumber); newbuf.SetUshort(m_NumGlyphs, (uint)Table_maxp.FieldOffsets.NumGlyphs); newbuf.SetUshort(m_maxPoints, (uint)Table_maxp.FieldOffsets.maxPoints); newbuf.SetUshort(m_maxContours, (uint)Table_maxp.FieldOffsets.maxContours); newbuf.SetUshort(m_maxCompositePoints, (uint)Table_maxp.FieldOffsets.maxCompositePoints); newbuf.SetUshort(m_maxCompositeContours, (uint)Table_maxp.FieldOffsets.maxCompositeContours); newbuf.SetUshort(m_maxZones, (uint)Table_maxp.FieldOffsets.maxZones); newbuf.SetUshort(m_maxTwilightPoints, (uint)Table_maxp.FieldOffsets.maxTwilightPoints); newbuf.SetUshort(m_maxStorage, (uint)Table_maxp.FieldOffsets.maxStorage); newbuf.SetUshort(m_maxFunctionDefs, (uint)Table_maxp.FieldOffsets.maxFunctionDefs); newbuf.SetUshort(m_maxInstructionDefs, (uint)Table_maxp.FieldOffsets.maxInstructionDefs); newbuf.SetUshort(m_maxStackElements, (uint)Table_maxp.FieldOffsets.maxStackElements); newbuf.SetUshort(m_maxSizeOfInstructions, (uint)Table_maxp.FieldOffsets.maxSizeOfInstructions); newbuf.SetUshort(m_maxComponentElements, (uint)Table_maxp.FieldOffsets.maxComponentElements); newbuf.SetUshort(m_maxComponentDepth, (uint)Table_maxp.FieldOffsets.maxComponentDepth); } // put the buffer into a Table_maxp object and return it Table_maxp maxpTable = new Table_maxp("maxp", newbuf); return(maxpTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(m_nLongVerMetrics * 4) + (uint)((m_nGlyphsInTheFont - m_nLongVerMetrics) * 2)); for (ushort i = 0; i < m_nGlyphsInTheFont; i++) { if (i < m_nLongVerMetrics) { newbuf.SetUshort(((vMetric)m_vMetric[i]).advanceHeight, (uint)(i * 4)); newbuf.SetShort(((vMetric)m_vMetric[i]).topSideBearing, (uint)((i * 4) + 2)); } else { newbuf.SetShort(((vMetric)m_vMetric[i]).topSideBearing, (uint)(((m_nLongVerMetrics - 1) * 4) + (i * 2))); } } // put the buffer into a Table_vhmtx object and return it Table_vmtx vmtxTable = new Table_vmtx("vmtx", newbuf); return(vmtxTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(m_nNumberOfHMetrics * 4) + (uint)((m_nGlyphsInTheFont - m_nNumberOfHMetrics) * 2)); for (ushort i = 0; i < m_nGlyphsInTheFont; i++) { if (i < m_nNumberOfHMetrics) { newbuf.SetUshort(((longHorMetric)m_longHorMetric[i]).advanceWidth, (uint)(i * 4)); newbuf.SetShort(((longHorMetric)m_longHorMetric[i]).lsb, (uint)((i * 4) + 2)); } else { newbuf.SetShort(((longHorMetric)m_longHorMetric[i]).lsb, (uint)(((m_nNumberOfHMetrics - 1) * 4) + (i * 2))); } } // put the buffer into a Table_vhmtx object and return it Table_hmtx hmtxTable = new Table_hmtx("hmtx", newbuf); return(hmtxTable); }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(54); // populate the buffer newbuf.SetFixed(m_Version, (uint)Table_PCLT.FieldOffsets.Version); newbuf.SetUint(m_FontNumber, (uint)Table_PCLT.FieldOffsets.FontNumber); newbuf.SetUshort(m_Pitch, (uint)Table_PCLT.FieldOffsets.Pitch); newbuf.SetUshort(m_xHeight, (uint)Table_PCLT.FieldOffsets.xHeight); newbuf.SetUshort(m_Style, (uint)Table_PCLT.FieldOffsets.Style); newbuf.SetUshort(m_TypeFamily, (uint)Table_PCLT.FieldOffsets.TypeFamily); newbuf.SetUshort(m_CapHeight, (uint)Table_PCLT.FieldOffsets.CapHeight); newbuf.SetUshort(m_SymbolSet, (uint)Table_PCLT.FieldOffsets.SymbolSet); for (uint i = 0; i < 16; i++) { newbuf.SetByte(m_Typeface[i], (uint)Table_PCLT.FieldOffsets.Typeface + i); } for (uint i = 0; i < 8; i++) { newbuf.SetByte(m_CharacterComplement[i], (uint)Table_PCLT.FieldOffsets.CharacterComplement + i); } for (uint i = 0; i < 6; i++) { newbuf.SetByte(m_FileName[i], (uint)Table_PCLT.FieldOffsets.FileName + i); } newbuf.SetShort(m_StrokeWeight, (uint)Table_PCLT.FieldOffsets.StrokeWeight); newbuf.SetShort(m_WidthType, (uint)Table_PCLT.FieldOffsets.WidthType); newbuf.SetByte(m_SerifStyle, (uint)Table_PCLT.FieldOffsets.SerifStyle); newbuf.SetByte(m_Reserved, (uint)Table_PCLT.FieldOffsets.Reserved); // put the buffer into a Table_vhea object and return it Table_PCLT PCLTTable = new Table_PCLT("PCLT", newbuf); return(PCLTTable); }
private void writeEBDTBuffer( MBOBuffer bufEBDT, uint imageDataOffset, imageCache ic, ushort imageFormat ) { switch( imageFormat ) { case 1: { imageCache1 ic1 = (imageCache1)ic; bufEBDT.SetByte( ic1.smallMetrics.height, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic1.smallMetrics.width, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic1.smallMetrics.BearingX, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingX ); bufEBDT.SetSbyte( ic1.smallMetrics.BearingY, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingY ); bufEBDT.SetByte( ic1.smallMetrics.Advance, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.Advance ); System.Buffer.BlockCopy( ic1.imageData, 0, bufEBDT.GetBuffer(), (int)(imageDataOffset + Table_EBDT.smallGlyphMetrics.bufSize), ic1.imageData.Length ); break; } case 2: { imageCache2 ic2 = (imageCache2)ic; bufEBDT.SetByte( ic2.smallMetrics.height, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic2.smallMetrics.width, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic2.smallMetrics.BearingX, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingX ); bufEBDT.SetSbyte( ic2.smallMetrics.BearingY, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingY ); bufEBDT.SetByte( ic2.smallMetrics.Advance, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.Advance ); System.Buffer.BlockCopy( ic2.imageData, 0, bufEBDT.GetBuffer(), (int)(imageDataOffset + Table_EBDT.smallGlyphMetrics.bufSize), ic2.imageData.Length ); break; } case 5: { imageCache5 ic5 = (imageCache5)ic; System.Buffer.BlockCopy( ic5.imageData, 0, bufEBDT.GetBuffer(), (int)imageDataOffset, ic5.imageData.Length ); break; } case 6: { imageCache6 ic6 = (imageCache6)ic; bufEBDT.SetByte( ic6.bigMetrics.height, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic6.bigMetrics.width, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic6.bigMetrics.horiBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingX ); bufEBDT.SetSbyte( ic6.bigMetrics.horiBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingY ); bufEBDT.SetByte( ic6.bigMetrics.horiAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiAdvance ); bufEBDT.SetSbyte( ic6.bigMetrics.vertBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingX ); bufEBDT.SetSbyte( ic6.bigMetrics.vertBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingY ); bufEBDT.SetByte( ic6.bigMetrics.vertAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertAdvance ); System.Buffer.BlockCopy( ic6.imageData, 0, bufEBDT.GetBuffer(), (int)(imageDataOffset + Table_EBDT.bigGlyphMetrics.bufSize), ic6.imageData.Length ); break; } case 7: { imageCache7 ic7 = (imageCache7)ic; bufEBDT.SetByte( ic7.bigMetrics.height, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic7.bigMetrics.width, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic7.bigMetrics.horiBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingX ); bufEBDT.SetSbyte( ic7.bigMetrics.horiBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingY ); bufEBDT.SetByte( ic7.bigMetrics.horiAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiAdvance ); bufEBDT.SetSbyte( ic7.bigMetrics.vertBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingX ); bufEBDT.SetSbyte( ic7.bigMetrics.vertBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingY ); bufEBDT.SetByte( ic7.bigMetrics.vertAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertAdvance ); System.Buffer.BlockCopy( ic7.imageData, 0, bufEBDT.GetBuffer(), (int)(imageDataOffset + Table_EBDT.bigGlyphMetrics.bufSize), ic7.imageData.Length ); break; } case 8: { imageCache8 ic8 = (imageCache8)ic; bufEBDT.SetByte( ic8.smallMetrics.height, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic8.smallMetrics.width, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic8.smallMetrics.BearingX, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingX ); bufEBDT.SetSbyte( ic8.smallMetrics.BearingY, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.BearingY ); bufEBDT.SetByte( ic8.smallMetrics.Advance, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.FieldOffsets.Advance ); //pad bufEBDT.SetByte( 0, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.bufSize ); bufEBDT.SetUshort( ic8.numComponents, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.bufSize + 1 ); for( ushort i = 0; i < ic8.numComponents; i++ ) { Table_EBDT.ebdtComponent ec = ic8.getComponent( i ); bufEBDT.SetUshort( ec.glyphCode, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.bufSize + 3 + (uint)(Table_EBDT.ebdtComponent.bufSize * i )); bufEBDT.SetSbyte( ec.xOffset, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.bufSize + 3 + (uint)(Table_EBDT.ebdtComponent.bufSize * i ) + 2 ); bufEBDT.SetSbyte( ec.yOffset, imageDataOffset + (uint)Table_EBDT.smallGlyphMetrics.bufSize + 3 + (uint)(Table_EBDT.ebdtComponent.bufSize * i ) + 3 ); } break; } case 9: { imageCache9 ic9 = (imageCache9)ic; bufEBDT.SetByte( ic9.bigMetrics.height, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.height ); bufEBDT.SetByte( ic9.bigMetrics.width, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.width ); bufEBDT.SetSbyte( ic9.bigMetrics.horiBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingX ); bufEBDT.SetSbyte( ic9.bigMetrics.horiBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingY ); bufEBDT.SetByte( ic9.bigMetrics.horiAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiAdvance ); bufEBDT.SetSbyte( ic9.bigMetrics.vertBearingX, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingX ); bufEBDT.SetSbyte( ic9.bigMetrics.vertBearingY, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingY ); bufEBDT.SetByte( ic9.bigMetrics.vertAdvance, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertAdvance ); bufEBDT.SetUshort( ic9.numComponents, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.bufSize ); for( ushort i = 0; i < ic9.numComponents; i++ ) { Table_EBDT.ebdtComponent ec = ic9.getComponent( i ); bufEBDT.SetUshort( ec.glyphCode, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.bufSize + 2 + (uint)(Table_EBDT.ebdtComponent.bufSize * i )); bufEBDT.SetSbyte( ec.xOffset, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.bufSize + 2 + (uint)(Table_EBDT.ebdtComponent.bufSize * i ) + 2 ); bufEBDT.SetSbyte( ec.yOffset, imageDataOffset + (uint)Table_EBDT.bigGlyphMetrics.bufSize + 2 + (uint)(Table_EBDT.ebdtComponent.bufSize * i ) + 3 ); } break; } } }
public override OTTable GenerateTable() { MBOBuffer newbuf; switch (m_version) { case 0x0000: newbuf = new MBOBuffer(78); break; case 0x0001: newbuf = new MBOBuffer(86); break; case 0x0002: newbuf = new MBOBuffer(96); break; case 0x0003: goto case 0x0002; default: goto case 0x0002; // version 3 is default } newbuf.SetUshort(m_version, (uint)Table_OS2.FieldOffsets.version); newbuf.SetShort(m_xAvgCharWidth, (uint)Table_OS2.FieldOffsets.xAvgCharWidth); newbuf.SetUshort(m_usWeightClass, (uint)Table_OS2.FieldOffsets.usWeightClass); newbuf.SetUshort(m_usWidthClass, (uint)Table_OS2.FieldOffsets.usWidthClass); newbuf.SetUshort(m_fsType, (uint)Table_OS2.FieldOffsets.fsType); newbuf.SetShort(m_ySubscriptXSize, (uint)Table_OS2.FieldOffsets.ySubscriptXSize); newbuf.SetShort(m_ySubscriptYSize, (uint)Table_OS2.FieldOffsets.ySubscriptYSize); newbuf.SetShort(m_ySubscriptXOffset, (uint)Table_OS2.FieldOffsets.ySubscriptXOffset); newbuf.SetShort(m_ySubscriptYOffset, (uint)Table_OS2.FieldOffsets.ySubscriptYOffset); newbuf.SetShort(m_ySuperscriptXSize, (uint)Table_OS2.FieldOffsets.ySuperscriptXSize); newbuf.SetShort(m_ySuperscriptYSize, (uint)Table_OS2.FieldOffsets.ySuperscriptYSize); newbuf.SetShort(m_ySuperscriptXOffset, (uint)Table_OS2.FieldOffsets.ySuperscriptXOffset); newbuf.SetShort(m_ySuperscriptYOffset, (uint)Table_OS2.FieldOffsets.ySuperscriptYOffset); newbuf.SetShort(m_yStrikeoutSize, (uint)Table_OS2.FieldOffsets.yStrikeoutSize); newbuf.SetShort(m_yStrikeoutPosition, (uint)Table_OS2.FieldOffsets.yStrikeoutPosition); newbuf.SetShort(m_sFamilyClass, (uint)Table_OS2.FieldOffsets.sFamilyClass); newbuf.SetByte(m_panose_byte1, (uint)Table_OS2.FieldOffsets.panose_byte1); newbuf.SetByte(m_panose_byte2, (uint)Table_OS2.FieldOffsets.panose_byte2); newbuf.SetByte(m_panose_byte3, (uint)Table_OS2.FieldOffsets.panose_byte3); newbuf.SetByte(m_panose_byte4, (uint)Table_OS2.FieldOffsets.panose_byte4); newbuf.SetByte(m_panose_byte5, (uint)Table_OS2.FieldOffsets.panose_byte5); newbuf.SetByte(m_panose_byte6, (uint)Table_OS2.FieldOffsets.panose_byte6); newbuf.SetByte(m_panose_byte7, (uint)Table_OS2.FieldOffsets.panose_byte7); newbuf.SetByte(m_panose_byte8, (uint)Table_OS2.FieldOffsets.panose_byte8); newbuf.SetByte(m_panose_byte9, (uint)Table_OS2.FieldOffsets.panose_byte9); newbuf.SetByte(m_panose_byte10, (uint)Table_OS2.FieldOffsets.panose_byte10); newbuf.SetUint(m_ulUnicodeRange1, (uint)Table_OS2.FieldOffsets.ulUnicodeRange1); newbuf.SetUint(m_ulUnicodeRange2, (uint)Table_OS2.FieldOffsets.ulUnicodeRange2); newbuf.SetUint(m_ulUnicodeRange3, (uint)Table_OS2.FieldOffsets.ulUnicodeRange3); newbuf.SetUint(m_ulUnicodeRange4, (uint)Table_OS2.FieldOffsets.ulUnicodeRange4); for (int i = 0; i < 4; i++) { newbuf.SetByte(m_achVendID[i], (uint)(Table_OS2.FieldOffsets.achVendID + i)); } newbuf.SetUshort(m_fsSelection, (uint)Table_OS2.FieldOffsets.fsSelection); newbuf.SetUshort(m_usFirstCharIndex, (uint)Table_OS2.FieldOffsets.usFirstCharIndex); newbuf.SetUshort(m_usLastCharIndex, (uint)Table_OS2.FieldOffsets.usLastCharIndex); newbuf.SetShort(m_sTypoAscender, (uint)Table_OS2.FieldOffsets.sTypoAscender); newbuf.SetShort(m_sTypoDescender, (uint)Table_OS2.FieldOffsets.sTypoDescender); newbuf.SetShort(m_sTypoLineGap, (uint)Table_OS2.FieldOffsets.sTypoLineGap); newbuf.SetUshort(m_usWinAscent, (uint)Table_OS2.FieldOffsets.usWinAscent); newbuf.SetUshort(m_usWinDescent, (uint)Table_OS2.FieldOffsets.usWinDescent); // version 1.0 if (version > 0x000) { newbuf.SetUint(m_ulCodePageRange1, (uint)Table_OS2.FieldOffsets.ulCodePageRange1); newbuf.SetUint(m_ulCodePageRange2, (uint)Table_OS2.FieldOffsets.ulCodePageRange2); // vewrsion 2 & 3 if (version > 0x001) { newbuf.SetShort(m_sxHeight, (uint)Table_OS2.FieldOffsets.sxHeight); newbuf.SetShort(m_sCapHeight, (uint)Table_OS2.FieldOffsets.sCapHeight); newbuf.SetUshort(m_usDefaultChar, (uint)Table_OS2.FieldOffsets.usDefaultChar); newbuf.SetUshort(m_usBreakChar, (uint)Table_OS2.FieldOffsets.usBreakChar); newbuf.SetUshort(m_usMaxContext, (uint)Table_OS2.FieldOffsets.usMaxContext); } } // put the buffer into a Table_maxp object and return it Table_OS2 OS2Table = new Table_OS2("OS/2", newbuf); return(OS2Table); }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( 4 + ((uint)m_numRanges * 4)); newbuf.SetUshort( m_version, (uint)Table_gasp.FieldOffsets.version ); newbuf.SetUshort( m_numRanges, (uint)Table_gasp.FieldOffsets.numRanges ); for( ushort i = 0; i < m_numRanges; i++ ) { newbuf.SetUshort( ((GaspRange)m_GaspRange[i]).rangeMaxPPEM, (uint)(Table_gasp.FieldOffsets.gaspRange + (i * 4))); newbuf.SetUshort(((GaspRange)m_GaspRange[i]).rangeGaspBehavior, (uint)(Table_gasp.FieldOffsets.gaspRange + (i * 4) + 2)); } // put the buffer into a Table_vhmtx object and return it Table_gasp gaspTable = new Table_gasp( "gasp", newbuf ); return gaspTable; }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf; uint nSizeOfIndexAndNames = 0; if( m_Version.GetUint() == 0x00020000 ) { uint nSizeOfByteArray = 0; // Get what the size of the byte array will be for(int i = 0; i < m_names.Count; i++ ) { nSizeOfByteArray += (uint)(((string)m_names[i]).Length + 1); } // Add 2 for the ushort numberOfGlyphs nSizeOfIndexAndNames = (uint)(2 + (m_numberOfGlyphs * 2) + nSizeOfByteArray); } newbuf = new MBOBuffer(32 + nSizeOfIndexAndNames); newbuf.SetFixed( m_Version, (uint)Table_post.FieldOffsets.Version ); newbuf.SetFixed( m_italicAngle, (uint)Table_post.FieldOffsets.italicAngle ); newbuf.SetShort( m_underlinePosition, (uint)Table_post.FieldOffsets.underlinePosition ); newbuf.SetShort( m_underlineThickness, (uint)Table_post.FieldOffsets.underlineThickness ); newbuf.SetUint( m_isFixedPitch, (uint)Table_post.FieldOffsets.isFixedPitch ); newbuf.SetUint( m_minMemType42, (uint)Table_post.FieldOffsets.minMemType42 ); newbuf.SetUint( m_maxMemType42, (uint)Table_post.FieldOffsets.maxMemType42 ); newbuf.SetUint( m_minMemType1, (uint)Table_post.FieldOffsets.minMemType1); newbuf.SetUint( m_maxMemType1, (uint)Table_post.FieldOffsets.maxMemType1); if( m_Version.GetUint() == 0x00020000 ) { newbuf.SetUshort( m_numberOfGlyphs, (uint)Table_post.FieldOffsetsVer2.numberOfGlyphs); uint nOffset = (uint)Table_post.FieldOffsetsVer2.glyphNameIndex; for( int i = 0; i < m_numberOfGlyphs; i++ ) { newbuf.SetUshort( (ushort)m_glyphNameIndex[i], nOffset ); nOffset += 2; } // write out the names to the buffer in length followed by character bytes for( int i = 0; i < m_names.Count; i++ ) { string sName = (string)m_names[i]; newbuf.SetByte( (byte)sName.Length, nOffset ); nOffset++; for( int ii = 0; ii < sName.Length; ii++ ) { newbuf.SetByte( (byte)sName[ii], nOffset ); nOffset++; } } } // put the buffer into a Table_maxp object and return it Table_post postTable = new Table_post("post", newbuf); return postTable; }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(36); // populate the buffer newbuf.SetFixed( m_TableVersionNumber, (uint)Table_hhea.FieldOffsets.TableVersionNumber ); newbuf.SetShort( m_Ascender, (uint)Table_hhea.FieldOffsets.Ascender ); newbuf.SetShort( m_Descender, (uint)Table_hhea.FieldOffsets.Descender ); newbuf.SetShort( m_LineGap, (uint)Table_hhea.FieldOffsets.LineGap ); newbuf.SetUshort( m_advanceWidthMax, (uint)Table_hhea.FieldOffsets.advanceWidthMax ); newbuf.SetShort( m_minLeftSideBearing, (uint)Table_hhea.FieldOffsets.minLeftSideBearing ); newbuf.SetShort( m_minRightSideBearing, (uint)Table_hhea.FieldOffsets.minRightSideBearing ); newbuf.SetShort( m_xMaxExtent, (uint)Table_hhea.FieldOffsets.xMaxExtent ); newbuf.SetShort( m_caretSlopeRise, (uint)Table_hhea.FieldOffsets.caretSlopeRise ); newbuf.SetShort( m_caretSlopeRun, (uint)Table_hhea.FieldOffsets.caretSlopeRun ); newbuf.SetShort( m_caretOffset, (uint)Table_hhea.FieldOffsets.caretOffset ); newbuf.SetShort( m_reserved1, (uint)Table_hhea.FieldOffsets.reserved1 ); newbuf.SetShort( m_reserved2, (uint)Table_hhea.FieldOffsets.reserved2 ); newbuf.SetShort( m_reserved3, (uint)Table_hhea.FieldOffsets.reserved3 ); newbuf.SetShort( m_reserved4, (uint)Table_hhea.FieldOffsets.reserved4 ); newbuf.SetShort( m_metricDataFormat, (uint)Table_hhea.FieldOffsets.metricDataFormat ); newbuf.SetUshort( m_numberOfHMetrics, (uint)Table_hhea.FieldOffsets.numberOfHMetrics ); // put the buffer into a Table_vhea object and return it Table_hhea hheaTable = new Table_hhea("hhea", newbuf); return hheaTable; }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( 8 + (uint)(SizeofDeviceRecord * m_NumberDeviceRecords)); // populate the buffer newbuf.SetUshort( m_TableVersionNumber, (uint)Table_hdmx.FieldOffsets.TableVersionNumber ); newbuf.SetShort( m_NumberDeviceRecords, (uint)Table_hdmx.FieldOffsets.NumberDeviceRecords ); newbuf.SetInt( SizeofDeviceRecord, (uint)Table_hdmx.FieldOffsets.SizeofDeviceRecord ); for( short i = 0; i < m_NumberDeviceRecords; i++ ) { newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).PixelSize, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord ) + (uint)DeviceRecord.FieldOffsets.PixelSize ); newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).MaxWidth, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord ) + (uint)DeviceRecord.FieldOffsets.MaxWidth ); for( ushort ii = 0; ii < m_NumGlyphs; ii++ ) { newbuf.SetByte(((DeviceRecordCache)m_DeviceRecords[i]).getWidth( ii ), (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord ) + (uint)(DeviceRecord.FieldOffsets.Widths + ii )); } // Pad the end with zeros for( uint ii = 0; ii < getNumPadBytes(); ii++ ) { newbuf.SetByte( 0, (uint)Table_hdmx.FieldOffsets.DeviceRecord + (uint)(i * SizeofDeviceRecord ) + (uint)DeviceRecord.FieldOffsets.Widths + m_NumGlyphs + ii ); } } // put the buffer into a Table_hdmx object and return it Table_hdmx hdmxTable = new Table_hdmx("hdmx", newbuf); return hdmxTable; }
protected byte[] GenerateFormat12Subtable(uint [] map) { bool bFound = false; uint CurChar = 0; ArrayList arrSegments = new ArrayList(); segment12 seg = new segment12(); while (CurChar < map.Length) { // find the startCode char in this segment bFound = false; for (uint i=CurChar; i<map.Length; i++) { if (map[i] != 0) { seg.startCharCode = i; bFound = true; break; } } if (bFound) { // find the endCode character in this segment CurChar = seg.startCharCode; if (CurChar < map.Length-2) { while (CurChar < map.Length - 1) { if (map[CurChar]+1 == map[CurChar+1] && CurChar != map.Length-2) { CurChar++; } else { seg.endCharCode = CurChar; break; } } } else if (CurChar == map.Length - 1) { seg.endCharCode = CurChar; } else { Debug.Assert(false); } Debug.Assert(seg.startCharCode <= seg.endCharCode); // store the start glyph ID for this segment seg.startGlyphID = map[seg.startCharCode]; // add the segment to the array arrSegments.Add(seg); Debug.Assert(arrSegments.Count < map.Length, "more segments than characters"); CurChar = (uint)(seg.endCharCode + 1); seg = new segment12(); } else { break; } } // allocate a buffer for the subtable uint nSize = (uint)(16 + 12 * arrSegments.Count); MBOBuffer buf = new MBOBuffer(nSize); // set the data buf.SetUshort(12, (uint)Format12.FieldOffsets.format); buf.SetUshort(0, (uint)Format12.FieldOffsets.reserved); buf.SetUint(nSize, (uint)Format12.FieldOffsets.length); buf.SetUint(0, (uint)Format12.FieldOffsets.language); buf.SetUint((uint)arrSegments.Count, (uint)Format12.FieldOffsets.nGroups); for (int i=0; i<arrSegments.Count; i++) { seg = (segment12)arrSegments[i]; buf.SetUint(seg.startCharCode, (uint) (Format12.FieldOffsets.firstGroup + i*12)); buf.SetUint(seg.endCharCode, (uint) (Format12.FieldOffsets.firstGroup + i*12 + 4)); buf.SetUint(seg.startGlyphID, (uint) (Format12.FieldOffsets.firstGroup + i*12 + 8)); } return buf.GetBuffer(); }
protected byte[] GenerateFormat0Subtable( uint [] map, ushort language ) { // allocate the buffer MBOBuffer buf = new MBOBuffer(262); // set the data buf.SetUshort(0, (uint)Format0.FieldOffsets.format); buf.SetUshort(262, (uint)Format0.FieldOffsets.length); buf.SetUshort(language, (uint)Format0.FieldOffsets.language); for (int i=0; i<256; i++) { buf.SetByte((byte)map[i], (uint)Format0.FieldOffsets.glyphIDArray + (uint)i); } // return the buffer return buf.GetBuffer(); }
public override OTTable GenerateTable() { ushort iSizeOfVDMXGroups = 0; // Used to detrmine which vdmx goes with which ratio ushort[] VDMXOffsets = new ushort[m_numRecs]; for (ushort i = 0; i < m_numRecs; i++) { iSizeOfVDMXGroups += (ushort)(4 + (((VDMXGroupCache)m_groups[i]).recs * 6)); } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(6 + (m_numRatios * 4) + (2 * m_numRatios) + iSizeOfVDMXGroups)); // populate the buffer newbuf.SetUshort(m_version, (uint)Table_VDMX.FieldOffsets.version); newbuf.SetUshort(m_numRecs, (uint)Table_VDMX.FieldOffsets.numRecs); newbuf.SetUshort(m_numRatios, (uint)Table_VDMX.FieldOffsets.numRatios); // populate buffer with Ratio Records for (ushort i = 0; i < m_numRatios; i++) { newbuf.SetByte(((RatioCache)m_ratRange[i]).bCharSet, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4))); newbuf.SetByte(((RatioCache)m_ratRange[i]).xRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 1)); newbuf.SetByte(((RatioCache)m_ratRange[i]).yStartRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 2)); newbuf.SetByte(((RatioCache)m_ratRange[i]).yEndRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 3)); } // Set up the strting offset for the VDMX Groups ushort iOffset = (ushort)(Table_VDMX.FieldOffsets.ratRange + (m_numRatios * 4) + (m_numRatios * 2)); // NOTE: we may want to check these VDMX Groups to see if they are orphans and remove them if they are? // populate buffer with VDMX Groups for (ushort i = 0; i < m_numRecs; i++) { // Save the offset for this group VDMXOffsets[i] = iOffset; newbuf.SetUshort(((VDMXGroupCache)m_groups[i]).recs, iOffset); iOffset += 2; newbuf.SetByte(((VDMXGroupCache)m_groups[i]).startsz, iOffset); iOffset += 1; newbuf.SetByte(((VDMXGroupCache)m_groups[i]).endsz, iOffset); iOffset += 1; for (ushort ii = 0; ii < ((VDMXGroupCache)m_groups[i]).recs; ii++) { newbuf.SetUshort(((VDMXGroupCache)m_groups[i]).getVTableRecordCache(ii).yPelHeight, iOffset); iOffset += 2; newbuf.SetShort(((VDMXGroupCache)m_groups[i]).getVTableRecordCache(ii).yMax, iOffset); iOffset += 2; newbuf.SetShort(((VDMXGroupCache)m_groups[i]).getVTableRecordCache(ii).yMin, iOffset); iOffset += 2; } } // populate buffer with Ratio Records for (ushort i = 0; i < m_numRatios; i++) { newbuf.SetByte(((RatioCache)m_ratRange[i]).bCharSet, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4))); newbuf.SetByte(((RatioCache)m_ratRange[i]).xRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 1)); newbuf.SetByte(((RatioCache)m_ratRange[i]).yStartRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 2)); newbuf.SetByte(((RatioCache)m_ratRange[i]).yEndRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 3)); // Write out the offsets for the VDMX Groups to the buffer newbuf.SetUshort(VDMXOffsets[((RatioCache)m_ratRange[i]).VDMXGroupThisRatio], (uint)(Table_VDMX.FieldOffsets.ratRange + (m_numRatios * 4) + (i * 2))); } // put the buffer into a Table_VDMX object and return it Table_VDMX VDMXTable = new Table_VDMX("VDMX", newbuf); return(VDMXTable); }
public override OTTable GenerateTable() { uint iSizeOfTables = 0; ushort nLeft = 0; ushort nRight = 0; short nValue = 0; // Find the sizeof all of the tables for( ushort i = 0; i < m_nTables; i++ ) { iSizeOfTables += (uint)((SubTableFormat0)m_SubTable[i]).CalculatedLength(); } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( (uint)FieldOffsets.FirstSubTableHeader + iSizeOfTables ); newbuf.SetUshort( m_version, (uint)FieldOffsets.version ); newbuf.SetUshort( m_nTables, (uint)FieldOffsets.nTables ); uint iOffset = (uint)FieldOffsets.FirstSubTableHeader; //Fill in the tables for( int i = 0; i < m_nTables; i++ ) { newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).version, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).length, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).coverage, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).nPairs, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).searchRange, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).entrySelector, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( ((SubTableFormat0)m_SubTable[i]).rangeShift, (uint)iOffset ); iOffset += 2; // Cycle through all of the kerning pairs for( int ii = 0; ii < ((SubTableFormat0)m_SubTable[i]).nPairs; ii++ ) { ((SubTableFormat0)m_SubTable[i]).GetKerningPairAndValue( ii, ref nLeft, ref nRight, ref nValue ); newbuf.SetUshort( nLeft, (uint)iOffset ); iOffset += 2; newbuf.SetUshort( nRight, (uint)iOffset ); iOffset += 2; newbuf.SetShort( nValue, (uint)iOffset ); iOffset += 2; } } // put the buffer into a Table_vhmtx object and return it Table_kern kernTable = new Table_kern("kern", newbuf); return kernTable; }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf; if( m_TableVersionNumber.GetUint() == 0x00000000 ) { newbuf = new MBOBuffer(6); newbuf.SetFixed (m_TableVersionNumber, (uint)Table_maxp.FieldOffsets.TableVersionNumber); newbuf.SetUshort (m_NumGlyphs, (uint)Table_maxp.FieldOffsets.NumGlyphs); } else { newbuf = new MBOBuffer(32); newbuf.SetFixed (m_TableVersionNumber, (uint)Table_maxp.FieldOffsets.TableVersionNumber); newbuf.SetUshort (m_NumGlyphs, (uint)Table_maxp.FieldOffsets.NumGlyphs); newbuf.SetUshort (m_maxPoints, (uint)Table_maxp.FieldOffsets.maxPoints); newbuf.SetUshort (m_maxContours, (uint)Table_maxp.FieldOffsets.maxContours); newbuf.SetUshort (m_maxCompositePoints, (uint)Table_maxp.FieldOffsets.maxCompositePoints); newbuf.SetUshort (m_maxCompositeContours, (uint)Table_maxp.FieldOffsets.maxCompositeContours); newbuf.SetUshort (m_maxZones, (uint)Table_maxp.FieldOffsets.maxZones); newbuf.SetUshort (m_maxTwilightPoints, (uint)Table_maxp.FieldOffsets.maxTwilightPoints); newbuf.SetUshort (m_maxStorage, (uint)Table_maxp.FieldOffsets.maxStorage); newbuf.SetUshort (m_maxFunctionDefs, (uint)Table_maxp.FieldOffsets.maxFunctionDefs); newbuf.SetUshort (m_maxInstructionDefs, (uint)Table_maxp.FieldOffsets.maxInstructionDefs); newbuf.SetUshort (m_maxStackElements, (uint)Table_maxp.FieldOffsets.maxStackElements); newbuf.SetUshort (m_maxSizeOfInstructions, (uint)Table_maxp.FieldOffsets.maxSizeOfInstructions); newbuf.SetUshort (m_maxComponentElements, (uint)Table_maxp.FieldOffsets.maxComponentElements); newbuf.SetUshort (m_maxComponentDepth, (uint)Table_maxp.FieldOffsets.maxComponentDepth); } // put the buffer into a Table_maxp object and return it Table_maxp maxpTable = new Table_maxp("maxp", newbuf); return maxpTable; }
public override OTTable GenerateTable() { uint nBufSize = (uint)Table_EBLC.FieldOffsets.FirstbitmapSizeTable; for( ushort i = 0; i < m_numSizes; i++ ) { bitmapSizeTableCache bstc = (bitmapSizeTableCache)m_bitmapSizeTables[i]; nBufSize += bitmapSizeTable.bufSize; nBufSize += bstc.indexSubTablesSize; } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( nBufSize ); // Determine the size of the EBDTTable and create its buffer uint nEBDTBufSize = (uint)Table_EBDT.FieldOffsets.StartOfData; for( ushort i = 0; i < m_numSizes; i++ ) { bitmapSizeTableCache bstc = (bitmapSizeTableCache)m_bitmapSizeTables[i]; for( int ii = 0; ii < bstc.numberOfIndexSubTables; ii++ ) { indexSubTableArrayCache istac = bstc.getIndexSubTableArrayCache( ii ); nEBDTBufSize += istac.indexSubTable.imageDataSize(); } } // create a Motorola Byte Order buffer for the EBDT table MBOBuffer bufEBDT = new MBOBuffer( nEBDTBufSize ); newbuf.SetFixed( m_version, (uint)Table_EBLC.FieldOffsets.version ); newbuf.SetUint( m_numSizes, (uint)Table_EBLC.FieldOffsets.numSizes ); //Set up initial offsets uint idxArrOffset = (uint)Table_EBLC.FieldOffsets.FirstbitmapSizeTable + (bitmapSizeTable.bufSize * m_numSizes); uint imageDataOffset = (uint)Table_EBDT.FieldOffsets.StartOfData; //EBDTTable for( ushort i = 0; i < m_numSizes; i++ ) { bitmapSizeTableCache bstc = (bitmapSizeTableCache)m_bitmapSizeTables[i]; //Set the offset to the bitmapSizeTable uint bstOffset = (uint)(Table_EBLC.FieldOffsets.FirstbitmapSizeTable + (i * bitmapSizeTable.bufSize)); newbuf.SetUint( idxArrOffset, bstOffset ); newbuf.SetUint( bstc.indexSubTablesSize, bstOffset + (uint)bitmapSizeTable.FieldOffsets.indexTablesSize ); newbuf.SetUint( bstc.numberOfIndexSubTables, bstOffset + (uint)bitmapSizeTable.FieldOffsets.numberOfIndexSubTables ); newbuf.SetUint( bstc.colorRef, bstOffset + (uint)bitmapSizeTable.FieldOffsets.colorRef ); // hori newbuf.SetSbyte( bstc.hori.ascender, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.ascender ); newbuf.SetSbyte( bstc.hori.descender, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.descender ); newbuf.SetByte( bstc.hori.widthMax, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.widthMax ); newbuf.SetSbyte( bstc.hori.caretSlopeNumerator, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretSlopeNumerator ); newbuf.SetSbyte( bstc.hori.caretSlopeDenominator, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretSlopeDenominator ); newbuf.SetSbyte( bstc.hori.caretOffset, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretOffset ); newbuf.SetSbyte( bstc.hori.minOriginSB, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minOriginSB ); newbuf.SetSbyte( bstc.hori.minAdvanceSB, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minAdvanceSB ); newbuf.SetSbyte( bstc.hori.maxBeforeBL, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.maxBeforeBL ); newbuf.SetSbyte( bstc.hori.minAfterBL, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minAfterBL ); newbuf.SetSbyte( bstc.hori.pad1, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.pad1 ); newbuf.SetSbyte( bstc.hori.pad2, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.pad2 ); //vert newbuf.SetSbyte( bstc.vert.ascender, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.ascender ); newbuf.SetSbyte( bstc.vert.descender, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.descender ); newbuf.SetByte( bstc.vert.widthMax, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.widthMax ); newbuf.SetSbyte( bstc.vert.caretSlopeNumerator, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretSlopeNumerator ); newbuf.SetSbyte( bstc.vert.caretSlopeDenominator, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretSlopeDenominator ); newbuf.SetSbyte( bstc.vert.caretOffset, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.caretOffset ); newbuf.SetSbyte( bstc.vert.minOriginSB, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minOriginSB ); newbuf.SetSbyte( bstc.vert.minAdvanceSB, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minAdvanceSB ); newbuf.SetSbyte( bstc.vert.maxBeforeBL, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.maxBeforeBL ); newbuf.SetSbyte( bstc.vert.minAfterBL, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.minAfterBL ); newbuf.SetSbyte( bstc.vert.pad1, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.pad1 ); newbuf.SetSbyte( bstc.vert.pad2, bstOffset + (uint)bitmapSizeTable.FieldOffsets.hori + (uint)sbitLineMetrics.FieldOffsets.pad2 ); newbuf.SetUshort( bstc.startGlyphIndex, bstOffset + (uint)bitmapSizeTable.FieldOffsets.startGlyphIndex ); newbuf.SetUshort( bstc.endGlyphIndex, bstOffset + (uint)bitmapSizeTable.FieldOffsets.endGlyphIndex ); newbuf.SetByte( bstc.ppemX, bstOffset + (uint)bitmapSizeTable.FieldOffsets.ppemX ); newbuf.SetByte( bstc.ppemY, bstOffset + (uint)bitmapSizeTable.FieldOffsets.ppemY ); newbuf.SetByte( bstc.bitDepth, bstOffset + (uint)bitmapSizeTable.FieldOffsets.bitDepth ); newbuf.SetSbyte( bstc.flags, bstOffset + (uint)bitmapSizeTable.FieldOffsets.flags ); uint idxSubTableOffset = idxArrOffset + (bstc.numberOfIndexSubTables * indexSubTableArray.bufSize); // Write this bitmapSizeTable indexSubTableArray and indexSubTable for( int ii = 0; ii < bstc.numberOfIndexSubTables; ii++ ) { // Write out the indexSubTableArray indexSubTableArrayCache istac = bstc.getIndexSubTableArrayCache( ii ); newbuf.SetUshort( istac.firstGlyphIndex, idxArrOffset + (uint)indexSubTableArray.FieldOffsets.firstGlyphIndex + (uint)(ii * indexSubTableArray.bufSize)); newbuf.SetUshort( istac.lastGlyphIndex, idxArrOffset + (uint)indexSubTableArray.FieldOffsets.lastGlyphIndex + (uint)(ii * indexSubTableArray.bufSize)); newbuf.SetUint( (idxSubTableOffset - idxArrOffset), idxArrOffset + (uint)indexSubTableArray.FieldOffsets.additionalOffsetToIndexSubtable + (uint)(ii * indexSubTableArray.bufSize)); // Write out the indexSubTable, The header is the same for all indexFormats newbuf.SetUshort( istac.indexSubTable.indexFormat, idxSubTableOffset + (uint)indexSubHeader.FieldOffsets.indexFormat ); newbuf.SetUshort( istac.indexSubTable.imageFormat, idxSubTableOffset + (uint)indexSubHeader.FieldOffsets.imageFormat ); newbuf.SetUint( imageDataOffset, idxSubTableOffset + (uint)indexSubHeader.FieldOffsets.imageDataOffset ); uint imageOffset = 0; switch( istac.indexSubTable.indexFormat ) { case 1: { indexSubTableCache1 istc = (indexSubTableCache1)istac.indexSubTable; for( ushort iii = istac.firstGlyphIndex; iii <= istac.lastGlyphIndex; iii++ ) { ushort nIndex = (ushort)(iii - istac.firstGlyphIndex); // offset + header length + (uint)offsetArray[iii] newbuf.SetUint( imageOffset, idxSubTableOffset + indexSubTable.headerLength + (uint)(nIndex * 4)); // Write image data for this indexSubTable to EBDT buffer imageCache ic = istc.getImageCache( iii, istac.firstGlyphIndex ); writeEBDTBuffer( bufEBDT, (imageDataOffset + imageOffset), ic, istac.indexSubTable.imageFormat ); imageOffset += ic.imageDataSize(); } // Add the last one so size can be determined newbuf.SetUint( imageOffset, idxSubTableOffset + indexSubTable.headerLength + ((uint)(istac.lastGlyphIndex - istac.firstGlyphIndex + 1) * 4)); break; } case 2: { indexSubTableCache2 istc = (indexSubTableCache2)istac.indexSubTable; // offset + header length newbuf.SetUint( istc.imageSize, idxSubTableOffset + indexSubTable.headerLength ); //BigMetrics, + 12 = indexSubTable.headerLength + (uint)imageSize newbuf.SetByte( istc.bigMetrics.height, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.height ); newbuf.SetByte( istc.bigMetrics.width, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.width ); newbuf.SetSbyte( istc.bigMetrics.horiBearingX, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingX ); newbuf.SetSbyte( istc.bigMetrics.horiBearingY, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingY ); newbuf.SetByte( istc.bigMetrics.horiAdvance, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiAdvance ); newbuf.SetSbyte( istc.bigMetrics.vertBearingX, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingX ); newbuf.SetSbyte( istc.bigMetrics.vertBearingY, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingY ); newbuf.SetByte( istc.bigMetrics.vertAdvance, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertAdvance ); for( ushort iii = istac.firstGlyphIndex; iii <= istac.lastGlyphIndex; iii++ ) { // Write image data for this indexSubTable to EBDT buffer imageCache ic = istc.getImageCache( iii, istac.firstGlyphIndex ); writeEBDTBuffer( bufEBDT, (imageDataOffset + imageOffset), ic, istac.indexSubTable.imageFormat ); imageOffset += ic.imageDataSize(); } break; } case 3: { indexSubTableCache3 istc = (indexSubTableCache3)istac.indexSubTable; for( ushort iii = istac.firstGlyphIndex; iii <= istac.lastGlyphIndex; iii++ ) { ushort nIndex = (ushort)(iii - istac.firstGlyphIndex); // offset + header length + ushort offsetArray[iii] newbuf.SetUshort( (ushort)imageOffset, idxSubTableOffset + indexSubTable.headerLength + (uint)(nIndex * 2 )); // Write image data for this indexSubTable to EBDT buffer imageCache ic = istc.getImageCache( iii, istac.firstGlyphIndex ); writeEBDTBuffer( bufEBDT, (imageDataOffset + imageOffset), ic, istac.indexSubTable.imageFormat ); imageOffset += ic.imageDataSize(); } // Add the last one so size can be determined newbuf.SetUshort( (ushort)imageOffset, idxSubTableOffset + indexSubTable.headerLength + ((uint)(istac.lastGlyphIndex - istac.firstGlyphIndex + 1) * 2 )); break; } case 4: { indexSubTableCache4 istc = (indexSubTableCache4)istac.indexSubTable; // offset + header length newbuf.SetUint( istc.numGlyphs, idxSubTableOffset + indexSubTable.headerLength ); for( ushort iii = 0; iii < istc.numGlyphs; iii++ ) { // offset + header length + (uint)numGlyphs + (4)codeOffsetPair[iii] newbuf.SetUshort( istc.getGlyphCode(iii), idxSubTableOffset + 12 + (uint)(iii * 4)); newbuf.SetUshort( (ushort)imageOffset, idxSubTableOffset + 12 + (uint)(iii * 4) + 2 ); // Write image data for this indexSubTable to EBDT buffer imageCache ic = istc.getImageCache( istc.getGlyphCode(iii)); writeEBDTBuffer( bufEBDT, (imageDataOffset + imageOffset), ic, istac.indexSubTable.imageFormat ); imageOffset += ic.imageDataSize(); } // Add the last codeOffsetPair so size can be determined newbuf.SetUshort( 0, idxSubTableOffset + 12 + (uint)(istc.numGlyphs * 4 )); newbuf.SetUshort( (ushort)imageOffset, idxSubTableOffset + 12 + (uint)(istc.numGlyphs * 4 ) + 2 ); break; } case 5: { indexSubTableCache5 istc = (indexSubTableCache5)istac.indexSubTable; // offset + header length newbuf.SetUint( istc.imageSize, idxSubTableOffset + indexSubTable.headerLength ); //BigMetrics, + 12 = indexSubTable.headerLength + (uint)imageSize newbuf.SetByte( istc.bigMetrics.height, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.height ); newbuf.SetByte( istc.bigMetrics.width, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.width ); newbuf.SetSbyte( istc.bigMetrics.horiBearingX, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingX ); newbuf.SetSbyte( istc.bigMetrics.horiBearingY, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiBearingY ); newbuf.SetByte( istc.bigMetrics.horiAdvance, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.horiAdvance ); newbuf.SetSbyte( istc.bigMetrics.vertBearingX, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingX ); newbuf.SetSbyte( istc.bigMetrics.vertBearingY, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertBearingY ); newbuf.SetByte( istc.bigMetrics.vertAdvance, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.FieldOffsets.vertAdvance ); newbuf.SetUint( istc.numGlyphs, idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.bufSize ); for( ushort iii = 0; iii < istc.numGlyphs; iii++ ) { // offset + header length + (uint)imageSize + bigGlyphMetrics.bufSize + big(uint)numGlyphs + (ushort)glyphCodeArray[iii} newbuf.SetUshort( istc.getGlyphCode(iii), idxSubTableOffset + 12 + (uint)Table_EBDT.bigGlyphMetrics.bufSize + 4 + (uint)(iii * 2 )); // Write image data for this indexSubTable to EBDT buffer imageCache ic = istc.getImageCache( istc.getGlyphCode(iii)); writeEBDTBuffer( bufEBDT, (imageDataOffset + imageOffset), ic, istac.indexSubTable.imageFormat ); imageOffset += ic.imageDataSize(); } break; } } // update imageDataOffset for the next SubTable imageDataOffset += imageOffset; // This will take care of any byte boundaries pads required by some indexSubTables idxSubTableOffset += istac.indexSubTable.indexSubTableSize(); } idxArrOffset += bstc.indexSubTablesSize; } // Put the EBDT buf to that table Table_EBDT.EBDT_cache EBDTCache = (Table_EBDT.EBDT_cache)m_tableEBDT.GetCache(); EBDTCache.setCache( bufEBDT ); // put the buffer into a Table_EBLC object and return it Table_EBLC EBLCTable = new Table_EBLC( "EBLC", newbuf ); return EBLCTable; }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(36); // populate the buffer newbuf.SetFixed (m_version, (uint)Table_vhea.FieldOffsets.version); newbuf.SetShort (m_vertTypoAscender, (uint)Table_vhea.FieldOffsets.vertTypoAscender); newbuf.SetShort (m_vertTypoDescender, (uint)Table_vhea.FieldOffsets.vertTypoDescender); newbuf.SetShort (m_vertTypoLineGap, (uint)Table_vhea.FieldOffsets.vertTypoLineGap); newbuf.SetShort (m_advanceHeightMax, (uint)Table_vhea.FieldOffsets.advanceHeightMax); newbuf.SetShort (m_minTopSideBearing, (uint)Table_vhea.FieldOffsets.minTopSideBearing); newbuf.SetShort (m_minBottomSideBearing, (uint)Table_vhea.FieldOffsets.minBottomSideBearing); newbuf.SetShort (m_yMaxExtent, (uint)Table_vhea.FieldOffsets.yMaxExtent); newbuf.SetShort (m_caretSlopeRise, (uint)Table_vhea.FieldOffsets.caretSlopeRise); newbuf.SetShort (m_caretSlopeRun, (uint)Table_vhea.FieldOffsets.caretSlopeRun); newbuf.SetShort (m_caretOffset, (uint)Table_vhea.FieldOffsets.caretOffset); newbuf.SetShort (m_reserved1, (uint)Table_vhea.FieldOffsets.reserved1); newbuf.SetShort (m_reserved2, (uint)Table_vhea.FieldOffsets.reserved2); newbuf.SetShort (m_reserved3, (uint)Table_vhea.FieldOffsets.reserved3); newbuf.SetShort (m_reserved4, (uint)Table_vhea.FieldOffsets.reserved4); newbuf.SetShort (m_metricDataFormat, (uint)Table_vhea.FieldOffsets.metricDataFormat); newbuf.SetUshort (m_numOfLongVerMetrics, (uint)Table_vhea.FieldOffsets.numOfLongVerMetrics); // put the buffer into a Table_vhea object and return it Table_vhea vheaTable = new Table_vhea("vhea", newbuf); return vheaTable; }
public override OTTable GenerateTable() { ArrayList bytesNameString = new ArrayList(); ushort nLengthOfStrings = 0; ushort nStartOfStringStorage = (ushort)(6 + (m_nameRecords.Count * 12)); for( ushort i = 0; i < m_nameRecords.Count; i++ ) { NameRecordCache nrc = (NameRecordCache)m_nameRecords[i]; byte[] byteString = EncodeString(nrc.sNameString, nrc.platformID, nrc.encodingID); bytesNameString.Add( byteString ); nLengthOfStrings += (ushort)byteString.Length; } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( (uint)(Table_name.FieldOffsets.NameRecords + (m_nameRecords.Count * 12) + nLengthOfStrings)); // populate the buffer newbuf.SetUshort( m_format, (uint)Table_name.FieldOffsets.FormatSelector ); newbuf.SetUshort( (ushort)m_nameRecords.Count, (uint)Table_name.FieldOffsets.NumberNameRecords ); newbuf.SetUshort( nStartOfStringStorage, (uint)Table_name.FieldOffsets.OffsetToStrings ); ushort nOffset = 0; // Write the NameRecords and Strings for( ushort i = 0; i < m_nameRecords.Count; i++ ) { byte[] bString = (byte[])bytesNameString[i]; newbuf.SetUshort( ((NameRecordCache)m_nameRecords[i]).platformID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12))); newbuf.SetUshort( ((NameRecordCache)m_nameRecords[i]).encodingID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 2)); newbuf.SetUshort( ((NameRecordCache)m_nameRecords[i]).languageID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 4)); newbuf.SetUshort( ((NameRecordCache)m_nameRecords[i]).nameID, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 6)); newbuf.SetUshort( (ushort)bString.Length, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 8)); newbuf.SetUshort( nOffset, (uint)(Table_name.FieldOffsets.NameRecords + (i * 12) + 10)); //Write the string to the buffer for( int ii = 0; ii < bString.Length; ii++ ) { newbuf.SetByte( bString[ii], (uint)(nStartOfStringStorage + nOffset + ii)); } nOffset += (ushort)bString.Length; } // put the buffer into a Table_name object and return it Table_name nameTable = new Table_name("name", newbuf); return nameTable; }
// generate a new table from the cached data public override OTTable GenerateTable() { // generate the subtables ArrayList arrSubtableBuffers = new ArrayList(); for (int i=0; i<m_arrSubtables.Count; i++) { byte [] buf = null; CachedSubtable st = (CachedSubtable)m_arrSubtables[i]; if (st.m_platID == 3 && st.m_encID == 10) { buf = GenerateFormat12Subtable(st.m_CharToGlyphMap); } else if (st.m_platID == 1 && st.m_encID == 0) { buf = GenerateFormat0Subtable(st.m_CharToGlyphMap, 0); } else { buf = GenerateFormat4Subtable(st.m_CharToGlyphMap); } arrSubtableBuffers.Add(buf); } // calculate the number of bytes required for the cmap table uint nBytes = 4; // version and number of subtables // encoding table entries nBytes += 8 * (uint)m_arrSubtables.Count; for (int i=0; i<m_arrSubtables.Count; i++) { byte[] buf = (byte[])arrSubtableBuffers[i]; nBytes += (uint)buf.Length; } // create a buffer for the new cmap table MBOBuffer newbuf = new MBOBuffer(nBytes); // populate the buffer // version and number of encoding tables newbuf.SetUshort(0, (uint) Table_cmap.FieldOffsets.TableVersionNumber); newbuf.SetUshort((ushort)m_arrSubtables.Count, (uint) Table_cmap.FieldOffsets.NumberOfEncodingTables ); // encoding table entries uint SubtableOffset = (uint)(4 + 8*m_arrSubtables.Count); for (int i=0; i < m_arrSubtables.Count; i++) { CachedSubtable st = (CachedSubtable)m_arrSubtables[i]; uint eteOffset = (uint)Table_cmap.FieldOffsets.EncodingTableEntries + (uint)i*8; newbuf.SetUshort(st.m_platID, eteOffset); newbuf.SetUshort(st.m_encID, eteOffset+2); newbuf.SetUint(SubtableOffset, eteOffset+4); byte[] buf = (byte[])arrSubtableBuffers[i]; SubtableOffset += (uint)buf.Length; } // subtables byte[] TableBuf = newbuf.GetBuffer(); SubtableOffset = (uint)(4 + 8*m_arrSubtables.Count); for (int i=0; i<m_arrSubtables.Count; i++) { byte[] SubtableBuf = (byte[])arrSubtableBuffers[i]; System.Buffer.BlockCopy(SubtableBuf, 0, TableBuf, (int)SubtableOffset, SubtableBuf.Length); SubtableOffset += (uint)SubtableBuf.Length; } // put the buffer into a Table_cmap object and return it Table_cmap cmapTable = new Table_cmap("cmap", newbuf); return cmapTable; }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(Table_LTSH.FieldOffsets.yPels + m_numGlyphs)); newbuf.SetUshort( m_version, (uint)Table_LTSH.FieldOffsets.version); newbuf.SetUshort( m_numGlyphs, (uint)Table_LTSH.FieldOffsets.numGlyphs); // Fill the buffer with the yPels for( int i = 0; i < m_numGlyphs; i++ ) { newbuf.SetByte( m_yPels[i], (uint)(Table_LTSH.FieldOffsets.yPels + i)); } // put the buffer into a Table_maxp object and return it Table_LTSH LTSHTable = new Table_LTSH("LTSH", newbuf); return LTSHTable; }
protected byte[] GenerateFormat4Subtable(uint [] map) { bool bFound = false; uint CurChar = 0; ArrayList arrSegments = new ArrayList(); segment4 seg = new segment4(); while (CurChar < map.Length) { // find the startCode char in this segment bFound = false; for (uint i=CurChar; i<map.Length; i++) { if (map[i] != 0) { seg.startCode = (ushort)i; bFound = true; break; } } if (bFound) { // count number of chars available for delta // representation short delta = (short) (map[seg.startCode] - seg.startCode); uint nDelta = 1; for (int i=seg.startCode+1; i<map.Length; i++) { if ((ushort)(i+delta) == (ushort)(map[i])) { nDelta++; } else { break; } } // count number of chars available for rangeoffset // to glyph id representation uint nRangeGlyph=1; if (nDelta == 1) { for (int i=seg.startCode+1; i<map.Length; i++) { if (map[i] == 0) { // don't keep the zero if it's followed // by another zero if (i+1 < map.Length) { if (map[i+1] == 0) { break; } } // don't keep the zero if it's followed by // a delta segment if (i+3 < map.Length) { if ((ushort)(map[i+1]+1) == (ushort)(map[i+2]) && (ushort)(map[i+2]+1) == (ushort)(map[i+3])) { break; } } else { break; } } else if (i+2 < map.Length) { // stop if this is the start of a two // glyph delta segment if ((ushort)(map[i ]+1) == (ushort)(map[i+1]) && (ushort)(map[i+1]+1) == (ushort)(map[i+2])) { break; } } else if (i+1 < map.Length) { // stop if we're at the end of the map if ((ushort)(map[i]+1) == (ushort)(map[i+1])) { break; } } nRangeGlyph++; } } // choose delta or rangeOffset representation if (nDelta >= nRangeGlyph) { // set the endCode character for this segment CurChar = seg.startCode; if (CurChar < 65535) { seg.endCode = (ushort) (seg.startCode + nDelta - 1); CurChar = seg.endCode; } else if (CurChar == 65535) { seg.endCode = 65535; } else { Debug.Assert(false); } Debug.Assert(seg.startCode <= seg.endCode); // calculate the id delta seg.idDelta = (short)(map[seg.startCode] - seg.startCode); // add the segment to the array arrSegments.Add(seg); Debug.Assert(arrSegments.Count < 65536); CurChar = (uint)(seg.endCode + 1); seg = new segment4(); } else { // set the endCode character for this segment CurChar = seg.startCode; if (CurChar < 65535) { seg.endCode = (ushort)(seg.startCode + nRangeGlyph - 1); CurChar = seg.endCode; Debug.Assert(seg.startCode != seg.endCode); } else if (CurChar == 65535) { seg.endCode = 65535; } else { Debug.Assert(false); } // store each character's glyph value in the // glyphID array int nCount = seg.endCode-seg.startCode+1; seg.glyphIdArray = new ushort[nCount]; for (ushort i=0; i<nCount; i++) { seg.glyphIdArray[i] = (ushort)map[seg.startCode+i]; } // add the segment to the array arrSegments.Add(seg); Debug.Assert(arrSegments.Count < 65536); CurChar = (uint)(seg.endCode + 1); seg = new segment4(); } } else { break; } } // add a final segment if needed bool bNeedFinal = true; if (arrSegments.Count != 0) { segment4 lastseg = (segment4) arrSegments[arrSegments.Count-1]; if (lastseg.endCode == 0xffff) { bNeedFinal = false; } } if (bNeedFinal) { segment4 segFinal = new segment4(); segFinal.startCode = 0xffff; segFinal.endCode = 0xffff; segFinal.idDelta = 1; arrSegments.Add(segFinal); } // allocate a buffer for the subtable ushort nSize = (ushort)(16 + 8 * arrSegments.Count); for (int i=0; i<arrSegments.Count; i++) { segment4 s = (segment4)arrSegments[(int)i]; if (s.glyphIdArray != null) { nSize += (ushort)(s.glyphIdArray.Length*2); } } MBOBuffer buf = new MBOBuffer(nSize); // set the data ushort segCountX2 = (ushort)(arrSegments.Count*2); ushort searchRange = (ushort) (2 * util.MaxPower2LE((ushort)(arrSegments.Count))); ushort entrySelector = util.Log2((ushort)(searchRange/2)); ushort rangeShift = (ushort)(segCountX2 - searchRange); buf.SetUshort(4, (uint)Format4.FieldOffsets.format); buf.SetUshort(nSize, (uint)Format4.FieldOffsets.length); buf.SetUshort(0, (uint)Format4.FieldOffsets.language); buf.SetUshort(segCountX2, (uint)Format4.FieldOffsets.segCountX2); buf.SetUshort(searchRange, (uint)Format4.FieldOffsets.searchRange); buf.SetUshort(entrySelector, (uint)Format4.FieldOffsets.entrySelector); buf.SetUshort(rangeShift, (uint)Format4.FieldOffsets.rangeShift); uint endOffset = (uint)Format4.FieldOffsets.endCode; uint startOffset = (uint)Format4.FieldOffsets.endCode + 2*(uint)arrSegments.Count + 2; uint idDeltaOffset = startOffset + 2*(uint)arrSegments.Count; uint idRangeOffset = idDeltaOffset + 2*(uint)arrSegments.Count; int nGlyphIdCount = 0; for (uint i=0; i<arrSegments.Count; i++) { segment4 s = (segment4)arrSegments[(int)i]; if (s.glyphIdArray != null) { s.idRangeOffset = (ushort) ((arrSegments.Count - i + nGlyphIdCount)*2); nGlyphIdCount += s.glyphIdArray.Length; } buf.SetUshort(s.endCode, endOffset + i*2); buf.SetUshort(s.startCode, startOffset + i*2); buf.SetShort(s.idDelta, idDeltaOffset + i*2); buf.SetUshort(s.idRangeOffset, idRangeOffset + i*2); } uint glyphIdPos = idRangeOffset + 2*(uint)arrSegments.Count; for (uint i=0; i<arrSegments.Count; i++) { segment4 s = (segment4)arrSegments[(int)i]; if (s.glyphIdArray != null) { for (uint j=0; j<s.glyphIdArray.Length; j++) { buf.SetUshort(s.glyphIdArray[j], glyphIdPos); glyphIdPos += 2; } } } return buf.GetBuffer(); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(m_nNumberOfHMetrics * 4) + (uint)((m_nGlyphsInTheFont - m_nNumberOfHMetrics) * 2)); for( ushort i = 0; i < m_nGlyphsInTheFont; i++ ) { if( i < m_nNumberOfHMetrics ) { newbuf.SetUshort( ((longHorMetric)m_longHorMetric[i]).advanceWidth, (uint)(i * 4 )); newbuf.SetShort ( ((longHorMetric)m_longHorMetric[i]).lsb, (uint)((i * 4) + 2)); } else { newbuf.SetShort ( ((longHorMetric)m_longHorMetric[i]).lsb, (uint)(((m_nNumberOfHMetrics - 1)* 4) + (i * 2))); } } // put the buffer into a Table_vhmtx object and return it Table_hmtx hmtxTable = new Table_hmtx("hmtx", newbuf); return hmtxTable; }
public override OTTable GenerateTable() { MBOBuffer newbuf; switch( m_version ) { case 0x0000: newbuf = new MBOBuffer( 78 ); break; case 0x0001: newbuf = new MBOBuffer( 86 ); break; case 0x0002: newbuf = new MBOBuffer( 96 ); break; case 0x0003: goto case 0x0002; default: goto case 0x0002; // version 3 is default } newbuf.SetUshort( m_version, (uint)Table_OS2.FieldOffsets.version ); newbuf.SetShort( m_xAvgCharWidth, (uint)Table_OS2.FieldOffsets.xAvgCharWidth ); newbuf.SetUshort( m_usWeightClass, (uint)Table_OS2.FieldOffsets.usWeightClass ); newbuf.SetUshort( m_usWidthClass, (uint)Table_OS2.FieldOffsets.usWidthClass ); newbuf.SetUshort( m_fsType, (uint)Table_OS2.FieldOffsets.fsType ); newbuf.SetShort( m_ySubscriptXSize, (uint)Table_OS2.FieldOffsets.ySubscriptXSize ); newbuf.SetShort( m_ySubscriptYSize, (uint)Table_OS2.FieldOffsets.ySubscriptYSize ); newbuf.SetShort( m_ySubscriptXOffset, (uint)Table_OS2.FieldOffsets.ySubscriptXOffset ); newbuf.SetShort( m_ySubscriptYOffset, (uint)Table_OS2.FieldOffsets.ySubscriptYOffset ); newbuf.SetShort( m_ySuperscriptXSize, (uint)Table_OS2.FieldOffsets.ySuperscriptXSize ); newbuf.SetShort( m_ySuperscriptYSize, (uint)Table_OS2.FieldOffsets.ySuperscriptYSize ); newbuf.SetShort( m_ySuperscriptXOffset, (uint)Table_OS2.FieldOffsets.ySuperscriptXOffset ); newbuf.SetShort( m_ySuperscriptYOffset, (uint)Table_OS2.FieldOffsets.ySuperscriptYOffset ); newbuf.SetShort( m_yStrikeoutSize, (uint)Table_OS2.FieldOffsets.yStrikeoutSize ); newbuf.SetShort( m_yStrikeoutPosition, (uint)Table_OS2.FieldOffsets.yStrikeoutPosition ); newbuf.SetShort( m_sFamilyClass, (uint)Table_OS2.FieldOffsets.sFamilyClass ); newbuf.SetByte( m_panose_byte1, (uint)Table_OS2.FieldOffsets.panose_byte1 ); newbuf.SetByte( m_panose_byte2, (uint)Table_OS2.FieldOffsets.panose_byte2 ); newbuf.SetByte( m_panose_byte3, (uint)Table_OS2.FieldOffsets.panose_byte3 ); newbuf.SetByte( m_panose_byte4, (uint)Table_OS2.FieldOffsets.panose_byte4 ); newbuf.SetByte( m_panose_byte5, (uint)Table_OS2.FieldOffsets.panose_byte5 ); newbuf.SetByte( m_panose_byte6, (uint)Table_OS2.FieldOffsets.panose_byte6 ); newbuf.SetByte( m_panose_byte7, (uint)Table_OS2.FieldOffsets.panose_byte7 ); newbuf.SetByte( m_panose_byte8, (uint)Table_OS2.FieldOffsets.panose_byte8 ); newbuf.SetByte( m_panose_byte9, (uint)Table_OS2.FieldOffsets.panose_byte9 ); newbuf.SetByte( m_panose_byte10, (uint)Table_OS2.FieldOffsets.panose_byte10 ); newbuf.SetUint( m_ulUnicodeRange1, (uint)Table_OS2.FieldOffsets.ulUnicodeRange1 ); newbuf.SetUint( m_ulUnicodeRange2, (uint)Table_OS2.FieldOffsets.ulUnicodeRange2 ); newbuf.SetUint( m_ulUnicodeRange3, (uint)Table_OS2.FieldOffsets.ulUnicodeRange3 ); newbuf.SetUint( m_ulUnicodeRange4, (uint)Table_OS2.FieldOffsets.ulUnicodeRange4 ); for( int i = 0; i < 4; i++ ) { newbuf.SetByte( m_achVendID[i], (uint)(Table_OS2.FieldOffsets.achVendID + i)); } newbuf.SetUshort( m_fsSelection, (uint)Table_OS2.FieldOffsets.fsSelection ); newbuf.SetUshort( m_usFirstCharIndex, (uint)Table_OS2.FieldOffsets.usFirstCharIndex ); newbuf.SetUshort( m_usLastCharIndex, (uint)Table_OS2.FieldOffsets.usLastCharIndex ); newbuf.SetShort( m_sTypoAscender, (uint)Table_OS2.FieldOffsets.sTypoAscender ); newbuf.SetShort( m_sTypoDescender, (uint)Table_OS2.FieldOffsets.sTypoDescender ); newbuf.SetShort( m_sTypoLineGap, (uint)Table_OS2.FieldOffsets.sTypoLineGap ); newbuf.SetUshort( m_usWinAscent, (uint)Table_OS2.FieldOffsets.usWinAscent ); newbuf.SetUshort( m_usWinDescent, (uint)Table_OS2.FieldOffsets.usWinDescent ); // version 1.0 if( version > 0x000 ) { newbuf.SetUint( m_ulCodePageRange1, (uint)Table_OS2.FieldOffsets.ulCodePageRange1 ); newbuf.SetUint( m_ulCodePageRange2, (uint)Table_OS2.FieldOffsets.ulCodePageRange2 ); // vewrsion 2 & 3 if( version > 0x001 ) { newbuf.SetShort( m_sxHeight, (uint)Table_OS2.FieldOffsets.sxHeight ); newbuf.SetShort( m_sCapHeight, (uint)Table_OS2.FieldOffsets.sCapHeight ); newbuf.SetUshort( m_usDefaultChar, (uint)Table_OS2.FieldOffsets.usDefaultChar ); newbuf.SetUshort( m_usBreakChar, (uint)Table_OS2.FieldOffsets.usBreakChar ); newbuf.SetUshort( m_usMaxContext, (uint)Table_OS2.FieldOffsets.usMaxContext ); } } // put the buffer into a Table_maxp object and return it Table_OS2 OS2Table = new Table_OS2("OS/2", newbuf); return OS2Table; }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(54); // populate the buffer newbuf.SetFixed (m_TableVersion, (uint)Table_head.FieldOffsets.TableVersionNumber); newbuf.SetFixed (m_fontRevision, (uint)Table_head.FieldOffsets.fontRevision); newbuf.SetUint (m_checkSumAdjustment, (uint)Table_head.FieldOffsets.checkSumAdjustment); newbuf.SetUint (m_magicNumber, (uint)Table_head.FieldOffsets.magicNumber); newbuf.SetUshort(m_flags, (uint)Table_head.FieldOffsets.flags); newbuf.SetUshort(m_unitsPerEm, (uint)Table_head.FieldOffsets.unitsPerEm); newbuf.SetLong (m_created, (uint)Table_head.FieldOffsets.created); newbuf.SetLong (m_modified, (uint)Table_head.FieldOffsets.modified); newbuf.SetShort (m_xMin, (uint)Table_head.FieldOffsets.xMin); newbuf.SetShort (m_yMin, (uint)Table_head.FieldOffsets.yMin); newbuf.SetShort (m_xMax, (uint)Table_head.FieldOffsets.xMax); newbuf.SetShort (m_yMax, (uint)Table_head.FieldOffsets.yMax); newbuf.SetUshort(m_macStyle, (uint)Table_head.FieldOffsets.macStyle); newbuf.SetUshort(m_lowestRecPPEM, (uint)Table_head.FieldOffsets.lowestRecPPEM); newbuf.SetShort (m_fontDirectionHint, (uint)Table_head.FieldOffsets.fontDirectionHint); newbuf.SetShort (m_indexToLocFormat, (uint)Table_head.FieldOffsets.indexToLocFormat); newbuf.SetShort (m_glyphDataFormat, (uint)Table_head.FieldOffsets.glyphDataFormat); // put the buffer into a Table_head object and return it Table_head headTable = new Table_head("head", newbuf); return headTable; }
public override OTTable GenerateTable() { uint iSizeOfTables = 0; ushort nLeft = 0; ushort nRight = 0; short nValue = 0; // Find the sizeof all of the tables for (ushort i = 0; i < m_nTables; i++) { iSizeOfTables += (uint)((SubTableFormat0)m_SubTable[i]).CalculatedLength(); } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)FieldOffsets.FirstSubTableHeader + iSizeOfTables); newbuf.SetUshort(m_version, (uint)FieldOffsets.version); newbuf.SetUshort(m_nTables, (uint)FieldOffsets.nTables); uint iOffset = (uint)FieldOffsets.FirstSubTableHeader; //Fill in the tables for (int i = 0; i < m_nTables; i++) { newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).version, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).length, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).coverage, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).nPairs, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).searchRange, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).entrySelector, (uint)iOffset); iOffset += 2; newbuf.SetUshort(((SubTableFormat0)m_SubTable[i]).rangeShift, (uint)iOffset); iOffset += 2; // Cycle through all of the kerning pairs for (int ii = 0; ii < ((SubTableFormat0)m_SubTable[i]).nPairs; ii++) { ((SubTableFormat0)m_SubTable[i]).GetKerningPairAndValue(ii, ref nLeft, ref nRight, ref nValue); newbuf.SetUshort(nLeft, (uint)iOffset); iOffset += 2; newbuf.SetUshort(nRight, (uint)iOffset); iOffset += 2; newbuf.SetShort(nValue, (uint)iOffset); iOffset += 2; } } // put the buffer into a Table_vhmtx object and return it Table_kern kernTable = new Table_kern("kern", newbuf); return(kernTable); }
// generate a new table from the cached data public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer((uint)(m_nLongVerMetrics * 4) + (uint)((m_nGlyphsInTheFont - m_nLongVerMetrics) * 2)); for( ushort i = 0; i < m_nGlyphsInTheFont; i++ ) { if( i < m_nLongVerMetrics ) { newbuf.SetUshort( ((vMetric)m_vMetric[i]).advanceHeight, (uint)(i * 4 )); newbuf.SetShort ( ((vMetric)m_vMetric[i]).topSideBearing, (uint)((i * 4) + 2)); } else { newbuf.SetShort ( ((vMetric)m_vMetric[i]).topSideBearing, (uint)(((m_nLongVerMetrics - 1)* 4) + (i * 2))); } } // put the buffer into a Table_vhmtx object and return it Table_vmtx vmtxTable = new Table_vmtx("vmtx", newbuf); return vmtxTable; }
public override OTTable GenerateTable() { ushort iSizeOfVDMXGroups = 0; // Used to detrmine which vdmx goes with which ratio ushort[] VDMXOffsets = new ushort[m_numRecs]; for( ushort i = 0; i < m_numRecs; i++ ) { iSizeOfVDMXGroups += (ushort)(4 + (((VDMXGroupCache)m_groups[i]).recs * 6)); } // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer( (uint)(6 + (m_numRatios * 4) + (2* m_numRatios) + iSizeOfVDMXGroups)); // populate the buffer newbuf.SetUshort( m_version, (uint)Table_VDMX.FieldOffsets.version ); newbuf.SetUshort( m_numRecs, (uint)Table_VDMX.FieldOffsets.numRecs ); newbuf.SetUshort( m_numRatios, (uint)Table_VDMX.FieldOffsets.numRatios ); // populate buffer with Ratio Records for( ushort i = 0; i < m_numRatios; i++ ) { newbuf.SetByte( ((RatioCache)m_ratRange[i]).bCharSet, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4))); newbuf.SetByte( ((RatioCache)m_ratRange[i]).xRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 1)); newbuf.SetByte( ((RatioCache)m_ratRange[i]).yStartRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 2)); newbuf.SetByte( ((RatioCache)m_ratRange[i]).yEndRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 3)); } // Set up the strting offset for the VDMX Groups ushort iOffset = (ushort)(Table_VDMX.FieldOffsets.ratRange + (m_numRatios * 4) + (m_numRatios * 2)); // NOTE: we may want to check these VDMX Groups to see if they are orphans and remove them if they are? // populate buffer with VDMX Groups for( ushort i = 0; i < m_numRecs; i++ ) { // Save the offset for this group VDMXOffsets[i] = iOffset; newbuf.SetUshort( ((VDMXGroupCache)m_groups[i]).recs, iOffset ); iOffset += 2; newbuf.SetByte( ((VDMXGroupCache)m_groups[i]).startsz, iOffset ); iOffset += 1; newbuf.SetByte( ((VDMXGroupCache)m_groups[i]).endsz, iOffset ); iOffset += 1; for( ushort ii = 0; ii < ((VDMXGroupCache)m_groups[i]).recs; ii++ ) { newbuf.SetUshort( ((VDMXGroupCache)m_groups[i]).getVTableRecordCache( ii ).yPelHeight, iOffset ); iOffset += 2; newbuf.SetShort( ((VDMXGroupCache)m_groups[i]).getVTableRecordCache( ii ).yMax, iOffset ); iOffset += 2; newbuf.SetShort( ((VDMXGroupCache)m_groups[i]).getVTableRecordCache( ii ).yMin, iOffset ); iOffset += 2; } } // populate buffer with Ratio Records for( ushort i = 0; i < m_numRatios; i++ ) { newbuf.SetByte( ((RatioCache)m_ratRange[i]).bCharSet, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4))); newbuf.SetByte( ((RatioCache)m_ratRange[i]).xRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 1)); newbuf.SetByte( ((RatioCache)m_ratRange[i]).yStartRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 2)); newbuf.SetByte( ((RatioCache)m_ratRange[i]).yEndRatio, (uint)(Table_VDMX.FieldOffsets.ratRange + (i * 4) + 3)); // Write out the offsets for the VDMX Groups to the buffer newbuf.SetUshort( VDMXOffsets[((RatioCache)m_ratRange[i]).VDMXGroupThisRatio], (uint)(Table_VDMX.FieldOffsets.ratRange + (m_numRatios * 4) + (i * 2))); } // put the buffer into a Table_VDMX object and return it Table_VDMX VDMXTable = new Table_VDMX("VDMX", newbuf); return VDMXTable; }
public override OTTable GenerateTable() { // create a Motorola Byte Order buffer for the new table MBOBuffer newbuf = new MBOBuffer(54); // populate the buffer newbuf.SetFixed( m_Version, (uint)Table_PCLT.FieldOffsets.Version ); newbuf.SetUint( m_FontNumber, (uint)Table_PCLT.FieldOffsets.FontNumber ); newbuf.SetUshort( m_Pitch, (uint)Table_PCLT.FieldOffsets.Pitch ); newbuf.SetUshort( m_xHeight, (uint)Table_PCLT.FieldOffsets.xHeight ); newbuf.SetUshort( m_Style, (uint)Table_PCLT.FieldOffsets.Style ); newbuf.SetUshort( m_TypeFamily, (uint)Table_PCLT.FieldOffsets.TypeFamily ); newbuf.SetUshort( m_CapHeight, (uint)Table_PCLT.FieldOffsets.CapHeight ); newbuf.SetUshort( m_SymbolSet, (uint)Table_PCLT.FieldOffsets.SymbolSet ); for( uint i = 0; i < 16; i++ ) { newbuf.SetByte( m_Typeface[i], (uint)Table_PCLT.FieldOffsets.Typeface + i ); } for( uint i = 0; i < 8; i++ ) { newbuf.SetByte( m_CharacterComplement[i],(uint)Table_PCLT.FieldOffsets.CharacterComplement + i ); } for( uint i = 0; i < 6; i++ ) { newbuf.SetByte( m_FileName[i], (uint)Table_PCLT.FieldOffsets.FileName + i ); } newbuf.SetShort( m_StrokeWeight, (uint)Table_PCLT.FieldOffsets.StrokeWeight ); newbuf.SetShort( m_WidthType, (uint)Table_PCLT.FieldOffsets.WidthType ); newbuf.SetByte( m_SerifStyle, (uint)Table_PCLT.FieldOffsets.SerifStyle ); newbuf.SetByte( m_Reserved, (uint)Table_PCLT.FieldOffsets.Reserved ); // put the buffer into a Table_vhea object and return it Table_PCLT PCLTTable = new Table_PCLT("PCLT", newbuf); return PCLTTable; }