class TPad: public TVirtualPad

 Pad default constructor.

 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.

  xlow [0,1] is the position of the bottom left point of the pad
             expressed in the mother pad reference system
  ylow [0,1] is the Y position of this point.
  xup  [0,1] is the x position of the top right point of the pad
             expressed in the mother pad reference system
  yup  [0,1] is the Y position of this point.

  the bordersize is in pixels
  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

 Pad destructor.

 Add a new TExec object to the list of Execs.
 When an event occurs in the pad (mouse click, etc) the list of CINT 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.
  The following examples of TExec commands are provided in the tutorials:
  macros exec1.C and exec2.C.
  Example1 of use of exec1.C

  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.
  Example2 of use of exec1.C

  Root > TFile f("hsimple.root")
  Root > hpxpy.Draw()
  Root > c1.AddExec("ex2",".x exec2.C")
    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 CINT
    as a development engine.

 Execute the list of Execs when a pad event occurs.

 Browse pad.

 Build a legend from the graphical objects in the pad

 A simple method to 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 " ".

 If the pad contains some TMultiGraph or THStack the individual graphs or
 histograms in them are added to the TLegend.

 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 subpads.
  Returns the new current pad, or 0 in case of failure.
  For example:
    c1.Divide(2,3); // create 6 pads (2 divisions along x, 3 along y).
    To set the current pad to the bottom right pad, do
    c1.cd(6);
  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);

 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)

 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.

 _Input parameters:

  x[2], y[2] : Segment coordinates
  xclipl, yclipb, xclipr, yclipt : Clipping boundary

 _Output parameters:

  x[2], y[2] : New segment coordinates

 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.

 _Input parameters:

  x[2], y[2] : Segment coordinates
  xclipl, yclipb, xclipr, yclipt : Clipping boundary

 _Output parameters:

  x[2], y[2] : New segment coordinates

 Compute the endpoint codes for TPad::Clip.

 Clip polygon using the Sutherland-Hodgman algorithm.

 Input parameters:

  n: Number of points in the polygon to be clipped
  x[n], y[n] : Polygon do be clipped vertices
  xclipl, yclipb, xclipr, yclipt : Clipping boundary

 Output parameters:

 nn: number of points in xc and yc
 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

 Delete all primitives in pad and pad itself.
 Pad cannot be used anymore after this call.
 Emits signal "Closed()".

 Copy the pixmap of the pad to the canvas.

 Copy the sub-pixmaps of the pad to the canvas.

 Remove TExec name from the list of Execs.

 Compute distance from point px,py to a box.

  Compute the closest distance of approach from point px,py to the
  edges of this pad.
  The distance is computed in pixels units.

 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.
    (see Note3 below for the special case xmargin <=0 and ymargin <=0)
  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.
       Example if canvasname=c1 , nx=2, ny=3


    .                               .                             .
    .                               .                             .
    .                               .                             .
    .           c1_1                .           c1_2              .
    .                               .                             .
    .                               .                             .
    .                               .                             .

    .                               .                             .
    .                               .                             .
    .                               .                             .
    .           c1_3                .           c1_4              .
    .                               .                             .
    .                               .                             .
    .                               .                             .

    .                               .                             .
    .                               .                             .
    .                               .                             .
    .           c1_5                .           c1_6              .
    .                               .                             .
    .                               .                             .



    Once a pad is divided into subpads, one can set the current pad
    to a subpad with a given division number as illustrated above
    with TPad::cd(subpad_number).
    For example, to set the current pad to c1_4, one can do:
    c1->cd(4)

  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:  in case xmargin <=0 and ymargin <= 0, there is no space
          between pads. The current pad margins are recomputed to
          optimize the layout.

 Draw Pad in Current pad (re-parent pad if necessary).

 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.
 The following picture is the class inheritance tree of class TPaveLabel:

Function called to draw a crosshair in the canvas

 Example:
 Root > TFile f("hsimple.root");
 Root > hpxpy.Draw();
 Root > c1.SetCrosshair();
 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

  Draw a pad frame

  Compute real pad range taking into account all margins
  Use services of TH1F class

 Static function to Display Color Table in a pad.

 Execute action corresponding to one event.

  This member function is called when a TPad object is clicked.

  If the mouse is clicked in one of the 4 corners of the pad (pA,pB,pC,pD)
  the pad is resized with the rubber rectangle.

  If the mouse is clicked inside the pad, the pad is moved.

  If the mouse is clicked on the 4 edges (pL,pR,pTop,pBot), the pad is scaled
  parallel to this edge.

    pA                   pTop                     pB
     +--------------------------------------------+
     |                                            |
     |                                            |
     |                                            |
   pL|                 pINSIDE                    |pR
     |                                            |
     |                                            |
     |                                            |
     |                                            |
     +--------------------------------------------+
    pD                   pBot                     pC


  Note that this function duplicates on purpose the functionality
  already implemented in TBox::ExecuteEvent.
  If somebody modifies this function, may be similar changes should also
  be applied to TBox::ExecuteEvent.

 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.

 Search if object named name is inside this pad or in pads inside this pad.

  In case name is in several subpads the first one is returned.

 Search if obj is in pad or in pads inside this pad.

  In case obj is in several subpads the first one is returned.

 Get canvas identifier.

 Get canvas implementation pointer if any

 Get Event.

 Get X event.

 Get Y event.

 Get virtual canvas.

 Get highlight color.

 Static function (see also TPad::SetMaxPickDistance)

 Get selected.

 Get selected pad.

 Get save pad.

 Get Wh.

 Get Ww.

 Hide tool tip depending on the event type. Typically tool tips
 are hidden when event is not a kMouseEnter and not a kMouseMotion
 event.

 Is pad in batch mode ?

 Is pad retained ?

 Is pad moving in opaque mode ?

 Is pad resizing in opaque mode ?

 Set pad in batch mode.

 Set canvas size.

 Set cursor type.

 Set double buffer mode ON or OFF.

 Set selected.

 Update pad.

 Get frame.

 Get primitive.

 Get a pointer to subpadnumber of this pad.

 Return lower and upper bounds of the pad in NDC coordinates.

 Return pad world coordinates range.

 Return pad axis coordinates range.

 Highlight pad.
do not highlight when printing on Postscript

 List all primitives in pad.

 Convert x from pad to X.

 Convert y from pad to Y.

 Convert x from X to pad.

 Convert y from Y to pad.

 Paint all primitives in pad.

 Paint the pad border.
 Draw first  a box as a normal filled box

 Paint a frame border with Postscript.

 Paint the current date and time if the option date is on.

 Paint histogram/graph frame.

 Traverse pad hierarchy and (re)paint only modified pads.

 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

 Copy pixmaps of pads laying below pad "stop" into pad "stop". This
 gives the effect of pad "stop" being transparent.

 Copy pixmap of this pad as background of the current pad.

 Paint fill area in CurrentPad World coordinates.

 Paint fill area in CurrentPad World coordinates.

   This function paints hatched fill area arcording 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

 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.

 Paint line in CurrentPad World coordinates.

 Paint 3-D line in the CurrentPad.

 Paint 3-D line in the CurrentPad.

 Paint polyline in CurrentPad World coordinates.

 Paint polyline in CurrentPad World coordinates.

  If option[0] == 'C' no clipping

 Paint polyline in CurrentPad NDC coordinates.

 Paint 3-D polyline in the CurrentPad.

 Paint polymarker in CurrentPad World coordinates.

 Paint polymarker in CurrentPad World coordinates.

 Paint text in CurrentPad World coordinates.

 Paint text in CurrentPad NDC coordinates.

 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 subpads
  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.

 Pop pad to the top of the stack.

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

 Save Pad contents in a file in one of various formats.

   if option  =  0   - as "ps"
               "ps"  - Postscript file is produced (see special cases below)
          "Portrait" - Postscript file is produced (Portrait)
         "Landscape" - Postscript file is produced (Landscape)
               "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
               "gif" - a GIF file is produced
               "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units
               "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 pad is saved
   to filename.ps or filename.eps. The aspect ratio of the pad is preserved
   on the Postscript file. When the "ps" option is selected, the Postscript
   page will be landscape format if the pad 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.
   Examples:
        gStyle->SetPaperSize(kA4);  //default
        gStyle->SetPaperSize(kUSLetter);
     where kA4 and kUSLetter are defined in the enum EPaperSize in TStyle.h
    An alternative is to call:
        gStyle->SetPaperSize(20,26);  same as kA4
 or     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).
  Example:
     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 file:

 if the Postscript file name finishes with "(", the file is not closed
 if the Postscript file name finishes with ")" and the file has been opened
    with "(", the file is closed. Example:
 {
    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
 }

  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 ")".  Example:

    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.

 It is possible to print a pad 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 ommitted 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.

 Set world coordinate system for the pad.
 Emits signal "RangeChanged()", in the slot get the range
 via GetRange().

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

 Recursively remove object from a pad and its subpads.

  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

 Compute pad conversion coefficients.

   Conversion from x to px & y to py


       x - xmin     px - pxlow              xrange  = xmax-xmin
       --------  =  ----------      with
        xrange        pxrange               pxrange = pxmax-pxmin

               pxrange(x-xmin)
   ==>  px =   ---------------  + pxlow   = fXtoPixelk + fXtoPixel * x
                    xrange

   ==>  fXtoPixelk = pxlow - pxrange*xmin/xrange
        fXtoPixel  = pxrange/xrange
           where  pxlow   = fAbsXlowNDC*fCw
                  pxrange = fAbsWNDC*fCw


       y - ymin     py - pylow              yrange  = ymax-ymin
       --------  =  ----------      with
        yrange        pyrange               pyrange = pymax-pymin

               pyrange(y-ymin)
   ==>  py =   ---------------  + pylow   = fYtoPixelk + fYtoPixel * y
                    yrange

   ==>  fYtoPixelk = pylow - pyrange*ymin/yrange
        fYtoPixel  = pyrange/yrange
           where  pylow   = (1-fAbsYlowNDC)*fCh
                  pyrange = -fAbsHNDC*fCh

-  Conversion from px to x & py to y


             xrange(px-pxlow)
   ==>  x =  ----------------  + xmin  = fPixeltoXk + fPixeltoX * px
                 pxrange
-
   ==>  fPixeltoXk = xmin - pxlow*xrange/pxrange
        fPixeltoX  = xrange/pxrange

             yrange(py-pylow)
   ==>  y =  ----------------  + ymin  = fPixeltoYk + fPixeltoY * py
                 pyrange
-
   ==>  fPixeltoYk = ymin - pylow*yrange/pyrange
        fPixeltoY  = yrange/pyrange



  Computation of the coefficients in case of LOG scales
- =====================================================

   A, Conversion from pixel coordinates to world coordinates

       Log(x) - Log(xmin)      Log(x/xmin)       px - pxlow
  u = --------------------- =  -------------  =  -----------
      Log(xmax) - Log(xmin)    Log(xmax/xmin)     pxrange

  ==> Log(x/xmin) = u*Log(xmax/xmin)
      x = xmin*exp(u*Log(xmax/xmin)
   Let alfa = Log(xmax/xmin)/fAbsWNDC

      x = xmin*exp(-alfa*pxlow) + exp(alfa*px)
      x = fPixeltoXk*exp(fPixeltoX*px)
  ==> fPixeltoXk = xmin*exp(-alfa*pxlow)
      fPixeltoX  = alfa

       Log(y) - Log(ymin)      Log(y/ymin)       pylow - py
  v = --------------------- =  -------------  =  -----------
      Log(ymax) - Log(ymin)    Log(ymax/ymin)     pyrange

   Let beta = Log(ymax/ymin)/pyrange
      Log(y/ymin) = beta*pylow - beta*py
      y/ymin = exp(beta*pylow - beta*py)
      y = ymin*exp(beta*pylow)*exp(-beta*py)
  ==> y = fPixeltoYk*exp(fPixeltoY*py)
      fPixeltoYk = ymin*exp(beta*pylow)
      fPixeltoY  = -beta

-  B, Conversion from World coordinates to pixel coordinates

  px = pxlow + u*pxrange
     = pxlow + Log(x/xmin)/alfa
     = pxlow -Log(xmin)/alfa  + Log(x)/alfa
     = fXtoPixelk + fXtoPixel*Log(x)
  ==> fXtoPixelk = pxlow -Log(xmin)/alfa
  ==> fXtoPixel  = 1/alfa

  py = pylow - Log(y/ymin)/beta
     = fYtoPixelk + fYtoPixel*Log(y)
  ==> fYtoPixelk = pylow - Log(ymin)/beta
      fYtoPixel  = 1/beta

 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 .gif, a GIF file is produced
   if filename contains .gif+NN, an  animated GIF file is produced
   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

 Save primitives in this pad on the C++ source file out.

 Fix pad aspect ratio to current value if fixed is true.

 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

 Overrride TAttFill::FillStyle for TPad because we want to handle style=0
 as style 4000.

 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

 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

 Set Lin/Log scale for Z

 Set canvas range for pad and resize the pad. If the aspect ratio
 was fixed before the call it will be un-fixed.

 Set all pad parameters.

 Set the current TView. Delete previous view if view=0

 Set postscript fill area attributes.

 Set postscript line attributes.

 Set postscript marker attributes.

 Set postscript text attributes.

 Return kTRUE if the crosshair has been activated (via SetCrosshair).

 Return the crosshair type (from the mother canvas)
 crosshair type = 0 means no crosshair.

 Set crosshair active/inactive.
 If crhair != 0, a crosshair will be drawn in the pad and its subpads.
 If the canvas crhair = 1 , the crosshair spans the full canvas.
 If the canvas crhair > 1 , the crosshair spans only the pad.

 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

 Set tool tip text associated with this pad. The delay is in
 milliseconds (minimum 250). To remove tool tip call method with
 text = 0.

 Set pad vertical (default) or horizontal

 Stream a class object.

 Force a copy of current style for all objects in pad.

 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
        = "Arc", "Line", "Arrow", "Button", "Diamond", "Ellipse",
        = "Pad","pave", "PaveLabel","PaveText", "PavesText",
        = "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"

 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());
   }
}

 Create a tool tip and return its pointer.

 Delete tool tip object.

 Reset tool tip, i.e. within time specified in CreateToolTip the
 tool tip will pop up.

 Hide tool tip.

 Depreciated: use TPad::GetViewer3D() instead

 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

 Release current (external) viewer
 TODO: By type

 Get GL device.

 Emit RecordPave() signal.

 Emit RecordLatex() signal.

Get pad painter from TCanvas.

   virtual void      UpdateFillAttributes(Int_t col, Int_t sty);
   virtual void      UpdateLineAttributes(Int_t col, Int_t sty, Int_t width);
   virtual void      UpdateMarkerAttributes(Int_t col, Int_t sty, Float_t msiz);
   virtual void      UpdateTextAttributes(Int_t align,Float_t angle,Int_t col,Int_t font,Float_t tsize);