home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 10 / AU_CD10.iso / Updates / GhostScript / !GhostScr / 6_01 / lib / pdf_font.ps < prev    next >
Text File  |  2000-03-29  |  22KB  |  695 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % $Id: pdf_font.ps,v 1.2 2000/03/10 03:57:50 lpd Exp $
  19. % pdf_font.ps
  20. % PDF font operations.
  21.  
  22. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  23. .currentglobal true .setglobal
  24. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  25. GS_PDF_ProcSet begin
  26. pdfdict begin
  27.  
  28. % We cache the PostScript font in an additional element of the
  29. % font resource dictionary, called PSFont.
  30.  
  31. % ---------------- Encodings ---------------- %
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   exch 0 2 index {
  38.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  39.   } forall
  40.   1 index length .max array dup 0 4 -1 roll putinterval
  41.   exch 0 exch {
  42.         % Stack: enc' code element
  43.     dup type /nametype ne
  44.       { exch pop }
  45.       { 3 copy put pop 1 add }
  46.     ifelse
  47.   } forall pop
  48. } bdef
  49.  
  50. % Get the Encoding for a font.
  51. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  52.  { /Encoding knownoget
  53.     { dup type /nametype eq
  54.        { exch pop findencoding
  55.        }
  56.        { dup /BaseEncoding knownoget
  57.       { findencoding 3 -1 roll pop exch
  58.       }
  59.      if
  60.      /Differences knownoget { updateencoding } if
  61.        }
  62.       ifelse
  63.     }
  64.    if
  65.  } bdef
  66.  
  67. % Rename a font with a generated name.
  68. /renamefont {        % <fontdict> renamefont <font'>
  69.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  70. } bind def
  71.  
  72. % Adjust a font according to the Encoding and Widths in the font resource.
  73. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  74.   getfontencoding getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  75. } bind def
  76.  
  77. % Get the (possibly modified) encoding of a font.
  78. /getfontencoding {    % <font-resource> <font> getfontencoding
  79.             %   <font-resource> <font> <Encoding|null>
  80.   1 index /Encoding known {
  81.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  82.   } {
  83.     null
  84.   } ifelse
  85. } bdef
  86.  
  87. % Get the metrics of a font, if specified.
  88. /getfontmetrics        % <font-resource> <font> <Encoding|null> getfontmetrics
  89.             %   <font-resource> <font> <Encoding|null>
  90.             %   <Metrics|null>
  91.  { 2 index /Widths known
  92.     { dup null eq { pop dup /Encoding get } if
  93.       2 dict begin
  94.       /Encoding exch def
  95.       /Metrics Encoding length dict def
  96.       exch
  97.         % Stack: font font-res
  98.         % Note that widths are always based on a 1000-unit
  99.         % character space, but the FontMatrix may specify
  100.         % some other scale factor.  Compensate for this here,
  101.         % by scaling the Widths if necessary.
  102.       0.001 2 index /FontMatrix get 0 get div
  103.         % Stack: font font-res mscale
  104.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  105.        {    % Stack: font font-res mscale first-char index
  106.      Encoding 1 index get
  107.      4 index /Widths oget 2 index 4 index sub get
  108.          % Stack: font font-res mscale first-char index charname width
  109.      4 index mul
  110.         % There is a hack here to deal with encodings where the
  111.         % same character appears more than once, because the Metrics
  112.         % dictionary works by character name, not by character code.
  113.         % Because of this, we can't deal with Width vectors that
  114.         % specify different widths for the same character name
  115.         % appearing multiple times in the Encoding.
  116.      Metrics 2 index .knownget not { 0 } if 0 ne {
  117.        pop pop
  118.      } {
  119.         % Work around a bug in pdfTeX, which can generate Encoding
  120.         % vectors containing nulls.
  121.        1 index null ne {
  122.          Metrics 3 1 roll put
  123.        } {
  124.          pop pop
  125.        } ifelse
  126.      }
  127.      ifelse pop
  128.        }
  129.       for pop
  130.         % Now fill in the MissingWidth for any encoded characters
  131.         % that aren't in Metrics already.  Note that built-in
  132.         % fonts may have Widths/FirstChar/LastChar but no
  133.         % FontDescriptor, so we must check for this.
  134.         % Stack: font font-res mscale
  135.       1 index /FontDescriptor knownoget {
  136.     Metrics exch
  137.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  138.     Encoding {
  139.         % Stack: font font-res mscale missing-width metrics charname
  140.         % Work around the abovementioned pdfTeX bug.
  141.       dup null ne {
  142.         2 copy known not { 2 copy 4 index put } if pop
  143.       } {
  144.         pop
  145.       } ifelse
  146.     } forall pop pop pop
  147.       } {
  148.     pop
  149.       } ifelse
  150.       exch Encoding Metrics end
  151.     }
  152.     { null
  153.     }
  154.    ifelse
  155.  } bdef
  156.  
  157. % ---------------- Descriptors ---------------- %
  158.  
  159. % Partial descriptors for the 14 built-in fonts.  Note that
  160. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  161. % object has undergone a subtle change in its meaning which has serious
  162. % consequences for searching with Acrobat:
  163. % In PDF 1.1, the flag meant: Font has StandardEncoding
  164. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  165. /standardfontdescriptors mark
  166.   /Courier mark /Flags 16#23 .dicttomark
  167.   /Courier-Oblique 1 index
  168.   /Courier-Bold 1 index
  169.   /Courier-BoldOblique 1 index
  170.   /Helvetica mark /Flags 16#20 .dicttomark
  171.   /Helvetica-Oblique 1 index
  172.   /Helvetica-Bold 1 index
  173.   /Helvetica-BoldOblique 1 index
  174.   /Times-Roman mark /Flags 16#22 .dicttomark
  175.   /Times-Bold 1 index
  176.   /Times-Italic mark /Flags 16#62 .dicttomark
  177.   /Times-BoldItalic 1 index
  178.   /Symbol mark /Flags 16#4 .dicttomark
  179.   /ZapfDingbats 1 index
  180. .dicttomark readonly def
  181.  
  182. % ---------------- Utilities ---------------- %
  183.  
  184. % Fabricate a font name by adding ?'s on the end.
  185. /genfontname        % <name> genfontname <name>
  186.  { dup length string cvs
  187.     { (?) concatstrings
  188.       dup cvn FontDirectory exch known not { cvn exit } if
  189.     }
  190.    loop
  191.  } bdef
  192.  
  193. % Find a font, and adjust its encoding if necessary.
  194. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  195.         % If the font isn't available, synthesize one based on
  196.         % its descriptor.
  197.   dup /Font resourcestatus {
  198.     pop pop findfont
  199.   } {
  200.     1 index /FontDescriptor knownoget {
  201.         % Stack: font-res fontname fontdesc
  202.       dup /Flags oget
  203.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  204.       1 index 16#40000 and -17 bitshift add    % 2, bold
  205.       exch 16#2 and 2 bitshift add    % 8, serif
  206.         % We should look at the fixed flag, too.
  207.         % Stack: font-res fontname fontdesc properties
  208.       1 index /FontName oget exch
  209.       1 index .fontnameproperties or
  210.       .substitutefontname
  211.         % Stack: font-res fontname fontdesc substname|null
  212.       Fontmap 1 index known not {
  213.         % No available good substitution, use the standard one.
  214.     pop 1 index .substitutefont
  215.       } if
  216.       QUIET not {
  217.     (Substituting font ) print dup =only
  218.     ( for ) print 2 index =only (.) = flush
  219.       } if
  220.       3 -1 roll pop findfont
  221.         % Stack: font-res fontdesc font
  222.         % If this is a small-caps font, replace the CharString
  223.         % entries for a..z.
  224.       exch /Flags oget 16#20000 and 0 ne {
  225.     true .copyfontdict
  226.     dup /CharStrings 2 copy get dup length dict .copydict
  227.     4 index /FirstChar get 97 .max
  228.     5 index /LastChar get 122 .min 1 exch {
  229.         % Stack: font-res font' font' /CharStrings charstrings code
  230.         % Note that this only remaps a-z, not accented characters.
  231.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  232.       1 string dup 0 5 -1 roll put
  233.         % Stack: font-res font' font' /CharStrings charstrings code
  234.         %   width (x)
  235.       2 index exch dup cvn exch
  236.       dup 0 2 copy get 32 sub put 4 -1 roll {
  237.             % Stack: operand (X) width
  238.         0 setcharwidth exch pop
  239.         currentfont /FontMatrix get matrix invertmatrix concat
  240.         0.7 dup scale 0 0 moveto show
  241.       } /exec cvx 4 packedarray cvx put
  242.     } for put
  243.     renamefont
  244.       } if
  245.     } {
  246.         % No descriptor available, use the default algorithm.
  247.       findfont
  248.     } ifelse
  249.   } ifelse adjustfont
  250. } bdef
  251.  
  252. % ---------------- Type 1 fonts ---------------- %
  253.  
  254. /buildType1        % <Type1-font-resource> buildType1 <font>
  255.  { dup /BaseFont get pdffindfont
  256.  } bdef
  257.  
  258. % The state dictionary for the embedded Type 1 font reading procedure
  259. % has the following keys and values:
  260. %    data - stream (filter)
  261. %    buffer, buffer2 - string
  262. %    leftstr - string containing (non-negative) integer
  263. %    sectionstr - string containing a character 0 .. 2
  264. %    stream - (stream) dictionary
  265. %    proc - procedure of the form {-dict- type1read}
  266. % When the procedure is executing, this dictionary is current.
  267. % leftstr and sectionstr are strings so that we can change their values
  268. % reliably in case the font executes a restore!
  269. % We also have to do something special about embedded fonts that
  270. % execute definefont more than once -- that is the function of topFontDict.
  271.  
  272. % Read an embedded Type 1 font.
  273. /readfontfilter {    % <proc> readfontfilter <filter>
  274.   0 () /SubFileDecode filter
  275. } bdef
  276. /readtype1dict 5 dict dup begin
  277.   /definefont {
  278.     dup topFontDict eq topFontDict null eq or {
  279.       dup wcheck not { dup length dict copy } if
  280.       exch pop savedFontName exch
  281.     } if
  282.     //systemdict /definefont get exec
  283.   } bdef
  284.   /eexec {
  285.         % Assume the font dictionary is on the top of the stack.
  286.     count 0 gt { /topFontDict 1 index cvlit store } if
  287.     55665 /eexecDecode filter
  288.     //systemdict begin readtype1dictcopy begin cvx stopped
  289.     currentdict readtype1dictcopy eq { end } if
  290.     currentdict //systemdict eq { end } if
  291.      { stop } if
  292.   } bdef
  293. end readonly def
  294. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  295.         % Read the definition, using a procedure-based filter
  296.         % that turns binary/hex conversion on and off
  297.         % at the right times.
  298.    1 index exch
  299.    PDFfile fileposition 3 1 roll
  300.    7 dict begin
  301.      /leftstr (          ) 10 string copy def
  302.        dup /Length1 oget leftstr cvs pop
  303.      /sectionstr <00> 1 string copy def
  304.      /stream 1 index def
  305.      true resolvestream /data exch def
  306.      /buffer 1000 string def        % arbitrary
  307.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  308.    currentdict end
  309.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  310.    readfontfilter
  311.         % Some buggy embedded fonts leave extra junk on the stack,
  312.         % so we have to make a closure that records the stack depth
  313.         % in a fail-safe way.
  314.    //systemdict begin
  315.         % The PDF specification is somewhat muddy about whether
  316.         % an embedded font's name is supposed to be the BaseFont
  317.         % from the Font object or the FontName from the descriptor.
  318.         % Acrobat Distiller requires the former.  Save away the
  319.         % name so we can substitute it at definefont time.
  320.    //readtype1dict dup length 3 add dict copy begin
  321.    1 index /BaseFont oget /savedFontName exch def
  322.    /topFontDict null def
  323.    /readtype1dictcopy currentdict def
  324.     { run } aload pop count 1 sub 2 packedarray cvx exec
  325.    end end
  326.    count exch sub { pop } repeat
  327.    PDFfile 3 -1 roll setfileposition
  328.    /BaseFont oget findfont
  329.    adjustfont
  330.  } bdef
  331.  
  332. % Execute the appropriate reading procedure.
  333. /type1read        % <dict> type1read <string>
  334.  { begin leftstr cvi
  335.     { type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  336.    (          ) leftstr copy cvs pop end
  337.  } bdef
  338.  
  339. % Read the next block of data into the buffer.
  340. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  341.  { 0 2 index 2 index length min getinterval
  342.         % Adobe requires readstring to signal an error if given
  343.         % an empty string.  Work around this nonsense here.
  344.    dup length 0 ne { data exch readstring pop } if
  345.    dup length 3 -1 roll exch sub
  346.    DEBUG
  347.     { dup =only ( read ) print
  348.       1 index length =only (: ) print
  349.       1 index == flush
  350.     } if
  351.  } bdef
  352.  
  353. % Read the next block of the initial text portion.
  354. /type1read1        % <left> type1read1 <string> <left'>
  355.  { DEBUG { (read1 ) print } if
  356.    dup 0 eq
  357.     { pop sectionstr 0 1 put
  358.       stream /Length2 oget type1read2
  359.     }
  360.     { buffer type1readdata
  361.     }
  362.    ifelse
  363.  } bdef
  364.  
  365. % Read the next block of the encrypted portion.
  366. /type1trailer
  367. (0000000000000000000000000000000000000000000000000000000000000000\n\
  368. 0000000000000000000000000000000000000000000000000000000000000000\n\
  369. 0000000000000000000000000000000000000000000000000000000000000000\n\
  370. 0000000000000000000000000000000000000000000000000000000000000000\n\
  371. 0000000000000000000000000000000000000000000000000000000000000000\n\
  372. 0000000000000000000000000000000000000000000000000000000000000000\n\
  373. 0000000000000000000000000000000000000000000000000000000000000000\n\
  374. 0000000000000000000000000000000000000000000000000000000000000000\n\
  375. cleartomark\n)
  376. readonly def
  377. /type1read2        % <left> type1read2 <string> <left'>
  378.  { DEBUG { (read2 ) print } if
  379.    dup 0 eq
  380.     { pop sectionstr 0 2 put
  381.       stream /Length3 oget
  382.       dup 0 eq
  383.        { DEBUG { (trailer ) print } if
  384.      type1trailer exch
  385.        }
  386.        { type1read3
  387.        }
  388.       ifelse
  389.     }
  390.     { buffer2 type1readdata exch
  391.       buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  392.       buffer (>) search pop exch pop exch pop exch
  393.     }
  394.    ifelse
  395.  } bdef
  396.  
  397. % Read the next block of the final text portion.
  398. % When finished, this procedure returns an empty string.
  399. /type1read3        % <left> type1read3 <string> <left'>
  400.  { DEBUG { (read3 ) print } if
  401.    buffer type1readdata
  402.  } bdef
  403.  
  404. % ---------------- Type 3 fonts ---------------- %
  405.  
  406. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  407.  
  408. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  409.   8 dict begin
  410.     /FontType 3 def
  411.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  412.     /FontBBox 1 index /FontBBox get cvx def
  413.     /FontMatrix 1 index /FontMatrix oget def
  414.     /CharProcs 1 index /CharProcs oget def
  415.     1 index /Widths knownoget {
  416.       /Widths exch def
  417.       /FirstChar 1 index /FirstChar oget def
  418.       /LastChar 1 index /LastChar oget def
  419.     } if
  420.     /FontName 1 index /Name get genfontname def
  421.     /Encoding .notdefEncoding 2 index getencoding def
  422.         % We have to define BuildChar rather than BuildGlyph:
  423.         % there is no PDF equivalent of glyphshow, and we need
  424.         % the character code to access the Widths.
  425.     /BuildChar {
  426.         % Stack: font charcode
  427.       1 index begin 3 dict begin
  428.       /Font 3 -1 roll def /CharCode 1 index def
  429.       Encoding exch get CharProcs exch oget
  430.       PDFfile fileposition exch
  431.       false resolvestream
  432.         % Stack: filepos stream
  433.         % Don't let setgcolor set the color inside the BuildGlyph
  434.         % procedure, because this causes an /undefined error.
  435.       q null /FillColor gput null /StrokeColor gput
  436.       Font /Resources get exch pdfopdict .pdfruncontext
  437.       Q
  438.       PDFfile exch setfileposition
  439.       end end
  440.     } bdef
  441.     FontName currentdict end definefont exch pop
  442. } bdef
  443. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  444.   /Widths where {
  445.     begin
  446.     CharCode FirstChar ge CharCode LastChar le and {
  447.       exch pop Widths CharCode FirstChar sub get exch
  448.     } if end
  449.   } if
  450. } bdef
  451.  
  452. % ---------------- TrueType fonts ---------------- %
  453.  
  454. /TTfonts mark
  455.   /Arial /Helvetica
  456.   /Arial,Italic /Helvetica-Oblique
  457.   /Arial,Bold /Helvetica-Bold
  458.   /Arial,BoldItalic /Helvetica-BoldOblique
  459.   /CourierNew /Courier
  460.   /CourierNew,Bold /Courier-Bold
  461.   /TimesNewRoman /Times-Roman
  462.   /TimesNewRoman,Italic /Times-Italic
  463.   /TimesNewRoman,Bold /Times-Bold
  464.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  465. .dicttomark readonly def
  466.  
  467. /buildTrueType        % <TrueType-font-resource> buildTrueType <font>
  468.  { dup /BaseFont get
  469.    dup TTfonts exch .knownget { exch pop } if pdffindfont
  470.  } bdef
  471.  
  472. % Read an embedded TrueType font.
  473. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  474.         % This is much simpler than readtype1, because we don't
  475.         % have to deal with the tripartite .PFB format.
  476.   1 index exch
  477.   PDFfile fileposition 3 1 roll
  478.   true resolvestream readfontfilter
  479.         % Stack: filepos fontres stream
  480.   1 index /Subtype get /CIDFontType2 eq {
  481.     .loadttcidfont
  482.   } {
  483.     .loadttfont
  484.   } ifelse
  485.   exch pop
  486.   PDFfile 3 -1 roll setfileposition
  487.         % Ignore both the Encoding and the Widths.
  488.   exch pop
  489. } bdef
  490.  
  491. % ---------------- Type 0 fonts ---------------- %
  492.  
  493. % Predefine the known CMaps, but only create them on demand.
  494. /knownCMaps mark
  495.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  496.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  497. .dicttomark def
  498.  
  499. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  500.   .currentglobal true .setglobal 3 1 roll
  501.   /CIDInit /ProcSet findresource begin
  502.   12 dict begin
  503.     /WMode exch def
  504.     /CMapName exch def
  505.     begincmap
  506.     /CIDSystemInfo 3 dict dup begin
  507.       /Registry (Adobe) def
  508.       /Ordering (Japan1) def
  509.       /Supplement 0 def
  510.     end def
  511.     %/CMapName ... def
  512.     /CMapVersion 1 def
  513.     /CMapType 1 def
  514.     %/WMode ... def
  515.     % The PDF documentation says that these CMaps map CIDs
  516.     % "1 to 65,536".  We think this is a misprint for 0 to 65,535.
  517.     2 begincodespacerange
  518.     % <0001> <00ff>  <0100> <ffff>
  519.       <0000> <ffff>
  520.     endcodespacerange
  521.     2 begincidrange
  522.     % <0001> <00ff> 1   <0100> <ffff> 256
  523.       <0000> <ffff> 0
  524.     endcidrange
  525.     endcmap
  526.     CMapName currentdict /CMap defineresource
  527.     knownCMaps CMapName 2 index put
  528.   end        % CMap
  529.   end        % CIDInit ProcSet
  530.   exch .setglobal
  531. } bdef
  532.  
  533. /buildType0        % <Type0-font-resource> buildType0 <font>
  534. { 10 dict begin
  535.   /FontType 0 def
  536.   /FontMatrix 1 index /FontMatrix knownoget not { matrix } if def
  537.   /FontName 1 index /BaseFont get def
  538.   /FMapType 9 def
  539.   /Encoding [
  540.     0 1 4 index /DescendantFonts oget length 1 sub { } for
  541.   ] def
  542.   /FDepVector [
  543.     2 index /DescendantFonts oget { exec resourcefont } forall
  544.   ] def
  545.   /CMap 1 index /Encoding oget
  546.     dup type /nametype eq {
  547.       dup /CMap resourcestatus {
  548.     pop pop /CMap findresource
  549.       } {
  550.     knownCMaps 1 index .knownget
  551.       { exch pop exec } { /undefined signalerror } ifelse
  552.       } ifelse
  553.     } {
  554.       resolvestream
  555.     } ifelse
  556.   def
  557.   FontName currentdict end definefont exch pop
  558. } bdef
  559.  
  560. % ---------------- CIDFontType0/2 fonts ---------------- %
  561.  
  562. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  563. % arrays and using a (currently very inefficient) CDevProc.
  564. /addCIDmetrics {    % <CIDFont-resource> addCIDmetrics <fontdict>
  565.   dup /BaseFont get /CIDFont findresource
  566.   dup length 5 add dict .copydict
  567.   dup /FID undef
  568.   dup /UniqueID undef
  569.   dup /XUID undef
  570.     % Insert the widths into the font.
  571.   {W W2 DW DW2} {
  572.     % Stack: pdfresource newfont key
  573.     2 index 1 index .knownget {
  574.       2 index 3 1 roll put
  575.     } {
  576.       pop
  577.     } ifelse
  578.   } forall
  579.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  580.   exch pop
  581. } bdef
  582.  
  583. % Apply the [D]W[2] metrics to a character before displaying.
  584. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  585.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  586.             %   <w0x'> ... <vy'>
  587.   begin
  588.     % Look up and apply [D]W
  589.   10 index
  590.   currentdict /DW .knownget { 1000 div exch pop } if
  591.   currentdict /W .knownget {
  592.     % Search the W array for the CID.
  593.     % ****** NOT IMPLEMENTED YET ******
  594.     pop
  595.   } if
  596.   0 13 2 roll 11 -2 roll pop pop
  597.     % Look up and apply [D]W2
  598.     % ****** NOT IMPLEMENTED YET ******
  599.   pop end
  600. } bdef
  601.  
  602. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  603.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  604. } bdef
  605.  
  606. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  607.   addCIDmetrics
  608.     %****** Handle CIDToGIDMap ******
  609.   dup /BaseFont get exch /CIDFont defineresource
  610. } bdef
  611.  
  612. % ---------------- Other embedded fonts ---------------- %
  613.  
  614. /fontloadprocs mark
  615.   /Type1C /readType1C cvx
  616. .dicttomark readonly def
  617.  
  618. % Read an embedded compressed font.
  619. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  620.   1 index exch
  621.   PDFfile fileposition 3 1 roll
  622.   dup true resolvestream dup readfontfilter
  623.         % Stack: pos resource streamdict stream filter
  624.   3 index /FontDescriptor oget /FontName oget
  625.   1 index FRD
  626.   closefile closefile pop
  627.   PDFfile 3 -1 roll setfileposition
  628.   /FontDescriptor oget /FontName oget findfont
  629.   adjustfont
  630.  } bdef
  631.  
  632. % ---------------- Font lookup ---------------- %
  633.  
  634. /fonttypeprocs mark        % <font-resource> -proc- <font>
  635.   /Type0 /buildType0 cvx
  636.   /Type1 /buildType1 cvx
  637.   /MMType1 1 index
  638.   /Type3 /buildType3 cvx
  639.   /TrueType /buildTrueType cvx
  640.   /CIDFontType0 /buildCIDType0 cvx
  641.   /CIDFontType2 /buildCIDType2 cvx
  642. .dicttomark readonly def
  643.  
  644. /resourcefont            % <font-resource> resourcefont <font>
  645.  { dup /PSFont .knownget
  646.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  647.     { false }
  648.    ifelse
  649.     { /PSFont get
  650.     }
  651.     { dup dup /FontDescriptor knownoget
  652.        {    % Stack: font-res font-res font-desc
  653.      dup /FontFile knownoget
  654.       { exch pop readtype1 true }
  655.       { dup /FontFile2 knownoget
  656.          { exch pop readtruetype true }
  657.          { /FontFile3 knownoget
  658.         { dup /Subtype get fontloadprocs exch get exec true }
  659.         { false }
  660.            ifelse
  661.          }
  662.         ifelse
  663.       }
  664.      ifelse
  665.        }
  666.        { false }
  667.       ifelse
  668.         % Stack: font-res font-res false
  669.         %  -or-: font-res font true
  670.       not
  671.        { dup /Subtype get fonttypeprocs exch get exec }
  672.       if
  673.       2 copy /PSFont exch put
  674.       exch pop
  675.     }
  676.    ifelse
  677.  } bdef
  678.  
  679. drawopdict begin
  680.   /d0 {
  681.     .adjustcharwidth setcharwidth
  682.   } bdef
  683.   /d1 {
  684.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  685.   } bdef
  686.   /Tf {
  687.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  688.     resourcefont exch Tf pop
  689.   } bdef
  690. end
  691.  
  692. end            % pdfdict
  693. end            % GS_PDF_ProcSet
  694. .setglobal
  695.