Subversion Repositories planix.SVN

%    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.

% 

% This software is provided AS-IS with no warranty, either express or

% implied.

% 

% This software is distributed under license and may not be copied,

% modified or distributed except as expressly authorized under the terms

% of the license contained in the file LICENSE in this distribution.

% 

% For more information about licensing, please refer to

% http://www.ghostscript.com/licensing/. For information on

% commercial licensing, go to http://www.artifex.com/licensing/ or

% contact Artifex Software, Inc., 101 Lucas Valley Road #110,

% San Rafael, CA  94903, U.S.A., +1(415)492-9861.

% $Id: pdf_ops.ps,v 1.41 2005/09/28 04:33:27 dan Exp $

% Definitions for most of the PDF operators.

.currentglobal true .setglobal

% Define pdfmark.  Don't allow it to be bound in.

% Also don't define it in systemdict, because this leads some Adobe code

% to think this interpreter is a distiller.

% (If this interpreter really is a distiller, don't do this.)

systemdict /pdfmark known not

 { userdict /pdfmark { cleartomark } bind put } if

userdict /GS_PDF_ProcSet 127 dict dup begin

% ---------------- Abbreviations ---------------- %

/bdef { bind def } bind def

% ---------------- Graphics state stack ---------------- %

% PDF adds a number of parameters to the graphics state.

% We implement this by pushing and popping a dictionary

% each time we do a PDF gsave or grestore.

% The keys in this dictionary are as follows:

%	self			% identifies the dictionary as one of ours

%	ClipRect		% (optional)

%	Show

%	TextSaveMatrix		% matrix at time of BT (iff within BT/ET)

% (The following correspond directly to PDF state parameters.)

%	AlphaIsShape

%	FillConstantAlpha

%	FillColor

%	FillColorSpace

%	FillOverprint

%	SoftMask

%	StrokeConstantAlpha

%	StrokeColor

%	StrokeColorSpace

%	StrokeOverprint

%	TextSpacing

%	TextHScaling

%	Leading

%	TextFont

%	TextLineMatrix

%	TextMatrix

%	TextRise

%	TextRenderingMode

%	WordSpacing

/nodict 1 dict def

nodict /self { //nodict } executeonly put

nodict readonly pop

/dictbeginpage {	% <initialdict> dictbeginpage -

  //nodict 20 dict .copydict begin { def } forall

  graphicsbeginpage textbeginpage

} bdef

/endpage {	% - endpage -

  showpage end

} bdef

/graphicsbeginpage {

  initgraphics

  currentdict /ClipRect knownoget { aload pop rectclip } if

  1 ca  1 CA  null SMask  false AIS  /Compatible BM  true TK

} bdef

/gput		% <value> <key> gput -

 { exch currentdict //nodict eq { /self dup load end 5 dict begin def } if

		% If we're in a Level 1 system, we need to grow the

		% dictionary explicitly.

   currentdict length currentdict maxlength ge %eq

    { currentdict dup length 3 mul 2 idiv 1 add dict .copydict end begin 

    }

   if def

 } bdef

% Restore graphics state, but do not modify path. Paths are not part

% of the PDF graphics state; see 4.4.1 of PDF reference 3rd ed.

/grestore_nopath {

  % Collect the upath with an identity CTM

  { matrix setmatrix //false upath } stopped {

    pop grestore newpath

  } {

    % Save the CTM, set identity during the uappend, then set the CTM

    grestore matrix currentmatrix matrix setmatrix

    exch newpath uappend setmatrix

  } ifelse

} bdef

/q {

  gsave //nodict begin

} bdef

% Some PDF files have excess Q operators!

/Q {

  currentdict /self .knownget {

    exec //nodict eq { end grestore_nopath false } { true } ifelse

  } {

    true	% formaterror -- not a gsave dict

  } ifelse

  { (\n   **** File has imbalanced q/Q operators \(too many Q's\) ****\n)

    pdfformaterror

  } if

} bdef

% Save PDF gstate

/qstate {       % - qstate <qstate>

  gstate

} bdef

% Set PDF gstate

/setqstate {    % <qstate> setqstate -

  { matrix setmatrix //false upath } stopped {

    pop setgstate newpath

  } {

    % Save the CTM, set identity during the uappend, then set the CTM

    exch setgstate matrix currentmatrix matrix setmatrix

    exch newpath uappend setmatrix

  } ifelse

} bdef

% ---------------- Color setting ---------------- %

/fcput		% <color> <colorspace> fcput -

 { /FillColorSpace gput /FillColor gput

 } bdef

/scput		% <color> <colorspace> scput -

 { /StrokeColorSpace gput /StrokeColor gput

 } bdef

/csput		% <colorspace> csput -

 { csset 2 copy fcput scput

 } bdef

/csdevgray [/DeviceGray] readonly def

/csdevrgb [/DeviceRGB] readonly def

/csdevcmyk [/DeviceCMYK] readonly def

/cspattern [/Pattern] readonly def

/nullpattern1 mark

   /PatternType 1 /PaintType 1 /TilingType 3 /BBox [0 0 0 0]

   /XStep 1 /YStep 1 /PaintProc { }

.dicttomark readonly def

/nullpattern2 nullpattern1 dup length dict copy readonly def

% Each entry in the color space dictionary is a procedure of the form

%	<cspace> -proc- <cspace> <initial-color>

/CSdict mark

  /DeviceGray { pop //csdevgray 0 } bind

  /DeviceRGB { pop //csdevrgb [0 0 0] cvx } bind

  /DeviceCMYK { pop //csdevcmyk [0 0 0 1] cvx } bind

  /CIEBasedA { 0 } bind

  /CIEBasedABC { [0 0 0] cvx } bind

  /ICCBased { [ 1 index 1 oget /N get { 0 } repeat ] cvx } bind

  /Separation { 1 } bind

  /DeviceN {	% What is the correct value??

    [ 1 index 1 get length { 1 } repeat ] cvx

  } bind

  /Indexed { 0 } bind

  /Pattern {

    dup type /nametype eq 1 index length 1 eq or {

      pop //cspattern //nullpattern1 matrix makepattern

    } {

      //nullpattern2 matrix makepattern 1 index 1 get csset

		% Stack: patternspace nullpattern basecolor basespace

      pop [ 3 1 roll dup type /arraytype eq { aload pop } if

      counttomark -1 roll ] cvx

    } ifelse

  } bind

.dicttomark readonly def

/csset			% <cspace> csset <color> <cspace>

 { dup dup type /nametype ne { 0 get } if //CSdict exch get exec exch

 } bdef

/g { //csdevgray fcput } bdef

/G { //csdevgray scput } bdef

/rg { 3 array astore cvx //csdevrgb fcput } bdef

/RG { 3 array astore cvx //csdevrgb scput } bdef

/k { 4 array astore cvx //csdevcmyk fcput } bdef

/K { 4 array astore cvx //csdevcmyk scput } bdef

/cs { csset fcput } bdef

/CS { csset scput } bdef

/ri { pop } bdef

% We have to break up sc according to the number of operands.

/sc1 { /FillColor gput } bdef

/SC1 { /StrokeColor gput } bdef

% We have to avoid storing into a color array associated with an outer

% gsave level, so we do a kind of "copy on write".

/sc* {

  currentdict /FillColor .knownget {

    astore pop

  } {

    /FillColor load

    % FillColor may contain either a single value or an array.

    dup type /arraytype eq { length }{ pop 1 } ifelse

    array astore cvx /FillColor gput

  } ifelse

} bdef

/SC* {

  currentdict /StrokeColor .knownget {

    astore pop

  } {

    /StrokeColor load

    % StrokeColor may contain either a single value or an array.

    dup type /arraytype eq { length }{ pop 1 } ifelse

    array astore cvx /StrokeColor gput

  } ifelse

} bdef

% ---------------- Overprint/transparency setting ---------------- %

/op { /FillOverprint gput } bdef

/OP { /StrokeOverprint gput } bdef

/OPM {

  /.setoverprintmode where { pop .setoverprintmode } { pop } ifelse

} bdef

/ca { /FillConstantAlpha gput } bdef

/CA { /StrokeConstantAlpha gput } bdef

/SMask { /SoftMask gput } bdef

/AIS { /AlphaIsShape gput } bdef

/BM {

  /.setblendmode where {

    pop [ exch dup type /nametype ne { aload pop } if /Normal ] {

      { .setblendmode } .internalstopped not { exit } if pop

    } forall

  } {

    pop

  } ifelse

} bdef

/TK {

  /.settextknockout where { pop .settextknockout } { pop } ifelse

} bdef

% ---------------- Color installation ---------------- %

% Establish a given color (and color space) as current.

/.settransparencyparams {	% <alpha> <smask> .settransparencyparams -

  /.inittransparencymask where {

    pop AlphaIsShape {

      1 .setopacityalpha 0 .inittransparencymask exch .setshapealpha 1

    } {

      1 .setshapealpha 1 .inittransparencymask exch .setopacityalpha 0

    } ifelse

	% Set the soft mask by rendering the XObject.  Doing this every time

	% is obviously very inefficient; we'll improve it later.

    .settransparencymask    

  } {

    pop pop

  } ifelse

} bdef

/.settransparencymask {		% <paramdict> <masknum> .settransparencymask -

  exch dup null eq {

    pop .inittransparencymask

  } {

    dup /Draw get exec

  } ifelse

} bdef

% (Non-mask) images must execute setfillblend.

/setfillblend {

  FillOverprint setoverprint

  FillConstantAlpha SoftMask .settransparencyparams

} def

/setfillstate {

  FillColor FillColorSpace setgcolor setfillblend

} def

/setstrokestate {

  StrokeColor StrokeColorSpace setgcolor StrokeOverprint setoverprint

  StrokeConstantAlpha SoftMask .settransparencyparams

} def

/Cdict 15 dict dup begin	% <color...> <colorspace> -proc- -

  /DeviceGray { pop setgray } bdef

  /DeviceRGB { pop setrgbcolor } bdef

  /DeviceCMYK { pop setcmykcolor } bdef

  /CIEBasedA { setgcolorspace setcolor } bdef

  /CIEBasedABC /CIEBasedA load def

  /CIEBasedDEF /CIEBasedA load def

  /CIEBasedDEFG /CIEBasedA load def

  /ICCBased /CIEBasedA load def

  /Separation /CIEBasedA load def

  /DeviceN /CIEBasedA load def

  /Indexed /CIEBasedA load def

  /Pattern

   { setgcolorspace

     % Since multiple patterns may share

     % same data stream, we need to ensure

     % that the stream is at 0 position.

     % Making this consistently with resolveshading,

     % which applies ReusableStreamDecode filter

     % to the PS stream, which represents the

     % PDF stream in dynamics.

     dup /Shading knownoget {

       dup /ShadingType oget 4 ge {

         /DataSource knownoget {

           dup type /filetype eq {

           } {

             pop

           } ifelse

         } if

       } {

        pop

       } ifelse

     } if

     dup /Matrix knownoget not { matrix } if

     gsave DefaultQstate setqstate makepattern grestore setcolor

   } bdef

end def

/setgcolor	% (null | <color...>) <colorspace> setgcolor -

 { 1 index null eq

    { pop pop }

    { dup 0 get //Cdict exch get exec }

   ifelse

 } bdef

% Compare the old and new color spaces in an attempt to avoid expensive

% reloads of CIEBased color spaces.

/PCSdict 15 dict dup begin	% <colorspace> -proc- <colorspace|pdfcspace>

  /CIEBasedA { dup 1 get /PDFColorSpace .knownget { exch pop } if } bdef

  /CIEBasedABC /CIEBasedA load def

  /CIEBasedDEF /CIEBasedA load def

  /CIEBasedDEFG /CIEBasedA load def

  /Indexed {

    dup 1 get dup pdfcolorspace 2 copy ne { 3 1 roll } if pop pop

  } bdef

end def

/pdfcolorspace {	% <colorspace> pdfcolorspace <colorspace|pdfcspace>

  dup type /arraytype eq {

    //PCSdict 1 index 0 get .knownget { exec } if

  } if

} bdef

/setgcolorspace {	% <colorspace> setgcolorspace -

  dup pdfcolorspace currentcolorspace pdfcolorspace eq {

    pop

  } {

    setcolorspace

  } ifelse

} bdef

/fsexec		% <fillop|strokeop> fsexec -

 {		% Preserve the current point, if any.

    { currentpoint } stopped

    { $error /newerror false put   cvx exec }

    { 3 -1 roll cvx exec moveto }

   ifelse

 } bdef

% ---------------- Path painting and clipping ---------------- %

/S { setstrokestate /stroke fsexec } bdef

/f { setfillstate /fill fsexec } bdef

/f* { setfillstate /eofill fsexec } bdef

/n { newpath } bdef		% don't allow n to get bound in

/s { closepath S } bdef

/B { gsave setfillstate fill grestore S } bdef

/b { closepath B } bdef

/B* { gsave setfillstate eofill grestore S } bdef

/b* { closepath B* } bdef

% Clipping:

/Wdict 4 dict dup begin

/S { gsave setstrokestate stroke grestore n } bdef

/f { gsave setfillstate fill grestore n } bdef

/f* { gsave setfillstate eofill grestore n } bdef

/n { end clip newpath } bdef

end readonly def

/W { //Wdict begin } bdef

/W*dict 4 dict dup begin

Wdict { def } forall

/n { end eoclip newpath } bdef

end readonly def

/W* { //W*dict begin } bdef

% ---------------- Text control ---------------- %

/textbeginpage

 { /TextSpacing 0 def		% 0 Tc

   /TextLeading 0 def		% 0 TL

   /TextRenderingMode 0 def	% 0 Tr

   /TextRise 0 def		% 0 Ts

   /WordSpacing 0 def		% 0 Tw

   /TextHScaling 1.0 def	% 100 Tz

   /TextFont null def

   /Show { showfirst } def

 } bdef

% Contrary to the statement in the PDF manual, BT and ET *can* be nested,

% if the CharProc for a Type 3 font does a BT/ET itself.

% Since we always call the CharProc inside a q/Q, we simply ensure that

% the text state is saved and restored like the rest of the extended

% graphics state.

/settextmatrix {

  TextMatrix concat

  TextHScaling 1 ne { TextHScaling 1 scale } if

  TextRise 0 ne { 0 TextRise translate } if

  TextFont dup null eq { pop } { setfont } ifelse

} bdef

/settextstate {

	% The text state can be set even outside BT/ET.

  currentdict /TextSaveMatrix known {

    TextSaveMatrix setmatrix settextmatrix

  } if

} bdef

/settextposition {

		% Update the TextMatrix translation.

  gsave TextSaveMatrix setmatrix

  currentpoint TextRise sub TextMatrix 4 2 getinterval astore pop

		% We would like to do "grestore currentpoint translate"

		% here, but some PDF files set a singular text matrix

		% (0 0 0 0 <x> <y> Tm), so we can't do this.

  TextTempMatrix identmatrix setmatrix currentpoint

  grestore

  TextTempMatrix currentmatrix 4 2 getinterval astore pop

  TextTempMatrix setmatrix

} bdef

/BT {

  currentdict /TextLineMatrix .knownget

    { identmatrix pop TextMatrix identmatrix pop }

    { matrix /TextLineMatrix gput matrix /TextMatrix gput }

  ifelse

  { showfirst } /Show gput

  currentdict /TextSaveMatrix .knownget not {

    matrix dup /TextSaveMatrix gput

  } if currentmatrix pop settextmatrix

  matrix /TextTempMatrix gput		% see settextposition

} bdef

/ET {

  TextRenderingMode 4 ge { clip newpath } if

  TextSaveMatrix setmatrix

  currentdict /TextSaveMatrix undef

} bdef

/Tc { /TextSpacing gput { showfirst } /Show gput } bdef

/TL { /TextLeading gput } bdef

/Tr { dup .settextrenderingmode /TextRenderingMode gput { showfirst } /Show gput } bdef

/Ts { /TextRise gput settextstate } bdef

/Tw { /WordSpacing gput { showfirst } /Show gput } bdef

/Tz { 100 div /TextHScaling gput settextstate} bdef

% ---------------- Font control ---------------- %

/Tf {		% <font> <scale> Tf -

  dup 0 eq {

    (\n   **** Warning: Invalid 0.0 font scale given for Tf ****\n)

    pdfformaterror

    pop 0.00000001	% handle invalid scale by using a really small value

  } if

  dup 1 eq { pop } { scalefont } ifelse

  /TextFont gput settextstate

} bdef

% Read a CFF font.

/FRD		% <resname> <file> FRD -

 { /FontSetInit /ProcSet findresource begin //true ReadData

 } bdef

% Copy a font, removing its FID.  If changed is true, also remove

% the UniqueID and XUID, if any.  If the original dictionary doesn't have

% the keys being removed, don't copy it.

/.copyfontdict		% <font> <changed> .copyfontdict <dict>

 { 1 index /FID known

   1 index { 2 index /UniqueID known or 2 index /XUID known or } if

    {		% We add 1 to the length just in case the original

		% didn't have a FID.

      exch dup length 1 add dict exch

       {		% Stack: changed newfont key value

	 1 index /FID eq 4 index

	  { 2 index /UniqueID eq or 2 index /XUID eq or }

	 if not { 3 copy put } if pop pop

       }

      forall exch

    }

   if pop

 } bdef

% Insert a new Encoding or Metrics into a font if necessary.

% Return a possibly updated font, and a flag to indicate whether

% the font was actually copied.

/.updatefontmetrics {	% <font> <Metrics|null> .updatefontmetrics

			%   <font'> <copied>

  dup //null ne {

    exch //true .copyfontdict dup /Metrics 4 -1 roll put //true

  } {

    pop //false

  } ifelse

} bdef

/.updatefontencoding {	% <font> <Encoding|null> .updatefontencoding

			%   <font'> <copied>

  dup //null ne { dup 2 index /Encoding get ne } { //false } ifelse {

    exch //false .copyfontdict dup /Encoding 4 -1 roll put //true

  } {

    pop //false

  } ifelse

} bdef

% Duplicate keys in CharString dictionary according to GlyphMap: <</new_glyph /old_glyph>>

% We have to do this because PDF fonts can associate multiple widths with the same glyph

% but Metrics dictionary works by the glyph name.

/.update_charstring {	% <font> <GlyphMap> .update_charstring  <font'> <copied>

  dup //null ne {

    exch //true .copyfontdict       % map font

    dup dup /CharStrings get        % map font font cstr

    dup length                      % map font font cstr len

    4 index length add              % map font font cstr len+map_len

    dict copy dup begin             % map font font cstr'

    /CharStrings exch put           % map font

    exch {                          % font /new /old

      currentdict exch .knownget {

        def

      } {

        currentdict /.notdef .knownget {

          def

        } {

          pop

          % The font has no .notdef.

          % Could not resolve the conflict,

          % but either the font is invalid or the glyph name is never used.

        } ifelse

      } ifelse

    } forall

    end //true

  } {

    pop //false

  } ifelse

} bdef

/.updatefont {	      % <font> <Encoding|null> <Metrics|null> <GlyphMap|null>

                      %        .updatefont <font'> <copied>

  4 2 roll            % <Metrics|null> <GlyphMap> <font> <Encoding|null>

  .updatefontencoding % <Metrics|null> <GlyphMap> <font> bool

  4 1 roll exch       % bool <Metrics|null> <font> <GlyphMap>

  .update_charstring  % bool <Metrics|null> <font> bool

  3 1 roll exch       % bool bool <font> <Metrics|null>

  .updatefontmetrics  % bool bool <font> bool

  4 2 roll or or      % <font> is_copied

} bdef

% ---------------- Text positioning ---------------- %

/Td {

  TextLineMatrix transform TextLineMatrix 4 2 getinterval astore pop

  TextLineMatrix TextMatrix copy pop settextstate

} bdef

/TD { dup neg /TextLeading gput Td } bdef

/T* { 0 TextLeading neg Td } bdef

/Tm {

  TextLineMatrix astore TextMatrix copy pop settextstate

} bdef

% ---------------- Text painting ---------------- %

/Vexch {

  rootfont /WMode knownoget { 1 eq { exch } if } if

} bind def

/textrenderingprocs [		% (0 is handled specially)

	% Painting-only modes

   { tf } { tS } { tB } { tn }

	% Clipping modes

   { gsave tf grestore tW }

   { gsave tS grestore tW }

   { gsave tB grestore tW }

   { tW }

] readonly def

/setshowstate

 { WordSpacing 0 eq TextSpacing 0 eq and

    { TextRenderingMode 0 eq {

        { setfillstate show }

      } {

        TextRenderingMode 3 eq {

            	% Some PDF files execute 'tm' with a singular matrix,

		% and then use the text rendering mode 3.

		% The graphics library currently cannot handle text

		% operations when the CTM is singular.

		% Work around this here.

	  {	

            matrix currentmatrix dup

            dup 0 get 0 eq 1 index 1 get 0 eq and {

              dup dup 2 get 0 eq { 0 }{ 1 } ifelse 1 put

            } if

            dup 2 get 0 eq 1 index 3 get 0 eq and {

              dup dup 1 get 0 eq { 3 }{ 2 } ifelse 1 put

            } if

            setmatrix

            1 index setfillstate show % Tr was set to graphic state.

            setmatrix 

	    % now set the currentpoint using the original matrix

            false charpath currentpoint newpath moveto

          }

        } {

          { false charpath textrenderingprocs TextRenderingMode get exec }

        } ifelse

      } ifelse

    }

    { TextRenderingMode 0 eq TextRenderingMode 3 eq or

       % Tr was set to graphic state.

       { WordSpacing 0 eq

          { { setfillstate TextSpacing 0 Vexch 3 -1 roll ashow } }

	  { TextSpacing 0 eq

            { { setfillstate WordSpacing 0 Vexch 32 4 -1 roll widthshow } }

            { { setfillstate WordSpacing 0 Vexch 32

                 TextSpacing 0 Vexch 6 -1 roll awidthshow } }

	    ifelse

	  }

	 ifelse

       }

       { { WordSpacing TextSpacing

			% Implement the combination of t3 and false charpath.

			% Note that we must use cshow for this, because we

			% can't parse multi-byte strings any other way.

			% Stack: string xword xchar

	    { pop pop (x) dup 0 3 index put false charpath

			% Stack: xword xchar ccode

             3 copy 32 eq { add } { exch pop } ifelse 0 Vexch rmoveto pop

	    }

	   4 -1 roll cshow pop pop

	   textrenderingprocs TextRenderingMode get exec

	 }

       }

      ifelse

    }

   ifelse /Show gput

 } bdef

/showfirst { setshowstate Show } def

/Tj {

} bdef

/' { T* Tj } bdef

/" { exch Tc exch Tw T* Tj } bdef

/TJ {

    dup type /stringtype eq {

      Show

    } { -1000 div

      currentfont /ScaleMatrix .knownget { 0 get mul } if

    } ifelse

  } forall settextposition

} bdef

/tf { setfillstate currentpoint fill moveto } bdef

/tn { currentpoint newpath moveto } bdef % Obsolete, never used.

% For stroking characters, temporarily restore the graphics CTM so that

% the line width will be transformed properly.

/Tmatrix matrix def

/tS

 { setstrokestate

   currentpoint //Tmatrix currentmatrix TextSaveMatrix setmatrix stroke

   setmatrix moveto

 } bdef

/tB { gsave tf grestore tS } bdef

% This does the wrong thing if there have been multiple text operations

% within a single BT/ET pair, but it's a start.

/tW { } bdef

end readonly put		% GS_PDF_ProcSet

.setglobal