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