summaryrefslogtreecommitdiff
path: root/Master/xemtex/gslib/pdf_font.ps
diff options
context:
space:
mode:
Diffstat (limited to 'Master/xemtex/gslib/pdf_font.ps')
-rw-r--r--Master/xemtex/gslib/pdf_font.ps1224
1 files changed, 0 insertions, 1224 deletions
diff --git a/Master/xemtex/gslib/pdf_font.ps b/Master/xemtex/gslib/pdf_font.ps
deleted file mode 100644
index 525ae34866e..00000000000
--- a/Master/xemtex/gslib/pdf_font.ps
+++ /dev/null
@@ -1,1224 +0,0 @@
-% Copyright (C) 1994-2002 artofcode LLC. All rights reserved.
-%
-% This program is free software; you can redistribute it and/or modify it
-% under the terms of the GNU General Public License as published by the
-% Free Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% This program is distributed in the hope that it will be useful, but
-% WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-% Public License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with this program; if not, write to the Free Software Foundation, Inc.,
-% 59 Temple Place, Suite 330, Boston, MA, 02111-1307.
-
-% $Id: pdf_font.ps,v 1.23.2.6.2.1 2003/04/12 14:02:39 giles Exp $
-% pdf_font.ps
-% PDF font operations.
-
-/.setlanguagelevel where { pop 2 .setlanguagelevel } if
-.currentglobal true .setglobal
-/pdfdict where { pop } { /pdfdict 100 dict def } ifelse
-GS_PDF_ProcSet begin
-pdfdict begin
-
-% We cache the PostScript font in an additional element of the
-% font resource dictionary, called PSFont.
-
-% ---------------- Encodings ---------------- %
-
-% Apply a list of differences to an Encoding.
-% Note that the differences may cause the array to grow.
-/updateencoding { % <encoding> <differences> updateencoding <enc'>
- % Calculate the length of the result.
- exch 0 2 index {
- dup type /nametype ne { exch pop } { pop 1 add } ifelse
- } forall
- 1 index length .max array dup 0 4 -1 roll putinterval
- exch 0 exch {
- % Stack: enc' code element
- dup type /nametype ne
- { exch pop }
- { 3 copy put pop 1 add }
- ifelse
- } forall pop
-} bdef
-
-% Get the Encoding for a font.
-/getencoding % <base-encoding> <font-resource> getencoding <enc>
- { /Encoding knownoget
- { dup type /nametype eq
- {
- % The published PDF specification says the Encoding name
- % "must be" one of the 3 predefined Encodings, implying
- % that an error should occur if it isn't. However, Acrobat
- % Reader simply ignores unknown names, and since there are
- % some buggy applications that rely on this, we do the same.
-
- dup dup dup /MacRomanEncoding eq
- exch /MacExpertEncoding eq or
- exch /WinAnsiEncoding eq or
- { exch pop findencoding
- }
- { pop
- }
- ifelse
- }
- { dup /BaseEncoding knownoget
- { findencoding 3 -1 roll pop exch
- }
- if
- /Differences knownoget { updateencoding } if
- }
- ifelse
- }
- if
- } bdef
-
-% Rename a font with a generated name.
-/renamefont { % <fontdict> renamefont <font'>
- dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
-} bind def
-
-% Adjust a font according to the Encoding and Widths in the font resource.
-/adjustfont { % <font-resource> <font> adjustfont <font'>
- getfontencoding
- getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
-} bind def
-
-% Get the (possibly modified) encoding of a font.
-/getfontencoding { % <font-resource> <font> getfontencoding
- % <font-resource> <font> <Encoding|null>
- 1 index /Encoding known {
- dup /Encoding .knownget { 2 index getencoding } { null } ifelse
- } {
- null
- } ifelse
-} bdef
-
-/find_in_diff % <Differences> <index> find_in_diff <bool>
-{ false exch 0 4 3 roll
- { dup type /nametype ne { exch pop } { pop 1 add } ifelse
- 2 copy eq {
- pop pop pop true 0 0 exit
- } if
- } forall
- pop pop
-} bdef
-
-% Get the metrics of a font, if specified.
-/getfontmetrics { % <font-resource> <font> <Encoding|null> getfontmetrics
- % <font-resource> <font> <Encoding|null>
- % <Metrics|null>
- 2 index /Widths known {
- dup null eq { pop dup /Encoding get } if
- 4 dict begin
- /Encoding exch def
- /Metrics Encoding length dict def
- exch
- dup /Widths oget /Widths exch def
- % Stack: font font-res
- % Note that widths are always based on a 1000-unit
- % character space, but the FontMatrix may specify
- % some other scale factor. Compensate for this here,
- % by scaling the Widths if necessary.
- 0.001 2 index /FontMatrix get 0 get div
- % Stack: font font-res mscale
- 1 index /FirstChar oget dup 1 4 index /LastChar oget
- { % Stack: font font-res mscale first-char index
- Encoding 1 index get
- Widths 2 index 4 index sub oget
- % Stack: font font-res mscale first-char index charname width
- 4 index mul
- % The following 'loop' is only context for 'exit'.
- {
- % Work around a bug in pdfTeX, which can generate Encoding
- % vectors containing nulls :
- 1 index null eq { exit } if
- % There is a hack here to deal with encodings where the
- % same character appears more than once, because the Metrics
- % dictionary works by character name, not by character code.
- % We prefer to take (1) non-zero width, and (2) width for
- % the character code which appears in Differences.
- Metrics 2 index .knownget not { 0 } if 0 ne {
- 5 index /Encoding knownoget not { exit } if
- dup type /dicttype ne { pop exit } if
- /Differences knownoget not { exit } if
- 3 index //find_in_diff exec not { exit } if
- } if
- 2 copy Metrics 3 1 roll put
- exit
- } loop
- pop pop pop
- }
- for pop
- % Now fill in the MissingWidth for any encoded characters
- % that aren't in Metrics already. Note that built-in
- % fonts may have Widths/FirstChar/LastChar but no
- % FontDescriptor, so we must check for this.
- % Stack: font font-res mscale
- 1 index /FontDescriptor knownoget {
- Metrics exch
- /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
- Encoding {
- % Stack: font font-res mscale missing-width metrics charname
- % Work around the abovementioned pdfTeX bug.
- dup null ne {
- 2 copy known not { 2 copy 4 index put } if pop
- } {
- pop
- } ifelse
- } forall pop pop pop
- } {
- pop
- } ifelse
- exch Encoding Metrics end
- } {
- null
- } ifelse
-} bdef
-
-currentdict /find_in_diff undef
-
-% ---------------- Descriptors ---------------- %
-
-% Partial descriptors for the 14 built-in fonts. Note that
-% from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
-% object has undergone a subtle change in its meaning which has serious
-% consequences for searching with Acrobat:
-% In PDF 1.1, the flag meant: Font has StandardEncoding
-% In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
-/standardfontdescriptors mark
- /Courier mark /Flags 16#23 .dicttomark
- /Courier-Oblique 1 index
- /Courier-Bold 1 index
- /Courier-BoldOblique 1 index
- /Helvetica mark /Flags 16#20 .dicttomark
- /Helvetica-Oblique 1 index
- /Helvetica-Bold 1 index
- /Helvetica-BoldOblique 1 index
- /Times-Roman mark /Flags 16#22 .dicttomark
- /Times-Bold 1 index
- /Times-Italic mark /Flags 16#62 .dicttomark
- /Times-BoldItalic 1 index
- /Symbol mark /Flags 16#4 .dicttomark
- /ZapfDingbats 1 index
-.dicttomark readonly def
-
-% ---------------- Utilities ---------------- %
-
-/.glyphpath { % <glyphname> <boolean> .glyphpath -
- % another glyphpath written in addxchar.ps does not work here...
- currentfont 3 1 roll exch
- currentfont dup length dict begin
- { 1 index /Encoding eq { pop [ 3 -1 roll ] def } { def } ifelse } forall
- currentdict end /.glyphpathfont exch definefont
- setfont <00> exch charpath setfont
-} bdef
-
-/makeboldfont { % <basefont> <strokewidth> makeboldfont <boldfont>
- 10 dict begin
- /strokewidth exch def
- /basefont exch def
- /FontMatrix matrix def
- %/FontName basefont /FontName get def
- /FontName /.boldfont def
- /FontType 3 def
- /Encoding basefont /Encoding get def
- /FontBBox [ basefont /FontBBox get cvx exec
- 4 2 roll basefont /FontMatrix get transform
- 4 2 roll basefont /FontMatrix get transform
- ] def
- /BuildGlyph {
- gsave
- exch begin
- basefont setfont
- strokewidth setlinewidth
- 1 setlinejoin
- newpath
- 0 0 moveto dup false .glyphpath stroke
- 0 0 moveto glyphshow
- currentpoint setcharwidth
- end
- grestore
- } bind def
- currentdict
- end
- dup /FontName get exch definefont
-} bind def
-
-% Fabricate a font name by adding ?'s on the end.
-/genfontname % <name> genfontname <name>
- { dup length string cvs
- { (?) concatstrings
- dup cvn FontDirectory exch known not { cvn exit } if
- }
- loop
- } bdef
-
-% Find a font, and adjust its encoding if necessary.
-/.pdfdfndict mark
- /defaultfontname /Helvetica
-.dicttomark readonly def
-/pdffindfont { % <font-resource> <fontname> pdffindfont <font>
- % If the font isn't available, synthesize one based on
- % its descriptor.
- dup /Font resourcestatus {
- pop pop findfont
- } {
- 1 index /FontDescriptor knownoget {
- % Stack: font-res fontname fontdesc
- dup /Flags oget
- dup 16#40 and -6 bitshift % 1, oblique/italic
- 1 index 16#40000 and -17 bitshift add % 2, bold
- exch 16#2 and 2 bitshift add % 8, serif
- % We should look at the fixed flag, too.
- % Stack: font-res fontname fontdesc properties
- 1 index /FontName oget exch
- % Analyzes font name and extract "Narrow" property
- % which is not described by the FontDescriptor Flags.
- 0 2 index .fontnameproperties 4 and or
- % Rebind the default font name to Helvetica so that
- % fonts with no properties are handled correctly.
- //.pdfdfndict begin .substitutefontname end
- % Stack: font-res fontname fontdesc substname|null
- Fontmap 1 index known not {
- % No available good substitution, use the standard one.
- pop 1 index .substitutefont
- } if
- QUIET not {
- (Substituting font ) print dup =only
- ( for ) print 2 index =only (.) = flush
- } if
- 3 -1 roll pop findfont
- % Stack: font-res fontdesc font
- % If this is a small-caps font, replace the CharString
- % entries for a..z.
- exch /Flags oget 16#20000 and 0 ne {
- true .copyfontdict
- dup /CharStrings 2 copy get dup length dict .copydict
- 4 index /FirstChar get 97 .max
- 5 index /LastChar get 122 .min 1 exch {
- % Stack: font-res font' font' /CharStrings charstrings code
- % Note that this only remaps a-z, not accented characters.
- 5 index /Widths oget 1 index 7 index /FirstChar get sub oget
- 1 string dup 0 5 -1 roll put
- % Stack: font-res font' font' /CharStrings charstrings code
- % width (x)
- 2 index exch dup cvn exch
- dup 0 2 copy get 32 sub put 4 -1 roll {
- % Stack: operand (X) width
- 0 setcharwidth exch pop
- currentfont /FontMatrix get matrix invertmatrix concat
- 0.7 dup scale 0 0 moveto show
- } /exec cvx 4 packedarray cvx put
- } for put
- renamefont
- } if
- } {
- % No descriptor available, use the default algorithm.
- findfont
- } ifelse
- } ifelse adjustfont
-} bdef
-/findpdffont { % <font-resource> <fontname> findpdffont <font>
- {} 3 1 roll % proc fnres fnname
- [
- [ (,Bold) { .03 makeboldfont } ]
- [ (,BoldItalic) { .03 makeboldfont [ 1 0 .3 1 0 0 ] makefont } bind ]
- [ (,Italic) { [ 1 0 .3 1 0 0 ] makefont } bind ]
- ] {
- 1 index dup length string cvs
- 1 index 0 get tailmatch { % proc fnres fnname []
- 3 -1 roll pop exch 1 get % proc fnres pre-fnname proc
- 4 -1 roll pop 3 1 roll % proc fnres pre-fnname
- exit
- } { pop pop } ifelse % proc fnres fnname
- } forall
- pdffindfont exch exec
-} bdef
-
-% ---------------- Type 1 fonts ---------------- %
-
-/buildType1 % <Type1-font-resource> buildType1 <font>
- { dup /BaseFont get pdffindfont
- } bdef
-
-% The state dictionary for the embedded Type 1 font reading procedure
-% has the following keys and values:
-% data - stream (filter)
-% buffer, buffer2 - string
-% hexify - procedure to convert buffer to hex if needed
-% leftstr - string containing (non-negative) integer
-% sectionstr - string containing a character 0 .. 3
-% stream - (stream) dictionary
-% proc - procedure of the form {-dict- type1read}
-% pfbhdr - string containing 16#80 if PFB, 0 otherwise
-% When the procedure is executing, this dictionary is current.
-% leftstr and sectionstr are strings so that we can change their values
-% reliably in case the font executes a restore!
-% We also have to do something special about embedded fonts that
-% execute definefont more than once -- that is the function of topFontDict.
-
-% Read an embedded Type 1 font.
-/readfontfilter { % <proc> readfontfilter <filter>
- 0 () /SubFileDecode filter
-} bdef
-/readtype1dict 5 dict dup begin
- /definefont {
- dup topFontDict eq topFontDict null eq or {
- dup wcheck not { dup length dict copy } if
- exch pop savedFontName exch
- } if
- //systemdict /definefont get exec
- } bdef
- /eexec {
- % Assume the font dictionary is directly below the file on the stack
- count 0 gt { /topFontDict 2 index cvlit store } if
- 55665 /eexecDecode filter
- //systemdict begin readtype1dictcopy begin cvx stopped
- currentdict readtype1dictcopy eq { end } if
- currentdict //systemdict eq { end } if
- { stop } if
- } bdef
-end readonly def
-/readtype1 { % <font-resource> <stream-dict> readtype1 <font>
- % Read the definition, using a procedure-based filter
- % that turns binary/hex conversion on and off
- % at the right times.
- 1 index exch
- PDFfile fileposition 3 1 roll
- 11 dict begin
- /leftstr ( ) 10 string copy def
- dup /Length1 oget leftstr cvs pop
- /sectionstr <00> 1 string copy def
- /pfbhdr <00> 1 string copy def
- /stream 1 index def
- true resolvestream /data exch def
- /buffer 1000 string def % arbitrary
- /buffer2 buffer length 2.1 div cvi 1 sub string def
- /hexify /buf2hex load def
- currentdict end
- /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
- readfontfilter
- % Some buggy embedded fonts leave extra junk on the stack,
- % so we have to make a closure that records the stack depth
- % in a fail-safe way.
- //systemdict begin
- % The PDF specification is somewhat muddy about whether
- % an embedded font's name is supposed to be the BaseFont
- % from the Font object or the FontName from the descriptor.
- % Acrobat Distiller requires the former. Save away the
- % name so we can substitute it at definefont time.
- //readtype1dict dup length 3 add dict copy begin
- 1 index /BaseFont oget /savedFontName exch def
- /topFontDict null def
- /readtype1dictcopy currentdict def
- { run } aload pop count 1 sub 2 packedarray cvx exec
- end end
- count exch sub { pop } repeat
- PDFfile 3 -1 roll setfileposition
- /BaseFont oget findfont
- adjustfont
- } bdef
-
-% Execute the appropriate reading procedure.
-/type1read % <dict> type1read <string>
- { begin leftstr cvi
- { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
- ( ) leftstr copy cvs pop end
- } bdef
-
-% Read the next block of data into the buffer.
-/type1readdata % <left> <buffer> type1readdata <substring> <left'>
- { 0 2 index 2 index length .min getinterval
- % Adobe requires readstring to signal an error if given
- % an empty string. Work around this nonsense here.
- dup length 0 ne { data exch readstring pop } if
- dup length 3 -1 roll exch sub
- DEBUG
- { dup =only ( read ) print
- 1 index length =only (: ) print
- 1 index == flush
- } if
- } bdef
-
-% Read the initial byte to see if we need to skip a 6 byte PFB header
-/type1read0 { % <left> type1read0 <string> <left'>
- sectionstr 0 1 put % either way we go to the next stage
- pfbhdr type1readdata
- 1 index 0 get 16#80 eq {
- (\n **** Warning: Embedded Type1 font in PFB format is not valid PDF.)
- pdfformaterror
- DEBUG { (skipping PFB header) = flush } if
- exch pop buffer 0 5 getinterval type1readdata exch
- dup 4 get 256 mul 1 index 3 get add 256 mul
- 1 index 2 get add 256 mul 1 index 1 get add
- DEBUG { (PFB segment length = ) print dup = } if
- exch pop % discard the string keeping the PFB segment length
- 2 copy ne {
- (\n **** Warning: Type 1 PFB segment length and Length 1 value do not match.)
- pdfformaterror
- exch % keep the PFB length instead
- } if
- pop
- buffer type1readdata % go ahead and read a block
- }
- if % if not PFB, return pfbhdr string (first char of file, usually %).
-} bdef
-
-% Read the next block of the initial text portion.
-/type1read1 { % <left> type1read1 <string> <left'>
- DEBUG { (read1 ) print } if
- dup 0 eq {
- pop sectionstr 0 2 put
- stream /Length2 oget
- % Determine whether to hexify data for eexec.
- dup 8 lt {
- type1read2 % Hexify.
- } {
- DEBUG { (read2 ) print } if
- pfbhdr 0 get 16#80 eq {
- % eat 6 more bytes of PFB junk before proceeding
- DEBUG { (skipping PFB header in segment 2) = flush } if
- buffer 0 6 getinterval type1readdata exch
- dup 5 get 256 mul 1 index 4 get add 256 mul
- 1 index 3 get add 256 mul 1 index 2 get add
- DEBUG { (PFB segment length = ) print dup = } if
- exch pop % discard the string keeping the PFB segment length
- 2 copy ne {
- (\n **** Warning: Type 1 PFB segment length and Length 2 value do not match.)
- pdfformaterror
- dup =
- exch % keep the PFB length instead
- } if
- pop
- } if
- buffer2 type1readdata exch
- % The check doesn't have to be 100% accurate:
- % hexifying is always OK.
- dup 0 8 getinterval 0 exch { or } forall
- 128 ge {
- /hexify { } store
- /buffer2 buffer def % We don't need an intermediate buffer.
- } if hexify exch
- } ifelse
- } {
- buffer type1readdata
- } ifelse
-} bdef
-
-% Convert a string from binary to hex for eexec.
-% Free variables: buffer.
-/buf2hex { % <string> buf2hex <hexstring>
- buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
- buffer (>) search pop exch pop exch pop
-} bdef
-
-% Read the next block of the encrypted portion.
-/type1trailer
-(0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-0000000000000000000000000000000000000000000000000000000000000000\n\
-cleartomark\n)
-readonly def
-/type1read2 { % <left> type1read2 <string> <left'>
- DEBUG { (read2 ) print } if
- dup 0 eq
- { pop sectionstr 0 3 put
- stream /Length3 oget
- dup 0 eq
- { DEBUG { (trailer ) print } if
- type1trailer exch
- }
- {
- pfbhdr 0 get 16#80 eq {
- % eat 6 more bytes of PFB junk before proceeding
- DEBUG { (skipping PFB header in segment 3) = flush } if
- buffer 0 6 getinterval type1readdata exch
- dup 5 get 256 mul 1 index 4 get add 256 mul
- 1 index 3 get add 256 mul 1 index 2 get add
- DEBUG { (PFB segment length = ) print dup = } if
- exch pop % discard the string keeping the PFB segment length
- 2 copy ne {
- (\n **** Warning: Type 1 PFB segment length and Length 3 value do not match.)
- pdfformaterror
- exch % keep the PFB length instead
- } if
- pop
- (\n) pdfformaterror
- } if
- type1read3
- }
- ifelse
- }
- { buffer2 type1readdata exch hexify exch
- }
- ifelse
-} bdef
-
-% Read the next block of the final text portion.
-% When finished, this procedure returns an empty string.
-/type1read3 % <left> type1read3 <string> <left'>
- { DEBUG { (read3 ) print } if
- buffer type1readdata
- } bdef
-
-% ---------------- Type 3 fonts ---------------- %
-
-/.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
-
-/buildType3 { % <Type3-font-resource> buildType3 <font>
- 8 dict begin
- /FontType 3 def
- /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
- /FontBBox 1 index /FontBBox get cvx def
- /FontMatrix 1 index /FontMatrix oget def
- /CharProcs 1 index /CharProcs oget def
- 1 index /Widths knownoget {
- /Widths exch def
- /FirstChar 1 index /FirstChar oget def
- /LastChar 1 index /LastChar oget def
- } if
- /FontName 1 index /Name get genfontname def
- /Encoding .notdefEncoding 2 index getencoding def
- % We have to define BuildChar rather than BuildGlyph:
- % there is no PDF equivalent of glyphshow, and we need
- % the character code to access the Widths.
- /BuildChar {
- % Stack: font charcode
- 1 index begin 3 dict begin
- /Font 3 -1 roll def /CharCode 1 index def
- % Make unknown characters map to /.notdef
- Encoding exch get dup CharProcs exch known
- { CharProcs exch oget }
- { pop CharProcs /.notdef oget }
- ifelse
- PDFfile fileposition exch
- false resolvestream
- % Stack: filepos stream
- % Don't let setgcolor set the color inside the BuildGlyph
- % procedure, because this causes an /undefined error.
- q null /FillColor gput null /StrokeColor gput
- Font /Resources get exch pdfopdict .pdfruncontext
- Q
- PDFfile exch setfileposition
- end end
- } bdef
- FontName currentdict end definefont exch pop
-} bdef
-/.adjustcharwidth { % <wx> <wy> .adjustcharwidth <wx'> <wy'>
- /Widths where {
- begin
- CharCode FirstChar ge CharCode LastChar le and {
- exch pop Widths CharCode FirstChar sub get exch
- } if end
- } if
-} bdef
-
-% ---------------- TrueType fonts ---------------- %
-
-/TTfonts mark
- /Arial /Helvetica
- /Arial,Italic /Helvetica-Oblique
- /Arial,Bold /Helvetica-Bold
- /Arial,BoldItalic /Helvetica-BoldOblique
- /CourierNew /Courier
- /CourierNew,Bold /Courier-Bold
- /TimesNewRoman /Times-Roman
- /TimesNewRoman,Italic /Times-Italic
- /TimesNewRoman,Bold /Times-Bold
- /TimesNewRoman,BoldItalic /Times-BoldItalic
- %
- /ArialBlack,Italic /Arial-BlackItalic
- /ArialNarrow,Bold /ArialNarrow-Bold
- /ArialNarrow,BoldItalic /ArialNarrow-BoldItalic
- /ArialNarrow,Italic /ArialNarrow-Italic
- /BookAntiqua,Bold /BookAntiqua-Bold
- /BookAntiqua,BoldItalic /BookAntiqua-BoldItalic
- /BookAntiqua,Italic /BookAntiqua-Italic
- /BookmanOldStyle,Bold /BookmanOldStyle-Bold
- /BookmanOldStyle,BoldItalic /BookmanOldStyle-BoldItalic
- /BookmanOldStyle,Italic /BookmanOldStyle-Italic
- /CenturyGothic,Bold /CenturyGothic-Bold
- /CenturyGothic,BoldItalic /CenturyGothic-BoldItalic
- /CenturyGothic,Italic /CenturyGothic-Italic
- /ComicSansMS,Bold /ComicSansMS-Bold
- /CourierNew,Bold /CourierNewPS-BoldMT
- /CourierNew,BoldItalic /CourierNewPS-BoldItalicMT
- /CourierNew,Italic /CourierNewPS-ItalicMT
- /FranklinGothicMedium,Italic /FranklinGothic-MediumItalic
- /Garamond,Bold /Garamond-Bold
- /Garamond,Italic /Garamond-Italic
- /Georgia,Bold /Georgia-Bold
- /Georgia,BoldItalic /Georgia-BoldItalic
- /Georgia,Italic /Georgia-Italic
- /Tahoma,Bold /Tahoma-Bold
- /TrebuchetMS,Bold /TrebuchetMS-Bold
- /TrebuchetMS,BoldItalic /Trebuchet-BoldItalic
- /TrebuchetMS,Italic /TrebuchetMS-Italic
- /Verdana,Bold /Verdana-Bold
- /Verdana,BoldItalic /Verdana-BoldItalic
- /Verdana,Italic /Verdana-Italic
-.dicttomark readonly def
-
-/buildTrueType { % <TrueType-font-resource> buildTrueType <font>
- dup /BaseFont get
- dup TTfonts exch .knownget {
- exch pop
- % Hack required by the PDF specification: if the
- % font resource has Subtype = /TrueType but the actual
- % (installed) font is not a TrueType font, ignore the
- % Encoding in the font resource. However, all current
- % versions of Acrobat Reader have the 14 base TrueType
- % fonts built in, so this produces incorrect output for
- % badly designed PDF files that specify these file names
- % with /Subtype = /TrueType but no embedded definition.
- % Compensate for this by removing the /Subtype key when
- % looking up the font.
- exch dup length dict copy dup /Subtype null put exch
- } if
- pdffindfont % findfont for PDF
- % disable the auto-bold and auto-italic since it sometimes applies
- % so an already bold or italic substitute font
- %findpdffont % findfont and auto-bold and/or auto-italic font for PDF
-} bdef
-
-% Read an embedded TrueType font.
-/readtruetype { % <font-resource> <stream-dict> readtruetype <font>
- % This is much simpler than readtype1, because we don't
- % have to deal with the tripartite .PFB format.
- 1 index exch
- PDFfile fileposition 3 1 roll
- true resolvestream readfontfilter
- % Stack: filepos fontres stream
- 1 index /Subtype get /CIDFontType2 eq {
- .loadttcidfont
- % Stack: filepos fontres cidfont
- 1 index /CIDToGIDMap knownoget {
- dup /Identity eq {
- pop
- } {
- true resolvestream
- % The following doesn't work for CIDToGIDMaps with more
- % than 32K-1 entries. We'll fix it later if necessary.
- % Stack: filepos fontres font mapstream
- dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
- exch dup length 5 add dict .copydict
- dup /FID undef
- dup /CIDMap 4 -1 roll put
- dup /CIDFontName get exch /CIDFont defineresource
- } ifelse
- } if
- } {
- null 2 index getencoding .loadpdfttfont
- } ifelse
- exch pop
- PDFfile 3 -1 roll setfileposition
- % Ignore both the Encoding and the Widths.
- exch pop
-} bdef
-
-% ---------------- Type 0 fonts ---------------- %
-
-% Predefine the known CMaps, but only create them on demand.
-/knownCMaps mark
- /Identity-H { /Identity-H 0 makeIdentityCMap }
- /Identity-V { /Identity-V 1 makeIdentityCMap }
-.dicttomark def
-
-/makeIdentityCMap { % <cmapname> <wmode> .makeIdentityCMap -
- .currentglobal true .setglobal 3 1 roll
- /CIDInit /ProcSet findresource begin
- 12 dict begin
- begincmap
- /WMode exch def
- /CMapName exch def
- /CIDSystemInfo 3 dict dup begin
- /Registry (Adobe) def
- /Ordering (Identity) def
- /Supplement 0 def
- end def
- %/CMapName (see above)
- /CMapVersion 1 def
- /CMapType 1 def
- %WMode (see above)
- % The PDF documentation says that these CMaps map CIDs
- % "1 to 65,536". This is a misprint for 0 to 65,535.
- 1 begincodespacerange
- % <0001> <00ff> <0100> <ffff>
- <0000> <ffff>
- endcodespacerange
- 1 begincidrange
- % <0001> <00ff> 1 <0100> <ffff> 256
- <0000> <ffff> 0
- endcidrange
- endcmap
- CMapName currentdict /CMap defineresource
- knownCMaps CMapName 2 index put
- end % CMap
- end % CIDInit ProcSet
- exch .setglobal
-} bdef
-
-/buildType0 { % <Type0-font-resource> buildType0 <font>
- dup /BaseFont get % FontName
- 1 index /Encoding oget
- dup type /nametype eq {
- dup /CMap resourcestatus {
- pop pop /CMap findresource
- } {
- knownCMaps 1 index .knownget
- { exch pop exec } { /undefined signalerror } ifelse
- } ifelse
- } {
- PDFfile fileposition exch
- dup /CMapName get exch true resolvestream cvx exec
- /CMap findresource
- exch PDFfile exch setfileposition
- } ifelse % CMap
- [
- 3 index /DescendantFonts oget { exec resourcefont } forall
- ] % subfonts
- composefont
- % Stack: fontres font
- 1 index /FontMatrix knownoget {
- dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
- 1 index exch makefont exch /FontName get exch definefont
- } {
- pop
- } ifelse
- } if exch pop
-} bdef
-
-% ---------------- CIDFontType0/2 fonts ---------------- %
-
-% Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
-% arrays and using a (currently very inefficient) CDevProc.
-% For detail, refer "PDF Reference" third edition, p. 337,
-% "5.6.3 CIDFonts" and table "Entries in a CIDFont dictionary".
-
-/.pdfDefaultDW 1000 def
-/.pdfDefaultDW2 [ 880 -1000 ] def
-
-/addCIDmetrics { % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
- dup length 5 add dict .copydict
- dup /FID undef
- dup /UniqueID undef
- dup /XUID undef
- % Insert the widths into the font.
-
- % Stack: pdfresource newfont
-
- 1 index /DW .knownget {
- 1 index /DW 3 -1 roll put
- } {
- dup /DW .pdfDefaultDW put
- } ifelse
-
-
- 1 index /W .knownget {
- dup 2 index /W 3 -1 roll put
- .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
- } if
-
-
- 1 index /DW2 .knownget {
- 1 index /DW2 3 -1 roll put
- } {
- dup /DW2 .pdfDefaultDW2 put
- } ifelse
-
-
- 1 index /W2 .knownget {
- dup 2 index /W2 3 -1 roll put
- .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
- } if
-
-
- dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
- exch pop
-} bdef
-
-/.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
-
- % convert /W or /W2 to internal expression
- %
- % mtx_array: original /W or /W2 array
- % item_size: number of metrics values per CID
- %
- % for detail of the metrics list format in PDF,
- % refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
- %
- % format of single entry in internal expression
- %
- % [
- % [cid_begin cid_end]
- % value_is_varied (bool)
- % [ [values for cid_begin...]
- % [values for cid_begin + 1]
- % ... ]
- % ]
- %
-
- 7 dict
- begin
- /itemSize exch def
- /M exch def % original /W or /W2
- /Msize M length def
- /Mi { M i get } def % W[i]
- /Mi1 { M i 1 add get } def % W[i + 1]
- /putMTXEntry <<
- /arraytype {
- [
- [Mi Mi Mi1 length add 1 sub]
- true
- [
- 0 itemSize Mi1 length 1 sub {
- [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
- } for
- ]
- ]
- /i i 2 add def
- }
- /integertype {
- [
- [Mi Mi1]
- false
- [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
- ]
- /i i 3 add def
- }
- >> def
-
- /i 0 def
-
- [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
- end
-} def
-
-/.pdfMakeInternalW { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
-/.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
-
-/.pdfGetMTXByCID { % <internalMTXArray> <cid>
- % .pdfGetMTXByCID
- % { <MTXEntry> true | false }
-
- % get values for given CID from internal format of /W or /W2
-
- exch
- {
- {
- dup 0 get {} forall % Stack: <cid> <entry> <cid_0> <cid_1>
- 3 index lt { pop pop false exit } if
- 2 index exch sub dup 0 lt { pop pop false exit } if
- 1 index 1 get not { pop 0 } if
- exch 2 get exch get true exit
- } loop
- { exit } if
- } forall
- dup type /arraytype eq { exch pop true } { pop false } ifelse
-} def
-
-
-% Apply the [D]W[2] metrics to a character before displaying.
-/CIDWProc { % <w0x> <w0y> <llx> <lly> <urx> <ury>
- % <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
- % <w0x'> ... <vy'>
-
- begin % push <font> to currentdict
- % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
- 5 1 roll pop pop pop pop
-
- {
- currentdict /DW .knownget not { % no DW
- .pdfDefaultDW exit % replace <w0x> by defaultDW
- } if
-
- currentdict /.internalW .knownget not { % no W
- exit % use already-stacked DW
- } if
-
- dup length 0 eq { % W is null array
- pop % discard unusable W
- exit % use already-stacked DW
- } if
-
- % W is finite array, try to get W_cid
- 2 index .pdfGetMTXByCID { % got W, discard DW
- exch pop {} forall
- exit
- } if
-
- exit
- } loop
-
- 1000 div % <w0x'> (normalized W)
- 0 % <w0y'>
-
- % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
- 9 -2 roll pop pop % discard <w0x> <w0y>
- 7 2 roll % put <w0x'> <w0y'>
-
- % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
- 0 % <w1x'>
- exch % put <w1x'>
-
- % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
- {
- currentdict /DW2 .knownget not { % no DW2, use defaultDW2
- .pdfDefaultDW2 exit
- } if
-
- currentdict /.internalW2 .knownget not { % has DW2, no W2
- exit % use already-stacked DW2
- } if
-
- dup length 0 eq { % W2 is null array
- pop % discard unusable W2
- exit % use already-stacked DW2
- } if
-
- 2 index .pdfGetMTXByCID { % got W2_cid, discard DW2
- exch pop
- exit
- } if
-
- % could not get W2_cid
- exit
-
- } loop
-
- exch pop % discard <cid>
-
-
- % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
- dup length 2 eq { % this is DW2
- {1000 div} forall exch
- 4 index 7 index add 2 div % <vx'> = (<urx> + <llx>) / 2
- exch
- }{ % assume W2
- {1000 div} forall
- } ifelse
- end % recover currentdict
-
-} def
-
-
-
-%----------------------------------------------------------------
-
-% <string> <match> tailmatch ==> <pre> true
-% ==> <string> false
-/tailmatch {
- 2 copy length 1 index length .min
- dup 2 index length exch sub exch getinterval
- 1 index eq {
- length 1 index length exch sub
- 0 exch getinterval true
- } {
- pop false
- } ifelse
-} bind def
-
-/makeboldcidfont {
- 16 dict begin
- /strokewidth exch def
- /basecidfont exch def
- /FontMatrix [ 1 0 0 1 0 0 ] def
-
- /CIDFontName /.boldfont def
- /CIDFontType 1 def
-
- /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
- /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
-
- /CIDSystemInfo dup basecidfont exch get def
- /FontBBox [ basecidfont /FontBBox get cvx exec
- 4 2 roll basecidfont /FontMatrix get transform
- 4 2 roll basecidfont /FontMatrix get transform
- ] def
-
- /tmpstr 2 string def
- /BuildGlyph {
- gsave
- exch begin
- dup 256 idiv tmpstr exch 0 exch put
- 256 mod tmpstr exch 1 exch put
- rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
- { basefont-V } { basefont-H } ifelse setfont
- strokewidth setlinewidth
- 1 setlinejoin
- newpath
- 0 0 moveto tmpstr false charpath stroke
- 0 0 moveto tmpstr show
- currentpoint setcharwidth
- end
- grestore
- } bind def
-
- currentdict
- end
- dup /CIDFontName get exch /CIDFont defineresource
-} bind def
-
-% <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
-% CIDFont-resource is not modified.
-/findCIDFont {
- {
- dup /CIDFont resourcestatus {
- pop pop /CIDFont findresource
- exit
- } if
-
- dup dup length string cvs
- (,Bold) tailmatch {
- exch pop
- cvn findCIDFont 0.03 makeboldcidfont
- exit
- } if
- (,Italic) tailmatch {
- exch pop
- cvn findCIDFont
- [ 1 0 0.3 1 0 0 ] makefont
- exit
- } if
- (,BoldItalic) tailmatch {
- exch pop
- cvn findCIDFont 0.03 makeboldcidfont
- [ 1 0 0.3 1 0 0 ] makefont
- exit
- } if
- pop
-
- 1 index /CIDSystemInfo get begin Registry (-) Ordering end
- concatstrings concatstrings
- cvn
- QUIET not {
- (Substituting ) print dup ==only
- ( for ) print 1 index ==only (.\n) print
- } if
- exch pop
- /CIDFont findresource
- exit
- } loop
-} bdef
-
-/buildCIDType0 { % <CIDFontType0-font-resource> buildCIDType0 <font>
- dup /BaseFont get exch 1 index findCIDFont
- addCIDmetrics /CIDFont defineresource
-} bdef
-
-/buildCIDType2 { % <CIDFontType2-font-resource> buildCIDType2 <font>
- dup /BaseFont get exch 1 index findCIDFont
- addCIDmetrics /CIDFont defineresource
-} bdef
-
-% ---------------- Other embedded fonts ---------------- %
-
-/fontloadprocs mark
- /Type1C /readType1C cvx
- /CIDFontType0C /readCIDFontType0C cvx
-.dicttomark readonly def
-
-% Read an embedded compressed font.
-/readType1C { % <font-resource> <stream-dict> readType1C <font>
- 1 index exch
- PDFfile fileposition 3 1 roll
- dup true resolvestream dup readfontfilter
- % Stack: pos resource streamdict stream filter
- 3 index /FontDescriptor oget /FontName oget
- 1 index FRD
- closefile closefile pop
- PDFfile 3 -1 roll setfileposition
- /FontDescriptor oget /FontName oget findfont
- adjustfont
-} bdef
-
-% Read an embedded CFF CIDFont.
-/readCIDFontType0C { % <font-resource> <stream-dict> readCIDFontType0C <font>
- PDFfile fileposition 3 1 roll
- dup true resolvestream dup readfontfilter
- % Stack: pos resource streamdict stream filter
- 3 index /FontDescriptor oget /FontName oget
- 1 index FRD
- closefile closefile pop
- PDFfile 3 -1 roll setfileposition
- % Some broken Adobe software produces PDF files in which
- % the FontName of the CFF font and the FontName in the
- % FontDescriptor don't match the BaseFont in the font.
- % Use the FontName, rather than the BaseFont, here.
- dup /FontDescriptor oget /FontName oget /CIDFont findresource
- addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
-} bdef
-
-% ---------------- Font lookup ---------------- %
-
-/fonttypeprocs mark % <font-resource> -proc- <font>
- /Type0 /buildType0 cvx
- /Type1 /buildType1 cvx
- /MMType1 1 index
- /Type3 /buildType3 cvx
- /TrueType /buildTrueType cvx
- /CIDFontType0 /buildCIDType0 cvx
- /CIDFontType2 /buildCIDType2 cvx
-.dicttomark readonly def
-
-/resourcefont % <font-resource> resourcefont <font>
- { dup /PSFont .knownget
- { /FID .knownget { type /fonttype eq } { false } ifelse }
- { false }
- ifelse
- { /PSFont get
- }
- { dup dup /FontDescriptor knownoget
- { % Stack: font-res font-res font-desc
- dup /FontFile knownoget
- { exch pop readtype1 true }
- { dup /FontFile2 knownoget
- { exch pop readtruetype true }
- { /FontFile3 knownoget
- { dup /Subtype get fontloadprocs exch get exec true }
- { false }
- ifelse
- }
- ifelse
- }
- ifelse
- }
- { false }
- ifelse
- % Stack: font-res font-res false
- % -or-: font-res font true
- not
- { dup /Subtype get fonttypeprocs exch get exec }
- if
- 2 copy /PSFont exch put
- exch pop
- }
- ifelse
- } bdef
-
-drawopdict begin
- /d0 {
- .adjustcharwidth setcharwidth
- } bdef
- /d1 {
- 6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
- } bdef
- /Tf {
- 1 index Page /Font rget not { 1 index /invalidfont signalerror } if
- resourcefont exch Tf pop
- } bdef
-end
-
-end % pdfdict
-end % GS_PDF_ProcSet
-.setglobal