library: libPostscript #include "TPostScript.h"

# TPostScript

class description - source file - inheritance tree (.pdf)

## class TPostScript : public TVirtualPS

| Inheritance Chart:
`TObject`
| <- | `TNamed`
`TAttLine`
`TAttFill`
`TAttMarker`
`TAttText`
| <- | `TVirtualPS`
| <- | `TPostScript` |

        public:

                          TPostScript()
                          TPostScript(const char* filename, Int_t type = -111)
                          TPostScript(const TPostScript&)
                  virtual ~TPostScript()
             virtual void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2, Double_t y1, Double_t y2)
             virtual void CellArrayEnd()
             virtual void CellArrayFill(Int_t r, Int_t g, Int_t b)
           static TClass* Class()
             virtual void Close(Option_t* opt = "")
                    Int_t CMtoPS(Double_t u)
                     void DefineMarkers()
             virtual void DrawBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
             virtual void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt, Int_t mode, Int_t border, Int_t dark, Int_t light)
                     void DrawHatch(Float_t dy, Float_t angle, Int_t n, Float_t* x, Float_t* y)
                     void DrawHatch(Float_t dy, Float_t angle, Int_t n, Double_t* x, Double_t* y)
                     void DrawPolyLine(Int_t n, TPoints* xy)
                     void DrawPolyLineNDC(Int_t n, TPoints* uv)
             virtual void DrawPolyMarker(Int_t n, Float_t* x, Float_t* y)
             virtual void DrawPolyMarker(Int_t n, Double_t* x, Double_t* y)
             virtual void DrawPS(Int_t n, Float_t* xw, Float_t* yw)
             virtual void DrawPS(Int_t n, Double_t* xw, Double_t* yw)
                     void FontEncode()
                     void Initialize()
          virtual TClass* IsA() const
                     void MakeGreek()
                     void MovePS(Int_t x, Int_t y)
             virtual void NewPage()
                     void Off()
                     void On()
             virtual void Open(const char* filename, Int_t type = -111)
             TPostScript& operator=(const TPostScript&)
                     void Range(Float_t xrange, Float_t yrange)
                     void SaveRestore(Int_t flag)
                     void SetColor(Int_t color = 1)
             virtual void SetColor(Float_t r, Float_t g, Float_t b)
             virtual void SetFillColor(Color_t cindex = 1)
                     void SetFillPatterns(Int_t ipat, Int_t color)
             virtual void SetLineColor(Color_t cindex = 1)
                     void SetLineJoin(Int_t linejoin = 0)
                     void SetLineScale(Float_t scale = 3)
             virtual void SetLineStyle(Style_t linestyle = 1)
             virtual void SetLineWidth(Width_t linewidth = 1)
             virtual void SetMarkerColor(Color_t cindex = 1)
             virtual void SetTextColor(Color_t cindex = 1)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
             virtual void Text(Double_t x, Double_t y, const char* string)
                     void TextNDC(Double_t u, Double_t v, const char* string)
                    Int_t UtoPS(Double_t u)
                    Int_t VtoPS(Double_t v)
                    Int_t XtoPS(Double_t x)
                    Int_t YtoPS(Double_t y)
                     void Zone()

### Data Members

        protected:

               Float_t fX1v              X bottom left corner of paper
               Float_t fY1v              Y bottom left corner of paper
               Float_t fX2v              X top right corner of paper
               Float_t fY2v              Y top right corner of paper
               Float_t fX1w
               Float_t fY1w
               Float_t fX2w
               Float_t fY2w
               Float_t fDXC
               Float_t fDYC
               Float_t fXC
               Float_t fYC
               Float_t fFX
               Float_t fFY
               Float_t fXVP1
               Float_t fXVP2
               Float_t fYVP1
               Float_t fYVP2
               Float_t fXVS1
               Float_t fXVS2
               Float_t fYVS1
               Float_t fYVS2
               Float_t fXsize            Page size along X
               Float_t fYsize            Page size along Y
               Float_t fMaxsize          Largest dimension of X and Y
               Float_t fRed              Per cent of red
               Float_t fGreen            Per cent of green
               Float_t fBlue             Per cent of blue
               Float_t fLineScale        Line width scale factor
                 Int_t fLineJoin         Appearance of joining lines
                 Int_t fSave             Number of gsave for restore
                 Int_t fNXzone           Number of zones along X
                 Int_t fNYzone           Number of zones along Y
                 Int_t fIXzone           Current zone along X
                 Int_t fIYzone           Current zone along Y
               Float_t fMarkerSizeCur    current transformed value of marker size
                 Int_t fCurrentColor     current Postscript color index
                 Int_t fNpages           number of pages
                 Int_t fType             PostScript workstation type
                 Int_t fMode             PostScript mode
                 Int_t fClip             Clipping mode
                Bool_t fBoundingBox      True for Encapsulated PostScript
                Bool_t fClear            True when page must be cleared
                Bool_t fClipStatus       Clipping Indicator
                Bool_t fRange            True when a range has been defined
                Bool_t fZone             Zone indicator
                  char fPatterns[32]     Indicate if pattern n is defined
                 Int_t fNbinCT           Number of entries in the current Cell Array
                 Int_t fNbCellW          Number of boxes per line
                 Int_t fNbCellLine       Number of boxes in the current line
                 Int_t fMaxLines         Maximum number of lines in a PS array
                 Int_t fLastCellRed      Last red value
                 Int_t fLastCellGreen    Last green value
                 Int_t fLastCellBlue     Last blue value
                 Int_t fNBSameColorCell  Number of boxes with the same color
          static Int_t fgLineJoin        Appearance of joining lines

## Class Description

     TPostScript

     Graphics interface to PostScript.

     This code was initially developed in the context of HIGZ and PAW
     by Olivier Couet and Pierre Juillot.
     It has been converted to a C++ class by Rene Brun.

/*

To generate a Postscript (or encapsulated ps) file corresponding to a single image in a canvas, you can:

- Select the Print PostScript item in the canvas File menu. By default, a Postscript file with the name of the canvas.ps is generated.
- Click in the canvas area, near the edges, with the right mouse button and select the Print item. You can select the name of the Postscript file. If the file name is xxx.ps, you will generate a Postscript file named xxx.ps. If the file name is xxx.eps, you generate an encapsulated Postscript file instead.
- In your program (or macro), you can type:

       c1->Print("xxx.ps") or c1->Print("xxx.eps")

      This will generate a file corresponding to the picture in the canvas
      pointed by c1.

     pad1->Print("xxx.ps")

    prints only the picture in the pad pointed by pad1. The size
    of the Postscript picture, by default, is computed to keep the aspect ratio
    of the picture on the screen, where the size along x is always 20cm. You
    can set the size of the PostScript picture before generating the picture
    with a command such as:

       TPostScript myps("myfile.ps",111)
       myps.Range(xsize,ysize);
       object->Draw();
       myps.Close();

    You can set the default paper size with:

       gStyle->SetPaperSize(xsize,ysize);

    You can resume writing again in this file with myps.Open();.
    Note that you may have several Postscript files opened simultaneously.

## Special characters

The following characters have a special action on the Postscript file:

           `   : go to Greek
           '   : go to special
           ~   : go to ZapfDingbats
           ?   : go to subscript
           ^   : go to superscript
           !   : go to normal level of script
           &   : backspace one character
           #   : end of Greek or of ZapfDingbats

These special characters are printed as such on the screen. To generate one of these characters on the Postscript file, you must escape it with the escape character "@".

The use of these special characters is illustrated in several macros referenced by the TPostScript constructor.

## Output type

The output type allows to define how the PostScript output will looks like. It allows to define the page format (A4, Legal etc..), the orientation (Portrait, Landscape) and the number of images (zones) per page. The output type has the following form:

                            [Format][Nx][Ny][Type]

Where:

- Format : Is an integer between 0 and 99 defining the page format. Example:
  Format = 3 the paper is in the standard A3 format.
  Format = n (1 Format = 4 and Format=0 are the same and define an A4 page.
  The A0 format is selected by Format=99.
  The US format Letter is selected by Format = 100.
  The US format Legal is selected by Format = 200.
  The US format Ledger is selected by Format = 300.
- Nx, Ny : Specify respectively the number of zones on the x and y axis. Nx and Ny are integers between 1 and 9.
- Type : Can be equal to:
  - 1 : Portrait mode with a small margin at the bottom of the page.
  - 2 : Landscape mode with a small margin at the bottom of the page.
  - 4 : Portrait mode with a large margin at the bottom of the page.
  - 5 : Landscape mode with a large margin at the bottom of the page. The large margin is useful for some PostScript printers (very often for the colour printers) as they need more space to grip the paper for mechanical reasons. Note that some PostScript colour printers can also use the so called special A4 format permitting the full usage of the A4 area; in this case larger margins are not necessary and Type=1 or 2 can be used.
  - 3 : Encapsulated PostScript. This Type permits the generation of files which can be included in other documents, for example in LaTeX files.

## Making several pictures in the same Postscript file: case 1

The following macro is an example illustrating how to open a Postscript file and draw several pictures. The generation of a new Postscript page is automatic when TCanvas::Clear is called by object->Draw().

    {
       TFile f("hsimple.root");
       TCanvas c1("c1","canvas",800,600);

       // select postscript output type
       // type = 111   portrait  ps
       // type = 112   landscape ps
       // type = 113   eps
       Int_t type = 111;

       // create a postscript file and set the paper size
       TPostScript ps("test.ps",type);
       ps.Range(16,24);  //set x,y of printed page

       // draw 3 histograms from file hsimple.root on separate pages
       hpx->Draw();
       c1.Update();      //force drawing in a macro
       hprof->Draw();
       c1.Update();
       hpx->Draw("lego1");
       c1.Update();
       ps.Close();
    }

## Making several pictures in the same Postscript file: case 2

This example shows 2 pages. The canvas is divided. TPostScript::NewPage must be called before starting a new picture. object->Draw does not clear the canvas in this case because we clear only the pads and not the main canvas. Note that c1->Update must be called at the end of the first picture

    {
       TFile *f1 = new TFile("hsimple.root");
       TCanvas *c1 = new TCanvas("c1");
       TPostScript *ps = new TPostScript("file.ps",112);
       c1->Divide(2,1);
    // picture 1
       ps->NewPage();
       c1->cd(1);
       hpx->Draw();
       c1->cd(2);
       hprof->Draw();
       c1->Update();

    // picture 2
       ps->NewPage();
       c1->cd(1);
       hpxpy->Draw();
       c1->cd(2);
       ntuple->Draw("px");
       c1->Update();
       ps->Close();

    // invoke Postscript viewer
       gSystem->Exec("gs file.ps");
    }

*/

     The picture below shows fancy text with national accents or
     subscripts and superscripts. This picture has been generated by
     the macro

psexam.

         The two following tables list the correspondence between the typed
         character and its interpretation using the special characters given
         in TPostScript::Text. These tables are screen copies. True and better
         resolution PostScript files can be seen at

psexam, pstable1 and pstable2.

     The macro

pstable

     has been used to generate the two PostScript tables.

TPostScript() : TVirtualPS()

     Default PostScript constructor

TPostScript(const char *fname, Int_t wtype) :TVirtualPS(fname, wtype)

     Initialize the PostScript interface

      fname : PostScript file name
      wtype : PostScript workstation type

      The possible workstation types are:
         111 ps  Portrait
         112 ps  Landscape
         113 eps

void Open(const char *fname, Int_t wtype)

     Open a PostScript file

~TPostScript()

     Default PostScript destructor

void Close(Option_t *)

     Close a PostScript file

void On()

     Activate an already open PostScript file

void Off()

     Deactivate an already open PostScript file

void CellArrayBegin(Int_t W, Int_t /*H*/, Double_t x1, Double_t x2, Double_t y1, Double_t y2)

     Draw a Cell Array

     Drawing a PostScript Cell Array is in fact done thanks to three
     procedures: CellArrayBegin, CellArrayFill, and CellArrayEnd.

     CellArrayBegin: Initiate the Cell Array by writing the necessary
                     PostScript procedures and the initial values of the
                     required parameters. The input parameters are:
                     W: number of boxes along the width.
                     H: number of boxes along the height
                     x1,x2,y1,y2: First box coordinates.
     CellArrayFill:  Is called for each box of the Cell Array. The first
                     box is the top left one and the last box is the
                     bottom right one. The input parameters are the Red,
                     Green, and Blue components of the box colour. These
                     Levels are between 0 and 255.
     CellArrayEnd:   Finishes the Cell Array.

     PostScript cannot handle arrays larger than 65535. So the Cell Array
     is drawn in several pieces.

void CellArrayFill(Int_t r, Int_t g, Int_t b)

void CellArrayEnd()

void DefineMarkers()

     Define the markers

void DrawBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2)

     Draw a Box

void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt, Int_t mode, Int_t border, Int_t dark, Int_t light)

     Draw a Frame around a box

     mode = -1  box looks as it is behind the screen
     mode =  1  box looks as it is in front of the screen
     border is the border size in already precomputed PostScript units
     dark  is the color for the dark part of the frame
     light is the color for the light part of the frame

void DrawPolyLine(Int_t nn, TPoints *xy)

     Draw a PolyLine

      Draw a polyline through  the points xy.
      If nn=1 moves only to point x,y.
      If nn=0 the x,y are  written  in the PostScript file
              according to the current transformation.
      If nn>0 the line is clipped as a line.
      If nn<0 the line is clipped as a fill area.

void DrawPolyLineNDC(Int_t nn, TPoints *xy)

     Draw a PolyLine in NDC space

      Draw a polyline through the points xy.
      If nn=1 moves only to point x,y.
      If nn=0 the x,y are  written  in the PostScript file
              according to the current transformation.
      If nn>0 the line is clipped as a line.
      If nn<0 the line is clipped as a fill area.

void DrawPolyMarker(Int_t n, Float_t *x, Float_t *y)

     Draw markers at the n WC points x, y

void DrawPolyMarker(Int_t n, Double_t *x, Double_t *y)

     Draw markers at the n WC points x, y

void DrawPS(Int_t nn, Float_t *xw, Float_t *yw)

     Draw a PolyLine

      Draw a polyline through the points xw,yw.
      If nn=1 moves only to point xw,yw.
      If nn=0 the XW(1) and YW(1) are  written  in the PostScript file
              according to the current NT.
      If nn>0 the line is clipped as a line.
      If nn<0 the line is clipped as a fill area.

void DrawPS(Int_t nn, Double_t *xw, Double_t *yw)

     Draw a PolyLine

     Draw a polyline through  the points xw,yw.
     If nn=1 moves only to point xw,yw.
     If nn=0 the xw(1) and YW(1) are  written  in the PostScript file
             according to the current NT.
     If nn>0 the line is clipped as a line.
     If nn<0 the line is clipped as a fill area.

void DrawHatch(Float_t, Float_t, Int_t, Float_t *, Float_t *)

     Draw Fill area with hatch styles

void DrawHatch(Float_t, Float_t, Int_t, Double_t *, Double_t *)

     Draw Fill area with hatch styles

void FontEncode()

     Font Reencoding

void Initialize()

     PostScript Initialisation

     This routine initialize the following PostScript procedures:

     +------------+------------------+-----------------------------------+
     | Macro Name | Input parameters |            Explanation            |
     +------------+------------------+-----------------------------------+
     |     l      | x y              | Draw a line to the x y position   |
     +------------+------------------+-----------------------------------+
     |     m      | x y              | Move to the position x y          |
     +------------+------------------+-----------------------------------+
     |     box    | dx dy x y        | Define a box                      |
     +------------+------------------+-----------------------------------+
     |     bl     | dx dy x y        | Draw a line box                   |
     +------------+------------------+-----------------------------------+
     |     bf     | dx dy x y        | Draw a filled box                 |
     +------------+------------------+-----------------------------------+
     |     sw     | text             | Return string width of text       |
     +------------+------------------+-----------------------------------+
     |     t      | x y              | Translate                         |
     +------------+------------------+-----------------------------------+
     |     r      | angle            | Rotate                            |
     +------------+------------------+-----------------------------------+
     |     rl     | i j              | Roll the stack                    |
     +------------+------------------+-----------------------------------+
     |     d      | x y              | Draw a relative line to x y       |
     +------------+------------------+-----------------------------------+
     |     X      | x                | Draw a relative line to x (y=0)   |
     +------------+------------------+-----------------------------------+
     |     Y      | y                | Draw a relative line to y (x=0)   |
     +------------+------------------+-----------------------------------+
     |     rm     | x y              | Move relatively to x y            |
     +------------+------------------+-----------------------------------+
     |     gr     |                  | Restore the graphic context       |
     +------------+------------------+-----------------------------------+
     |     lw     | lwidth           | Set line width to lwidth          |
     +------------+------------------+-----------------------------------+
     |     sd     | [] 0             | Set dash line define by []        |
     +------------+------------------+-----------------------------------+
     |     s      |                  | Stroke mode                       |
     +------------+------------------+-----------------------------------+
     |     c      | r g b            | Set rgb color to r g b            |
     +------------+------------------+-----------------------------------+
     |     cl     |                  | Close path                        |
     +------------+------------------+-----------------------------------+
     |     f      |                  | Fill the last describe path       |
     +------------+------------------+-----------------------------------+
     |     mXX    | x y              | Draw the marker type XX at (x,y)  |
     +------------+------------------+-----------------------------------+
     |     Zone   | ix iy            | Define the current zone           |
     +------------+------------------+-----------------------------------+
     |     black  |                  | The color is black                |
     +------------+------------------+-----------------------------------+
     |     C      | dx dy x y        | Clipping on                       |
     +------------+------------------+-----------------------------------+
     |     NC     |                  | Clipping off                      |
     +------------+------------------+-----------------------------------+
     |     R      |                  | repeat                            |
     +------------+------------------+-----------------------------------+

void MakeGreek()

     Reencode the Greek (/Symbol) font into the special font (/Special)

void MovePS(Int_t ix, Int_t iy)

     Move to a new position

void NewPage()

     Move to a new PostScript page

void Range(Float_t xsize, Float_t ysize)

     Set the range for the paper in centimeters

void SaveRestore(Int_t flag)

     Compute number of gsaves for restore
     This allows to write the correct number of grestore at the
     end of the PS file.

void SetFillColor( Color_t cindex )

     Set color index for fill areas

void SetFillPatterns(Int_t ipat, Int_t color)

     Patterns definition

     Define the pattern ipat in the current PS file. ipat can vary from
     1 to 25. Together with the pattern, the color (color) in which the
     pattern has to be drawn is also required. A pattern is defined in the
     current PS file only the first time it is used. Some level 2
     Postscript functions are used, so on level 1 printers, patterns will
     not work. This is not a big problem because patterns are
     defined only if they are used, so if they are not used a PS level 1
     file will not be polluted by level 2 features, and in any case the old
     patterns used a lot of memory which made them almost unusable on old
     level 1 printers. Finally we should say that level 1 devices are
     becoming very rare. The official PostScript is now level 3 !

void SetLineColor( Color_t cindex )

     Set color index for lines

void SetLineJoin( Int_t linejoin )

     Set the value of the global parameter TPostScript::fgLineJoin.
     This parameter determines the appearance of joining lines in a PostScript
     output.
     It takes one argument which may be:
       - 0 (miter join)
       - 1 (round join)
       - 2 (bevel join)
     The default value is 0 (miter join).

/* */

     To change the line join behaviour just do:
     TPostScript::SetLineJoin(2); // Set the PS line join to bevel.

void SetLineStyle(Style_t linestyle)

     Change the line style

       linestyle = 2 dashed
                 = 3  dotted
                 = 4  dash-dotted
                  else = solid

     See TStyle::SetLineStyleString for style definition

void SetLineWidth(Width_t linewidth)

     Change the line width

void SetMarkerColor( Color_t cindex )

     Set color index for markers

void SetColor(Int_t color)

     Set the current color.

void SetColor(Float_t r, Float_t g, Float_t b)

     Set directly current color (don't go via TColor).

void SetTextColor( Color_t cindex )

     Set color index for text

void Text(Double_t xx, Double_t yy, const char *chars)

     Write a string of characters

     This routine writes the string chars into a PostScript file
     at position xx,yy in world coordinates.

     Note the special action of the following special characters:

           ` : go to Greek
           ' : go to special
           ~ : go to ZapfDingbats
           ? : go to subscript
           ^ : go to superscript
           ! : go to normal level of script
           & : backspace one character
           # : end of Greek or of ZapfDingbats

     Note1: This special characters have no effect on the screen.
     Note2: To print one of the characters above in the Postscript file
            use the escape character "@" in front of the character.

void TextNDC(Double_t u, Double_t v, const char *chars)

     Write a string of characters in NDC

Int_t UtoPS(Double_t u)

     Convert U from NDC coordinate to PostScript

Int_t VtoPS(Double_t v)

     Convert V from NDC coordinate to PostScript

Int_t XtoPS(Double_t x)

     Convert X from world coordinate to PostScript

Int_t YtoPS(Double_t y)

     Convert Y from world coordinate to PostScript

void Zone()

     Initialize the PostScript page in zones

### Inline Functions

                   Int_t CMtoPS(Double_t u)
                    void SetLineScale(Float_t scale = 3)
                 TClass* Class()
                 TClass* IsA() const
                    void ShowMembers(TMemberInspector& insp, char* parent)
                    void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
             TPostScript TPostScript(const TPostScript&)
            TPostScript& operator=(const TPostScript&)

Author: Rene Brun, Olivier Couet, Pierre Juillot 29/11/94
Last update: root/postscript:$Name: $:$Id: TPostScript.cxx,v 1.56 2005/05/18 10:28:08 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *