Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
550819b829
pdf.js/src/fonts.js

3741 lines
138 KiB
JavaScript
Raw Normal View History

Fix Mode comment lines.
2011-09-13 02:37:33 +09:00
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
Add some code to make (the first one only...) font pass the sanitizer check
2011-06-12 21:23:39 +09:00
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
Make the Type1 to OTF code active, even if the sanitizer prevent fonts to load at the moment
2011-06-12 10:00:45 +09:00
'use strict' everywhere
2011-10-26 10:18:22 +09:00
'use strict';
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
/**
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
* Maximum time to wait for a font to be loaded by font-face rules.
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
*/
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
var kMaxWaitForFontFace = 1000;
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
// Unicode Private Use Area
var kCmapGlyphOffset = 0xE000;
Fix regression caused by pull request #491. Glyphs in positions that match complex scripts or special characters can be messed up by the browser when drawn to the canvas. Limit to fonts with a small to medium sized glyph set.
2011-10-03 18:16:18 +09:00
var kSizeOfGlyphArea = 0x1900;
Fixing lint long lines warnings
2011-09-17 09:53:52 +09:00
// PDF Glyph Space Units are one Thousandth of a TextSpace Unit
// except for Type 3 fonts
Add opentype ascender, descender and units-per-em to font properties Prefer font ascender, descender when creating OS/2 table scale PDF ascender and descender in OS/2 table by font units per em if it exists Fix the truetype font header to prevent Windows rejecting a Mac truetype font
2011-09-16 21:50:11 +09:00
var kPDFGlyphSpaceUnits = 1000;
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
Disable hinting until it works
2011-09-11 03:00:27 +09:00
// Until hinting is fully supported this constant can be used
var kHintingEnabled = false;
Splitting files
2011-10-25 08:55:23 +09:00
var Encodings = {
get ExpertEncoding() {
return shadow(this, 'ExpertEncoding', ['', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', 'space', 'exclamsmall', 'Hungarumlautsmall', '',
'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', 'Acutesmall',
'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',
'onedotenleader', 'comma', 'hyphen', 'period', 'fraction',
'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle',
'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle',
'eightoldstyle', 'nineoldstyle', 'colon', 'semicolon', 'commasuperior',
'threequartersemdash', 'periodsuperior', 'questionsmall', '',
'asuperior', 'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', '',
'', 'isuperior', '', '', 'lsuperior', 'msuperior', 'nsuperior',
'osuperior', '', '', 'rsuperior', 'ssuperior', 'tsuperior', '', 'ff',
'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', '', 'parenrightinferior',
'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall', 'Bsmall',
'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall',
'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall',
'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall',
'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah',
'Tildesmall', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall', '', '',
'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall',
'Caronsmall', '', 'Dotaccentsmall', '', '', 'Macronsmall', '', '',
'figuredash', 'hypheninferior', '', '', 'Ogoneksmall', 'Ringsmall',
'Cedillasmall', '', '', '', 'onequarter', 'onehalf', 'threequarters',
'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths',
'seveneighths', 'onethird', 'twothirds', '', '', 'zerosuperior',
'onesuperior', 'twosuperior', 'threesuperior', 'foursuperior',
'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior',
'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior',
'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior',
'seveninferior', 'eightinferior', 'nineinferior', 'centinferior',
'dollarinferior', 'periodinferior', 'commainferior', 'Agravesmall',
'Aacutesmall', 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall',
'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall',
'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall',
'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall',
'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall',
'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall',
'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall',
'Ydieresissmall'
]);
},
get MacExpertEncoding() {
return shadow(this, 'MacExpertEncoding', ['', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', 'space', 'exclamsmall', 'Hungarumlautsmall',
'centoldstyle', 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall',
'Acutesmall', 'parenleftsuperior', 'parenrightsuperior',
'twodotenleader', 'onedotenleader', 'comma', 'hyphen', 'period',
'fraction', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',
'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',
'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'colon', 'semicolon',
'', 'threequartersemdash', '', 'questionsmall', '', '', '', '',
'Ethsmall', '', '', 'onequarter', 'onehalf', 'threequarters',
'oneeighth', 'threeeighths', 'fiveeighths', 'seveneighths', 'onethird',
'twothirds', '', '', '', '', '', '', 'ff', 'fi', 'fl', 'ffi', 'ffl',
'parenleftinferior', '', 'parenrightinferior', 'Circumflexsmall',
'hypheninferior', 'Gravesmall', 'Asmall', 'Bsmall', 'Csmall', 'Dsmall',
'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall', 'Jsmall', 'Ksmall',
'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall', 'Qsmall', 'Rsmall',
'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall',
'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', 'Tildesmall', '', '',
'asuperior', 'centsuperior', '', '', '', '', 'Aacutesmall',
'Agravesmall', 'Acircumflexsmall', 'Adieresissmall', 'Atildesmall',
'Aringsmall', 'Ccedillasmall', 'Eacutesmall', 'Egravesmall',
'Ecircumflexsmall', 'Edieresissmall', 'Iacutesmall', 'Igravesmall',
'Icircumflexsmall', 'Idieresissmall', 'Ntildesmall', 'Oacutesmall',
'Ogravesmall', 'Ocircumflexsmall', 'Odieresissmall', 'Otildesmall',
'Uacutesmall', 'Ugravesmall', 'Ucircumflexsmall', 'Udieresissmall', '',
'eightsuperior', 'fourinferior', 'threeinferior', 'sixinferior',
'eightinferior', 'seveninferior', 'Scaronsmall', '', 'centinferior',
'twoinferior', '', 'Dieresissmall', '', 'Caronsmall', 'osuperior',
'fiveinferior', '', 'commainferior', 'periodinferior', 'Yacutesmall', '',
'dollarinferior', '', 'Thornsmall', '', 'nineinferior', 'zeroinferior',
'Zcaronsmall', 'AEsmall', 'Oslashsmall', 'questiondownsmall',
'oneinferior', 'Lslashsmall', '', '', '', '', '', '', 'Cedillasmall', '',
'', '', '', '', 'OEsmall', 'figuredash', 'hyphensuperior', '', '', '',
'', 'exclamdownsmall', '', 'Ydieresissmall', '', 'onesuperior',
'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior',
'sixsuperior', 'sevensuperior', 'ninesuperior', 'zerosuperior', '',
'esuperior', 'rsuperior', 'tsuperior', '', '', 'isuperior', 'ssuperior',
'dsuperior', '', '', '', '', '', 'lsuperior', 'Ogoneksmall',
'Brevesmall', 'Macronsmall', 'bsuperior', 'nsuperior', 'msuperior',
'commasuperior', 'periodsuperior', 'Dotaccentsmall', 'Ringsmall'
]);
},
get MacRomanEncoding() {
return shadow(this, 'MacRomanEncoding', ['', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', 'space', 'exclam', 'quotedbl', 'numbersign',
'dollar', 'percent', 'ampersand', 'quotesingle', 'parenleft',
'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash',
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question',
'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore',
'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'braceleft', 'bar', 'braceright', 'asciitilde', '', 'Adieresis', 'Aring',
'Ccedilla', 'Eacute', 'Ntilde', 'Odieresis', 'Udieresis', 'aacute',
'agrave', 'acircumflex', 'adieresis', 'atilde', 'aring', 'ccedilla',
'eacute', 'egrave', 'ecircumflex', 'edieresis', 'iacute', 'igrave',
'icircumflex', 'idieresis', 'ntilde', 'oacute', 'ograve', 'ocircumflex',
'odieresis', 'otilde', 'uacute', 'ugrave', 'ucircumflex', 'udieresis',
'dagger', 'degree', 'cent', 'sterling', 'section', 'bullet', 'paragraph',
'germandbls', 'registered', 'copyright', 'trademark', 'acute',
'dieresis', 'notequal', 'AE', 'Oslash', 'infinity', 'plusminus',
'lessequal', 'greaterequal', 'yen', 'mu', 'partialdiff', 'summation',
'product', 'pi', 'integral', 'ordfeminine', 'ordmasculine', 'Omega',
'ae', 'oslash', 'questiondown', 'exclamdown', 'logicalnot', 'radical',
'florin', 'approxequal', 'Delta', 'guillemotleft', 'guillemotright',
'ellipsis', 'space', 'Agrave', 'Atilde', 'Otilde', 'OE', 'oe', 'endash',
'emdash', 'quotedblleft', 'quotedblright', 'quoteleft', 'quoteright',
'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction', 'currency',
'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl',
'periodcentered', 'quotesinglbase', 'quotedblbase', 'perthousand',
'Acircumflex', 'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute',
'Icircumflex', 'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple',
'Ograve', 'Uacute', 'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex',
'tilde', 'macron', 'breve', 'dotaccent', 'ring', 'cedilla',
'hungarumlaut', 'ogonek', 'caron'
]);
},
get StandardEncoding() {
return shadow(this, 'StandardEncoding', ['', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', 'space', 'exclam', 'quotedbl', 'numbersign',
'dollar', 'percent', 'ampersand', 'quoteright', 'parenleft',
'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash',
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question',
'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore',
'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'braceleft', 'bar', 'braceright', 'asciitilde', '', '', 'exclamdown',
'cent', 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency',
'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft',
'guilsinglright', 'fi', 'fl', '', 'endash', 'dagger', 'daggerdbl',
'periodcentered', '', 'paragraph', 'bullet', 'quotesinglbase',
'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis',
'perthousand', '', 'questiondown', '', 'grave', 'acute', 'circumflex',
'tilde', 'macron', 'breve', 'dotaccent', 'dieresis', '', 'ring',
'cedilla', '', 'hungarumlaut', 'ogonek', 'caron', 'emdash', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', 'AE', '',
'ordfeminine', '', '', '', '', 'Lslash', 'Oslash', 'OE', 'ordmasculine',
'', '', '', '', '', 'ae', '', '', '', 'dotlessi', '', '', 'lslash',
'oslash', 'oe', 'germandbls'
]);
},
get WinAnsiEncoding() {
return shadow(this, 'WinAnsiEncoding', ['', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', 'space', 'exclam', 'quotedbl', 'numbersign',
'dollar', 'percent', 'ampersand', 'quotesingle', 'parenleft',
'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash',
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question',
'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore',
'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'braceleft', 'bar', 'braceright', 'asciitilde', 'bullet', 'Euro',
'bullet', 'quotesinglbase', 'florin', 'quotedblbase', 'ellipsis',
'dagger', 'daggerdbl', 'circumflex', 'perthousand', 'Scaron',
'guilsinglleft', 'OE', 'bullet', 'Zcaron', 'bullet', 'bullet',
'quoteleft', 'quoteright', 'quotedblleft', 'quotedblright', 'bullet',
'endash', 'emdash', 'tilde', 'trademark', 'scaron', 'guilsinglright',
'oe', 'bullet', 'zcaron', 'Ydieresis', 'space', 'exclamdown', 'cent',
'sterling', 'currency', 'yen', 'brokenbar', 'section', 'dieresis',
'copyright', 'ordfeminine', 'guillemotleft', 'logicalnot', 'hyphen',
'registered', 'macron', 'degree', 'plusminus', 'twosuperior',
'threesuperior', 'acute', 'mu', 'paragraph', 'periodcentered',
'cedilla', 'onesuperior', 'ordmasculine', 'guillemotright', 'onequarter',
'onehalf', 'threequarters', 'questiondown', 'Agrave', 'Aacute',
'Acircumflex', 'Atilde', 'Adieresis', 'Aring', 'AE', 'Ccedilla',
'Egrave', 'Eacute', 'Ecircumflex', 'Edieresis', 'Igrave', 'Iacute',
'Icircumflex', 'Idieresis', 'Eth', 'Ntilde', 'Ograve', 'Oacute',
'Ocircumflex', 'Otilde', 'Odieresis', 'multiply', 'Oslash', 'Ugrave',
'Uacute', 'Ucircumflex', 'Udieresis', 'Yacute', 'Thorn', 'germandbls',
'agrave', 'aacute', 'acircumflex', 'atilde', 'adieresis', 'aring', 'ae',
'ccedilla', 'egrave', 'eacute', 'ecircumflex', 'edieresis', 'igrave',
'iacute', 'icircumflex', 'idieresis', 'eth', 'ntilde', 'ograve',
'oacute', 'ocircumflex', 'otilde', 'odieresis', 'divide', 'oslash',
'ugrave', 'uacute', 'ucircumflex', 'udieresis', 'yacute', 'thorn',
'ydieresis'
]);
},
get symbolsEncoding() {
return shadow(this, 'symbolsEncoding', ['', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', 'space', 'exclam', 'universal', 'numbersign',
'existential', 'percent', 'ampersand', 'suchthat', 'parenleft',
'parenright', 'asteriskmath', 'plus', 'comma', 'minus', 'period',
'slash', 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven',
'eight', 'nine', 'colon', 'semicolon', 'less', 'equal', 'greater',
'question', 'congruent', 'Alpha', 'Beta', 'Chi', 'Delta', 'Epsilon',
'Phi', 'Gamma', 'Eta', 'Iota', 'theta1', 'Kappa', 'Lambda', 'Mu', 'Nu',
'Omicron', 'Pi', 'Theta', 'Rho', 'Sigma', 'Tau', 'Upsilon', 'sigma1',
'Omega', 'Xi', 'Psi', 'Zeta', 'bracketleft', 'therefore', 'bracketright',
'perpendicular', 'underscore', 'radicalex', 'alpha', 'beta', 'chi',
'delta', 'epsilon', 'phi', 'gamma', 'eta', 'iota', 'phi1', 'kappa',
'lambda', 'mu', 'nu', 'omicron', 'pi', 'theta', 'rho', 'sigma', 'tau',
'upsilon', 'omega1', 'omega', 'xi', 'psi', 'zeta', 'braceleft', 'bar',
'braceright', 'similar', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', 'Euro', 'Upsilon1', 'minute', 'lessequal', 'fraction',
'infinity', 'florin', 'club', 'diamond', 'heart', 'spade', 'arrowboth',
'arrowleft', 'arrowup', 'arrowright', 'arrowdown', 'degree', 'plusminus',
'second', 'greaterequal', 'multiply', 'proportional', 'partialdiff',
'bullet', 'divide', 'notequal', 'equivalence', 'approxequal', 'ellipsis',
'arrowvertex', 'arrowhorizex', 'carriagereturn', 'aleph', 'Ifraktur',
'Rfraktur', 'weierstrass', 'circlemultiply', 'circleplus', 'emptyset',
'intersection', 'union', 'propersuperset', 'reflexsuperset', 'notsubset',
'propersubset', 'reflexsubset', 'element', 'notelement', 'angle',
'gradient', 'registerserif', 'copyrightserif', 'trademarkserif',
'product', 'radical', 'dotmath', 'logicalnot', 'logicaland', 'logicalor',
'arrowdblboth', 'arrowdblleft', 'arrowdblup', 'arrowdblright',
'arrowdbldown', 'lozenge', 'angleleft', 'registersans', 'copyrightsans',
'trademarksans', 'summation', 'parenlefttp', 'parenleftex',
'parenleftbt', 'bracketlefttp', 'bracketleftex', 'bracketleftbt',
'bracelefttp', 'braceleftmid', 'braceleftbt', 'braceex', '',
'angleright', 'integral', 'integraltp', 'integralex', 'integralbt',
'parenrighttp', 'parenrightex', 'parenrightbt', 'bracketrighttp',
'bracketrightex', 'bracketrightbt', 'bracerighttp', 'bracerightmid',
'bracerightbt'
]);
},
get zapfDingbatsEncoding() {
return shadow(this, 'zapfDingbatsEncoding', ['', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', 'space', 'a1', 'a2', 'a202', 'a3', 'a4',
'a5', 'a119', 'a118', 'a117', 'a11', 'a12', 'a13', 'a14', 'a15', 'a16',
'a105', 'a17', 'a18', 'a19', 'a20', 'a21', 'a22', 'a23', 'a24', 'a25',
'a26', 'a27', 'a28', 'a6', 'a7', 'a8', 'a9', 'a10', 'a29', 'a30', 'a31',
'a32', 'a33', 'a34', 'a35', 'a36', 'a37', 'a38', 'a39', 'a40', 'a41',
'a42', 'a43', 'a44', 'a45', 'a46', 'a47', 'a48', 'a49', 'a50', 'a51',
'a52', 'a53', 'a54', 'a55', 'a56', 'a57', 'a58', 'a59', 'a60', 'a61',
'a62', 'a63', 'a64', 'a65', 'a66', 'a67', 'a68', 'a69', 'a70', 'a71',
'a72', 'a73', 'a74', 'a203', 'a75', 'a204', 'a76', 'a77', 'a78', 'a79',
'a81', 'a82', 'a83', 'a84', 'a97', 'a98', 'a99', 'a100', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', 'a101', 'a102', 'a103',
'a104', 'a106', 'a107', 'a108', 'a112', 'a111', 'a110', 'a109', 'a120',
'a121', 'a122', 'a123', 'a124', 'a125', 'a126', 'a127', 'a128', 'a129',
'a130', 'a131', 'a132', 'a133', 'a134', 'a135', 'a136', 'a137', 'a138',
'a139', 'a140', 'a141', 'a142', 'a143', 'a144', 'a145', 'a146', 'a147',
'a148', 'a149', 'a150', 'a151', 'a152', 'a153', 'a154', 'a155', 'a156',
'a157', 'a158', 'a159', 'a160', 'a161', 'a163', 'a164', 'a196', 'a165',
'a192', 'a166', 'a167', 'a168', 'a169', 'a170', 'a171', 'a172', 'a173',
'a162', 'a174', 'a175', 'a176', 'a177', 'a178', 'a179', 'a193', 'a180',
'a199', 'a181', 'a200', 'a182', '', 'a201', 'a183', 'a184', 'a197',
'a185', 'a194', 'a198', 'a186', 'a195', 'a187', 'a188', 'a189', 'a190',
'a191'
]);
}
};
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
/**
Support standards fonts
2011-07-25 23:42:46 +09:00
* Hold a map of decoded fonts and of the standard fourteen Type1
* fonts and their acronyms.
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
*/
Support standards fonts
2011-07-25 23:42:46 +09:00
var stdFontMap = {
Simulate Arial Black and Arial Narrow
2011-09-01 11:06:33 +09:00
'ArialNarrow': 'Helvetica',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'ArialNarrow-Bold': 'Helvetica-Bold',
'ArialNarrow-BoldItalic': 'Helvetica-BoldOblique',
'ArialNarrow-Italic': 'Helvetica-Oblique',
Simulate Arial Black and Arial Narrow
2011-09-01 11:06:33 +09:00
'ArialBlack': 'Helvetica',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'ArialBlack-Bold': 'Helvetica-Bold',
'ArialBlack-BoldItalic': 'Helvetica-BoldOblique',
'ArialBlack-Italic': 'Helvetica-Oblique',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'Arial': 'Helvetica',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'Arial-Bold': 'Helvetica-Bold',
'Arial-BoldItalic': 'Helvetica-BoldOblique',
'Arial-Italic': 'Helvetica-Oblique',
'Arial-BoldItalicMT': 'Helvetica-BoldOblique',
'Arial-BoldMT': 'Helvetica-Bold',
'Arial-ItalicMT': 'Helvetica-Oblique',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'ArialMT': 'Helvetica',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'Courier-Bold': 'Courier-Bold',
'Courier-BoldItalic': 'Courier-BoldOblique',
'Courier-Italic': 'Courier-Oblique',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'CourierNew': 'Courier',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'CourierNew-Bold': 'Courier-Bold',
'CourierNew-BoldItalic': 'Courier-BoldOblique',
'CourierNew-Italic': 'Courier-Oblique',
'CourierNewPS-BoldItalicMT': 'Courier-BoldOblique',
'CourierNewPS-BoldMT': 'Courier-Bold',
'CourierNewPS-ItalicMT': 'Courier-Oblique',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'CourierNewPSMT': 'Courier',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'Helvetica-Bold': 'Helvetica-Bold',
'Helvetica-BoldItalic': 'Helvetica-BoldOblique',
'Helvetica-Italic': 'Helvetica-Oblique',
'Symbol-Bold': 'Symbol',
'Symbol-BoldItalic': 'Symbol',
'Symbol-Italic': 'Symbol',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'TimesNewRoman': 'Times-Roman',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'TimesNewRoman-Bold': 'Times-Bold',
'TimesNewRoman-BoldItalic': 'Times-BoldItalic',
'TimesNewRoman-Italic': 'Times-Italic',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'TimesNewRomanPS': 'Times-Roman',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'TimesNewRomanPS-Bold': 'Times-Bold',
'TimesNewRomanPS-BoldItalic': 'Times-BoldItalic',
'TimesNewRomanPS-BoldItalicMT': 'Times-BoldItalic',
'TimesNewRomanPS-BoldMT': 'Times-Bold',
'TimesNewRomanPS-Italic': 'Times-Italic',
'TimesNewRomanPS-ItalicMT': 'Times-Italic',
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
'TimesNewRomanPSMT': 'Times-Roman',
Initial merge of master.
2011-10-20 03:14:13 +09:00
'TimesNewRomanPSMT-Bold': 'Times-Bold',
'TimesNewRomanPSMT-BoldItalic': 'Times-BoldItalic',
'TimesNewRomanPSMT-Italic': 'Times-Italic'
Support standards fonts
2011-07-25 23:42:46 +09:00
};
Add a fake canvas for scaling fonts to improve perfs
2011-06-29 01:24:16 +09:00
fix serif and symbol attribute detection for standard fonts
2012-01-10 12:15:18 +09:00
var serifFonts = {
'Adobe Jenson': true, 'Adobe Text': true, 'Albertus': true,
'Aldus': true, 'Alexandria': true, 'Algerian': true,
'American Typewriter': true, 'Antiqua': true, 'Apex': true,
'Arno': true, 'Aster': true, 'Aurora': true,
'Baskerville': true, 'Bell': true, 'Bembo': true,
'Bembo Schoolbook': true, 'Benguiat': true, 'Berkeley Old Style': true,
'Bernhard Modern': true, 'Berthold City': true, 'Bodoni': true,
'Bauer Bodoni': true, 'Book Antiqua': true, 'Bookman': true,
'Bordeaux Roman': true, 'Californian FB': true, 'Calisto': true,
'Calvert': true, 'Capitals': true, 'Cambria': true,
'Cartier': true, 'Caslon': true, 'Catull': true,
'Centaur': true, 'Century Old Style': true, 'Century Schoolbook': true,
'Chaparral': true, 'Charis SIL': true, 'Cheltenham': true,
'Cholla Slab': true, 'Clarendon': true, 'Clearface': true,
'Cochin': true, 'Colonna': true, 'Computer Modern': true,
'Concrete Roman': true, 'Constantia': true, 'Cooper Black': true,
'Corona': true, 'Ecotype': true, 'Egyptienne': true,
'Elephant': true, 'Excelsior': true, 'Fairfield': true,
'FF Scala': true, 'Folkard': true, 'Footlight': true,
'FreeSerif': true, 'Friz Quadrata': true, 'Garamond': true,
'Gentium': true, 'Georgia': true, 'Gloucester': true,
'Goudy Old Style': true, 'Goudy Schoolbook': true, 'Goudy Pro Font': true,
'Granjon': true, 'Guardian Egyptian': true, 'Heather': true,
'Hercules': true, 'High Tower Text': true, 'Hiroshige': true,
'Hoefler Text': true, 'Humana Serif': true, 'Imprint': true,
'Ionic No. 5': true, 'Janson': true, 'Joanna': true,
'Korinna': true, 'Lexicon': true, 'Liberation Serif': true,
'Linux Libertine': true, 'Literaturnaya': true, 'Lucida': true,
'Lucida Bright': true, 'Melior': true, 'Memphis': true,
'Miller': true, 'Minion': true, 'Modern': true,
'Mona Lisa': true, 'Mrs Eaves': true, 'MS Serif': true,
'Museo Slab': true, 'New York': true, 'Nimbus Roman': true,
'NPS Rawlinson Roadway': true, 'Palatino': true, 'Perpetua': true,
'Plantin': true, 'Plantin Schoolbook': true, 'Playbill': true,
'Poor Richard': true, 'Rawlinson Roadway': true, 'Renault': true,
'Requiem': true, 'Rockwell': true, 'Roman': true,
'Rotis Serif': true, 'Sabon': true, 'Scala': true,
'Seagull': true, 'Sistina': true, 'Souvenir': true,
'STIX': true, 'Stone Informal': true, 'Stone Serif': true,
'Sylfaen': true, 'Times': true, 'Trajan': true,
'Trinité': true, 'Trump Mediaeval': true, 'Utopia': true,
'Vale Type': true, 'Bitstream Vera': true, 'Vera Serif': true,
'Versailles': true, 'Wanted': true, 'Weiss': true,
'Wide Latin': true, 'Windsor': true, 'XITS': true
};
var symbolsFonts = {
'Dingbats': true, 'Symbol': true, 'ZapfDingbats': true
};
Add support for WebKit using measure on canvas method
2011-09-16 15:14:35 +09:00
var FontLoader = {
listeningForFontLoad: false,
Use canvas measureText to detect font loading
2011-09-14 23:55:15 +09:00
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
bind: function fontLoaderBind(fonts, callback) {
Backup
2011-10-01 18:44:01 +09:00
function checkFontsLoaded() {
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = objs.length; i < ii; i++) {
Backup
2011-10-01 18:44:01 +09:00
var fontObj = objs[i];
if (fontObj.loading) {
return false;
}
}
document.documentElement.removeEventListener(
'pdfjsFontLoad', checkFontsLoaded, false);
callback();
return true;
}
var rules = [], names = [], objs = [];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = fonts.length; i < ii; i++) {
Backup
2011-10-01 18:44:01 +09:00
var font = fonts[i];
Fix lint errors
2011-10-09 17:37:53 +09:00
Process fonts on main thread again - font handling works again
2011-10-09 05:22:30 +09:00
// If there is already a fontObj on the font, then it was loaded/attached
// to the page already and we don't have to do anything for this font
// here future.
if (font.fontObj) {
continue;
}
Backup
2011-10-01 18:44:01 +09:00
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
var obj = new Font(font.name, font.file, font.properties);
Process fonts on main thread again - font handling works again
2011-10-09 05:22:30 +09:00
// Store the fontObj on the font such that `setFont` in CanvasGraphics
// can reuse it later again.
font.fontObj = obj;
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
objs.push(obj);
Backup
2011-10-01 18:44:01 +09:00
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
var str = '';
var data = obj.data;
if (data) {
var length = data.length;
for (var j = 0; j < length; j++)
str += String.fromCharCode(data[j]);
Backup
2011-10-01 18:44:01 +09:00
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
var rule = isWorker ? obj.bindWorker(str) : obj.bindDOM(str);
if (rule) {
rules.push(rule);
names.push(obj.loadedName);
}
}
Add support for WebKit using measure on canvas method
2011-09-16 15:14:35 +09:00
}
Backup
2011-10-01 18:44:01 +09:00
this.listeningForFontLoad = false;
if (!isWorker && rules.length) {
FontLoader.prepareFontLoadEvent(rules, names, objs);
}
if (!checkFontsLoaded()) {
document.documentElement.addEventListener(
'pdfjsFontLoad', checkFontsLoaded, false);
}
return objs;
Cleanup Moz support in FontLoader
2011-09-16 15:27:22 +09:00
},
// Set things up so that at least one pdfjsFontLoad event is
// dispatched when all the @font-face |rules| for |names| have been
// loaded in a subdocument. It's expected that the load of |rules|
// has already started in this (outer) document, so that they should
// be ordered before the load in the subdocument.
Backup
2011-10-01 18:44:01 +09:00
prepareFontLoadEvent: function fontLoaderPrepareFontLoadEvent(rules, names,
objs) {
Cleanup Moz support in FontLoader
2011-09-16 15:27:22 +09:00
/** Hack begin */
// There's no event when a font has finished downloading so the
// following code is a dirty hack to 'guess' when a font is
// ready. This code will be obsoleted by Mozilla bug 471915.
//
// The only reliable way to know if a font is loaded in Gecko
// (at the moment) is document.onload in a document with
// a @font-face rule defined in a "static" stylesheet. We use a
// subdocument in an <iframe>, set up properly, to know when
// our @font-face rule was loaded. However, the subdocument and
// outer document can't share CSS rules, so the inner document
// is only part of the puzzle. The second piece is an invisible
// div created in order to force loading of the @font-face in
// the *outer* document. (The font still needs to be loaded for
// its metrics, for reflow). We create the div first for the
// outer document, then create the iframe. Unless something
// goes really wonkily, we expect the @font-face for the outer
// document to be processed before the inner. That's still
// fragile, but seems to work in practice.
//
// The postMessage() hackery was added to work around chrome bug
// 82402.
Backup
2011-09-16 14:46:44 +09:00
Backup
2011-10-01 18:44:01 +09:00
var div = document.createElement('div');
div.setAttribute('style',
'visibility: hidden;' +
'width: 10px; height: 10px;' +
'position: absolute; top: 0px; left: 0px;');
var html = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = names.length; i < ii; ++i) {
Backup
2011-10-01 18:44:01 +09:00
html += '<span style="font-family:' + names[i] + '">Hi</span>';
}
div.innerHTML = html;
document.body.appendChild(div);
if (!this.listeningForFontLoad) {
window.addEventListener(
'message',
function fontLoaderMessage(e) {
var fontNames = JSON.parse(e.data);
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = objs.length; i < ii; ++i) {
Backup
2011-10-01 18:44:01 +09:00
var font = objs[i];
font.loading = false;
}
var evt = document.createEvent('Events');
evt.initEvent('pdfjsFontLoad', true, false);
document.documentElement.dispatchEvent(evt);
},
false);
this.listeningForFontLoad = true;
}
Cleanup Moz support in FontLoader
2011-09-16 15:27:22 +09:00
// XXX we should have a time-out here too, and maybe fire
// pdfjsFontLoadFailed?
var src = '<!DOCTYPE HTML><html><head>';
src += '<style type="text/css">';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = rules.length; i < ii; ++i) {
Backup
2011-10-01 18:44:01 +09:00
src += rules[i];
}
Cleanup Moz support in FontLoader
2011-09-16 15:27:22 +09:00
src += '</style>';
Backup
2011-10-01 18:44:01 +09:00
src += '<script type="application/javascript">';
var fontNamesArray = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = names.length; i < ii; ++i) {
Backup
2011-10-01 18:44:01 +09:00
fontNamesArray += '"' + names[i] + '", ';
}
src += ' var fontNames=[' + fontNamesArray + '];\n';
src += ' window.onload = function fontLoaderOnload() {\n';
src += ' parent.postMessage(JSON.stringify(fontNames), "*");\n';
src += ' }';
src += '</script></head><body>';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = names.length; i < ii; ++i) {
Backup
2011-10-01 18:44:01 +09:00
src += '<p style="font-family:\'' + names[i] + '\'">Hi</p>';
}
Cleanup Moz support in FontLoader
2011-09-16 15:27:22 +09:00
src += '</body></html>';
var frame = document.createElement('iframe');
frame.src = 'data:text/html,' + src;
frame.setAttribute('style',
'visibility: hidden;' +
'width: 10px; height: 10px;' +
'position: absolute; top: 0px; left: 0px;');
document.body.appendChild(frame);
/** Hack end */
}
};
Backup
2011-09-16 14:46:44 +09:00
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
var UnicodeRanges = [
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
{ 'begin': 0x0000, 'end': 0x007F }, // Basic Latin
{ 'begin': 0x0080, 'end': 0x00FF }, // Latin-1 Supplement
{ 'begin': 0x0100, 'end': 0x017F }, // Latin Extended-A
{ 'begin': 0x0180, 'end': 0x024F }, // Latin Extended-B
{ 'begin': 0x0250, 'end': 0x02AF }, // IPA Extensions
{ 'begin': 0x02B0, 'end': 0x02FF }, // Spacing Modifier Letters
{ 'begin': 0x0300, 'end': 0x036F }, // Combining Diacritical Marks
{ 'begin': 0x0370, 'end': 0x03FF }, // Greek and Coptic
{ 'begin': 0x2C80, 'end': 0x2CFF }, // Coptic
{ 'begin': 0x0400, 'end': 0x04FF }, // Cyrillic
{ 'begin': 0x0530, 'end': 0x058F }, // Armenian
{ 'begin': 0x0590, 'end': 0x05FF }, // Hebrew
{ 'begin': 0xA500, 'end': 0xA63F }, // Vai
{ 'begin': 0x0600, 'end': 0x06FF }, // Arabic
{ 'begin': 0x07C0, 'end': 0x07FF }, // NKo
{ 'begin': 0x0900, 'end': 0x097F }, // Devanagari
{ 'begin': 0x0980, 'end': 0x09FF }, // Bengali
{ 'begin': 0x0A00, 'end': 0x0A7F }, // Gurmukhi
{ 'begin': 0x0A80, 'end': 0x0AFF }, // Gujarati
{ 'begin': 0x0B00, 'end': 0x0B7F }, // Oriya
{ 'begin': 0x0B80, 'end': 0x0BFF }, // Tamil
{ 'begin': 0x0C00, 'end': 0x0C7F }, // Telugu
{ 'begin': 0x0C80, 'end': 0x0CFF }, // Kannada
{ 'begin': 0x0D00, 'end': 0x0D7F }, // Malayalam
{ 'begin': 0x0E00, 'end': 0x0E7F }, // Thai
{ 'begin': 0x0E80, 'end': 0x0EFF }, // Lao
{ 'begin': 0x10A0, 'end': 0x10FF }, // Georgian
{ 'begin': 0x1B00, 'end': 0x1B7F }, // Balinese
{ 'begin': 0x1100, 'end': 0x11FF }, // Hangul Jamo
{ 'begin': 0x1E00, 'end': 0x1EFF }, // Latin Extended Additional
{ 'begin': 0x1F00, 'end': 0x1FFF }, // Greek Extended
{ 'begin': 0x2000, 'end': 0x206F }, // General Punctuation
{ 'begin': 0x2070, 'end': 0x209F }, // Superscripts And Subscripts
{ 'begin': 0x20A0, 'end': 0x20CF }, // Currency Symbol
{ 'begin': 0x20D0, 'end': 0x20FF }, // Combining Diacritical Marks For Symbols
{ 'begin': 0x2100, 'end': 0x214F }, // Letterlike Symbols
{ 'begin': 0x2150, 'end': 0x218F }, // Number Forms
{ 'begin': 0x2190, 'end': 0x21FF }, // Arrows
{ 'begin': 0x2200, 'end': 0x22FF }, // Mathematical Operators
{ 'begin': 0x2300, 'end': 0x23FF }, // Miscellaneous Technical
{ 'begin': 0x2400, 'end': 0x243F }, // Control Pictures
{ 'begin': 0x2440, 'end': 0x245F }, // Optical Character Recognition
{ 'begin': 0x2460, 'end': 0x24FF }, // Enclosed Alphanumerics
{ 'begin': 0x2500, 'end': 0x257F }, // Box Drawing
{ 'begin': 0x2580, 'end': 0x259F }, // Block Elements
{ 'begin': 0x25A0, 'end': 0x25FF }, // Geometric Shapes
{ 'begin': 0x2600, 'end': 0x26FF }, // Miscellaneous Symbols
{ 'begin': 0x2700, 'end': 0x27BF }, // Dingbats
{ 'begin': 0x3000, 'end': 0x303F }, // CJK Symbols And Punctuation
{ 'begin': 0x3040, 'end': 0x309F }, // Hiragana
{ 'begin': 0x30A0, 'end': 0x30FF }, // Katakana
{ 'begin': 0x3100, 'end': 0x312F }, // Bopomofo
{ 'begin': 0x3130, 'end': 0x318F }, // Hangul Compatibility Jamo
{ 'begin': 0xA840, 'end': 0xA87F }, // Phags-pa
{ 'begin': 0x3200, 'end': 0x32FF }, // Enclosed CJK Letters And Months
{ 'begin': 0x3300, 'end': 0x33FF }, // CJK Compatibility
{ 'begin': 0xAC00, 'end': 0xD7AF }, // Hangul Syllables
{ 'begin': 0xD800, 'end': 0xDFFF }, // Non-Plane 0 *
{ 'begin': 0x10900, 'end': 0x1091F }, // Phoenicia
{ 'begin': 0x4E00, 'end': 0x9FFF }, // CJK Unified Ideographs
{ 'begin': 0xE000, 'end': 0xF8FF }, // Private Use Area (plane 0)
{ 'begin': 0x31C0, 'end': 0x31EF }, // CJK Strokes
{ 'begin': 0xFB00, 'end': 0xFB4F }, // Alphabetic Presentation Forms
{ 'begin': 0xFB50, 'end': 0xFDFF }, // Arabic Presentation Forms-A
{ 'begin': 0xFE20, 'end': 0xFE2F }, // Combining Half Marks
{ 'begin': 0xFE10, 'end': 0xFE1F }, // Vertical Forms
{ 'begin': 0xFE50, 'end': 0xFE6F }, // Small Form Variants
{ 'begin': 0xFE70, 'end': 0xFEFF }, // Arabic Presentation Forms-B
{ 'begin': 0xFF00, 'end': 0xFFEF }, // Halfwidth And Fullwidth Forms
{ 'begin': 0xFFF0, 'end': 0xFFFF }, // Specials
{ 'begin': 0x0F00, 'end': 0x0FFF }, // Tibetan
{ 'begin': 0x0700, 'end': 0x074F }, // Syriac
{ 'begin': 0x0780, 'end': 0x07BF }, // Thaana
{ 'begin': 0x0D80, 'end': 0x0DFF }, // Sinhala
{ 'begin': 0x1000, 'end': 0x109F }, // Myanmar
{ 'begin': 0x1200, 'end': 0x137F }, // Ethiopic
{ 'begin': 0x13A0, 'end': 0x13FF }, // Cherokee
{ 'begin': 0x1400, 'end': 0x167F }, // Unified Canadian Aboriginal Syllabics
{ 'begin': 0x1680, 'end': 0x169F }, // Ogham
{ 'begin': 0x16A0, 'end': 0x16FF }, // Runic
{ 'begin': 0x1780, 'end': 0x17FF }, // Khmer
{ 'begin': 0x1800, 'end': 0x18AF }, // Mongolian
{ 'begin': 0x2800, 'end': 0x28FF }, // Braille Patterns
{ 'begin': 0xA000, 'end': 0xA48F }, // Yi Syllables
{ 'begin': 0x1700, 'end': 0x171F }, // Tagalog
{ 'begin': 0x10300, 'end': 0x1032F }, // Old Italic
{ 'begin': 0x10330, 'end': 0x1034F }, // Gothic
{ 'begin': 0x10400, 'end': 0x1044F }, // Deseret
{ 'begin': 0x1D000, 'end': 0x1D0FF }, // Byzantine Musical Symbols
{ 'begin': 0x1D400, 'end': 0x1D7FF }, // Mathematical Alphanumeric Symbols
{ 'begin': 0xFF000, 'end': 0xFFFFD }, // Private Use (plane 15)
{ 'begin': 0xFE00, 'end': 0xFE0F }, // Variation Selectors
{ 'begin': 0xE0000, 'end': 0xE007F }, // Tags
{ 'begin': 0x1900, 'end': 0x194F }, // Limbu
{ 'begin': 0x1950, 'end': 0x197F }, // Tai Le
{ 'begin': 0x1980, 'end': 0x19DF }, // New Tai Lue
{ 'begin': 0x1A00, 'end': 0x1A1F }, // Buginese
{ 'begin': 0x2C00, 'end': 0x2C5F }, // Glagolitic
{ 'begin': 0x2D30, 'end': 0x2D7F }, // Tifinagh
{ 'begin': 0x4DC0, 'end': 0x4DFF }, // Yijing Hexagram Symbols
{ 'begin': 0xA800, 'end': 0xA82F }, // Syloti Nagri
{ 'begin': 0x10000, 'end': 0x1007F }, // Linear B Syllabary
{ 'begin': 0x10140, 'end': 0x1018F }, // Ancient Greek Numbers
{ 'begin': 0x10380, 'end': 0x1039F }, // Ugaritic
{ 'begin': 0x103A0, 'end': 0x103DF }, // Old Persian
{ 'begin': 0x10450, 'end': 0x1047F }, // Shavian
{ 'begin': 0x10480, 'end': 0x104AF }, // Osmanya
{ 'begin': 0x10800, 'end': 0x1083F }, // Cypriot Syllabary
{ 'begin': 0x10A00, 'end': 0x10A5F }, // Kharoshthi
{ 'begin': 0x1D300, 'end': 0x1D35F }, // Tai Xuan Jing Symbols
{ 'begin': 0x12000, 'end': 0x123FF }, // Cuneiform
{ 'begin': 0x1D360, 'end': 0x1D37F }, // Counting Rod Numerals
{ 'begin': 0x1B80, 'end': 0x1BBF }, // Sundanese
{ 'begin': 0x1C00, 'end': 0x1C4F }, // Lepcha
{ 'begin': 0x1C50, 'end': 0x1C7F }, // Ol Chiki
{ 'begin': 0xA880, 'end': 0xA8DF }, // Saurashtra
{ 'begin': 0xA900, 'end': 0xA92F }, // Kayah Li
{ 'begin': 0xA930, 'end': 0xA95F }, // Rejang
{ 'begin': 0xAA00, 'end': 0xAA5F }, // Cham
{ 'begin': 0x10190, 'end': 0x101CF }, // Ancient Symbols
{ 'begin': 0x101D0, 'end': 0x101FF }, // Phaistos Disc
{ 'begin': 0x102A0, 'end': 0x102DF }, // Carian
{ 'begin': 0x1F030, 'end': 0x1F09F } // Domino Tiles
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var MacStandardGlyphOrdering = [
'.notdef', '.null', 'nonmarkingreturn', 'space', 'exclam', 'quotedbl',
'numbersign', 'dollar', 'percent', 'ampersand', 'quotesingle', 'parenleft',
'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash',
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question', 'at',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft',
'backslash', 'bracketright', 'asciicircum', 'underscore', 'grave', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright',
'asciitilde', 'Adieresis', 'Aring', 'Ccedilla', 'Eacute', 'Ntilde',
'Odieresis', 'Udieresis', 'aacute', 'agrave', 'acircumflex', 'adieresis',
'atilde', 'aring', 'ccedilla', 'eacute', 'egrave', 'ecircumflex', 'edieresis',
'iacute', 'igrave', 'icircumflex', 'idieresis', 'ntilde', 'oacute', 'ograve',
'ocircumflex', 'odieresis', 'otilde', 'uacute', 'ugrave', 'ucircumflex',
'udieresis', 'dagger', 'degree', 'cent', 'sterling', 'section', 'bullet',
'paragraph', 'germandbls', 'registered', 'copyright', 'trademark', 'acute',
'dieresis', 'notequal', 'AE', 'Oslash', 'infinity', 'plusminus', 'lessequal',
'greaterequal', 'yen', 'mu', 'partialdiff', 'summation', 'product', 'pi',
'integral', 'ordfeminine', 'ordmasculine', 'Omega', 'ae', 'oslash',
'questiondown', 'exclamdown', 'logicalnot', 'radical', 'florin',
'approxequal', 'Delta', 'guillemotleft', 'guillemotright', 'ellipsis',
'nonbreakingspace', 'Agrave', 'Atilde', 'Otilde', 'OE', 'oe', 'endash',
'emdash', 'quotedblleft', 'quotedblright', 'quoteleft', 'quoteright',
'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction', 'currency',
'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl', 'periodcentered',
'quotesinglbase', 'quotedblbase', 'perthousand', 'Acircumflex',
'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute', 'Icircumflex',
'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple', 'Ograve', 'Uacute',
'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex', 'tilde', 'macron',
'breve', 'dotaccent', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron',
'Lslash', 'lslash', 'Scaron', 'scaron', 'Zcaron', 'zcaron', 'brokenbar',
'Eth', 'eth', 'Yacute', 'yacute', 'Thorn', 'thorn', 'minus', 'multiply',
'onesuperior', 'twosuperior', 'threesuperior', 'onehalf', 'onequarter',
'threequarters', 'franc', 'Gbreve', 'gbreve', 'Idotaccent', 'Scedilla',
'scedilla', 'Cacute', 'cacute', 'Ccaron', 'ccaron', 'dcroat'];
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
function getUnicodeRangeFor(value) {
First iteration, tracemonkey/ecma262 working
2011-11-03 03:43:27 +09:00
for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) {
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
var range = UnicodeRanges[i];
if (value >= range.begin && value < range.end)
return i;
}
return -1;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
}
Start adding a FontLoader class to isolate the font-loaded hack
2011-06-24 18:47:22 +09:00
Change cmap encoding for Type 1
2011-10-29 23:29:19 +09:00
function isSpecialUnicode(unicode) {
return (unicode <= 0x1F || (unicode >= 127 && unicode < kSizeOfGlyphArea)) ||
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
(unicode >= kCmapGlyphOffset &&
unicode < kCmapGlyphOffset + kSizeOfGlyphArea);
Change cmap encoding for Type 1
2011-10-29 23:29:19 +09:00
}
Add the beginning of a Type1 to Type2 charstring converter
2011-06-10 08:20:00 +09:00
/**
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
* 'Font' is the class the outside world should use, it encapsulate all the font
* decoding logics whatever type it is (assuming the font type is supported).
*
* For example to read a Type1 font and to attach it to the document:
Clean up some debug leftovers
2011-06-17 20:55:42 +09:00
* var type1Font = new Font("MyFontName", binaryFile, propertiesObject);
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
* type1Font.bind();
Remove some debug leftover
2011-06-04 00:54:40 +09:00
*/
Name all constructors.
2011-12-09 07:18:43 +09:00
var Font = (function FontClosure() {
function Font(name, file, properties) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
this.name = name;
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
this.coded = properties.coded;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.charProcIRQueues = properties.charProcIRQueues;
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
this.resources = properties.resources;
cleanup
2011-07-21 09:10:04 +09:00
this.sizes = [];
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
var names = name.split('+');
Add a list of common serif fonts to not always fallback on sans-serif if the font file is missing
2011-09-07 07:29:08 +09:00
names = names.length > 1 ? names[1] : names[0];
names = names.split(/[-,_]/g)[0];
using font flags to recognize the symbol and serif fonts; using the encoding instead of predefined MacRoman in TrueType fonts
2012-01-10 10:36:24 +09:00
this.isSerifFont = !!(properties.flags & 2);
this.isSymbolicFont = !!(properties.flags & 4);
Add a list of common serif fonts to not always fallback on sans-serif if the font file is missing
2011-09-07 07:29:08 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var type = properties.type;
this.type = type;
Rename s2a, s16, s32 and do some dance inside the bind() code
2011-06-21 11:30:28 +09:00
// If the font is to be ignored, register it like an already loaded font
// to avoid the cost of waiting for it be be loaded by the platform.
remove fontCount/fontName/kDisableFonts debug hacks and fix bug in font loading
2011-07-07 14:14:48 +09:00
if (properties.ignore) {
using font flags to recognize the symbol and serif fonts; using the encoding instead of predefined MacRoman in TrueType fonts
2012-01-10 10:36:24 +09:00
this.loadedName = this.isSerifFont ? 'serif' : 'sans-serif';
Support standards fonts
2011-07-25 23:42:46 +09:00
this.loading = false;
return;
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.differences = properties.differences;
this.widths = properties.widths;
this.defaultWidth = properties.defaultWidth;
this.composite = properties.composite;
TrueType encoding for files without font data
2011-10-29 22:45:29 +09:00
this.hasEncoding = properties.hasEncoding;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
this.fontMatrix = properties.fontMatrix;
Fixing base encoding presence detection; character width scale
2011-11-30 13:06:00 +09:00
this.widthMultiplier = 1.0;
(#867) Set Type3 font encoding; enable text selection testing
2011-12-05 04:51:12 +09:00
if (properties.type == 'Type3') {
this.encoding = properties.baseEncoding;
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
return;
(#867) Set Type3 font encoding; enable text selection testing
2011-12-05 04:51:12 +09:00
}
Support standards fonts
2011-07-25 23:42:46 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
// Trying to fix encoding using glyph CIDSystemInfo.
this.loadCidToUnicode(properties);
Support standards fonts
2011-07-25 23:42:46 +09:00
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
if (properties.toUnicode)
this.toUnicode = properties.toUnicode;
else
this.rebuildToUnicode(properties);
Support standards fonts
2011-07-25 23:42:46 +09:00
if (!file) {
Fixing bad comment
2011-08-15 02:11:23 +09:00
// The file data is not specified. Trying to fix the font name
BaseFont and misc fonts fixes
2011-08-14 22:40:22 +09:00
// to be used with the canvas.font.
Initial merge of master.
2011-10-20 03:14:13 +09:00
var fontName = name.replace(/[,_]/g, '-');
fontName = stdFontMap[fontName] || fontName;
Be more generic for bold/italic rules
2011-09-10 23:47:58 +09:00
this.bold = (fontName.search(/bold/gi) != -1);
this.italic = (fontName.search(/oblique/gi) != -1) ||
(fontName.search(/italic/gi) != -1);
Simulate Arial Black and Arial Narrow
2011-09-01 11:06:33 +09:00
// Use 'name' instead of 'fontName' here because the original
Use the built-in widths to calculate glyphs metrics
2011-09-09 08:35:37 +09:00
// name ArialBlack for example will be replaced by Helvetica.
Fix gjslint warnings.
2011-09-13 02:42:55 +09:00
this.black = (name.search(/Black/g) != -1);
Simulate Arial Black and Arial Narrow
2011-09-01 11:06:33 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.encoding = properties.baseEncoding;
this.noUnicodeAdaptation = true;
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
this.loadedName = fontName.split('-')[0];
Support standards fonts
2011-07-25 23:42:46 +09:00
this.loading = false;
Merge with master
2011-06-21 09:35:14 +09:00
return;
}
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
Start adding a FontLoader class to isolate the font-loaded hack
2011-06-24 18:47:22 +09:00
var data;
Fix tests failure by cloning the GlyphsUnicode object
2011-09-22 20:39:28 +09:00
switch (type) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case 'Type1':
cleanup, added new flag to the font properties called compositeFont. If true, the encoding and ShowText strings must be multi-byte
2011-07-12 11:58:09 +09:00
case 'CIDFontType0':
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
this.mimetype = 'font/opentype';
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
extracted filetype in pdf.js instead of fonts.js
2011-07-21 03:25:00 +09:00
var subtype = properties.subtype;
Fix tests failure by cloning the GlyphsUnicode object
2011-09-22 20:39:28 +09:00
var cff = (subtype == 'Type1C' || subtype == 'CIDFontType0C') ?
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
new Type2CFF(file, properties) : new CFF(name, file, properties);
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
Merge with master
2011-06-21 09:35:14 +09:00
// Wrap the CFF data inside an OTF font file
Start adding a FontLoader class to isolate the font-loaded hack
2011-06-24 18:47:22 +09:00
data = this.convert(name, cff, properties);
Merge with master
2011-06-21 09:35:14 +09:00
break;
Add a root 'Font' class as the outside world API
2011-06-13 08:38:05 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case 'TrueType':
cleanup, added new flag to the font properties called compositeFont. If true, the encoding and ShowText strings must be multi-byte
2011-07-12 11:58:09 +09:00
case 'CIDFontType2':
Second pass CIDFont support - make Arial Unicode in OpenOffice PDF - supports PDF fonts with CIDtoGIDMap and no cmap
2011-07-12 01:41:47 +09:00
this.mimetype = 'font/opentype';
If the glyph is not indexed, ignore it completely in getOrderedCharstrings
2011-08-26 22:30:26 +09:00
// Repair the TrueType file. It is can be damaged in the point of
Second pass CIDFont support - make Arial Unicode in OpenOffice PDF - supports PDF fonts with CIDtoGIDMap and no cmap
2011-07-12 01:41:47 +09:00
// view of the sanitizer
data = this.checkAndRepair(name, file, properties);
break;
Merge with master
2011-06-21 09:35:14 +09:00
default:
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
warn('Font ' + properties.type + ' is not supported');
Merge with master
2011-06-21 09:35:14 +09:00
break;
Use spaces to compare font size to detect when the @font-face rule works, this seems to be more accurate
2011-06-16 08:30:47 +09:00
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
First pass on FontWorker
2011-06-27 03:55:27 +09:00
this.data = data;
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
this.fontMatrix = properties.fontMatrix;
Fixing base encoding presence detection; character width scale
2011-11-30 13:06:00 +09:00
this.widthMultiplier = !properties.fontMatrix ? 1.0 :
1.0 / properties.fontMatrix[0];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.encoding = properties.baseEncoding;
this.hasShortCmap = properties.hasShortCmap;
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
this.loadedName = getUniqueName();
Support standards fonts
2011-07-25 23:42:46 +09:00
this.loading = true;
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
};
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
var numFonts = 0;
function getUniqueName() {
return 'pdfFont' + numFonts++;
}
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
function stringToArray(str) {
var array = [];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = str.length; i < ii; ++i)
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
array[i] = str.charCodeAt(i);
return array;
};
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
function arrayToString(arr) {
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
var str = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = arr.length; i < ii; ++i)
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
str += String.fromCharCode(arr[i]);
return str;
};
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
function int16(bytes) {
return (bytes[0] << 8) + (bytes[1] & 0xff);
};
function int32(bytes) {
return (bytes[0] << 24) + (bytes[1] << 16) +
(bytes[2] << 8) + (bytes[3] & 0xff);
};
function getMaxPower2(number) {
var maxPower = 0;
var value = number;
while (value >= 2) {
value /= 2;
maxPower++;
}
value = 2;
for (var i = 1; i < maxPower; i++)
value *= 2;
return value;
};
Filled notdef in the cmap table
2011-06-28 20:06:31 +09:00
function string16(value) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
return String.fromCharCode((value >> 8) & 0xff) +
String.fromCharCode(value & 0xff);
};
Fixing missing text (#886)
2011-12-07 13:13:14 +09:00
function safeString16(value) {
// clamp value to the 16-bit int range
value = value > 0x7FFF ? 0x7FFF : value < -0x8000 ? -0x8000 : value;
return String.fromCharCode((value >> 8) & 0xff) +
String.fromCharCode(value & 0xff);
};
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
function string32(value) {
return String.fromCharCode((value >> 24) & 0xff) +
String.fromCharCode((value >> 16) & 0xff) +
String.fromCharCode((value >> 8) & 0xff) +
String.fromCharCode(value & 0xff);
};
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
function createOpenTypeHeader(sfnt, file, numTables) {
Add opentype ascender, descender and units-per-em to font properties Prefer font ascender, descender when creating OS/2 table scale PDF ascender and descender in OS/2 table by font units per em if it exists Fix the truetype font header to prevent Windows rejecting a Mac truetype font
2011-09-16 21:50:11 +09:00
// Windows hates the Mac TrueType sfnt version number
if (sfnt == 'true')
sfnt = string32(0x00010000);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// sfnt version (4 bytes)
var header = sfnt;
// numTables (2 bytes)
header += string16(numTables);
// searchRange (2 bytes)
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var tablesMaxPower2 = getMaxPower2(numTables);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var searchRange = tablesMaxPower2 * 16;
header += string16(searchRange);
// entrySelector (2 bytes)
header += string16(Math.log(tablesMaxPower2) / Math.log(2));
// rangeShift (2 bytes)
header += string16(numTables * 16 - searchRange);
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
file.file += header;
file.virtualOffset += header.length;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
function createTableEntry(file, tag, data) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// offset
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
var offset = file.virtualOffset;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
Do not include the padding size in the length declared in the table header
2011-06-30 04:30:25 +09:00
// length
var length = data.length;
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// Per spec tables must be 4-bytes align so add padding as needed
while (data.length & 3)
data.push(0x00);
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
while (file.virtualOffset & 3)
file.virtualOffset++;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// checksum
fixing CFF things to pass FontValidator
2011-07-06 22:12:41 +09:00
var checksum = 0, n = data.length;
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
for (var i = 0; i < n; i += 4)
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
checksum = (checksum + int32([data[i], data[i + 1], data[i + 2],
data[i + 3]])) | 0;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var tableEntry = (tag + string32(checksum) +
string32(offset) + string32(length));
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
file.file += tableEntry;
file.virtualOffset += data.length;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
function getRanges(glyphs) {
// Array.sort() sorts by characters, not numerically, so convert to an
// array of characters.
var codes = [];
var length = glyphs.length;
for (var n = 0; n < length; ++n)
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
codes.push({ unicode: glyphs[n].unicode, code: n });
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
codes.sort(function fontGetRangesSort(a, b) {
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
return a.unicode - b.unicode;
});
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// Split the sorted codes into ranges.
var ranges = [];
for (var n = 0; n < length; ) {
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
var start = codes[n].unicode;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var codeIndices = [codes[n].code];
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
++n;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var end = start;
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
while (n < length && end + 1 == codes[n].unicode) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
codeIndices.push(codes[n].code);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
++end;
++n;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
ranges.push([start, end, codeIndices]);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
}
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
return ranges;
};
Add a simpler path for cmap format 0 to cmap format 4
2011-07-20 21:29:07 +09:00
function createCMapTable(glyphs, deltas) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var ranges = getRanges(glyphs);
Remove cmap format 100, fixes some nits to merge with upstream
2011-07-02 12:46:50 +09:00
var numTables = 1;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var cmap = '\x00\x00' + // version
Add a format100 table for Mac
2011-07-02 09:44:57 +09:00
string16(numTables) + // numTables
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x03' + // platformID
'\x00\x01' + // encodingID
Remove cmap format 100, fixes some nits to merge with upstream
2011-07-02 12:46:50 +09:00
string32(4 + numTables * 8); // start of the table record
Add a format100 table for Mac
2011-07-02 09:44:57 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var segCount = ranges.length + 1;
var segCount2 = segCount * 2;
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var searchRange = getMaxPower2(segCount) * 2;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var searchEntry = Math.log(segCount) / Math.log(2);
var rangeShift = 2 * segCount - searchRange;
// Fill up the 4 parallel arrays describing the segments.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var startCount = '';
var endCount = '';
var idDeltas = '';
var idRangeOffsets = '';
var glyphsIds = '';
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var bias = 0;
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
if (deltas) {
for (var i = 0; i < segCount - 1; i++) {
var range = ranges[i];
var start = range[0];
var end = range[1];
var offset = (segCount - i) * 2 + bias * 2;
bias += (end - start + 1);
startCount += string16(start);
endCount += string16(end);
idDeltas += string16(0);
idRangeOffsets += string16(offset);
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var codes = range[2];
for (var j = 0, jj = codes.length; j < jj; ++j)
glyphsIds += string16(deltas[codes[j]]);
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
}
} else {
for (var i = 0; i < segCount - 1; i++) {
var range = ranges[i];
var start = range[0];
var end = range[1];
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var startCode = range[2][0];
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
startCount += string16(start);
endCount += string16(end);
idDeltas += string16((startCode - start + 1) & 0xFFFF);
idRangeOffsets += string16(0);
}
}
Add a simpler path for cmap format 0 to cmap format 4
2011-07-20 21:29:07 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
endCount += '\xFF\xFF';
startCount += '\xFF\xFF';
idDeltas += '\x00\x01';
idRangeOffsets += '\x00\x00';
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
var format314 = '\x00\x00' + // language
string16(segCount2) +
string16(searchRange) +
string16(searchEntry) +
string16(rangeShift) +
endCount + '\x00\x00' + startCount +
idDeltas + idRangeOffsets + glyphsIds;
return stringToArray(cmap +
'\x00\x04' + // format
string16(format314.length + 4) + // length
format314);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
function createOS2Table(properties, charstrings, override) {
Initial merge of master.
2011-10-20 03:14:13 +09:00
override = override || {
unitsPerEm: 0,
yMax: 0,
yMin: 0,
ascent: 0,
descent: 0
};
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
var ulUnicodeRange1 = 0;
var ulUnicodeRange2 = 0;
var ulUnicodeRange3 = 0;
var ulUnicodeRange4 = 0;
Clean up a bit the encoding/charset/glyphs dance
2011-08-30 07:56:02 +09:00
var firstCharIndex = null;
var lastCharIndex = 0;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (charstrings) {
for (var i = 0; i < charstrings.length; ++i) {
var code = charstrings[i].unicode;
if (firstCharIndex > code || !firstCharIndex)
firstCharIndex = code;
if (lastCharIndex < code)
lastCharIndex = code;
var position = getUnicodeRangeFor(code);
if (position < 32) {
ulUnicodeRange1 |= 1 << position;
} else if (position < 64) {
ulUnicodeRange2 |= 1 << position - 32;
} else if (position < 96) {
ulUnicodeRange3 |= 1 << position - 64;
} else if (position < 123) {
ulUnicodeRange4 |= 1 << position - 96;
} else {
error('Unicode ranges Bits > 123 are reserved for internal usage');
}
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
} else {
// TODO
firstCharIndex = 0;
lastCharIndex = 255;
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
}
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
var unitsPerEm = override.unitsPerEm || kPDFGlyphSpaceUnits;
var typoAscent = override.ascent || properties.ascent;
var typoDescent = override.descent || properties.descent;
var winAscent = override.yMax || typoAscent;
var winDescent = -override.yMin || -typoDescent;
Fixing lint long lines warnings
2011-09-17 09:53:52 +09:00
// if there is a units per em value but no other override
// then scale the calculated ascent
if (unitsPerEm != kPDFGlyphSpaceUnits &&
'undefined' == typeof(override.ascent)) {
// if the font units differ to the PDF glyph space units
// then scale up the values
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
typoAscent = Math.round(typoAscent * unitsPerEm / kPDFGlyphSpaceUnits);
typoDescent = Math.round(typoDescent * unitsPerEm / kPDFGlyphSpaceUnits);
winAscent = typoAscent;
winDescent = -typoDescent;
Add opentype ascender, descender and units-per-em to font properties Prefer font ascender, descender when creating OS/2 table scale PDF ascender and descender in OS/2 table by font units per em if it exists Fix the truetype font header to prevent Windows rejecting a Mac truetype font
2011-09-16 21:50:11 +09:00
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
return '\x00\x03' + // version
'\x02\x24' + // xAvgCharWidth
'\x01\xF4' + // usWeightClass
'\x00\x05' + // usWidthClass
'\x00\x00' + // fstype (0 to let the font loads via font-face on IE)
'\x02\x8A' + // ySubscriptXSize
'\x02\xBB' + // ySubscriptYSize
'\x00\x00' + // ySubscriptXOffset
'\x00\x8C' + // ySubscriptYOffset
'\x02\x8A' + // ySuperScriptXSize
'\x02\xBB' + // ySuperScriptYSize
'\x00\x00' + // ySuperScriptXOffset
'\x01\xDF' + // ySuperScriptYOffset
'\x00\x31' + // yStrikeOutSize
'\x01\x02' + // yStrikeOutPosition
'\x00\x00' + // sFamilyClass
'\x00\x00\x06' +
String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) +
'\x00\x00\x00\x00\x00\x00' + // Panose
Add better informations for the OS/2 table
2011-06-30 09:52:47 +09:00
string32(ulUnicodeRange1) + // ulUnicodeRange1 (Bits 0-31)
string32(ulUnicodeRange2) + // ulUnicodeRange2 (Bits 32-63)
string32(ulUnicodeRange3) + // ulUnicodeRange3 (Bits 64-95)
string32(ulUnicodeRange4) + // ulUnicodeRange4 (Bits 96-127)
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x2A\x32\x31\x2A' + // achVendID
Fix more headers tables
2011-06-30 18:48:43 +09:00
string16(properties.italicAngle ? 1 : 0) + // fsSelection
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
string16(firstCharIndex ||
properties.firstChar) + // usFirstCharIndex
Make windows table header more compatible with windows
2011-06-30 12:38:10 +09:00
string16(lastCharIndex || properties.lastChar) + // usLastCharIndex
Add opentype ascender, descender and units-per-em to font properties Prefer font ascender, descender when creating OS/2 table scale PDF ascender and descender in OS/2 table by font units per em if it exists Fix the truetype font header to prevent Windows rejecting a Mac truetype font
2011-09-16 21:50:11 +09:00
string16(typoAscent) + // sTypoAscender
string16(typoDescent) + // sTypoDescender
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x64' + // sTypoLineGap (7%-10% of the unitsPerEM value)
Add opentype ascender, descender and units-per-em to font properties Prefer font ascender, descender when creating OS/2 table scale PDF ascender and descender in OS/2 table by font units per em if it exists Fix the truetype font header to prevent Windows rejecting a Mac truetype font
2011-09-16 21:50:11 +09:00
string16(winAscent) + // usWinAscent
string16(winDescent) + // usWinDescent
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x00\x00\x00' + // ulCodePageRange1 (Bits 0-31)
'\x00\x00\x00\x00' + // ulCodePageRange2 (Bits 32-63)
string16(properties.xHeight) + // sxHeight
Remove some hardcoded glue
2011-06-24 06:15:22 +09:00
string16(properties.capHeight) + // sCapHeight
Map .notdef in order to attach the [missing|break]Char to it
2011-06-30 10:01:46 +09:00
string16(0) + // usDefaultChar
Make windows table header more compatible with windows
2011-06-30 12:38:10 +09:00
string16(firstCharIndex || properties.firstChar) + // usBreakChar
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x03'; // usMaxContext
Add a createPostTable function and remove the useless join('') calls
2011-06-24 05:11:16 +09:00
};
Remove some hardcoded glue
2011-06-24 06:15:22 +09:00
function createPostTable(properties) {
Fix more headers tables
2011-06-30 18:48:43 +09:00
var angle = Math.floor(properties.italicAngle * (Math.pow(2, 16)));
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
return '\x00\x03\x00\x00' + // Version number
string32(angle) + // italicAngle
'\x00\x00' + // underlinePosition
'\x00\x00' + // underlineThickness
Fix more headers tables
2011-06-30 18:48:43 +09:00
string32(properties.fixedPitch) + // isFixedPitch
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x00\x00\x00' + // minMemType42
'\x00\x00\x00\x00' + // maxMemType42
'\x00\x00\x00\x00' + // minMemType1
'\x00\x00\x00\x00'; // maxMemType1
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
function createNameTable(name) {
var strings = [
'Original licence', // 0.Copyright
name, // 1.Font family
'Unknown', // 2.Font subfamily (font weight)
'uniqueID', // 3.Unique ID
name, // 4.Full font name
'Version 0.11', // 5.Version
'', // 6.Postscript name
'Unknown', // 7.Trademark
'Unknown', // 8.Manufacturer
'Unknown' // 9.Designer
];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
// Mac want 1-byte per character strings while Windows want
// 2-bytes per character, so duplicate the names table
var stringsUnicode = [];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = strings.length; i < ii; i++) {
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var str = strings[i];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var strUnicode = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var j = 0, jj = str.length; j < jj; j++)
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
strUnicode += string16(str.charCodeAt(j));
stringsUnicode.push(strUnicode);
}
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var names = [strings, stringsUnicode];
var platforms = ['\x00\x01', '\x00\x03'];
var encodings = ['\x00\x00', '\x00\x01'];
var languages = ['\x00\x00', '\x04\x09'];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var namesRecordCount = strings.length * platforms.length;
var nameTable =
'\x00\x00' + // format
string16(namesRecordCount) + // Number of names Record
string16(namesRecordCount * 12 + 6); // Storage
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
// Build the name records field
var strOffset = 0;
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = platforms.length; i < ii; i++) {
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var strs = names[i];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var j = 0, jj = strs.length; j < jj; j++) {
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
var str = strs[j];
var nameRecord =
platforms[i] + // platform ID
encodings[i] + // encoding ID
languages[i] + // language ID
string16(j) + // name ID
string16(str.length) +
string16(strOffset);
nameTable += nameRecord;
strOffset += str.length;
}
}
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
nameTable += strings.join('') + stringsUnicode.join('');
return nameTable;
}
Name all constructors.
2011-12-09 07:18:43 +09:00
Font.prototype = {
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
name: null,
font: null,
mimetype: null,
Merge with master
2011-06-21 09:35:14 +09:00
encoding: null,
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
checkAndRepair: function font_checkAndRepair(name, font, properties) {
function readTableEntry(file) {
var tag = file.getBytes(4);
tag = String.fromCharCode(tag[0]) +
String.fromCharCode(tag[1]) +
String.fromCharCode(tag[2]) +
String.fromCharCode(tag[3]);
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var checksum = int32(file.getBytes(4));
var offset = int32(file.getBytes(4));
var length = int32(file.getBytes(4));
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// Read the table associated data
Start displaying TrueType fonts
2011-06-22 04:11:59 +09:00
var previousPosition = file.pos;
file.pos = file.start ? file.start : 0;
file.skip(offset);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var data = file.getBytes(length);
Start displaying TrueType fonts
2011-06-22 04:11:59 +09:00
file.pos = previousPosition;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
Fix OS/2 table to match font yMax and yMin from head table
2011-09-16 07:23:22 +09:00
if (tag == 'head') {
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
// clearing checksum adjustment
data[8] = data[9] = data[10] = data[11] = 0;
Fix OS/2 table to match font yMax and yMin from head table
2011-09-16 07:23:22 +09:00
data[17] |= 0x20; //Set font optimized for cleartype flag
}
Clearing font checksum adjustment field
2011-07-11 06:47:09 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
return {
tag: tag,
checksum: checksum,
Switch length versus offset mistake in readTableEntry
2011-07-15 23:02:32 +09:00
length: length,
offset: offset,
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
data: data
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
};
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
Make the fonts decoding code works with asynchronous data url
2011-06-14 11:35:46 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
function readOpenTypeHeader(ttf) {
return {
Fix lying sfnt header for some CFF font that pretend to be TrueType and fix unknown unicode glyphs when building from Type1
2011-08-26 21:21:25 +09:00
version: arrayToString(ttf.getBytes(4)),
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
numTables: int16(ttf.getBytes(2)),
searchRange: int16(ttf.getBytes(2)),
entrySelector: int16(ttf.getBytes(2)),
rangeShift: int16(ttf.getBytes(2))
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
};
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
};
Move the Type2 utils to a new file and create a Stack object
2011-06-10 09:07:41 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
function createGlyphNameMap(glyphs, ids, properties) {
var glyphNames = properties.glyphNames;
if (!glyphNames) {
properties.glyphNameMap = {};
return;
}
var glyphsLength = glyphs.length;
var glyphNameMap = {};
var encoding = [];
for (var i = 0; i < glyphsLength; ++i) {
var glyphName = glyphNames[ids[i]];
if (!glyphName)
continue;
var unicode = glyphs[i].unicode;
glyphNameMap[glyphName] = unicode;
var code = glyphs[i].code;
encoding[code] = glyphName;
}
properties.glyphNameMap = glyphNameMap;
if (!properties.hasEncoding)
properties.baseEncoding = encoding;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
function readCMapTable(cmap, font) {
Switch length versus offset mistake in readTableEntry
2011-07-15 23:02:32 +09:00
var start = (font.start ? font.start : 0) + cmap.offset;
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
font.pos = start;
Reland commit 442d184 but make it works with uncompressed PDF
2011-07-02 07:19:24 +09:00
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var version = int16(font.getBytes(2));
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
var numRecords = int16(font.getBytes(2));
var records = [];
for (var i = 0; i < numRecords; i++) {
records.push({
platformID: int16(font.getBytes(2)),
encodingID: int16(font.getBytes(2)),
offset: int32(font.getBytes(4))
});
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
}
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
Fix cmap encoding records to pass the sanitizer in the case of a duplicate platform: 1, encoding: 0
2011-09-06 22:12:33 +09:00
// Check that table are sorted by platformID then encodingID,
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
records.sort(function fontReadCMapTableSort(a, b) {
Fix review comments from #424
2011-09-07 07:19:58 +09:00
return ((a.platformID << 16) + a.encodingID) -
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
((b.platformID << 16) + b.encodingID);
Fix review comments from #424
2011-09-07 07:19:58 +09:00
});
Fix cmap encoding records to pass the sanitizer in the case of a duplicate platform: 1, encoding: 0
2011-09-06 22:12:33 +09:00
var tables = [records[0]];
for (var i = 1; i < numRecords; i++) {
// The sanitizer will drop the font if 2 tables have the same
// platformID and the same encodingID, this will be correct for
// most cases but if the font has been made for Mac it could
// exist a few platformID: 1, encodingID: 0 but with a different
// language field and that's correct. But the sanitizer does not
// seem to support this case.
var current = records[i];
var previous = records[i - 1];
if (((current.platformID << 16) + current.encodingID) <=
((previous.platformID << 16) + previous.encodingID))
continue;
tables.push(current);
}
var missing = numRecords - tables.length;
Fix review comments from #424
2011-09-07 07:19:58 +09:00
if (missing) {
Fix cmap encoding records to pass the sanitizer in the case of a duplicate platform: 1, encoding: 0
2011-09-06 22:12:33 +09:00
numRecords = tables.length;
var data = string16(version) + string16(numRecords);
for (var i = 0; i < numRecords; i++) {
var table = tables[i];
data += string16(table.platformID) +
string16(table.encodingID) +
string32(table.offset);
}
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = data.length; i < ii; i++)
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
cmap.data[i] = data.charCodeAt(i);
Fix cmap encoding records to pass the sanitizer in the case of a duplicate platform: 1, encoding: 0
2011-09-06 22:12:33 +09:00
}
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
for (var i = 0; i < numRecords; i++) {
Fix cmap encoding records to pass the sanitizer in the case of a duplicate platform: 1, encoding: 0
2011-09-06 22:12:33 +09:00
var table = tables[i];
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
font.pos = start + table.offset;
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var format = int16(font.getBytes(2));
var length = int16(font.getBytes(2));
var language = int16(font.getBytes(2));
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (format == 0) {
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Characters below 0x20 are controls characters that are hardcoded
// into the platform so if some characters in the font are assigned
// under this limit they will not be displayed so let's rewrite the
// CMap.
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
var glyphs = [];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var ids = [];
Add a simpler path for cmap format 0 to cmap format 4
2011-07-20 21:29:07 +09:00
for (var j = 0; j < 256; j++) {
var index = font.getByte();
if (index) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
glyphs.push({ unicode: j, code: j });
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
ids.push(index);
}
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
return {
glyphs: glyphs,
ids: ids,
hasShortCmap: true
};
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
} else if (format == 4) {
// re-creating the table in format 4 since the encoding
// might be changed
var segCount = (int16(font.getBytes(2)) >> 1);
font.getBytes(6); // skipping range fields
var segIndex, segments = [];
for (segIndex = 0; segIndex < segCount; segIndex++) {
segments.push({ end: int16(font.getBytes(2)) });
}
font.getBytes(2);
for (segIndex = 0; segIndex < segCount; segIndex++) {
segments[segIndex].start = int16(font.getBytes(2));
}
for (segIndex = 0; segIndex < segCount; segIndex++) {
segments[segIndex].delta = int16(font.getBytes(2));
}
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var offsetsCount = 0;
for (segIndex = 0; segIndex < segCount; segIndex++) {
var segment = segments[segIndex];
var rangeOffset = int16(font.getBytes(2));
if (!rangeOffset) {
segment.offsetIndex = -1;
continue;
Fix a little typo
2011-08-30 07:59:37 +09:00
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var offsetIndex = (rangeOffset >> 1) - (segCount - segIndex);
segment.offsetIndex = offsetIndex;
offsetsCount = Math.max(offsetsCount, offsetIndex +
segment.end - segment.start + 1);
Merge with upstream
2011-07-20 22:18:44 +09:00
}
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var offsets = [];
for (var j = 0; j < offsetsCount; j++)
offsets.push(int16(font.getBytes(2)));
var glyphs = [], ids = [];
for (segIndex = 0; segIndex < segCount; segIndex++) {
var segment = segments[segIndex];
var start = segment.start, end = segment.end;
var delta = segment.delta, offsetIndex = segment.offsetIndex;
for (var j = start; j <= end; j++) {
if (j == 0xFFFF)
continue;
var glyphCode = offsetIndex < 0 ? j :
offsets[offsetIndex + j - start];
glyphCode = (glyphCode + delta) & 0xFFFF;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
if (glyphCode == 0)
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
continue;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
glyphs.push({ unicode: j, code: j });
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
ids.push(glyphCode);
}
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
return {
glyphs: glyphs,
ids: ids
};
Clean up a bit the encoding/charset/glyphs dance
2011-08-30 07:56:02 +09:00
} else if (format == 6) {
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
// Format 6 is a 2-bytes dense mapping, which means the font data
// lives glue together even if they are pretty far in the unicode
Start of a TTF Format6 to Format4 converter (sigh)
2011-06-22 14:46:41 +09:00
// table. (This looks weird, so I can have missed something), this
// works on Linux but seems to fails on Mac so let's rewrite the
// cmap table to a 3-1-4 style
Get rid of FontsUtils
2011-07-02 14:54:28 +09:00
var firstCode = int16(font.getBytes(2));
var entryCount = int16(font.getBytes(2));
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
Start of a TTF Format6 to Format4 converter (sigh)
2011-06-22 14:46:41 +09:00
var glyphs = [];
Simplify the cmap format 6 conversion - fix #449
2011-09-10 20:41:07 +09:00
var ids = [];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
for (var j = 0; j < entryCount; j++) {
var glyphCode = int16(font.getBytes(2));
var code = firstCode + j;
Fixing duplicates in cmap
2011-10-30 11:55:43 +09:00
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
glyphs.push({ unicode: code, code: code });
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
ids.push(glyphCode);
Add more glue between glyph mapping and code mapping
2011-09-08 10:16:33 +09:00
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
return {
glyphs: glyphs,
ids: ids
};
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
}
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
error('Unsupported cmap table format');
Support Format 6 cmap table, but does not pass the sanitizer yet
2011-06-22 11:41:31 +09:00
};
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
function sanitizeMetrics(font, header, metrics, numGlyphs) {
if (!header && !metrics)
return;
// The vhea/vmtx tables are not required, so it happens that
// some fonts embed a vmtx table without a vhea table. In this
// situation the sanitizer assume numOfLongVerMetrics = 1. As
// a result it tries to read numGlyphs - 1 SHORT from the vmtx
// table, and if it is not possible, the font is rejected.
// So remove the vmtx table if there is no vhea table.
if (!header && metrics) {
metrics.data = null;
return;
}
font.pos = (font.start ? font.start : 0) + header.offset;
font.pos += header.length - 2;
var numOfMetrics = int16(font.getBytes(2));
Fix gjslint warnings.
2011-09-13 02:42:55 +09:00
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
var numOfSidebearings = numGlyphs - numOfMetrics;
var numMissing = numOfSidebearings -
((hmtx.length - numOfMetrics * 4) >> 1);
if (numMissing > 0) {
font.pos = (font.start ? font.start : 0) + metrics.offset;
var entries = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = hmtx.length; i < ii; i++)
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
entries += String.fromCharCode(font.getByte());
for (var i = 0; i < numMissing; i++)
entries += '\x00\x00';
metrics.data = stringToArray(entries);
}
};
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
function sanitizeGlyphLocations(loca, glyf, numGlyphs,
isGlyphLocationsLong) {
var itemSize, itemDecode, itemEncode;
if (isGlyphLocationsLong) {
itemSize = 4;
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
itemDecode = function fontItemDecodeLong(data, offset) {
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
return (data[offset] << 24) | (data[offset + 1] << 16) |
(data[offset + 2] << 8) | data[offset + 3];
};
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
itemEncode = function fontItemEncodeLong(data, offset, value) {
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
data[offset] = (value >>> 24) & 0xFF;
data[offset + 1] = (value >> 16) & 0xFF;
data[offset + 2] = (value >> 8) & 0xFF;
data[offset + 3] = value & 0xFF;
};
} else {
itemSize = 2;
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
itemDecode = function fontItemDecode(data, offset) {
Fix for 16-bit 'loca' table
2011-09-19 12:44:25 +09:00
return (data[offset] << 9) | (data[offset + 1] << 1);
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
};
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
itemEncode = function fontItemEncode(data, offset, value) {
Fix for 16-bit 'loca' table
2011-09-19 12:44:25 +09:00
data[offset] = (value >> 9) & 0xFF;
data[offset + 1] = (value >> 1) & 0xFF;
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
};
}
var locaData = loca.data;
var startOffset = itemDecode(locaData, 0);
var firstOffset = itemDecode(locaData, itemSize);
if (firstOffset - startOffset < 12 || startOffset > 0) {
// removing first glyph
glyf.data = glyf.data.subarray(firstOffset);
glyf.length -= firstOffset;
itemEncode(locaData, 0, 0);
var i, pos = itemSize;
for (i = 1; i <= numGlyphs; ++i) {
itemEncode(locaData, pos,
itemDecode(locaData, pos) - firstOffset);
pos += itemSize;
}
}
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
function readGlyphNameMap(post, properties) {
var start = (font.start ? font.start : 0) + post.offset;
font.pos = start;
var length = post.length, end = start + length;
var version = int32(font.getBytes(4));
// skip rest to the tables
font.getBytes(28);
var glyphNames;
switch (version) {
case 0x00010000:
glyphNames = MacStandardGlyphOrdering;
break;
case 0x00020000:
var numGlyphs = int16(font.getBytes(2));
var glyphNameIndexes = [];
for (var i = 0; i < numGlyphs; ++i)
glyphNameIndexes.push(int16(font.getBytes(2)));
var customNames = [];
while (font.pos < end) {
var stringLength = font.getByte();
var string = '';
for (var i = 0; i < stringLength; ++i)
string += font.getChar();
customNames.push(string);
}
glyphNames = [];
for (var i = 0; i < numGlyphs; ++i) {
var j = glyphNameIndexes[i];
if (j < 258) {
glyphNames.push(MacStandardGlyphOrdering[j]);
continue;
}
glyphNames.push(customNames[j - 258]);
}
break;
case 0x00030000:
break;
default:
warn('Unknown/unsupported post table version ' + version);
break;
}
properties.glyphNames = glyphNames;
}
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
// Check that required tables are present
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var requiredTables = ['OS/2', 'cmap', 'head', 'hhea',
'hmtx', 'maxp', 'name', 'post'];
Rename s2a, s16, s32 and do some dance inside the bind() code
2011-06-21 11:30:28 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var header = readOpenTypeHeader(font);
var numTables = header.numTables;
Make the Type1 to OTF code active, even if the sanitizer prevent fonts to load at the moment
2011-06-12 10:00:45 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var cmap, post, maxp, hhea, hmtx, vhea, vmtx, head, loca, glyf;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var tables = [];
for (var i = 0; i < numTables; i++) {
var table = readTableEntry(font);
var index = requiredTables.indexOf(table.tag);
if (index != -1) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
if (table.tag == 'cmap')
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
cmap = table;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
else if (table.tag == 'post')
post = table;
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
else if (table.tag == 'maxp')
maxp = table;
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
else if (table.tag == 'hhea')
hhea = table;
else if (table.tag == 'hmtx')
hmtx = table;
Fix OS/2 table to match font yMax and yMin from head table
2011-09-16 07:23:22 +09:00
else if (table.tag == 'head')
head = table;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
requiredTables.splice(index, 1);
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
} else {
if (table.tag == 'vmtx')
vmtx = table;
else if (table.tag == 'vhea')
vhea = table;
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
else if (table.tag == 'loca')
loca = table;
else if (table.tag == 'glyf')
glyf = table;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
}
tables.push(table);
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
Add a the beggining of a Type1 font reader
2011-06-01 03:22:05 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
var numTables = header.numTables + requiredTables.length;
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
// header and new offsets. Table entry information is appended to the
// end of file. The virtualOffset represents where to put the actual
// data of a particular table;
var ttf = {
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
file: '',
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
virtualOffset: numTables * (4 * 4)
cleanup
2011-08-19 12:40:16 +09:00
};
Prepare the way to decode Type1 charStrings
2011-06-01 18:52:10 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// The new numbers of tables will be the last one plus the num
// of missing tables
Fix lying sfnt header for some CFF font that pretend to be TrueType and fix unknown unicode glyphs when building from Type1
2011-08-26 21:21:25 +09:00
createOpenTypeHeader(header.version, ttf, numTables);
CMAP creation code is now more readable
2011-06-13 10:35:56 +09:00
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
if (requiredTables.indexOf('OS/2') != -1) {
Fixing lint long lines warnings
2011-09-17 09:53:52 +09:00
// extract some more font properties from the OpenType head and
// hhea tables; yMin and descent value are always negative
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
var override = {
unitsPerEm: int16([head.data[18], head.data[19]]),
yMax: int16([head.data[42], head.data[43]]),
Fixing lint long lines warnings
2011-09-17 09:53:52 +09:00
yMin: int16([head.data[38], head.data[39]]) - 0x10000,
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
ascent: int16([hhea.data[4], hhea.data[5]]),
Fixing lint long lines warnings
2011-09-17 09:53:52 +09:00
descent: int16([hhea.data[6], hhea.data[7]]) - 0x10000
};
Added myself to the license (yay!) Tweaked according to comments in pull request #482
2011-09-17 07:55:06 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
tables.push({
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
tag: 'OS/2',
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
data: stringToArray(createOS2Table(properties, null, override))
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
});
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
}
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
// Ensure the [h/v]mtx tables contains the advance width and
// sidebearings information for numGlyphs in the maxp table
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
font.pos = (font.start || 0) + maxp.offset;
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
var version = int16(font.getBytes(4));
var numGlyphs = int16(font.getBytes(2));
Fix an issue with the vhea/vmtx tables
2011-09-09 23:37:56 +09:00
sanitizeMetrics(font, hhea, hmtx, numGlyphs);
sanitizeMetrics(font, vhea, vmtx, numGlyphs);
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
Sanitize 'loca' font table: some fonts have first glyph with length 10
2011-09-19 11:25:05 +09:00
if (head && loca && glyf) {
var isGlyphLocationsLong = int16([head.data[50], head.data[51]]);
sanitizeGlyphLocations(loca, glyf, numGlyphs, isGlyphLocationsLong);
}
Fixing the maxAdvanceWidth and the amount of the missing sidebearing
2011-08-01 12:56:41 +09:00
// Sanitizer reduces the glyph advanceWidth to the maxAdvanceWidth
// Sometimes it's 0. That needs to be fixed
if (hhea.data[10] == 0 && hhea.data[11] == 0) {
hhea.data[10] = 0xFF;
hhea.data[11] = 0xFF;
}
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
// The 'post' table has glyphs names.
if (post) {
readGlyphNameMap(post, properties);
}
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Replace the old CMAP table with a shiny new one
if (properties.type == 'CIDFontType2') {
Fix missing sidebearings from the hmtx table (see canvas.pdf)
2011-07-15 23:22:45 +09:00
// Type2 composite fonts map characters directly to glyphs so the cmap
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// table must be replaced.
Change the way Type 2 CID fonts are encoded. Move the cmap glyphs above the first 255 unicode values so that fillText does not change them and create an encoding to map characters to the glyphs.
2011-08-19 22:04:34 +09:00
// canvas fillText will reencode some characters even if the font has a
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
// glyph at that position - e.g. newline is converted to a space and
// U+00AD (soft hyphen) is not drawn.
Change the way Type 2 CID fonts are encoded. Move the cmap glyphs above the first 255 unicode values so that fillText does not change them and create an encoding to map characters to the glyphs.
2011-08-19 22:04:34 +09:00
// So, offset all the glyphs by 0xFF to avoid these cases and use
// the encoding to map incoming characters to the new glyph positions
Add more glue between glyph mapping and code mapping
2011-09-08 10:16:33 +09:00
if (!cmap) {
cmap = {
tag: 'cmap',
data: null
};
tables.push(cmap);
}
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Remove indexOf, using reverse map instead
2011-11-29 12:54:07 +09:00
var cidToGidMap = properties.cidToGidMap || [];
var gidToCidMap = [0];
(#840) fix font stretching and overlapping characters encoding
2011-12-02 11:56:26 +09:00
if (cidToGidMap.length > 0) {
for (var j = cidToGidMap.length - 1; j >= 0; j--) {
var gid = cidToGidMap[j];
if (gid)
gidToCidMap[gid] = j;
}
// filling the gaps using CID above the CIDs currently used in font
var nextCid = cidToGidMap.length;
for (var i = 1; i < numGlyphs; i++) {
if (!gidToCidMap[i])
gidToCidMap[i] = nextCid++;
}
Remove indexOf, using reverse map instead
2011-11-29 12:54:07 +09:00
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var glyphs = [], ids = [];
Fix CIDFontType2 large cmap tables
2011-11-29 10:47:37 +09:00
var usedUnicodes = [];
var unassignedUnicodeItems = [];
for (var i = 1; i < numGlyphs; i++) {
Remove indexOf, using reverse map instead
2011-11-29 12:54:07 +09:00
var cid = gidToCidMap[i] || i;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var unicode = this.toUnicode[cid];
if (!unicode || isSpecialUnicode(unicode) ||
unicode in usedUnicodes) {
Fix CIDFontType2 large cmap tables
2011-11-29 10:47:37 +09:00
unassignedUnicodeItems.push(i);
continue;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
}
usedUnicodes[unicode] = true;
glyphs.push({ unicode: unicode, code: cid });
ids.push(i);
Fixing large cmap-s; reduce changes in the indent encoding
2011-09-18 07:13:22 +09:00
}
Remove indexOf, using reverse map instead
2011-11-29 12:54:07 +09:00
// trying to fit as many unassigned symbols as we can
// in the range allocated for the user defined symbols
var unusedUnicode = kCmapGlyphOffset;
for (var j = 0, jj = unassignedUnicodeItems.length; j < jj; j++) {
var i = unassignedUnicodeItems[j];
var cid = gidToCidMap[i] || i;
while (unusedUnicode in usedUnicodes)
unusedUnicode++;
if (unusedUnicode >= kCmapGlyphOffset + kSizeOfGlyphArea)
break;
var unicode = unusedUnicode++;
this.toUnicode[cid] = unicode;
usedUnicodes[unicode] = true;
glyphs.push({ unicode: unicode, code: cid });
ids.push(i);
Fix CIDFontType2 large cmap tables
2011-11-29 10:47:37 +09:00
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cmap.data = createCMapTable(glyphs, ids);
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
} else {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var cmapTable = readCMapTable(cmap, font);
var glyphs = cmapTable.glyphs;
var ids = cmapTable.ids;
var hasShortCmap = !!cmapTable.hasShortCmap;
var toUnicode = this.toUnicode;
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
if (toUnicode && toUnicode.length > 0) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
// checking if cmap is just identity map
var isIdentity = true;
for (var i = 0, ii = glyphs.length; i < ii; i++) {
if (glyphs[i].unicode != i + 1) {
isIdentity = false;
break;
}
}
// if it is, replacing with meaningful toUnicode values
if (isIdentity) {
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
var usedUnicodes = [], unassignedUnicodeItems = [];
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
for (var i = 0, ii = glyphs.length; i < ii; i++) {
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
var unicode = toUnicode[i + 1];
Using 'in' instead of array index
2011-12-10 09:25:44 +09:00
if (!unicode || unicode in usedUnicodes) {
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
unassignedUnicodeItems.push(i);
continue;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
glyphs[i].unicode = unicode;
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
usedUnicodes[unicode] = true;
}
var unusedUnicode = kCmapGlyphOffset;
for (var j = 0, jj = unassignedUnicodeItems.length; j < jj; j++) {
var i = unassignedUnicodeItems[j];
Using 'in' instead of array index
2011-12-10 09:25:44 +09:00
while (unusedUnicode in usedUnicodes)
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
unusedUnicode++;
(#919) Fixing toUnicode mapping for TrueType fonts with identity mapping
2011-12-10 12:21:58 +09:00
var cid = i + 1;
// override only if unicode mapping is not specified
if (!(cid in toUnicode))
toUnicode[cid] = unusedUnicode;
Fixing TrueType code-glyph assigmnent to pass sanitizer
2011-12-08 11:59:44 +09:00
glyphs[i].unicode = unusedUnicode++;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
}
this.useToUnicode = true;
}
}
properties.hasShortCmap = hasShortCmap;
remove glyph references outside range of avaialable glyphs
2011-12-08 12:38:34 +09:00
// remove glyph references outside range of avaialable glyphs
for (var i = 0, ii = ids.length; i < ii; i++) {
if (ids[i] >= numGlyphs)
ids[i] = 0;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
createGlyphNameMap(glyphs, ids, properties);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.glyphNameMap = properties.glyphNameMap;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cmap.data = createCMapTable(glyphs, ids);
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
}
Fully support truetype composite fonts, clean up
2011-07-13 17:31:34 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Rewrite the 'post' table if needed
if (requiredTables.indexOf('post') != -1) {
tables.push({
tag: 'post',
data: stringToArray(createPostTable(properties))
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
});
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
}
Prepare the way to decode Type1 charStrings
2011-06-01 18:52:10 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Rewrite the 'name' table if needed
if (requiredTables.indexOf('name') != -1) {
tables.push({
tag: 'name',
data: stringToArray(createNameTable(this.name))
});
}
CMAP creation code is now more readable
2011-06-13 10:35:56 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Tables needs to be written by ascendant alphabetic order
tables.sort(function tables_sort(a, b) {
return (a.tag > b.tag) - (a.tag < b.tag);
});
Clean up some code and add some changes to pdf.js
2011-06-04 02:47:07 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// rewrite the tables but tweak offsets
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = tables.length; i < ii; i++) {
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
var table = tables[i];
var data = [];
make createOpenTypeHeader and createTableEntry inner functions of co(n)ver(t) so we can use an upvar to collect the output
2011-06-20 07:58:02 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
var tableData = table.data;
Using ii convention
2011-11-03 04:21:45 +09:00
for (var j = 0, jj = tableData.length; j < jj; j++)
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
data.push(tableData[j]);
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
createTableEntry(ttf, table.tag, data);
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
}
make createOpenTypeHeader and createTableEntry inner functions of co(n)ver(t) so we can use an upvar to collect the output
2011-06-20 07:58:02 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// Add the table datas
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = tables.length; i < ii; i++) {
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
var table = tables[i];
var tableData = table.data;
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
ttf.file += arrayToString(tableData);
make createOpenTypeHeader and createTableEntry inner functions of co(n)ver(t) so we can use an upvar to collect the output
2011-06-20 07:58:02 +09:00
Support font with characters below 0x20 declared in format 1 cmap and be more general about the TrueType rewritting cases
2011-07-15 21:58:14 +09:00
// 4-byte aligned data
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
while (ttf.file.length & 3)
ttf.file += String.fromCharCode(0);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
}
remove remaining uses of integerToBytes in type1 font code
2011-06-21 03:42:39 +09:00
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
return stringToArray(ttf.file);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
},
Rename s2a, s16, s32 and do some dance inside the bind() code
2011-06-21 11:30:28 +09:00
Fix a bunch of warnings from Firebug strict mode
2011-06-24 18:58:05 +09:00
convert: function font_convert(fontName, font, properties) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
function isFixedPitch(glyphs) {
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = glyphs.length - 1; i < ii; i++) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
if (glyphs[i] != glyphs[i + 1])
return false;
}
return true;
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
Fill informations for the 'name' table in order to pass the sanitizer (Mozilla bug 660088)
2011-06-19 09:25:21 +09:00
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
// The offsets object holds at the same time a representation of where
// to write the table entry information about a table and another offset
// representing the offset where to draw the actual data of a particular
// table
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
var kRequiredTablesCount = 9;
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
var otf = {
Add more debug data to error-logs. Fix also a few gjslint errors.
2011-08-23 04:30:22 +09:00
file: '',
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
virtualOffset: 9 * (4 * 4)
cleanup
2011-08-19 12:40:16 +09:00
};
CMAP creation code is now more readable
2011-06-13 10:35:56 +09:00
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
createOpenTypeHeader('\x4F\x54\x54\x4F', otf, 9);
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var charstrings = font.charstrings;
properties.fixedPitch = isFixedPitch(charstrings);
Fixed the mapping from charstring to glyphs
2011-07-23 01:57:26 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var glyphNameMap = {};
for (var i = 0; i < charstrings.length; ++i) {
var charstring = charstrings[i];
glyphNameMap[charstring.glyph] = charstring.unicode;
}
this.glyphNameMap = glyphNameMap;
if (!properties.hasEncoding && (properties.subtype == 'Type1C' ||
properties.subtype == 'CIDFontType0C')) {
var encoding = [];
for (var i = 0; i < charstrings.length; ++i) {
var charstring = charstrings[i];
encoding[charstring.code] = charstring.glyph;
}
properties.baseEncoding = encoding;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
if (properties.subtype == 'CIDFontType0C') {
var toUnicode = [];
for (var i = 0; i < charstrings.length; ++i) {
var charstring = charstrings[i];
toUnicode[charstring.code] = charstring.unicode;
}
this.toUnicode = toUnicode;
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
var fields = {
// PostScript Font Program
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'CFF ': font.data,
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
// OS/2 and Windows Specific metrics
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
'OS/2': stringToArray(createOS2Table(properties, charstrings)),
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
// Character to glyphs mapping
Initial merge of master.
2011-10-20 03:14:13 +09:00
'cmap': createCMapTable(charstrings.slice(),
('glyphIds' in font) ? font.glyphIds : null),
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
// Font header
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
'head': (function fontFieldsHead() {
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
return stringToArray(
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x01\x00\x00' + // Version number
'\x00\x00\x10\x00' + // fontRevision
'\x00\x00\x00\x00' + // checksumAdjustement
'\x5F\x0F\x3C\xF5' + // magicNumber
'\x00\x00' + // Flags
'\x03\xE8' + // unitsPerEM (defaulting to 1000)
'\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // creation date
'\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // modifification date
'\x00\x00' + // xMin
Fixing missing text (#886)
2011-12-07 13:13:14 +09:00
safeString16(properties.descent) + // yMin
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x0F\xFF' + // xMax
Fixing missing text (#886)
2011-12-07 13:13:14 +09:00
safeString16(properties.ascent) + // yMax
Fix more headers tables
2011-06-30 18:48:43 +09:00
string16(properties.italicAngle ? 2 : 0) + // macStyle
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x11' + // lowestRecPPEM
'\x00\x00' + // fontDirectionHint
'\x00\x00' + // indexToLocFormat
'\x00\x00'); // glyphDataFormat
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
})(),
// Horizontal header
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
'hhea': (function fontFieldsHhea() {
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
return stringToArray(
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x01\x00\x00' + // Version number
Fixing missing text (#886)
2011-12-07 13:13:14 +09:00
safeString16(properties.ascent) + // Typographic Ascent
safeString16(properties.descent) + // Typographic Descent
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x00' + // Line Gap
'\xFF\xFF' + // advanceWidthMax
'\x00\x00' + // minLeftSidebearing
'\x00\x00' + // minRightSidebearing
'\x00\x00' + // xMaxExtent
Fixing missing text (#886)
2011-12-07 13:13:14 +09:00
safeString16(properties.capHeight) + // caretSlopeRise
safeString16(Math.tan(properties.italicAngle) *
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
properties.xHeight) + // caretSlopeRun
'\x00\x00' + // caretOffset
'\x00\x00' + // -reserved-
'\x00\x00' + // -reserved-
'\x00\x00' + // -reserved-
'\x00\x00' + // -reserved-
'\x00\x00' + // metricDataFormat
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
string16(charstrings.length + 1)); // Number of HMetrics
})(),
// Horizontal metrics
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
'hmtx': (function fontFieldsHmtx() {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var hmtx = '\x00\x00\x00\x00'; // Fake .notdef
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
for (var i = 0, ii = charstrings.length; i < ii; i++) {
var charstring = charstrings[i];
var width = 'width' in charstring ? charstring.width : 0;
hmtx += string16(width) + string16(0);
}
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
return stringToArray(hmtx);
})(),
// Maximum profile
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
'maxp': (function fontFieldsMaxp() {
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
return stringToArray(
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x00\x00\x50\x00' + // Version number
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
string16(charstrings.length + 1)); // Num of glyphs
})(),
// Naming tables
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'name': stringToArray(createNameTable(fontName)),
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
// PostScript informations
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'post': stringToArray(createPostTable(properties))
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
};
for (var field in fields)
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
createTableEntry(otf, field, fields[field]);
Clean up Fonts.convert()
2011-07-03 08:17:28 +09:00
for (var field in fields) {
var table = fields[field];
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
otf.file += arrayToString(table);
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
}
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Fixed fonts to use strings instead of Uint8Arrays
2011-08-19 12:17:54 +09:00
return stringToArray(otf.file);
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
},
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
rebuildToUnicode: function font_rebuildToUnicode(properties) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var firstChar = properties.firstChar, lastChar = properties.lastChar;
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
var map = [];
if (properties.composite) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var isIdentityMap = this.cidToUnicode.length == 0;
for (var i = firstChar, ii = lastChar; i <= ii; i++) {
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
// TODO missing map the character according font's CMap
var cid = i;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
map[i] = isIdentityMap ? cid : this.cidToUnicode[cid];
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
}
} else {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
for (var i = firstChar, ii = lastChar; i <= ii; i++) {
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
var glyph = properties.differences[i];
if (!glyph)
glyph = properties.baseEncoding[i];
if (!!glyph && (glyph in GlyphsUnicode))
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
map[i] = GlyphsUnicode[glyph];
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
}
}
this.toUnicode = map;
},
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
loadCidToUnicode: function font_loadCidToUnicode(properties) {
if (!properties.cidSystemInfo)
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
return;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var cidToUnicodeMap = [], unicodeToCIDMap = [];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.cidToUnicode = cidToUnicodeMap;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
this.unicodeToCID = unicodeToCIDMap;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
var cidSystemInfo = properties.cidSystemInfo;
var cidToUnicode;
if (cidSystemInfo) {
Moving CID-2 hack in fixWidths
2011-09-30 10:35:10 +09:00
cidToUnicode = CIDToUnicodeMaps[
cidSystemInfo.registry + '-' + cidSystemInfo.ordering];
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (!cidToUnicode)
return; // identity encoding
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var cid = 1, i, j, k, ii;
Using ii convention
2011-11-03 04:21:45 +09:00
for (i = 0, ii = cidToUnicode.length; i < ii; ++i) {
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
var unicode = cidToUnicode[i];
if (isArray(unicode)) {
Moving CID-2 hack in fixWidths
2011-09-30 10:35:10 +09:00
var length = unicode.length;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
for (j = 0; j < length; j++) {
cidToUnicodeMap[cid] = unicode[j];
unicodeToCIDMap[unicode[j]] = cid;
}
cid++;
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
} else if (typeof unicode === 'object') {
var fillLength = unicode.f;
if (fillLength) {
Fixes the special char codes... and unpack fix
2011-09-29 11:34:24 +09:00
k = unicode.c;
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
for (j = 0; j < fillLength; ++j) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cidToUnicodeMap[cid] = k;
unicodeToCIDMap[k] = cid;
cid++;
Fixes the special char codes... and unpack fix
2011-09-29 11:34:24 +09:00
k++;
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
}
} else
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cid += unicode.s;
Moving CID-2 hack in fixWidths
2011-09-30 10:35:10 +09:00
} else if (unicode) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cidToUnicodeMap[cid] = unicode;
unicodeToCIDMap[unicode] = cid;
cid++;
Fixes the special char codes... and unpack fix
2011-09-29 11:34:24 +09:00
} else
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
cid++;
Moving CID-0 encoding hack to fonts.js
2011-09-29 11:19:49 +09:00
}
},
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
bindWorker: function font_bindWorker(data) {
postMessage({
action: 'font',
data: {
raw: data,
fontName: this.loadedName,
mimetype: this.mimetype
}
});
},
bindDOM: function font_bindDom(data) {
var fontName = this.loadedName;
// Add the font-face rule to the document
var url = ('url(data:' + this.mimetype + ';base64,' +
window.btoa(data) + ');');
var rule = "@font-face { font-family:'" + fontName + "';src:" + url + '}';
Fix same origin policy issue when adding @font-face rules If the first stylesheet in the document is located on an external domain, then trying to access the `cssRules` property of that `CSSStyleSheet` object will result in a Security error being thrown in Firefox. In Safari, `cssRules` will be null, which causes a null pointer exception in the `styleSheet.cssRules.length` expression.
2011-11-02 19:47:41 +09:00
Add the style element to the head rather than first element in the document, as the first element could be a comment and this would line would then throw
2012-01-03 14:40:43 +09:00
document.documentElement.getElementsByTagName('head')[0].appendChild(
Fix same origin policy issue when adding @font-face rules If the first stylesheet in the document is located on an external domain, then trying to access the `cssRules` property of that `CSSStyleSheet` object will result in a Security error being thrown in Firefox. In Safari, `cssRules` will be null, which causes a null pointer exception in the `styleSheet.cssRules.length` expression.
2011-11-02 19:47:41 +09:00
document.createElement('style'));
var styleSheet = document.styleSheets[document.styleSheets.length - 1];
Hack something up that renders font right again
2011-10-09 01:15:18 +09:00
styleSheet.insertRule(rule, styleSheet.cssRules.length);
return rule;
},
Fixing Type3 text layer creation and character spacing
2011-12-13 12:32:20 +09:00
get spaceWidth() {
// trying to estimate space character width
type3 font.coded comment; proper geometery for showText; glyph name
2011-12-14 09:28:02 +09:00
var possibleSpaceReplacements = ['space', 'minus', 'one', 'i'];
Fixing Type3 text layer creation and character spacing
2011-12-13 12:32:20 +09:00
var width;
for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) {
var glyphName = possibleSpaceReplacements[i];
// if possible, getting width by glyph name
if (glyphName in this.widths) {
width = this.widths[glyphName];
break;
}
var glyphUnicode = GlyphsUnicode[glyphName];
// finding the charcode via unicodeToCID map
var charcode = 0;
if (this.composite)
charcode = this.unicodeToCID[glyphUnicode];
// ... via toUnicode map
if (!charcode && 'toUnicode' in this)
charcode = this.toUnicode.indexOf(glyphUnicode);
// setting it to unicode if negative or undefined
if (!(charcode > 0))
charcode = glyphUnicode;
// trying to get width via charcode
width = this.widths[charcode];
if (width)
break; // the non-zero width found
}
width = (width || this.defaultWidth) * this.widthMultiplier;
return shadow(this, 'spaceWidth', width);
},
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
charToGlyph: function fonts_charToGlyph(charcode) {
var unicode, width, codeIRQueue;
var width = this.widths[charcode];
switch (this.type) {
case 'CIDFontType0':
if (this.noUnicodeAdaptation) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
width = this.widths[this.unicodeToCID[charcode] || charcode];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
unicode = charcode;
break;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
unicode = this.toUnicode[charcode] || charcode;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
break;
case 'CIDFontType2':
if (this.noUnicodeAdaptation) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
width = this.widths[this.unicodeToCID[charcode] || charcode];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
unicode = charcode;
break;
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
unicode = this.toUnicode[charcode] || charcode;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
break;
case 'Type1':
var glyphName = this.differences[charcode] || this.encoding[charcode];
(#906) fixing glyph width defined by glyph name
2011-12-08 14:30:48 +09:00
if (!isNum(width))
width = this.widths[glyphName];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (this.noUnicodeAdaptation) {
unicode = GlyphsUnicode[glyphName] || charcode;
break;
}
unicode = this.glyphNameMap[glyphName] ||
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
GlyphsUnicode[glyphName] || charcode;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
break;
case 'Type3':
var glyphName = this.differences[charcode] || this.encoding[charcode];
codeIRQueue = this.charProcIRQueues[glyphName];
unicode = charcode;
break;
case 'TrueType':
Use unicode mapping cmap when simple identity cmap was originally used
2011-12-06 11:42:39 +09:00
if (this.useToUnicode) {
unicode = this.toUnicode[charcode] || charcode;
break;
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var glyphName = this.differences[charcode] || this.encoding[charcode];
if (!glyphName)
glyphName = Encodings.StandardEncoding[charcode];
TrueType encoding for files without font data
2011-10-29 22:45:29 +09:00
if (!isNum(width))
width = this.widths[glyphName];
if (this.noUnicodeAdaptation) {
unicode = GlyphsUnicode[glyphName] || charcode;
break;
}
using font flags to recognize the symbol and serif fonts; using the encoding instead of predefined MacRoman in TrueType fonts
2012-01-10 10:36:24 +09:00
if (!this.hasEncoding || this.isSymbolicFont) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
unicode = this.useToUnicode ? this.toUnicode[charcode] : charcode;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
break;
}
using font flags to recognize the symbol and serif fonts; using the encoding instead of predefined MacRoman in TrueType fonts
2012-01-10 10:36:24 +09:00
if (this.hasShortCmap) {
var j = this.encoding.indexOf(glyphName);
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
unicode = j >= 0 ? j :
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.glyphNameMap[glyphName];
} else {
unicode = glyphName in GlyphsUnicode ?
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
GlyphsUnicode[glyphName] :
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
this.glyphNameMap[glyphName];
}
break;
default:
warn('Unsupported font type: ' + this.type);
break;
}
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
Fix the unicode symbols on the text layer
2011-12-07 13:59:06 +09:00
var unicodeChars = !('toUnicode' in this) ? charcode :
this.toUnicode[charcode] || charcode;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
if (typeof unicodeChars === 'number')
unicodeChars = String.fromCharCode(unicodeChars);
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
Fixing base encoding presence detection; character width scale
2011-11-30 13:06:00 +09:00
width = (isNum(width) ? width : this.defaultWidth) * this.widthMultiplier;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
return {
Initial ToUnicode modifications
2011-11-25 00:38:09 +09:00
fontChar: String.fromCharCode(unicode),
unicode: unicodeChars,
Fixing base encoding presence detection; character width scale
2011-11-30 13:06:00 +09:00
width: width,
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
codeIRQueue: codeIRQueue
};
},
(#867) Set Type3 font encoding; enable text selection testing
2011-12-05 04:51:12 +09:00
charsToGlyphs: function fonts_charsToGlyphs(chars) {
move unicode translation cache into Font
2011-07-09 08:36:50 +09:00
var charsCache = this.charsCache;
Fixing defaultWidth; variables names
2011-09-16 09:26:32 +09:00
var glyphs;
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
move unicode translation cache into Font
2011-07-09 08:36:50 +09:00
// if we translated this string before, just grab it from the cache
if (charsCache) {
Fixing defaultWidth; variables names
2011-09-16 09:26:32 +09:00
glyphs = charsCache[chars];
if (glyphs)
return glyphs;
move unicode translation cache into Font
2011-07-09 08:36:50 +09:00
}
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
move unicode translation cache into Font
2011-07-09 08:36:50 +09:00
// lazily create the translation cache
if (!charsCache)
charsCache = this.charsCache = Object.create(null);
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fixing defaultWidth; variables names
2011-09-16 09:26:32 +09:00
glyphs = [];
Change the way Type 2 CID fonts are encoded. Move the cmap glyphs above the first 255 unicode values so that fillText does not change them and create an encoding to map characters to the glyphs.
2011-08-19 22:04:34 +09:00
Refactor translateFont() to be more readable
2011-09-08 01:00:38 +09:00
if (this.composite) {
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
// composite fonts have multi-byte strings convert the string from
Change the way Type 2 CID fonts are encoded. Move the cmap glyphs above the first 255 unicode values so that fillText does not change them and create an encoding to map characters to the glyphs.
2011-08-19 22:04:34 +09:00
// single-byte to multi-byte
// XXX assuming CIDFonts are two-byte - later need to extract the
// correct byte encoding according to the PDF spec
var length = chars.length - 1; // looping over two bytes at a time so
// loop should never end on the last byte
Second pass CIDFont support - make Arial Unicode in OpenOffice PDF - supports PDF fonts with CIDtoGIDMap and no cmap
2011-07-12 01:41:47 +09:00
for (var i = 0; i < length; i++) {
Change the way Type 2 CID fonts are encoded. Move the cmap glyphs above the first 255 unicode values so that fillText does not change them and create an encoding to map characters to the glyphs.
2011-08-19 22:04:34 +09:00
var charcode = int16([chars.charCodeAt(i++), chars.charCodeAt(i)]);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var glyph = this.charToGlyph(charcode);
Fixing defaultWidth; variables names
2011-09-16 09:26:32 +09:00
glyphs.push(glyph);
// placing null after each word break charcode (ASCII SPACE)
if (charcode == 0x20)
glyphs.push(null);
work around #233 so that tests stop failing for the moment
2011-07-10 14:12:42 +09:00
}
Second pass CIDFont support - make Arial Unicode in OpenOffice PDF - supports PDF fonts with CIDtoGIDMap and no cmap
2011-07-12 01:41:47 +09:00
}
else {
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = chars.length; i < ii; ++i) {
Second pass CIDFont support - make Arial Unicode in OpenOffice PDF - supports PDF fonts with CIDtoGIDMap and no cmap
2011-07-12 01:41:47 +09:00
var charcode = chars.charCodeAt(i);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var glyph = this.charToGlyph(charcode);
Fixing defaultWidth; variables names
2011-09-16 09:26:32 +09:00
glyphs.push(glyph);
if (charcode == 0x20)
glyphs.push(null);
move unicode translation cache into Font
2011-07-09 08:36:50 +09:00
}
}
// Enter the translated string into the cache
Merge branch 'master' of https://github.com/andreasgal/pdf.js.git into charstoglyphs Conflicts: fonts.js
2011-09-13 08:14:18 +09:00
return (charsCache[chars] = glyphs);
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
};
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Name all constructors.
2011-12-09 07:18:43 +09:00
return Font;
add a closure around Font so we can hide helper functions in it
2011-06-20 07:46:58 +09:00
})();
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Fix lint errors.
2011-08-26 02:20:19 +09:00
/*
Clean up some debug leftovers
2011-06-17 20:55:42 +09:00
* Type1Parser encapsulate the needed code for parsing a Type1 font
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
* program. Some of its logic depends on the Type2 charstrings
* structure.
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
*/
Name anonymous functions for debugging purposes. It also makes profiling more convenient.
2011-09-24 02:44:48 +09:00
var Type1Parser = function type1Parser() {
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
/*
* Decrypt a Sequence of Ciphertext Bytes to Produce the Original Sequence
* of Plaintext Bytes. The function took a key as a parameter which can be
* for decrypting the eexec block of for decoding charStrings.
*/
var kEexecEncryptionKey = 55665;
var kCharStringsEncryptionKey = 4330;
Add the beginning of a Type1 to Type2 charstring converter
2011-06-10 08:20:00 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
function decrypt(stream, key, discardNumber) {
var r = key, c1 = 52845, c2 = 22719;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
var decryptedString = [];
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var value = '';
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var count = stream.length;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
for (var i = 0; i < count; i++) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
value = stream[i];
Clean up some debug leftovers
2011-06-17 20:55:42 +09:00
decryptedString[i] = value ^ (r >> 8);
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
r = ((value + r) * c1 + c2) & ((1 << 16) - 1);
}
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
return decryptedString.slice(discardNumber);
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
/*
* CharStrings are encoded following the the CharString Encoding sequence
* describe in Chapter 6 of the "Adobe Type1 Font Format" specification.
* The value in a byte indicates a command, a number, or subsequent bytes
* that are to be interpreted in a special way.
*
* CharString Number Encoding:
* A CharString byte containing the values from 32 through 255 inclusive
* indicate an integer. These values are decoded in four ranges.
*
* 1. A CharString byte containing a value, v, between 32 and 246 inclusive,
* indicate the integer v - 139. Thus, the integer values from -107 through
* 107 inclusive may be encoded in single byte.
*
* 2. A CharString byte containing a value, v, between 247 and 250 inclusive,
* indicates an integer involving the next byte, w, according to the formula:
* [(v - 247) x 256] + w + 108
*
* 3. A CharString byte containing a value, v, between 251 and 254 inclusive,
* indicates an integer involving the next byte, w, according to the formula:
* -[(v - 251) * 256] - w - 108
*
* 4. A CharString containing the value 255 indicates that the next 4 bytes
* are a two complement signed integer. The first of these bytes contains the
* highest order bits, the second byte contains the next higher order bits
* and the fourth byte contain the lowest order bits.
*
*
* CharString Command Encoding:
* CharStrings commands are encoded in 1 or 2 bytes.
*
* Single byte commands are encoded in 1 byte that contains a value between
* 0 and 31 inclusive.
* If a command byte contains the value 12, then the value in the next byte
* indicates a command. This "escape" mechanism allows many extra commands
* to be encoded and this encoding technique helps to minimize the length of
* the charStrings.
*/
var charStringDictionary = {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'1': 'hstem',
'3': 'vstem',
'4': 'vmoveto',
'5': 'rlineto',
'6': 'hlineto',
'7': 'vlineto',
'8': 'rrcurveto',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// closepath is a Type1 command that do not take argument and is useless
// in Type2 and it can simply be ignored.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'9': null, // closepath
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'10': 'callsubr',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// return is normally used inside sub-routines to tells to the execution
// flow that it can be back to normal.
// During the translation process Type1 charstrings will be flattened and
// sub-routines will be embedded directly into the charstring directly, so
// this can be ignored safely.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'11': 'return',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'12': {
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// dotsection is a Type1 command to specify some hinting feature for dots
// that do not take a parameter and it can safely be ignored for Type2.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'0': null, // dotsection
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// [vh]stem3 are Type1 only and Type2 supports [vh]stem with multiple
// parameters, so instead of returning [vh]stem3 take a shortcut and
// return [vhstem] instead.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'1': 'vstem',
'2': 'hstem',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// Type1 only command with command not (yet) built-in ,throw an error
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'6': -1, // seac
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
'7': -1, // sbw
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'11': 'sub',
'12': 'div',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// callothersubr is a mechanism to make calls on the postscript
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
// interpreter, this is not supported by Type2 charstring but hopefully
// most of the default commands can be ignored safely.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'16': 'callothersubr',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'17': 'pop',
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// setcurrentpoint sets the current point to x, y without performing a
// moveto (this is a one shot positionning command). This is used only
// with the return of an OtherSubrs call.
// TODO Implement the OtherSubrs charstring embedding and replace this
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
// call by a no-op, like 2 'pop' commands for example.
'33': null // setcurrentpoint
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
},
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'13': 'hsbw',
'14': 'endchar',
'21': 'rmoveto',
'22': 'hmoveto',
'30': 'vhcurveto',
'31': 'hvcurveto'
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
};
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
var kEscapeCommand = 12;
Small cleanup
2011-06-29 00:35:15 +09:00
function decodeCharString(array) {
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
var charstring = [];
Give a shot at passing better information to hmtx (hinting is slightly broken)
2011-06-28 07:11:53 +09:00
var lsb = 0;
var width = 0;
Initial merge of master.
2011-10-20 03:14:13 +09:00
var flexState = 0;
Add the necessary bits to handle Arrays, Procedure and a bigger set of instructions for Type1
2011-06-04 00:48:32 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var value = '';
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var count = array.length;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
for (var i = 0; i < count; i++) {
still mucking with subroutines
2011-08-17 06:49:12 +09:00
value = array[i];
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
if (value < 32) {
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
var command = null;
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
if (value == kEscapeCommand) {
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var escape = array[++i];
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
// TODO Clean this code
if (escape == 16) {
var index = charstring.pop();
Still testing type1 charstring conversion
2011-08-17 08:14:29 +09:00
var argc = charstring.pop();
for (var j = 0; j < argc; j++)
working font
2011-08-18 07:55:09 +09:00
charstring.push('drop');
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
Use lenIV to read the subrs section
2011-09-02 20:37:39 +09:00
// If the flex mechanism is not used in a font program, Adobe
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
// states that entries 0, 1 and 2 can simply be replaced by
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
// {}, which means that we can simply ignore them.
if (index < 3) {
continue;
}
// This is the same things about hint replacement, if it is not used
// entry 3 can be replaced by {3}
Add a comment about supporting hint replacement
2011-09-02 22:26:16 +09:00
// TODO support hint replacment
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
if (index == 3) {
Still testing type1 charstring conversion
2011-08-17 08:14:29 +09:00
charstring.push(3);
i++;
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
continue;
}
Initial merge of master.
2011-10-20 03:14:13 +09:00
} else if (escape == 17 || escape == 33) {
// pop or setcurrentpoint commands can be ignored
// since we are not doing callothersubr
continue;
} else if (!kHintingEnabled && (escape == 1 || escape == 2)) {
Disable hinting until it works
2011-09-11 03:00:27 +09:00
charstring.push('drop', 'drop', 'drop', 'drop', 'drop', 'drop');
continue;
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
command = charStringDictionary['12'][escape];
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
} else {
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
// TODO Clean this code
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
if (value == 13) { // hsbw
Handle division in hsbw to provide the correct information to the hmtx table
2011-06-28 20:34:39 +09:00
if (charstring.length == 2) {
Support lsb div format
2011-08-25 00:18:56 +09:00
lsb = charstring[0];
Handle division in hsbw to provide the correct information to the hmtx table
2011-06-28 20:34:39 +09:00
width = charstring[1];
Move splice() after the width assigment
2011-08-25 09:56:03 +09:00
charstring.splice(0, 1);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
} else if (charstring.length == 4 && charstring[3] == 'div') {
Support lsb div format
2011-08-25 00:18:56 +09:00
lsb = charstring[0];
Handle division in hsbw to provide the correct information to the hmtx table
2011-06-28 20:34:39 +09:00
width = charstring[1] / charstring[2];
Move splice() after the width assigment
2011-08-25 09:56:03 +09:00
charstring.splice(0, 1);
Support lsb div format
2011-08-25 00:18:56 +09:00
} else if (charstring.length == 4 && charstring[2] == 'div') {
lsb = charstring[0] / charstring[1];
width = charstring[3];
Move splice() after the width assigment
2011-08-25 09:56:03 +09:00
charstring.splice(0, 3);
Handle division in hsbw to provide the correct information to the hmtx table
2011-06-28 20:34:39 +09:00
} else {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
error('Unsupported hsbw format: ' + charstring);
Handle division in hsbw to provide the correct information to the hmtx table
2011-06-28 20:34:39 +09:00
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
charstring.push(lsb, 'hmoveto');
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
continue;
Initial merge of master.
2011-10-20 03:14:13 +09:00
} else if (value == 10) { // callsubr
if (charstring[charstring.length - 1] < 3) { // subr #0..2
var subrNumber = charstring.pop();
switch (subrNumber) {
case 1:
flexState = 1; // prepare for flex coordinates
break;
case 2:
flexState = 2; // flex in progress
break;
case 0:
// type2 flex command does not need final coords
charstring.push('exch', 'drop', 'exch', 'drop');
charstring.push('flex');
flexState = 0;
break;
}
continue;
}
} else if (value == 21 && flexState > 0) {
if (flexState > 1)
continue; // ignoring rmoveto
value = 5; // first segment replacing with rlineto
Disable hinting until it works
2011-09-11 03:00:27 +09:00
} else if (!kHintingEnabled && (value == 1 || value == 3)) {
charstring.push('drop', 'drop');
continue;
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
}
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
command = charStringDictionary[value];
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
// Some charstring commands are meaningless in Type2 and will return
// a null, let's just ignored them
Do not use stream when it is not necessary
2011-06-17 14:48:45 +09:00
if (!command && i < count) {
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
continue;
Do not use stream when it is not necessary
2011-06-17 14:48:45 +09:00
} else if (!command) {
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
break;
Do not use stream when it is not necessary
2011-06-17 14:48:45 +09:00
} else if (command == -1) {
Fix lenIV misreading and warn instead of stop for unimplemented Type1 commands
2011-09-07 22:20:23 +09:00
warn('Support for Type1 command ' + value +
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
' (' + escape + ') is not implemented in charstring: ' +
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
charstring);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (value == 12) {
// we know how to ignore only some the Type1 commands
switch (escape) {
case 7:
charstring.push('drop', 'drop', 'drop', 'drop');
continue;
case 8:
charstring.push('drop');
continue;
}
}
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
}
value = command;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
} else if (value <= 246) {
still mucking with subroutines
2011-08-17 06:49:12 +09:00
value = value - 139;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
} else if (value <= 250) {
still mucking with subroutines
2011-08-17 06:49:12 +09:00
value = ((value - 247) * 256) + array[++i] + 108;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
} else if (value <= 254) {
still mucking with subroutines
2011-08-17 06:49:12 +09:00
value = -((value - 251) * 256) - array[++i] - 108;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
} else {
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
value = (array[++i] & 0xff) << 24 | (array[++i] & 0xff) << 16 |
(array[++i] & 0xff) << 8 | (array[++i] & 0xff) << 0;
Starts playing with the execution stack
2011-06-02 03:40:25 +09:00
}
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
Kill Flatten - part 1
2011-06-26 17:04:56 +09:00
charstring.push(value);
Add a the beggining of a Type1 font reader
2011-06-01 03:22:05 +09:00
}
Clean up some code and add some changes to pdf.js
2011-06-04 02:47:07 +09:00
Give a shot at passing better information to hmtx (hinting is slightly broken)
2011-06-28 07:11:53 +09:00
return { charstring: charstring, width: width, lsb: lsb };
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
Add the beginning of a Type1 to Type2 charstring converter
2011-06-10 08:20:00 +09:00
Fix lint errors.
2011-08-26 02:20:19 +09:00
/*
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
* Returns an object containing a Subrs array and a CharStrings
* array extracted from and eexec encrypted block of data
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
*/
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
function readNumberArray(str, index) {
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
var start = index;
while (str[index++] != '[')
start++;
start++;
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
var count = 0;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
while (str[index++] != ']')
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
count++;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var array = str.substr(start, count).split(' ');
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = array.length; i < ii; i++)
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
array[i] = parseFloat(array[i] || 0);
return array;
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
function readNumber(str, index) {
Fix lenIV misreading and warn instead of stop for unimplemented Type1 commands
2011-09-07 22:20:23 +09:00
while (str[index] == ' ')
index++;
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
var start = index;
var count = 0;
while (str[index++] != ' ')
count++;
return parseFloat(str.substr(start, count) || 0);
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
function isSeparator(c) {
return c == ' ' || c == '\n' || c == '\x0d';
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
this.extractFontProgram = function t1_extractFontProgram(stream) {
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
var eexec = decrypt(stream, kEexecEncryptionKey, 4);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var eexecStr = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = eexec.length; i < ii; i++)
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
eexecStr += String.fromCharCode(eexec[i]);
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
var glyphsSection = false, subrsSection = false;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var program = {
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
subrs: [],
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
charstrings: [],
properties: {
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
'private': {
'lenIV': 4
}
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
}
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
};
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var glyph = '';
var token = '';
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
var length = 0;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var c = '';
var count = eexecStr.length;
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
for (var i = 0; i < count; i++) {
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
var getToken = function getToken() {
while (i < count && isSeparator(eexecStr[i]))
working on subroutines
2011-08-17 02:25:02 +09:00
++i;
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
var token = '';
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
while (i < count && !isSeparator(eexecStr[i]))
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
token += eexecStr[i++];
working on subroutines
2011-08-17 02:25:02 +09:00
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
return token;
};
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var c = eexecStr[i];
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
if ((glyphsSection || subrsSection) &&
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
(token == 'RD' || token == '-|')) {
i++;
var data = eexec.slice(i, i + length);
var lenIV = program.properties.private['lenIV'];
var encoded = decrypt(data, kCharStringsEncryptionKey, lenIV);
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
var str = decodeCharString(encoded);
if (glyphsSection) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
program.charstrings.push({
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
glyph: glyph,
Give a shot at passing better information to hmtx (hinting is slightly broken)
2011-06-28 07:11:53 +09:00
data: str.charstring,
lsb: str.lsb,
width: str.width
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
});
} else {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
program.subrs.push(str.charstring);
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
}
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
i += length;
token = '';
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
} else if (isSeparator(c)) {
Use radix in parseInt function calls.
2011-09-07 07:39:48 +09:00
length = parseInt(token, 10);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
token = '';
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
} else {
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
token += c;
if (!glyphsSection) {
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
switch (token) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case '/CharString':
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
glyphsSection = true;
break;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case '/Subrs':
working on subroutines
2011-08-17 02:25:02 +09:00
++i;
Use radix in parseInt function calls.
2011-09-07 07:39:48 +09:00
var num = parseInt(getToken(), 10);
working on subroutines
2011-08-17 02:25:02 +09:00
getToken(); // read in 'array'
for (var j = 0; j < num; ++j) {
var t = getToken(); // read in 'dup'
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
if (t == 'ND' || t == '|-' || t == 'noaccess')
working on subroutines
2011-08-17 02:25:02 +09:00
break;
Use radix in parseInt function calls.
2011-09-07 07:39:48 +09:00
var index = parseInt(getToken(), 10);
working on subroutines
2011-08-17 02:25:02 +09:00
if (index > j)
j = index;
Use radix in parseInt function calls.
2011-09-07 07:39:48 +09:00
var length = parseInt(getToken(), 10);
working on subroutines
2011-08-17 02:25:02 +09:00
getToken(); // read in 'RD'
var data = eexec.slice(i + 1, i + 1 + length);
Use lenIV to read the subrs section
2011-09-02 20:37:39 +09:00
var lenIV = program.properties.private['lenIV'];
var encoded = decrypt(data, kCharStringsEncryptionKey, lenIV);
working on subroutines
2011-08-17 02:25:02 +09:00
var str = decodeCharString(encoded);
i = i + 1 + length;
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
t = getToken(); // read in 'NP'
Be more flexible about Subrs parsing
2011-09-02 21:21:48 +09:00
if (t == 'noaccess')
Fix regression on i9.pdf
2011-09-05 21:35:03 +09:00
getToken(); // read in 'put'
working on subroutines
2011-08-17 02:25:02 +09:00
program.subrs[index] = str.charstring;
}
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
break;
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
case '/BlueValues':
case '/OtherBlues':
case '/FamilyBlues':
case '/FamilyOtherBlues':
case '/StemSnapH':
case '/StemSnapV':
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
program.properties.private[token.substring(1)] =
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
readNumberArray(eexecStr, i + 1);
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
break;
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
case '/StdHW':
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case '/StdVW':
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
program.properties.private[token.substring(1)] =
readNumberArray(eexecStr, i + 2)[0];
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
break;
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
case '/BlueShift':
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
case '/lenIV':
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
case '/BlueFuzz':
case '/BlueScale':
case '/LanguageGroup':
case '/ExpansionFactor':
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
program.properties.private[token.substring(1)] =
readNumber(eexecStr, i + 1);
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
break;
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
} else if (c == '/') {
token = glyph = '';
while ((c = eexecStr[++i]) != ' ')
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
glyph += c;
}
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
}
Improve the extractInfo code to be more robust
2011-07-01 12:16:27 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
return program;
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
};
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
this.extractFontHeader = function t1_extractFontHeader(stream, properties) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var headerString = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = stream.length; i < ii; i++)
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
headerString += String.fromCharCode(stream[i]);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var token = '';
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
var count = headerString.length;
for (var i = 0; i < count; i++) {
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
var getToken = function getToken() {
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
var char = headerString[i];
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
while (i < count && (isSeparator(char) || char == '/'))
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
char = headerString[++i];
var token = '';
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
while (i < count && !(isSeparator(char) || char == '/')) {
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
token += char;
char = headerString[++i];
}
return token;
};
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
var c = headerString[i];
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
if (isSeparator(c)) {
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
switch (token) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
case '/FontMatrix':
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
var matrix = readNumberArray(headerString, i + 1);
// The FontMatrix is in unitPerEm, so make it pixels
Using ii convention
2011-11-03 04:21:45 +09:00
for (var j = 0, jj = matrix.length; j < jj; j++)
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
matrix[j] *= 1000;
// Make the angle into the right direction
matrix[2] *= -1;
#502 Adding basic Type3 font support.
2011-10-04 08:36:01 +09:00
properties.fontMatrix = matrix;
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
break;
case '/Encoding':
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var encodingArg = getToken();
var encoding;
if (!/^\d+$/.test(encodingArg)) {
// encoding name is specified
encoding = Encodings[encodingArg];
} else {
encoding = [];
var size = parseInt(encodingArg, 10);
getToken(); // read in 'array'
Fix a small Type1 encoding parsing error that cause the first Type1 font of the Type1 spec to be rejected
2011-09-10 21:50:46 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
for (var j = 0; j < size; j++) {
var token = getToken();
if (token == 'dup') {
var index = parseInt(getToken(), 10);
var glyph = getToken();
encoding[index] = glyph;
getToken(); // read the in 'put'
Clean up a bit the encoding/charset/glyphs dance
2011-08-30 07:56:02 +09:00
}
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
}
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (!properties.hasEncoding && encoding) {
properties.baseEncoding = encoding;
break;
}
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
break;
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
token = '';
Read the text matrix from the Type1 font ascii header
2011-07-01 14:16:56 +09:00
} else {
token += c;
}
}
};
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
};
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Rename s2a, s16, s32 and do some dance inside the bind() code
2011-06-21 11:30:28 +09:00
/**
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
* The CFF class takes a Type1 file and wrap it into a
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
* 'Compact Font Format' which itself embed Type2 charstrings.
Rename s2a, s16, s32 and do some dance inside the bind() code
2011-06-21 11:30:28 +09:00
*/
fix strict-mode violations in chrome
2011-06-23 10:50:38 +09:00
var CFFStrings = [
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent',
'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus',
'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four',
'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less',
'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', 'asciicircum',
'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
'z', 'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent',
'sterling', 'fraction', 'yen', 'florin', 'section', 'currency',
'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft',
'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl',
'periodcentered', 'paragraph', 'bullet', 'quotesinglbase', 'quotedblbase',
'quotedblright', 'guillemotright', 'ellipsis', 'perthousand', 'questiondown',
'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve', 'dotaccent',
'dieresis', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron', 'emdash',
'AE', 'ordfeminine', 'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae',
'dotlessi', 'lslash', 'oslash', 'oe', 'germandbls', 'onesuperior',
'logicalnot', 'mu', 'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn',
'onequarter', 'divide', 'brokenbar', 'degree', 'thorn', 'threequarters',
'twosuperior', 'registered', 'minus', 'eth', 'multiply', 'threesuperior',
'copyright', 'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring',
'Atilde', 'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave',
'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute',
'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute',
'Ucircumflex', 'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron',
'aacute', 'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde',
'ccedilla', 'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute',
'icircumflex', 'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex',
'odieresis', 'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex',
'udieresis', 'ugrave', 'yacute', 'ydieresis', 'zcaron', 'exclamsmall',
'Hungarumlautsmall', 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall',
'Acutesmall', 'parenleftsuperior', 'parenrightsuperior', '266 ff',
'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',
'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',
'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'commasuperior',
'threequartersemdash', 'periodsuperior', 'questionsmall', 'asuperior',
'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', 'isuperior',
'lsuperior', 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',
'tsuperior', 'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior',
'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall', 'Bsmall',
'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall',
'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall',
'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall',
'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah',
'Tildesmall', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall',
'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall',
'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior',
'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall', 'oneeighth',
'threeeighths', 'fiveeighths', 'seveneighths', 'onethird', 'twothirds',
'zerosuperior', 'foursuperior', 'fivesuperior', 'sixsuperior',
'sevensuperior', 'eightsuperior', 'ninesuperior', 'zeroinferior',
'oneinferior', 'twoinferior', 'threeinferior', 'fourinferior',
'fiveinferior', 'sixinferior', 'seveninferior', 'eightinferior',
'nineinferior', 'centinferior', 'dollarinferior', 'periodinferior',
'commainferior', 'Agravesmall', 'Aacutesmall', 'Acircumflexsmall',
'Atildesmall', 'Adieresissmall', 'Aringsmall', 'AEsmall', 'Ccedillasmall',
'Egravesmall', 'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall',
'Igravesmall', 'Iacutesmall', 'Icircumflexsmall', 'Idieresissmall',
'Ethsmall', 'Ntildesmall', 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall',
'Otildesmall', 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall',
'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall',
'Thornsmall', 'Ydieresissmall', '001.000', '001.001', '001.002', '001.003',
'Black', 'Bold', 'Book', 'Light', 'Medium', 'Regular', 'Roman', 'Semibold'
move cffStandardStrings into utils/ along with font_utils.js
2011-06-18 08:07:09 +09:00
];
Remove some hardcoded glue
2011-06-24 06:15:22 +09:00
var type1Parser = new Type1Parser();
Use lowercase properly in function names.
2011-09-27 02:30:05 +09:00
var CFF = function cffCFF(name, file, properties) {
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
// Get the data block containing glyphs and subrs informations
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
var headerBlock = file.getBytes(properties.length1);
Add built-in encoding for Type1 if there is no encoding built yet (fix some missing chars in pypy.pdf page 7)
2011-08-25 09:29:22 +09:00
type1Parser.extractFontHeader(headerBlock, properties);
Do not use makeSubStream in the CFF constructor
2011-06-14 06:23:13 +09:00
Remove some hardcoded glue
2011-06-24 06:15:22 +09:00
// Decrypt the data blocks and retrieve it's content
Add '^M' support in the ASCII85Decode filter and fix the fonts code to load the Type1 spec
2011-09-06 05:09:40 +09:00
var eexecBlock = file.getBytes(properties.length2);
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
var data = type1Parser.extractFontProgram(eexecBlock);
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
for (var info in data.properties)
properties[info] = data.properties[info];
Get rid of the PostScript interpreter (part 1)
2011-06-16 06:02:30 +09:00
Fix lying sfnt header for some CFF font that pretend to be TrueType and fix unknown unicode glyphs when building from Type1
2011-08-26 21:21:25 +09:00
var charstrings = this.getOrderedCharStrings(data.charstrings, properties);
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
var type2Charstrings = this.getType2Charstrings(charstrings);
var subrs = this.getType2Subrs(data.subrs);
this.charstrings = charstrings;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
this.data = this.wrap(name, type2Charstrings, this.charstrings,
subrs, properties);
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
};
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
CFF.prototype = {
Fix a bunch of warnings from Firebug strict mode
2011-06-24 18:58:05 +09:00
createCFFIndexHeader: function cff_createCFFIndexHeader(objects, isByte) {
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
// First 2 bytes contains the number of objects contained into this index
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
var count = objects.length;
Clean up some debug leftovers
2011-06-17 20:55:42 +09:00
// If there is no object, just create an array saying that with another
// offset byte.
if (count == 0)
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
return '\x00\x00\x00';
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
var data = String.fromCharCode((count >> 8) & 0xFF, count & 0xff);
Fix a bunch of errors reported by OTS except the error about 3-0-4 MS symbol in cmap
2011-06-12 08:51:27 +09:00
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
// Next byte contains the offset size use to reference object in the file
// Actually we're using 0x04 to be sure to be able to store everything
// without thinking of it while coding.
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
data += '\x04';
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
// Add another offset after this one because we need a new offset
var relativeOffset = 1;
for (var i = 0; i < count + 1; i++) {
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
data += String.fromCharCode((relativeOffset >>> 24) & 0xFF,
(relativeOffset >> 16) & 0xFF,
(relativeOffset >> 8) & 0xFF,
relativeOffset & 0xFF);
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
if (objects[i])
relativeOffset += objects[i].length;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
for (var i = 0; i < count; i++) {
Using ii convention
2011-11-03 04:21:45 +09:00
for (var j = 0, jj = objects[i].length; j < jj; j++)
Correct the coding style according to gjslint in font.js Also refactor the lines that are over 80 characters long.
2011-08-12 03:41:03 +09:00
data += isByte ? String.fromCharCode(objects[i][j] & 0xFF) :
objects[i][j];
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
return data;
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
},
Fix a bunch of warnings from Firebug strict mode
2011-06-24 18:58:05 +09:00
encodeNumber: function cff_encodeNumber(value) {
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
// some of the fonts has ouf-of-range values
// they are just arithmetic overflows
// make sanitizer happy
value |= 0;
Get rid of the TrueType class, adapt the code to conventions and new code
2011-06-21 13:49:59 +09:00
if (value >= -32768 && value <= 32767) {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
return '\x1c' +
fixing CFF things to pass FontValidator
2011-07-06 22:12:41 +09:00
String.fromCharCode((value >> 8) & 0xFF) +
Start converting CFF class to use strings instead of arrays
2011-07-01 07:57:17 +09:00
String.fromCharCode(value & 0xFF);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
} else {
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
return '\x1d' +
Fix a > 32000 conversion error in type1 to type2 charstring
2011-07-21 18:01:38 +09:00
String.fromCharCode((value >> 24) & 0xFF) +
fixing CFF things to pass FontValidator
2011-07-06 22:12:41 +09:00
String.fromCharCode((value >> 16) & 0xFF) +
String.fromCharCode((value >> 8) & 0xFF) +
Start converting CFF class to use strings instead of arrays
2011-07-01 07:57:17 +09:00
String.fromCharCode(value & 0xFF);
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
}
},
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Fix gjslint errors.
2011-08-27 05:55:14 +09:00
getOrderedCharStrings: function cff_getOrderedCharStrings(glyphs,
properties) {
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
var charstrings = [];
Fixing duplicates in cmap
2011-10-30 11:55:43 +09:00
var i, length, glyphName;
Change cmap encoding for Type 1
2011-10-29 23:29:19 +09:00
var unusedUnicode = kCmapGlyphOffset;
for (i = 0, length = glyphs.length; i < length; i++) {
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var item = glyphs[i];
Change cmap encoding for Type 1
2011-10-29 23:29:19 +09:00
var glyphName = item.glyph;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var unicode = glyphName in GlyphsUnicode ?
GlyphsUnicode[glyphName] : unusedUnicode++;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
charstrings.push({
Change cmap encoding for Type 1
2011-10-29 23:29:19 +09:00
glyph: glyphName,
unicode: unicode,
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
gid: i,
charstring: item.data,
width: item.width,
lsb: item.lsb
});
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
}
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Add a name to some anonyous functions
2011-06-21 11:35:28 +09:00
charstrings.sort(function charstrings_sort(a, b) {
Let Chrome (and others?) handle Type1 Fonts (TrueType not working yet)
2011-07-03 21:52:00 +09:00
return a.unicode - b.unicode;
Beginning of the separatation of the Type1/CFF/OTF code
2011-06-13 09:30:16 +09:00
});
return charstrings;
},
Add a basic non-working OTF generator
2011-06-11 10:25:58 +09:00
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
getType2Charstrings: function cff_getType2Charstrings(type1Charstrings) {
var type2Charstrings = [];
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var count = type1Charstrings.length;
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
for (var i = 0; i < count; i++) {
var charstring = type1Charstrings[i].charstring;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
type2Charstrings.push(this.flattenCharstring(charstring.slice(),
this.commandsMap));
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
}
return type2Charstrings;
},
Add a comment about supporting hint replacement
2011-09-02 22:26:16 +09:00
getType2Subrs: function cff_getType2Subrs(type1Subrs) {
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
var bias = 0;
var count = type1Subrs.length;
if (count < 1240)
bias = 107;
else if (count < 33900)
bias = 1131;
else
bias = 32768;
// Add a bunch of empty subrs to deal with the Type2 bias
var type2Subrs = [];
for (var i = 0; i < bias; i++)
type2Subrs.push([0x0B]);
working on subroutines
2011-08-17 02:25:02 +09:00
for (var i = 0; i < count; i++) {
var subr = type1Subrs[i];
if (!subr)
subr = [0x0B];
type2Subrs.push(this.flattenCharstring(subr, this.commandsMap));
}
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
return type2Subrs;
},
Rework some code to enhance performance (CIIM6/CIIM9 are rejected by the sanitizer now)
2011-06-17 13:02:29 +09:00
/*
* Flatten the commands by interpreting the postscript code and replacing
* every 'callsubr', 'callothersubr' by the real commands.
*/
commandsMap: {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'hstem': 1,
'vstem': 3,
'vmoveto': 4,
'rlineto': 5,
'hlineto': 6,
'vlineto': 7,
'rrcurveto': 8,
'callsubr': 10,
'return': 11,
'sub': [12, 11],
'div': [12, 12],
Initial merge of master.
2011-10-20 03:14:13 +09:00
'exch': [12, 28],
'flex': [12, 35],
working font
2011-08-18 07:55:09 +09:00
'drop' : [12, 18],
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'endchar': 14,
'rmoveto': 21,
'hmoveto': 22,
'vhcurveto': 30,
'hvcurveto': 31
Rework some code to enhance performance (CIIM6/CIIM9 are rejected by the sanitizer now)
2011-06-17 13:02:29 +09:00
},
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
flattenCharstring: function flattenCharstring(charstring, map) {
First iteration, tracemonkey/ecma262 working
2011-11-03 03:43:27 +09:00
// charstring changes size - can't cache .length in loop
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
for (var i = 0; i < charstring.length; i++) {
var command = charstring[i];
if (command.charAt) {
var cmd = map[command];
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
assert(cmd, 'Unknow command: ' + command);
Rework some code to enhance performance (CIIM6/CIIM9 are rejected by the sanitizer now)
2011-06-17 13:02:29 +09:00
Use lowercase in function names. This alleviates the confusion which functions can be instantiated with new.
2011-09-29 04:00:12 +09:00
if (isArray(cmd))
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
charstring.splice(i++, 1, cmd[0], cmd[1]);
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
else
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
charstring[i] = cmd;
} else {
Fix a > 32000 conversion error in type1 to type2 charstring
2011-07-21 18:01:38 +09:00
// Type1 charstring use a division for number above 32000
if (command > 32000) {
var divisor = charstring[i + 1];
command /= divisor;
charstring.splice(i, 3, 28, command >> 8, command & 0xff);
} else {
charstring.splice(i, 1, 28, command >> 8, command & 0xff);
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
i += 2;
Rework some code to enhance performance (CIIM6/CIIM9 are rejected by the sanitizer now)
2011-06-17 13:02:29 +09:00
}
}
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
return charstring;
Rework some code to enhance performance (CIIM6/CIIM9 are rejected by the sanitizer now)
2011-06-17 13:02:29 +09:00
},
Open the CFF class road for Type1C font
2011-07-01 07:44:11 +09:00
wrap: function wrap(name, glyphs, charstrings, subrs, properties) {
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var fields = {
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
// major version, minor version, header size, offset size
'header': '\x01\x00\x04\x04',
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'names': this.createCFFIndexHeader([name]),
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'topDict': (function topDict(self) {
Use lowercase properly in function names.
2011-09-27 02:30:05 +09:00
return function cffWrapTopDict() {
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
var header = '\x00\x01\x01\x01';
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var dict =
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\xf8\x1b\x00' + // version
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
'\xf8\x1c\x01' + // Notice
'\xf8\x1d\x02' + // FullName
'\xf8\x1e\x03' + // FamilyName
'\xf8\x1f\x04' + // Weight
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x1c\x00\x00\x10'; // Encoding
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var boundingBox = properties.bbox;
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = boundingBox.length; i < ii; i++)
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
dict += self.encodeNumber(boundingBox[i]);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
dict += '\x05'; // FontBBox;
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var offset = fields.header.length +
fields.names.length +
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
(header.length + 1) +
(dict.length + (4 + 4)) +
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
fields.strings.length +
fields.globalSubrs.length;
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
// If the offset if over 32767, encodeNumber is going to return
// 5 bytes to encode the position instead of 3.
if ((offset + fields.charstrings.length) > 32767) {
offset += 9;
} else {
offset += 7;
}
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
dict += self.encodeNumber(offset) + '\x0f'; // Charset
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
offset = offset + (glyphs.length * 2) + 1;
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
dict += self.encodeNumber(offset) + '\x11'; // Charstrings
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
offset = offset + fields.charstrings.length;
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
dict += self.encodeNumber(fields.private.length);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
dict += self.encodeNumber(offset) + '\x12'; // Private
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Fix wrong dict data offset when there is many charstrings
2011-08-27 00:18:18 +09:00
return header + String.fromCharCode(dict.length + 1) + dict;
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
};
})(this),
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'strings': (function strings(self) {
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var strings = [
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'Version 0.11', // Version
'See original notice', // Notice
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
name, // FullName
name, // FamilyName
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'Medium' // Weight
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
];
return self.createCFFIndexHeader(strings);
})(this),
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'globalSubrs': this.createCFFIndexHeader([]),
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'charset': (function charset(self) {
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
var charsetString = '\x00'; // Encoding
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
var count = glyphs.length;
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
for (var i = 0; i < count; i++) {
Clean up a bit the encoding/charset/glyphs dance
2011-08-30 07:56:02 +09:00
var index = CFFStrings.indexOf(charstrings[i].glyph);
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
// Some characters like asterikmath && circlecopyrt are
// missing from the original strings, for the moment let's
// map them to .notdef and see later if it cause any
// problems
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
if (index == -1)
index = 0;
Start converting CFF class to use strings instead of arrays
2011-07-01 07:57:17 +09:00
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
charsetString += String.fromCharCode(index >> 8, index & 0xff);
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
}
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
return charsetString;
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
})(this),
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'charstrings': this.createCFFIndexHeader([[0x8B, 0x0E]].concat(glyphs),
true),
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
Use lowercase properly in function names.
2011-09-27 02:30:05 +09:00
'private': (function cffWrapPrivate(self) {
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var data =
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'\x8b\x14' + // defaultWidth
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
'\x8b\x15'; // nominalWidth
var fieldMap = {
BlueValues: '\x06',
OtherBlues: '\x07',
FamilyBlues: '\x08',
FamilyOtherBlues: '\x09',
StemSnapH: '\x0c\x0c',
StemSnapV: '\x0c\x0d',
BlueShift: '\x0c\x0a',
BlueFuzz: '\x0c\x0b',
BlueScale: '\x0c\x09',
LanguageGroup: '\x0c\x11',
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
ExpansionFactor: '\x0c\x18'
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
};
for (var field in fieldMap) {
Show Type1 glyphs below 0x20, fix a bug in readNumberArray, read lenIV
2011-09-02 02:50:04 +09:00
if (!properties.private.hasOwnProperty(field))
continue;
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
var value = properties.private[field];
Use lowercase in function names. This alleviates the confusion which functions can be instantiated with new.
2011-09-29 04:00:12 +09:00
if (isArray(value)) {
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
data += self.encodeNumber(value[0]);
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 1, ii = value.length; i < ii; i++)
CFF/OTF font and sanitizer friendly fixes
2011-07-10 13:12:11 +09:00
data += self.encodeNumber(value[i] - value[i - 1]);
} else {
data += self.encodeNumber(value);
}
data += fieldMap[field];
}
Add support for stemHW/stemVW/stemSnapH/stemSnapV
2011-07-01 18:28:22 +09:00
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
data += self.encodeNumber(data.length + 4) + '\x13'; // Subrs offset
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
return data;
})(this),
Almost passing gjslint.
2011-07-06 15:06:45 +09:00
'localSubrs': this.createCFFIndexHeader(subrs, true)
Start converting CFF class to use strings instead of arrays
2011-07-01 07:57:17 +09:00
};
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
fields.topDict = fields.topDict();
Start converting CFF class to use strings instead of arrays
2011-07-01 07:57:17 +09:00
No more errors for an empty unicode table
2011-06-12 07:54:47 +09:00
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
var cff = [];
for (var index in fields) {
var field = fields[index];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = field.length; i < ii; i++)
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
cff.push(field.charCodeAt(i));
Remove some debug leftovers and add some comments about future directions for the code
2011-06-16 16:34:43 +09:00
}
OTF does not complain anymore about a duplicate .notdef
2011-06-12 05:08:30 +09:00
Use strings instead of arrays in CFF.wrap
2011-07-01 10:24:23 +09:00
return cff;
Add the beginning of a CFF encoder
2011-06-10 13:12:59 +09:00
}
Add the beginning of a working CFF font encoder
2011-06-10 15:40:28 +09:00
};
Name all constructors.
2011-12-09 07:18:43 +09:00
var Type2CFF = (function Type2CFFClosure() {
cleanup
2011-07-20 03:33:54 +09:00
// TODO: replace parsing code with the Type2Parser in font_utils.js
Name all constructors.
2011-12-09 07:18:43 +09:00
function Type2CFF(file, properties) {
working version, spacing not working
2011-07-19 04:22:04 +09:00
var bytes = file.getBytes();
this.bytes = bytes;
moved width setting code
2011-07-21 07:00:16 +09:00
this.properties = properties;
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
this.data = this.parse();
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
Name all constructors.
2011-12-09 07:18:43 +09:00
Type2CFF.prototype = {
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
parse: function cff_parse() {
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var header = this.parseHeader();
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
var properties = this.properties;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var nameIndex = this.parseIndex(header.endPos);
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var dictIndex = this.parseIndex(nameIndex.endPos);
cleanup code
2011-07-23 01:21:38 +09:00
if (dictIndex.length != 1)
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
error('CFF contains more than 1 font');
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var stringIndex = this.parseIndex(dictIndex.endPos);
var gsubrIndex = this.parseIndex(stringIndex.endPos);
working on cff fonts
2011-07-19 00:24:57 +09:00
var strings = this.getStrings(stringIndex);
Prevent the deprecated 'dotsection' command in Type1C to hit the sanitizer
2011-09-11 22:23:35 +09:00
var baseDict = this.parseDict(dictIndex.get(0).data);
working on cff fonts
2011-07-19 00:24:57 +09:00
var topDict = this.getTopDict(baseDict, strings);
var bytes = this.bytes;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
Basic support for the embedded font file of CIDFontType0
2011-09-13 01:32:46 +09:00
var privateDict = {};
Address review comments of #409
2011-08-31 20:42:10 +09:00
var privateInfo = topDict.Private;
Basic support for the embedded font file of CIDFontType0
2011-09-13 01:32:46 +09:00
if (privateInfo) {
var privOffset = privateInfo[1], privLength = privateInfo[0];
var privBytes = bytes.subarray(privOffset, privOffset + privLength);
baseDict = this.parseDict(privBytes);
privateDict = this.getPrivDict(baseDict, strings);
} else {
privateDict.defaultWidthX = properties.defaultWidth;
}
cleanup code
2011-07-23 01:21:38 +09:00
Address review comments of #409
2011-08-31 20:42:10 +09:00
var charStrings = this.parseIndex(topDict.CharStrings);
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var charset, encoding;
var isCIDFont = properties.subtype == 'CIDFontType0C';
if (isCIDFont) {
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
charset = ['.notdef'];
for (var i = 1, ii = charStrings.length; i < ii; ++i)
charset.push('glyph' + i);
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
encoding = this.parseCidMap(topDict.charset,
charStrings.length);
} else {
charset = this.parseCharsets(topDict.charset,
charStrings.length, strings);
encoding = this.parseEncoding(topDict.Encoding, properties,
strings, charset);
}
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
// The font sanitizer does not support CFF encoding with a
// supplement, since the encoding is not really use to map
// between gid to glyph, let's overwrite what is declared in
// the top dictionary to let the sanitizer think the font use
// StandardEncoding, that's a lie but that's ok.
Initial merge of master.
2011-10-20 03:14:13 +09:00
if (encoding.hasSupplement)
bytes[topDict.Encoding] &= 0x7F;
working on cff fonts
2011-07-19 00:24:57 +09:00
Prevent the deprecated 'dotsection' command in Type1C to hit the sanitizer
2011-09-11 22:23:35 +09:00
// The CFF specification state that the 'dotsection' command
// (12, 0) is deprecated and treated as a no-op, but all Type2
// charstrings processors should support them. Unfortunately
// the font sanitizer don't. As a workaround the sequence (12, 0)
// is replaced by a useless (0, hmoveto).
var count = charStrings.length;
for (var i = 0; i < count; i++) {
var charstring = charStrings.get(i);
var start = charstring.start;
var data = charstring.data;
var length = data.length;
for (var j = 0; j <= length; j) {
var value = data[j++];
if (value == 12 && data[j++] == 0) {
bytes[start + j - 2] = 139;
bytes[start + j - 1] = 22;
} else if (value === 28) {
j += 2;
} else if (value >= 247 && value <= 254) {
j++;
} else if (value == 255) {
j += 4;
}
}
}
cleanup
2011-07-20 03:30:42 +09:00
// charstrings contains info about glyphs (one element per glyph
cleanup code
2011-07-23 01:21:38 +09:00
// containing mappings for {unicode, width})
Initial merge of master.
2011-10-20 03:14:13 +09:00
var charstrings = this.getCharStrings(charset, encoding.encoding,
Basic support for the embedded font file of CIDFontType0
2011-09-13 01:32:46 +09:00
privateDict, this.properties);
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
Fixed the mapping from charstring to glyphs
2011-07-23 01:57:26 +09:00
// create the mapping between charstring and glyph id
var glyphIds = [];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = charstrings.length; i < ii; i++)
Fixed the mapping from charstring to glyphs
2011-07-23 01:57:26 +09:00
glyphIds.push(charstrings[i].gid);
this.charstrings = charstrings;
this.glyphIds = glyphIds;
Lie to the sanitizer about the real nature of Type1C font
2011-08-31 08:23:55 +09:00
var data = [];
for (var i = 0, ii = bytes.length; i < ii; ++i)
data.push(bytes[i]);
return data;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
},
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
Initial merge of master.
2011-10-20 03:14:13 +09:00
getCharStrings: function cff_charstrings(charsets, encoding,
Basic support for the embedded font file of CIDFontType0
2011-09-13 01:32:46 +09:00
privateDict, properties) {
working version, spacing not working
2011-07-19 04:22:04 +09:00
var charstrings = [];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var unicodeUsed = [];
var unassignedUnicodeItems = [];
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var inverseEncoding = [];
for (var charcode in encoding)
inverseEncoding[encoding[charcode]] = charcode | 0;
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = charsets.length; i < ii; i++) {
Initial merge of master.
2011-10-20 03:14:13 +09:00
var glyph = charsets[i];
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
if (glyph == '.notdef') {
charstrings.push({
unicode: 0,
code: 0,
gid: i,
glyph: glyph
});
continue;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var code = inverseEncoding[i];
if (!code || isSpecialUnicode(code)) {
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
unassignedUnicodeItems.push(i);
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
continue;
Initial merge of master.
2011-10-20 03:14:13 +09:00
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
charstrings.push({
unicode: code,
code: code,
gid: i,
glyph: glyph
});
unicodeUsed[code] = true;
Initial merge of master.
2011-10-20 03:14:13 +09:00
}
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var nextUnusedUnicode = kCmapGlyphOffset;
Merge branch 'master' of git://github.com/mozilla/pdf.js.git into encoding-2 Conflicts: src/evaluator.js src/fonts.js
2011-11-13 02:09:19 +09:00
for (var j = 0, jj = unassignedUnicodeItems.length; j < jj; ++j) {
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var i = unassignedUnicodeItems[j];
// giving unicode value anyway
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
while (nextUnusedUnicode in unicodeUsed)
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
nextUnusedUnicode++;
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
var unicode = nextUnusedUnicode++;
Address review comment for pull #419
2011-09-01 08:16:40 +09:00
charstrings.push({
Removing adaptUnicode; making cmap equal to ToUnicode tables
2011-11-28 11:43:23 +09:00
unicode: unicode,
code: inverseEncoding[i] || 0,
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
gid: i,
glyph: charsets[i]
Address review comment for pull #419
2011-09-01 08:16:40 +09:00
});
working version, spacing not working
2011-07-19 04:22:04 +09:00
}
Fixed the mapping from charstring to glyphs
2011-07-23 01:57:26 +09:00
Initial merge of master.
2011-10-20 03:14:13 +09:00
// sort the array by the unicode value (again)
charstrings.sort(function type2CFFGetCharStringsSort(a, b) {
return a.unicode - b.unicode;
});
working version, spacing not working
2011-07-19 04:22:04 +09:00
return charstrings;
},
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
parseEncoding: function cff_parseencoding(pos, properties, strings,
charset) {
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
var encoding = {};
var bytes = this.bytes;
Initial merge of master.
2011-10-20 03:14:13 +09:00
var result = {
encoding: encoding,
hasSupplement: false
};
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
function readSupplement() {
var supplementsCount = bytes[pos++];
for (var i = 0; i < supplementsCount; i++) {
var code = bytes[pos++];
var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
encoding[code] = properties.differences.indexOf(strings[sid]);
}
working on cff fonts
2011-07-19 00:24:57 +09:00
}
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
if (pos == 0 || pos == 1) {
var gid = 1;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var baseEncoding = pos ? Encodings.ExpertEncoding :
Encodings.StandardEncoding;
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = charset.length; i < ii; i++) {
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
var index = baseEncoding.indexOf(charset[i]);
if (index != -1)
encoding[index] = gid++;
}
} else {
var format = bytes[pos++];
switch (format & 0x7f) {
case 0:
var glyphsCount = bytes[pos++];
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
for (var i = 1; i <= glyphsCount; i++)
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
encoding[bytes[pos++]] = i;
break;
case 1:
var rangesCount = bytes[pos++];
var gid = 1;
for (var i = 0; i < rangesCount; i++) {
var start = bytes[pos++];
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
var left = bytes[pos++];
for (var j = start; j <= start + left; j++)
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
encoding[j] = gid++;
}
break;
default:
Fix gjslint warnings.
2011-09-09 04:37:35 +09:00
error('Unknow encoding format: ' + format + ' in CFF');
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
break;
}
Initial merge of master.
2011-10-20 03:14:13 +09:00
if (format & 0x80) {
readSupplement();
result.hasSupplement = true;
}
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
}
Initial merge of master.
2011-10-20 03:14:13 +09:00
return result;
working on cff fonts
2011-07-19 00:24:57 +09:00
},
Support Type1C built-in encoding - part1
2011-08-31 02:52:24 +09:00
working on cff fonts
2011-07-19 00:24:57 +09:00
parseCharsets: function cff_parsecharsets(pos, length, strings) {
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
if (pos == 0) {
Fix tests failure by cloning the GlyphsUnicode object
2011-09-22 20:39:28 +09:00
return ISOAdobeCharset.slice();
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
} else if (pos == 1) {
Fix tests failure by cloning the GlyphsUnicode object
2011-09-22 20:39:28 +09:00
return ExpertCharset.slice();
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
} else if (pos == 2) {
Fix tests failure by cloning the GlyphsUnicode object
2011-09-22 20:39:28 +09:00
return ExpertSubsetCharset.slice();
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
}
working on cff fonts
2011-07-19 00:24:57 +09:00
var bytes = this.bytes;
var format = bytes[pos++];
var charset = ['.notdef'];
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
cleanup code
2011-07-23 01:21:38 +09:00
// subtract 1 for the .notdef glyph
length -= 1;
working on cff fonts
2011-07-19 00:24:57 +09:00
switch (format) {
case 0:
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
for (var i = 0; i < length; i++) {
Fix lint errors and add metrics.js and charsets.js to the default set of pdf files in the Makefile
2011-09-20 11:26:37 +09:00
var sid = (bytes[pos++] << 8) | bytes[pos++];
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
charset.push(strings[sid]);
working on cff fonts
2011-07-19 00:24:57 +09:00
}
Fix some strict warnings
2011-08-31 07:37:39 +09:00
break;
working on cff fonts
2011-07-19 00:24:57 +09:00
case 1:
while (charset.length <= length) {
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
var sid = (bytes[pos++] << 8) | bytes[pos++];
var count = bytes[pos++];
for (var i = 0; i <= count; i++)
charset.push(strings[sid++]);
working on cff fonts
2011-07-19 00:24:57 +09:00
}
Fix some strict warnings
2011-08-31 07:37:39 +09:00
break;
working on cff fonts
2011-07-19 00:24:57 +09:00
case 2:
cleanup code
2011-07-23 01:21:38 +09:00
while (charset.length <= length) {
Add support for Type1C advanced charsets
2011-09-12 00:38:02 +09:00
var sid = (bytes[pos++] << 8) | bytes[pos++];
var count = (bytes[pos++] << 8) | bytes[pos++];
for (var i = 0; i <= count; i++)
charset.push(strings[sid++]);
cleanup code
2011-07-23 01:21:38 +09:00
}
Fix some strict warnings
2011-08-31 07:37:39 +09:00
break;
working on cff fonts
2011-07-19 00:24:57 +09:00
default:
cleanup code
2011-07-23 01:21:38 +09:00
error('Unknown charset format');
working on cff fonts
2011-07-19 00:24:57 +09:00
}
Fix some strict warnings
2011-08-31 07:37:39 +09:00
return charset;
working on cff fonts
2011-07-19 00:24:57 +09:00
},
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
parseCidMap: function cff_parsecharsets(pos, length) {
var bytes = this.bytes;
var format = bytes[pos++];
var encoding = {};
var map = {encoding: encoding};
encoding[0] = 0;
var gid = 1;
switch (format) {
case 0:
while (gid < length) {
var cid = (bytes[pos++] << 8) | bytes[pos++];
encoding[cid] = gid++;
}
break;
case 1:
while (gid < length) {
var cid = (bytes[pos++] << 8) | bytes[pos++];
var count = bytes[pos++];
for (var i = 0; i <= count; i++)
encoding[cid++] = gid++;
}
break;
case 2:
while (gid < length) {
var cid = (bytes[pos++] << 8) | bytes[pos++];
var count = (bytes[pos++] << 8) | bytes[pos++];
for (var i = 0; i <= count; i++)
encoding[cid++] = gid++;
}
break;
default:
error('Unknown charset format');
}
return map;
},
add correct char width
2011-07-19 07:49:32 +09:00
getPrivDict: function cff_getprivdict(baseDict, strings) {
var dict = {};
cleanup code
2011-07-23 01:21:38 +09:00
// default values
add correct char width
2011-07-19 07:49:32 +09:00
dict['defaultWidthX'] = 0;
dict['nominalWidthX'] = 0;
for (var i = 0, ii = baseDict.length; i < ii; ++i) {
var pair = baseDict[i];
var key = pair[0];
var value = pair[1];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
switch (key) {
add correct char width
2011-07-19 07:49:32 +09:00
case 20:
dict['defaultWidthX'] = value[0];
case 21:
dict['nominalWidthX'] = value[0];
default:
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
TODO('interpret top dict key: ' + key);
add correct char width
2011-07-19 07:49:32 +09:00
}
}
return dict;
},
working on cff fonts
2011-07-19 00:24:57 +09:00
getTopDict: function cff_gettopdict(baseDict, strings) {
var dict = {};
// default values
dict['Encoding'] = 0;
dict['charset'] = 0;
for (var i = 0, ii = baseDict.length; i < ii; ++i) {
var pair = baseDict[i];
var key = pair[0];
var value = pair[1];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
switch (key) {
working on cff fonts
2011-07-19 00:24:57 +09:00
case 1:
dict['Notice'] = strings[value[0]];
break;
case 4:
dict['Weight'] = strings[value[0]];
break;
case 3094:
dict['BaseFontName'] = strings[value[0]];
break;
case 5:
dict['FontBBox'] = value;
break;
case 13:
dict['UniqueID'] = value[0];
break;
case 15:
dict['charset'] = value[0];
break;
case 16:
dict['Encoding'] = value[0];
break;
case 17:
dict['CharStrings'] = value[0];
break;
case 18:
dict['Private'] = value;
break;
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
case 3102:
case 3103:
case 3104:
case 3105:
case 3106:
case 3107:
case 3108:
case 3109:
case 3110:
dict['cidOperatorPresent'] = true;
break;
working on cff fonts
2011-07-19 00:24:57 +09:00
default:
TODO('interpret top dict key');
}
}
return dict;
},
Fix a regression caused by the last patch to resolve the 'dotsection' issue
2011-09-11 23:14:28 +09:00
getStrings: function cff_getStrings(stringIndex) {
function bytesToString(bytesArray) {
var str = '';
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = bytesArray.length; i < ii; i++)
Fix a regression caused by the last patch to resolve the 'dotsection' issue
2011-09-11 23:14:28 +09:00
str += String.fromCharCode(bytesArray[i]);
return str;
cleanup code
2011-07-23 01:21:38 +09:00
}
working on cff fonts
2011-07-19 00:24:57 +09:00
var stringArray = [];
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = CFFStrings.length; i < ii; i++)
working on cff fonts
2011-07-19 00:24:57 +09:00
stringArray.push(CFFStrings[i]);
Using ii convention
2011-11-03 04:21:45 +09:00
for (var i = 0, ii = stringIndex.length; i < ii; i++)
Fix a regression caused by the last patch to resolve the 'dotsection' issue
2011-09-11 23:14:28 +09:00
stringArray.push(bytesToString(stringIndex.get(i).data));
working on cff fonts
2011-07-19 00:24:57 +09:00
return stringArray;
},
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
parseHeader: function cff_parseHeader() {
var bytes = this.bytes;
var offset = 0;
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
while (bytes[offset] != 1)
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
++offset;
cleanup code
2011-07-23 01:21:38 +09:00
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
if (offset != 0) {
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
warning('cff data is shifted');
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
bytes = bytes.subarray(offset);
this.bytes = bytes;
}
return {
endPos: bytes[2],
offsetSize: bytes[3]
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
};
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
},
parseDict: function cff_parseDict(dict) {
var pos = 0;
function parseOperand() {
var value = dict[pos++];
if (value === 30) {
working on cff fonts
2011-07-19 00:24:57 +09:00
return parseFloatOperand(pos);
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
} else if (value === 28) {
working on cff fonts
2011-07-19 00:24:57 +09:00
value = dict[pos++];
value = (value << 8) | dict[pos++];
return value;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
} else if (value === 29) {
working on cff fonts
2011-07-19 00:24:57 +09:00
value = dict[pos++];
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
value = (value << 8) | dict[pos++];
value = (value << 8) | dict[pos++];
value = (value << 8) | dict[pos++];
return value;
} else if (value <= 246) {
return value - 139;
} else if (value <= 250) {
return ((value - 247) * 256) + dict[pos++] + 108;
} else if (value <= 254) {
return -((value - 251) * 256) - dict[pos++] - 108;
} else {
Prevent the deprecated 'dotsection' command in Type1C to hit the sanitizer
2011-09-11 22:23:35 +09:00
error('255 is not a valid DICT command');
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
}
Fix some strict warnings
2011-08-31 07:37:39 +09:00
return -1;
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
working on cff fonts
2011-07-19 00:24:57 +09:00
function parseFloatOperand() {
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
var str = '';
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var eof = 15;
var lookup = ['0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', '.', 'E', 'E-', null, '-'];
var length = dict.length;
while (pos < length) {
var b = dict[pos++];
var b1 = b >> 4;
var b2 = b & 15;
if (b1 == eof)
break;
str += lookup[b1];
if (b2 == eof)
break;
str += lookup[b2];
}
return parseFloat(str);
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var operands = [];
var entries = [];
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var pos = 0;
var end = dict.length;
while (pos < end) {
var b = dict[pos];
if (b <= 21) {
working on cff fonts
2011-07-19 00:24:57 +09:00
if (b === 12) {
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
++pos;
Initial merge of master.
2011-10-20 03:14:13 +09:00
var op = dict[pos];
if ((op > 14 && op < 17) ||
(op > 23 && op < 30) || op > 38) {
warn('Invalid CFF dictionary key: ' + op);
// trying to replace it with initialRandomSeed
// to pass sanitizer
dict[pos] = 19;
}
var b = (b << 8) | op;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
}
Migration of the 'encoding-1' branch (ref #674)
2011-10-29 10:38:31 +09:00
if (!operands.length && b == 8 &&
dict[pos + 1] == 9) {
// no operands for FamilyBlues, removing the key
// and next one is FamilyOtherBlues - skipping them
// also replacing FamilyBlues to pass sanitizer
dict[pos] = 139;
pos += 2;
continue;
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
entries.push([b, operands]);
operands = [];
++pos;
} else {
operands.push(parseOperand());
}
}
return entries;
},
parseIndex: function cff_parseIndex(pos) {
var bytes = this.bytes;
var count = bytes[pos++] << 8 | bytes[pos++];
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
var offsets = [];
var end = pos;
if (count != 0) {
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var offsetSize = bytes[pos++];
working on cff fonts
2011-07-19 00:24:57 +09:00
// add 1 for offset to determine size of last object
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
var startPos = pos + ((count + 1) * offsetSize) - 1;
for (var i = 0, ii = count + 1; i < ii; ++i) {
var offset = 0;
for (var j = 0; j < offsetSize; ++j) {
offset <<= 8;
offset += bytes[pos++];
}
offsets.push(startPos + offset);
}
fix jslint warnings in fonts.js
2011-09-12 05:04:17 +09:00
end = offsets[count];
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
}
return {
get: function index_get(index) {
if (index >= count)
return null;
var start = offsets[index];
var end = offsets[index + 1];
Prevent the deprecated 'dotsection' command in Type1C to hit the sanitizer
2011-09-11 22:23:35 +09:00
return {
start: start,
end: end,
data: bytes.subarray(start, end)
Fix lint errors and add metrics.js and charsets.js to the default set of pdf files in the Makefile
2011-09-20 11:26:37 +09:00
};
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
},
working on cff fonts
2011-07-19 00:24:57 +09:00
length: count,
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
endPos: end
Correct the coding style according to gjslint. And remove stray tabs.
2011-08-09 05:13:32 +09:00
};
}
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
};
Name all constructors.
2011-12-09 07:18:43 +09:00
return Type2CFF;
added support for index, dictionary in cff
2011-07-16 00:58:09 +09:00
})();
Fix js strict warning in worker.js. Also fix a few minor nits.
2011-10-28 03:51:10 +09:00
Reference in New Issue Copy Permalink