Current File : //proc/self/root/proc/self/root/usr/share/ghostscript/Resource/Init/pdf_draw.ps
% Copyright (C) 2001-2019 Artifex Software, Inc.
% 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.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%
% pdf_draw.ps
% PDF drawing operations (graphics, text, and images).
/.setlanguagelevel where { pop 2 .setlanguagelevel } if
.currentglobal //true .setglobal
/GS_PDF_ProcSet load begin
pdfdict begin
% For simplicity, we use a single interpretation dictionary for all
% PDF graphics operations, even though this is too liberal.
/drawopdict 100 dict def
% ================================ Graphics ================================ %
% ---------------- Functions ---------------- %
% Note that resolvefunction converts a PDF Function to a PostScript Function;
% resolve*fnproc converts a PDF function to a PostScript procedure.
% We need to process all required and optional parameters to resolve any
% use of indirect references.
/fnrdict mark
0 { .resolvefn0 }
2 { .resolvefn2 }
3 { .resolvefn3 }
4 { .resolvefn4 }
.dicttomark readonly def
/.resolvefn0 {
dup length 1 add dict .copydict % make room for DataSource
% now resolve any indirect references
dup /Size 2 copy knownoget { put } { pop pop } ifelse
dup /BitsPerSample 2 copy knownoget { put } { pop pop } ifelse
dup /Order 2 copy knownoget { put } { pop pop } ifelse
dup /Encode 2 copy knownoget { put } { pop pop } ifelse
dup /Decode 2 copy knownoget { put } { pop pop } ifelse
% Don't lose our place in PDFfile.
PDFfile fileposition exch
dup //true resolvestream
% The stream isn't positionable, so read all the data now.
% Stack: filepos fndict stream
1 index /Range get length 2 idiv 2 index /BitsPerSample get mul
2 index /Size get { mul } forall
7 add 8 idiv
dup 65535 le {
string 1 index exch readstring pop
} {
1 index exch () /SubFileDecode filter /ReusableStreamDecode filter
} ifelse
exch closefile
% Stack: filepos fndict data
exch dup /DataSource 4 -1 roll put
exch PDFfile exch setfileposition
} bind executeonly def
/.resolvefn2 {
dup length dict .copydict
dup /C0 2 copy knownoget { put } { pop pop } ifelse
dup /C1 2 copy knownoget { put } { pop pop } ifelse
dup /N 2 copy knownoget { put } { pop pop } ifelse
} bind executeonly def
/.resolvefn3 {
dup length dict .copydict
dup /Bounds 2 copy knownoget { put } { pop pop } ifelse
dup /Encode 2 copy knownoget { put } { pop pop } ifelse
dup /Functions 2 copy oget mark exch dup {
oforce .resolvefn
} forall
counttomark -1 roll astore exch pop put
} bind executeonly def
/.resolvefn4 {
PDFfile fileposition exch % filepos fndict
dup //true resolvestream % filepos fndict stream
exch dup length dict copy % filepos stream fndict2
dup /Function undef % filepos stream fndict2
exch dup token not {
() /rangecheck cvx signalerror
} if
exch token {
/rangecheck cvx signalerror
} if
% Use .bind to avoid idiom recognition.
.bind
1 index /Function 3 -1 roll put
exch PDFfile exch setfileposition
} bind executeonly def
/.resolvefn { % <fndict> .resolvefn <fndict'>
dup length dict .copydict
dup /Domain 2 copy knownoget { put } { pop pop } ifelse
dup /Range 2 copy knownoget { put } { pop pop } ifelse
dup /FunctionType oget //fnrdict exch get exec
} bind executeonly def
/resolvefunction { % <fndict> resolvefunction <function>
.resolvefn
PDFDEBUG { //pdfdict /PDFSTEPcount .knownget { 1 le } { //true } ifelse { (%Function: ) print dup === flush } if } if
} bind executeonly def
/resolvefnproc { % <fndict> resolvefnproc <proc>
resolvefunction .buildfunction
} bind executeonly def
/resolveidfnproc { % <fndict> resolveidfnproc <proc>
dup /Identity eq { pop { } } { resolvefnproc } ifelse
} bind executeonly def
/resolvedefaultfnproc { % <fndict> <default> resolved'fnproc <proc>
1 index /Default eq { exch pop } { pop resolveidfnproc } ifelse
} bind executeonly def
%% A BBox where width or height (or both) is 0 should still paint one pixel
%% See the ISO 32000-2:2017 spec, section 8.7.4.3, p228 'BBox' and 8.7.3.1
/FixPatternBBox
{
dup aload pop
3 index 2 index sub 0 eq {
3 index 0.000001 add 3 -1 roll pop exch
} if
2 index 1 index sub 0 eq {
2 index 0.000001 add exch pop
}if
5 -1 roll astore
}bind executeonly def
% ---------------- Shadings ---------------- %
/shrdict mark
/Coords {
aload
5 1 roll
4 { % Bug 694542
dup type dup /integertype ne exch /realtype ne and {
( **** Error: replacing malformed number ') pdfformaterror pdfstring cvs pdfformaterror
(' with 0.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
0
} if
4 1 roll
} repeat
5 -1 roll
astore
} bind executeonly
/BBox {
dup dup dup aload pop normrect_elems
5 -1 roll astore
FixPatternBBox
} bind executeonly
/ColorSpace {
resolvecolorspace
} bind executeonly
/Function {
dup type /dicttype eq {
resolvefunction
} {
[ exch { oforce resolvefunction } forall ]
} ifelse
} bind executeonly
/Extend {
mark exch {oforce} forall ]
} bind executeonly
.dicttomark readonly def
/resolveshading { % <shadingstream> resolveshading <shading>
dup /.shading_dict .knownget {
exch pop
dup /ShadingType get 4 ge {
dup /DataSource get 0 setfileposition
} if
} {
dup
PDFfile fileposition exch
mark exch {
oforce //shrdict 2 index .knownget { exec } if
} forall .dicttomark
dup /ShadingType get 4 ge {
dup dup //true resolvestream
% Make a reusable stream so that the shading doesn't
% reposition PDFfile at unexpected times.
/ReusableStreamDecode filter /DataSource exch put
} if
exch PDFfile exch setfileposition
dup 3 1 roll /.shading_dict exch put
} ifelse
} bind executeonly def
/resolvesh { % <shname> resolvesh <shading>
% <shname> resolvesh <null>
Page /Shading rget {
%% Horrible hacky fix, see /DoImage later in ths file for more information
%%
dup /ColorSpace known {
dup /ColorSpace get dup type /arraytype eq {
exch dup length dict copy exch
dup length array copy /ColorSpace exch 2 index 3 1 roll put
} {pop} ifelse
} if
resolveshading
} {
//null
}ifelse
} bind executeonly def
% ---------------- Halftones ---------------- %
/spotfunctions mark
/Round {
abs exch abs 2 copy add 1 le {
dup mul exch dup mul add 1 exch sub
} {
1 sub dup mul exch 1 sub dup mul add 1 sub
} ifelse
} bind executeonly
/Diamond {
abs exch abs 2 copy add .75 le {
dup mul exch dup mul add 1 exch sub
} {
2 copy add 1.23 le {
.85 mul add 1 exch sub
} {
1 sub dup mul exch 1 sub dup mul add 1 sub
} ifelse
} ifelse
} bind executeonly
/Ellipse {
abs exch abs 2 copy 3 mul exch 4 mul add 3 sub dup 0 lt {
pop dup mul exch .75 div dup mul add 4 div 1 exch sub
} {
dup 1 gt {
pop 1 exch sub dup mul exch 1 exch sub
.75 div dup mul add 4 div 1 sub
} {
.5 exch sub exch pop exch pop
} ifelse
} ifelse
} bind executeonly
/EllipseA { dup mul .9 mul exch dup mul add 1 exch sub } bind executeonly
/InvertedEllipseA { dup mul .9 mul exch dup mul add 1 sub } bind executeonly
/EllipseB { dup 5 mul 8 div mul exch dup mul exch add sqrt 1 exch sub } bind executeonly
/EllipseC { dup mul .9 mul exch dup mul add 1 exch sub } bind executeonly
/InvertedEllipseC { dup mul .9 mul exch dup mul add 1 sub } bind executeonly
/Line { exch pop abs neg } bind executeonly
/LineX { pop } bind executeonly
/LineY { exch pop } bind executeonly
/Square { abs exch abs 2 copy lt { exch } if pop neg } bind executeonly
/Cross { abs exch abs 2 copy gt { exch } if pop neg } bind executeonly
/Rhomboid { abs exch abs 0.9 mul add 2 div } bind executeonly
/DoubleDot { 2 {360 mul sin 2 div exch } repeat add } bind executeonly
/InvertedDoubleDot { 2 {360 mul sin 2 div exch } repeat add neg } bind executeonly
/SimpleDot { dup mul exch dup mul add 1 exch sub } bind executeonly
/InvertedSimpleDot { dup mul exch dup mul add 1 sub } bind executeonly
/CosineDot { 180 mul cos exch 180 mul cos add 2 div } bind executeonly
/Double { exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add } bind executeonly
/InvertedDouble {
exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add neg
} bind executeonly
.dicttomark readonly def
/.resolveht1 {
mark exch {
oforce
1 index /SpotFunction eq {
dup type /arraytype eq {
%% check all the names in the array in turn, stop when we find
%% the first one we recognise.
{
//spotfunctions exch .knownget {
exit
} if
} forall
dup type /nametype eq {
%% If we didn't find any that we recognise, then use
%% the default halftone's spot function
.setdefaulthalftone currenthalftone dup /SpotFunction .knownget {
exch pop
}{
/GraySpotFunction .knownget not {
//spotfunctions /Round get
} if
}ifelse
} if
}{
dup type /nametype eq
{ //spotfunctions exch get } { resolvefnproc }
ifelse
} ifelse
} {
1 index /TransferFunction eq {
resolveidfnproc
} if
} ifelse
} forall .dicttomark
} bind executeonly def
/.resolveht5 {
mark exch {
oforce dup type /dicttype eq { resolvehalftone } if
} forall .dicttomark
} bind executeonly def
/.resolveht6 {
%% resolvestream will reposition PDFfile. If we are in the middle
%% of reading a content stream from PDFfile when we execute this,
%% then reading the next buffer will read from the wrong place. We
%% must save and restore the position of PDFfile. See the definition
%% of resolvestream. Bug #695886
PDFfile fileposition exch
mark exch { oforce } forall .dicttomark
dup dup //false resolvestream /ReusableStreamDecode filter
/Thresholds exch put
dup /TransferFunction .knownget {
resolveidfnproc
1 index exch /TransferFunction exch put
} if
exch PDFfile exch setfileposition
} bind executeonly def
/htrdict mark
1 //.resolveht1
5 //.resolveht5
6 //.resolveht6
10 //.resolveht6
16 //.resolveht6
.dicttomark readonly def
currentdict /.resolveht1 undef
currentdict /.resolveht5 undef
currentdict /.resolveht6 undef
/resolvehalftone { % <dict> resolvehalftone <halftone>
dup /HalftoneType oget
dup //htrdict exch .knownget {
exch pop exec
} {
=string cvs
( **** Error: Incorrect halftone type ) exch concatstrings
(. Using defailt.\n) concatstrings pdfformaterror
( Output may be incorrect.\n) pdfformaterror
gsave .setdefaulthalftone currenthalftone grestore
} ifelse
} bind executeonly def
% ---------------- Graphics state management ---------------- %
/cmmatrix matrix def
drawopdict begin
% Graphics state stack
/q { q } executeonly def
/Q { Q } executeonly def
% Graphics state setting
/cm { //cmmatrix astore
.getpath
exch concat
newpath { exec } forall
% If inside a BT/ET block, we need to update the TextSaveMatrix
currentdict /TextSaveMatrix .knownget {
//cmmatrix exch dup concatmatrix pop
} if
% And if we ha\ve done a gsave inside a text block, we need to update
% that matrix instead.
currentdict /qTextSaveMatrix .knownget {
//cmmatrix exch dup concatmatrix pop
} if
} bind executeonly def
/i { 1 .min setflat } bind executeonly def
/J { setlinecap } bind 0 get def
/d { setdash } bind 0 get def
/j { setlinejoin } bind 0 get def
/w { setlinewidth } bind 0 get def
/M { 1 .max setmiterlimit } bind executeonly def
/gs { gs } executeonly def
end
% Each entry in this dictionary is
% <gsres> <value> -proc- <gsres>
/gsbg {
/BGDefault load resolvedefaultfnproc setblackgeneration
} bind executeonly def
/gsucr {
/UCRDefault load resolvedefaultfnproc setundercolorremoval
} bind executeonly def
/gstr {
dup type /arraytype eq {
{ oforce /TRDefault load resolvedefaultfnproc } forall
setcolortransfer
} {
/TRDefault load resolvedefaultfnproc settransfer
} ifelse
} bind executeonly def
/gsparamdict mark
/SA { setstrokeadjust } executeonly
/OP { 1 index /op known not { dup op } if OP } executeonly
% The PDF 1.3 specification says that the name /Default is only
% recognized for {BG,UCR,TR}2. However, PDF 1.3 files produced
% by Adobe Acrobat Distiller 4.0 for Windows use the name /Default
% with the older keys, so we have to implement this.
/BG { 1 index /BG2 known { pop } { gsbg } ifelse } executeonly
/UCR { 1 index /UCR2 known { pop } { gsucr } ifelse } executeonly
/TR { 1 index /TR2 known { pop } { gstr } ifelse } executeonly
% Some functions used to implement phases of HT and HTP
/sethalftones {
dup /Default eq {
pop .setdefaulthalftone
} {
resolvehalftone sethalftone
} ifelse
} bind executeonly def
/sethalftonephases {
aload pop -1 2 index 2 index .setscreenphase pop pop
} bind executeonly def
/HT {
dup sethalftones .swapcolors sethalftones .swapcolors
% the transfer function may dependent on the halftone, so make sure
% it is set if included in the graphic state (otherwise this is
% subject to order of a dictionary forall, which is unpredictable)
dup /TR2 .knownget {
dup /Default eq { oforce gsparamdict /TR2 get exec } { pop } ifelse
} {
dup /TR .knownget {
/dup /Default eq { oforce gsparamdict /TR get exec } { pop } ifelse
} if
} ifelse
} executeonly
/HTP {
% HTP may be present even if this isn't a DPS interpreter.
dup sethalftonephases .swapcolors sethalftonephases .swapcolors
} executeonly
% PDF 1.3
% The font is an indirect reference, not a resource name
/Font { aload pop exch oforce resourcefont exch Tf }
/LW { setlinewidth } executeonly
/LC { setlinecap } executeonly
/LJ { setlinejoin } executeonly
/ML { 1 .max setmiterlimit } executeonly
/D { aload pop setdash } executeonly
/RI { ri } executeonly
/op { op } executeonly
/OPM { OPM } executeonly
/BG2 { gsbg } executeonly
/UCR2 { gsucr } executeonly
/TR2 { gstr } executeonly
/FL { 1 .min setflat } executeonly
/SM {
% SM may be present even if this is only a Level 2 interpreter.
/setsmoothness where { pop setsmoothness } { pop } ifelse
} executeonly
% PDF 1.4
% All of these require the "transparency" feature in the interpreter.
/ca { ca } executeonly
/CA { CA } executeonly
/SMask {
{gssmask} PDFSTOPONERROR { exec //false } { stopped } ifelse
{
pop (\n **** Error in SMask during ExtGState. Ignoring the mask, output may be incorrect.\n)
pdfformaterror
} if
} executeonly
/AIS { AIS } executeonly
/BM { BM } executeonly
/TK { TK } executeonly
/UseBlackPtComp { UseBlackPtComp } executeonly
/HTO {
% PDF 2.0, supposed to be 'similar' to halftone phase but using a different
% co-ordiate system. Treat the same for now and fix if anyone ever complains.
aload pop transform cvi exch cvi exch 2 array astore
dup sethalftonephases .swapcolors sethalftonephases .swapcolors
} executeonly
.dicttomark readonly def
/gs { % <gsres> gs -
Page /ExtGState rget {
% We keep the dictionary on the stack during the forall so that
% keys that interact with each other have access to it.
dup {
oforce exch gsparamdict exch .knownget { exec } { pop } ifelse
} forall pop
} {
//pdfdict /.gs_warning_issued known not {
(\n **** Error 'gs' ignored -- ExtGState missing from Resources.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
//pdfdict /.gs_warning_issued //true .forceput
PDFSTOPONERROR { /gs /undefined signalerror } if
} executeonly if
} executeonly
ifelse
} bind executeonly def
% ------ Transparency support ------ %
/gssmask {
{
dup type /dicttype eq
{
dup /G knownogetdict
{pop}
{
( **** Error: Ignoring invalid transparency SMask group\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
% replace the invalid SMask object
pop /None
} ifelse
} if
dup /None eq 1 index //null eq or PDFusingtransparency not or {
pop //null
.currentSMask //null ne {
% get rid of the current SMask (Bug 695471)
//false % colorspace not set
<< /Subtype /None >> % Special type for this purpose
0 0 0 0 % fake BBox
.begintransparencymaskgroup
} if
exit
} if
% Preprocess the SMask value into a parameter dictionary for
% .begintransparencymaskgroup, with added /BBox and /Draw keys.
mark exch % Stack: mark smaskdict
dup /S oget /Subtype exch 3 2 roll
% Stack: mark ... smaskdict
dup /BC knownoget {
dup /Background exch 4 2 roll
1 index /G oget /Group knownoget not {
( **** Error: Ignoring a transparency group XObject without /Group attribute.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
cleartomark //null exit
} if
gsave //nodict begin
/CS knownoget {
resolvecolorspace dup setgcolorspace csput
} if
aload pop setcolor [ currentgray ]
end grestore
/GrayBackground exch 3 2 roll
} if
dup /TR knownoget {
dup /Identity eq {
pop
} {
resolvefnproc /TransferFunction exch 3 2 roll
} ifelse
} if
dup /G oget
dup /BBox oget oforce_array
1 index /Matrix knownoget {
oforce_array .bbox_transform 4 array astore
} if
/BBox exch 4 2 roll
% Because we don't execute the group form stream until we find
% out whether we're actually going to draw through it, we need
% to save the current gstate with the other parameters, so
% we can subsequently execute it in the correct graphics state.
% We need to concatenate the Matrix in this gstate as per the PDF
% spec 7.5.4 (p. 552 in the PDF 1.7 Ref) (bug 694455).
gsave
dup /Matrix knownoget {
matrix currentmatrix matrix concatmatrix setmatrix
} if
/GroupGState gstate currentgstate 6 2 roll
grestore
/GroupMat matrix currentmatrix 8 2 roll
% /GroupExtGState 1 dict
% 10 2 roll
/.execmaskgroup cvx 2 packedarray cvx /Draw exch 3 2 roll
pop
.dicttomark
exit
} loop
SMask
} bind executeonly def
% Functions specific to the Device* colorspaces to force the switch to
% the Device* colorspace so that the SMask will not get a CIEBased* colorspace
% in the case when UseCIEColor changes the Device* colorspace to something else.
% Also see the logic in pdf_main.ps:pdfopen that similarly defines these resources.
/forceDefaultCS <<
{
currentcolorspace setcolorspace % this will switch to Device colorspace
} bind executeonly
/DeviceGray exch
/DeviceRGB 1 index
/DeviceCMYK 1 index
>>
def
% This procedure is called to actually render the soft mask.
/.execmaskgroup { % <masknum> <paramdict> <formdict> .execmaskgroup -
% Save our place in PDFfile. Do not use gsave-grestore when creating
% a soft mask with .begintransparencygroup because high level devices
% need to modify the graphic state by storing the soft mask ID.
% Save the ExtGState (//nodict begin) BEFORE changing the colorspace
//nodict begin
matrix currentmatrix 4 1 roll
mark currentcolor counttomark dup 4 add exch roll pop
currentcolorspace 4 1 roll .getuseciecolor 4 1 roll
.swapcolors mark currentcolor counttomark dup 4 add exch roll pop currentcolorspace 4 1 roll .swapcolors
currentuserparams /OverrideICC get 4 1 roll
mark /OverrideICC //true .dicttomark setuserparams
% We can't simply set the group's gstate here because
% we can't use gsave/grestore. So we actually set it
% in .execgroup. But the matrix needs set here for
% .begintransparencymaskgroup to correctly work.
% It might seem we should also set the colorspace
% in case the group doesn't have one, *but* empirical
% suggests that is not the case - fts_26_2600.pdf and
% fts_26_2603.pdf render incorrectly if we set the
% colrospace
1 index /GroupMat .knownget { setmatrix } if
PDFfile fileposition 4 1 roll
% We have to select the group's color space so that the
% background color will be interpreted correctly.
% [save/restore]DefaultCS make sure that the SMask logic sees
% the Device* spaces, not CIEBased* that UseCIEColor may have
% established.
//false .setuseciecolor % SMask gets processed without UseCIEColor
dup /Group oget /CS knownoget {
resolvecolorspace dup setgcolorspace csput
//true % use currentcolorspace
} {
% inheriting the colorspace -- make sure Device* spaces are not CIEBased
forceDefaultCS currentcolorspace 0 get .knownget { exec } if
//false % no defined colorspace
} ifelse
3 -1 roll dup
dup 4 1 roll /BBox get aload pop .begintransparencymaskgroup
exch dup /Resources knownoget { oforce } { 2 dict } ifelse
3 -1 roll /GroupGState .knownget { 1 index /GroupGState 3 -1 roll put} if
exch //false resolvestream
1 index exch
%% Get the current colour space and colour values (as an array), we need to pass these to .execgroup
%% as well, so that it can restore them, in case the colour space gets changed by transparency
%% graphics state stuff.
mark currentcolor counttomark array astore exch pop
currentcolorspace 4 2 roll
.execgroup
% We have to remove these in case the Form XObject is subsequently used as
% a form rather than a group - they remain in the paramdict for the SMask
% so this will all still work if the SMask is re-evaluated.
/GroupGState undef
.endtransparencymask
PDFfile exch setfileposition
mark exch /OverrideICC exch .dicttomark setuserparams
.swapcolors setcolorspace setcolor .swapcolors
.setuseciecolor setcolorspace setcolor
setmatrix
end % restore colorspace, color and ExtGState (end)
.currentSMask /Processed //true put % special setting to tell us it has been rendered
} bind executeonly def
% Paint a Form+Group XObject, either for a transparency mask or for a Do.
/.execgroup { % [colour values] <colour space> <resdict> <stream> .execgroup -
pdfemptycount 3 1 roll
/pdfemptycount count 5 sub store
gsave //nodict begin
% We have to set the gstate correctly for lazy evaluation of a softmask group.
% we also must restore the color(space) as setup in .execmaskgroup or paintformgroup.
% This stuff must be done here, as .execmaskgroup can't use gsave/grestore to
% manipulate the gstates, due to the requirements of .begintransparencymaskgroup.
% We also must set the ExtGState values.
% It may seem redundant to do the color(space) twice (once here and once in
% .execmaskgroup) but we have to set it in .execmaskgroup for the background
% color and set it here once in the correct gstate.
1 index
/GroupGState .knownget { setgstate } if
newpath //null SMask
1 .setopacityalpha 1 .setshapealpha
1 CA 1 ca
/Compatible .setblendmode
% Execute the body of the Form, similar to DoForm.
pdfopdict
%% Restore the colour space (passed in on the stack) and current colour
%%
6 -2 roll
setcolorspace
aload pop setcolor
.pdfruncontext
end grestore
/pdfemptycount exch store
} bind executeonly def
/.beginformgroup { % groupdict bbox .beginformgroup -
exch mark exch % bbox mark groupdict
dup /CS knownoget { resolvecolorspace dup setgcolorspace /CS exch 3 2 roll} if
dup /I knownoget { /Isolated exch 3 2 roll } if
dup /K knownoget { /Knockout exch 3 2 roll } if
pop .dicttomark
% Stack: bbox paramdict
exch aload pop
.begintransparencygroup
} bind executeonly def
/.beginpagegroup { % groupdict bbox .beginformgroup -
currentcolorspace 3 1 roll
exch mark exch % bbox mark groupdict
dup /CS knownoget { resolvecolorspace dup setgcolorspace /CS exch 3 2 roll} if
dup /I knownoget { /Isolated exch 3 2 roll } if
dup /K knownoget { /Knockout exch 3 2 roll } if
pop .dicttomark
% Stack: bbox paramdict
exch aload pop
.begintransparencypagegroup
setcolorspace
} bind executeonly def
% .paintgroupform implements the Form PaintProc in the case where the
% Form XObject dictionary includes a Group key. See .paintform below.
/.paintgroupform { % <resdict> <stream> <formdict> .paintgroupform -
%% Pass the current color space, and an array with the current color vales
%% as arguments to .execgroup
mark currentcolor counttomark array astore exch pop
currentcolorspace 5 2 roll
dup /Group oget exch /BBox oget
% Stack: resdict stream groupdict bbox
.beginformgroup
.execgroup
.endtransparencygroup
} bind executeonly def
% Make an ImageType 103 (soft-masked) image.
/makesoftmaskimage { % <datasource> <imagemask> <SMask> makesoftmaskimage
% <datasource> <imagemask>, updates currentdict =
% imagedict
% See the ImageType 3 case of makemaskimage below.
% SMask is a stream, another Image XObject.
% Stack: datasource imagemask(false) smaskstreamdict
PDFfile fileposition exch
dup /Matte knownoget { /Matte exch def } if
dup length dict makeimagedict pop
% In order to prevent the two data sources from being
% aliased, we need to make at least one a reusable stream.
% We pick the mask, since it's smaller (in case we need to
% read all its data now).
% Stack: datasource imagemask(false) savedpos
% maskdict is currentdict
/DataSource DataSource mark
/Intent 1
/AsyncRead //true
.dicttomark {.reusablestreamdecode} stopped {pop} if def
PDFfile exch setfileposition
currentdict end currentdict end
5 dict begin
/ImageType 103 def
/DataDict exch def
dup /InterleaveType 3 put
DataDict /Matte knownoget {
/Matte exch def
} if
.currentalphaisshape
{ /ShapeMaskDict } { /OpacityMaskDict } ifelse exch def
/ColorSpace DataDict /ColorSpace get def
} bind executeonly def
% ---------------- Color setting ---------------- %
/01_1 [0 1] readonly def
/01_3 [0 1 0 1 0 1] readonly def
/01_4 [0 1 0 1 0 1 0 1] readonly def
% The keys here are resolved (PostScript, not PDF) color space names.
/csncompdict 9 dict begin
/DeviceGray { pop 1 } bind executeonly def
/DeviceRGB { pop 3 } bind executeonly def
/DeviceCMYK { pop 4 } bind executeonly def
/CIEBasedA //DeviceGray def
/CIEBasedABC //DeviceRGB def
/CalGray //DeviceGray def
/CalRGB //DeviceRGB def
/Lab //DeviceRGB def
/ICCBased { 1 oget /N oget } bind executeonly def
/Separation //DeviceGray def
/DeviceN { 1 oget length } bind executeonly def
/Indexed //DeviceGray def
currentdict end readonly def
% <colorspace> csncomp <n>
/csncomp {
dup dup type /arraytype eq { 0 oget } if
//csncompdict exch get exec
} bind executeonly def
currentdict /csncompdict undef
/ICCBased-resolve {
PDFfile fileposition exch
dup dup 1 oget
mark exch { oforce } forall .dicttomark
dup dup //true resolvestream
/ReusableStreamDecode filter /DataSource exch put
dup /.hash 0 put % placeholder for use by seticc icc_profile_cache key
% Check that the number of components (/N) defined in the ICCBased
% dictionry matches the actual profile. Bug #696120
dup /N get
1 index
%% If we get an error reading the profile, just assume that /N is correct
%% If its genuinely faulty we will use an alternate based on /N.
{.numicc_components} stopped {pop dup} if
dup 3 -1 roll ne {
%% /N and the actual number of components don't match. Ensure
%% that we have a valid number of components from the ICC
%% profile. Certain kinds of profile can't determine the numebr of components
%% and in ths case we must not override the /N value.
dup 0 gt {
( **** Error: ICCbased space /N value does not match the ICC profile.\n) pdfformaterror
( Using the number of channels from the profile.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
1 index dup /N get /OrigN exch put
1 index exch /N exch put
}{
pop
} ifelse
} {
pop
} ifelse
1 exch put
exch PDFfile exch setfileposition
% Resolve alternate color space
dup 1 get % Get colorspace dictionary
dup /Alternate .knownget { % Check for alternate color space
oforce resolvecolorspace /Alternate exch put % resolve and replace
} {
pop % remove colorspace dictionary
} ifelse
} bind executeonly def
/csrdict 13 dict begin
/DeviceGray { } bind executeonly def
/DeviceRGB { } bind executeonly def
/DeviceCMYK { } bind executeonly def
/CalGray { 1 oget [ exch /CalGray exch ] } bind executeonly def
/CalRGB { 1 oget [ exch /CalRGB exch ] } bind executeonly def
/Lab { 1 oget [ exch /Lab exch ] } bind executeonly def
/CalCMYK {
pop /DeviceCMYK % not defined by Adobe
} bind executeonly def
/ICCBased {
dup 1 get type /dicttype ne { % don't resolve more than once
ICCBased-resolve
} if
} bind executeonly def
/Separation {
aload pop exch oforce resolvecolorspace
% Contrary to PDF manuals up to v.1.5, Acrobat Distiller 3.01
% can use /Identity name here instead of a function.
exch oforce resolveidfnproc
%% Make sure the ink name is not an indirect object....
3 -1 roll oforce 3 1 roll
4 array astore
} bind executeonly def
/DeviceN {
[ exch aload pop ] % Copy into a new array
dup dup 1 oget % Resolve Names array
[ exch { oforce } forall ] % resolve each of the names
1 exch put
dup dup 2 oget resolvecolorspace
2 exch put
dup dup 3 oget resolvefnproc
3 exch put
dup length 4 gt { % Check for attributes dict
dup dup 4 oget % devn_array devn_array attr_dict
dup /Colorants knownoget % Check for Colorants Dict
{ % Create a new attribute dict with only a Colorants dict entry.
% Resolve all of the Colorant dict entries. This is needed
% to prevent a conflict if we attempt to resolve the tint
% transform functions of the Colorant color spaces multiple
% times.
exch pop % Remove old attributes dict
<< exch % Start new attributes dict
% Build new Colorants dict with resolved entries
<< exch { oforce resolvecolorspace } forall >>
/Colorants exch >> % Finish new attributes dict
} if
4 exch put % Put resolved or new attributes dict
} if
} bind executeonly def
/Indexed {
aload pop
%% Resolve 'hival' in case it is an indirect reference. This is kind of
%% dumb, it just makes the file bigger, but it *is* legal.
3 1 roll oforce 3 -1 roll
1 index -1 eq {
exch pop 255 exch
( **** Error: Highest color index given as -1. Assuming this actually means 255.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} if
3 -1 roll oforce resolvecolorspace
% Stack: /Indexed hival lookup basespace
% If the underlying space is a Lab space, we must scale
% the output of the lookup table as part of DecodeABC.
dup dup type /arraytype eq { 0 get } if /CIEBasedABC eq {
dup 1 get /DecodeLMN known {
1 get dup length dict copy
begin /DecodeABC [ 0 2 4 {
RangeABC 1 index 1 add get RangeABC 2 index get sub /mul load
RangeABC 3 index get /add load
DecodeABC 6 -1 roll 2 idiv get [ 6 1 roll aload pop ] cvx
} for ] def
/RangeABC //01_3 def
currentdict end /CIEBasedABC exch 2 array astore
} if
} if
3 1 roll % Stack: /Indexed csp comp table
oforce dup type /stringtype ne {
% The color lookup table is a stream.
% Get its contents. Don't lose our place in PDFfile.
% Stack: /Indexed basespace hival lookup
PDFfile fileposition 5 1 roll
dup /Filter oknown not { % For Bug691941.pdf and similar lossage
dup /Length knownoget not { 0 } if
} {
0
} ifelse
% Stack: filepos /Indexed basespace hival lookup Length
2 index 1 add
% Stack: filepos /Indexed basespace hival lookup Length len
4 index csncomp mul .max string
% Stack: filepos /Indexed basespace hival lookup (...)
exch //true resolvestream
1 index readstring not {
% The string is padded with 0s
( **** Error: Short look-up table in the Indexed color space was padded with 0's.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} if
pop
% Stack: filepos /Indexed basespace hival (...)
PDFfile 6 -1 roll setfileposition
} if
4 array astore
% Stack: [filepos /Indexed basespace hival (...)]
% Replace the PDFColorSpace with the Indexed space if needed.
dup 1 get
dup type /arraytype eq {
dup length 2 ge {
dup 1 get type /dicttype eq {
dup 1 get /PDFColorSpace known {
dup 1 get /PDFColorSpace 3 index put
} if
} if
} if
} if pop
} bind executeonly def
/I { % Bug 689815
( **** Error: The name /Indexed cannot be abbreviated to /I in the color space\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
dup 0 /Indexed put
//Indexed exec
} bind executeonly def
/Pattern {
dup type /nametype ne {
dup length 1 gt {
1 oget resolvecolorspace
/Pattern exch 2 array astore
} if
} if
} bind executeonly def
currentdict end readonly def
/cssubst { % <csname> cssubst <cspace'> true
% <csname> cssubst false
dup resolvecolorspace
dup 1 index ne { exch pop //true } { pop pop //false } ifelse
} bind executeonly def
/csnames mark
/DeviceGray dup /DeviceRGB dup /DeviceCMYK dup /Pattern dup
.dicttomark readonly def
/csresolve { % <csresourcename> csresolve <cspace> <true> | <false>
dup type /nametype ne {
(\n **** Error: CS/cs (setcolorspace) operand not a name: ) pdfformaterror
dup stderrfile dup 3 -1 roll write==only flushfile
( ****\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
dup type /arraytype eq { % Adobe InDesign + PDF Library has array
resolvecolorspace
} if //true
} {
dup Page /ColorSpace rget {
exch pop resolvecolorspace //true
} {
//csnames 1 index known {
//true
} {
( **** Error: Undefined space resource: /)
exch .namestring concatstrings (\n) concatstrings pdfformaterror
( Output may be incorrect.\n) pdfformaterror
//false
} ifelse
} ifelse
} ifelse
} bind executeonly def
/resolvecolorspace { % <cspace> resolvecolorspace <cspace'>
dup type /dicttype eq {
dup /N known {
( **** ICCBased color space is a bare stream dictionary\n) pdfformatwarning
[ /ICCBased 3 -1 roll ] ICCBased-resolve exec
//false
} {
dup /ColorSpace knownoget {
( **** Error: unrecognised color space <</ColorSpace /Device...>>\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
exch pop //true
} {
//true
} ifelse
} ifelse
} {
//true
} ifelse {
dup dup type /arraytype eq { 0 get } if
//csrdict exch .knownget {
exec dup type /nametype ne { dup length 1 eq { 0 get } if } if
} {
dup type /nametype eq {
csresolve not { /DeviceRGB } if % Arbitrary
} {
csset exch pop
} ifelse
} ifelse
} if
} bind executeonly def
/scresolve { % <c0> ... scresolve <multi>
% We can't really make sc[n] and SC[N] work, because
% the color space information isn't available at
% conversion time; so we hack it by assuming that
% all the operands on the stack are used, and that
% if the top operand is a name, it's a Pattern resource.
dup type /nametype eq
{ Page /Pattern rget { resolvepattern } { //null } ifelse }
if
dup type /dicttype eq {
% Check the PaintType, if any (shading patterns don't
% have one).
dup /PaintType knownoget { 2 eq } { //false } ifelse
} {
.pdfcount 1 gt
} ifelse
} bind executeonly def
%% Bug #696017 When we begin a text block, we switch to a special set of marking operations
%% for paths, these ops don't use the current CTM, but the 'SavedTextMatrix', in order to
%% correctly position marks which are illegally present inside a text block. But, if we are
%% executing a PaintProc (eg for a pattern) we *don't* want to do that or the pattern will be wrong.
%% So we moved the .pdfpaintproc to .actual_pdfpaintproc, and redefined .pdfpaintproc to test
%% the current value of /m. We always switch to the regular marking operations, but if the definition
%% of /m at the start of the PaintProc was a special text version, then we switch back to that after we
%% finished running the PaintProc.
/.actual_pdfpaintproc { % <patdict> <resdict> .pdfpaintproc -
PDFDEBUG { //pdfdict /PDFSTEPcount .knownget { 1 le } { //true } ifelse { (%Begin PaintProc) print dup === flush } if } if
PDFfile fileposition 3 1 roll
q
1 index /PaintType oget 1 eq {
% For colored patterns, set default fill and stroke colors.
0 g 0 G
} {
% For uncolored patterns, we have to unbind the current
% color and color space before running the PaintProc.
% Not true since moving the ExtGState parameters into the gstate.
% //null sc1 //null SC1
} ifelse
% Save old values on opstack, set pdfemptycount to new value.
pdfemptycount countdictstack mark
%% We can't simply 'def' into the dictionary saved by 'q' above, we need to
%% call gput to copy it and store inside it. Stupid or what....
/pdfemptycount count 3 sub gput 5 3 roll
%
% Stack: ... <old emptycount> <dictcount> mark <patdict> <resdict>
% |
% New empty count points here -----------+
exch //false resolvestream pdfopdict .pdfruncontext
cleartomark
//false
{ countdictstack
2 index le { exit } if
currentdict /n known not or
currentdict /n known currentdict /self known or{
Q
}{
(\n **** Error: File has unbalanced q/Q operators \(too many Q's\)\n Output may be incorrect.\n)
//pdfdict /.Qqwarning_issued .knownget
{
{
pop
}
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
} executeonly
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
end
} executeonly ifelse
} executeonly loop
{
(\n **** Error: File has unbalanced q/Q operators \(too many q's\)\n Output may be incorrect.\n)
//pdfdict /.Qqwarning_issued .knownget
{
{
pop
}
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
} executeonly
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
} executeonly if
pop
% restore pdfemptycount
/pdfemptycount exch def
Q
PDFDEBUG { //pdfdict /PDFSTEPcount .knownget { 1 le } { //true } ifelse { (%End PaintProc) print dup === flush } if } if
PDFfile exch setfileposition
} bind executeonly odef
/.pdfpaintproc {
%% Get the /m from pdfopdict (must be present)
%% and check its a packedarray
pdfopdict /m get dup type /packedarraytype eq {
%% The non-text version of /m is executeonly, so if we can't read it, its not a text block.
dup rcheck {
%% get the initial element of the packedarray
%% and check its a name
0 get dup type /nametype eq {
%% If the name is inside_text_m then we are in a text block
/inside_text_m eq
}{
pop //false
} ifelse
}{
pop //false
} ifelse
}{
pop //false
} ifelse
%% rearrange the operands, move the boolean to the back
3 1 roll
%% Uncopnditionally use the normal marking ops
switch_to_normal_marking_ops
.actual_pdfpaintproc
%% If we were in a text block, restore the text marking ops.
{
switch_to_text_marking_ops
} if
}bind executeonly odef
/resolvepattern { % <patternstreamdict> resolvepattern <patterndict>
% Don't do the resolvestream now: just capture the data
% from the file if necessary.
dup length dict copy
dup /FilePosition .knownget {
1 index /File get dup fileposition 3 1 roll
% Stack: dict savepos pos file
dup 3 -1 roll setfileposition
dup 3 index /Length knownoget {
dup 65535 le {
dup 0 eq {
pop pop ()
} {
string readstring pop
} ifelse
} {
() /SubFileDecode filter /ReusableStreamDecode filter
} ifelse
} {
0 (endstream) /SubFileDecode filter /ReusableStreamDecode filter
} ifelse
% Stack: dict savepos file string
3 1 roll exch setfileposition
1 index /File 3 -1 roll put
dup /FilePosition undef
} if
dup /Shading knownoget {
resolveshading 1 index /Shading 3 -1 roll put
} if
dup /PaintProc [
% Bind the resource dictionary into the PaintProc.
2 index /Resources knownoget { oforce } { 0 dict } ifelse
/.pdfpaintproc cvx
] cvx put
dup /BBox 2 copy knownoget { normrect FixPatternBBox put } { pop pop } ifelse
dup /.pattern_uses_transparency 1 index patternusestransparency put
PDFDEBUG { //pdfdict /PDFSTEPcount .knownget { 1 le } { //true } ifelse { (%Pattern: ) print dup === flush } if } if
} bind executeonly def
/ignore_color_op ( **** Error: Ignoring a color operation in a cached context.\n Output may be incorrect.\n) readonly def
drawopdict begin
/g { .incachedevice { % Bug 689302
pop //ignore_color_op pdfformaterror
} {
/DeviceGray cssubst { cs sc1 } { g } ifelse
} ifelse
} bind executeonly def
/rg { .incachedevice {
pop pop pop //ignore_color_op pdfformaterror
} {
/DeviceRGB cssubst { cs sc* } { rg } ifelse
} ifelse
} bind executeonly def
/k { .incachedevice {
pop pop pop pop //ignore_color_op pdfformaterror
} {
k
} ifelse
} bind executeonly def
/cs { .incachedevice {
pop //ignore_color_op pdfformaterror
} {
csresolve { cs } if
} ifelse
} bind executeonly def
/sc { .incachedevice {
.pdfcount { pop } repeat //ignore_color_op pdfformaterror
} {
scresolve 1 index //null eq {
pop pop
//ignore_color_op pdfformaterror
} {
{ sc*_and_set } { sc1_and_set } ifelse
} ifelse
} ifelse
} bind executeonly def
/scn /sc load def
/G { .incachedevice {
pop //ignore_color_op pdfformaterror
} {
/DeviceGray cssubst { CS SC1 } { G } ifelse
} ifelse
} bind executeonly def
/RG { .incachedevice {
pop pop pop //ignore_color_op pdfformaterror
} {
/DeviceRGB cssubst { CS SC* } { RG } ifelse
} ifelse
} bind executeonly def
/K { .incachedevice {
pop pop pop pop //ignore_color_op pdfformaterror
} {
K
} ifelse
} bind executeonly def
/CS { .incachedevice {
pop //ignore_color_op pdfformaterror
} {
csresolve { CS } if
} ifelse
} bind executeonly def
/ri { .incachedevice {
pop //ignore_color_op pdfformaterror
} {
ri
} ifelse
} bind executeonly def
/SC { .incachedevice {
.pdfcount { pop } repeat //ignore_color_op pdfformaterror
} {
scresolve 1 index //null eq {
pop pop
//ignore_color_op pdfformaterror
}{
{ SC*_and_set } { SC1_and_set } ifelse
}ifelse
} ifelse
} bind executeonly def
/SCN /SC load def
end
currentdict /ignore_color_op undef
% ---------------- Paths ---------------- %
drawopdict begin
% Path construction
/m { { moveto } stopped { count pdfemptycount sub 2 .min { pop } repeat 0 0 moveto } if } bind executeonly def
/l { { lineto } stopped { count pdfemptycount sub 2 .min { pop } repeat } if } bind executeonly def
/c { { curveto } stopped { count pdfemptycount sub 6 .min { pop } repeat } if } bind executeonly def
/v { count pdfemptycount sub 4 ge {
{ currentpoint 6 2 roll curveto } stopped { count pdfemptycount sub 6 .min { pop } repeat } if
} {
count pdfemptycount sub { pop } repeat
} ifelse
} bind executeonly def
/y { { 2 copy curveto } stopped { count pdfemptycount sub 6 .min { pop } repeat } if } bind executeonly def
/re {
4 2 roll moveto exch dup 0 rlineto 0 3 -1 roll rlineto neg 0 rlineto
closepath
} bind executeonly def
/h { closepath } bind 0 get def
% Path painting and clipping
/n { n } executeonly def
/S { S } executeonly def
/s { s } executeonly def
/f { f } executeonly def
/f* { f* } executeonly def
/B { B } executeonly def
/b { b } executeonly def
/B* { B* } executeonly def
/b* { b* } executeonly def
/W { W } executeonly def
/W* { W* } executeonly def
/sh_save 1 array def
/sh_group << /Subtype /Group /Isolated //true >> readonly def
/do_shade {
0 .setoverprintmode
{ dup /.shading .knownget {
exch pop
} {
.buildshading_and_shfill
} ifelse
} stopped {
pop
( **** Error: Ignoring invalid smooth shading object, output may be incorrect.\n)
pdfformaterror
} if
} bind executeonly def
/sh {
OFFlevels length 0 eq {
setfillstate resolvesh
//sh_save 0 save put
PDFusingtransparency {
.currentSMask //null ne {
//sh_group
1 index /BBox knownoget {
{ oforce } forall
} {
gsave clippath pathbbox grestore
} ifelse
.begintransparencygroup
} if
dup checkOPtrans exch 1 index {
% We need to push a non-isolated, non-knockout transparency group and
% perform the operation in CompatibleOverprint mode, then end the
% transparency group. Do the begintransparencygroup step here.
mark /Subtype /Group /Isolated //false .dicttomark
1 index /BBox knownoget {
{ oforce } forall
} {
gsave clippath pathbbox grestore
} ifelse
.begintransparencygroup
exch .currentblendmode exch .currentopacityalpha exch 4 -1 roll % save current values
/CompatibleOverprint .setblendmode 1 .setopacityalpha
} if
//do_shade exec
{
.endtransparencygroup .setopacityalpha .setblendmode % end the CompatibleOverprint group
} if
.currentSMask //null ne {
.endtransparencygroup
} if
} {
//do_shade exec
} ifelse
//sh_save 0 get restore
} {
pop
} ifelse
} bind executeonly def
currentdict dup /sh_save undef /sh_group undef
end
% ---------------- XObjects ---------------- %
/xobjectprocs mark % <dict> -proc- -
/Image { DoImage } executeonly
/Form { DoForm } executeonly
/PS { DoPS } executeonly
.dicttomark readonly def
% Note that the keys in defaultdecodedict are resolved (PostScript, not PDF)
% color space names.
/defaultdecodedict mark
/DeviceGray { pop //01_1 } bind executeonly
/DeviceRGB { pop //01_3 } bind executeonly
/DeviceCMYK { pop //01_4 } bind executeonly
/CIEBasedA { 1 get /RangeA knownoget not { //01_1 } if } bind executeonly
/CIEBasedABC { 1 get /RangeABC knownoget not { //01_3 } if } bind executeonly
/CalGray { pop //01_1 } bind executeonly
/CalRGB { pop //01_3 } bind executeonly
/Lab { 1 get /Range knownoget not { [-100 100 -100 100] } {aload pop 0 100 6 2 roll 6 array astore}ifelse } bind executeonly
/ICCBased {
1 oget dup /Range knownoget {
exch pop
}{
/N get [ exch {0 1} repeat ] readonly
} ifelse
} bind executeonly
/Separation { pop //01_1 } bind executeonly
/DeviceN {
1 oget length [ exch {0 1} repeat ] readonly
} bind executeonly
/Indexed {
pop [ 0 1 BitsPerComponent bitshift 1 sub ]
} bind executeonly
.dicttomark readonly def
/checkaltimage { % <resdict> checkaltimage <resdict[']>
Printed {
dup /Alternates knownoget {
{
dup /DefaultForPrinting knownoget {
{
/Image oget exch pop exit
} {
pop
} ifelse
} {
pop
} ifelse
} forall
} if
} if
} bind executeonly def
% <string> <index> getu16 <integer>
/getu16 {
2 copy get 8 bitshift 3 1 roll 1 add get add
} bind executeonly def
% <string> <index> getu32 <integer>
/getu32 {
2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
} bind executeonly def
/jp2_csp_dict mark
12 { /DeviceCMYK } % CMYK
14 { [ /Lab << /WhitePoint [ 0.9505 1 1.0890 ] readonly >> ] } % LAB, WhitePoint == D65
16 { /sRGBICC /ColorSpace findresource } bind executeonly
17 { /sGrayICC /ColorSpace findresource } bind executeonly
18 3 index % YCC is converted to RGB
% 19 % CIEJab not supportec by PDF 1.7
20 { /esRGBICC /ColorSpace findresource } bind executeonly % e-sRGB
21 { /rommRGBICC /ColorSpace findresource} bind executeonly % ROMMRGB
24 { /esRGBICC /ColorSpace findresource } bind executeonly % e-sYCC
.dicttomark readonly def
% Process jp2 blocks (aka boxes). All procedures have the signature
% <file> <length> -> ... <file> <flush_length>
/jp2_tag_dict 10 dict begin
/jp2h { % descend into a sub-stream, don't return.
() /SubFileDecode filter 0
} bind executeonly def
/ihdr {
14 sub % file len-14
1 index (1234567890abcd) readstring pop % file len-14 (14)
/JPXComponents 1 index 8 getu16 % file len-14 (14) /JPXComponents NC
def % file len-14 (14)
10 get
%% If the BPC is 255 then each component has variable depth
%% we can't handle this, but JasPer is known to produce
%% images whcih declare this, but are actually all equal, we cater
%% for that in the bpcc box below.
dup 16#FF eq not {
16#7F and 1 add
dup 12 eq { pop 16 } if
/BitsPerComponent exch def % file len-14
} {pop} ifelse
} bind executeonly def
%% if the ihdr has a BPC of 255 then we get a bpcc box which
%% gives the bpc for each component individually. We cannot
%% actually deal with differing component depths, but it
%% seems JasPer produces images with this box where all the
%% component depths are in fact the same.
/bpcc {
JPXComponents sub
1 index JPXComponents string readstring pop
dup 0 get /BitsPerComponent exch def
1 1 JPXComponents 1 sub {
1 index exch get BitsPerComponent eq not {
( **** Error: JPX image colour channels do not all have the same colour depth\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} if
} for
pop
/BitsPerComponent BitsPerComponent 1 add def
} bind executeonly def
/colr {
currentdict /ColorSpace known not {
3 sub
1 index (123) readstring pop % file len-3 (3)
0 get dup 1 eq {
pop 4 sub % file len-7
1 index (1234) readstring pop % file len-16 (4)
0 getu32 % file len-16 enum
//jp2_csp_dict exch .knownget {
exec /ColorSpace exch def % file len-7
} {
( **** Error: Unknown enumerated color space in JPX stream.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} {
dup 2 eq exch 3 eq or {
1 index exch () /SubFileDecode filter /ReusableStreamDecode filter
/JPXICC exch def
0 % file 0
} {
( **** Error: Unknown color space method in JPX stream.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} ifelse
} if
} bind executeonly def
% Palette colors are decoded by the library.
/pclr {
4 sub
1 index (1234) readstring pop
3 get 16#7F and 1 add
/BitsPerComponent exch def
} bind executeonly def
/cdef {
pop
dup (12) readstring pop
0 getu16 {
dup (123456) readstring pop
2 getu16
dup 3 lt {
{ /JPXColors /JPXOpacity /JPXPremult } exch get
currentdict 1 index .knownget { 1 add } { 1 } ifelse def
} {
pop
} ifelse
} repeat
0
} bind executeonly def
currentdict end readonly def
% Parse jp2 file format to get color space and image depth info.
% <file> get_jp2_csp -
/get_jp2_csp {
{
dup (01234567) readstring pop % f (LBoxTBox)
dup length 8 lt {
pop exit
} if
dup 4 4 getinterval exch % f (TBox) (LBoxTBox)
0 getu32 % f (TBox) LBox
dup 0 eq {
pop pop exit % cannot happen
} {
dup 1 eq {
pop 1 index (01234567) readstring pop
4 getu32 % f (TBox) LBox
16 sub
} {
8 sub
} ifelse
} ifelse % f (TBox) LBox-8..16
PDFDEBUG {
2 copy 2 packedarray //== exec % f (TBox) LBox-8..16
} if
//jp2_tag_dict 3 -1 roll .knownget {
exec
} if % f flush
dup 0 ne {
1 index exch % f f flush
() /SubFileDecode filter flushfile % skip unwanted blocks
} {
pop
} ifelse
} loop
pop
} bind executeonly def
currentdict /jp2_tag_dict .undef
currentdict /jp2_csp_dict .undef
% Add a key-value pair to the last /DecodeParms dictionary
% Copy the objects to avoid spoiling shared ones.
% <resdict> <key> <value> -> <resdict>
/add-to-last-param {
2 index /DecodeParms knownoget {
dup {} eq {
pop //false
} {
//true
} ifelse
} {
//false
} ifelse {
dup type /arraytype eq {
[ exch { oforce } forall
dup //null eq { pop 1 dict } if
]
dup dup length 1 sub get % <resdict> <key> <value> [] <<>>
} {
dup length 1 add dict copy dup % <resdict> <key> <value> <<>> <<>>
} ifelse
4 2 roll put % <resdict> obj
} {
% <resdict> <key> <value>
mark 3 1 roll .dicttomark % <resdict> obj
1 index /Filter knownoget {
dup type /arraytype eq {
length array % <resdict> obj [...]
dup dup length 1 sub % <resdict> obj [...] [...] len-1
4 -1 roll put % <resdict> [... obj]
} {
pop
} ifelse
} if
} ifelse
1 index exch
/DecodeParms exch put % <resdict>
} bind executeonly def
/last-ditch-bpc-csp {
currentdict /BitsPerComponent oknown not {
( **** Error: image has no /BitsPerComponent key; assuming 8 bit.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
/BitsPerComponent 8 def
} if
currentdict /ColorSpace knownoget not {
dup /ColorSpace knownoget not {
( **** Error: image has no /ColorSpace key; assuming /DeviceRGB.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
/DeviceRGB
} if
} if
resolvecolorspace
%% This section is to deal with the horrible pair of files in Bug #696690 and Bug #696120
%% These files have ICCBased spaces where the value of /N and the number of components
%% in the profile differ. In addition the profile in Bug #696690 is invalid. In the
%% case of Bug #696690 the /N value is correct, and the profile is wrong, in the case
%% of Bug #696120 the /N value is incorrect and the profile is correct.
%% We 'suspect' that Acrobat uses the fact that Bug #696120 is a pure image to detect
%% that the /N is incorrect, we can't be sure whether it uses the profile or just uses
%% the /N to decide on a device space. What we now do is; If the /N and device profile
%% number of components don't match, we assume the device profile is correct and patch
%% /N to be the same as the profile (see /ICCBased-resolve), but we save the original
%% value of /N in /OrigN. In setcolor, if the space is a genuine ICCBased space
%% (not a replacement for a device profile) we call set_dev_color which will actually
%% exercise the profile. If that fails we return an error. Here we run setcolor in a
%% stopped context, and if it fails we check to see if there is a /OrigN (ths occurs
%% only if the /N was different to the number of components in the profile). If there
%% is a /OrigN then prefer that to the profile, otherwise they agreed, so just use
%% /N and select a device space. If we can't select a device space with the correct
%% number of components, give up and throw an error. See also 'Cdict' in pdf_ops.ps.
dup type /arraytype eq {
dup 0 get /ICCBased eq {
gsave
dup setcolorspace dup 1 get /N get
1 sub mark exch 0 1 3 -1 roll
{pop 0} for
{setcolor} stopped
grestore
{
cleartomark
1 get
dup /OrigN .knownget {exch pop}{/N get} ifelse
[//null /DeviceGray //null /DeviceRGB /DeviceCMYK] exch
{get} stopped
{
( **** Error: Unable to set an ICCBased colour space, and cannot set an alternate from the number of components.\n) print
/setcolorspace cvx /undefined signalerror
}
{
dup //null eq {
( **** Error: Unable to set an ICCBased colour space, and cannot set an alternate from the number of components.\n) print
/setcolorspace cvx /undefined signalerror
}{
ICCProfileNError not {
( **** Warning : Error setting an ICCBased colour space, using /N to set an alternate device space.\n) print
( Output may be incorrect.\n) print
} if
} ifelse
}ifelse
/ICCProfileNError //true def
}{cleartomark}ifelse
} if
} if
/ColorSpace exch def
} bind executeonly def
/get-smask-in-data { % <dict> -> <int>
/SMaskInData knownoget {
dup dup 1 ne exch 2 ne and {
pop 0
} if
} {
0
} ifelse
} bind executeonly def
/makeimagedict { % <resdict> <newdict> makeimagedict <imagemask?>
% On return, newdict' is currentdict
begin
/Width 2 copy oget def
/Height 2 copy oget def
% Handle missing BitsPerComponent later.
/BitsPerComponent 2 copy knownoget { cvi def } { pop } ifelse
/Interpolate 2 copy knownoget { def } { pop } ifelse
makeimagekeys
} bind executeonly def
/makeimagekeys { % <resdict> makeimagekeys <imagemask>
% newdict is currentdict
% Assumes Width, Height, BPC, Interpolate already copied.
/ImageType 1 def
/ImageMatrix Width 0 0
% Handle 0-height images specially.
Height dup 0 eq { pop 1 } if neg 0 1 index neg
6 array astore def
%% If the image has a rendering intent, get its numeric equivalent
%% from renderingintentdict, and save it in the dictionary we pass
%% on to render images.
dup /Intent knownoget {
//.renderingintentdict exch .knownget { /Intent exch def } if
} if
dup /ImageMask knownoget dup { and } if {
% Image mask
% Decode is required for the PostScript image operators.
% AI8 writes bogus decode array [0 1 0 0 0 0 0 0]
/Decode 2 copy knownoget { 0 2 getinterval } { //01_1 } ifelse def
% BitsPerComponent is optional for masks.
/BitsPerComponent 2 copy known { pop } { 1 def } ifelse
% Even though we're going to read data,
% pass false to resolvestream so that
% it doesn't try to use Length (which may not be present).
//false resolvestream /DataSource exch def
//true
} {
% Opaque image
dup /Filter knownoget {
dup type /arraytype eq {
dup length
dup 0 gt {
1 sub get oforce
} {
pop
} ifelse
} if
/JPXDecode eq
} {
//false
} ifelse {
% /JPXDecode tricks
% Previously we only ran the code to extract the Color Space and Bits Per Component
% from the JOX stream if the image dict had either BPC or ColorSpace undefined.
% However, while this is correct for the ColorSpace, its *not* correct for the BPC.
% According to the spec we should ignore any BPC in the image dicitonary and
% always use the BPC from the JPX stream.
% Now the code in get_jp2_csp always overwrites the ColorSpace (in the image resource dict)
% which technically is fine, because the image dictionary entry must be either not present or the
% same as the JPX stream. However, this doesn't work, so instead we just save the existing
% color space (if any). Then after extracting the color space and BPC from the JPX stream
% we put back the saved color space, but only if there was one previously.
dup /ColorSpace oknown {
dup dup /ColorSpace get /ImageDictColorSpace exch put
} if
dup /IDFlag known {
( **** Warning: PDF spec bans inline JPX images.\n) pdfformatwarning
% Inline stream is not positionable. Cannot get ColorSpace.
} {
% Drop the last filter (JPXDecode) from the pipeline
dup dup length dict copy
dup /Filter oget
dup type /arraytype eq {
dup length 1 gt {
dup length 1 sub 0 exch getinterval
1 index exch /Filter exch put
dup /DecodeParms knownoget {
dup type /arraytype eq {
dup length 1 gt {
dup length 1 sub 0 exch getinterval
1 index exch /DecodeParms exch put
} {
pop
dup /DecodeParms undef
} ifelse
} {
pop
dup /DecodeParms undef
} ifelse
} if
} {
pop
dup /Filter undef
dup /DecodeParms undef
} ifelse
} {
pop
dup /Filter undef
dup /DecodeParms undef
} ifelse
//false resolvestream get_jp2_csp
currentdict /ColorSpace oknown not {
currentdict /JPXICC .knownget {
[ /ICCBased mark
/DataSource 5 -1 roll
/N currentdict /JPXColors .knownget not {
currentdict /JPXComponents get
} if
.dicttomark
] /ColorSpace exch def
} if
} if
{ /JPXICC /JPXColors /JPXComponents /JPXOpacity /JPXPremult } {
currentdict exch undef
} forall
} ifelse
% If we had a Color Space in the image dictionary before we read the JPX
% stream, put it back now. We mujst do this before last-ditch-bpc-csp
% because that resolves any indirect references to the color space.
dup /ImageDictColorSpace known {
dup /ImageDictColorSpace get currentdict /ColorSpace 3 -1 roll put
} if
//last-ditch-bpc-csp exec
dup /ColorSpace oknown {
% Propagate known color space to the filter
/ColorSpace currentdict /ColorSpace get //add-to-last-param exec
} if
/Decode 2 copy knownoget not {
ColorSpace //defaultdecodedict
ColorSpace dup type /arraytype eq { 0 get } if get exec
} if def
dup get-smask-in-data dup 0 ne {
PDFusingtransparency {
currentdict dup length dict copy begin
{/Mask/SMask/SMaskInData/Name} { currentdict exch undef } forall
2 eq {
/Matte [ Decode length 2 idiv { 0 } repeat ] def
} if
/Decode //01_1 def
/ColorSpace /DeviceGray def
{/File /FilePosition /Filter /Length /DecodeParms /FFilter /FDecodeParms } {
2 copy knownoget {
def
} {
pop
} ifelse
} forall
currentdict /Alpha //true //add-to-last-param exec pop
/SMask currentdict end def
} {
pop
} ifelse
} {
pop
} ifelse
} { % not JPX image
//last-ditch-bpc-csp exec
/Decode 2 copy knownoget not {
ColorSpace //defaultdecodedict
ColorSpace dup type /arraytype eq { 0 get } if get exec
} if def
} ifelse % fi JPX tricks
% Add a /Height key containing the image height to the DecodeParms
% for any Filters we will apply. If there are no DecodeParms for any
% filter, create one and add a /Height key. This is to solve the problem
% in Bug #695116 where a JPEG image has a bad height, which is later
% fixed up using a DNL marker. By placing the image height from the
% PDF in the DeoceParms we cna use it in the DCTDecode filter to
% work around this.
dup /Filter knownoget { % <<stream dict>> /name or [array]
dup type /arraytype eq {
% <<stream dict>> [array of names]
length % <<stream dict>> number of filters
1 index /DecodeParms knownoget {
exch pop % drop length of Filter array, the DecodeParams has 1 entry per filter
% <<stream dict>> [array of decodeparams]
} {
% No deocde params, we must make an array of them
% <<stream dict>> number of filters
array % <<stream dict>> []
dup % <<stream dict>> [] []
2 index /DecodeParms exch % <<stream dict>> [] [] /DecodeParms <<stream dict>>
3 1 roll % <<stream dict>> <<stream dict>> [] /DecodeParms
exch put % <<stream dict>> []
} ifelse
dup length 1 sub % <<stream dict>> [] arraylength-1
0 1 3 -1 roll % <<stream dict>> [] 0 1 arraylength-1
{ % <<stream dict>> [] loopcount
1 index % <<stream dict>> [] loopcount []
2 copy % <<stream dict>> [] loopcount [] loopcount []
exch
get % <<stream dict>> [] loopcount [] <<>> or -null-
dup //null eq {
pop exch % <<stream dict>> [] [] loopcount
<</Height
5 index /Height oget % <<stream dict>> [] [] loopcount << /Height Height
round cvi
>>
put % <<stream dict>> []
}{ %
oforce_recursive % resolve any indirect references
dup type /dicttype eq {
% <<stream dict>> [] loopcount [] <<>>
/Height % <<stream dict>> [] loopcount [] <<>> /Height
5 index /Height oget % <<stream dict>> [] loopcount [] <<>> /Height Height
round
cvi
put pop pop % <<stream dict>> []
}{
%% bogus entry, throw it away and create a new one
pop exch % <<stream dict>> [] loopcount []
<</Height
5 index /Height oget % <<stream dict>> [] [] loopcount << /Height Height
round cvi
>>
put % <<stream dict>> []
} ifelse
}ifelse
} for
pop % <<stream dict>>
}{
pop % <<stream dict>>
dup /DecodeParms knownoget {
oforce_recursive % resolve any indirect references
dup type /dicttype eq {
% <<stream dict>> <<decode parms dict>>
/Height 2 index % <<stream dict>> <<decode parms dict>> /Height <<stream dict>>
/Height oget % <<stream dict>> <<decode parms dict>> /Height ImageHeight
round cvi
put % <<stream dict>>
}{
%% bogus entry, throw it away and create a new one
pop % <<image dict>> <<stream dict>> []
<</Height % <<stream dict>> <<image dict>> << /Height
2 index /Height oget % <<stream dict>> <<image dict>> << /Height Height
round cvi
>>
1 index exch /DecodeParms exch put % <<stream dict> <<image dict>>
} ifelse
}{
dup % <<stream dict>> <<stream dict>>
/DecodeParms <</Height % <<stream dict>> <<stream dict>> /DecodeParms << /Height
3 index % <<stream dict>> <<stream dict>> /DecodeParms << /Height <<stream dict>>
/Height oget
round cvi
>> % <<stream dict>> <<stream dict>> /DecodeParms << /Height ImageHeight>>
put % <<stream dict>>
}ifelse
}ifelse
} if
% Even though we're going to read data,
% pass false to resolvestream so that
% it doesn't try to use Length (which may not be present).
//false resolvestream /DataSource exch def
//false
} ifelse
} bind executeonly def
currentdict /add-to-last-param undef
currentdict /last-ditch-bpc-csp undef
/DoImage {
%% Bug #696439. This is incredibly icky. When we find indirect obects we resolve them
%% and store the resolved object in the containing object. This means that we retain
%% the image dicionary here until the end of job. Potentially wasteful. Even worse though
%% is the case where the image has a ColorSpace which is not an indirect object, but *is*
%% an ICCBased colour space. In ths case we end up resolving the colour space and storing it
%% here. Unfortunately, we use a ReusableStreamDecode filter on the ICC profile, which means
%% we end up retaining the memory for that too. ICC profiles can be large, and if there are a
%% lot of places where they get used, we can exhaust memory.
%% Here we check if the ColorSpace is an array object, if it is we *copy* the image dictionary
%% and use the copy instead. The copy is (eventually) discarded so we don't retain the ICC profile
%% and don't exhaust memory. Note that we have to copy the actual colour space array too, copying
%% the dictionary just copies the opriginal array as well.
%%
dup /ColorSpace known {
dup /ColorSpace get dup type /arraytype eq {
exch dup length dict copy exch
dup length array copy /ColorSpace exch 2 index 3 1 roll put
} {pop} ifelse
} if
checkaltimage dup length 6 add dict % <<image>> <<>>
1 index /SMask knownoget { % <<image>> <<>> <<sm>>
dup 3 index ne { % <<image>> <<>> <<sm>> <<sm>>
1 index exch /SMask exch put
} {
pop
( **** Error: ignoring recursive /SMask attribute.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
1 index /Mask knownoget { 1 index exch /Mask exch put } if
makeimagedict doimagesmask
} bind executeonly def
/makemaskimage { % <datasource> <imagemask> <Mask> makemaskimage
% <datasource> <imagemask>, updates currentdict =
% imagedict
dup type /arraytype eq {
/ImageType 4 def
% Check that every element of the Mask is an integer.
//false 1 index {
type /integertype ne or
} forall {
oforce_array
//false 1 index {
type /integertype ne or
} forall {
(\n **** Error: Some elements of Mask array are not integers.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
[ exch { 0.5 add cvi } forall ] % following AR4, 5, 6 implementation
} if
} if
% Check elements of array are within 0::(2**BitsPerComponent)-1
% This is a PostScript error, but AR tries to fix the Mask.
1 BitsPerComponent bitshift 1 sub //false 2 index {
% stack: max_value result_bool value
dup 0 lt exch 3 index gt or or
} forall exch pop {
( **** Error: Some elements of Mask array are out of range.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
ColorSpace dup type /arraytype eq { 0 oget } if /Indexed eq
BitsPerComponent 1 eq and {
% AR9 treats Indexed 1 bpc images specially. Bug 692852 see also 697919 and 689717.
dup 0 oget
dup 0 lt exch 1 BitsPerComponent bitshift ge or {
% First component is invalid - AR9 ignores the mask
pop //null
} {
% Second component is invalid; AR9 replaces it with 1.
[ exch 0 oget 1 ]
} ifelse
} {
% AR5, AR9 do this for most cases. Bug 690786.
[ exch { 1 BitsPerComponent bitshift 1 sub and } forall ]
} ifelse
} {
ColorSpace dup type /arraytype eq { 0 oget } if /DeviceGray eq
BitsPerComponent 1 eq and {
%% For DeviceGray, try clamping the values to 0 and 1 respectively
dup 0 oget
dup 0 lt exch 1 gt or {
dup 0 oget
dup 0 lt {
pop dup 0 0 put
}{
dup 0 1 put
} ifelse
} if
dup 1 oget
dup 0 lt exch 1 gt or {
dup 1 oget
dup 0 lt {
pop dup 0 0 put
}{
dup 0 1 put
} ifelse
} if
}{
% AR5, AR9 do this for most cases. Bug 690786.
[ exch { 1 BitsPerComponent bitshift 1 sub and } forall ]
} ifelse
} ifelse
dup //null ne {
/MaskColor exch def
} {
pop
/ImageType 1 def
} ifelse
} {
% Mask is a stream, another Image XObject.
% Stack: datasource imagemask(false) maskstreamdict
PDFfile fileposition exch
dup length dict makeimagedict pop
% In order to prevent the two data sources from being
% aliased, we need to make at least one a reusable stream.
% We pick the mask, since it's smaller (in case we need to
% read all its data now).
% Stack: datasource imagemask(false) savedpos
% maskdict is currentdict
/DataSource DataSource mark
/Intent 1
/AsyncRead //true
.dicttomark {.reusablestreamdecode} stopped {pop} if def
PDFfile exch setfileposition
currentdict end currentdict end
5 dict begin
/ImageType 3 def
/InterleaveType 3 def
/DataDict exch def
/MaskDict exch def
/ColorSpace DataDict /ColorSpace get def
} ifelse
} bind executeonly def
/doimagesmask { % <imagemask> doimagesmask -
PDFusingtransparency {
currentdict /SMask knownoget
} {
//false
} ifelse
{ % We are doing transparency and SMask is present in the image
% stack: <imagemask> <SMask>
/PreserveSMask /GetDeviceParam .special_op {
exch pop
}{
//false
}ifelse
{
pop % pdfwrite will process SMask directly during 'doimage'
} {
.begintransparencymaskimage
PDFfile fileposition exch
gsave //nodict begin
//null .setSMask
1 .setopacityalpha 1 .setshapealpha
1 CA 1 ca
/Compatible .setblendmode
DoImage
end grestore
PDFfile exch setfileposition
0 .endtransparencymask
} ifelse
<< /Subtype /Group /Isolated //true
/.image_with_SMask //true
% pdfwrite needs : see gs/src/ztrans.c, gs/src/gdevpdft.c
% Code to deal with a Matte in the SMask. We know the image dictionary must have an SMask
% entry if we get here, so we don't need to check its existence. Just pull it out and see if
% the SMask has a Matte entry. If it does, get the ColorSpace from the parent image and
% put a /CS key with that colour space in the Group that we manufacture. Bug #700686
% We also need to actually set the current colour space to be the same as the group
% code only picks up the current colour space, not the space from the dictionary.
currentdict /SMask get /Matte known {/CS currentdict /ColorSpace get dup pdfopdict /cs get exec } if
>> 0 0 1 1 .begintransparencygroup
doimage
.endtransparencygroup
% tell the compositor we're done with the SMask.
% Note that any SMask in the ExtGState should be reapplied
% by the next call to setfill(stroke)state AND this relies
% on our lazy evaulation of SMask groups
//false << /Subtype /None >> 0 0 0 0 .begintransparencymaskgroup
} {
.currentSMask //null ne {
% the image doesn't have an SMask, but the ExtGState does, force a group.
<< /Subtype /Group /Isolated //true >> 0 0 1 1 .begintransparencygroup
doimage
.endtransparencygroup
}
{ doimage }
ifelse
} ifelse
} bind executeonly def
% For development needs we define a special option for running with a new handler
% for images with a soft mask.
//systemdict /NEW_IMAGE3X .knownget not { //false } if {
/doimagesmask { % <imagemask> doimagesmask -
doimage
} bind executeonly def
} if
/ValidateDecode { % <<image dict>> -imagemask- ValidateDecode <<image dict>>
exch
dup /Decode .knownget {
dup length % -imagemask- <<image dict>> [Decode] length
4 -1 roll % <<image dict>> [Decode] length -imagemask-
{
1 % ImageMask Decode arrays must be [0 1] or [1 0]
}
{
mark currentcolor counttomark % <<image dict>> [Decode] length [ ... component_count
dup 2 add 1 roll % <<image dict>> [Decode] length component_count [ ....
cleartomark % <<image dict>> [Decode] length component_count
} ifelse
2 mul dup % <<image dict>> [Decode] length comp_count*2 comp_count*2
3 1 roll % <<image dict>> [Decode] comp_count*2 length comp_count*2
eq { % <<image dict>> length of Decode matches colour space requirement
pop pop % <<image dict>> remove [Decode] and comp_count*2
}{ % <<image dict>> Decode array incorrect
dup 2 index length % <<image dict>> [Decode] comp_count*2 comp_count*2 length
exch sub 0 gt { % Decode is too long
(\n **** Warning: Decode array for an image is too long\n) pdfformatwarning
( Output may be incorrect.\n) pdfformatwarning
0 exch % <<image dict>> [Decode] 0 comp_count*2
getinterval % <<image dict>> [subarray of Decode]
1 index exch /Decode exch % <<image dict>> <<image dict>> /Decode [subarray]
put % <<image dict>>
}{
% Decode is too short, Acrobat throws errors on this
(\n **** ERROR: Decode array for an image is too short\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop pop % remove [Decode] and comp_count*2
} ifelse
} ifelse
} {
exch pop
}ifelse
}bind executeonly def
/doimage { % <imagemask> doimage -
% imagedict is currentdict, gets popped from dstack
//null checkOPtrans {
% We need to push a non-isolated, non-knockout transparency group and
% perform the operation in CompatibleOverprint mode, then end the
% transparency group. Do the begintransparencygroup step here.
mark /Subtype /Group /Isolated //false .dicttomark 0 0 1 1 .begintransparencygroup
OPsavedict dup /saveBM .currentblendmode put /saveOA .currentopacityalpha put % save current values
/CompatibleOverprint .setblendmode 1 .setopacityalpha
} if
%% save the current rendering intent
.currentrenderintent exch
%% Check the image dictionary to see if there is a /Intent
currentdict /Intent known {
%% and set the current rendering intent to match if so
Intent .setrenderingintent
} if
DataSource exch
currentdict /SMask known PDFusingtransparency and {
/PreserveSMask /GetDeviceParam .special_op {
pop pop
currentdict /SMask oget
makesoftmaskimage
} if
} if
currentdict /Mask knownoget {
makemaskimage
} if
% Stack: datasource imagemask
{ currentdict end setfillstate //true ValidateDecode { imagemask } }
{ ColorSpace setgcolorspace currentdict end setfillblend //false ValidateDecode { image } }
ifelse
PDFSTOPONERROR { exec //false } { stopped } ifelse {
dup type /dicttype eq { pop } if % Sometimes image fails to restore the stack
$error /errorname get dup /ioerror eq {
pop (\n **** Error: File has insufficient data for an image.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} {
(\n **** Error: File encountered ')
exch 40 string cvs concatstrings
(' error while processing an image.\n) concatstrings
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
% Close the input stream, unless it is PDFfile or
% PDFsource.
dup dup PDFfile eq exch PDFsource eq or { pop } { closefile } ifelse
%% restore the rendering intent
.setrenderingintent
.currentblendmode /CompatibleOverprint eq {
.endtransparencygroup
OPsavedict dup /saveOA get .setopacityalpha /saveBM get .setblendmode
} if
} bind executeonly def
/.paintform { % <formdict> <resdict> <stream> .paintform -
1 index /FormResDict gput % For broken forms that inherit resources from the context.
3 -1 roll dup /Group known PDFusingtransparency and {
.paintgroupform
} {
pop pdfopdict .pdfruncontext
} ifelse
} bind executeonly def
/IncrementAppearanceNumber {
//pdfdict /AppearanceNumber .knownget {
1 add //pdfdict /AppearanceNumber 3 -1 roll .forceput
} executeonly
{
//pdfdict /AppearanceNumber 0 .forceput
} executeonly ifelse
}bind executeonly odef
/MakeAppearanceName {
//pdfdict /AppearanceNumber get
10 string cvs
dup length 10 add string dup 0 (\{FormName) putinterval
dup 3 -1 roll
9 exch putinterval
dup dup length 1 sub (\}) putinterval
} bind executeonly def
/MakeNewAppearanceName {
IncrementAppearanceNumber
MakeAppearanceName
}bind executeonly def
/DoAppearance {
%% Might need to rethink this. The problem is that if the page has a CropBox, we apply
%% that as an initial clip. When we run the form, we don't apply the /Rect from the
%% annotation, which means that the form could be out of the clip, which results in
%% content going missing. Resetting the clip prevents this.
gsave initclip
MakeNewAppearanceName
.pdfFormName
//pdfdict /.PreservePDFForm known {//pdfdict /.PreservePDFForm get} {//false}ifelse exch
//pdfdict /.PreservePDFForm //true .forceput
DoForm
//pdfdict /.PreservePDFForm 3 -1 roll .forceput
grestore
} bind executeonly odef
%% We don't want to do any high level forms stuff if the source
%% is PDF because :
%% 1) Transparent forms are handled separately and we don't want to ge confused
%% 2) PDF forms are too llikely to trip over the limitations in our support
%% 3) Its highly unusual to find a PDF file which uses forms sensibly.
%%
%% So we have a special PDF version of execform which doesn't do high level forms.
pdfdict
/.PDFexecform {
% This is a separate operator so that the stacks will be restored
% properly if an error occurs.
dup /Matrix get concat
dup /BBox get aload pop
exch 3 index sub exch 2 index sub rectclip
dup /PaintProc get
1 index /Implementation known not {
1 index dup /Implementation //null .forceput readonly pop
} executeonly if
exec
} .bind executeonly put
pdfdict
/PDFexecform {
gsave { //.PDFexecform exec } stopped
grestore {stop} if
} .bind executeonly put
/DoForm {
%% save the current value, if its true we will set it to false later, in order
%% to prevent us preserving Forms which are used *from* an annotation /Appearance.
//pdfdict /.PreservePDFForm known {//pdfdict /.PreservePDFForm get} {//false}ifelse exch
%% We may alter the Default* colour spaces, if the Resources
%% ColorSpace entry contains one of them. But we don't want that
%% to become the new default, we want to revert to any existing
%% definition, or the Device space. The Default* spaces are defined
%% as ColorSpace resources, so the only way to handle them is to
%% save and restore round the definitions
3 dict dup begin
/saved_DG /DefaultGray /ColorSpace findresource def
/saved_DRGB /DefaultRGB /ColorSpace findresource def
/saved_DCMYK /DefaultCMYK /ColorSpace findresource def
end
exch
% Adobe 2nd edition of the PDF 1.3 spec makes /FormType
% and /Matrix keys optional. Cope with the missing keys.
begin <<
currentdict /FormType known not { /FormType 1 } if
currentdict /Matrix known not
{ /Matrix { 1 0 0 1 0 0 } cvlit }
{
0 1 Matrix length 1 sub
{
dup Matrix exch get type dup
/integertype eq exch
/realtype eq or not
{
(\n **** Error: Invalid element in /Form XObject matrix.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
Matrix exch 0.00 put
}
{ pop }
ifelse
} for
} ifelse
currentdict /BBox known not {
(\n **** Error: Required entry /BBox not present in Form.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
/BBox [0 1 0 1]
} if
currentdict end { oforce } forall
>>
dup [ 2 index /Resources knownoget { oforce } { 0 dict } ifelse
%% Ugly hackery for Default* colour spaces in forms
%%
dup /ColorSpace knownoget {
oforce {
//false 3 1 roll
exch dup /DefaultGray eq
{
pop exec resolvecolorspace dup csncomp 1 eq {
dup type /nametype eq { 1 array astore } if
/DefaultGray exch /ColorSpace defineresource pop
pop //true
}{
pop
( **** Error: ignoring invalid /DefaultGray color space.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
}{
dup /DefaultRGB eq {
pop exec resolvecolorspace dup csncomp 3 eq {
dup type /nametype eq { 1 array astore } if
/DefaultRGB exch /ColorSpace defineresource pop
pop //true
}{
pop
( **** Error: ignoring invalid /DefaultRGB color space in Form Resources.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
}{
/DefaultCMYK eq {
exec resolvecolorspace dup csncomp 4 eq {
dup type /nametype eq { 1 array astore } if
/DefaultCMYK exch /ColorSpace defineresource pop
pop //true
}{
pop
( **** Error: ignoring invalid /DefaultCMYK color space in Form Resources.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
}{
pop
} ifelse
} ifelse
}ifelse
{ % if using color space substitution, "transition" the current color space
currentcolorspace dup length 1 eq { % always an array
0 get
dup /DeviceGray eq 1 index /DeviceRGB eq or 1 index /DeviceCMYK eq or {
/Pattern setcolorspace setcolorspace
} {
pop
} ifelse
} {
pop
} ifelse
} if
} forall
} if
3 index //false /resolvestream cvx
/.paintform cvx
] cvx /PaintProc exch put
% Adjust pdfemptycount since we have an extra dictionary on the stack
pdfemptycount countdictstack 3 -1 roll
/pdfemptycount count 4 sub store
//pdfdict /.PreservePDFForm known {//pdfdict /.PreservePDFForm get}{//false} ifelse
{
%% We must *not* preserve any subsidiary forms (curently at least) as PDF
%% form preservation doesn't really work. This is used just for Annotation
%% Appearances currently, and if they should happen to use a form, we do not
%% want to preserve it.
//pdfdict /.PreservePDFForm //false .forceput
/q cvx /execform cvx 5 -2 roll
} executeonly
{
/q cvx /PDFexecform cvx 5 -2 roll
} ifelse
4 .execn
% Restore pdfemptycount
0
{ countdictstack
2 index le { exit } if
currentdict /n known not { 1 add } if
countdictstack
Q
countdictstack eq {end} if
} loop
1 gt {
( **** Error: Form stream has unbalanced q/Q operators \(too many q's\)\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} if
pop
/pdfemptycount exch store
%% Put back pre-existing Default* ColorSpace definitions.
dup type /dicttype eq {
begin
saved_DG /DefaultGray exch /ColorSpace defineresource pop
saved_DRGB /DefaultRGB exch /ColorSpace defineresource pop
saved_DCMYK /DefaultCMYK exch /ColorSpace defineresource pop
end
} if
//pdfdict /.PreservePDFForm 3 -1 roll .forceput
} bind executeonly odef
/_dops_save 1 array def
/DoPS {
DOPS
{
//_dops_save 0 save put
//true resolvestream cvx exec
//_dops_save 0 get restore
}
{ pop }
ifelse
} bind executeonly def
currentdict /_dops_save undef
/ocg_pocs 4 dict begin
/AllOn {
//true exch {
oforce dup type /dicttype eq {
/OFF known not and
} {
pop
} ifelse
} forall
} bind executeonly def
/AnyOn {
//false exch {
oforce dup type /dicttype eq {
/OFF known not or
} {
pop
} ifelse
} forall
} bind executeonly def
/AnyOff {
//AllOn exec not
} bind executeonly def
/AllOff {
//AnyOn exec not
} bind executeonly def
currentdict end readonly def
% Check whether OCG or OCMD is visible
% <dict> oc-is-visible <bool>
/ocg-is-visible {
dup /Type knownoget {
/OCMD eq {
dup /OCGs knownoget not { {} } if % OC OCGs
dup type /dicttype eq { 1 array astore } if
//true 1 index { //null eq and } forall {
pop pop //true % all nulls => show
} {
exch /P knownoget not { /AnyOn } if % OCGs P
//ocg_pocs exch get exec % bool
} ifelse
} {
dup /OFF known not % OFF is inserted by process_trailer_attrs
{
%% /OC is not in the OCProperties /OFF array, so we need to
%% test its usage. We may eventually have to add a /ON to the dictionary
%% if the OCProperties /ON array defines the /OC, I think that should override
% the Usage, but I don't have an example to test.
/Usage .knownget {
oforce
/Printed where {
/Printed get
} {
//false
}ifelse
{
%% We are behaving as a printer, check the Print state
/Print .knownget {
/PrintState .knownget {
oforce
/OFF eq {
//false
}{
//true
} ifelse
}{
//true
} ifelse
}{
%% If we don't know, assume its visible
//true
} ifelse
}{
%% We are behaving as a viewer, check the View state
/View .knownget {
oforce
/ViewState .knownget {
/OFF eq {
//false
}{
//true
} ifelse
}{
//true
} ifelse
}{
%% If we don't know, assume its visible
//true
} ifelse
} ifelse
}{
%% If we don't know, assume its visible
//true
} ifelse
}{
pop //false
}ifelse
} ifelse
} {
/OFF known not % OFF is inserted by process_trailer_attrs
} ifelse
} bind executeonly def
drawopdict begin
/Do { % /Name
%% Bug 695897 This file has nested text blocks and also a Do image inside
%% a text block. Here we attempt to detect and recover from this by setting the
%% CTM to the matrix we saved before the text block. NB we update the 'TextSaveMatrix'
%% or 'qTextSaveMatrix' whenever a 'cm' is issued, even if we are in a text block, so
%% these matrices 'ought' to be correct.
%% Of course, the file is badly broken, but 'Acrobat can open it....'
currentdict /TextSaveMatrix known {
gsave
( **** Error: Executing Do inside a text block, attempting to recover\n) pdfformaterror
currentdict /TextSaveMatrix get setmatrix
( Output may be incorrect.\n) pdfformaterror
} if
currentdict /qTextSaveMatrix known {
gsave
( **** Error: Executing Do inside a text block, attempting to recover\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
currentdict /qTextSaveMatrix get setmatrix
} if
setfillblend
PDFfile fileposition exch % pos /Name
% Bug #698226, Acrobat signals an error for recursive XObjects in a PDF file
% but continues. This is true even if the XObject is not a simple self-reference
% (eg /Fm1 -> /Fm2 -> /Fm3 -> /Fm1).
% Normally when dealing with recursion we would put a dictionary on the stack, store the
% object numbers encoutnered in it, and check each new object number to see if we've
% already seen it. This doesn't work well for XObjects, because the operand stack can be
% in any state when we run a Do. So we make a new dictionary in pdfdict to hold the
% object numbers.
% We also don't usually know the object number of a Form, we just get given its name
% so we need a new routine to return the object number. This is because the parent XObject
% might reference teh object by one name, while the child references it by another, we
% can't permit clashes.
%
% Start by getting the object number for a Form XObject
dup Page /XObject obj_get dup 0 eq not {
% Now get the recording dictionary and see if that object number has been seen
//pdfdict /Recursive_XObject_D get 1 index known {
( **** Error: Recursive XObject detected, ignoring ") print 1 index 256 string cvs print (", object number ) print 256 string cvs print (\n) print
( Output may be incorrect.\n) pdfformaterror
//false
}{
% We haven't seen it yet, so record it.
//pdfdict /Recursive_XObject_D get 1 index //null put
3 1 roll
//true
}ifelse
}
{
% I don't think this should be possible, but just in case
( **** Error: Unable to determine object number for ) print exch 256 string cvs print ( so ignoring it) print
( Output may be incorrect.\n) pdfformaterror
//false
} ifelse
% If we could get the object number, and we haven't already seen it, then execute it.
{
dup Page /XObject rget {
exch pop % pos obj
OFFlevels length 0 eq {
dup /OC knownoget { ocg-is-visible } { //true } ifelse
} {
//false
} ifelse {
dup /Subtype oget //xobjectprocs exch get % pos obj {proc}
% Don't leave extra objects on the stack while executing
% the definition of the form.
3 -1 roll % obj {proc} pos
2 .execn % pos
} {
pop % pos
} ifelse
} {
% This should cause an error, but Acrobat Reader can
% continue, so we do too.
( **** Error: Undefined XObject resource: )
exch =string cvs concatstrings (\n) concatstrings
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
PDFfile exch setfileposition
//pdfdict /Recursive_XObject_D get exch undef
}{
% Otherwise ignore it and tidy up the stacks
pop pop
} ifelse
} bind executeonly def
end
currentdict /xobjectprocs .undef
currentdict /ocg_pocs .undef
% ---------------- In-line images ---------------- %
% Undo the abbreviations in an in-line image dictionary.
% Note that we must look inside array values.
% /I is context-dependent.
/unabbrevkeydict mark
/BPC /BitsPerComponent /CS /ColorSpace /D /Decode /DP /DecodeParms
/F /Filter /H /Height /I /Interpolate /IM /ImageMask /W /Width
.dicttomark readonly def
/unabbrevvaluedict mark
/AHx /ASCIIHexDecode /A85 /ASCII85Decode /CC /CalCMYK
/CCF /CCITTFaxDecode /CG /CalGray /CR /CalRGB
/DCT /DCTDecode /CMYK /DeviceCMYK /Fl /FlateDecode
/G /DeviceGray /RGB /DeviceRGB
/I /Indexed /LZW /LZWDecode /RL /RunLengthDecode
.dicttomark readonly def
/unabbrevtypedict mark
/nametype {
//unabbrevvaluedict 1 index .knownget { exch pop } if
}
/arraytype {
dup 0 1 2 index length 1 sub {
2 copy get unabbrevvalue put dup
} for pop
}
.dicttomark readonly def
/unabbrevvalue { % <obj> unabbrevvalue <obj'>
oforce //unabbrevtypedict 1 index type .knownget { exec } if
} bind executeonly def
/is_space_dict << 0 0 9 9 10 10 12 12 13 13 32 32 >> readonly def
drawopdict begin
/BI { mark } bind executeonly def
/ID {
gsave
%% Bug 696547, related to Bug 695897 (see /Do above) This file has an inline image inside
%% a text block. Here we attempt to detect and recover from this by setting the
%% CTM to the matrix we saved before the text block. NB we update the 'TextSaveMatrix'
%% or 'qTextSaveMatrix' whenever a 'cm' is issued, even if we are in a text block, so
%% these matrices 'ought' to be correct.
%% Of course, the file is badly broken, but 'Acrobat can open it....'
currentdict /TextSaveMatrix known {
( **** Error: Executing ID inside a text block, attempting to recover\n) pdfformaterror
currentdict /TextSaveMatrix get setmatrix
( Output may be incorrect.\n) pdfformaterror
} if
currentdict /qTextSaveMatrix known {
( **** Error: Executing ID inside a text block, attempting to recover\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
currentdict /qTextSaveMatrix get setmatrix
} if
counttomark 2 idiv dup 7 add dict begin {
exch //unabbrevkeydict 1 index .knownget { exch pop } if
exch unabbrevvalue def
} repeat pop
/IDFlag //true def % flag for stream processing.
/File PDFsource def
currentdict makeimagekeys
OFFlevels length 0 eq {
doimage
} {
pop Width
currentdict /ImageMask knownoget dup { and } if not {
ColorSpace oforce csncomp mul
BitsPerComponent mul
} if
7 add 8 idiv Height mul
DataSource exch () /SubFileDecode filter flushfile
end
} ifelse
% The Adobe documentation says that the data following ID
% consists of "lines", and some PDF files (specifically, some files
% produced by PCL2PDF from Visual Software) contain garbage bytes
% between the last byte of valid data and an EOL.
% Some files (PDFOUT v3.8d by GenText) have EI immediately following
% the stream. Some have no EOL and garbage bytes.
% Sometimes (bug 690300) CCITTDecode filter consumes 'E' in 'EI'.
% Therefore, we search for <start>I<sp|end> or <start|sp>EI<sp|end>
PDFsource read not {
/ID cvx /syntaxerror signalerror
} if
dup 73 eq {
pop 10 69 73 % Seed to: <sp>EI
} {
10 10 3 -1 roll % Seed to: <sp><sp><any>
} ifelse
{ PDFsource read not dup { 10 exch } if
//is_space_dict 2 index known
3 index 73 eq and 4 index 69 eq and
//is_space_dict 6 index known and {
pop pop pop pop pop exit
} {
{
pop pop pop /ID cvx /syntaxerror signalerror
} {
4 -1 roll pop
} ifelse
} ifelse
} loop
grestore
} bind executeonly def
end
currentdict /is_space_dict undef
% ================================ Text ================================ %
drawopdict begin
% Text control
/BT { BT } executeonly def
/ET { ET } executeonly def
/Tc { Tc } executeonly def
/TL { TL } executeonly def
/Tr { Tr } executeonly def
/Ts { Ts } executeonly def
/Tw { Tw } executeonly def
/Tz { Tz } executeonly def
% Text positioning
/Td { Td } executeonly def
/TD { TD } executeonly def
/Tm { Tm } executeonly def
/T* { T* } executeonly def
% Text painting
/Tj { Tj } executeonly def
/' { ' } executeonly def
/" { " } executeonly def
/TJ { TJ } executeonly def
/Tform { Tform } executeonly def % Text formatting and painting for AcroForm
% without appearance streams.
end
% ======================= Invalid operators ============================ %
drawopdict begin
/QBT {
Q BT
( **** Error: invalid operator QBT processed as Q BT .\n)
pdfformaterror % Bug 690089
( Output may be incorrect.\n) pdfformaterror
} executeonly def
/. {
0.
( **** Error: invalid operator . processed as number 0. .\n)
pdfformaterror % Bug 690730
( Output may be incorrect.\n) pdfformaterror
} executeonly def
end
% ============================== Annotations ============================== %
% Create links from separate widget annotations to the parent field nodes.
% Surprisingly, separate widget annotations don't have a link to the parent
% from which they inherit some data.
/link_widget_annots { % <<parent>> <<kid>> -> <<parent>> <<kid>>
dup /Kids knownoget {
{ oforce
dup type /dicttype eq {
link_widget_annots
} if
pop
} forall
} if
dup /Parent oknown not {
2 copy exch /ParentField exch put
} if
} bind executeonly def
% Get and normalize an annotation's rectangle.
/annotrect { % <annot> annotrect <x> <y> <w> <h>
/Rect oget oforce_recursive aload pop
exch 3 index sub dup 0 lt { dup 5 -1 roll add 4 1 roll neg } if
exch 2 index sub dup 0 lt { dup 4 -1 roll add 3 1 roll neg } if
} bind executeonly def
% Set an annotation color.
% If the /C array is empty we don't want to draw the annotation
%
/annotsetcolor { % <annot> annotsetcolor bool
/C knownoget {
dup length 4 eq {
aload pop setcmykcolor //true
}{
dup length 3 eq {
aload pop setrgbcolor //true
}{
dup length 1 eq {
aload pop setgray //true
} {
dup length 0 eq {
pop
//false
}{
( **** Error: invalid color specified for annotation /C entry)
pdfformaterror //false
( Output may be incorrect.\n) pdfformaterror
} ifelse
} ifelse
} ifelse
} ifelse
}
{ 0 setgray //true} ifelse
} bind executeonly def
% Set an annotation color.
% If the /C array is empty we don't want to draw the annotation
%
/annotsetinteriorcolor { % <annot> annotsetcolor bool
/IC knownoget {
dup length 4 eq {
aload pop setcmykcolor //true
}{
dup length 3 eq {
aload pop setrgbcolor //true
}{
dup length 1 eq {
aload pop setgray //true
} {
dup length 0 eq {
pop
//false
}{
( **** Error: invalid color specified for annotation /C entry)
pdfformaterror //false
( Output may be incorrect.\n) pdfformaterror
} ifelse
} ifelse
} ifelse
} ifelse
}
{ 0 setgray //true} ifelse
} bind executeonly def
% Draw the border. Currently, we ignore requests for beveling, and we
% don't round the corners of rectangles.
/strokeborder { % <annot> <width> <dash> strokeborder -
1 index 0 ne { % do not draw if border width is 0
gsave
2 index annotsetcolor
{
0 setdash dup setlinewidth
exch annotrect
2 { 4 index sub 4 1 roll } repeat
2 { 4 index 0.5 mul add 4 1 roll } repeat
rectstroke pop
grestore
} {
pop pop pop
} ifelse
} {
pop pop pop
}ifelse
} bind executeonly def
% Draw an annotation border.
/drawborder { % <annot> drawborder -
gsave
dup /BS known 1 index /Border known or {
dup /BS knownoget {
dup type /dicttype ne % <annot> <border> <bad?>
} {
dup /Border oget
dup type /arraytype eq {
dup length 3 lt
} {
//true
} ifelse % <annot> [border] <bad?>
} ifelse {
( **** Error: Invalid annotation border object, border has not been drawn.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop { 0 0 0 }
} if
dup type /dicttype eq {
dup /W knownoget not { 1 } if
% Per PDF1.6 Reference table 8.13, /W in the border style dictionary is
% expressed in points (an absolute unit), so compensate here for any
% scaling of the PostScript user space done due to /UserUnit.
% Scaling due to -dPDFFitPage is not undone, to keep the correct border width
% compared to the size of the surrounding marks.
//systemdict /NoUserUnit .knownget not { //false } if not
//systemdict /PDFFitPage known not and { % UserUnit is ignored if -dPDFFitPage
Page /UserUnit knownoget { div } if
} if
{} 2 index /S knownoget {
/D eq { 2 index /D knownoget not { {3} } if exch pop } if
} if 3 -1 roll pop strokeborder
} {
dup 2 get
exch dup length 3 gt { 3 get } { pop {} } ifelse
strokeborder
} ifelse
} {
1 {} strokeborder
} ifelse
grestore
} bind executeonly def
% stroke the path of an annotation border.
/strokeborderpath { % <annot> strokeborderpath -
gsave
dup /BS known 1 index /Border known or {
dup /BS knownoget {
dup type /dicttype ne % <annot> <border> <bad?>
} {
dup /Border oget
dup type /arraytype eq {
dup length 3 lt
} {
//true
} ifelse % <annot> [border] <bad?>
} ifelse {
( **** Error: Invalid annotation border object, border has not been drawn.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop { 0 0 0 }
} if
dup type /dicttype eq {
dup /W knownoget not { 1 } if
% Per PDF1.6 Reference table 8.13, /W in the border style dictionary is
% expressed in points (an absolute unit), so compensate here for any
% scaling of the PostScript user space done due to /UserUnit.
% Scaling due to -dPDFFitPage is not undone, to keep the correct border width
% compared to the size of the surrounding marks.
//systemdict /NoUserUnit .knownget not { //false } if not
//systemdict /PDFFitPage known not and { % UserUnit is ignored if -dPDFFitPage
Page /UserUnit knownoget { div } if
} if
{} 2 index /S knownoget {
/D eq { 2 index /D knownoget not { {3} } if exch pop } if
} if
3 index /CA knownoget {.setopacityalpha} if
3 -1 roll pop 2 index annotsetcolor {0 setdash setlinewidth stroke} if
} {
dup 2 get
exch dup length 3 gt { 3 get } { pop {} } ifelse
3 index /CA knownoget {.setopacityalpha} if
2 index annotsetcolor {0 setdash setlinewidth stroke} if
} ifelse
} {
3 index /CA knownoget {.setopacityalpha} if
1 {} 2 index annotsetcolor {0 setdash setlinewidth stroke} if
} ifelse
pop
grestore
} bind executeonly def
/fillborderpath { % <annot> fillborderpath -
gsave
dup /ca knownoget {.setopacityalpha} if
annotsetinteriorcolor
{fill} if
grestore
}bind executeonly def
%
% The PDF annotation F (flags) integer is bit encoded.
% Bit 1 (LSB) Invisible: 1 --> Do not display if no handler.
% Note: We have no handlers but we ignore this bit.
% Bit 2 Hidden: 1 --> Do not display. We will not display if this bit is set.
% Bit 3 Print: 1 --> Display if printing. We will display if this bit set
% (and not hidden) and Printed is true
% Bit 4 NoZoom: 1 --> Do not zoom annotation even if image is zoomed.
% Bit 5 NoRotate: 1 --> Do not rotate annotation even if image is rotated.
% Bit 6 NoView: 0 --> Display if this is a 'viewer'. We will display
% if this bit is not set (and not hidden) and Printed is false
% Bit 7 Read Only - 1 --> No interaction. We ignore this bit
%
% AR8 and AR9 print 3D annotations even if Print flag is off. Bug 691486.
%
/annotvisible { % <annot> annotvisible <visible>
dup /Subtype knownoget { /3D eq } { //false } ifelse % 3D annot
exch /F knownoget not { 0 } if % Get flag value
dup 2 and 0 eq {
/Printed load {
4 and 4 eq or % Printed or 3D
} {
32 and 0 eq exch pop % not NoView
} ifelse
} {
pop pop //false % Hidden
} ifelse
} bind executeonly def
/set_bc_color <<
1 { 0 get oforce setgray } bind executeonly
3 { { oforce } forall setrgbcolor } bind executeonly
4 { { oforce } forall setcmykcolor } bind executeonly
>> readonly def
% Get an inherited attribute from a node through /Parent and /ParentField
% links. The latter is set at start-up to access parents of annotations and
% defaults at AcroForm.
/fget % <field> <key> fget <value> -true-
{ % <field> <key> fget -false-
{
2 copy knownoget {
exch pop exch pop //true exit
} {
exch
dup /Parent knownoget {
exch pop exch
} {
/ParentField knownoget {
exch
} {
pop //false exit
} ifelse
} ifelse
} ifelse
} loop
} bind executeonly def
% <annot> foo <annot>
/make_tx_da {
dup /AP << /N 10 dict dup cvx begin >> put
/Subtype /Form def
/BBox [ 0 0 4 index /Rect oget { oforce } forall 3 -1 roll sub abs 3 1 roll sub abs exch ] def
/Resources 1 index /DR fget not { 0 dict } if def
/File 1 index /V fget not { () } if length
2 index /DA fget not { () } if length add
500 add 65535 .min string dup 3 1 roll def
/NullEncode filter % <annot> file
dup (BT ) writestring
1 index /DA fget not {
1 index /V fget {
<EFBBBF> anchorsearch {
pop /Helvetica findfont 12 scalefont setfont
} {
<FEFF> anchorsearch {
pop pop /FallBackFont /Identity-UTF16-H [/CIDFallBack] composefont 12 scalefont setfont
} {
pop /Helvetica findfont 12 scalefont setfont
}ifelse
}ifelse
} if
()
}if
[ exch
{ token {
dup /Tf eq {
2 index 0 eq {
/BBox load 3 get
0.75 mul % empirical constant
4 -1 roll pop 3 1 roll
} if
} if
exch
} {
exit
} ifelse
} loop
]
{ 1 index exch write== } forall
dup 2 index /MaxLen fget not { 0 } if write=
dup 2 index /V fget not { () } if write==
dup 2 index /Ff fget not { 0 } if write=
dup 2 index /Q fget not { 0 } if write=
dup (Tform ET) write=
dup .fileposition /Length exch def
/File File 0 Length getinterval def
closefile % <annot>
end
} bind executeonly def
/can-regenerate-ap { % <annot> -> <bool>
//false exch
NeedAppearances {
dup /FT fget {
dup /Tx eq {
pop
dup /V oknown {
pop not 1
} if
} {
/Ch eq {
dup /V oknown {
pop not 1
} if
} if
} ifelse
} if
} if
pop
} bind executeonly def
/drawwidget { % <scalefactor_x> <scalefactor_y> <annot> drawwidget -
%% This code checks to see if we can geenrate an appearance stream for the
%% given widget, and if we can it ignores the given Appearance stream, so that
%% we generate one instead. This seems wrong to me, if we've been given an
%% appearance stream we should use it, no synthesize something else. Several
%% files in our regression test suite render 'incorrectly' when compared to
%% Acrobat with this removed, clearly Acrobat always ignores appearances. However
%% several other files are rendered better when we *don't* ignore the Appearance
%% So on balance I'm choosing to honour the appearance.
%%
% dup /UpdatedAP known not {
% dup can-regenerate-ap {
% dup /AP undef
% } if
% } if
dup /AP knownoget {
dup /N known not {
( **** Error: Appearance dictionary (AP) lacks the mandatory normal (N) appearance.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} if
//false
[/N /R /D] {
% stack: scalex scaley annot appearance false key
2 index exch knownogetdict {
exch not exit
} if
} forall
% stack: scalex scaley annot appearance value true
% stack: scalex scaley annot appearance false
dup {
pop exch pop
% Acrobat Distiller produces files in which this Form
% XObject lacks Type and Subtype keys. This is illegal,
% but Acrobat Reader accepts it. The only way we can
% tell whether this is a Form or a set of sub-appearances
% is by testing for the stream Length or File key.
% If the stream lacks Length key, try File key.
dup /Length knownoget { type /integertype eq } { //false } ifelse
1 index /File knownoget { type /filetype eq or } if {
% If this is a form then simply use it
//true
} {
1 index /AS knownoget not {
% If we do not have AS then use any appearance
{ exch pop oforce exit } forall //true
} {
% Stack: annot Ndict AS
% Get the specified appearance. If no appearance, then
% display nothing - set stack = false.
knownoget
} ifelse
} ifelse
} {
exch pop % discard useless AP dictionary
} ifelse
% Stack: scalex scaley annot appearance true
% Stack: scalex scaley annot false
{
dup type /dicttype eq {
% Draw appearance
% Initialize graphic following "7.4.4 Appearance Streams"
q graphicsbeginpage textbeginpage
1 index annotrect pop pop translate
3 index 3 index scale % Apply scale factors
dup /BBox knownoget {
1 index /Matrix knownoget not { {1 0 0 1 0 0} } if
.bbox_transform pop pop
% Compensate for non-zero origin of BBox
neg exch neg exch translate
} if
DoForm Q
} {
( **** Error: Annotation's appearance is not a dictionary.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
} {
dup /MK knownoget { % mk
dup /BG knownoget { % mk bg
dup length % mk bg len
//set_bc_color exch .knownget {
gsave
exec
3 index 3 index scale
1 index annotrect rectfill
grestore
} {
pop
} ifelse
} if
dup /BC knownoget {
dup length
//set_bc_color exch .knownget {
gsave
exec
1 setlinewidth
3 index 3 index scale
1 index annotrect rectstroke
grestore
} {
pop
} ifelse
} if
pop
} if
dup can-regenerate-ap {
make_tx_da
dup /UpdatedAP //true put
3 copy drawwidget
} if
} ifelse
pop pop pop
} bind executeonly def
currentdict /set_bc_color undef
% For annotation object we have to determine the size of the output rectangle
% and the size of the BBox for the form XObject. From these we calculate
% a scale factors for drawing it.
/calc_annot_scale { % <annot> calc_annot_scale <x_scale> <y_scale>
dup /Rect knownoget {
pop dup annotrect 4 2 roll pop pop % get width height size in user space
2 index /AP knownoget {
/N knownogetdict { % <<Annot>> x y <<N>>
dup 4 index /AS knownoget {
knownoget {
exch pop
} if
} {
pop
} ifelse
dup /Matrix knownoget not { {1 0 0 1 0 0} } if
exch /BBox knownoget { % <<>> x y {matrix} [box]
exch .bbox_transform % <<>> x y x0 y0 x1 y1
3 -1 roll sub % <<>> x y x0 x1 y1-y0
3 1 roll exch sub % <<>> x y y1-y0 x1-x0
2 copy mul 0 eq {
( **** Error: /BBox has zero width or height, which is not allowed.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop pop pop pop 1 1 % zero size -- revert to unity scaling
} {
3 1 roll div % <<>> x x1-x0 y/(y1-y0)
3 1 roll div % <<>> y/(y1-y0) x/(x1-x0)
exch % <<>> x/(x1-x0) y/(y1-y0)
} ifelse
} {
pop pop pop 1 1 % default to unity scaling
} ifelse % if we have /BBox
} {
pop pop 1 1
} ifelse % if we have /N
} {
pop pop 1 1
} ifelse % if we have /AP
3 -1 roll pop
} {
( **** Error: /Annot dict is missing required /Rect entry.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop 1 1
} ifelse
} bind executeonly def
% Draw an annotation.
/drawannottypes 20 dict begin
/startannottransparency {
PDFusingtransparency {
dup /BM known {
dup /BM get
<< exch /BM exch >>
} {
<< >>
}ifelse
%% We should be able to use the Rect to create the group, but it seems
%% Acrobat ignores this, or at least doesn't clip the annotation to it :-(
% 1 index /Rect known {
% 1 index annotrect exch % llx lly h w
% 3 index add exch % x y urx h
% 2 index add
% }{
clippath pathbbox newpath
% } ifelse
.begintransparencygroup
} if
}bind executeonly def
/endannottransparency {
PDFusingtransparency {
.endtransparencygroup
} if
}bind executeonly def
/ValidateAP {
dup /AP oknown {
dup /AP oget
/N oknown not {
//false
} {
//true
} ifelse
} {
//false
}ifelse
} bind executeonly def
% x0 y0 x1 y1 x2 y2 x3 y3 -> x0 y0 x1-x0 y1-y0 x2-x0 y2-y0
/quadpoints2basis {
8 { oforce 8 1 roll } repeat
% The text is oriented with respect to the vertex with the smallest
% y value (or the leftmost of those, if there are two such vertices)
% (x0, y0) and the next vertex in a counterclockwise direction
% (x1, y1), regardless of whether these are the first two points in
% the QuadPoints array.
2 {
2 index 1 index eq {
3 index 2 index gt {
4 2 roll
} if
} {
2 index 1 index gt {
4 2 roll
} if
} ifelse
8 4 roll
} repeat
6 index 3 index gt {
8 4 roll
} if
% ^
% |
% * (x2,y2) * (x3,y3)
% |
% |
% *------------*->
% (x0,y0) (x1,y1)
pop pop % x0 y0 x1 y1 x2 y2
4 index sub exch % x0 y0 x1 y1 y2-y0 x2
5 index sub exch % x0 y0 x1 y1 x2-x0 y2-y0
4 2 roll
4 index sub exch % x0 y0 x2-x0 y2-y0 y1-y0 x1
5 index sub exch % x0 y0 x2-x0 y2-y0 x1-x0 y1-y0
4 2 roll % x0 y0 x1-x0 y1-y0 x2-x0 y2-y0
} bind executeonly def
/Square {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
dup
annotsetinteriorcolor
{
gsave
dup /ca knownoget {.setopacityalpha} if
dup annotrect rectfill
grestore
dup /CA knownoget {.setopacityalpha} if
drawborder
//false
}{
pop
} ifelse
//endannottransparency exec
grestore
}ifelse
} bind executeonly def
%% Width Height drawellipse -
/drawellipse {
%% Don Lancaster's code for drawing an ellipse
0.55228475 0.00045 sub % improved magic value
3 1 roll % magic width height
2 div exch 2 div % magic y-radius x-radius
dup 3 index mul % magic y-radius x-radius x-magic
2 index % magic y-radius x-radius x-magic y-radius
5 -1 roll mul % magic y-radius x-radius x-magic y-magic
2 index neg 0 moveto % xrad neg 0 moveto
2 index neg 1 index 3 index neg 6 index 0 8 index curveto % xrad neg ymag xmag neg yrad 0 yrad curveto
1 index 4 index 4 index 3 index 1 index 0 curveto % xmag yrad xrad ymag xrad 0 curveto
2 index 1 index neg 3 index 6 index neg 0 1 index curveto % xrad ymag neg xmag yrad neg 0 yrad neg curveto
% Stack: yrad xrad xmag ymag
exch neg 4 1 roll 3 -1 roll neg 3 1 roll exch neg exch
neg 1 index 0 curveto % xmag neg yrad neg xrad neg ymag neg 0 curveto
}bind executeonly def
/Circle {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
dup annotrect 4 2 roll exch 3 index 2 div add exch 2 index 2 div add
translate //drawellipse exec
dup
fillborderpath
strokeborderpath
//endannottransparency exec
grestore
//false
} ifelse
} bind executeonly def
/Polygon {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
dup /Vertices knownoget {
dup length 2 div 1 sub cvi 0 1 3 -1 roll
{
2 mul dup
2 index exch 2 getinterval aload pop
3 -1 roll 0 eq {
moveto
}{
lineto
} ifelse
}
for
pop
closepath
//true
} {
( **** Error: Invalid Vertices for Polygon, annotation has not been drawn.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
//false
} ifelse
1 index annotsetinteriorcolor {
//true
}{
//false
}ifelse
and
{
gsave
dup /ca knownoget {.setopacityalpha} if
fill
grestore
dup /CA knownoget {.setopacityalpha} if
strokeborderpath
} if
//endannottransparency exec
//false
grestore
} ifelse
} bind executeonly def
/LineEnd_dict 10 dict begin
%% Stack contains <annot>
%% CTM rotated so line segment is vertical, translated so line endpoint at 0,0
/Square {
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
dup 2.5 mul
gsave
dup neg 1 index neg exch moveto
dup neg 1 index lineto
dup 1 index exch lineto
dup neg lineto
closepath
1 index /CA knownoget {.setopacityalpha} if
1 index fillborderpath
grestore
3 mul
dup neg 1 index neg exch moveto
dup neg 1 index lineto
dup 1 index exch lineto
dup neg lineto
closepath
strokeborderpath
} bind executeonly def
/Circle {
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
dup
gsave
2.5 mul dup
0 moveto
0 0 3 -1 roll 0 360 arc
1 index /CA knownoget {.setopacityalpha} if
1 index fillborderpath
grestore
3 mul dup
0 moveto
0 0 3 -1 roll 0 360 arc
strokeborderpath
} bind executeonly def
/Diamond {
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
dup 2.5 mul
gsave
dup neg 0 exch moveto
dup neg 0 lineto
dup 0 exch lineto
0 lineto
closepath
1 index /CA knownoget {.setopacityalpha} if
1 index fillborderpath
grestore
3 mul
dup neg 0 exch moveto
dup neg 0 lineto
dup 0 exch lineto
0 lineto
closepath
strokeborderpath
} bind executeonly def
/OpenArrow {
dup
gsave
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
0 setlinejoin
dup 6 mul neg 1 index 4 mul neg moveto dup 1.2 div neg 0 lineto
dup 6 mul neg exch 4 mul lineto
strokeborderpath
grestore
} bind executeonly def
/ClosedArrow {
dup
gsave
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
dup
gsave
0 setlinejoin
dup 6 mul neg 1 index 4 mul neg moveto dup 1.2 div neg 0 lineto
dup 6 mul neg exch 4 mul lineto closepath
1 index strokeborderpath
grestore
dup 1.3 mul neg 0 translate
dup 2 div sub
dup 8.4 mul neg 1 index 5.9 mul neg moveto dup 1.2 div neg 0 lineto
dup 8.4 mul neg exch 5.9 mul lineto closepath
dup /CA knownoget {.setopacityalpha} if
fillborderpath
grestore
} bind executeonly def
/None {} bind executeonly def
/Butt {
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
3 mul dup neg 0 exch moveto 0 exch lineto
strokeborderpath
} bind executeonly def
/ROpenArrow {
gsave
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
180 rotate
0 setlinejoin
dup 6 mul neg 1 index 4 mul neg moveto dup 1.2 div neg 0 lineto
dup 6 mul neg exch 4 mul lineto
strokeborderpath
grestore
} bind executeonly def
/RClosedArrow {
gsave
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
180 rotate
dup
gsave
0 setlinejoin
dup 6 mul neg 1 index 4 mul neg moveto dup 1.2 div neg 0 lineto
dup 6 mul neg exch 4 mul lineto closepath
1 index strokeborderpath
grestore
dup 1.3 mul neg 0 translate
dup 2 div sub
dup 8.4 mul neg 1 index 5.9 mul neg moveto dup 1.2 div neg 0 lineto
dup 8.4 mul neg exch 5.9 mul lineto closepath
dup /CA knownoget {.setopacityalpha} if
fillborderpath
grestore
} bind executeonly def
/Slash {
gsave
dup
/BS knownoget {
/W knownoget {
}{
1
}ifelse
}{
1
}ifelse
330 rotate
3 mul dup neg 0 exch moveto 0 exch lineto
strokeborderpath
grestore
} bind executeonly def
currentdict end readonly def
/Line {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
dup /L knownoget {
1 index /LE knownoget {
gsave
1 index aload pop % x1 y1 x2 y2
3 -1 roll sub % x1 x2 dy
3 1 roll exch sub % dy dx
2 copy translate
atan
rotate
dup 0 get dup //LineEnd_dict exch known not {pop /None} if //LineEnd_dict exch get 3 index exch exec
grestore
gsave
1 index aload pop % x1 y1 x2 y2
3 -1 roll sub % x1 x2 dy
3 1 roll exch sub % dy dx
2 copy translate
atan 180 add
rotate
1 get dup //LineEnd_dict exch known not {pop /None} if //LineEnd_dict exch get 3 index exch exec
grestore
}if
aload pop 4 2 roll
moveto lineto
strokeborderpath
}{
( **** Error: Invalid L array for Line, annotation has not been drawn.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
pop
} ifelse
//endannottransparency exec
//false
grestore
} ifelse
} bind executeonly def
/PolyLine {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
dup /Vertices knownoget {
1 index /LE knownoget {
gsave
1 index 0 4 getinterval aload pop
4 2 roll
2 copy translate 4 2 roll
3 -1 roll sub % x1 x2 dy
3 1 roll exch sub % dy dx
atan
rotate
dup 0 get dup //LineEnd_dict exch known not {pop /None} if //LineEnd_dict exch get 3 index exch exec
grestore
gsave
1 index dup length 4 sub 4 getinterval aload pop
2 copy translate
3 -1 roll sub % x1 x2 dy
3 1 roll exch sub % dy dx
atan
rotate
1 get dup //LineEnd_dict exch known not {pop /None} if //LineEnd_dict exch get 3 index exch exec
grestore
} if
dup length 2 div 1 sub cvi 0 1 3 -1 roll
{
2 mul dup
2 index exch 2 getinterval aload pop
3 -1 roll 0 eq {
moveto
}{
lineto
} ifelse
}
for
pop
//true
} {
( **** Error: Invalid Vertices for Polygon, annotation has not been drawn.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
//false
} ifelse
{
strokeborderpath
} if
//endannottransparency exec
//false
grestore
} ifelse
} bind executeonly def
/Link { % <annot> -> <false>
//startannottransparency exec
dup drawborder dup calc_annot_scale
2 copy mul 0 ne
{3 -1 roll drawwidget //false}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}ifelse
//endannottransparency exec
} bind executeonly def
/Ink { % <annot> -> <annot> <true>
% <annot> -> <false>
//ValidateAP exec
{
//true
} {
//startannottransparency exec
1 setlinewidth
1 setlinecap
1 setlinejoin
dup annotsetcolor {
dup calc_annot_scale
2 copy mul 0 ne
{
scale
dup /InkList knownoget {
{ oforce
mark exch { oforce } forall
.pdfinkpath
stroke
} forall
pop
} {
/Path knownoget {
oforce
dup length 1 sub 0 1 3 -1 roll {
dup 0 eq {
1 index exch get aload pop moveto
} {
1 index exch get dup length 2 eq {
aload pop lineto
}{
aload pop curveto
} ifelse
}ifelse
} for
pop dup
strokeborderpath
} if
}ifelse
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
} if
//endannottransparency exec
//false
} ifelse
} bind executeonly def
/Underline {
//ValidateAP exec
{
//true
} {
0 setlinecap
dup annotsetcolor {
dup calc_annot_scale
2 copy mul 0 ne
{
scale
/QuadPoints knownoget {
aload length 8 idiv {
//quadpoints2basis exec
% Acrobat draws the line at 1/7 of the box width from the bottom
% of the box and 1/16 thick of the box width. /Rect is ignored.
2 copy dup mul exch dup mul add sqrt 16 div setlinewidth
7 div 4 index add exch % x0 y0 x1-x0 y1-y0 (y2-y0)/7+y0 x2-x0
7 div 5 index add exch % x0 y0 x1-x0 y1-y0 (x2-x0)/7+x0 (y2-y0)/7+y0
2 copy moveto
2 index add exch
3 index add exch lineto % x0 y0 x1-x0 y1-y0
pop pop pop pop
stroke
} repeat
} if
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
} if
//false
} ifelse
} bind executeonly def
/StrikeOut {
//ValidateAP exec
{
//true
} {
0 setlinecap
dup annotsetcolor {
dup calc_annot_scale
2 copy mul 0 ne
{
scale
/QuadPoints knownoget {
aload length 8 idiv {
//quadpoints2basis exec
% Acrobat draws the line at 3/7 of the box width from the bottom
% of the box and 1/16 thick of the box width. /Rect is ignored.
2 copy dup mul exch dup mul add sqrt 16 div setlinewidth
0.4285714 mul 4 index add exch % x0 y0 x1-x0 y1-y0 (y2-y0)*3/7+y0 x2-x0
0.4285714 mul 5 index add exch % x0 y0 x1-x0 y1-y0 (x2-x0)*3/7+x0 (y2-y0)*3/7+y0
2 copy moveto
2 index add exch
3 index add exch lineto % x0 y0 x1-x0 y1-y0
pop pop pop pop
stroke
} repeat
} if
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
} if
//false
} ifelse
} bind executeonly def
% Connect 2 points with an arc that has max distance from the line
% segment to the ark equal 1/4 of the radius.
/highlight-arc { % x1 y1 x0 y0 -> -
4 2 roll % x0 y0 x1 y1
dup 3 index add 2 div % x0 y0 x1 y1 (y1+y0)/2
2 index 5 index sub .9375 mul sub % x0 y0 x1 y1 (y1+y0)/2-15/16*dx=yc
4 index 3 index add 2 div % x0 y0 x1 y1 yc (x0+x1)/2
2 index 5 index sub .9375 mul add % x0 y0 x1 y1 yc xc
exch % x0 y0 x1 y1 xc yc
dup 3 index exch sub % x0 y0 x1 y1 xc yc y1-yc
4 index 3 index sub % x0 y0 x1 y1 xc yc y1-yc x1-xc
dup dup mul 2 index dup mul add sqrt %x0 y0 x1 y1 xc yc y1-yc x1-xc r
3 1 roll atan % x0 y0 x1 y1 xc yc r a1
6 index 3 index sub % x0 y0 x1 y1 xc yc r a1 y0-yc
8 index 5 index sub % x0 y0 x1 y1 xc yc r a1 y0-yc x0-xc
atan % x0 y0 x1 y1 xc yc r a1 a2
exch arcn % x0 y0 x1 y1
pop pop pop pop
} bind executeonly def
/emptydict 0 dict readonly def
/Highlight {
//ValidateAP exec
{
//true
} {
0 setlinecap
dup annotsetcolor {
/QuadPoints knownoget {
aload length 8 idiv {
6 -2 roll
2 copy moveto
//highlight-arc exec
2 copy lineto
//highlight-arc exec
closepath
} repeat
PDFusingtransparency {
//emptydict
pathbbox 2 index add exch 3 index add exch .begintransparencygroup
/Multiply .setblendmode
fill
.endtransparencygroup
} { % for -dNOTRANSPARENCY
stroke newpath
} ifelse
} if
} if
//false
} ifelse
} bind executeonly def
currentdict /emptydict undef
currentdict /highlight-arc undef
/Squiggly {
//ValidateAP exec
{
//true
} {
//startannottransparency exec
dup annotsetcolor {
dup calc_annot_scale
2 copy mul 0 ne
{
scale
/QuadPoints knownoget {
aload length 8 idiv {
gsave
8 copy moveto lineto
4 2 roll lineto lineto closepath clip newpath
//quadpoints2basis exec
6 -2 roll translate % adjust for x0 y0 % x1-x0 y1-y0 x2-x0 y2-y0
1 index 56 div 1 index 56 div translate % zigzag box is 1/56 up
1 index 72 div 1 index 72 div translate % the line in the box is 1/72 up
2 copy dup mul exch dup mul add sqrt % x1-x0 y1-y0 x2-x0 y2-y0 |p2|
4 index dup mul 4 index dup mul add sqrt % x1-x0 y1-y0 x2-x0 y2-y0 |p2| |p1|
dup 0 gt 2 index 0 gt and {
div % x1-x0 y1-y0 x2-x0 y2-y0 |p2|/|p1|=p12
dup 1 exch div 4 mul 1 add cvi exch 6 2 roll % cnt p12 x1-x0 y1-y0 x2-x0 y2-y0
4 2 roll % cnt p12 x2-x0 y2-y0 x1-x0 y1-y0
4 index mul exch 4 index mul exch % cnt p12 x2-x0 y2-y0 (x1-x0)*p12 (y1-y0)*p12
4 2 roll 0 0 6 array astore concat % cnt p12
1 40 div 1 72 div scale
pop % cnt
0 0 moveto
1 setlinecap
1 setlinejoin
1 setlinewidth
{
5 10 lineto
10 0 lineto
10 0 translate
} repeat
stroke
} {
6 { pop } repeat
} ifelse
grestore
} repeat
} if
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
} if
//endannottransparency exec
//false
} ifelse
} bind executeonly def
/Text {
//ValidateAP exec
{
//true
} {
//startannottransparency exec
dup calc_annot_scale
2 copy mul 0 ne
{
scale
annotrect 4 2 roll translate
exch pop
% Draw a page icon
0.5 exch 18.5 sub translate
1 setlinewidth
0.75 setgray
0.5 -1 moveto 10 -1 lineto 15 4 lineto 15 17.5 lineto stroke
0 0 moveto
9 0 lineto
14 5 lineto
14 18 lineto
0 18 lineto closepath
gsave .5 setgray fill grestore 0 setgray stroke
3 8 moveto 7.5 8 lineto
3 11 moveto 10 11 lineto
3 14 moveto 10 14 lineto
9 0 moveto 9 5 lineto 14 5 lineto
stroke
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
//endannottransparency exec
//false
} ifelse
} bind executeonly def
/FreeText {
//ValidateAP exec
{
//true
}
%% We either have no appearance, or its invalid, make one up.
{
gsave
//startannottransparency exec
dup annotrect rectclip
dup /CA knownoget {
.setopacityalpha
} if
dup /ca knownoget {
.setopacityalpha
} if
dup /C knownoget {
dup length 4 eq {
aload pop setcmykcolor //true
}{
dup length 3 eq {
aload pop setrgbcolor //true
}{
dup length 1 eq {
aload pop setgray //true
} {
dup length 0 eq {
pop
//false
}{
( **** Error: invalid color specified for FreeText annotation /C entry)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
//false
} ifelse
} ifelse
} ifelse
} ifelse
}{
//false
} ifelse
{dup annotrect
%% Somewhat horrifyingly, rectfill maps directly to the device fill_rectangle
%% method, which bypasses transparency (!!) So we construct the rectangle,
%% and fill it, manually instead....
gsave 4 2 roll moveto 1 index 0 rlineto
0 exch rlineto neg 0 rlineto closepath fill grestore
} if
%% get and process the default appearance string, if we don't have one, use a default
/DA_Action_Dict
<<
/Tf {exch dup /Helv eq {pop /Helvetica findfont exch scalefont setfont}{findfont exch scalefont setfont}ifelse}
/r {aload pop setrgbcolor} % Can't find this actually defined anywhere, but Acrobat seems to honour it :-(
/rg {setrgbcolor}
/RG {setrgbcolor}
/G {setgray}
/g {setgray}
/k {setcmykcolor}
/K {setcmykcolor}
>> def
dup /DA knownoget {
length string /tempstr exch def
dup /DA get tempstr copy pop
{
%% This is kind of ugly, we use token to process the string
%% and process each token separately.
tempstr
token {
exch /tempstr exch def
%% If the token is a name
%%
dup type /nametype eq {
%% Is it a name we want to take actionon
dup DA_Action_Dict exch known {
DA_Action_Dict exch get exec
}{
%% Its not a name we know, is it executable
dup xcheck {exec} if
} ifelse
}{
%% Not a name, just make it executable and execute it
cvx exec
}ifelse
}{
exit
}ifelse
} loop
} {
0 setgray
/Helvetica findfont 12 scalefont setfont
}ifelse
%% draw the border, if we don't have a border style dictionary, draw a default one.
dup /BS knownoget {
pop dup drawborder
}{
newpath
0 setgray 1 setlinewidth
dup annotrect 4 -1 roll 1 add 4 -1 roll 1 add 4 -1 roll 2 sub 4 -1 roll 2 sub
4 2 roll moveto
currentpoint exch 3 index add exch lineto
currentpoint 2 index add lineto
exch currentpoint 3 1 roll exch sub exch lineto
currentpoint 3 -1 roll sub lineto stroke
}ifelse
%% Start the current point at the top left of the annotation Rect
%%
dup annotrect 4 -1 roll 2 add 4 -1 roll 2 add 4 -1 roll 4 sub 4 -1 roll 4 sub
3 -1 roll add 2 index exch moveto 1 index add
%% Get the Contents string, if we don't have one, we're done
%%
2 index /Contents knownoget {
PDFusingtransparency {
.begintransparencytextgroup
} if
%% Check for UTF16-BE, we probably don't work properly with this yet.
%%
dup 0 get 254 eq 1 index 1 get 255 eq and
{
/FallBackFont /Identity-UTF16-H [/CIDFallBack] composefont 12 scalefont setfont
dup length 2 div 1 sub 0 1 3 -1 roll {
%% llx urx (string) index
1 index exch 2 mul 2 getinterval %% llx urx (string) (substring)
dup stringwidth pop currentpoint pop add 3 index gt {
currentpoint exch pop 4 index exch 12 sub moveto
} if
show
} for
pop
}
{
%% Heuristic to determine the height (ascender to descender) of the text
%% for when we move down a line.
gsave
/..TextHeight (Hy) //false charpath pathbbox exch pop exch sub exch pop def
grestore
%% and use it immediatley to start the text one line down
%%
currentpoint ..TextHeight sub moveto
%% Now we process each character code in the string. If we find
%% a /r/ or /n then we drop a line. If the character would end up
%% outside the Annot Rect, then we drop a line before showing it.
%%
dup length 1 sub 0 1 3 -1 roll {
%% llx urx (string) index
1 index exch get %% llx urx (string) int
dup 10 eq 1 index 13 eq or {
pop
currentpoint exch pop 3 index exch ..TextHeight sub moveto
} {
1 string dup 0 4 -1 roll
put dup %% llx urx (string) (int) (int)
stringwidth pop currentpoint pop add 3 index gt {
currentpoint exch pop 4 index exch ..TextHeight sub moveto
} if
show
} ifelse
} for
pop
}ifelse
PDFusingtransparency {
.endtransparencytextgroup
} if
} if
pop pop
//endannottransparency exec
//false
grestore
} ifelse
} bind executeonly def
/frame {
{ 255 div } forall setrgbcolor
-95 -25 translate
2 190 atan rotate
{
6 0 moveto
190 0 190 6 6 arct
190 47 184 47 6 arct
0 47 0 41 6 arct
0 0 6 0 6 arct
closepath
10 4 moveto
185 4 185 9 5 arct
185 43 180 43 5 arct
5 43 5 38 5 arct
5 4 9 4 5 arct
closepath
eofill
}
gsave 1 -1 translate 0.75 setgray dup exec grestore
exec
} bind executeonly def
% (text) y h -> -
/text {
PDFusingtransparency {
.begintransparencytextgroup
} if
/Times-Bold findfont exch scalefont setfont % (text) y
gsave
0 0 moveto
1 index //false charpath flattenpath pathbbox
pop exch pop sub 2 div
grestore
95 add exch moveto
gsave 1 -1 rmoveto 0.75 setgray dup show grestore
show
PDFusingtransparency {
.endtransparencytextgroup
} if
} bind executeonly def
/red <ef4023> readonly def
/green <3fae49> readonly def
/blue <0072bc> readonly def
/stamp_dict 14 dict begin
/Approved {
//green //frame exec
(APPROVED) 13 30 //text exec
} bind executeonly def
/AsIs {
//red //frame exec
(AS IS) 13 30 //text exec
} bind executeonly def
/Confidential {
//red //frame exec
(CONFIDENTIAL) 17 20 //text exec
} bind executeonly def
/Departmental {
//blue //frame exec
(DEPARTMENTAL) 17 20 //text exec
} bind executeonly def
/Draft {
//red //frame exec
(DRAFT) 13 30 //text exec
} bind executeonly def
/Experimental {
//blue //frame exec
(EXPERIMENTAL) 17 20 //text exec
} bind executeonly def
/Expired {
//red //frame exec
(EXPIRED) 13 30 //text exec
} bind executeonly def
/Final {
//red //frame exec
(FINAL) 13 30 //text exec
} bind executeonly def
/ForComment {
//green //frame exec
(FOR COMMENT) 17 20 //text exec
} bind executeonly def
/ForPublicRelease {
//green //frame exec
(FOR PUBLIC) 26 18 //text exec
(RELEASE) 8.5 18 //text exec
} bind executeonly def
/NotApproved {
//red //frame exec
(NOT APPROVED) 17 20 //text exec
} bdef
/NotForPublicRelease {
//red //frame exec
(NOT FOR) 26 18 //text exec
(PUBLIC RELEASE) 8.5 18 //text exec
} bind executeonly def
/Sold {
//blue //frame exec
(SOLD) 13 30 //text exec
} bind executeonly def
/TopSecret {
//red //frame exec
(TOP SECRET) 14 26 //text exec
} bind executeonly def
currentdict end readonly def
{/text/frame/red/green/blue} {currentdict exch undef} forall
/Stamp {
//ValidateAP exec
{
//true
} {
//startannottransparency exec
dup calc_annot_scale
2 copy mul 0 ne
{
scale
% translate to the center of Rect
dup annotrect
4 2 roll % dx dy x0 y0
2 index 2 div add exch
3 index 2 div add exch translate % dx dy
50 div exch 190 div .min dup 0.0 eq {pop 1.0} if dup scale
/Name knownoget not { /Draft } if
//stamp_dict 1 index known not { exch pop /Draft exch } if
//stamp_dict exch get exec
}
{
pop pop
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
ifelse
//endannottransparency exec
//false
} ifelse
} bind executeonly def
/Popup {
dup /Open oknown {
dup /Open get {
//ValidateAP exec
{
//true
} {
gsave
//startannottransparency exec
newpath
0.05 setlinewidth
dup /Parent .knownget {
oforce
} {
dup /P .knownget {
oforce
} {
dup
} ifelse
} ifelse
/C .knownget {
aload pop
}{
1 1 0
}ifelse
setrgbcolor
dup /Rect get
dup aload pop
2 index sub
exch 3 index sub exch
4 copy
gsave 1 setgray rectfill grestore
gsave 0 setgray rectstroke grestore
1 index /Parent .knownget {
oforce
}{
1 index /P .knownget {
oforce
}{
1 index
} ifelse
}ifelse
dup
/Contents .knownget {
gsave
PDFusingtransparency {
.begintransparencytextgroup
} if
0 setgray
/Helvetica findfont 9 scalefont setfont
2 index aload pop 3 1 roll pop pop 30 sub exch 5 add exch
moveto show
PDFusingtransparency {
.endtransparencytextgroup
} if
grestore
} if
exch
dup aload pop 3 -1 roll pop exch 2 index sub -15
4 copy rectfill
0 setgray rectstroke
exch
/T .knownget {
gsave
PDFusingtransparency {
.begintransparencytextgroup
} if
0 setgray
/Helvetica findfont 9 scalefont setfont
dup stringwidth pop
2 index aload pop pop exch pop exch sub
exch sub 2 div 2 index aload pop 3 1 roll pop pop 11 sub 3 1 roll add exch moveto
show
PDFusingtransparency {
.endtransparencytextgroup
} if
grestore
} if
grestore
//endannottransparency exec
//false
} ifelse
} {
pop //false
}ifelse
} {
pop //false
}ifelse
} bind executeonly def
/Redact {
%% Redact annotations are part of a process, a Redact annotation is only present
%% until the content is removed, before that the content should be present and
%% I beleive we should print it. So take no action for Redact annotations if they
%% have no appearance.
//ValidateAP exec
{
//true
} {
//false
} ifelse
} bind executeonly def
currentdict /startannottransparency undef
currentdict /endannottransparency undef
currentdict /ValidateAP undef
currentdict /quadpoints2basis undef
currentdict /drawellipse undef
currentdict end readonly def
/.PDFDrawAnnotType?
{
//false exch
/ShowAnnotTypes where
{
/ShowAnnotTypes get
{
dup /* eq exch 2 index eq or
{
pop //true exch
exit
} if
} forall
pop
}
{pop pop //true}
ifelse
} bind executeonly def
/drawannot { % <annot> drawannot -
dup annotvisible {
gsave
dup dup /Subtype knownoget {
dup //.PDFDrawAnnotType? exec
{
//drawannottypes exch .knownget { exec } { //true } ifelse
{
dup calc_annot_scale 2 copy mul 0 ne
{
3 -1 roll drawwidget
}
{
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}ifelse % Draw rejected annots as widgets
} if % type known
}
{
pop
}ifelse
} {
pop
( **** Error: Ignoring /Annot dict without required /Subtype entry.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
grestore
} if pop % annotvisible
} bind executeonly def
currentdict /drawannottypes undef
% Draw an annotation.
/loadannot {
dup /AP .knownget { % <<Annot dict>> <<Appearance dictionary>> true | false
oforce
dup { % <<Annot dict>> <<Appearance dict>> /Key <</Key dict>>
oforce % <<Annot dict>> <<Appearance dict>> /Key <<resolved /Key dict>>
%%
%% Check to see if the apperance key has a simple stream or a dictionary of states
%%
dup /Subtype known % <<Annot dict>> <<Appearance dict>> /Key <<resolved /Key dict>> bool
{
%% Simple appearance stream
DoAppearance % <<Annot dict>> <<Appearance dict>> /Key
2 index % <<Annot dict>> <<Appearance dict>> /Key <<Annot dict>>
/AP << % <<Annot dict>> <<Appearance dict>> /Key <<Annot dict>> /AP <<
4 -1 roll MakeAppearanceName cvx cvn >> put % <<Annot dict>> <<Appearance dict>>
} {
%% dictionary of states <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>>
dup % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> <<appearance states dict>>
{ % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> /StateKey <<State dictionary>>
oforce % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> /StateKey <<resolved State dictionary>>
DoAppearance % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> /StateKey
1 index exch % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> <<appearance states dict>> /StateKey
MakeAppearanceName cvx cvn % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>> <<appearance states dict>> /StateKey {}
put % <<Annot dict>> <<Appearance dict>> /Key <<appearance states dict>>
} forall
put % <<Annot dict>> <<Appearance dict>> /Key
dup
}ifelse
} forall
pop % <<Annot dict>>
} if
%% Parent (or /P) references will be incorrect. Remove them
%% for now as they are optional.
dup /Popup known {dup /Popup undef} if
dup /IRT known {dup /IRT undef} if
dup /RT known {dup /RT undef} if
dup /P known {dup /P undef} if
dup /Parent known {dup /Parent undef} if
%% Resolve any indirect references. May need further work :-(
{
%% We know /AP doesn't need processing, we handled that above...
1 index /AP eq not {
dup {oforce} stopped not {exch pop} if
dup type /dicttype eq{
dup
{
dup {oforce} stopped not {exch pop} if
2 index 3 1 roll put
} forall
Removepdfobj#
} if
dup type /arraytype eq {
0 1 2 index length 1 sub{
dup 2 index exch get dup {oforce} stopped not {exch pop} if
2 index 3 1 roll put
} for
} if
} if
} forall
} bind executeonly def
/ApplyCTMToQuadPoints {
%% Nasty hackery here really. We need to undo the HWResolution scaling which
%% is done by pdfwrite. Default is 720 dpi, so 0.1. We also need to make
%% sure that any translation of the page (because its been rotated for example)
%% is also modified by the requisite amount. SO we ned to calculate a matrix
%% which does the scaling and concatenate it with the current matrix.
%% Do this inside a gsave/grestore pair to avoid side effects!
gsave
currentpagedevice /HWResolution get
aload pop exch 72 exch div exch 72 exch div
matrix 3 1 roll 2 index 3 3 -1 roll put
1 index 0 3 -1 roll put
matrix currentmatrix exch matrix concatmatrix
setmatrix
oforce
%% QuadPoints are given as 'n' sequences of 8 numbers.
mark exch aload counttomark 1 roll
counttomark 1 sub 2 div cvi {
transform
counttomark 1 sub 2 roll
} repeat
counttomark -1 roll astore
exch pop % the mark
grestore
} bind executeonly def
/preserveannottypes 20 dict begin
/Circle {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/FileAttachment {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/FreeText {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Highlight {
mark exch
dup /QuadPoints .knownget {
1 index /QuadPoints 3 -1 roll
ApplyCTMToQuadPoints
put
} if
loadannot /ANN pdfmark //false
} bind executeonly def
/Ink {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Line {
mark exch dup /L .knownget {
aload 5 1 roll transform 4 -2 roll transform 4 2 roll
5 -1 roll astore
1 index /L 3 -1 roll put
} if
loadannot /ANN pdfmark //false
} bind executeonly def
/Link {
/NO_PDFMARK_DESTS where {pop NO_PDFMARK_DESTS not}{//true}ifelse
{
mark exch
dup /BS knownoget { << exch { oforce } forall >> /BS exch 3 -1 roll } if
dup /F knownoget { /F exch 3 -1 roll } if
dup /C knownoget { /Color exch 3 -1 roll } if
dup /Rect knownoget { /Rect exch 3 -1 roll } if
dup /Border knownoget {
dup type /arraytype eq {
dup length 3 lt
} {
//true
} ifelse {
pop [ 0 0 0 ] % Following AR5 use invisible border.
} if
/Border exch 3 -1 roll
} if
dup /A knownoget {
dup /URI known {
/A mark 3 2 roll % <<>> /A [ <<action>>
{ oforce } forall
.dicttomark
3 2 roll
} {
dup /S knownoget {
%% Because we process GoTo Destinations into absolute references in the PDF file
%% we need to resolve the /D or /Dest. However, we must *not* do this for
%% GoToR Destinations because (obviously) those are in a different file and
%% we cannot resolve them into absolute references. We don't need to anyway
%% because that file must already have a named destination.
dup /GoTo eq {
pop
dup /D knownoget {
exch pop exch dup length dict copy dup /Dest 4 -1 roll put
} if
}{
dup /GoToR eq {
pop /A mark % <<..action dict..>> /A [
3 2 roll % /A [ <<..action dict..>>
{ oforce } forall
.dicttomark
3 2 roll
}{
dup /Launch eq {
pop /A mark % <<..action dict..>> /A [
3 2 roll % /A [ <<..action dict..>>
{ oforce } forall
.dicttomark
3 2 roll
}{
/Named eq {
/N knownoget {
namedactions exch .knownget {
exec {
pop
( **** Warning: Ignoring a named action pointing out of the document page range.\n)
pdfformatwarning
} {
/Page exch 3 -1 roll
} ifelse
} if
} if
} if
}ifelse
} ifelse
} ifelse
} if
} ifelse
} if
{ linkdest } stopped {
cleartomark
( **** Warning: Link annotation points out of the document page range.\n)
pdfformatwarning
} {
pop
{
%% Need to remove any '/.gs.pdfobj# key/value pairs from any dictionaries
counttomark array astore dup length 1 sub 0 1 3 -1 roll {
dup 2 index exch get Removepdfobj# 2 index 3 1 roll put
} for aload pop
/LNK pdfmark
} stopped {cleartomark} if
} ifelse
}{pop} ifelse
//false
} bind executeonly def
/Movie {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Popup {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Sound {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Square {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Stamp {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/StrikeOut {
mark exch
dup /QuadPoints .knownget {
1 index /QuadPoints 3 -1 roll
ApplyCTMToQuadPoints
put
} if
loadannot /ANN pdfmark //false
} bind executeonly def
/Squiggly {
mark exch
dup /QuadPoints .knownget {
1 index /QuadPoints 3 -1 roll
ApplyCTMToQuadPoints
put
} if
loadannot /ANN pdfmark //false
} bind executeonly def
/Text {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/TrapNet {mark exch loadannot /ANN pdfmark //false} bind executeonly def
/Underline {
mark exch
dup /QuadPoints .knownget {
1 index /QuadPoints 3 -1 roll
ApplyCTMToQuadPoints
put
} if
loadannot /ANN pdfmark //false
} bind executeonly def
%% Widget annotations are only used with AcroForms, and since we don't preserve AcroForms
%% we don't want to preserve widget annotations either, because the consumer of the new
%% PDF won't know what values they should take. So we draw widget annotations instead. If we
%% ever preserve AcroForms then we should alter this to preserve Widgets as well.
%% simply chane "drawannot" to "mark exch loadannot /ANN pdfmark"
/Widget {mark exch {drawannot} PDFSTOPONERROR {exec}{stopped {(Error: Ignoring invalid annotation, output may be incorrect.\n) pdfformaterror} if} ifelse cleartomark //false} bind executeonly def
currentdict end readonly def
/preserveannot { % <annot> preserveannot -
dup /.gs.pdfobj# known {
dup /.gs.pdfobj# undef
} if
dup annotvisible {
gsave
dup dup /Subtype knownoget {
dup //.PDFDrawAnnotType? exec
{
//preserveannottypes exch .knownget { exec } { //true } ifelse
{
dup calc_annot_scale 2 copy mul 0 ne
{
3 -1 roll drawwidget
}
{
( **** Error: ignoring annotation with scale factor of 0\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}ifelse % Draw rejected annots as widgets
} if
}
{pop} ifelse
% type known
} {
pop
( **** Error: Ignoring /Annot dict without required /Subtype entry.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
grestore
} if pop % annotvisible
} bind executeonly def
currentdict /preserveannottypes undef
currentdict /.PDFDrawAnnotType? undef
% ============================ AcroForm fields ============================ %
% Get an attribure of the 0th annotation of a node
/annot_oget { % <annot> /Name annot_oget <value>
1 index /Kids knownoget {
0 oget exch oget exch pop
} {
oget
} ifelse
} bind executeonly def
% All procedures have the signature:
% <acroform> <field> <annot|field> foo <acroform> <field> <annot|field>
/draw_terminal_field_dict 4 dict begin
/Btn {
1 index /Tf pget not { 0 } if
dup 16#20000 and 0 ne {
pop % Push button
dup /AP known {
1 1 2 index drawwidget
} {
(Push button without appearance stream is not yet implemented) =
} ifelse
} {
16#10000 and 0 ne {
% Radio button
dup /AP known {
1 index /Kids oget {
1 1 3 -1 roll drawwidget
} forall
} {
(Radio button without appearance stream is not yet implemented) =
} ifelse
} {
% Checkbox
dup /AP known {
dup 1 1 3 -1 roll drawwidget
} {
(CkeckBox without appearance stream is not yet implemented) =
} ifelse
} ifelse
} ifelse
} bind executeonly def
/Tx {
dup /AP known {
dup 1 1 3 -1 roll drawwidget
} {
%% If we don't have a NeedApperances, treat as true, because Acrobat
%% always regenerates Appearances anyway.
2 index /NeedAppearances knownoget not { //true } if {
dup /AP << /N 10 dict dup cvx begin >> put
/Subtype /Form def
/BBox [ 0 0 4 index /Rect oget { oforce } forall 3 -1 roll sub abs 3 1 roll sub abs exch ] def
/Resources 3 index /DR pget not { 0 dict } if def
/File 1000 string dup 3 1 roll def
/Length 1000 def
% <acroform> <field> <annot> (string)
/NullEncode filter % <acroform> <field> <annot> file
dup (BT ) writestring
2 index /DA pget not { () } if
[ exch
{ token {
dup /Tf eq {
2 index 0 eq {
/BBox load 3 get
0.75 mul % empirical constant
4 -1 roll pop 3 1 roll
} if
} if
exch
} {
exit
} ifelse
} loop
]
{ 1 index exch write== } forall
dup 3 index /MaxLen pget not { 0 } if write=
dup 3 index /V pget not {
3 index /DV pget not { () } if
} if write==
dup 3 index /Ff pget not { 0 } if write=
dup 3 index /Q pget not { 0 } if write=
dup (Tform ET) write=
end
closefile % <acroform> <field> <annot>
dup 1 1 3 -1 roll drawwidget
} if
} ifelse
} bind executeonly def
/Ch {
dup /AP known 3 index /NeedAppearances knownoget not { //true } if not and {
dup 1 1 3 -1 roll drawwidget
} {
%% If we don't have a NeedApperances, treat as true, because Acrobat
%% always regenerates Appearances anyway.
2 index /NeedAppearances knownoget not { //true } if {
dup /AP << /N 10 dict dup cvx begin >> put
/Subtype /Form def
/BBox [ 0 0 4 index /Rect oget { oforce } forall 3 -1 roll sub abs 3 1 roll sub abs exch ] def
/Resources 3 index /DR pget not { 0 dict } if def
/File 1000 string dup 3 1 roll def
/Length 1000 def
% <acroform> <field> <annot> (string)
/NullEncode filter % <acroform> <field> <annot> file
dup (BT ) writestring
2 index /DA pget not { () } if
[ exch
{ token {
dup /Tf eq {
2 index 0 eq {
/BBox load 3 get
0.75 mul % empirical constant
4 -1 roll pop 3 1 roll
} if
} if
exch
} {
exit
} ifelse
} loop
]
{ 1 index exch write== } forall
dup 3 index /MaxLen pget not { 0 } if write=
dup 3 index /V pget not {
3 index /DV pget not { () } if
} if write==
dup 3 index /Ff pget not { 0 } if write=
dup 3 index /Q pget not { 0 } if write=
dup (Tform ET) write=
end
closefile % <acroform> <field> <annot>
dup 1 1 3 -1 roll drawwidget
} if
} ifelse
} bind executeonly def
/Sig {
(Sig is not yet implemened ) //== exec
} bind executeonly def
currentdict end def
/draw_terminal_field { % <field> draw_terminal_field -
dup /Kids knownoget { 0 oget } { dup } ifelse
dup /P knownoget {
/Page load eq {
//draw_terminal_field_dict 2 index /FT pget not { 0 } if .knownget {
exec
} if
} if
} if
pop pop
} bind executeonly def
% We distinguish 4 types of nodes on the form field tree:
% - non-terminal field - has a kid that refers to the parent (or anywhere else)
% - terminal field with separate widget annotations - has a kid that doesn't have a parent
% - terminal field with a merged widget annotation - has no kids
% - widget annotation - has /Subtype and /Rect
%
% The recursive enumeration of the form fields doesn't descend into widget annotations.
/draw_form_field { % <field> draw_form_field -
dup /Kids knownoget { % field []
dup length 0 gt {
dup 0 oget /Parent knownoget { % field [] kid
pop % mon-terminal field % field []
exch pop % []
{ oforce draw_form_field } forall
} {
pop draw_terminal_field % separate annots % -
} ifelse
} {
( **** Error: Ignoring empty /Kids array in Form field.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} {
draw_terminal_field % merged annotation % -
} ifelse
} bind executeonly def
/draw_acro_form { % <form> draw_acro_form -
dup /Fields knownoget {
{ oforce draw_form_field } forall
} if
pop
} bind executeonly def
currentdict /draw_terminal_field_dict undef
end % pdfdict
end % GS_PDF_ProcSet
.setglobal
Mini Shell