TPostScript

class TPostScript : public TVirtualPS

    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(const 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)
                 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 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 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

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.                   
                                                                      

 Default PostScript constructor

 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

 Open a PostScript file

 Default PostScript destructor

 Close a PostScript file

 Activate an already open PostScript file

 Deactivate an already open PostScript file

 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.

 Define the markers

 Draw a Box

 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

 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.

 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.

 Draw markers at the n WC points x, y

 Draw markers at the n WC points x, y

 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.

 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.

 Draw Fill area with hatch styles

 Draw Fill area with hatch styles

 Font Reencoding

 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                            |
 +------------+------------------+-----------------------------------+

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

 Move to a new position

 Move to a new PostScript page

 Set the range for the paper in centimeters

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

 Set color index for fill areas

 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 !

 Set color index for lines

 Change the line style

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

 See TStyle::SetLineStyleString for style definition

 Change the line width

 Set color index for markers

 Set the current color.

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

 Set color index for text

 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.

 Write a string of characters in NDC

 Convert U from NDC coordinate to PostScript

 Convert V from NDC coordinate to PostScript

 Convert X from world coordinate to PostScript

 Convert Y from world coordinate to PostScript

 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&)