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