TPad*¶
继承 TVirtualPad, TAttBBox2D
The most important graphics class in the ROOT system.
A Pad is contained in a Canvas.
A Pad may contain other pads (unlimited pad hierarchy).
A pad is a linked list of primitives of any type (graphics objects, histograms, detectors, tracks, etc.).
Adding a new element into a pad is in general performed by the Draw member function of the object classes.
It is important to realize that the pad is a linked list of references to the original object. For example, in case of a histogram, the histogram.Draw() operation only stores a reference to the histogram object and not a graphical representation of this histogram. When the mouse is used to change (say the bin content), the bin content of the original histogram is changed.
The convention used in ROOT is that a Draw operation only adds a reference to the object. The effective drawing is performed when the canvas receives a signal to be painted.
In ExecuteEvent, move, changes can be performed on the object.
For examples of DistancetoPrimitive and ExecuteEvent functions, see classes
TLine::DistancetoPrimitive, TLine::ExecuteEvent
TBox::DistancetoPrimitive, TBox::ExecuteEvent
TH1::DistancetoPrimitive, TH1::ExecuteEvent
A Pad supports linear and log scales coordinate systems. The transformation coefficients are explained in TPad::ResizePad.
class¶
// TPad status bits
enum {
kFraming = BIT(6),
kHori = BIT(9),
kClipFrame = BIT(10),
kPrintingPS = BIT(11),
kCannotMove = BIT(12),
kClearAfterCR = BIT(14)
};
TPad();
TPad(const char *name, const char *title, Double_t xlow,
Double_t ylow, Double_t xup, Double_t yup,
Color_t color=-1, Short_t bordersize=-1, Short_t bordermode=-2);
/// Pad constructor.
/// A pad is a linked list of primitives.
/// A pad is contained in a canvas. It may contain other pads.
/// A pad has attributes. When a pad is created, the attributes
/// defined in the current style are copied to the pad attributes.
/// \param[in] name pad name
/// \param[in] title pad title
/// \param[in] xlow [0,1] is the position of the bottom left point of the pad
/// expressed in the mother pad reference system
/// \param[in] ylow [0,1] is the Y position of this point.
/// \param[in] xup [0,1] is the x position of the top right point of the pad
/// expressed in the mother pad reference system
/// \param[in] yup [0,1] is the Y position of this point.
/// \param[in] color pad color
/// \param[in] bordersize border size in pixels
/// \param[in] bordermode border mode
/// - bordermode = -1 box looks as it is behind the screen
/// - bordermode = 0 no special effects
/// - bordermode = 1 box looks as it is in front of the screen
virtual ~TPad();
void AbsCoordinates(Bool_t set) { fAbsCoord = set; }
Double_t AbsPixeltoX(Int_t px) {return fAbsPixeltoXk + px*fPixeltoX;}
Double_t AbsPixeltoY(Int_t py) {return fAbsPixeltoYk + py*fPixeltoY;}
virtual void AbsPixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y);
virtual void AddExec(const char *name, const char *command);
/// Add a new TExec object to the list of Execs.
/// When an event occurs in the pad (mouse click, etc) the list of C++ commands
/// in the list of Execs are executed via TPad::AutoExec.
/// When a pad event occurs (mouse move, click, etc) all the commands
/// contained in the fExecs list are executed in the order found in the list.
/// This facility is activated by default. It can be deactivated by using
/// the canvas "Option" menu.
/// When moving the mouse in the canvas, a second canvas shows the
/// projection along X of the bin corresponding to the Y position
/// of the mouse. The resulting histogram is fitted with a gaussian.
/// A "dynamic" line shows the current bin position in Y.
/// This more elaborated example can be used as a starting point
/// to develop more powerful interactive applications exploiting the C++
/// interpreter as a development engine.
virtual void AutoExec();/// Execute the list of Execs when a pad event occurs.
virtual void Browse(TBrowser *b);/// Browse pad.
virtual TLegend *BuildLegend(Double_t x1=0.5, Double_t y1=0.67, Double_t x2=0.88, Double_t y2=0.88, const char *title=""); // *MENU*
/// Build a legend from the graphical objects in the pad
/// A simple method to build automatically a TLegend from the
/// primitives in a TPad. Only those deriving from TAttLine,
/// TAttMarker and TAttFill are added, excluding TPave and TFrame
/// derived classes. x1, y1, x2, y2 are the TLegend coordinates.
/// title is the legend title. By default it is " ". The caller
/// program owns the returned TLegend.
/// If the pad contains some TMultiGraph or THStack the individual
/// graphs or histograms in them are added to the TLegend.
TVirtualPad* cd(Int_t subpadnumber=0); // *MENU*
/// Set Current pad.
/// When a canvas/pad is divided via TPad::Divide, one can directly
/// set the current path to one of the subdivisions.
/// See TPad::Divide for the convention to number sub-pads.
/// Returns the new current pad, or 0 in case of failure.
/// Note1: c1.cd() is equivalent to c1.cd(0) and sets the current pad
/// to c1 itself.
/// Note2: after a statement like c1.cd(6), the global variable gPad
/// points to the current pad. One can use gPad to set attributes
/// of the current pad.
/// Note3: One can get a pointer to one of the sub-pads of pad with:
/// TPad *subpad = (TPad*)pad->GetPad(subpadnumber);
void Clear(Option_t *option="");
/// Delete all pad primitives.
/// If the bit kClearAfterCR has been set for this pad, the Clear function
/// will execute only after having pressed a CarriageReturn
/// Set the bit with mypad->SetBit(TPad::kClearAfterCR)
virtual Int_t Clip(Float_t *x, Float_t *y, Float_t xclipl, Float_t yclipb, Float_t xclipr, Float_t yclipt);
/// Clipping routine: Cohen Sutherland algorithm.
/// - If Clip ==2 the segment is outside the boundary.
/// - If Clip ==1 the segment has one point outside the boundary.
/// - If Clip ==0 the segment is inside the boundary.
/// \param[in] x[],y[] Segment coordinates (2 points)
/// \param[in] xclipl,yclipb,xclipr,yclipt Clipping boundary
/// \param[out] x[],y[] New segment coordinates( 2 points)
virtual Int_t Clip(Double_t *x, Double_t *y, Double_t xclipl, Double_t yclipb, Double_t xclipr, Double_t yclipt);
/// Clipping routine: Cohen Sutherland algorithm.
/// - If Clip ==2 the segment is outside the boundary.
/// - If Clip ==1 the segment has one point outside the boundary.
/// - If Clip ==0 the segment is inside the boundary.
/// \param[in] x[],y[] Segment coordinates (2 points)
/// \param[in] xclipl,yclipb,xclipr,yclipt Clipping boundary
/// \param[out] x[],y[] New segment coordinates(2 points)
virtual Int_t ClippingCode(Double_t x, Double_t y, Double_t xcl1, Double_t ycl1, Double_t xcl2, Double_t ycl2);/// Compute the endpoint codes for TPad::Clip.
virtual Int_t ClipPolygon(Int_t n, Double_t *x, Double_t *y, Int_t nn, Double_t *xc, Double_t *yc, Double_t xclipl, Double_t yclipb, Double_t xclipr, Double_t yclipt);
/// Clip polygon using the Sutherland-Hodgman algorithm.
/// \param[in] n Number of points in the polygon to
/// be clipped
/// \param[in] x[n],y[n] Polygon do be clipped vertices
/// \param[in] xclipl,yclipb,xclipr,yclipt Clipping boundary
/// \param[out] nn Number of points in xc and yc
/// \param[out] xc,yc Clipped polygon vertices. The Int_t
/// returned by this function is
/// the number of points in the clipped
/// polygon. These vectors must
/// be allocated by the calling function.
/// A size of 2*n for each is
/// enough.
/// Sutherland and Hodgman's polygon-clipping algorithm uses a divide-and-conquer
/// strategy: It solves a series of simple and identical problems that, when
/// combined, solve the overall problem. The simple problem is to clip a polygon
/// against a single infinite clip edge. Four clip edges, each defining one boundary
/// of the clip rectangle, successively clip a polygon against a clip rectangle.
///
/// Steps of Sutherland-Hodgman's polygon-clipping algorithm:
/// * Polygons can be clipped against each edge of the window one at a time.
/// Windows/edge intersections, if any, are easy to find since the X or Y coordinates
/// are already known.
/// * Vertices which are kept after clipping against one window edge are saved for
/// clipping against the remaining edges.
/// * Note that the number of vertices usually changes and will often increases.
/// The clip boundary determines a visible and invisible region. The edges from
/// vertex i to vertex i+1 can be one of four types:
/// * Case 1 : Wholly inside visible region - save endpoint
/// * Case 2 : Exit visible region - save the intersection
/// * Case 3 : Wholly outside visible region - save nothing
/// * Case 4 : Enter visible region - save intersection and endpoint
virtual void Close(Option_t *option="");
/// Delete all primitives in pad and pad itself.
/// Pad cannot be used anymore after this call.
/// Emits signal Closed().
virtual void Closed() { Emit("Closed()"); } // *SIGNAL*
virtual void CopyPixmap();/// Copy the pixmap of the pad to the canvas.
virtual void CopyPixmaps();/// Copy the sub-pixmaps of the pad to the canvas.
virtual void DeleteExec(const char *name);/// Remove TExec name from the list of Execs.
virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0); // *MENU*
/// Automatic pad generation by division.
/// - The current canvas is divided in nx by ny equal divisions (pads).
/// - xmargin is the space along x between pads in percent of canvas.
/// - ymargin is the space along y between pads in percent of canvas.
/// - color is the color of the new pads. If 0, color is the canvas color.
/// Pads are automatically named canvasname_n where n is the division number
/// starting from top left pad.
virtual void DivideSquare(Int_t n, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0);
/// "n" is the total number of sub-pads. The number of sub-pads along the X
/// and Y axis are computed according to the square root of n.
virtual void Draw(Option_t *option="");/// Draw Pad in Current pad (re-parent pad if necessary).
virtual void DrawClassObject(const TObject *obj, Option_t *option="");
/// Draw class inheritance tree of the class to which obj belongs.
/// If a class B inherits from a class A, description of B is drawn
/// on the right side of description of A.
/// Member functions overridden by B are shown in class A with a blue line
/// crossing-out the corresponding member function.
static void DrawColorTable();/// Static function to Display Color Table in a pad.
virtual void DrawCrosshair();
/// Function called to draw a crosshair in the canvas
/// When moving the mouse in the canvas, a crosshair is drawn
/// - if the canvas fCrosshair = 1 , the crosshair spans the full canvas
/// - if the canvas fCrosshair > 1 , the crosshair spans only the pad
TH1F *DrawFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, const char *title="");
/// Draw an empty pad frame with X and Y axis.
/// \param[in] xmin X axis lower limit
/// \param[in] xmax X axis upper limit
/// \param[in] ymin Y axis lower limit
/// \param[in] ymax Y axis upper limit
/// \param[in] title Pad title.If title is of the form "stringt;stringx;stringy"
/// the pad title is set to stringt, the x axis title to
/// stringx, the y axis title to stringy.
virtual void ExecuteEventAxis(Int_t event, Int_t px, Int_t py, TAxis *axis);
/// Execute action corresponding to one event for a TAxis object (called by TAxis::ExecuteEvent.)
/// This member function is called when an axis is clicked with the locator
/// The axis range is set between the position where the mouse is pressed
/// and the position where it is released.
/// If the mouse position is outside the current axis range when it is released
/// the axis is unzoomed with the corresponding proportions.
/// Note that the mouse does not need to be in the pad or even canvas
/// when it is released.
virtual TObject *FindObject(const char *name) const;
/// Search if object named name is inside this pad or in pads inside this pad.
/// In case name is in several sub-pads the first one is returned.
virtual TObject *FindObject(const TObject *obj) const;
/// Search if obj is in pad or in pads inside this pad.
/// In case obj is in several sub-pads the first one is returned.
virtual void UseCurrentStyle(); // *MENU*
/// Force a copy of current style for all objects in pad.
virtual Short_t GetBorderMode() const { return fBorderMode;}
virtual Short_t GetBorderSize() const { return fBorderSize;}
Int_t GetCrosshair() const;
/// Return the crosshair type (from the mother canvas)
/// crosshair type = 0 means no crosshair.
virtual Int_t GetCanvasID() const;/// Get canvas identifier.
virtual TCanvasImp *GetCanvasImp() const;/// Get canvas implementation pointer if any
TFrame *GetFrame();/// Get frame.
virtual Int_t GetEvent() const;/// Get Event.
virtual Int_t GetEventX() const;/// Get X event.
virtual Int_t GetEventY() const;/// Get Y event.
virtual Color_t GetHighLightColor() const;/// Get highlight color.
virtual void GetRange(Double_t &x1, Double_t &y1, Double_t &x2, Double_t &y2);/// Return pad world coordinates range.
virtual void GetRangeAxis(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax);/// Return pad axis coordinates range.
virtual void GetPadPar(Double_t &xlow, Double_t &ylow, Double_t &xup, Double_t &yup);/// Return lower and upper bounds of the pad in NDC coordinates.
Double_t GetXlowNDC() const {return fXlowNDC;}
Double_t GetYlowNDC() const {return fYlowNDC;}
Double_t GetWNDC() const {return fWNDC;}
Double_t GetHNDC() const {return fHNDC;}
virtual UInt_t GetWw() const;/// Get Ww.
virtual UInt_t GetWh() const;/// Get Wh.
Double_t GetAbsXlowNDC() const {return fAbsXlowNDC;}
Double_t GetAbsYlowNDC() const {return fAbsYlowNDC;}
Double_t GetAbsWNDC() const {return fAbsWNDC;}
Double_t GetAbsHNDC() const {return fAbsHNDC;}
Double_t GetAspectRatio() const { return fAspectRatio; }
Double_t GetPhi() const {return fPhi;}
Double_t GetTheta() const {return fTheta;}
Double_t GetUxmin() const {return fUxmin;}
Double_t GetUymin() const {return fUymin;}
Double_t GetUxmax() const {return fUxmax;}
Double_t GetUymax() const {return fUymax;}
Bool_t GetGridx() const {return fGridx;}
Bool_t GetGridy() const {return fGridy;}
Int_t GetNumber() const {return fNumber;}
Int_t GetTickx() const {return fTickx;}
Int_t GetTicky() const {return fTicky;}
Double_t GetX1() const { return fX1; }
Double_t GetX2() const { return fX2; }
Double_t GetY1() const { return fY1; }
Double_t GetY2() const { return fY2; }
static Int_t GetMaxPickDistance();/// Static function (see also TPad::SetMaxPickDistance)
TList *GetListOfPrimitives() const {return fPrimitives;}
TList *GetListOfExecs() const {return fExecs;}
virtual TObject *GetPrimitive(const char *name) const; //obsolete, use FindObject instead
virtual TObject *GetSelected() const;/// Get selected.
virtual TVirtualPad *GetPad(Int_t subpadnumber) const;/// Get a pointer to subpadnumber of this pad.
virtual TObject *GetPadPointer() const {return fPadPointer;}
TVirtualPad *GetPadSave() const;/// Get save pad.
TVirtualPad *GetSelectedPad() const;/// Get selected pad.
Int_t GetGLDevice();/// Get GL device.
TView *GetView() const {return fView;}
TObject *GetView3D() const {return fPadView3D;}// Return 3D View of this TPad
Int_t GetLogx() const {return fLogx;}
Int_t GetLogy() const {return fLogy;}
Int_t GetLogz() const {return fLogz;}
virtual TVirtualPad *GetMother() const {return fMother;}
const char *GetName() const {return fName.Data();}
const char *GetTitle() const {return fTitle.Data();}
virtual TCanvas *GetCanvas() const { return fCanvas; }
virtual TVirtualPad *GetVirtCanvas() const ;/// Get virtual canvas.
virtual TVirtualPadPainter *GetPainter();/// Get pad painter from TCanvas.
Int_t GetPadPaint() const {return fPadPaint;}
Int_t GetPixmapID() const {return fPixmapID;}
ULong_t Hash() const { return fName.Hash(); }
virtual Bool_t HasCrosshair() const;/// Return kTRUE if the crosshair has been activated (via SetCrosshair).
void HighLight(Color_t col=kRed, Bool_t set=kTRUE);
/// Highlight pad.
/// do not highlight when printing on Postscript
Bool_t HasFixedAspectRatio() const { return fFixedAspectRatio; }
virtual Bool_t IsBatch() const;/// Is pad in batch mode ?
virtual Bool_t IsEditable() const {return fEditable;}
Bool_t IsFolder() const {return kTRUE;}
Bool_t IsModified() const {return fModified;}
virtual Bool_t IsRetained() const;/// Is pad retained ?
virtual Bool_t IsVertical() const {return !TestBit(kHori);}
virtual void ls(Option_t *option="") const;/// List all primitives in pad.
void Modified(Bool_t flag=1); // *SIGNAL* // Set to true when pad is modified
virtual Bool_t OpaqueMoving() const;/// Is pad moving in opaque mode ?
virtual Bool_t OpaqueResizing() const;/// Is pad resizing in opaque mode ?
Double_t PadtoX(Double_t x) const;/// Convert x from pad to X.
Double_t PadtoY(Double_t y) const;/// Convert y from pad to Y.
virtual void Paint(Option_t *option="");/// Paint all primitives in pad.
void PaintBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Option_t *option="");
/// Paint box in CurrentPad World coordinates.
/// - if option[0] = 's' the box is forced to be paint with style=0
/// - if option[0] = 'l' the box contour is drawn
void PaintFillArea(Int_t n, Float_t *x, Float_t *y, Option_t *option=""); // Obsolete
void PaintFillArea(Int_t n, Double_t *x, Double_t *y, Option_t *option=""); /// Paint fill area in CurrentPad World coordinates.
void PaintFillAreaHatches(Int_t n, Double_t *x, Double_t *y, Int_t FillStyle);
/// This function paints hatched fill area according to the FillStyle value
/// The convention for the Hatch is the following:
/// FillStyle = 3ijk
/// - i (1-9) : specify the space between each hatch
/// 1 = minimum 9 = maximum
/// the final spacing is i*GetHatchesSpacing(). The hatches spacing
/// is set by SetHatchesSpacing()
/// - j (0-9) : specify angle between 0 and 90 degrees
/// * 0 = 0
/// * 1 = 10
/// * 2 = 20
/// * 3 = 30
/// * 4 = 45
/// * 5 = Not drawn
/// * 6 = 60
/// * 7 = 70
/// * 8 = 80
/// * 9 = 90
/// - k (0-9) : specify angle between 90 and 180 degrees
/// * 0 = 180
/// * 1 = 170
/// * 2 = 160
/// * 3 = 150
/// * 4 = 135
/// * 5 = Not drawn
/// * 6 = 120
/// * 7 = 110
/// * 8 = 100
/// * 9 = 90
void PaintHatches(Double_t dy, Double_t angle, Int_t nn, Double_t *xx, Double_t *yy);
/// This routine draw hatches inclined with the
/// angle "angle" and spaced of "dy" in normalized device
/// coordinates in the surface defined by n,xx,yy.
void PaintPadFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);/// Paint histogram/graph frame.
void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2);/// Paint line in CurrentPad World coordinates.
void PaintLineNDC(Double_t u1, Double_t v1,Double_t u2, Double_t v2);/// Paint line in normalized coordinates.
void PaintLine3D(Float_t *p1, Float_t *p2);/// Paint 3-D line in the CurrentPad.
void PaintLine3D(Double_t *p1, Double_t *p2);/// Paint 3-D line in the CurrentPad.
void PaintPolyLine(Int_t n, Float_t *x, Float_t *y, Option_t *option="");
/// Paint polyline in CurrentPad World coordinates.
void PaintPolyLine(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
/// Paint polyline in CurrentPad World coordinates.
/// If option[0] == 'C' no clipping
void PaintPolyLine3D(Int_t n, Double_t *p);/// Paint 3-D polyline in the CurrentPad.
void PaintPolyLineNDC(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
/// Paint polyline in CurrentPad NDC coordinates.
void PaintPolyMarker(Int_t n, Float_t *x, Float_t *y, Option_t *option="");
/// Paint polymarker in CurrentPad World coordinates.
void PaintPolyMarker(Int_t n, Double_t *x, Double_t *y, Option_t *option="");
/// Paint polymarker in CurrentPad World coordinates.
virtual void PaintModified();
void PaintText(Double_t x, Double_t y, const char *text);/// Paint text in CurrentPad World coordinates.
void PaintText(Double_t x, Double_t y, const wchar_t *text);/// Paint text in CurrentPad World coordinates.
void PaintTextNDC(Double_t u, Double_t v, const char *text);/// Paint text in CurrentPad NDC coordinates.
void PaintTextNDC(Double_t u, Double_t v, const wchar_t *text);/// Paint text in CurrentPad NDC coordinates.
virtual TPad *Pick(Int_t px, Int_t py, TObjLink *&pickobj);
/// Search for an object at pixel position px,py.
/// Check if point is in this pad.
/// If yes, check if it is in one of the sub-pads
/// If found in the pad, compute closest distance of approach to each primitive.
/// If one distance of approach is found to be within the limit Distancemaximum
/// the corresponding primitive is selected and the routine returns.
Double_t PixeltoX(Int_t px);
Double_t PixeltoY(Int_t py);
virtual void PixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Double_t &y);
virtual void Pop(); // *MENU* /// Pop pad to the top of the stack.
virtual void Print(const char *filename="") const;
/// Save Pad contents in a file in one of various formats.
/// - if filename is "", the file produced is padname.ps
/// - if filename starts with a dot, the padname is added in front
/// - if filename contains .eps, an Encapsulated Postscript file is produced
/// - if filename contains .gif, a GIF file is produced
/// - if filename contains .gif+NN, an animated GIF file is produced
/// See comments in TASImage::WriteImage for meaning of NN and other
/// .gif suffix variants
/// - if filename contains .C or .cxx, a C++ macro file is produced
/// - if filename contains .root, a Root file is produced
/// - if filename contains .xml, a XML file is produced
/// See comments in TPad::SaveAs or the TPad::Print function below
virtual void Print(const char *filename, Option_t *option);
/// Save Canvas contents in a file in one of various formats.
/// option can be:
/// - 0 - as "ps"
/// - "ps" - Postscript file is produced (see special cases below)
/// - "Portrait" - Postscript file is produced (Portrait)
/// - "Landscape" - Postscript file is produced (Landscape)
/// - "Title:" - The character string after "Title:" becomes a table
/// - of content entry (for PDF files).
/// - "eps" - an Encapsulated Postscript file is produced
/// - "Preview" - an Encapsulated Postscript file with preview is produced.
/// - "pdf" - a PDF file is produced
/// - "svg" - a SVG file is produced
/// - "tex" - a TeX file is produced
/// - "gif" - a GIF file is produced
/// - "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units NOTE: See other variants for looping animation in TASImage::WriteImage
/// - "xpm" - a XPM file is produced
/// - "png" - a PNG file is produced
/// - "jpg" - a JPEG file is produced. NOTE: JPEG's lossy compression will make all sharp edges fuzzy.
/// - "tiff" - a TIFF file is produced
/// - "cxx" - a C++ macro file is produced
/// - "xml" - a XML file
/// - "root" - a ROOT binary file
/// filename = 0 - filename is defined by the GetName and its
/// extension is defined with the option
/// When Postscript output is selected (ps, eps), the canvas is saved
/// to filename.ps or filename.eps. The aspect ratio of the canvas is preserved
/// on the Postscript file. When the "ps" option is selected, the Postscript
/// page will be landscape format if the canvas is in landscape format, otherwise
/// portrait format is selected.
/// The physical size of the Postscript page is the one selected in the
/// current style. This size can be modified via TStyle::SetPaperSize.
virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2); // *MENU* *ARGS={x1=>fX1,y1=>fY1,x2=>fX2,y2=>fY2}
/// Set world coordinate system for the pad.
/// Emits signal "RangeChanged()", in the slot get the range
/// via GetRange().
virtual void RangeChanged() { Emit("RangeChanged()"); } // *SIGNAL*
virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);
/// Set axis coordinate system for the pad.
/// The axis coordinate system is a subset of the world coordinate system
/// xmin,ymin is the origin of the current coordinate system,
/// xmax is the end of the X axis, ymax is the end of the Y axis.
/// By default a margin of 10 per cent is left on all sides of the pad
/// Emits signal "RangeAxisChanged()", in the slot get the axis range
/// via GetRangeAxis().
virtual void RangeAxisChanged() { Emit("RangeAxisChanged()"); } // *SIGNAL*
virtual void RecursiveRemove(TObject *obj);/// Recursively remove object from a pad and its sub-pads.
virtual void RedrawAxis(Option_t *option="");
/// Redraw the frame axis
/// Redrawing axis may be necessary in case of superimposed histograms
/// when one or more histograms have a fill color
/// Instead of calling this function, it may be more convenient
/// to call directly h1->Draw("sameaxis") where h1 is the pointer
/// to the first histogram drawn in the pad.
/// By default, if the pad has the options gridx or/and gridy activated,
/// the grid is not drawn by this function.
/// if option="g" is specified, this will force the drawing of the grid
/// on top of the picture
virtual void ResetView3D(TObject *view=0){fPadView3D=view;}
virtual void ResizePad(Option_t *option="");/// Compute pad conversion coefficients.
virtual void SaveAs(const char *filename="",Option_t *option="") const; // *MENU*
/// Save Pad contents in a file in one of various formats.
/// - if filename is "", the file produced is padname.ps
/// - if filename starts with a dot, the padname is added in front
/// - if filename contains .eps, an Encapsulated Postscript file is produced
/// - if filename contains .pdf, a PDF file is produced
/// - if filename contains .svg, a SVG file is produced
/// - if filename contains .tex, a TeX file is produced
/// - if filename contains .gif, a GIF file is produced
/// - if filename contains .gif+NN, an animated GIF file is produced See comments in TASImage::WriteImage for meaning of NN and other .gif sufix variants
/// - if filename contains .xpm, a XPM file is produced
/// - if filename contains .png, a PNG file is produced
/// - if filename contains .jpg, a JPEG file is produced NOTE: JPEG's lossy compression will make all sharp edges fuzzy.
/// - if filename contains .tiff, a TIFF file is produced
/// - if filename contains .C or .cxx, a C++ macro file is produced
/// - if filename contains .root, a Root file is produced
/// - if filename contains .xml, a XML file is produced
/// See comments in TPad::Print for the Postscript formats
virtual void SetBorderMode(Short_t bordermode) {fBorderMode = bordermode; Modified();} // *MENU*
virtual void SetBorderSize(Short_t bordersize) {fBorderSize = bordersize; Modified();} // *MENU*
void SetCanvas(TCanvas *c) { fCanvas = c; }
virtual void SetCanvasSize(UInt_t ww, UInt_t wh);/// Set canvas size.
virtual void SetCrosshair(Int_t crhair=1); // *TOGGLE*
/// Set crosshair active/inactive.
/// - If crhair != 0, a crosshair will be drawn in the pad and its sub-pads.
/// - If the canvas crhair = 1 , the crosshair spans the full canvas.
/// - If the canvas crhair > 1 , the crosshair spans only the pad.
virtual void SetCursor(ECursor cursor);/// Set cursor type.
virtual void SetDoubleBuffer(Int_t mode=1);/// Set double buffer mode ON or OFF.
virtual void SetDrawOption(Option_t *option="");
virtual void SetEditable(Bool_t mode=kTRUE); // *TOGGLE*
/// Set pad editable yes/no
/// If a pad is not editable:
/// - one cannot modify the pad and its objects via the mouse.
/// - one cannot add new objects to the pad
virtual void SetFixedAspectRatio(Bool_t fixed = kTRUE); // *TOGGLE* /// Fix pad aspect ratio to current value if fixed is true.
virtual void SetGrid(Int_t valuex = 1, Int_t valuey = 1) {fGridx = valuex; fGridy = valuey; Modified();}
virtual void SetGridx(Int_t value = 1) {fGridx = value; Modified();} // *TOGGLE*
virtual void SetGridy(Int_t value = 1) {fGridy = value; Modified();} // *TOGGLE*
virtual void SetFillStyle(Style_t fstyle);
/// Override TAttFill::FillStyle for TPad because we want to handle style=0
/// as style 4000.
virtual void SetLogx(Int_t value = 1); // *TOGGLE*
/// Set Lin/Log scale for X
/// - value = 0 X scale will be linear
/// - value = 1 X scale will be logarithmic (base 10)
/// - value > 1 reserved for possible support of base e or other
virtual void SetLogy(Int_t value = 1); // *TOGGLE*
/// Set Lin/Log scale for Y
/// - value = 0 Y scale will be linear
/// - value = 1 Y scale will be logarithmic (base 10)
/// - value > 1 reserved for possible support of base e or other
virtual void SetLogz(Int_t value = 1); // *TOGGLE* /// Set Lin/Log scale for Z
virtual void SetNumber(Int_t number) {fNumber = number;}
virtual void SetPad(const char *name, const char *title,
Double_t xlow, Double_t ylow, Double_t xup,
Double_t yup, Color_t color=35,
Short_t bordersize=5, Short_t bordermode=-1);/// Set all pad parameters.
virtual void SetPad(Double_t xlow, Double_t ylow, Double_t xup, Double_t yup);
/// Set canvas range for pad and resize the pad. If the aspect ratio
/// was fixed before the call it will be un-fixed.
virtual void SetAttFillPS(Color_t color, Style_t style);/// Set postscript fill area attributes.
virtual void SetAttLinePS(Color_t color, Style_t style, Width_t lwidth);/// Set postscript line attributes.
virtual void SetAttMarkerPS(Color_t color, Style_t style, Size_t msize);/// Set postscript marker attributes.
virtual void SetAttTextPS(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize);/// Set postscript text attributes.
static void SetMaxPickDistance(Int_t maxPick=5);
/// static function to set the maximum Pick Distance fgMaxPickDistance
/// This parameter is used in TPad::Pick to select an object if
/// its DistancetoPrimitive returns a value < fgMaxPickDistance
/// The default value is 5 pixels. Setting a smaller value will make
/// picking more precise but also more difficult
virtual void SetName(const char *name) {fName = name;} // *MENU*
virtual void SetSelected(TObject *obj);/// Set selected.
virtual void SetTicks(Int_t valuex = 1, Int_t valuey = 1) {fTickx = valuex; fTicky = valuey; Modified();}
virtual void SetTickx(Int_t value = 1) {fTickx = value; Modified();} // *TOGGLE*
virtual void SetTicky(Int_t value = 1) {fTicky = value; Modified();} // *TOGGLE*
virtual void SetTitle(const char *title="") {fTitle = title;}
virtual void SetTheta(Double_t theta=30) {fTheta = theta; Modified();}
virtual void SetPhi(Double_t phi=30) {fPhi = phi; Modified();}
virtual void SetToolTipText(const char *text, Long_t delayms = 1000);
/// Set tool tip text associated with this pad. The delay is in
/// milliseconds (minimum 250). To remove tool tip call method with
/// text = 0.
virtual void SetVertical(Bool_t vert=kTRUE);/// Set pad vertical (default) or horizontal
virtual void SetView(TView *view = 0);/// Set the current TView. Delete previous view if view=0
virtual void SetViewer3D(TVirtualViewer3D *viewer3d) {fViewer3D = viewer3d;}
virtual void SetGLDevice(Int_t dev) {fGLDevice = dev;}
virtual void SetCopyGLDevice(Bool_t copy) {fCopyGLDevice = copy;}
virtual void ShowGuidelines(TObject *object, const Int_t event, const char mode = 'i', const bool cling = true);
/// Shows lines to indicate if a TAttBBox2D object is aligned to
/// the center or to another object, shows distance arrows if two
/// objects on screen have the same distance to another object
/// Call from primitive in Execute Event, in ButtonMotion after
/// the new coordinates have been set, to 'stick'
/// once when button is up to delete lines
/// modes: t (Top), b (bottom), l (left), r (right), i (inside)
/// in resize modes (t,b,l,r) only size arrows are sticky
/// in mode, the function gets the point on the element that is clicked to
/// move (i) or resize (all others).
virtual void Update();/// Update pad.
Int_t UtoAbsPixel(Double_t u) const {return Int_t(fUtoAbsPixelk + u*fUtoPixel);}
Int_t VtoAbsPixel(Double_t v) const {return Int_t(fVtoAbsPixelk + v*fVtoPixel);}
Int_t UtoPixel(Double_t u) const;
Int_t VtoPixel(Double_t v) const;
virtual TObject *WaitPrimitive(const char *pname="", const char *emode="");
/// Loop and sleep until a primitive with name=pname is found in the pad.
/// If emode is given, the editor is automatically set to emode, ie
/// it is not required to have the editor control bar.
/// The possible values for emode are:
/// - emode = "" (default). User will select the mode via the editor bar
/// - emode = "Arc", "Line", "Arrow", "Button", "Diamond", "Ellipse",
/// - emode = "Pad","pave", "PaveLabel","PaveText", "PavesText",
/// - emode = "PolyLine", "CurlyLine", "CurlyArc", "Text", "Marker", "CutG"
/// If emode is specified and it is not valid, "PolyLine" is assumed. If emode
/// is not specified or ="", an attempt is to use pname[1...]
///
/// for example if pname="TArc", emode="Arc" will be assumed.
/// When this function is called within a macro, the macro execution
/// is suspended until a primitive corresponding to the arguments
/// is found in the pad.
/// If CRTL/C is typed in the pad, the function returns 0.
/// While this function is executing, one can use the mouse, interact
/// with the graphics pads, use the Inspector, Browser, TreeViewer, etc.
/// Examples:
/// c1.WaitPrimitive(); // Return the first created primitive
/// // whatever it is.
/// // If a double-click with the mouse is executed
/// // in the pad or any key pressed, the function
/// // returns 0.
/// c1.WaitPrimitive("ggg"); // Set the editor in mode "PolyLine/Graph"
/// // Create a polyline, then using the context
/// // menu item "SetName", change the name
/// // of the created TGraph to "ggg"
/// c1.WaitPrimitive("TArc");// Set the editor in mode "Arc". Returns
/// // as soon as a TArc object is created.
/// c1.WaitPrimitive("lat","Text"); // Set the editor in Text/Latex mode.
/// // Create a text object, then Set its name to "lat"
Int_t XtoAbsPixel(Double_t x) const;
Int_t YtoAbsPixel(Double_t y) const;
Double_t XtoPad(Double_t x) const;/// Convert x from X to pad.
Double_t YtoPad(Double_t y) const;/// Convert y from Y to pad.
Int_t XtoPixel(Double_t x) const;
Int_t YtoPixel(Double_t y) const;
virtual void XYtoAbsPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const;
virtual void XYtoPixel(Double_t x, Double_t y, Int_t &xpixel, Int_t &ypixel) const;
virtual TObject *CreateToolTip(const TBox *b, const char *text, Long_t delayms);/// Create a tool tip and return its pointer.
virtual void DeleteToolTip(TObject *tip);/// Delete tool tip object.
virtual void ResetToolTip(TObject *tip);
/// Reset tool tip, i.e. within time specified in CreateToolTip the
/// tool tip will pop up.
virtual void CloseToolTip(TObject *tip);/// Hide tool tip.
virtual void x3d(Option_t *type=""); // Depreciated
/// Deprecated: use TPad::GetViewer3D() instead
virtual TVirtualViewer3D *GetViewer3D(Option_t * type = "");
/// Create/obtain handle to 3D viewer. Valid types are:
/// - 'pad' - pad drawing via TViewer3DPad
/// any others registered with plugin manager supporting TVirtualViewer3D
/// If an invalid/null type is requested then the current viewer is returned
/// (if any), otherwise a default 'pad' type is returned
virtual Bool_t HasViewer3D() const { return (fViewer3D); }
virtual void ReleaseViewer3D(Option_t * type = "");/// Release current (external) viewer
virtual Rectangle_t GetBBox();/// Return the bounding Box of the Pad
virtual TPoint GetBBoxCenter();/// Return the center of the Pad as TPoint in pixels
virtual void SetBBoxCenter(const TPoint &p);/// Set center of the Pad
virtual void SetBBoxCenterX(const Int_t x);
/// Set X coordinate of the center of the Pad
virtual void SetBBoxCenterY(const Int_t y);
/// Set Y coordinate of the center of the Pad
virtual void SetBBoxX1(const Int_t x);
/// Set lefthandside of BoundingBox to a value
/// (resize in x direction on left)
virtual void SetBBoxX2(const Int_t x);
/// Set right hand side of BoundingBox to a value
/// (resize in x direction on right)
virtual void SetBBoxY1(const Int_t y);
/// Set top of BoundingBox to a value (resize in y direction on top)
virtual void SetBBoxY2(const Int_t y);
/// Set bottom of BoundingBox to a value
/// (resize in y direction on bottom)
virtual void RecordPave(const TObject *obj); // *SIGNAL*
/// Emit RecordPave() signal.
virtual void RecordLatex(const TObject *obj); // *SIGNAL*
/// Emit RecordLatex() signal.
virtual void EventPave() { Emit("EventPave()"); } // *SIGNAL*
virtual void StartEditing() { Emit("StartEditing()"); } // *SIGNAL*
code¶
//图片修饰
gPad->SetTickx(1);//上边框有刻度
gPad->SetTicky(1);//右边框有刻度
gPad->SetTickx(2);//上边框有刻度和数值
gPad->SetTicky(2);//右边框有刻度和数值
TPad* pad1 = new TPad("pad1","pad1",0.03,0.62,0.50,0.92,32);//x起点，y起点，x终点，y终点，颜色
pad1->Draw();
pad1->cd();
pad1->SetLogy();//y轴 对数坐标
pad1->SetGridy();//y轴 网格
pad2->SetLogx();
pad2->SetGridx();
/// The following macro waits for 10 primitives of any type to be created.
TCanvas c1("c1");
TObject *obj;
for (Int_t i=0;i<10;i++) {
obj = gPad->WaitPrimitive();
if (!obj) break;
printf("Loop i=%d, found objIsA=%s, name=%s\n",
i,obj->ClassName(),obj->GetName());
}
/// Function called to draw a crosshair in the canvas
/// When moving the mouse in the canvas, a crosshair is drawn
/// - if the canvas fCrosshair = 1 , the crosshair spans the full canvas
/// - if the canvas fCrosshair > 1 , the crosshair spans only the pad
TFile f("hsimple.root");
hpxpy.Draw();
c1.SetCrosshair();
/// The following examples of TExec commands are provided in the tutorials:
Root > TFile f("hsimple.root")
Root > hpx.Draw()
Root > c1.AddExec("ex1",".x exec1.C")
/// At this point you can use the mouse to click on the contour of
/// the histogram hpx. When the mouse is clicked, the bin number and its
/// contents are printed.
Root > TFile f("hsimple.root")
Root > hpxpy.Draw()
Root > c1.AddExec("ex2",".x exec2.C")
/// The physical size of the Postscript page is the one selected in the
/// current style. This size can be modified via TStyle::SetPaperSize.
gStyle->SetPaperSize(TStyle::kA4); //default
gStyle->SetPaperSize(TStyle::kUSLetter);
/// where TStyle::kA4 and TStyle::kUSLetter are defined in the enum
/// EPaperSize in TStyle.h
/// An alternative is to call:
gStyle->SetPaperSize(20,26); same as kA4
gStyle->SetPaperSize(20,24); same as kUSLetter
/// The above numbers take into account some margins and are in centimeters.
/// The "Preview" option allows to generate a preview (in the TIFF format) within
/// the Encapsulated Postscript file. This preview can be used by programs like
/// MSWord to visualize the picture on screen. The "Preview" option relies on the
/// epstool command (http://www.cs.wisc.edu/~ghost/gsview/epstool.htm).
canvas->Print("example.eps","Preview");
/// To generate a Postscript file containing more than one picture, see
/// class TPostScript.
///
/// ### Writing several canvases to the same Postscript or PDF file:
///
/// - if the Postscript or PDF file name finishes with "(", the file is not closed
/// - if the Postscript or PDF file name finishes with ")" and the file has been opened
/// with "(", the file is closed.
TCanvas c1("c1");
h1.Draw();
c1.Print("c1.ps("); //write canvas and keep the ps file open
h2.Draw();
c1.Print("c1.ps"); canvas is added to "c1.ps"
h3.Draw();
c1.Print("c1.ps)"); canvas is added to "c1.ps" and ps file is closed
/// In the previous example replacing "ps" by "pdf" will create a multi-pages PDF file.
/// Note that the following sequence writes the canvas to "c1.ps" and closes the ps file.:
TCanvas c1("c1");
h1.Draw();
c1.Print("c1.ps");
/// The TCanvas::Print("file.ps(") mechanism is very useful, but it can be
/// a little inconvenient to have the action of opening/closing a file
/// being atomic with printing a page. Particularly if pages are being
/// generated in some loop one needs to detect the special cases of first
/// and last page and then munge the argument to Print() accordingly.
///
/// The "[" and "]" can be used instead of "(" and ")".
c1.Print("file.ps["); // No actual print, just open file.ps
for (int i=0; i<10; ++i) {
// fill canvas for context i
// ...
c1.Print("file.ps"); // actually print canvas to file
}// end loop
c1.Print("file.ps]"); // No actual print, just close.
/// As before, the same macro is valid for PDF files.
///
/// It is possible to print a canvas into an animated GIF file by specifying the
/// file name as "myfile.gif+" or "myfile.gif+NN", where NN*10ms is delay
/// between the subimages' display. If NN is omitted the delay between
/// subimages is zero. Each picture is added in the animation thanks to a loop
/// similar to the following one:
for (int i=0; i<10; ++i) {
// fill canvas for context i
// ...
c1.Print("file.gif+5"); // print canvas to GIF file with 50ms delays
}// end loop
/// The delay between each frame must be specified in each Print() statement.
/// If the file "myfile.gif" already exists, the new frame are appended at
/// the end of the file. To avoid this, delete it first with gSystem->Unlink(myfile.gif);
/// If you want the gif file to repeat or loop forever, check TASImage::WriteImage documentation