library: libPostscript #include "TPostScript.h" |
TPostScript
class description - source file - inheritance tree (.pdf)
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()
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
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.
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.51 2004/04/19 13:41:51 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.