home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 October / Chip_2002-10_cd1.bin / zkuste / pdf / download / gs704w32.exe / gs7.04 / lib / pdf_draw.ps < prev    next >
Encoding:
Text File  |  2002-01-31  |  34.5 KB  |  1,153 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: pdf_draw.ps,v 1.36 2001/10/16 22:20:31 dancoby Exp $
  19. % pdf_draw.ps
  20. % PDF drawing operations (graphics, text, and images).
  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. % For simplicity, we use a single interpretation dictionary for all
  29. % PDF graphics operations, even though this is too liberal.
  30. /drawopdict 100 dict def
  31.  
  32. % ================================ Graphics ================================ %
  33.  
  34. % ---------------- Functions ---------------- %
  35.  
  36. % Note that resolvefunction converts a PDF Function to a PostScript Function;
  37. % resolve*fnproc converts a PDF function to a PostScript procedure.
  38.  
  39. /fnrdict mark
  40.   0 { .resolvefn0 }
  41.   2 { }
  42.   3 { .resolvefn3 }
  43.   4 { .resolvefn4 }
  44. .dicttomark readonly def
  45.  
  46. /.resolvefn0 {
  47.         % Don't lose our place in PDFfile.
  48.   PDFfile fileposition exch
  49.   dup true resolvestream
  50.         % The stream isn't positionable, so read all the data now.
  51.         % Stack: filepos fndict stream
  52.   1 index /Range oget length 2 idiv 2 index /BitsPerSample oget mul
  53.   2 index /Size oget { mul } forall
  54.   7 add 8 idiv string
  55.   1 index exch readstring pop exch closefile
  56.         % Stack: filepos fndict data
  57.   exch dup length 1 add dict .copydict
  58.   dup /DataSource 4 -1 roll put
  59.   exch PDFfile exch setfileposition
  60. } bdef
  61.  
  62. /.resolvefn3 {
  63.   dup length dict .copydict
  64.   dup /Bounds 2 copy knownoget { put } { pop pop } ifelse
  65.   dup /Encode 2 copy knownoget { put } { pop pop } ifelse
  66.   dup /Functions 2 copy oget mark exch dup {
  67.     oforce .resolvefn
  68.   } forall
  69.   counttomark -1 roll astore exch pop put
  70. } bdef
  71.  
  72. /.resolvefn4 {
  73.   PDFfile fileposition exch             % filepos fndict
  74.   dup true resolvestream                % filepos fndict stream
  75.   exch dup length dict copy             % filepos stream fndict2
  76.   dup /Function undef                   % filepos stream fndict2
  77.   exch dup token not {
  78.     () /rangecheck cvx signalerror
  79.   } if
  80.   exch token {
  81.     /rangecheck cvx signalerror
  82.   } if
  83.         % Use .bind to avoid idiom recognition.
  84.   .bind
  85.   1 index /Function 3 -1 roll put
  86.   exch PDFfile exch setfileposition
  87. } bdef
  88. currentdict /tfopdict undef
  89.  
  90. /.resolvefn {        % <fndict> .resolvefn <fndict'>
  91.   dup /FunctionType oget //fnrdict exch get exec
  92. } bdef
  93.  
  94. /resolvefunction {    % <fndict> resolvefunction <function>
  95.   .resolvefn
  96.   DEBUG { (%Function: ) print dup === flush } if
  97. } bdef
  98.  
  99. /resolvefnproc {    % <fndict> resolvefnproc <proc>
  100.   resolvefunction .buildfunction
  101. } bdef
  102.  
  103. /resolveidfnproc {    % <fndict> resolveidfnproc <proc>
  104.   dup /Identity eq { pop { } } { resolvefnproc } ifelse
  105. } bdef
  106.  
  107. /resolvedefaultfnproc {    % <fndict> <default> resolved'fnproc <proc>
  108.   1 index /Default eq { exch pop } { pop resolveidfnproc } ifelse
  109. } bdef
  110.  
  111. % ---------------- Shadings ---------------- %
  112.  
  113. /shrdict mark
  114.   /ColorSpace {
  115.     resolvecolorspace
  116.   }
  117.   /Function {
  118.     dup type /dicttype eq {
  119.       resolvefunction
  120.     } {
  121.       [ exch { oforce resolvefunction } forall ]
  122.     } ifelse
  123.   }
  124. .dicttomark readonly def
  125.  
  126. /resolveshading {    % <shadingstream> resolveshading <shading>
  127.   PDFfile fileposition exch
  128.   mark exch {
  129.     oforce //shrdict 2 index .knownget { exec } if
  130.   } forall .dicttomark
  131.   dup /ShadingType get 4 ge {
  132.     dup dup true resolvestream
  133.         % Make a reusable stream so that the shading doesn't
  134.         % reposition PDFfile at unexpected times.
  135.     /ReusableStreamDecode filter /DataSource exch put
  136.   } if exch PDFfile exch setfileposition
  137. } bdef
  138. /resolvesh {        % <shname> resolveshading <shading>
  139.   Page /Shading rget {
  140.     resolveshading
  141.   } {
  142.     null
  143.   }ifelse
  144. } bdef
  145.  
  146. % ---------------- Halftones ---------------- %
  147.  
  148. /spotfunctions mark
  149.   /Round {
  150.     abs exch abs 2 copy add 1 le {
  151.       dup mul exch dup mul add 1 exch sub 
  152.     } {
  153.       1 sub dup mul exch 1 sub dup mul add 1 sub
  154.     } ifelse
  155.   }
  156.   /Diamond {
  157.     abs exch abs 2 copy add .75 le {
  158.       dup mul exch dup mul add 1 exch sub
  159.     } {
  160.       2 copy add 1.23 le {
  161.     .85 mul add 1 exch sub
  162.       } {
  163.     1 sub dup mul exch 1 sub dup mul add 1 sub
  164.       } ifelse
  165.     } ifelse
  166.   }
  167.   /Ellipse {
  168.     abs exch abs 2 copy 3 mul exch 4 mul add 3 sub dup 0 lt {
  169.       pop dup mul exch .75 div dup mul add 4 div 1 exch sub
  170.     } {
  171.       dup 1 gt {
  172.     pop 1 exch sub dup mul exch 1 exch sub
  173.     .75 div dup mul add 4 div 1 sub
  174.       } {
  175.     .5 exch sub exch pop exch pop
  176.       } ifelse
  177.     } ifelse
  178.   }
  179.   /EllipseA { dup mul .9 mul exch dup mul add 1 exch sub }
  180.   /InvertedEllipseA { dup mul .9 mul exch dup mul add 1 sub }
  181.   /EllipseB { dup 5 mul 8 div mul exch dup mul exch add sqrt 1 exch sub }
  182.   /EllipseC { dup mul .9 mul exch dup mul add 1 exch sub }
  183.   /InvertedEllipseC { dup mul .9 mul exch dup mul add 1 sub }
  184.   /Line { exch pop abs neg }
  185.   /LineX { pop }
  186.   /LineY { exch pop }
  187.   /Square { abs exch abs 2 copy lt { exch } if pop neg }
  188.   /Cross { abs exch abs 2 copy gt { exch } if pop neg }
  189.   /Rhomboid { abs exch abs 0.9 mul add 2 div }
  190.   /DoubleDot { 2 {360 mul sin 2 div exch } repeat add }
  191.   /InvertedDoubleDot { 2 {360 mul sin 2 div exch } repeat add neg }
  192.   /SimpleDot { dup mul exch dup mul add 1 exch sub }
  193.   /InvertedSimpleDot { dup mul exch dup mul add 1 sub }
  194.   /CosineDot { 180 mul cos exch 180 mul cos add 2 div }
  195.   /Double { exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add }
  196.   /InvertedDouble {
  197.     exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add neg
  198.   }
  199. .dicttomark readonly def
  200.  
  201. /htrdict mark
  202.   1 { .resolveht1 }
  203.   5 { .resolveht5 }
  204.     % We don't support types 6, 10, or 16 yet.
  205. .dicttomark readonly def
  206.  
  207. /.resolveht1 {
  208.   mark exch {
  209.     oforce
  210.     1 index /SpotFunction eq {
  211.       dup type /nametype eq
  212.     { //spotfunctions exch get } { resolvefnproc }
  213.       ifelse
  214.     } {
  215.       1 index /TransferFunction eq {
  216.     resolveidfnproc
  217.       } if
  218.     } ifelse
  219.   } forall .dicttomark
  220. } bdef
  221.  
  222. /.resolveht5 {
  223.   mark exch {
  224.     oforce dup type /dicttype eq { resolvehalftone } if
  225.   } forall .dicttomark
  226. } bdef
  227.  
  228. /resolvehalftone {    % <dict> resolvehalftone <halftone>
  229.   dup /HalftoneType get //htrdict exch get exec
  230. } bdef
  231.  
  232. % ---------------- Graphics state management ---------------- %
  233.  
  234. /cmmatrix matrix def
  235. drawopdict begin
  236.             % Graphics state stack
  237.   /q { q } def
  238.   /Q { Q } def
  239.             % Graphics state setting
  240.   /cm { //cmmatrix astore concat } def
  241.   /i /setflat load def
  242.   /J /setlinecap load def
  243.   /d /setdash load def
  244.   /j /setlinejoin load def
  245.   /w /setlinewidth load def
  246.   /M /setmiterlimit load def
  247.   /gs { gs } def
  248. end
  249.  
  250. % Each entry in this dictionary is
  251. %    <gsres> <value> -proc- <gsres>
  252. /gsbg {
  253.   /BGDefault load resolvedefaultfnproc setblackgeneration
  254. } bdef
  255. /gsucr {
  256.   /UCRDefault load resolvedefaultfnproc setundercolorremoval
  257. } bdef
  258. /gstr {
  259.   dup type /arraytype eq {
  260.     { oforce /TRDefault load resolvedefaultfnproc } forall
  261.     setcolortransfer
  262.   } {
  263.     /TRDefault load resolvedefaultfnproc settransfer
  264.   } ifelse
  265. } bdef
  266. /gsparamdict mark
  267.   /SA { setstrokeadjust }
  268.   /OP { 1 index /op known not { dup op } if OP }
  269.     % The PDF 1.3 specification says that the name /Default is only
  270.     % recognized for {BG,UCR,TR}2.  However, PDF 1.3 files produced
  271.     % by Adobe Acrobat Distiller 4.0 for Windows use the name /Default
  272.     % with the older keys, so we have to implement this.
  273.   /BG { 1 index /BG2 known { pop } { gsbg } ifelse }
  274.   /UCR { 1 index /UCR2 known { pop } { gsucr } ifelse }
  275.   /TR { 1 index /TR2 known { pop } { gstr } ifelse }
  276.   /HT {
  277.     dup /Default eq {
  278.       pop .setdefaultscreen
  279.     } {
  280.     %****** DOESN'T IMPLEMENT THE STREAM CASE YET ******
  281.       resolvehalftone sethalftone
  282.     } ifelse
  283.   }
  284.   /HTP {
  285.     % HTP may be present even if this isn't a DPS interpreter.
  286.     /sethalftonephase where { pop aload pop sethalftonephase } { pop } ifelse
  287.   }
  288.     % PDF 1.3
  289.   /Font { aload pop Tf }
  290.   /LW { setlinewidth }
  291.   /LC { setlinecap }
  292.   /LJ { setlinejoin }
  293.   /ML { setmiterlimit }
  294.   /D { aload pop setdash }
  295.   /RI { ri }
  296.   /op { op }
  297.   /OPM { OPM }
  298.   /BG2 { gsbg }
  299.   /UCR2 { gsucr }
  300.   /TR2 { gstr }
  301.   /FL { setflat }
  302.   /SM {
  303.     % SM may be present even if this is only a Level 2 interpreter.
  304.     /setsmoothness where { pop setsmoothness } { pop } ifelse
  305.   }
  306.     % PDF 1.4
  307.     % All of these require the "transparency" feature in the interpreter.
  308.   /ca { ca }
  309.   /CA { CA }
  310.   /SMask { gssmask }
  311.   /AIS { AIS }
  312.   /BM { BM }
  313.   /TK { TK }
  314. .dicttomark readonly def
  315. /gs {            % <gsres> gs -
  316.   Page /ExtGState rget {
  317.     % We keep the dictionary on the stack during the forall so that
  318.     % keys that interact with each other have access to it.
  319.     dup {
  320.       oforce exch gsparamdict exch .knownget { exec } { pop } ifelse
  321.     } forall pop
  322.   } if
  323. } bdef
  324.  
  325. % ------ Transparency support ------ %
  326.  
  327. /gssmask {
  328.   dup /None eq {
  329.     pop null
  330.   } {
  331.     % Preprocess the SMask value into a parameter dictionary for
  332.     % .begintransparencymask, with added /BBox and /Draw keys.
  333.     mark exch        % Stack: mark smaskdict
  334.     dup /S oget /Subtype exch 3 2 roll
  335.             % Stack: mark ... smaskdict
  336.     dup /BC knownoget { /Background exch 3 2 roll } if
  337.     dup /TR knownoget {
  338.       resolveidfnproc /TransferFunction exch 3 2 roll
  339.     } if    
  340.     dup /G oget dup /BBox oget /BBox exch 4 2 roll
  341.     /.execmaskgroup cvx 2 packedarray cvx /Draw exch 3 2 roll
  342.     pop .dicttomark
  343.   } ifelse SMask
  344. } bdef
  345.  
  346. % This procedure is called to actually render the soft mask.
  347. /.execmaskgroup {    % <masknum> <paramdict> <formdict> .execmaskgroup -
  348.     % Save our place in PDFfile, and do a gsave to avoid resetting
  349.     % the color space.
  350.   gsave PDFfile fileposition 4 1 roll
  351.     % We have to select the group's color space so that the
  352.     % background color will be interpreted correctly.
  353.   dup /Group oget /CS knownoget { csresolve setcolorspace } if
  354.   exch dup /BBox get aload pop .begintransparencymask {
  355.     dup /Resources knownoget { oforce } { 0 dict } ifelse
  356.     exch false resolvestream
  357.     .execgroup .endtransparencymask
  358.   } .internalstopped {
  359.     .discardtransparencymask stop
  360.   } if
  361.   PDFfile exch setfileposition grestore
  362. } bdef
  363. % Paint a Form+Group XObject, either for a transparency mask or for a Do.
  364. /.execgroup {        % <resdict> <stream> .execgroup -
  365.   gsave
  366.   1 .setopacityalpha 1 .setshapealpha
  367.   0 .inittransparencymask 1 .inittransparencymask
  368.   /Compatible .setblendmode
  369.     % Execute the body of the Form, similar to DoForm.
  370.   pdfopdict .pdfruncontext
  371.   grestore
  372. } bdef
  373.  
  374. /.beginformgroup {    % groupdict bbox .beginformgroup -
  375.   exch mark exch            % bbox mark groupdict
  376.   dup /CS knownoget { csresolve setcolorspace } if
  377.   dup /I knownoget { /Isolated exch 3 2 roll } if
  378.   dup /K knownoget { /Knockout exch 3 2 roll } if
  379.   pop .dicttomark
  380.         % Stack: bbox paramdict
  381.   exch aload pop
  382.   .begintransparencygroup
  383. } bdef
  384.  
  385. % .paintgroupform implements the Form PaintProc in the case where the
  386. % Form XObject dictionary includes a Group key.  See .paintform below.
  387. /.paintgroupform {    % <resdict> <stream> <formdict> .paintgroupform -
  388.   dup /Group oget exch /BBox oget
  389.         % Stack: resdict stream groupdict bbox
  390.   .beginformgroup {
  391.     .execgroup
  392.   } .internalstopped {
  393.     .discardtransparencygroup stop
  394.   } if .endtransparencygroup
  395. } bdef
  396.  
  397. % Make an ImageType 103 (soft-masked) image.
  398. /makesoftmaskimage {    % <datasource> <imagemask> <SMask> makesoftmaskimage
  399.             %   <datasource> <imagemask>, updates currentdict =
  400.             %   imagedict
  401.         % See the ImageType 3 case of makemaskimage below.
  402.         % SMask is a stream, another Image XObject.
  403.         % Stack: datasource imagemask(false) smaskstreamdict
  404.   PDFfile fileposition exch
  405.   dup /Matte knownoget { /Matte exch def } if
  406.   dup length dict makeimagedict pop
  407.         % In order to prevent the two data sources from being
  408.         % aliased, we need to make at least one a reusable stream.
  409.         % We pick the mask, since it's smaller (in case we need to
  410.         % read all its data now).
  411.         % Stack: datasource imagemask(false) savedpos
  412.         % maskdict is currentdict
  413.   /DataSource DataSource mark
  414.     /Intent 1
  415.     /AsyncRead true
  416.   .dicttomark .reusablestreamdecode def
  417.   PDFfile exch setfileposition
  418.   currentdict end currentdict end
  419.   5 dict begin
  420.   /ImageType 103 def
  421.   /DataDict exch def
  422.   dup /InterleaveType 3 put
  423.   DataDict /Matte .knownget {
  424.     /Matte exch def
  425.   } if
  426.   AlphaIsShape { /ShapeMaskDict } { /OpacityMaskDict } ifelse exch def
  427.   /ColorSpace DataDict /ColorSpace get def
  428. } bdef
  429.  
  430. % ---------------- Color setting ---------------- %
  431.  
  432. /01_1 [0 1] readonly def
  433. /01_3 [0 1 0 1 0 1] readonly def
  434. /01_4 [0 1 0 1 0 1 0 1] readonly def
  435.  
  436. % The keys here are resolved (PostScript, not PDF) color space names.
  437. /csncompdict mark
  438.   /DeviceGray { pop 1 }
  439.   /DeviceRGB { pop 3 }
  440.   /DeviceCMYK { pop 4 }
  441.   /CIEBasedA { pop 1 }
  442.   /CIEBasedABC { pop 3 }
  443.   /ICCBased { 1 oget /N oget }
  444.   /Separation { pop 1 }
  445.   /DeviceN { 1 oget length }
  446. .dicttomark readonly def
  447.  
  448. % Perhaps some of the values in the following need to be modified
  449. % depending on the WhitePoint value....
  450. /cslabinit mark
  451.   /DecodeABC [{16 add 116 div} bind {500 div} bind {200 div} bind]
  452.   /MatrixABC [1 1 1 1 0 0 0 0 -1]
  453.   /DecodeLMN [
  454.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  455.      0.9505 mul} bind
  456.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  457.      } bind
  458.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  459.      1.0890 mul} bind
  460.   ]
  461. .dicttomark readonly def
  462.  
  463. /csrdict mark
  464.   /DeviceGray {
  465.     /DefaultGray Page /ColorSpace rget { exch pop resolvecolorspace } if
  466.   }
  467.   /DeviceRGB {
  468.     /DefaultRGB Page /ColorSpace rget { exch pop resolvecolorspace } if
  469.   }
  470.   /DeviceCMYK { }
  471.   /CalGray {
  472.     1 oget 6 dict begin
  473.     dup /Gamma knownoget {
  474.       /exp load 2 packedarray cvx /DecodeA exch def
  475.     } if
  476.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  477.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  478.     pop [ /CIEBasedA currentdict end ]
  479.   }
  480.   /CalRGB {
  481.     1 oget 6 dict begin
  482.     dup /Gamma knownoget {
  483.       [ exch { /exp load 2 packedarray cvx } forall
  484.       ] /DecodeABC exch def
  485.     } if
  486.     dup /Matrix knownoget { /MatrixABC exch def } if
  487.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  488.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  489.     pop [ /CIEBasedABC currentdict end ]
  490.   }
  491.   /CalCMYK {
  492.     pop /DeviceCMYK        % not defined by Adobe
  493.   }
  494.   /Lab {
  495.     1 oget 6 dict begin
  496.     dup /Range knownoget not { [-100 100 -100 100] } if
  497.     [0 100 null null null null] dup 2 4 -1 roll putinterval
  498.     /RangeABC exch def
  499.     //cslabinit { def } forall
  500.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  501.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  502.     pop [ /CIEBasedABC currentdict end ]
  503.   }
  504.   /ICCBased {
  505.     PDFfile fileposition exch
  506.     dup dup 1 oget
  507.     mark exch { oforce } forall .dicttomark
  508.     dup dup true resolvestream
  509.     /ReusableStreamDecode filter /DataSource exch put
  510.     1 exch put
  511.     exch PDFfile exch setfileposition
  512.   } bind
  513.   /Separation {
  514.     aload pop exch oforce resolvecolorspace exch oforce resolvefnproc
  515.     4 array astore
  516.   }
  517.   /DeviceN {
  518.     0 4 getinterval                    % ignore attributes
  519.     aload pop 3 -1 roll oforce
  520.     3 -1 roll oforce resolvecolorspace
  521.     3 -1 roll oforce resolvefnproc
  522.     4 array astore
  523.   }
  524.   /Indexed {
  525.     aload pop 3 -1 roll oforce resolvecolorspace
  526.         % If the underlying space is a Lab space, we must scale
  527.         % the output of the lookup table as part of DecodeABC.
  528.     dup dup type /arraytype eq { 0 get } if /CIEBasedABC eq {
  529.       dup 1 get /DecodeLMN known {
  530.     1 get dup length dict copy
  531.     begin /DecodeABC [ 0 2 4 {
  532.       RangeABC 1 index 1 add get RangeABC 2 index get sub /mul load
  533.       RangeABC 3 index get /add load
  534.       DecodeABC 6 -1 roll 2 idiv get [ 6 1 roll aload pop ] cvx
  535.     } for ] def
  536.     /RangeABC //01_3 def
  537.     currentdict end /CIEBasedABC exch 2 array astore
  538.       } if
  539.     } if
  540.     3 1 roll
  541.     oforce dup type /stringtype ne {
  542.         % The color lookup table is a stream.
  543.         % Get its contents.  Don't lose our place in PDFfile.
  544.         % Stack: /Indexed basespace hival lookup
  545.     PDFfile fileposition 5 1 roll true resolvestream
  546.         % Stack: filepos /Indexed basespace hival lookupstream
  547.     1 index 1 add
  548.         % Stack: filepos /Indexed basespace hival lookupstream len
  549.     3 index
  550.       dup dup type /arraytype eq { 0 get } if
  551.       //csncompdict exch get exec mul
  552.     string readstring pop
  553.         % Stack: filepos /Indexed basespace hival table
  554.     5 -1 roll PDFfile exch setfileposition
  555.     }
  556.     if 4 array astore
  557.   }
  558.   /Pattern {
  559.     dup type /nametype ne {
  560.       dup length 1 gt {
  561.     1 oget resolvecolorspace
  562.     /Pattern exch 2 array astore
  563.       } if
  564.     } if
  565.   }
  566. .dicttomark readonly def
  567.  
  568. /cssubst {        % <csname> cssubst <cspace'> true
  569.             % <csname> cssubst false
  570.   dup resolvecolorspace
  571.   dup 1 index ne { exch pop true } { pop pop false } ifelse
  572. } bdef
  573.  
  574. /csnames mark
  575.   /DeviceGray dup  /DeviceRGB dup  /DeviceCMYK dup  /Pattern dup
  576. .dicttomark readonly def
  577. /csresolve {        % <csresourcename> csresolve <cspace>
  578.   dup Page /ColorSpace rget {
  579.     exch pop resolvecolorspace
  580.   } {
  581.     //csnames 1 index known not { /undefined cvx signalerror } if
  582.   } ifelse
  583. } bdef
  584. /resolvecolorspace {    % <cspace> resolvecolorspace <cspace'>
  585.   dup dup type /arraytype eq { 0 get } if
  586.   //csrdict exch .knownget {
  587.     exec dup type /nametype ne { dup length 1 eq { 0 get } if } if
  588.   } {
  589.     csresolve
  590.   } ifelse
  591. } bdef
  592.  
  593. /scresolve {    % <c0> ... scresolve <multi>
  594.         % We can't really make sc[n] and SC[N] work, because
  595.         % the color space information isn't available at
  596.         % conversion time; so we hack it by assuming that
  597.         % all the operands on the stack are used, and that
  598.         % if the top operand is a name, it's a Pattern resource.
  599.   dup type /nametype eq
  600.     { Page /Pattern rget { resolvepattern } { null } ifelse }
  601.   if
  602.   dup type /dicttype eq {
  603.         % Check the PaintType, if any (shading patterns don't
  604.         % have one).
  605.     dup /PaintType .knownget { 2 eq } { false } ifelse
  606.   } {
  607.     .pdfcount 1 gt
  608.   } ifelse
  609. } bdef
  610.  
  611. /.pdfpaintproc {         % <patdict> <resdict> .pdfpaintproc -
  612.   DEBUG { (%Begin PaintProc) = flush } if
  613.     % For uncolored patterns, we have to unbind the current
  614.     % color and color space before running the PaintProc.
  615.     % There's no harm in doing this for colored patterns,
  616.     % so for simplicity, we always do it.
  617.   PDFfile fileposition 3 1 roll
  618.   q
  619.   null sc1 null SC1
  620.   exch false resolvestream pdfopdict .pdfruncontext
  621.   Q
  622.   DEBUG { (%End PaintProc) = flush } if
  623.   PDFfile exch setfileposition
  624. } bdef
  625.  
  626. /resolvepattern {    % <patternstreamdict> resolvepattern <patterndict>
  627.         % Don't do the resolvestream now: just capture the data
  628.         % from the file if necessary.
  629.   dup length dict copy
  630.   dup /FilePosition .knownget {
  631.     1 index /File get dup fileposition 3 1 roll
  632.         % Stack: dict savepos pos file
  633.     dup 3 -1 roll setfileposition
  634.     dup 3 index /Length oget string readstring pop
  635.         % Stack: dict savepos file string
  636.     3 1 roll exch setfileposition
  637.     1 index /File 3 -1 roll put
  638.     dup /FilePosition undef
  639.   } if
  640.   dup /Shading knownoget {
  641.     resolveshading 1 index /Shading 3 -1 roll put
  642.   } if
  643.   dup /PaintProc [
  644.         % Bind the resource dictionary into the PaintProc.
  645.     2 index /Resources knownoget { oforce } { 0 dict } ifelse
  646.     /.pdfpaintproc cvx
  647.   ] cvx put
  648.   DEBUG {
  649.     (%Pattern: ) print dup === flush
  650.   } if
  651. } bdef
  652.  
  653. drawopdict begin
  654.   /g { /DeviceGray cssubst { cs sc1 } { g } ifelse } bdef
  655.   /rg { /DeviceRGB cssubst { cs sc* } { rg } ifelse } bdef
  656.   /k { k } bdef
  657.   /cs { csresolve cs } bdef
  658.   /sc { scresolve { sc* } { sc1 } ifelse } bdef
  659.   /scn /sc load def
  660.   /G { /DeviceGray cssubst { CS SC1 } { G } ifelse } bdef
  661.   /RG { /DeviceRGB cssubst { CS SC* } { RG } ifelse } bdef
  662.   /K { K } bdef
  663.   /CS { csresolve CS } bdef
  664.   /ri { ri } bdef
  665.   /SC { scresolve { SC* } { SC1 } ifelse } bdef
  666.   /SCN /SC load def
  667. end
  668.  
  669. % ---------------- Paths ---------------- %
  670.  
  671. drawopdict begin
  672.             % Path construction
  673.   /m /moveto load def
  674.   /l /lineto load def
  675.   /c /curveto load def
  676.   /v { currentpoint 6 2 roll curveto } def
  677.   /y { 2 copy curveto } def
  678.   /re {
  679.    4 2 roll moveto  exch dup 0 rlineto  0 3 -1 roll rlineto  neg 0 rlineto
  680.    closepath
  681.   } def
  682.   /h /closepath load def
  683.             % Path painting and clipping
  684.   /n { n } def
  685.   /S { S } def
  686.   /s { s } def
  687.   /f { f } def
  688.   /f* { f* } def
  689.   /B { B } def
  690.   /b { b } def
  691.   /B* { B* } def
  692.   /b* { b* } def
  693.   /W { W } def
  694.   /W* { W* } def
  695.   /sh { resolvesh shfill } def
  696. end
  697.  
  698. % ---------------- XObjects ---------------- %
  699.  
  700. /xobjectprocs mark        % <dict> -proc- -
  701.   /Image { DoImage }
  702.   /Form { DoForm }
  703.   /PS { DoPS }
  704. .dicttomark readonly def
  705.  
  706. % Note that the keys in defaultdecodedict are resolved (PostScript, not PDF)
  707. % color space names.
  708. /defaultdecodedict mark
  709.   /DeviceGray { pop //01_1 } bind
  710.   /DeviceRGB { pop //01_3 } bind
  711.   /DeviceCMYK { pop //01_4 } bind
  712.   /CIEBasedA { 1 get /RangeA .knownget not { //01_1 } if } bind
  713.   /CIEBasedABC { 1 get /RangeABC .knownget not { //01_3 } if } bind
  714.   /ICCBased {
  715.      1 oget dup /Range .knownget {
  716.        exch pop
  717.      }{
  718.        /N get [ exch {0 1} repeat ] readonly
  719.      } ifelse
  720.   } bind
  721.   /Separation { pop //01_1 } bind
  722.   /DeviceN {
  723.     1 oget length [ exch {0 1} repeat ] readonly
  724.   } bind
  725.   /Indexed {
  726.     pop [ 0 1 BitsPerComponent bitshift 1 sub ]
  727.   } bind
  728. .dicttomark readonly def
  729.  
  730. /checkaltimage {    % <resdict> checkaltimage <resdict[']>
  731.   Printed {
  732.     dup /Alternates knownoget {
  733.       {
  734.     dup /DefaultForPrinting knownoget {
  735.       {
  736.         /Image oget exch pop exit
  737.       } {
  738.         pop
  739.       } ifelse
  740.     } {
  741.       pop
  742.     } ifelse
  743.       } forall
  744.     } if
  745.   } if
  746. } bdef
  747.  
  748. /makeimagedict {    % <resdict> <newdict> makeimagedict <imagemask>
  749.             % On return, newdict' is currentdict
  750.   begin
  751.   /Width 2 copy oget def
  752.   /Height 2 copy oget def
  753.   /BitsPerComponent 2 copy oget def
  754.   /Interpolate 2 copy knownoget { def } { pop } ifelse
  755.   makeimagekeys
  756. } bdef
  757. /makeimagekeys {    % <resdict> makeimagekeys <imagemask>
  758.         % newdict is currentdict
  759.         % Assumes Width, Height, BPC, Interpolate already copied.
  760.   /ImageType 1 def
  761.   /ImageMatrix Width 0 0
  762.         % Handle 0-height images specially.
  763.     Height dup 0 eq { pop 1 } if neg 0 1 index neg
  764.     6 array astore def
  765.   dup /ImageMask knownoget dup { and } if {
  766.         % Image mask
  767.         % Decode is required for the PostScript image operators.
  768.                 % AI8 writes bogus decode array [0 1 0 0 0 0 0 0]
  769.     /Decode 2 copy knownoget { 0 2 getinterval } { //01_1 } ifelse def
  770.         % BitsPerComponent may be missing for masks.
  771.         % The spec requires it, but some producers omit it, and
  772.         % Acrobat Reader doesn't care.
  773.     /BitsPerComponent 2 copy known { pop } { 1 def } ifelse
  774.     true
  775.   } {
  776.         % Opaque image
  777.     dup /ColorSpace oget resolvecolorspace /ColorSpace exch def
  778.         % Decode is required for the PostScript image operators.
  779.     /Decode 2 copy knownoget not {
  780.       ColorSpace //defaultdecodedict
  781.       ColorSpace dup type /arraytype eq { 0 get } if get exec
  782.     } if def
  783.     false
  784.   } ifelse
  785.         % Even though we're going to read data,
  786.         % pass false to resolvestream so that
  787.         % it doesn't try to use Length (which may not be present).
  788.   exch false resolvestream /DataSource exch def
  789. } bdef
  790.  
  791. /DoImage {
  792.   checkaltimage dup length 6 add dict
  793.   1 index /SMask knownoget { 1 index exch /SMask exch put } if
  794.   1 index /Mask knownoget { 1 index exch /Mask exch put } if
  795.   makeimagedict doimage
  796. } bdef
  797. /makemaskimage {    % <datasource> <imagemask> <Mask> makemaskimage
  798.             %   <datasource> <imagemask>, updates currentdict =
  799.             %   imagedict
  800.   dup type /arraytype eq {
  801.     /ImageType 4 def
  802.     /MaskColor exch def
  803.   } {
  804.         % Mask is a stream, another Image XObject.
  805.         % Stack: datasource imagemask(false) maskstreamdict
  806.     PDFfile fileposition exch
  807.     dup length dict makeimagedict pop
  808.         % In order to prevent the two data sources from being
  809.         % aliased, we need to make at least one a reusable stream.
  810.         % We pick the mask, since it's smaller (in case we need to
  811.         % read all its data now).
  812.         % Stack: datasource imagemask(false) savedpos
  813.         % maskdict is currentdict
  814.     /DataSource DataSource mark
  815.       /Intent 1
  816.       /AsyncRead true
  817.     .dicttomark .reusablestreamdecode def
  818.     PDFfile exch setfileposition
  819.     currentdict end currentdict end
  820.     5 dict begin
  821.     /ImageType 3 def
  822.     /InterleaveType 3 def
  823.     /DataDict exch def
  824.     /MaskDict exch def
  825.     /ColorSpace DataDict /ColorSpace get def
  826.   } ifelse
  827. } bdef
  828. /doimage {    % <imagemask> doimage -
  829.         % imagedict is currentdict, gets popped from dstack
  830.   DataSource exch
  831.   PDFversion 1.4 ge { currentdict /SMask knownoget } { false } ifelse {
  832.     makesoftmaskimage
  833.   } {
  834.     currentdict /Mask knownoget {
  835.       makemaskimage
  836.     } if
  837.   } ifelse
  838.         % Stack: datasource imagemask
  839.    % image and imagemask can be redefined in gs_init.ps to tweak interpolation
  840.    % after device-specific files are run. Don't bind them here.
  841.    { currentdict end setfillstate /imagemask }
  842.    { ColorSpace setcolorspace currentdict end setfillblend /image }
  843.   ifelse
  844.   .systemvar exec
  845.    
  846.         % Close the input stream, unless it is PDFfile or
  847.         % PDFsource.
  848.   dup dup PDFfile eq exch PDFsource eq or { pop } { closefile } ifelse
  849. } bdef
  850.  
  851. /.paintform {    % <formdict> <resdict> <stream> .paintform -
  852.   3 -1 roll dup /Group known {
  853.     .paintgroupform
  854.   } {
  855.     pop pdfopdict .pdfruncontext
  856.   } ifelse
  857. } bdef
  858.  
  859. /DoForm {
  860.     % Adobe 2nd edition of the PDF 1.3 spec makes /FormType
  861.     % and /Matrix keys optional. Cope with the missing keys.
  862.   dup length
  863.   1 index /Matrix known
  864.     { dict
  865.     }
  866.     { 1 add dict
  867.       dup /Matrix { 1 0 0 1 0 0 } cvlit put
  868.     }
  869.   ifelse
  870.   copy
  871.   dup /FormType known not {
  872.     dup length 1 add dict copy dup /FormType 1 put
  873.   } if
  874.  
  875.   dup [ 2 index /Resources knownoget { oforce } { 0 dict } ifelse
  876.   3 index false /resolvestream cvx
  877.   /.paintform cvx
  878.   ] cvx /PaintProc exch put
  879.   execform
  880. } bdef
  881.  
  882. /DoPS {
  883.   true resolvestream cvx exec
  884. } bdef
  885.  
  886. drawopdict begin
  887.   /Do {
  888.     setfillblend
  889.     PDFfile fileposition exch
  890.     dup Page /XObject rget { 
  891.       exch pop dup /Subtype get xobjectprocs exch get
  892.         % Don't leave extra objects on the stack while executing
  893.         % the definition of the form.
  894.       3 -1 roll 2 .execn
  895.     } {
  896.         % This should cause an error, but Acrobat Reader can
  897.         % continue, so we do too.
  898.       (%stderr) (w) file
  899.       dup (****************Undefined XObject resource: ) writestring 
  900.       dup 3 -1 roll write===
  901.       flushfile
  902.     } ifelse
  903.     PDFfile exch setfileposition
  904.   } bdef
  905. end
  906.  
  907. % ---------------- In-line images ---------------- %
  908.  
  909. % Undo the abbreviations in an in-line image dictionary.
  910. % Note that we must look inside array values.
  911. % /I is context-dependent.
  912. /unabbrevkeydict mark
  913.   /BPC /BitsPerComponent  /CS /ColorSpace  /D /Decode  /DP /DecodeParms
  914.   /F /Filter  /H /Height  /I /Interpolate  /IM /ImageMask  /W /Width
  915. .dicttomark readonly def
  916. /unabbrevvaluedict mark
  917.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CC /CalCMYK
  918.   /CCF /CCITTFaxDecode  /CG /CalGray  /CR /CalRGB
  919.   /DCT /DCTDecode  /CMYK /DeviceCMYK  /Fl /FlateDecode
  920.   /G /DeviceGray  /RGB /DeviceRGB
  921.   /I /Indexed  /LZW /LZWDecode  /RL /RunLengthDecode
  922. .dicttomark readonly def
  923. /unabbrevtypedict mark
  924.   /nametype {
  925.     //unabbrevvaluedict 1 index .knownget { exch pop } if
  926.   }
  927.   /arraytype {
  928.     dup 0 1 2 index length 1 sub {
  929.       2 copy get unabbrevvalue put dup
  930.     } for pop
  931.   }
  932. .dicttomark readonly def
  933. /unabbrevvalue {    % <obj> unabbrevvalue <obj'>
  934.   oforce //unabbrevtypedict 1 index type .knownget { exec } if
  935. } bdef
  936.  
  937. drawopdict begin
  938.   /BI { mark } bdef
  939.   /ID {
  940.     counttomark 2 idiv dup 6 add dict begin {
  941.       exch //unabbrevkeydict 1 index .knownget { exch pop } if
  942.       exch unabbrevvalue def
  943.     } repeat pop
  944.     /File PDFsource def
  945.     currentdict makeimagekeys doimage    
  946.     % The Adobe documentation says that the data following ID
  947.     % consists of "lines", and some PDF files (specifically, some files
  948.     % produced by PCL2PDF from Visual Software) contain garbage bytes
  949.     % between the last byte of valid data and an EOL.
  950.         % Some files (PDFOUT v3.8d by GenText) have EI immediately following
  951.         % the stream. Some have no EOL and garbage bytes.
  952.         % Therefore, we skip all bytes before EI or EOL 
  953.     0
  954.       { PDFsource read not { //true exit } if
  955.         dup 10 eq 1 index 13 eq or
  956.           { pop PDFsource token pop /EI ne exit
  957.           }
  958.         if
  959.         exch 69 eq 1 index 73 eq and { //false exit } if  % 'EI'
  960.       }
  961.     loop
  962.     exch pop
  963.       { /ID cvx /syntaxerror signalerror
  964.       }
  965.     if
  966.   } bdef
  967. end
  968.  
  969. % ================================ Text ================================ %
  970.  
  971. drawopdict begin
  972.             % Text control
  973.   /BT { BT } def
  974.   /ET { ET } def
  975.   /Tc { Tc } def
  976.   /TL { TL } def
  977.   /Tr { Tr } def
  978.   /Ts { Ts } def
  979.   /Tw { Tw } def
  980.   /Tz { Tz } def
  981.             % Text positioning
  982.   /Td { Td } def
  983.   /TD { TD } def
  984.   /Tm { Tm } def
  985.   /T* { T* } def
  986.             % Text painting
  987.   /Tj { Tj } def
  988.   /' { ' } def
  989.   /" { " } def
  990.   /TJ { TJ } def
  991. end
  992.  
  993. % ============================== Annotations ============================== %
  994.  
  995.  
  996.  
  997. % Get and normalize an annotation's rectangle.
  998. /annotrect {        % <annot> annotrect <x> <y> <w> <h>
  999.   /Rect get aload pop
  1000.   exch 3 index sub dup 0 lt { dup 5 -1 roll add 4 1 roll neg } if
  1001.   exch 2 index sub dup 0 lt { dup 4 -1 roll add 3 1 roll neg } if
  1002. } bdef
  1003.  
  1004. % Set an annotation color.
  1005. /annotsetcolor {    % <annot> annotsetcolor -
  1006.   /C knownoget { aload pop setrgbcolor } { 0 setgray } ifelse
  1007. } bdef
  1008.  
  1009. % Draw the border.  Currently, we ignore requests for beveling, and we
  1010. % don't round the corners of rectangles.
  1011. /strokeborder {        % <annot> <width> <dash> strokeborder -
  1012.   1 index 0 ne {    % do not draw if border width is 0
  1013.     gsave
  1014.     2 index annotsetcolor
  1015.     0 setdash dup setlinewidth
  1016.     exch annotrect
  1017.     2 { 4 index sub 4 1 roll } repeat
  1018.     2 { 4 index 0.5 mul add 4 1 roll } repeat
  1019.     rectstroke pop
  1020.     grestore
  1021.   } {
  1022.     pop pop pop
  1023.   } ifelse
  1024. } bdef
  1025.  
  1026. % Draw an annotation border.
  1027. /drawborder {        % <annot> drawborder -
  1028.   gsave
  1029.   dup /BS knownoget {
  1030.     dup /W knownoget not { 1 } if
  1031.     [] 2 index /S knownoget {
  1032.       /D eq { 2 index /D knownoget not { [3] } if exch pop } if
  1033.     } if 3 -1 roll pop strokeborder
  1034.   } {
  1035.     dup /Border knownoget {
  1036.       dup 2 get
  1037.       exch dup length 3 gt { 3 get } { pop [] } ifelse
  1038.       strokeborder
  1039.     } {
  1040.       pop
  1041.     } ifelse
  1042.   } ifelse
  1043.   grestore
  1044. } bdef
  1045.  
  1046. %
  1047. %   The PDF annotation F (flags) integer is bit encoded.
  1048. %   Bit 1 (LSB) Invisible:  1 --> Do not display if no handler.
  1049. %         Note:  We have no handlers but we ignore this bit.
  1050. %   Bit 2 Hidden:  1 --> Do not display.  We will not display if this bit is set.
  1051. %   Bit 3 Print:  1 --> Display if printing.  We will display if this bit set
  1052. %         (and not hidden) and Printed is true
  1053. %   Bit 4 NoZoom:  1 --> Do not zoom annotation even if image is zoomed.
  1054. %   Bit 5 NoRotate:  1 --> Do not rotate annotation even if image is rotated.
  1055. %   Bit 6 NoView:  0 --> Display if this is a 'viewer'.  We will display
  1056. %         if this bit is not set (and not hidden) and Printed is false
  1057. %   Bit 7 Read Only - 1 --> No interaction.  We ignore this bit
  1058. %
  1059. /annotvisible {            % <annot> annotvisible <visible>
  1060.   /F knownoget not { 0 } if         % Get flag value
  1061.   dup 2 and 0 eq              % Check hidden flag
  1062.   exch dup 4 and 0 ne Printed and    % Check print flag
  1063.   exch 64 and 0 eq Printed not and    % Check noview flag
  1064.   or                    % Combine print and view
  1065.   and                     % Combine with 'hidden' flag test
  1066. } bdef
  1067.  
  1068. /drawwidget {            % <scalefactor> <annot> drawwidget -
  1069.   dup /AP knownoget {
  1070.     % Always use the Normal appearance.
  1071.     /N oget
  1072.         % Acrobat Distiller produces files in which this Form
  1073.         % XObject lacks Type and Subtype keys.  This is illegal,
  1074.         % but Acrobat Reader accepts it.  The only way we can
  1075.         % tell whether this is a Form or a set of sub-appearances
  1076.         % is by testing for the stream Length key.
  1077.     dup /Length known {
  1078.               % If this is a form then simply use it
  1079.       true
  1080.     } {
  1081.       1 index /AS knownoget not {
  1082.               % If we do not have AS then use any appearance
  1083.     { exch pop oforce exit } forall true
  1084.       } { 
  1085.         % Stack: annot Ndict AS
  1086.         % Get the specified appearance.  If no appearance, then
  1087.         % display nothing - set stack = false.
  1088.     knownoget
  1089.       } ifelse
  1090.     } ifelse
  1091.  
  1092.         % Stack: scale annot appearance true
  1093.         % Stack: scale annot false
  1094.     {
  1095.               % Draw appearance
  1096.       1 index annotrect pop pop translate
  1097.       2 index dup scale        % Apply scale factor
  1098.       DoForm
  1099.     } if
  1100.   } if pop pop
  1101. } bdef
  1102.  
  1103. %
  1104. %  For stamp object we have to determine the size of the output rectangle
  1105. %  and the size of the BBox for the stamp image.  From these we calculate
  1106. %  a scale factor for drawing the stamp.
  1107. %
  1108. /calcstampscale {        % <annot> calcstampscale scale
  1109.   dup annotrect 4 -2 roll pop pop pop    % get x width
  1110.   dup 0 lt { neg } if        % get magnitude
  1111.   exch /AP knownoget {
  1112.     /N knownoget {
  1113.       /BBox knownoget {
  1114.          aload pop 4 -2 roll pop pop pop
  1115.          div
  1116.       } {
  1117.         pop 1            % default to unity scaling
  1118.       } ifelse            % if we have /BBox
  1119.     } {
  1120.       pop 1
  1121.     } ifelse            % if we have /N
  1122.   } {
  1123.     pop 1
  1124.   } ifelse            % if we have /AP
  1125. } bdef
  1126.  
  1127. /drawlink {            % <annot> drawlink -
  1128.   dup drawborder
  1129.   1 exch drawwidget
  1130. } bdef
  1131.  
  1132. % Draw an annotation.
  1133. /drawannottypes mark
  1134.   /Link { drawlink } bind
  1135.   /Stamp { dup calcstampscale exch drawwidget } bind
  1136. .dicttomark readonly def
  1137. /drawannot {        % <annot> drawannot -
  1138.   dup annotvisible {
  1139.     gsave
  1140.     dup dup /Subtype get //drawannottypes exch .knownget {
  1141.       exec
  1142.     } {
  1143.       1 exch drawwidget        % Use drawwidget for everything else
  1144.     } ifelse            % type known
  1145.     grestore
  1146.   } if pop            % annotvisible
  1147. } bdef
  1148. currentdict /drawannottypes undef
  1149.  
  1150. end            % pdfdict
  1151. end            % GS_PDF_ProcSet
  1152. .setglobal
  1153.