%    Copyright (C) 2001, 2002 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_patrn.ps,v 1.2 2002/11/13 20:23:10 alexcher Exp $% Pattern color space method dictionary.  % verify that Pattern color spaces are supported/.setpatternspace where  { pop }  { currentfile closefile }ifelse .currentglobal true .setglobal.cspace_util begin %%   <name1 | array1>   get_pattern_base_cspace   <null | name2 | array2>%% If the Pattern color space has a base color space, push that base% color space onto the stack. Otherwise, push a null object.%/get_pattern_base_cspace  {    dup type /nametype eq      { pop //null }      {        dup length 1 gt          { 1 get }          { pop //null }        ifelse      }    ifelse  }bind def  %%   <dict>   has_base_color   <bool>%% Determine if a Pattern "color" includes a base color. This is the case% if the pattern dictionary has PatternType 1 and PaintType 2.%/has_base_color  {    dup //null eq      { pop //false }      {        dup /PatternType get 1 eq          { /PaintType get 2 eq }          { pop //false }        ifelse      }    ifelse  }bind def %%   <c1> ... <cn>  <pattern_dict>  <pattern_cspace>%   get_pattern_base_color%   <c1> ... <cn>  <base_cspace>  true% or%   <?c1?> ... <?cn?>  <dict>  <pattern>%   get_pattern_base_color%   false%% If a pattern dictionary has a base color, set up that base color and% color space, and push true. Otherwise, just push false. It is assumed% that if the pattern includes a base color, the Pattern color space% has a base color space.%/get_pattern_base_color  {    exch //has_base_color exec      { 1 get //true }      { pop //false }    ifelse  }bind def  colorspacedict/Pattern  mark    /cs_potential_indexed_base false    /cs_potential_pattern_base false    /cs_potential_alternate false    /cs_potential_icc_alternate false     %    % We employ the same convention for describing the number of    % components in a Pattern color space as is used by the graphic    % library. For pattern spaces with no underlying color space,    % the result is -1. If a Pattern space has an underlying color    % space with n components, the result is -(n + 1).    %    /cs_get_ncomps      {        //get_pattern_base_cspace exec dup //null eq          { pop 0 }          //.cs_get_ncomps        ifelse        1 add neg      }    bind     % there is no "range" for a Pattern color space    /cs_get_range { {} cvlit } bind     /cs_get_default_color { pop //null } bind     /cs_get_currentgray      {        //get_pattern_base_color exec          //.cs_get_currentgray          { 0 }        ifelse      }    bind     /cs_get_currentrgb      {        //get_pattern_base_color exec          //.cs_get_currentrgb          { 0 0 0 }        ifelse      }    bind     /cs_get_currentcmyk      {        //get_pattern_base_color exec          //.cs_get_currentcmyk          { 0 0 0 1.0 }        ifelse      }    bind     /cs_validate      {        dup //get_pattern_base_cspace exec dup //null eq          { pop }          {            //.cs_validate exec //.cs_potential_pattern_base exec not              //setcspace_rangecheck            if          }        ifelse      }    bind     % substitute the base space if appropriate    /cs_substitute      {        dup //get_pattern_base_cspace exec dup //null eq          { pop dup }          {            //.cs_substitute exec 2 copy eq              { pop pop dup }              {                % retain only the new alternate space                exch pop                 % build all new structures in local VM               .currentglobal 3 1 roll //false .setglobal                 % construct a new array and insert the new base color space                 1 index dup length array copy dup 1 4 -1 roll put                 % restore VM mode                3 -1 roll .setglobal              }            ifelse          }        ifelse      }    bind     /cs_prepare {}     %    % Install the current color space.    %    % The current Ghostscript color space implementation requires that    % color spaces that provide a base or alternative color space set    % that base/alternative color space to be the current color space    % before attempting to set the original color space.    %    % In principle, the only errors that are possible for .setpatternspace    % (given that setcolorspace itself is legal) are limitcheck and/or    % VMerror. The Ghostscript implementation allows a few others, so     % we go through the full code to restore the current color space in    % the event of an error.    %    /cs_install      {        dup //get_pattern_base_cspace exec dup //null eq          {            pop            dup type /nametype eq              { pop { /Pattern } cvlit }            if            .setpatternspace          }          {            % save the current color space            currentcolorspace             % set the base color space as the current color space            exch //forcesetcolorspace             % set the pattern color space; restore the earlier space on error            mark 2 index              { .setpatternspace }            stopped              { cleartomark setcolorspace stop }              { pop pop pop }            ifelse          }        ifelse      }    bind      %    % Pattern dictionaries generated by makepattern will include an    % Implementation entry whose value is an internal data structure.    % Such structures are given executable type names that match their    % internal structure names. The names used for pattern    % implementations are gs_pattern1_instance_t and    % gs_pattern2_instance_t. It is unfortunate to have to expose such    % internal names at this level, but not easily avoided.    %    /cs_prepare_color      {        % verify that the topmost operand is a pattern dictionary        1 index dup type /dicttype ne          {            //null ne              //setcspace_typecheck            if            pop          }          {            dup /Implementation .knownget              {                type dup dup                /gs_pattern1_instance_t ne exch /gs_pattern2_instance_t ne and                exch xcheck not                or                  //setcspace_typecheck                if              }              //setcspace_typecheck            ifelse             % check if base color space operands are present            dup /PatternType get 1 eq              {                /PaintType get 2 eq                  {                    % verify that a base color space exists                    //get_pattern_base_cspace exec dup //null eq                      //setcspace_rangecheck                    if                    exch 1 index //.cs_get_ncomps exec                    exch 1 index 3 add 1 roll                    //check_num_stack exec                    //.cs_get_ncomps exec 1 add -1 roll                  }                  { pop }                ifelse              }              { pop pop }            ifelse          }        ifelse      }    bind     /cs_complete_setcolor //pop_1   .dicttomarkput end     % .cspace_util.setglobal