% Copyright (C) 1994, 2000 Aladdin Enterprises. All rights reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% For more information about licensing, please refer to
% http://www.ghostscript.com/licensing/. For information on
% commercial licensing, go to http://www.artifex.com/licensing/ or
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
% San Rafael, CA 94903, U.S.A., +1(415)492-9861.
% $Id: gs_setpd.ps,v 1.27 2005/06/09 19:47:18 ray Exp $
% The current implementation of setpagedevice has the following limitations:
% - It doesn't attempt to "interact with the user" for Policy = 2.
languagelevel 1 .setlanguagelevel
level2dict begin
% ---------------- Redefinitions ---------------- %
% Redefine .beginpage and .endpage so that they call BeginPage and
% EndPage respectively if appropriate.
% We have to guard against the BeginPage procedure not popping its operand.
% This is really stupid, but the Genoa CET does it.
/.beginpage { % - .beginpage -
.currentshowpagecount {
.currentpagedevice pop
dup //null ne { /BeginPage .knownget } { pop //false } ifelse {
% Stack: ... pagecount proc
count 2 .execn
% Stack: ... ..???.. oldcount
count 1 add exch sub { pop } repeat
} {
pop
} ifelse
} if
} bind odef
% Guard similarly against EndPage not popping its operand.
/.endpage { % <reason> .endpage <print_bool>
.currentshowpagecount {
1 index .currentpagedevice pop
dup //null ne { /EndPage .knownget } { pop //false } ifelse {
% Stack: ... reason pagecount reason proc
count 2 .execn
% Stack: ... ..???.. print oldcount
count 2 add exch sub { exch pop } repeat
} {
pop pop 2 ne
} ifelse
} {
2 ne
} ifelse
} bind odef
% Define interpreter callouts for handling gstate-saving operators,
% to make sure that they create a page device dictionary for use by
% the corresponding gstate-restoring operator.
% We'd really like to avoid the cost of doing this, but we don't see how.
% The names %gsavepagedevice, %savepagedevice, %gstatepagedevice,
% %copygstatepagedevice, and %currentgstatepagedevice are known to the
% interpreter.
(%gsavepagedevice) cvn
{ currentpagedevice pop gsave
} bind def
(%savepagedevice) cvn
{ currentpagedevice pop save
} bind def
(%gstatepagedevice) cvn
{ currentpagedevice pop gstate
} bind def
(%copygstatepagedevice) cvn
{ currentpagedevice pop copy
} bind def
(%currentgstatepagedevice) cvn
{ currentpagedevice pop currentgstate
} bind def
% Define interpreter callouts for handling gstate-restoring operators
% when the current page device needs to be changed.
% The names %grestorepagedevice, %grestoreallpagedevice,
% %restorepagedevice, %restore1pagedevice, and %setgstatepagedevice
% are known to the interpreter.
/.installpagedevice
{ % Since setpagedevice doesn't create new device objects,
% we must (carefully) reinstall the old parameters in
% the same device.
.currentpagedevice pop //null currentdevice //null .trysetparams
dup type /booleantype eq
{ pop pop }
{ % This should never happen!
SETPDDEBUG { (Error in .trysetparams!) = pstack flush } if
cleartomark pop pop pop
/.installpagedevice cvx /rangecheck signalerror
}
ifelse pop pop
% A careful reading of the Red Book reveals that an erasepage
% should occur, but *not* an initgraphics.
erasepage .beginpage
} bind def
/.uninstallpagedevice
{ 2 .endpage { .currentnumcopies //false .outputpage } if
nulldevice
} bind def
(%grestorepagedevice) cvn
{ .uninstallpagedevice grestore .installpagedevice
} bind def
(%grestoreallpagedevice) cvn
{ .uninstallpagedevice grestore .installpagedevice grestoreall
} bind def
(%restore1pagedevice) cvn
{ .uninstallpagedevice grestore .installpagedevice restore
} bind def
(%restorepagedevice) cvn
{ .uninstallpagedevice restore .installpagedevice
} bind def
(%setgstatepagedevice) cvn
{ .uninstallpagedevice setgstate .installpagedevice
} bind def
% Redefine .currentnumcopies so it consults the NumCopies device parameter.
/.numcopiesdict mark
/NumCopies dup
.dicttomark readonly def
/.currentnumcopies
{ currentdevice //.numcopiesdict .getdeviceparams
dup type /integertype eq
{ exch pop exch pop }
{ cleartomark #copies }
ifelse
} bind odef
% Redefine .currentpagedevice and .setpagedevice so they convert between
% null and a fixed empty directionary.
/.nullpagedevice 0 dict readonly def
/.currentpagedevice {
//.currentpagedevice exch dup //null eq { pop //.nullpagedevice } if exch
} bind odef
/.setpagedevice {
dup //.nullpagedevice eq { pop //null } if //.setpagedevice
} bind odef
% ---------------- Auxiliary definitions ---------------- %
% Define the required attributes of all page devices, and their default values.
% We don't include attributes such as .MediaSize, which all devices
% are guaranteed to supply on their own.
/.defaultpolicies mark
/PolicyNotFound 1
/PageSize 0
/PolicyReport {
dup /.LockSafetyParams known {
% Only possible error is invalidaccess
/setpagedevice .systemvar /invalidaccess signalerror
}
if
pop
} bind
.dicttomark readonly def
% Note that the values of .requiredattrs are executed, not just fetched.
/.requiredattrs mark
/PageDeviceName //null
/PageOffset [0 0] readonly
% We populate InputAttributes with all of the known page sizes
% followed by a dummy media type that handles pages of any size.
% This will create some duplicates, but that only slightly slows
% down the media selection (loop is in zmedia2.c).
%
% Some PostScript creators assume that slot 0 is the default media
% size and some can't handle a non-standard 4-element array which
% is a 'range' type page size (always put last).
%
% Real Devices that can only handle specific page sizes will override this.
/InputAttributes {
mark
% First put the device's default page size in slot 0
% This satifies those that have devices built with a4 as the default
0 mark /PageSize currentdevice /PageSize gsgetdeviceprop .dicttomark
statusdict /.pagetypenames get {
counttomark 1 sub 2 idiv exch mark exch /PageSize exch
% stack: mark --dict-- --dict-- ... key mark /PageSize pagetypename
% see note above about pagetype executable array contents.
load dup 0 get exch 1 get 2 array astore .dicttomark
} forall
% If NORANGEPAGESIZE is defined, (-dNORANGEPAGESIZE), then don't add
% the 'match any' PageSize entry
systemdict /NORANGEPAGESIZE known not {
% Add one last entry which is the 4 element range array (non-standard)
counttomark 2 idiv
% PageSize with either dimension 0 will be detected in
% match_page_size, so we can allow it here
mark /PageSize [0 dup 16#7ffff dup] .dicttomark
} if
.dicttomark
}
(%MediaSource) 0
/OutputAttributes {
mark 0 mark .dicttomark readonly .dicttomark
}
(%MediaDestination) 0
/Install {{.callinstall}} bind
/BeginPage {{.callbeginpage}} bind
/EndPage {{.callendpage}} bind
/Policies .defaultpolicies
/ImagingBBox //null % default value
/UseCIEColor /.getuseciecolor load
.dicttomark readonly def
% Define currentpagedevice so it creates the dictionary on demand if needed,
% adding all the required entries defined just above.
% We have to deal specially with entries that the driver may change
% on its own.
/.dynamicppkeys mark
/.MediaSize dup % because it changes when PageSize is set
/PageCount dup
/Colors dup
/BitsPerPixel dup
/ColorValues dup
.dicttomark readonly def
/.makecurrentpagedevice { % - .makecurrentpagedevice <dict>
currentdevice //null .getdeviceparams
% Make the dictionary large enough to add defaulted entries.
counttomark 2 idiv .requiredattrs length add dict
counttomark 2 idiv { dup 4 2 roll put } repeat exch pop
% Add any missing required attributes.
% Make a writable and (if possible) local copy of any default
% dictionaries, to work around a bug in the output of WordPerfect,
% which assumes that these dictionaries are writable and local.
.currentglobal exch dup gcheck .setglobal
.requiredattrs {
2 index 2 index known {
1 index /Policies eq {
% Merge policies from the device driver with defaults
2 index % <<>> /key value <<>>
3 2 roll get % <<>> value <<policies>>
exch {
2 index 2 index known {
pop pop
} {
2 index 3 1 roll put
} ifelse
} forall
pop
} {
pop pop
} ifelse
} {
exec 2 index 3 1 roll put
} ifelse
} forall exch .setglobal
dup .setpagedevice
} bind def
/currentpagedevice {
.currentpagedevice {
dup length 0 eq {
pop .makecurrentpagedevice
} {
% If any of the dynamic keys have changed,
% we must update the page device dictionary.
currentdevice //.dynamicppkeys .getdeviceparams .dicttomark {
% Stack: current key value
2 index 2 index .knownget { 1 index ne } { //true } ifelse
{ 2 index wcheck not
{ % This is the first entry being updated.
% Copy the dictionary to make it writable.
3 -1 roll
currentglobal 1 index dup gcheck currentglobal and setglobal
length dict
exch setglobal
.copydict
3 1 roll
}
if
2 index 3 1 roll put
}
{ pop pop
}
ifelse
} forall
% If the device is the distiller device, update distillerparams that
% may have been changed by setdistillerparams
currentdevice .devicename /pdfwrite eq {
currentdistillerparams {
% Stack: current key value
2 index 2 index .knownget { 1 index ne } { //true } ifelse
{ 2 index 3 1 roll put } { pop pop } ifelse
} forall
} if
% If the dictionary was global and is now local, copy
% any global subsidiary dictionaries to local VM. This
% too is to work around the Word Perfect bug (see above).
dup gcheck not {
dup {
dup type /dicttype eq { dup gcheck } { //false } ifelse {
% Copy-on-write, see above.
2 index wcheck not {
3 -1 roll dup length dict .copydict
3 1 roll
} if
.copytree 2 index 3 1 roll put
} {
pop pop
} ifelse
} forall
} if
% We would like to do a .setpagedevice so we don't keep
% re-creating the dictionary. Unfortunately, the effect
% of this is that if any dynamic key changes (PageCount
% in particular), we will do the equivalent of a
% setpagedevice at the next restore or grestore.
% Therefore, we make the dictionary read-only, but
% we don't store it away. I.e., NOT:
% dup wcheck { .setpagedevice .currentpagedevice pop } if
readonly
} ifelse
} if
} bind odef
% Copy a dictionary recursively.
/.copytree { % <dict> .copytree <dict'>
dup length dict exch {
dup type /dicttype eq { .copytree } if 2 index 3 1 roll put
} forall
} bind def
% The implementation of setpagedevice is quite complex. Currently,
% everything but the media matching algorithm is implemented here.
% By default, we only present the requested changes to the device,
% but there are some parameters that require special merging action.
% Define those parameters here, with the procedures that do the merging.
% The procedures are called as follows:
% <merged> <key> <new_value> -proc- <merged> <key> <new_value'>
/.mergespecial mark
/InputAttributes
{ dup //null eq
{ pop //null
}
{ 3 copy pop .knownget
{ dup //null eq
{ pop dup length dict }
{ dup length 2 index length add dict .copydict }
ifelse
}
{ dup length dict
}
ifelse .copydict readonly
}
ifelse
} bind
/OutputAttributes 1 index
/Policies
{ 3 copy pop .knownget
{ dup length 2 index length add dict .copydict }
{ dup length dict }
ifelse copy readonly
} bind
.dicttomark readonly def
% Define the keys used in input attribute matching.
/.inputattrkeys [
/PageSize /MediaColor /MediaWeight /MediaType /InsertSheet /ManualFeed
% The following are documented in Adobe's supplement for v2017.
/LeadingEdge /MediaClass
] readonly def
% Define other keys used in media selection.
/.inputselectionkeys [
/MediaPosition /Orientation
] readonly def
% Define the keys used in output attribute matching.
/.outputattrkeys [
/OutputType
] readonly def
% Define all the parameters that should always be copied to the merged
% dictionary.
/.copiedkeys [
/OutputDevice
.mergespecial { pop } forall
.inputattrkeys aload pop
.inputselectionkeys aload pop
.outputattrkeys aload pop
] readonly def
% Define the parameters that should not be presented to the device.
% The procedures are called as follows:
% <merged> <key> <value> -proc-
% The procedure leaves all its operands on the stack and returns
% true iff the key/value pair should be presented to .putdeviceparams.
/.presentspecial mark
.dynamicppkeys { pop //false } forall
% We must ignore an explicit request for .MediaSize,
% because media matching always handles this.
/.MediaSize //false
/Name //false
/OutputDevice //false
/PageDeviceName //false
/PageOffset //false
/PageSize //false % obsolete alias for .MediaSize
/InputAttributes //false
.inputattrkeys
{ dup /PageSize eq
{ pop }
{ { 2 index /InputAttributes .knownget { //null eq } { //true } ifelse } }
ifelse
}
forall
.inputselectionkeys { //false } forall
/OutputAttributes //false
.outputattrkeys
{ { 2 index /OutputAttributes .knownget { //null eq } { //true } ifelse } }
forall
/Install //false
/BeginPage //false
/EndPage //false
/Policies //false
% Our extensions:
/HWColorMap
{ % HACK: don't transmit the color map, because
% window systems can change the color map on their own
% incrementally. Someday we'll have a better
% solution for this....
//false
}
/ViewerPreProcess //false
/ImagingBBox //false % This prevents the ImagingBBox value in the setpagedevice
% from affecting the device's ImagingBBox parameter, but
% does retain a 'shadow' copy at the PostScript level.
% This is done for Adobe compatibility since Adobe does
% render marks outside the ImagingBBox (and QuarkXpress
% relies on it).
.dicttomark readonly def
% Define access to device defaults.
/.defaultdeviceparams
{ finddevice //null .getdeviceparams
} bind def
% Select media (input or output). The hard work is done in an operator:
% <pagedict> <attrdict> <policydict> <keys> .matchmedia <key> true
% <pagedict> <attrdict> <policydict> <keys> .matchmedia false
% <pagedict> null <policydict> <keys> .matchmedia null true
/.selectmedia % <orig> <request> <merged> <failed> <-- retained
% <attrdict> <policydict> <attrkeys> <mediakey>
% .selectmedia
{ 5 index 5 -2 roll 4 index .matchmedia
% Stack: orig request merged failed attrkeys mediakey
% (key true | false)
{ 4 index 3 1 roll put pop
}
{ % Adobe's implementations have a "big hairy heuristic"
% to choose the set of keys to report as having failed the match.
% For the moment, we report any keys that are in the request
% and don't have the same value as in the original dictionary.
5 index 1 index .knownget
{ 4 index 3 1 roll put }
{ 3 index exch .undef }
ifelse
{ % Stack: <orig> <request> <merged> <failed> <attrkey>
3 index 1 index .knownget
{ 5 index 2 index .knownget { ne } { pop //true } ifelse }
{ //true }
ifelse % Stack: ... <failed> <attrkey> <report>
{ 2 copy /rangecheck put }
if pop
}
forall
}
ifelse
} bind def
% Apply Policies to any unprocessed failed requests.
% As we process each request entry, we replace the error name
% in the <failed> dictionary with the policy value,
% and we replace the key in the <merged> dictionary with its prior value
% (or remove it if it had no prior value).
/.policyprocs mark
% These procedures are called with the following on the stack:
% <orig> <merged> <failed> <Policies> <key> <policy>
% They are expected to consume the top 2 operands.
% NOTE: we currently treat all values other than 0, 1, or 7 (for PageSize)
% the same as 0, i.e., we signal an error.
0 { % Set errorinfo and signal a configurationerror.
pop dup 4 index exch get 2 array astore
$error /errorinfo 3 -1 roll put
cleartomark
/setpagedevice load /configurationerror signalerror
} bind
1 { % Roll back the failed request to its previous status.
SETPDDEBUG { (Rolling back.) = pstack flush } if
3 index 2 index 3 -1 roll put
4 index 1 index .knownget
{ 4 index 3 1 roll put }
{ 3 index exch .undef }
ifelse
} bind
7 { % For PageSize only, just impose the request.
1 index /PageSize eq
{ pop pop 1 index /PageSize 7 put }
{ .policyprocs 0 get exec }
ifelse
} bind
.dicttomark readonly def
/.applypolicies % <orig> <merged> <failed> .applypolicies
% <orig> <merged'> <failed'>
{ 1 index /Policies get 1 index
{ type /integertype eq
{ pop % already processed
}
{ 2 copy .knownget not { 1 index /PolicyNotFound get } if
% Stack: <orig> <merged> <failed> <Policies> <key>
% <policy>
.policyprocs 1 index .knownget not { .policyprocs 0 get } if exec
}
ifelse
}
forall pop
} bind def
% Prepare to present parameters to the device, by spreading them onto the
% operand stack and removing any that shouldn't be presented.
/.prepareparams % <params> .prepareparams -mark- <key1> <value1> ...
{ mark exch dup
{ % Stack: -mark- key1 value1 ... merged key value
.presentspecial 2 index .knownget
{ exec { 3 -1 roll } { pop pop } ifelse }
{ 3 -1 roll }
ifelse
}
forall pop
} bind def
% Put device parameters without resetting currentpagedevice.
% (.putdeviceparams clears the current page device.)
/.putdeviceparamsonly % <device> <Policies|null> <require_all> -mark-
% <key1> <value1> ... .putdeviceparamsonly
% On success: <device> <eraseflag>
% On failure: <device> <Policies|null> <req_all> -mark-
% <key1> <error1> ...
{ .currentpagedevice
{ counttomark 4 add 1 roll .putdeviceparams
dup type /booleantype eq { 3 } { counttomark 5 add } ifelse -1 roll
.setpagedevice
}
{ pop .putdeviceparams
}
ifelse
} bind def
% Try setting the device parameters from the merged request.
/.trysetparams % <merged> <(ignored)> <device> <Policies>
% .trysetparams
{ //true 4 index .prepareparams
% Add the computed .MediaSize.
% Stack: merged (ignored) device Policies -true-
% -mark- key1 value1 ...
counttomark 5 add index .computemediasize
exch pop exch pop /.MediaSize exch
SETPDDEBUG { (Putting.) = pstack flush } if
.putdeviceparamsonly
SETPDDEBUG { (Result of putting.) = pstack flush } if
} bind def
% Compute the media size and initial matrix from a merged request (after
% media selection).
/.computemediasize % <request> .computemediasize
% <request> <matrix> <[width height]>
{ dup /PageSize get % requested page size
1 index /InputAttributes get
2 index (%MediaSource) get get /PageSize get % media size
% (may be a range)
2 index /Policies get
dup /PageSize .knownget
{ exch pop } { /PolicyNotFound get } ifelse % PageSize policy,
% affects scaling
3 index /Orientation .knownget not { //null } if
4 index /RollFedMedia .knownget not { //false } if
matrix .matchpagesize not {
% This is a "can't happen" condition!
/setpagedevice load /rangecheck signalerror
} if
2 array astore
} bind def
% ---------------- setpagedevice itself ---------------- %
/setpagedevice
{ % We mustn't pop the argument until the very end,
% so that the pseudo-operator machinery can restore the stack
% if an error occurs.
mark 1 index currentpagedevice
% Check whether we are changing OutputDevice;
% also handle the case where the current device
% is not a page device.
% Stack: mark <request> <current>
SETPDDEBUG { (Checking.) = pstack flush } if
dup /OutputDevice .knownget
{ % Current device is a page device.
2 index /OutputDevice .knownget
{ % A specific OutputDevice was requested.
2 copy eq
{ pop pop //null }
{ exch pop }
ifelse
}
{ pop //null
}
ifelse
}
{ % Current device is not a page device.
% Use the default device.
1 index /OutputDevice .knownget not { .defaultdevicename } if
}
ifelse
dup //null eq
{ pop
}
{ exch pop .defaultdeviceparams
% In case of duplicate keys, .dicttomark takes the entry
% lower on the stack, so we can just append the defaults here.
.requiredattrs { exec } forall .dicttomark
}
ifelse
% Check whether a viewer wants to intervene.
% We must check both the request (which takes precedence)
% and the current dictionary.
% Stack: mark <request> <orig>
exch dup /ViewerPreProcess .knownget
{ exec }
{ 1 index /ViewerPreProcess .knownget { exec } if }
ifelse exch
% Construct a merged request from the actual request plus
% any keys that should always be propagated.
% Stack: mark <request> <orig>
SETPDDEBUG { (Merging.) = pstack flush } if
exch 1 index length 1 index length add dict
.copiedkeys
{ % Stack: <orig> <request> <merged> <key>
3 index 1 index .knownget { 3 copy put pop } if pop
}
forall
% Stack: <orig> <request> <merged>
dup 2 index
{ % stack: <orig> <request> <merged> <merged> <rkey> <rvalue>
.mergespecial 2 index .knownget { exec } if
put dup
}
forall pop
% Hack: if FIXEDRESOLUTION is true, discard any attempt to
% change HWResolution.
FIXEDRESOLUTION { dup /HWResolution .undef } if
% Hack: if FIXEDMEDIA is true, discard any attempt to change
% PageSize or HWSize.
FIXEDMEDIA
{ dup /PageSize 4 index /PageSize get put
dup /HWSize 4 index /HWSize get put
} if
% Hack: to work around some files that take a PageSize
% from InputAttributes and impose it, discard any attempt
% to set PageSize to a 4-element value.
% Stack: mark <orig> <request> <merged>
dup /PageSize .knownget {
length 2 ne {
dup /PageSize 4 index /PageSize get put
} if
} if
% Select input and output media.
% Stack: mark <orig> <request> <merged>
SETPDDEBUG { (Selecting.) = pstack flush } if
0 dict % <failed>
1 index /InputAttributes .knownget
{ 2 index /Policies get
.inputattrkeys (%MediaSource) cvn .selectmedia
} if
1 index /OutputAttributes .knownget
{ 2 index /Policies get
.outputattrkeys (%MediaDestination) cvn .selectmedia
} if
3 -1 roll 4 1 roll % temporarily swap orig & request
.applypolicies
3 -1 roll 4 1 roll % swap back
% Construct the new device, and attempt to set its attributes.
% Stack: mark <orig> <request> <merged> <failed>
SETPDDEBUG { (Constructing.) = pstack flush } if
currentdevice .devicename 2 index /OutputDevice get eq
{ currentdevice }
{ 1 index /OutputDevice get finddevice }
ifelse
%**************** We should copy the device here,
%**************** but since we can't close the old device,
%**************** we don't. This is WRONG.
%****************copydevice
2 index /Policies get
.trysetparams
dup type /booleantype ne
{ % The request failed.
% Stack: ... <orig> <request> <merged> <failed> <device>
% <Policies> true mark <name> <errorname> ...
SETPDDEBUG { (Recovering.) = pstack flush } if
counttomark 4 add index
counttomark 2 idiv { dup 4 -2 roll put } repeat
pop pop pop
% Stack: mark ... <orig> <request> <merged> <failed> <device>
% <Policies>
6 2 roll 3 -1 roll 4 1 roll
.applypolicies
3 -1 roll 4 1 roll 6 -2 roll
.trysetparams % shouldn't fail!
dup type /booleantype ne
{ 2 { counttomark 1 add 1 roll cleartomark } repeat
/setpagedevice load exch signalerror
}
if
}
if
% The attempt succeeded. Install the new device.
% Stack: mark ... <merged> <failed> <device> <eraseflag>
SETPDDEBUG { (Installing.) = pstack flush } if
pop 2 .endpage
{ 1 //true .outputpage
(>>setpagedevice, press <return> to continue<<\n) .confirm
}
if
% .setdevice clears the current page device!
.currentpagedevice pop exch
.setdevice pop
.setpagedevice
% Implement UseCIEColor directly if this is a LL3 system.
% The color substitution feature is now implemented in
% the interpreter, and this is used as an optimization.
%
% NB: This shoud be the only use of the .setuseciecolor
% operator anywhere.
%
% If UseCIEColor is transitioned to false, set some
% color space other than /DeviceGray, to insure that
% initgraphics will actually perform a setcolorspace
% operation (there is an optimization in setcolorspace
% that does nothing if the operand and current color
% spaces are the same, and UseCIEColor is false).
/.setuseciecolor where
{
pop 1 index /UseCIEColor .knownget
{
dup .setuseciecolor not
{ /DeviceRGB setcolorspace }
if
}
if
}
if
% Merge the request into the current page device,
% unless we're changing the OutputDevice.
% Stack: mark ... <merged> <failed>
exch currentpagedevice dup length 2 index length add dict
% Stack: mark ... <failed> <merged> <current> <newdict>
2 index /OutputDevice .knownget {
2 index /OutputDevice .knownget not { //null } if eq
} {
//true
} ifelse {
% Same OutputDevice, merge the dictionaries.
.copydict
} {
% Different OutputDevice, discard the old dictionary.
exch pop
} ifelse .copydict
% Initialize the default matrix, taking media matching
% into account.
.computemediasize pop initmatrix concat
dup /PageOffset .knownget
{ % Translate by the given number of 1/72" units in device X/Y.
dup 0 get exch 1 get
2 index /HWResolution get dup 1 get exch 0 get
4 -1 roll mul 72 div 3 1 roll mul 72 div
idtransform translate
}
if
% We must install the new page device dictionary
% before calling the Install procedure.
dup .setpagedevice
.setdefaulthalftone % Set the default screen before calling Install.
dup /Install .knownget {
{ .execinstall } stopped { .postinstall stop } { .postinstall } ifelse
} {
.postinstall
} ifelse
} odef
% We break out the code after calling the Install procedure into a
% separate procedure, since it is executed even if Install causes an error.
% By making .execinstall a separate operator procedure, we get the stacks
% restored if it fails.
/.execinstall { % <proc> .execinstall -
% Because the interpreter optimizes tail calls, we can't just let
% the body of this procedure be 'exec', because that would lose
% the stack protection that is the whole reason for having the
% procedure in the first place. We hack this by adding a couple
% of extra tokens to ensure that the operator procedure is still
% on the stack during the exec.
exec
0 pop % See above.
} odef
/.postinstall { % mark ... <failed> <merged> .postinstall -
matrix currentmatrix .setdefaultmatrix
% Erase and initialize the page.
initgraphics
currentoverprint //false setoverprint 1 setcolor
.fillpage
0 setcolor setoverprint
.beginpage
% Clean up, calling PolicyReport if needed.
% Stack: mark ... <failed> <merged>
SETPDDEBUG { (Finishing.) = pstack flush } if
exch dup length 0 ne
{ 1 index /Policies get /PolicyReport get
counttomark 1 add 2 roll cleartomark
exec
}
{ cleartomark
}
ifelse pop
} odef
end % level2dict
.setlanguagelevel
|
