677 lines
20 KiB
PostScript
677 lines
20 KiB
PostScript
% 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
|
|
0 g 0 G false op false OP 0 OPM
|
|
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 {
|
|
0 setfileposition
|
|
} {
|
|
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 {
|
|
0 0 moveto Show settextposition
|
|
} bdef
|
|
/' { T* Tj } bdef
|
|
/" { exch Tc exch Tw T* Tj } bdef
|
|
/TJ {
|
|
0 0 moveto {
|
|
dup type /stringtype eq {
|
|
Show
|
|
} { -1000 div
|
|
currentfont /ScaleMatrix .knownget { 0 get mul } if
|
|
0 Vexch rmoveto
|
|
} 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
|