%    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 .setlanguagelevellevel2dict 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)

Lines 1–500 of 863. Load more