path: root/src/gui/painting/qpsprinter.ps

% the postscript header we use for our qpsprinter in uncompressed and commented form.
% use the makepsheader perl script to generate a compressed version of this header
% you can then paste into qpsprinter.cpp
%
% some compression of the code is done by the makepsheader script, so we don't need to 
% write too criptically here. 

/BD  {bind def} bind def
/d2 {dup dup} BD
/ED {exch def} BD
/D0 {0 ED} BD

/F  {setfont} BD
/RL {rlineto} BD
/CM {currentmatrix} BD
/SM {setmatrix} BD
/TR {translate} BD
/SD {setdash} BD
/SC {aload pop setrgbcolor} BD
/CR {currentfile read pop} BD
/i  {index} BD
/scs {setcolorspace} BD
/DB {dict dup begin} BD
/DE {end def} BD
/ie {ifelse} BD
/gs {gsave} BD
/gr {grestore} BD

% these use PDF syntax
/w {setlinewidth} BD
/d {setdash} BD
/J {setlinecap} BD
/j {setlinejoin} BD
/scn {3 array astore /BCol exch def} BD
/SCN {3 array astore /PCol exch def} BD
/cm {6 array astore concat} BD

/m  {moveto} BD
/l  {lineto} BD
/c  {curveto} BD
/h  {closepath} BD

/W  {clip} BD
/W* {eoclip} BD
/n {newpath} BD
% ENDUNCOMPRESSED: Warning: leave this line in. 
% Everything before this line will be left untouched by the compression

/q  {gsave 10 dict begin} BD
/Q  {end grestore} BD

% PDF operators
/re { % PDF re operator
  4 2 roll  % w h x y
  moveto % w h
  dup % w h h
  0 exch rlineto % w h
  exch 0 rlineto % h
  0 exch neg rlineto
  closepath
} bind def

/S {
  gsave
    PCol SC stroke
  grestore
  newpath
} BD

% PDF text operators
/BT {gsave 10 dict begin /_m matrix currentmatrix def BCol SC} BD
/ET {end grestore} BD
/Tf {
  /_fs exch def
  findfont
  [ _fs 0 0 _fs 0 0 ]  
  makefont
  setfont
} BD
/Tm {6 array astore concat} BD
/Td {translate} BD
/Tj {0 0 moveto show} BD
/BDC {pop pop} BD
/EMC {} BD

% old operators

/BSt 0 def                             % brush style
/WFi false def                 % winding fill

/BCol  [ 1 1 1 ] def                   % brush color
/PCol  [ 0 0 0 ] def                   % pen color
/BDArr [                             % Brush dense patterns
  0.94
  0.88
  0.63
  0.50
  0.37 
  0.12 
  0.06 
] def

% -- level3 true/false
/level3 {
  /languagelevel where {
    pop
    languagelevel 3 ge 
  } { false } ifelse
} bind def


%% image drawing routines

% defines for QCI
/QCIgray D0 /QCIcolor D0 /QCIindex D0

% this method prints color images if colorimage is available, otherwise
% converts the string to a grayscale image and uses the reular postscript image
% operator for printing.
% Arguments are the same as for the image operator:
% 
%     width height bits/sample matrix datasrc QCI -
/QCI {
  /colorimage where {
    pop
    false 3 colorimage
  }{  % the hard way, based on PD code by John Walker <kelvin@autodesk.com>
    exec /QCIcolor exch def
    /QCIgray QCIcolor length 3 idiv string def
    0 1 QCIcolor length 3 idiv 1 sub
    { /QCIindex exch def
      /_x QCIindex 3 mul def
      QCIgray QCIindex
      QCIcolor _x       get 0.30 mul
      QCIcolor _x 1 add get 0.59 mul
      QCIcolor _x 2 add get 0.11 mul
      add add cvi
      put
    } for
    QCIgray image
  } ifelse
} bind def

% general image drawing routine, used from the postscript driver
%
% Draws images with and without mask with 1, 8 and 24(rgb) bits depth.
%
%     width height matrix image 1|8|24 mask|false x y di
%
% width and height specify the width/height of the image,
% matrix a transformation matrix, image a procedure holding the image data
% (same for mask) and x/y an additional translation.
%
% ### should move the translation into the matrix!!!
/di 
{
  gsave
    translate
    1 index 1 eq { % bitmap
      pop pop % get rid of mask and depth
      false 3 1 roll % width height false matrix image
      BCol SC
      imagemask
    } { 
      dup false ne { 
	% have a mask, see if we can use it
	level3
      } { 
	false 
      } ifelse

      {
	% languagelevel3, we can use image mask and dicts

	% store the image mask
	/_ma exch def
	% select colorspace according to 8|24 bit depth and set the decode array /dc
	8 eq {
	  /_dc [0 1] def
	  /DeviceGray
	} {
	  /_dc [0 1 0 1 0 1] def
	  /DeviceRGB
	} ifelse
	setcolorspace
	% the image data
	/_im exch def
	% transformation matrix
	/_mt exch def
	% width and height
	/_h exch def
	/_w exch def
	% and the combined image dict
	<<
	  /ImageType 3
	  % the image dict
	  /DataDict <<
              /ImageType 1
	      /Width _w
	      /Height _h
	      /ImageMatrix _mt
	      /DataSource _im
	      /BitsPerComponent 8
	      /Decode _dc
	  >> 
	  % the mask dictionary
	  /MaskDict <<
             /ImageType 1
	     /Width _w
	     /Height _h
	     /ImageMatrix _mt
	     /DataSource _ma
	     /BitsPerComponent 1
	     /Decode [0 1]
	  >> 
	  /InterleaveType 3
	>> 
	image
      } {
	pop % no mask or can't use it, get rid of it
	8 % width height image 8|24 8 matrix
	4 1 roll
	8 eq { % grayscale
	  image
	} { %color
	  QCI
	} ifelse
      } ifelse
    } ifelse
  grestore    
} bind def


/BF {                                % brush fill
  gsave
    BSt 1 eq                          % solid brush?
    {
      BCol SC
      WFi { fill } { eofill } ifelse
    } if
    BSt 2 ge BSt 8 le and             % dense pattern?
    {
      BDArr BSt 2 sub get /_sc exch def 
      % the following line scales the brush color according to the pattern. the higher the pattern the lighter the color.
      BCol 
      { 
	1. exch sub _sc mul 1. exch sub 
      } forall 
      3 array astore
      SC 
      WFi { fill } { eofill } ifelse
    } if
    BSt 9 ge BSt 14 le and            % brush pattern?
    {
      WFi { clip } { eoclip } ifelse
      pathbbox                        % left upper right lower
      3 index 3 index translate
      4 2 roll                        % right lower left upper
      3 2 roll                        % right left upper lower
      exch                            % left right lower upper
      sub /_h exch def
      sub /_w exch def
      BCol SC
      0.3 setlinewidth
      newpath
      BSt 9 eq BSt 11 eq or           % horiz or cross pattern
      { 0 4 _h
	{ dup 0 exch moveto _w exch lineto } for
      } if
      BSt 10 eq BSt 11 eq or          % vert or cross pattern
      { 0 4 _w
	{ dup 0 moveto _h lineto } for
      } if
      BSt 12 eq BSt 14 eq or          % F-diag or diag cross
      { _w _h gt
	{ 0 6 _w _h add
	  { dup 0 moveto _h sub _h lineto } for
	} { 0 6 _w _h add
	  { dup 0 exch moveto _w sub _w exch lineto } for
	} ifelse
      } if
      BSt 13 eq BSt 14 eq or          % B-diag or diag cross
      { _w _h gt
	{ 0 6 _w _h add
	  { dup _h moveto _h sub 0 lineto } for
	} { 0 6 _w _h add
	  { dup _w exch moveto _w sub 0 exch lineto } for
	} ifelse
      } if
      stroke
    } if
    BSt 15 eq
    {
    } if
    BSt 24 eq                         % TexturePattern
    {
    } if
  grestore
} bind def

% more PDF operators
/f { /WFi true def BF newpath } bind def
/f* { /WFi false def BF newpath } bind def
/B { /WFi true def BF S newpath } bind def
/B* { /WFi false def BF S newpath } bind def

%% start of page
/QI {
  /C save def
  pageinit
  q
  newpath
} bind def

%% end of page
/QP {
  Q                                % show page
  C restore
  showpage
} bind def

% merges one key value pair into the page device dict
%
%    key value SPD -
/SPD {
  /setpagedevice where {
    << 3 1 roll >>
    setpagedevice
  } { pop pop } ifelse
} bind def


% font handling

/T1AddMapping { % basefont [glyphname ...] T1AddMapping -
  10 dict begin
    /glyphs exch def
    /fnt exch def
    /current fnt /NumGlyphs get def
    /CMap fnt /CMap get def

    0 1 glyphs length 1 sub % 0 1 (num glyphs - 1)
    {
      glyphs exch get /gn exch def

      current dup                                 % glyph_index glyph_index
      256 mod /min exch def                       % glyph_index
      256 idiv /maj exch def                      % -
      CMap dup maj get dup                        % cmap cmap_maj cmap_maj
      null eq {
	pop 256 array 
	0 1 255 {1 index exch /.notdef put} for
      } if
      dup                                         % cmap cmap_maj cmap_maj
      min gn put                                  % cmap cmap_maj
      maj exch put                                % -

      /current current 1 add def
    } for

    fnt /CMap CMap put
    fnt /NumGlyphs current put
  end 
} def

/T1AddGlyphs { % basefont [glyphname charstring ...] T1AddGlyphs -
  10 dict begin
    /glyphs exch def
    /fnt exch def
    /current fnt /NumGlyphs get def
    /CMap fnt /CMap get def
    /CharStrings fnt /CharStrings get def

    0 1 glyphs length 2 idiv 1 sub % 0 1 (num glyphs - 1)
    {
      2 mul dup
      glyphs exch get /gn exch def
      1 add
      glyphs exch get /cs exch def

      current dup                                 % glyph_index glyph_index
      256 mod /min exch def                       % glyph_index
      256 idiv /maj exch def                      % -
      CMap dup maj get dup                        % cmap cmap_maj cmap_maj
      null eq {
	pop 256 array 
	0 1 255 {1 index exch /.notdef put} for
      } if
      dup                                         % cmap cmap_maj cmap_maj
      min gn put                                  % cmap cmap_maj
      maj exch put                                % -

      CharStrings gn cs put
      /current current 1 add def
    } for

    fnt /CharStrings CharStrings put
    fnt /CMap CMap put
    fnt /NumGlyphs current put
  end 
} def



/StringAdd { % string1 string2 stringadd result
  1 index length 1 index length add
  string
  3 1 roll
  2 index 0 3 index putinterval
  2 index 2 index length 2 index putinterval 
  pop pop
} def


/T1Setup { % fontname T1Setup -
10 dict begin
  dup /FontName exch def
  (-Base) StringAdd cvx cvn /Font exch def
  /MaxPage Font /NumGlyphs get 1 sub 256 idiv def

  /FDepVector MaxPage 1 add array def
  /Encoding MaxPage 1 add array def

  0 1 MaxPage {
    dup Encoding exch dup put
 

    dup /Page exch def
    FontName (-) StringAdd 
    exch 
    20 string cvs StringAdd % page fontname
    cvn

    Font 0 dict copy dup dup /CMap get 
    Page get 
    /Encoding exch put definefont 
    FDepVector exch Page exch put
  } for 

  FontName cvn <<
    /FontType 0
    /FMapType 2
    /FontMatrix[1 0 0 1 0 0]
    /Encoding Encoding
    /FDepVector FDepVector
    >> definefont pop
  end
} def