path: root/vcl/unx/generic/print/psheader.ps

%
% This file is part of the LibreOffice project.
%
% This Source Code Form is subject to the terms of the Mozilla Public
% License, v. 2.0. If a copy of the MPL was not distributed with this
% file, You can obtain one at http://mozilla.org/MPL/2.0/.
%
% This file incorporates work covered by the following license notice:
%
%   Licensed to the Apache Software Foundation (ASF) under one or more
%   contributor license agreements. See the NOTICE file distributed
%   with this work for additional information regarding copyright
%   ownership. The ASF licenses this file to you under the Apache
%   License, Version 2.0 (the "License"); you may not use this file
%   except in compliance with the License. You may obtain a copy of
%   the License at http://www.apache.org/licenses/LICENSE-2.0 .
%

% This is an "unobsfucated version of postscript header" in printerjob.cxx. It
% was probably kept separate for the comments, but it is not used in it self
% and probably was not kept in sync with the actual header.

%
%
% readpath
%
% The intention of readpath is to save disk space since the vcl clip region routines 
% produce a huge amount of lineto/moveto commands
%
% The principal idea is to maintain the current point on stack and to provide only deltas
% in the command. These deltas are added to the current point. The new point is used for
% the lineto and moveto command and saved on stack for the next command.
%
% pathdict implements binary/hex representation of lineto and moveto commands. 
% The command consists of a 1byte opcode to switch between lineto and moveto and the size
% of the following delta-x and delta-y values. The opcode is read with /rcmd, the two 
% coordinates are read with /rhex. The whole command is executed with /xcmd
%
% 

/pathdict dup 8 dict def load 
begin

	% the command is of the bit format cxxyy
	% with c=0 meaning lineto
	%      c=1 meaning moveto
	% xx is a 2bit value for the number of bytes for x position
	% yy is the same for y, values are off by one: 00 means 1; 11 means 4 !
	% the command has been added to 'A' to be always in the ascii character
	% range. the command is followed by 2*xx + 2*yy hexchars. 
	% '~' denotes the special case of EOD 
	/rcmd  	{ 
				{ 
					currentfile 1 string readstring % s bool
					pop								% s
					0 get							% s[0]
													% --- check whether s[0] is CR, LF ...
					dup 32 gt						% s > ' ' ? then read on
					{ exit }
					{ pop  }
					ifelse
				}
				loop

				dup 126 eq { pop exit } if		% -- Exit loop if cmd is '~'
				65 sub							% cmd=s[0]-'A'
												% -- Separate yy bits
				dup 16#3 and 1 add				% cmd yy
												% -- Separate xx bits
				exch							% yy cmd
				dup 16#C and -2 bitshift 
				16#3 and 1 add exch 			% yy xx cmd
												% -- Separate command bit
				16#10 and 16#10 eq				% yy xx bool
				3 1 roll exch					% bool xx yy
			} def

	% length rhex -- reads a signed hex value of given length
	% the left most bit of char 0 is considered as the sign (0 means '+', 1 means '-')
	% the rest of the bits is considered to be the abs value. Please note that this 
	% does not match the C binary representation of integers 
	/rhex 	{ 
				dup 1 sub exch 			% l-1 l
				currentfile exch string readhexstring 	% l-1 substring[l] bool
				pop 
				dup 0 get dup 			% l-1 s s[0] s[0]
										% -- Extract the sign
				16#80 and 16#80 eq dup  % l-1 s s[0] sign=- sign=-
										% -- Mask out the sign bit and put value back
				3 1 roll				% l-1 s sign=- s[0] sign=-
				{ 16#7f and } if		% l-1 s sign=- +s[0]
				2 index 0 				% l-1 s sign=- +s[0] s 0
				3 -1 roll put			% l-1 s sign=- s 0 +s[0]
										% -- Read loop: add to prev sum, mul with 256
				3 1 roll 0			    % sign=- l-1 s Sum=0 
				0 1 5 -1 roll			% sign=- s Sum=0 0 1 l-1
				{						% sign=- s Sum idx
					2 index exch		% sign=- s Sum s idx 
					get 				% sign=- s Sum s[idx]
					add	256 mul			% sign=- s Sum=(s[idx]+Sum)*256
				}
				for
										% -- mul was once too often, weave in the sign
				256 div					% sign=- s Sum/256
				exch pop 				% sign=- Sum/256
				exch { neg } if 		% (sign=- ? -Sum : Sum) 
		  	} def

	% execute a single command, the former x and y position is already on stack
	% only offsets are read from cmdstring 
	/xcmd	{							% x y
				rcmd					% x y bool wx wy
				exch rhex				% x y bool wy Dx
				exch rhex				% x y bool Dx Dy
				exch 5 -1 roll			% y bool Dy Dx x
				add exch				% y bool X Dy
				4 -1 roll add			% bool X Y
				1 index 1 index			% bool X Y X Y
				5 -1 roll				% X Y X Y bool
				{ moveto }
				{ lineto }
				ifelse					% X Y
			} def
end

/readpath
{	
	0 0		% push initial-x initial-y 
	pathdict begin
		{ xcmd } loop 
	end
	pop pop % pop final-x final-y
} def

%
%
% if languagelevel is not in the systemdict then its level 1 interpreter:
% provide compatibility routines
%
%

systemdict /languagelevel known not
{
	% string numarray xxshow -
 	% does only work for single byte fonts
	/xshow {
		exch dup 					% a s s
		length 0 1					% a s l(s) 1 1
		3 -1 roll 1 sub				% a s 0 1 l(s)-1
		{							% a s idx
			dup 					% a s idx idx
									% -- extract the delta offset
			3 index exch get		% a s idx a[idx]
									% -- extract the character
			exch 					% a s a[idx] idx
			2 index exch get		% a s a[idx] s[idx]
									% -- create a tmp string for show
			1 string dup 0			% a s a[idx] s[idx] s1 s1 0
			4 -1 roll				% a s a[idx] s1 s1 0 s[idx]
			put						% a s a[idx] s1
									% -- store the current point
			currentpoint 3 -1 roll	% a s a[idx] x y s1
									% -- draw the character
			show					% a s a[idx] x y  
									% -- move to the offset
			moveto 0 rmoveto		% a s
		}
		for
		pop pop						% -
	} def

	% x y width height rectfill
	% x y width height rectshow
	% in contrast to the languagelevel 2 operator 
	% they use and change the currentpath
	/rectangle {
		4 -2 roll			% width height x y 
		moveto				% width height
		1 index 0 rlineto	% width height	% rmoveto(width,  0)
		0 exch rlineto		% width   		% rmoveto(0,      height)
		neg 0 rlineto 		% -  			% rmoveto(-width, 0)
		closepath
	} def 

	/rectfill   { rectangle fill   } def
	/rectstroke { rectangle stroke } def
}
if 

% -- small test program
% 75 75 moveto /Times-Roman findfont 12 scalefont setfont
% <292a2b2c2d2e2f30313233343536373839>
% [5 5 6 6 6 6 6 6 6 6 6 6 7 7 7 7 5] xshow <21>[0] xshow 
% showpage

%
%
% shortcuts for image header with compression
%
%

/psp_lzwfilter { 
    currentfile /ASCII85Decode filter /LZWDecode filter 
} def
/psp_ascii85filter { 
    currentfile /ASCII85Decode filter 
} def
/psp_lzwstring { 
    psp_lzwfilter 1024 string readstring 
} def
/psp_ascii85string { 
    psp_ascii85filter 1024 string readstring 
} def
/psp_imagedict {
    /psp_bitspercomponent { 
        3 eq 
        { 1 }
        { 8 } 
        ifelse 
    } def
    /psp_decodearray { 
        [ [0 1 0 1 0 1] [0 255] [0 1] [0 255] ] exch get 
    } def 

    7 dict dup
        /ImageType 1                    put dup
        /Width 7 -1 roll                put dup
        /Height 5 index                 put dup
        /BitsPerComponent 4 index 
            psp_bitspercomponent        put dup
        /Decode 5 -1 roll 
            psp_decodearray             put dup
        /ImageMatrix [1 0 0 1 0 0] dup 
            5 8 -1 roll put             put dup
        /DataSource 4 -1 roll 
            1 eq 
            { psp_lzwfilter } 
            { psp_ascii85filter } 
            ifelse                      put
} def


%
%
% font encoding and reencoding
%
%

/ISO1252Encoding [
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /space /exclam /quotedbl /numbersign /dollar /percent /ampersand /quotesingle
    /parenleft /parenright /asterisk /plus /comma /hyphen /period /slash
    /zero /one /two /three /four /five /six /seven
    /eight /nine /colon /semicolon /less /equal /greater /question
    /at /A /B /C /D /E /F /G
    /H /I /J /K /L /M /N /O
    /P /Q /R /S /T /U /V /W
    /X /Y /Z /bracketleft /backslash /bracketright /asciicircum /underscore
    /grave /a /b /c /d /e /f /g
    /h /i /j /k /l /m /n /o
    /p /q /r /s /t /u /v /w
    /x /y /z /braceleft /bar /braceright /asciitilde /unused
    /Euro /unused /quotesinglbase /florin /quotedblbase /ellipsis /dagger /daggerdbl
    /circumflex /perthousand /Scaron /guilsinglleft /OE /unused /Zcaron /unused
    /unused /quoteleft /quoteright /quotedblleft /quotedblright /bullet /endash /emdash
    /tilde /trademark /scaron /guilsinglright /oe /unused /zcaron /Ydieresis
    /space /exclamdown /cent /sterling /currency /yen /brokenbar /section
    /dieresis /copyright /ordfeminine /guillemotleft /logicalnot /hyphen /registered /macron
    /degree /plusminus /twosuperior /threesuperior /acute /mu /paragraph /periodcentered
    /cedilla /onesuperior /ordmasculine /guillemotright /onequarter /onehalf /threequarters /questiondown
    /Agrave /Aacute /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedilla
    /Egrave /Eacute /Ecircumflex /Edieresis /Igrave /Iacute /Icircumflex /Idieresis
    /Eth /Ntilde /Ograve /Oacute /Ocircumflex /Otilde /Odieresis /multiply
    /Oslash /Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thorn /germandbls
    /agrave /aacute /acircumflex /atilde /adieresis /aring /ae /ccedilla
    /egrave /eacute /ecircumflex /edieresis /igrave /iacute /icircumflex /idieresis
    /eth /ntilde /ograve /oacute /ocircumflex /otilde /odieresis /divide
    /oslash /ugrave /uacute /ucircumflex /udieresis /yacute /thorn /ydieresis
] def

% /fontname /encoding psp_findfont 
/psp_findfont {
    exch dup                % encoding fontname fontname 
    findfont                % encoding fontname
    dup length dict 
    begin
    {  
        1 index /FID ne
        { def }
        { pop pop }
        ifelse
    } forall
    /Encoding 3 -1 roll def
    currentdict 
    end
    /psp_reencodedfont exch definefont
} def

% bshow shows a text in artificial bold
% this is achieved by first showing the text
% then stroking its outline over it with
% the linewidth set to the second parameter
% usage: (string) num bshow

/bshow {
  currentlinewidth		% save current linewidth
  3 1 roll				% move it to the last stack position
  currentpoint			% save the current point
  3 index				% copy the string to show
  show					% show it
  moveto				% move to the original coordinates again
  setlinewidth			% set the linewidth
  false charpath		% create the outline path of the shown string
  stroke				% and stroke it
  setlinewidth			% reset the stored linewidth
} def

% bxshow shows a text with a delta array in artificial bold
% that is it does what bshow does for show
% usage: (string) [deltaarray] num bxshow

/bxshow {
  currentlinewidth		% save linewidth
  4 1 roll				% move it to the last stack position
  setlinewidth			% set the new linewidth
  exch					% exchange string and delta array
  dup
  length				% get length of string
  1 sub					% prepare parameters for {} for
  0 1
  3 -1 roll
  {
    1 string			% create a string object length 1
    2 index				% get the text
    2 index				% get charpos (for index variable)
    get					% have char value at charpos
    1 index				% prepare string for put
    exch
    0
    exch
    put					% put into string of length 1
    dup					% duplicate the it
    currentpoint		% save current position
    3 -1 roll			% prepare show
    show				% show the character
    moveto				% move back to beginning
    currentpoint		% save current position
    3 -1 roll			% prepare outline path of character
    false charpath
    stroke				% stroke it
    moveto				% move back
    % now move to next point
    2 index				% get advance array
    exch				% get charpos
    get					% get advance element
    0 rmoveto			% advance current position
  } for
  pop pop				% remove string and delta array
  setlinewidth			% restore linewidth
} def