// @(#)root/gpad:$Id$
// Author: Rene Brun   12/12/94

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#include <string.h>
#include <stdlib.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TError.h"
#include "TMath.h"
#include "TSystem.h"
#include "TStyle.h"
#include "TH1.h"
#include "TClass.h"
#include "TBaseClass.h"
#include "TClassTable.h"
#include "TVirtualPS.h"
#include "TVirtualX.h"
#include "TVirtualViewer3D.h"
#include "TView.h"
#include "TPoint.h"
#include "TGraph.h"
#include "TMultiGraph.h"
#include "THStack.h"
#include "TPaveText.h"
#include "TGroupButton.h"
#include "TBrowser.h"
#include "TVirtualGL.h"
#include "TString.h"
#include "TDataMember.h"
#include "TMethod.h"
#include "TDataType.h"
#include "TRealData.h"
#include "TFrame.h"
#include "TExec.h"
#include "TDatime.h"
#include "TColor.h"
#include "TCanvas.h"
#include "TPluginManager.h"
#include "TEnv.h"
#include "TImage.h"
#include "TViewer3DPad.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TCreatePrimitives.h"
#include "TLegend.h"
#include "TAtt3D.h"
#include "TObjString.h"
#include "TApplication.h"
#include "TVirtualPadPainter.h"

#include "TVirtualMutex.h"

static Int_t gReadLevel = 0;

Int_t TPad::fgMaxPickDistance = 5;

ClassImpQ(TPad)


//______________________________________________________________________________
//  The Pad class is the most important graphics class in the ROOT system.
//Begin_Html
/*
<img src="gif/tpad_classtree.gif">
*/
//End_Html
//  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.
//  This signal is generally sent when typing carriage return in the
//  command input or when a graphical operation has been performed on one
//  of the pads of this canvas.
//  When a Canvas/Pad is repainted, the member function Paint for all
//  objects in the Pad linked list is invoked.
//
//  When the mouse is moved on the Pad, The member function DistancetoPrimitive
//  is called for all the elements in the pad. DistancetoPrimitive returns
//  the distance in pixels to this object.
//  when the object is within the distance window, the member function
//  ExecuteEvent is called for this object.
//  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.
//  An example of pads hierarchy is shown below:
//Begin_Html
/*
<img src="gif/canvas.gif">
*/
//End_Html
//


//______________________________________________________________________________
TPad::TPad()
{
   // Pad default constructor.

   fModified   = kTRUE;
   fTip        = 0;
   fPadPointer = 0;
   fPrimitives = 0;
   fExecs      = 0;
   fCanvas     = 0;
   fMother     = 0;
   fPadPaint   = 0;
   fPixmapID   = -1;
   fGLDevice   = -1;
   fCopyGLDevice = kFALSE;
   fEmbeddedGL = kFALSE;
   fTheta      = 30;
   fPhi        = 30;
   fNumber     = 0;
   fAbsCoord   = kFALSE;
   fEditable   = kTRUE;
   fCrosshair  = 0;
   fCrosshairPos = 0;
   fPadView3D  = 0;
   fMother     = (TPad*)gPad;

   fAbsHNDC      = 0.;
   fAbsPixeltoXk = 0.;
   fAbsPixeltoYk = 0.;
   fAbsWNDC      = 0.;
   fAbsXlowNDC   = 0.;
   fAbsYlowNDC   = 0.;
   fBorderMode   = 0;
   fBorderSize   = 0;
   fPixeltoX     = 0;
   fPixeltoXk    = 0.;
   fPixeltoY     = 0.;
   fPixeltoYk    = 0.;
   fUtoAbsPixelk = 0.;
   fUtoPixel     = 0.;
   fUtoPixelk    = 0.;
   fVtoAbsPixelk = 0.;
   fVtoPixel     = 0.;
   fVtoPixelk    = 0.;
   fXtoAbsPixelk = 0.;
   fXtoPixel     = 0.;
   fXtoPixelk    = 0.;
   fYtoAbsPixelk = 0.;
   fYtoPixel     = 0.;
   fYtoPixelk    = 0.;
   fXUpNDC       = 0.;
   fYUpNDC       = 0.;

   fFixedAspectRatio = kFALSE;
   fAspectRatio      = 0.;

   fLogx  = 0;
   fLogy  = 0;
   fLogz  = 0;
   fGridx = 0;
   fGridy = 0;
   fTickx = 0;
   fTicky = 0;
   fFrame = 0;
   fView  = 0;

   fUxmin = fUymin = fUxmax = fUymax = 0;

   // Set default world coordinates to NDC [0,1]
   fX1 = 0;
   fX2 = 1;
   fY1 = 0;
   fY2 = 1;

   // Set default pad range
   fXlowNDC = 0;
   fYlowNDC = 0;
   fWNDC    = 1;
   fHNDC    = 1;

   fViewer3D = 0;
   SetBit(kMustCleanup);

   // the following line is temporarily disabled. It has side effects
   // when the pad is a TDrawPanelHist or a TFitPanel.
   // the line was supposed to fix a problem with DrawClonePad
   //   gROOT->SetSelectedPad(this);
}


//______________________________________________________________________________
TPad::TPad(const char *name, const char *title, Double_t xlow,
           Double_t ylow, Double_t xup, Double_t yup,
           Color_t color, Short_t bordersize, Short_t bordermode)
          : TVirtualPad(name,title,xlow,ylow,xup,yup,color,bordersize,bordermode)
{
   // 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

   fModified   = kTRUE;
   fTip        = 0;
   fBorderSize = bordersize;
   fBorderMode = bordermode;
   if (gPad)   fCanvas = gPad->GetCanvas();
   else        fCanvas = (TCanvas*)this;
   fMother     = (TPad*)gPad;
   fPrimitives = new TList;
   fExecs      = new TList;
   fPadPointer = 0;
   fTheta      = 30;
   fPhi        = 30;
   fGridx      = gStyle->GetPadGridX();
   fGridy      = gStyle->GetPadGridY();
   fTickx      = gStyle->GetPadTickX();
   fTicky      = gStyle->GetPadTickY();
   fFrame      = 0;
   fView       = 0;
   fPadPaint   = 0;
   fPadView3D  = 0;
   fPixmapID   = -1;      // -1 means pixmap will be created by ResizePad()
   fCopyGLDevice = kFALSE;
   fEmbeddedGL = kFALSE;
   fNumber     = 0;
   fAbsCoord   = kFALSE;
   fEditable   = kTRUE;
   fCrosshair  = 0;
   fCrosshairPos = 0;

   fFixedAspectRatio = kFALSE;
   fAspectRatio      = 0.;

   fViewer3D = 0;

   fGLDevice = fCanvas->GetGLDevice();
   // Set default world coordinates to NDC [0,1]
   fX1 = 0;
   fX2 = 1;
   fY1 = 0;
   fY2 = 1;

   if (!gPad) {
      Error("TPad", "You must create a TCanvas before creating a TPad");
      MakeZombie();
      return;
   }

   TPad *padsav = (TPad*)gPad;

   if ((xlow < 0) || (xlow > 1) || (ylow < 0) || (ylow > 1)) {
      Error("TPad", "illegal bottom left position: x=%f, y=%f", xlow, ylow);
      goto zombie;
   }
   if ((xup < 0) || (xup > 1) || (yup < 0) || (yup > 1)) {
      Error("TPad", "illegal top right position: x=%f, y=%f", xup, yup);
      goto zombie;
   }

   fLogx = gStyle->GetOptLogx();
   fLogy = gStyle->GetOptLogy();
   fLogz = gStyle->GetOptLogz();

   fUxmin = fUymin = fUxmax = fUymax = 0;

   // Set pad parameters and Compute conversion coeeficients
   SetPad(name, title, xlow, ylow, xup, yup, color, bordersize, bordermode);
   Range(0, 0, 1, 1);
   SetBit(kMustCleanup);
   SetBit(kCanDelete);

   padsav->cd();
   return;

zombie:
   // error in creating pad occured, make this pad a zombie
   MakeZombie();
   padsav->cd();
}


//______________________________________________________________________________
TPad::~TPad()
{
   // Pad destructor.

   if (!TestBit(kNotDeleted)) return;
   Close();
   CloseToolTip(fTip);
   DeleteToolTip(fTip);
   SafeDelete(fPrimitives);
   SafeDelete(fExecs);
   delete fViewer3D;
}


//______________________________________________________________________________
void TPad::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 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.

   if (!fExecs) fExecs = new TList;
   TExec *ex = new TExec(name,command);
   fExecs->Add(ex);
}


//______________________________________________________________________________
void TPad::AutoExec()
{
   // Execute the list of Execs when a pad event occurs.

   if (GetCrosshair()) DrawCrosshair();

   if (!fExecs) fExecs = new TList;
   TIter next(fExecs);
   TExec *exec;
   while ((exec = (TExec*)next())) {
      exec->Exec();
   }
}


//______________________________________________________________________________
void TPad::Browse(TBrowser *b)
{
   // Browse pad.

   cd();
   if (fPrimitives) fPrimitives->Browse(b);
}


//______________________________________________________________________________
TLegend *TPad::BuildLegend(Double_t x1, Double_t y1, Double_t x2, Double_t y2,
                           const char* title)
{
   // 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.

   TList *lop=GetListOfPrimitives();
   if (!lop) return 0;
   TLegend *leg=0;
   TIter next(lop);
   TString mes;
   TObject *o=0;
   while( (o=next()) ) {
      if((o->InheritsFrom(TAttLine::Class()) || o->InheritsFrom(TAttMarker::Class()) ||
          o->InheritsFrom(TAttFill::Class())) &&
         ( !(o->InheritsFrom(TFrame::Class())) && !(o->InheritsFrom(TPave::Class())) )) {
            if (!leg) leg = new TLegend(x1, y1, x2, y2, title);
            if (o->InheritsFrom(TNamed::Class()) && strlen(((TNamed *)o)->GetTitle()))
               mes = ((TNamed *)o)->GetTitle();
            else if (strlen(o->GetName()))
               mes = o->GetName();
            else
               mes = o->ClassName();
            TString opt("");
            if (o->InheritsFrom(TAttLine::Class()))   opt += "l";
            if (o->InheritsFrom(TAttMarker::Class())) opt += "p";
            if (o->InheritsFrom(TAttFill::Class()))   opt += "f";
            leg->AddEntry(o,mes.Data(),opt.Data());
      } else if ( o->InheritsFrom(TMultiGraph::Class() ) ) {
         if (!leg) leg = new TLegend(x1, y1, x2, y2, title);
         TList * grlist = ((TMultiGraph *)o)->GetListOfGraphs();
         TIter nextgraph(grlist);
         TGraph * gr;
         TObject * obj;
         while ((obj = nextgraph())) {
            gr = (TGraph*) obj;
            if      (strlen(gr->GetTitle())) mes = gr->GetTitle();
            else if (strlen(gr->GetName()))  mes = gr->GetName();
            else                             mes = gr->ClassName();
            leg->AddEntry( obj, mes.Data(), "lpf" );
         }
      } else if ( o->InheritsFrom(THStack::Class() ) ) {
         if (!leg) leg = new TLegend(x1, y1, x2, y2, title);
         TList * hlist = ((THStack *)o)->GetHists();
         TIter nexthist(hlist);
         TH1 * hist;
         TObject * obj;
         while ((obj = nexthist())) {
            hist = (TH1*) obj;
            if      (strlen(hist->GetTitle())) mes = hist->GetTitle();
            else if (strlen(hist->GetName()))  mes = hist->GetName();
            else                               mes = hist->ClassName();
            leg->AddEntry( obj, mes.Data(), "lpf" );
         }
      }
   }
   if (leg) {
      TVirtualPad *gpadsave;
      gpadsave = gPad;
      this->cd();
      leg->Draw();
      gpadsave->cd();
   } else {
      Info("BuildLegend(void)","No object to build a TLegend.");
   }
   return leg;
}


//______________________________________________________________________________
TVirtualPad *TPad::cd(Int_t subpadnumber)
{
   // 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);

   if (!subpadnumber) {
      gPad = this;
      if (!gPad->IsBatch() && GetPainter()) GetPainter()->SelectDrawable(fPixmapID);
      return gPad;
   }

   TObject *obj;
   if (!fPrimitives) fPrimitives = new TList;
   TIter    next(fPrimitives);
   while ((obj = next())) {
      if (obj->InheritsFrom(TPad::Class())) {
         Int_t n = ((TPad*)obj)->GetNumber();
         if (n == subpadnumber) {
            return ((TPad*)obj)->cd();
         }
      }
   }
   return 0;
}


//______________________________________________________________________________
void TPad::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)

   if (!IsEditable()) return;

   R__LOCKGUARD2(gROOTMutex);

   if (!fPadPaint) {
      SafeDelete(fView);
      if (fPrimitives) fPrimitives->Clear(option);
      if (fFrame) {
         if (fFrame->TestBit(kNotDeleted)) delete fFrame;
         fFrame = 0;
      }
   }
   if (fCanvas) fCanvas->Cleared(this);

   cd();

   if (TestBit(kClearAfterCR)) {
      // Intentional do not use the return value of getchar,
      // we just want to get it and forget it
      getchar();
   }

   if (!gPad->IsBatch()) GetPainter()->ClearDrawable();
   if (gVirtualPS && gPad == gPad->GetCanvas()) gVirtualPS->NewPage();

   PaintBorder(GetFillColor(), kTRUE);
   fCrosshairPos = 0;
   ResetBit(TGraph::kClipFrame);
}


//___________________________________________________________
Int_t TPad::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.
   //
   // _Input parameters:
   //
   //  x[2], y[2] : Segment coordinates
   //  xclipl, yclipb, xclipr, yclipt : Clipping boundary
   //
   // _Output parameters:
   //
   //  x[2], y[2] : New segment coordinates

   const Float_t kP=10000;
   Int_t clip = 0;

   for (Int_t i=0;i<2;i++) {
      if (TMath::Abs(xclipl-x[i]) <= TMath::Abs(xclipr-xclipl)/kP) x[i] = xclipl;
      if (TMath::Abs(xclipr-x[i]) <= TMath::Abs(xclipr-xclipl)/kP) x[i] = xclipr;
      if (TMath::Abs(yclipb-y[i]) <= TMath::Abs(yclipt-yclipb)/kP) y[i] = yclipb;
      if (TMath::Abs(yclipt-y[i]) <= TMath::Abs(yclipt-yclipb)/kP) y[i] = yclipt;
   }

   // Compute the first endpoint codes.
   Int_t code1 = ClippingCode(x[0],y[0],xclipl,yclipb,xclipr,yclipt);
   Int_t code2 = ClippingCode(x[1],y[1],xclipl,yclipb,xclipr,yclipt);

   Double_t xt=0, yt=0;
   Int_t clipped = 0; //this variable could be used in a future version
   while(code1 + code2) {
      clipped = 1;

      // The line lies entirely outside the clipping boundary
      if (code1&code2) {
         clip = 2;
         return clip;
      }

      // The line is subdivided into several parts
      Int_t ic = code1;
      if (ic == 0) ic = code2;
      if (ic & 0x1) {
         yt = y[0] + (y[1]-y[0])*(xclipl-x[0])/(x[1]-x[0]);
         xt = xclipl;
      }
      if (ic & 0x2) {
         yt = y[0] + (y[1]-y[0])*(xclipr-x[0])/(x[1]-x[0]);
         xt = xclipr;
      }
      if (ic & 0x4) {
         xt = x[0] + (x[1]-x[0])*(yclipb-y[0])/(y[1]-y[0]);
         yt = yclipb;
      }
      if (ic & 0x8) {
         xt = x[0] + (x[1]-x[0])*(yclipt-y[0])/(y[1]-y[0]);
         yt = yclipt;
      }
      if (ic == code1) {
         x[0]  = xt;
         y[0]  = yt;
         code1 = ClippingCode(xt,yt,xclipl,yclipb,xclipr,yclipt);
      } else {
         x[1]  = xt;
         y[1]  = yt;
         code2 = ClippingCode(xt,yt,xclipl,yclipb,xclipr,yclipt);
      }
   }
   clip = clipped;
   return clip;
}


//___________________________________________________________
Int_t TPad::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.
   //
   // _Input parameters:
   //
   //  x[2], y[2] : Segment coordinates
   //  xclipl, yclipb, xclipr, yclipt : Clipping boundary
   //
   // _Output parameters:
   //
   //  x[2], y[2] : New segment coordinates

   const Double_t kP=10000;
   Int_t clip = 0;

   for (Int_t i=0;i<2;i++) {
      if (TMath::Abs(xclipl-x[i]) <= TMath::Abs(xclipr-xclipl)/kP) x[i] = xclipl;
      if (TMath::Abs(xclipr-x[i]) <= TMath::Abs(xclipr-xclipl)/kP) x[i] = xclipr;
      if (TMath::Abs(yclipb-y[i]) <= TMath::Abs(yclipt-yclipb)/kP) y[i] = yclipb;
      if (TMath::Abs(yclipt-y[i]) <= TMath::Abs(yclipt-yclipb)/kP) y[i] = yclipt;
   }

   // Compute the first endpoint codes.
   Int_t code1 = 0;
   if (x[0] < xclipl) code1 = code1 | 0x1;
   if (x[0] > xclipr) code1 = code1 | 0x2;
   if (y[0] < yclipb) code1 = code1 | 0x4;
   if (y[0] > yclipt) code1 = code1 | 0x8;
   Int_t code2 = 0;
   if (x[1] < xclipl) code2 = code2 | 0x1;
   if (x[1] > xclipr) code2 = code2 | 0x2;
   if (y[1] < yclipb) code2 = code2 | 0x4;
   if (y[1] > yclipt) code2 = code2 | 0x8;

   Double_t xt=0, yt=0;
   Int_t clipped = 0; //this variable could be used in a future version
   while(code1 + code2) {
      clipped = 1;

      // The line lies entirely outside the clipping boundary
      if (code1&code2) {
         clip = 2;
         return clip;
      }

      // The line is subdivided into several parts
      Int_t ic = code1;
      if (ic == 0) ic = code2;
      if (ic & 0x1) {
         yt = y[0] + (y[1]-y[0])*(xclipl-x[0])/(x[1]-x[0]);
         xt = xclipl;
      }
      if (ic & 0x2) {
         yt = y[0] + (y[1]-y[0])*(xclipr-x[0])/(x[1]-x[0]);
         xt = xclipr;
      }
      if (ic & 0x4) {
         xt = x[0] + (x[1]-x[0])*(yclipb-y[0])/(y[1]-y[0]);
         yt = yclipb;
      }
      if (ic & 0x8) {
         xt = x[0] + (x[1]-x[0])*(yclipt-y[0])/(y[1]-y[0]);
         yt = yclipt;
      }
      if (ic == code1) {
         x[0]  = xt;
         y[0]  = yt;
         code1 = ClippingCode(xt,yt,xclipl,yclipb,xclipr,yclipt);
      } else {
         x[1]  = xt;
         y[1]  = yt;
         code2 = ClippingCode(xt,yt,xclipl,yclipb,xclipr,yclipt);
      }
   }
   clip = clipped;
   return clip;
}


//___________________________________________________________
Int_t TPad::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.

   Int_t code = 0;
   if (x < xcl1) code = code | 0x1;
   if (x > xcl2) code = code | 0x2;
   if (y < ycl1) code = code | 0x4;
   if (y > ycl2) code = code | 0x8;
   return code;
}


//___________________________________________________________
Int_t TPad::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.
   //
   // 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

   Int_t nc, nc2;
   Double_t x1, y1, x2, y2, slope; // Segment to be clipped

   Double_t *xc2 = new Double_t[nn];
   Double_t *yc2 = new Double_t[nn];

   // Clip against the left boundary
   x1 = x[n-1]; y1 = y[n-1];
   nc2 = 0;
   Int_t i;
   for (i=0; i<n; i++) {
      x2 = x[i]; y2 = y[i];
      if (x1 == x2) {
         slope = 0;
      } else {
         slope = (y2-y1)/(x2-x1);
      }
      if (x1 >= xclipl) {
         if (x2 < xclipl) {
            xc2[nc2] = xclipl; yc2[nc2++] = slope*(xclipl-x1)+y1;
         } else {
            xc2[nc2] = x2; yc2[nc2++] = y2;
         }
      } else {
         if (x2 >= xclipl) {
            xc2[nc2] = xclipl; yc2[nc2++] = slope*(xclipl-x1)+y1;
            xc2[nc2] = x2; yc2[nc2++] = y2;
         }
      }
      x1 = x2; y1 = y2;
   }

   // Clip against the top boundary
   x1 = xc2[nc2-1]; y1 = yc2[nc2-1];
   nc = 0;
   for (i=0; i<nc2; i++) {
      x2 = xc2[i]; y2 = yc2[i];
      if (y1 == y2) {
         slope = 0;
      } else {
         slope = (x2-x1)/(y2-y1);
      }
      if (y1 <= yclipt) {
         if (y2 > yclipt) {
            xc[nc] = x1+(yclipt-y1)*slope; yc[nc++] = yclipt;
         } else {
            xc[nc] = x2; yc[nc++] = y2;
         }
      } else {
         if (y2 <= yclipt) {
            xc[nc] = x1+(yclipt-y1)*slope; yc[nc++] = yclipt;
            xc[nc] = x2; yc[nc++] = y2;
         }
      }
      x1 = x2; y1 = y2;
   }

   // Clip against the right boundary
   x1 = xc[nc-1]; y1 = yc[nc-1];
   nc2 = 0;
   for (i=0; i<nc; i++) {
      x2 = xc[i]; y2 = yc[i];
      if (x1 == x2) {
         slope = 0;
      } else {
         slope = (y2-y1)/(x2-x1);
      }
      if (x1 <= xclipr) {
         if (x2 > xclipr) {
            xc2[nc2] = xclipr; yc2[nc2++] = slope*(xclipr-x1)+y1;
         } else {
            xc2[nc2] = x2; yc2[nc2++] = y2;
         }
      } else {
         if (x2 <= xclipr) {
            xc2[nc2] = xclipr; yc2[nc2++] = slope*(xclipr-x1)+y1;
            xc2[nc2] = x2; yc2[nc2++] = y2;
         }
      }
      x1 = x2; y1 = y2;
   }

   // Clip against the bottom boundary
   x1 = xc2[nc2-1]; y1 = yc2[nc2-1];
   nc = 0;
   for (i=0; i<nc2; i++) {
      x2 = xc2[i]; y2 = yc2[i];
      if (y1 == y2) {
         slope = 0;
      } else {
         slope = (x2-x1)/(y2-y1);
      }
      if (y1 >= yclipb) {
         if (y2 < yclipb) {
            xc[nc] = x1+(yclipb-y1)*slope; yc[nc++] = yclipb;
         } else {
            xc[nc] = x2; yc[nc++] = y2;
         }
      } else {
         if (y2 >= yclipb) {
            xc[nc] = x1+(yclipb-y1)*slope; yc[nc++] = yclipb;
            xc[nc] = x2; yc[nc++] = y2;
         }
      }
      x1 = x2; y1 = y2;
   }

   delete [] xc2;
   delete [] yc2;

   if (nc < 3) nc =0;
   return nc;
}


//______________________________________________________________________________
void TPad::Close(Option_t *)
{
   // Delete all primitives in pad and pad itself.
   // Pad cannot be used anymore after this call.
   // Emits signal "Closed()".

   if (!TestBit(kNotDeleted)) return;
   if (!fMother) return;

   if (fPrimitives)
      fPrimitives->Clear();
   if (fView) {
      if (fView->TestBit(kNotDeleted)) delete fView;
      fView = 0;
   }
   if (fFrame) {
      if (fFrame->TestBit(kNotDeleted)) delete fFrame;
      fFrame = 0;
   }

   // emit signal
   if (IsA() != TCanvas::Class())
      Closed();

   if (fPixmapID != -1) {
      if (gPad) {
         if (!gPad->IsBatch()) {
            GetPainter()->SelectDrawable(fPixmapID);
            GetPainter()->DestroyDrawable();
         }
      }
      fPixmapID = -1;

      if (!gROOT->GetListOfCanvases()) return;
      if (fMother == this) {
         gROOT->GetListOfCanvases()->Remove(this);
         return;   // in case of TCanvas
      }

      // remove from the mother's list of primitives
      if (fMother) {
         if (fMother->GetListOfPrimitives())
            fMother->GetListOfPrimitives()->Remove(this);

         if (gPad == this) fMother->cd();
      }

      if (fCanvas->GetPadSave() == this)
         fCanvas->ClearPadSave();
      if (fCanvas->GetSelectedPad() == this)
         fCanvas->SetSelectedPad(0);
      if (fCanvas->GetClickSelectedPad() == this)
         fCanvas->SetClickSelectedPad(0);
   }

   fMother = 0;
   if (gROOT->GetSelectedPad() == this) gROOT->SetSelectedPad(0);
}


//______________________________________________________________________________
void TPad::CopyPixmap()
{
   // Copy the pixmap of the pad to the canvas.

   int px, py;
   XYtoAbsPixel(fX1, fY2, px, py);

   if (fPixmapID != -1)
      GetPainter()->CopyDrawable(fPixmapID, px, py);

   if (this == gPad) HighLight(gPad->GetHighLightColor());
}


//______________________________________________________________________________
void TPad::CopyPixmaps()
{
   // Copy the sub-pixmaps of the pad to the canvas.

   TObject *obj;
   if (!fPrimitives) fPrimitives = new TList;
   TIter    next(GetListOfPrimitives());
   while ((obj = next())) {
      if (obj->InheritsFrom(TPad::Class())) {
         ((TPad*)obj)->CopyPixmap();
         ((TPad*)obj)->CopyPixmaps();
      }
   }
}


//______________________________________________________________________________
void TPad::DeleteExec(const char *name)
{
   // Remove TExec name from the list of Execs.

   if (!fExecs) fExecs = new TList;
   TExec *ex = (TExec*)fExecs->FindObject(name);
   if (!ex) return;
   fExecs->Remove(ex);
   delete ex;
}


//______________________________________________________________________________
Int_t TPad::DistancetoPrimitive(Int_t px, Int_t py)
{
   // 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.

   Int_t pxl, pyl, pxt, pyt;
   Int_t px1 = gPad->XtoAbsPixel(fX1);
   Int_t py1 = gPad->YtoAbsPixel(fY1);
   Int_t px2 = gPad->XtoAbsPixel(fX2);
   Int_t py2 = gPad->YtoAbsPixel(fY2);
   if (px1 < px2) {pxl = px1; pxt = px2;}
   else           {pxl = px2; pxt = px1;}
   if (py1 < py2) {pyl = py1; pyt = py2;}
   else           {pyl = py2; pyt = py1;}

   // Are we inside the box?
   // ======================
   if ( (px > pxl && px < pxt) && (py > pyl && py < pyt) ) {
      if (GetFillStyle()) return 0;  //*-* if pad is filled
   }

   // Are we on the edges?
   // ====================
   Int_t dxl = TMath::Abs(px - pxl);
   if (py < pyl) dxl += pyl - py; if (py > pyt) dxl += py - pyt;
   Int_t dxt = TMath::Abs(px - pxt);
   if (py < pyl) dxt += pyl - py; if (py > pyt) dxt += py - pyt;
   Int_t dyl = TMath::Abs(py - pyl);
   if (px < pxl) dyl += pxl - px; if (px > pxt) dyl += px - pxt;
   Int_t dyt = TMath::Abs(py - pyt);
   if (px < pxl) dyt += pxl - px; if (px > pxt) dyt += px - pxt;

   Int_t distance = dxl;
   if (dxt < distance) distance = dxt;
   if (dyl < distance) distance = dyl;
   if (dyt < distance) distance = dyt;

   return distance - Int_t(0.5*fLineWidth);
}


//______________________________________________________________________________
void TPad::Divide(Int_t nx, Int_t ny, Float_t xmargin, Float_t ymargin, Int_t color)
{
   // 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.

   if (!IsEditable()) return;


   if (gThreadXAR) {
      void *arr[7];
      arr[1] = this; arr[2] = (void*)&nx;arr[3] = (void*)& ny;
      arr[4] = (void*)&xmargin; arr[5] = (void *)& ymargin; arr[6] = (void *)&color;
      if ((*gThreadXAR)("PDCD", 7, arr, 0)) return;
   }

   TPad *padsav = (TPad*)gPad;
   cd();
   if (nx <= 0) nx = 1;
   if (ny <= 0) ny = 1;
   Int_t ix,iy;
   Double_t x1,y1,x2,y2;
   Double_t dx,dy;
   TPad *pad;
   Int_t nchname  = strlen(GetName())+6;
   Int_t nchtitle = strlen(GetTitle())+6;
   char *name  = new char [nchname];
   char *title = new char [nchtitle];
   Int_t n = 0;
   if (color == 0) color = GetFillColor();
   if (xmargin > 0 && ymargin > 0) {
      //general case
      dy = 1/Double_t(ny);
      dx = 1/Double_t(nx);
      for (iy=0;iy<ny;iy++) {
         y2 = 1 - iy*dy - ymargin;
         y1 = y2 - dy + 2*ymargin;
         if (y1 < 0) y1 = 0;
         if (y1 > y2) continue;
         for (ix=0;ix<nx;ix++) {
            x1 = ix*dx + xmargin;
            x2 = x1 +dx -2*xmargin;
            if (x1 > x2) continue;
            n++;
            snprintf(name,nchname,"%s_%d",GetName(),n);
            pad = new TPad(name,name,x1,y1,x2,y2,color);
            pad->SetNumber(n);
            pad->Draw();
         }
      }
   } else {
      // special case when xmargin <= 0 && ymargin <= 0
      Double_t xl = GetLeftMargin();
      Double_t xr = GetRightMargin();
      Double_t yb = GetBottomMargin();
      Double_t yt = GetTopMargin();
      xl /= (1-xl+xr)*nx;
      xr /= (1-xl+xr)*nx;
      yb /= (1-yb+yt)*ny;
      yt /= (1-yb+yt)*ny;
      SetLeftMargin(xl);
      SetRightMargin(xr);
      SetBottomMargin(yb);
      SetTopMargin(yt);
      dx = (1-xl-xr)/nx;
      dy = (1-yb-yt)/ny;
      Int_t number = 0;
      for (Int_t i=0;i<nx;i++) {
         x1 = i*dx+xl;
         x2 = x1 + dx;
         if (i == 0) x1 = 0;
         if (i == nx-1) x2 = 1-xr;
         for (Int_t j=0;j<ny;j++) {
            number = j*nx + i +1;
            y2 = 1 -j*dy -yt;
            y1 = y2 - dy;
            if (j == 0)    y2 = 1-yt;
            if (j == ny-1) y1 = 0;
            snprintf(name,nchname,"%s_%d",GetName(),number);
            snprintf(title,nchtitle,"%s_%d",GetTitle(),number);
            pad = new TPad(name,title,x1,y1,x2,y2);
            pad->SetNumber(number);
            pad->SetBorderMode(0);
            if (i == 0)    pad->SetLeftMargin(xl*nx);
            else           pad->SetLeftMargin(0);
                           pad->SetRightMargin(0);
                           pad->SetTopMargin(0);
            if (j == ny-1) pad->SetBottomMargin(yb*ny);
            else           pad->SetBottomMargin(0);
            pad->Draw();
         }
      }
   }
   delete [] name;
   delete [] title;
   Modified();
   if (padsav) padsav->cd();
}


//______________________________________________________________________________
void TPad::DivideSquare(Int_t n, Float_t xmargin, Float_t ymargin, Int_t color)
{
   // "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.

   Int_t w = 1, h = 1;

   if (fCanvas->GetWindowWidth() > fCanvas->GetWindowHeight()) {
      w = TMath::Ceil(TMath::Sqrt(n));
      h = TMath::Floor(TMath::Sqrt(n));
      if (w*h < n) w++;
   } else {
      h = TMath::Ceil(TMath::Sqrt(n));
      w = TMath::Floor(TMath::Sqrt(n));
      if (w*h < n) h++;
   }

   Divide( w, h, xmargin, ymargin, color);
}


//______________________________________________________________________________
void TPad::Draw(Option_t *option)
{
   // Draw Pad in Current pad (re-parent pad if necessary).

   // if no canvas opened yet create a default canvas
   if (!gPad) {
      gROOT->MakeDefCanvas();
   }

   // pad cannot be in itself and it can only be in one other pad at a time
   if (!fPrimitives) fPrimitives = new TList;
   if (gPad != this) {
      if (fMother) fMother->GetListOfPrimitives()->Remove(this);
      TPad *oldMother = fMother;
      fCanvas = gPad->GetCanvas();
      //
      fMother = (TPad*)gPad;
      if (oldMother != fMother || fPixmapID == -1) ResizePad();
   }

   Paint();

   if (gPad->IsRetained() && gPad != this && fMother)
      fMother->GetListOfPrimitives()->Add(this, option);
}


//______________________________________________________________________________
void TPad::DrawClassObject(const TObject *classobj, 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.
   // The following picture is the class inheritance tree of class TPaveLabel:
   //Begin_Html
   /*
   <img src="gif/drawclass.gif">
   */
   //End_Html

   char dname[256];
   const Int_t kMAXLEVELS = 10;
   TClass *clevel[kMAXLEVELS], *cl, *cll;
   TBaseClass *base, *cinherit;
   TText *ptext = 0;
   TString opt=option;
   Double_t x,y,dy,y1,v1,v2,dv;
   Int_t nd,nf,nc,nkd,nkf,i,j;
   TPaveText *pt;
   Int_t maxlev = 4;
   if (opt.Contains("2")) maxlev = 2;
   if (opt.Contains("3")) maxlev = 3;
   if (opt.Contains("5")) maxlev = 5;
   if (opt.Contains("6")) maxlev = 6;
   if (opt.Contains("7")) maxlev = 7;

      // Clear and Set Pad range
   Double_t xpad = 20.5;
   Double_t ypad = 27.5;
   Clear();
   Range(0,0,xpad,ypad);

   // Find number of levels
   Int_t nlevel = 0;
   TClass *obj = (TClass*)classobj;
   clevel[nlevel] = obj;
   TList *lbase = obj->GetListOfBases();
   while(lbase) {
      base = (TBaseClass*)lbase->First();
      if (!base) break;
      if ( base->GetClassPointer() == 0) break;
      nlevel++;
      clevel[nlevel] = base->GetClassPointer();
      lbase = clevel[nlevel]->GetListOfBases();
      if (nlevel >= maxlev-1) break;
   }
   Int_t maxelem = 0;
   Int_t ncdraw  = 0;
   Int_t ilevel, nelem;
   for (ilevel=nlevel;ilevel>=0;ilevel--) {
      cl = clevel[ilevel];
      nelem = cl->GetNdata() + cl->GetNmethods();
      if (nelem > maxelem) maxelem = nelem;
      nc = (nelem/50) + 1;
      ncdraw += nc;
   }

   Double_t tsizcm = 0.40;
   Double_t x1 = 0.25;
   Double_t x2 = 0;
   Double_t dx = 3.5;
   if (ncdraw > 4) {
      dx = dx - 0.42*Double_t(ncdraw-5);
      if (dx < 1.3) dx = 1.3;
      tsizcm = tsizcm - 0.03*Double_t(ncdraw-5);
      if (tsizcm < 0.27) tsizcm = 0.27;
   }
   Double_t tsiz = 1.2*tsizcm/ypad;

   // Now loop on levels
   for (ilevel=nlevel;ilevel>=0;ilevel--) {
      cl    = clevel[ilevel];
      nelem = cl->GetNdata() + cl->GetNmethods();
      if (nelem > maxelem) maxelem = nelem;
      nc    = (nelem/50) + 1;
      dy    = 0.45;
      if (ilevel < nlevel) x1 = x2 + 0.5;
      x2    = x1 + nc*dx;
      v2    = ypad - 0.5;
      lbase = cl->GetListOfBases();
      cinherit = 0;
      if (lbase) cinherit = (TBaseClass*)lbase->First();

      do {
         nd = cl->GetNdata();
         nf = cl->GetNmethods() - 2; //do not show default constructor and destructor
         if (cl->GetListOfMethods()->FindObject("Dictionary")) {
            nf -= 6;  // do not count the Dictionary/ClassDef functions
         }
         nkf= nf/nc +1;
         nkd= nd/nc +1;
         if (nd == 0) nkd=0;
         if (nf == 0) nkf=0;
         y1 = v2 - 0.7;
         v1 = y1 - Double_t(nkf+nkd+nc-1)*dy;
         dv = v2 - v1;

         // Create a new PaveText
         pt = new TPaveText(x1,v1,x2,v2);
         pt->SetBit(kCanDelete);
         pt->SetFillColor(19);
         pt->Draw();
         pt->SetTextColor(4);
         pt->SetTextFont(61);
         pt->SetTextAlign(12);
         pt->SetTextSize(tsiz);
         TBox *box = pt->AddBox(0,(y1+0.01-v1)/dv,0,(v2-0.01-v1)/dv);
         if (box) box->SetFillColor(17);
         pt->AddLine(0,(y1-v1)/dv,0,(y1-v1)/dv);
         TText *title = pt->AddText(0.5,(0.5*(y1+v2)-v1)/dv,(char*)cl->GetName());
         title->SetTextAlign(22);
         title->SetTextSize(0.6*(v2-y1)/ypad);

         // Draw data Members
         i = 0;
         x = 0.03;
         y = y1 + 0.5*dy;
         TDataMember *d;
         TIter        nextd(cl->GetListOfDataMembers());
         while ((d = (TDataMember *) nextd())) {
            if (i >= nkd) { i = 1; y = y1 - 0.5*dy; x += 1/Double_t(nc); }
            else { i++; y -= dy; }

            // Take in account the room the array index will occupy

            Int_t dim = d->GetArrayDim();
            Int_t indx = 0;
            snprintf(dname,256,"%s",obj->EscapeChars(d->GetName()));
            Int_t ldname = 0;
            while (indx < dim ){
               ldname = strlen(dname);
               snprintf(&dname[ldname],256,"[%d]",d->GetMaxIndex(indx));
               indx++;
            }
            pt->AddText(x,(y-v1)/dv,dname);
         }

         // Draw a separator line
         Double_t ysep;
         if (nd) {
            ysep = y1 - Double_t(nkd)*dy;
            pt->AddLine(0,(ysep-v1)/dv,0,(ysep-v1)/dv);
            ysep -= 0.5*dy;
         } else  ysep = y1;

         // Draw Member Functions
         Int_t fcount = 0;
         i = 0;
         x = 0.03;
         y = ysep + 0.5*dy;
         TMethod *m;
         TIter        nextm(cl->GetListOfMethods());
         while ((m = (TMethod *) nextm())) {
            if (
               !strcmp( m->GetName(), "Dictionary"    ) ||
               !strcmp( m->GetName(), "Class_Version" ) ||
               !strcmp( m->GetName(), "DeclFileName"  ) ||
               !strcmp( m->GetName(), "DeclFileLine"  ) ||
               !strcmp( m->GetName(), "ImplFileName"  ) ||
               !strcmp( m->GetName(), "ImplFileLine"  )
            ) continue;
            fcount++;
            if (fcount > nf) break;
            if (i >= nkf) { i = 1; y = ysep - 0.5*dy; x += 1/Double_t(nc); }
            else { i++; y -= dy; }
            ptext = pt->AddText(x,(y-v1)/dv,obj->EscapeChars(m->GetName()));

            // Check if method is overloaded in a derived class
            // If yes, Change the color of the text to blue
            for (j=ilevel-1;j>=0;j--) {
               if (cl == clevel[ilevel]) {
                  if (clevel[j]->GetMethodAny((char*)m->GetName())) {
                     ptext->SetTextColor(15);
                     break;
                  }
               }
            }
         }

         // Draw second inheritance classes for this class
         cll = 0;
         if (cinherit) {
            cinherit = (TBaseClass*)lbase->After(cinherit);
            if (cinherit) {
               cl  = cinherit->GetClassPointer();
               cll = cl;
               v2  = v1 -0.4;
               dy  = 0.35;
            }
         }
      } while (cll);
   }
   Update();
}


//______________________________________________________________________________
void TPad::DrawCrosshair()
{
   //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

   if (gPad->GetEvent() == kMouseEnter) return;

   TPad *cpad = (TPad*)gPad;
   TCanvas *canvas = cpad->GetCanvas();
   canvas->FeedbackMode(kTRUE);

   //erase old position and draw a line at current position
   Int_t pxmin,pxmax,pymin,pymax,pxold,pyold,px,py;
   pxold = fCrosshairPos%10000;
   pyold = fCrosshairPos/10000;
   px    = cpad->GetEventX();
   py    = cpad->GetEventY()+1;
   if (canvas->GetCrosshair() > 1) {  //crosshair only in the current pad
      pxmin = cpad->XtoAbsPixel(fX1);
      pxmax = cpad->XtoAbsPixel(fX2);
      pymin = cpad->YtoAbsPixel(fY1);
      pymax = cpad->YtoAbsPixel(fY2);
   } else { //default; crosshair spans the full canvas
      pxmin = 0;
      pxmax = canvas->GetWw();
      pymin = 0;
      pymax = cpad->GetWh();
   }
   if(pxold) gVirtualX->DrawLine(pxold,pymin,pxold,pymax);
   if(pyold) gVirtualX->DrawLine(pxmin,pyold,pxmax,pyold);
   if (cpad->GetEvent() == kButton1Down ||
       cpad->GetEvent() == kButton1Up   ||
       cpad->GetEvent() == kMouseLeave) {
      fCrosshairPos = 0;
      return;
   }
   gVirtualX->DrawLine(px,pymin,px,pymax);
   gVirtualX->DrawLine(pxmin,py,pxmax,py);
   fCrosshairPos = px + 10000*py;
}


//______________________________________________________________________________
TH1F *TPad::DrawFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, const char *title)
{
   //  Draw a pad frame
   //
   //  Compute real pad range taking into account all margins
   //  Use services of TH1F class
   if (!IsEditable()) return 0;
   TPad *padsav = (TPad*)gPad;
   if (this !=  padsav) {
      Warning("DrawFrame","Must be called for the current pad only");
      return padsav->DrawFrame(xmin,ymin,xmax,ymax,title);
   }

   cd();

   TH1F *hframe = (TH1F*)FindObject("hframe");
   if (hframe) delete hframe;
   Int_t nbins = 1000;
   //if log scale in X, use variable bin size linear with log(x)
   //this gives a better precision when zooming on the axis
   if (fLogx && xmin > 0 && xmax > xmin) {
      Double_t xminl = TMath::Log(xmin);
      Double_t xmaxl = TMath::Log(xmax);
      Double_t dx = (xmaxl-xminl)/nbins;
      Double_t *xbins = new Double_t[nbins+1];
      xbins[0] = xmin;
      for (Int_t i=1;i<=nbins;i++) {
         xbins[i] = TMath::Exp(xminl+i*dx);
      }
      hframe = new TH1F("hframe",title,nbins,xbins);
      delete [] xbins;
   } else {
      hframe = new TH1F("hframe",title,nbins,xmin,xmax);
   }
   hframe->SetBit(TH1::kNoStats);
   hframe->SetBit(kCanDelete);
   hframe->SetMinimum(ymin);
   hframe->SetMaximum(ymax);
   hframe->GetYaxis()->SetLimits(ymin,ymax);
   hframe->SetDirectory(0);
   hframe->Draw(" ");
   Update();
   if (padsav) padsav->cd();
   return hframe;
}

//______________________________________________________________________________
void TPad::DrawColorTable()
{
   // Static function to Display Color Table in a pad.

   Int_t i, j;
   Int_t color;
   Double_t xlow, ylow, xup, yup, hs, ws;
   Double_t x1, y1, x2, y2;
   x1 = y1 = 0;
   x2 = y2 = 20;

   gPad->SetFillColor(0);
   gPad->Clear();
   gPad->Range(x1,y1,x2,y2);

   TText *text = new TText(0,0,"");
   text->SetTextFont(61);
   text->SetTextSize(0.07);
   text->SetTextAlign(22);

   TBox *box = new TBox();

   // Draw color table boxes.
   hs = (y2-y1)/Double_t(5);
   ws = (x2-x1)/Double_t(10);
   for (i=0;i<10;i++) {
      xlow = x1 + ws*(Double_t(i)+0.1);
      xup  = x1 + ws*(Double_t(i)+0.9);
      for (j=0;j<5;j++) {
         ylow = y1 + hs*(Double_t(j)+0.1);
         yup  = y1 + hs*(Double_t(j)+0.9);
         color = 10*j + i;
         box->SetFillStyle(1001);
         box->SetFillColor(color);
         box->DrawBox(xlow, ylow, xup, yup);
         box->SetFillStyle(0);
         box->SetLineColor(1);
         box->DrawBox(xlow, ylow, xup, yup);
         if (color == 1) text->SetTextColor(0);
         else            text->SetTextColor(1);
         text->DrawText(0.5*(xlow+xup), 0.5*(ylow+yup), Form("%d",color));
      }
   }
}


//______________________________________________________________________________
void TPad::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // 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.

   const Int_t kMaxDiff = 5;
   const Int_t kMinSize = 20;
   static Int_t pxorg, pyorg;
   static Int_t px1, px2, py1, py2, pxl, pyl, pxt, pyt, pxold, pyold;
   static Int_t px1p, px2p, py1p, py2p, pxlp, pylp, pxtp, pytp;
   static Bool_t pA, pB, pC, pD, pTop, pL, pR, pBot, pINSIDE;
   Int_t  wx, wy;
   Bool_t opaque  = OpaqueMoving();
   Bool_t ropaque = OpaqueResizing();
   Bool_t fixedr  = HasFixedAspectRatio();

   if (!IsEditable() && event != kMouseEnter) return;
   TVirtualPad  *parent = GetMother();
   if (!parent->IsEditable()) return;

   HideToolTip(event);

   if (fXlowNDC < 0 && event != kButton1Down) return;
   if (fYlowNDC < 0 && event != kButton1Down) return;

   // keep old mouse position
   if (event == kButton1Down) {
      pxorg = px;
      pyorg = py;
   }

   Int_t newcode = gROOT->GetEditorMode();
   if (newcode)
      pA = pB = pC = pD = pTop = pL = pR = pBot = pINSIDE = kFALSE;
   switch (newcode) {
      case kPad:
         TCreatePrimitives::Pad(event,px,py,0);
         break;
      case kMarker:
      case kText:
         TCreatePrimitives::Text(event,px,py,newcode);
         break;
      case kLine:
         TCreatePrimitives::Line(event,px,py,kLine);
         break;
      case kArrow:
         TCreatePrimitives::Line(event,px,py,kArrow);
         break;
      case kCurlyLine:
         TCreatePrimitives::Line(event,px,py,kCurlyLine);
         break;
      case kCurlyArc:
         TCreatePrimitives::Line(event,px,py,kCurlyArc);
         break;
      case kPolyLine:
         TCreatePrimitives::PolyLine(event,px,py,kPolyLine);
         break;
      case kCutG:
         TCreatePrimitives::PolyLine(event,px,py,kCutG);
         break;
      case kArc:
         TCreatePrimitives::Ellipse(event,px,py,kArc);
         break;
      case kEllipse:
         TCreatePrimitives::Ellipse(event,px,py,kEllipse);
         break;
      case kButton:
      case kPave:
      case kPaveLabel:
      case kPaveText:
      case kPavesText:
      case kDiamond:
         TCreatePrimitives::Pave(event,px,py,newcode);
         return;
      default:
         break;
      }
      if (newcode) return;

   switch (event) {

   case kMouseEnter:
      if (fTip)
         ResetToolTip(fTip);
      break;

   case kArrowKeyPress:
   case kButton1Down:

      fXUpNDC = fXlowNDC + fWNDC;
      fYUpNDC = fYlowNDC + fHNDC;

      GetPainter()->SetLineColor(-1);
      TAttLine::Modify();  //Change line attributes only if necessary
      if (GetFillColor())
         GetPainter()->SetLineColor(GetFillColor());
      else
         GetPainter()->SetLineColor(1);
      GetPainter()->SetLineWidth(2);

      // No break !!!

   case kMouseMotion:

      px1 = XtoAbsPixel(fX1);
      py1 = YtoAbsPixel(fY1);
      px2 = XtoAbsPixel(fX2);
      py2 = YtoAbsPixel(fY2);

      if (px1 < px2) {
         pxl = px1;
         pxt = px2;
      } else {
         pxl = px2;
         pxt = px1;
      }
      if (py1 < py2) {
         pyl = py1;
         pyt = py2;
      } else {
         pyl = py2;
         pyt = py1;
      }

      px1p = parent->XtoAbsPixel(parent->GetX1()) + parent->GetBorderSize();
      py1p = parent->YtoAbsPixel(parent->GetY1()) - parent->GetBorderSize();
      px2p = parent->XtoAbsPixel(parent->GetX2()) - parent->GetBorderSize();
      py2p = parent->YtoAbsPixel(parent->GetY2()) + parent->GetBorderSize();

      if (px1p < px2p) {
         pxlp = px1p;
         pxtp = px2p;
      } else {
         pxlp = px2p;
         pxtp = px1p;
      }
      if (py1p < py2p) {
         pylp = py1p;
         pytp = py2p;
      } else {
         pylp = py2p;
         pytp = py1p;
      }

      pA = pB = pC = pD = pTop = pL = pR = pBot = pINSIDE = kFALSE;

                                                         // case pA
      if (TMath::Abs(px - pxl) <= kMaxDiff && TMath::Abs(py - pyl) <= kMaxDiff) {
         pxold = pxl; pyold = pyl; pA = kTRUE;
         SetCursor(kTopLeft);
      }
                                                         // case pB
      if (TMath::Abs(px - pxt) <= kMaxDiff && TMath::Abs(py - pyl) <= kMaxDiff) {
         pxold = pxt; pyold = pyl; pB = kTRUE;
         SetCursor(kTopRight);
      }
                                                         // case pC
      if (TMath::Abs(px - pxt) <= kMaxDiff && TMath::Abs(py - pyt) <= kMaxDiff) {
         pxold = pxt; pyold = pyt; pC = kTRUE;
         SetCursor(kBottomRight);
      }
                                                         // case pD
      if (TMath::Abs(px - pxl) <= kMaxDiff && TMath::Abs(py - pyt) <= kMaxDiff) {
         pxold = pxl; pyold = pyt; pD = kTRUE;
         SetCursor(kBottomLeft);
      }

      if ((px > pxl+kMaxDiff && px < pxt-kMaxDiff) &&
          TMath::Abs(py - pyl) < kMaxDiff) {             // top edge
         pxold = pxl; pyold = pyl; pTop = kTRUE;
         SetCursor(kTopSide);
      }

      if ((px > pxl+kMaxDiff && px < pxt-kMaxDiff) &&
          TMath::Abs(py - pyt) < kMaxDiff) {             // bottom edge
         pxold = pxt; pyold = pyt; pBot = kTRUE;
         SetCursor(kBottomSide);
      }

      if ((py > pyl+kMaxDiff && py < pyt-kMaxDiff) &&
          TMath::Abs(px - pxl) < kMaxDiff) {             // left edge
         pxold = pxl; pyold = pyl; pL = kTRUE;
         SetCursor(kLeftSide);
      }

      if ((py > pyl+kMaxDiff && py < pyt-kMaxDiff) &&
         TMath::Abs(px - pxt) < kMaxDiff) {             // right edge
         pxold = pxt; pyold = pyt; pR = kTRUE;
         SetCursor(kRightSide);
      }

      if ((px > pxl+kMaxDiff && px < pxt-kMaxDiff) &&
          (py > pyl+kMaxDiff && py < pyt-kMaxDiff)) {    // inside box
         pxold = px; pyold = py; pINSIDE = kTRUE;
         if (event == kButton1Down)
            SetCursor(kMove);
         else
            SetCursor(kCross);
      }

      fResizing = kFALSE;
      if (pA || pB || pC || pD || pTop || pL || pR || pBot)
         fResizing = kTRUE;

      if (!pA && !pB && !pC && !pD && !pTop && !pL && !pR && !pBot && !pINSIDE)
         SetCursor(kCross);

      break;

   case kArrowKeyRelease:
   case kButton1Motion:

      if (TestBit(kCannotMove)) break;
      wx = wy = 0;

      if (pA) {
         if (!ropaque) gVirtualX->DrawBox(pxold, pyt, pxt, pyold, TVirtualX::kHollow);
         if (px > pxt-kMinSize) { px = pxt-kMinSize; wx = px; }
         if (py > pyt-kMinSize) { py = pyt-kMinSize; wy = py; }
         if (px < pxlp) { px = pxlp; wx = px; }
         if (py < pylp) { py = pylp; wy = py; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(pxt-px))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = pyt - TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 < pylp) {
               px = pxold;
               py = pyold;
            } else
               py = npy2;

            wx = wy = 0;
         }
         if (!ropaque) gVirtualX->DrawBox(px, pyt, pxt, py, TVirtualX::kHollow);
      }
      if (pB) {
         if (!ropaque) gVirtualX->DrawBox(pxl  , pyt, pxold, pyold, TVirtualX::kHollow);
         if (px < pxl+kMinSize) { px = pxl+kMinSize; wx = px; }
         if (py > pyt-kMinSize) { py = pyt-kMinSize; wy = py; }
         if (px > pxtp) { px = pxtp; wx = px; }
         if (py < pylp) { py = pylp; wy = py; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(pxl-px))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = pyt - TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 < pylp) {
               px = pxold;
               py = pyold;
            } else
               py = npy2;

            wx = wy = 0;
         }
         if (!ropaque) gVirtualX->DrawBox(pxl  , pyt, px ,  py,    TVirtualX::kHollow);
      }
      if (pC) {
         if (!ropaque) gVirtualX->DrawBox(pxl  , pyl, pxold, pyold, TVirtualX::kHollow);
         if (px < pxl+kMinSize) { px = pxl+kMinSize; wx = px; }
         if (py < pyl+kMinSize) { py = pyl+kMinSize; wy = py; }
         if (px > pxtp) { px = pxtp; wx = px; }
         if (py > pytp) { py = pytp; wy = py; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(pxl-px))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = pyl + TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 > pytp) {
               px = pxold;
               py = pyold;
            } else
               py = npy2;

            wx = wy = 0;
         }
         if (!ropaque) gVirtualX->DrawBox(pxl, pyl, px, py, TVirtualX::kHollow);
      }
      if (pD) {
         if (!ropaque) gVirtualX->DrawBox(pxold, pyold, pxt, pyl, TVirtualX::kHollow);
         if (px > pxt-kMinSize) { px = pxt-kMinSize; wx = px; }
         if (py < pyl+kMinSize) { py = pyl+kMinSize; wy = py; }
         if (px < pxlp) { px = pxlp; wx = px; }
         if (py > pytp) { py = pytp; wy = py; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(pxt-px))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = pyl + TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 > pytp) {
               px = pxold;
               py = pyold;
            } else
               py = npy2;

            wx = wy = 0;
         }
         if (!ropaque) gVirtualX->DrawBox(px, py, pxt, pyl, TVirtualX::kHollow);
      }
      if (pTop) {
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
         py2 += py - pyold;
         if (py2 > py1-kMinSize) { py2 = py1-kMinSize; wy = py2; }
         if (py2 < py2p) { py2 = py2p; wy = py2; }
         if (fixedr) {
            Double_t dx = Double_t(TMath::Abs(py2-py1))/parent->VtoPixel(0) *
                          fAspectRatio;
            Int_t npx2 = px1 + parent->UtoPixel(dx);
            if (npx2 > px2p)
               py2 -= py - pyold;
            else
               px2 = npx2;
         }
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
      }
      if (pBot) {
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
         py1 += py - pyold;
         if (py1 < py2+kMinSize) { py1 = py2+kMinSize; wy = py1; }
         if (py1 > py1p) { py1 = py1p; wy = py1; }
         if (fixedr) {
            Double_t dx = Double_t(TMath::Abs(py2-py1))/parent->VtoPixel(0) *
                          fAspectRatio;
            Int_t npx2 = px1 + parent->UtoPixel(dx);
            if (npx2 > px2p)
               py1 -= py - pyold;
            else
               px2 = npx2;
         }
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
      }
      if (pL) {
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
         px1 += px - pxold;
         if (px1 > px2-kMinSize) { px1 = px2-kMinSize; wx = px1; }
         if (px1 < px1p) { px1 = px1p; wx = px1; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(px2-px1))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = py1 - TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 < py2p)
               px1 -= px - pxold;
            else
               py2 = npy2;
         }
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
      }
      if (pR) {
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
         px2 += px - pxold;
         if (px2 < px1+kMinSize) { px2 = px1+kMinSize; wx = px2; }
         if (px2 > px2p) { px2 = px2p; wx = px2; }
         if (fixedr) {
            Double_t dy = Double_t(TMath::Abs(px2-px1))/parent->UtoPixel(1.) /
                          fAspectRatio;
            Int_t npy2 = py1 - TMath::Abs(parent->VtoAbsPixel(dy) -
                                          parent->VtoAbsPixel(0));
            if (npy2 < py2p)
               px2 -= px - pxold;
            else
               py2 = npy2;
         }
         if (!ropaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);
      }
      if (pINSIDE) {
         if (!opaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);  // draw the old box
         Int_t dx = px - pxold;
         Int_t dy = py - pyold;
         px1 += dx; py1 += dy; px2 += dx; py2 += dy;
         if (px1 < px1p) { dx = px1p - px1; px1 += dx; px2 += dx; wx = px+dx; }
         if (px2 > px2p) { dx = px2 - px2p; px1 -= dx; px2 -= dx; wx = px-dx; }
         if (py1 > py1p) { dy = py1 - py1p; py1 -= dy; py2 -= dy; wy = py-dy; }
         if (py2 < py2p) { dy = py2p - py2; py1 += dy; py2 += dy; wy = py+dy; }
         if (!opaque) gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);  // draw the new box
      }

      if (wx || wy) {
         if (wx) px = wx;
         if (wy) py = wy;
         gVirtualX->Warp(px, py);
      }

      pxold = px;
      pyold = py;

      Double_t x1, y1, x2, y2;
      x1 = x2 = y1 = y2 = 0;

      if ((!fResizing && opaque) || (fResizing && ropaque)) {
         if (pA) {
            x1 = AbsPixeltoX(pxold);
            y1 = AbsPixeltoY(pyt);
            x2 = AbsPixeltoX(pxt);
            y2 = AbsPixeltoY(pyold);
         }
         if (pB) {
            x1 = AbsPixeltoX(pxl);
            y1 = AbsPixeltoY(pyt);
            x2 = AbsPixeltoX(pxold);
            y2 = AbsPixeltoY(pyold);
         }
         if (pC) {
            x1 = AbsPixeltoX(pxl);
            y1 = AbsPixeltoY(pyold);
            x2 = AbsPixeltoX(pxold);
            y2 = AbsPixeltoY(pyl);
         }
         if (pD) {
            x1 = AbsPixeltoX(pxold);
            y1 = AbsPixeltoY(pyold);
            x2 = AbsPixeltoX(pxt);
            y2 = AbsPixeltoY(pyl);
         }
         if (pTop || pBot || pL || pR || pINSIDE) {
            x1 = AbsPixeltoX(px1);
            y1 = AbsPixeltoY(py1);
            x2 = AbsPixeltoX(px2);
            y2 = AbsPixeltoY(py2);
         }

         if (px != pxorg || py != pyorg) {

            // Get parent corners pixels coordinates
            Int_t parentpx1 = fMother->XtoAbsPixel(parent->GetX1());
            Int_t parentpx2 = fMother->XtoAbsPixel(parent->GetX2());
            Int_t parentpy1 = fMother->YtoAbsPixel(parent->GetY1());
            Int_t parentpy2 = fMother->YtoAbsPixel(parent->GetY2());

            // Get pad new corners pixels coordinates
            Int_t apx1 = XtoAbsPixel(x1); if (apx1 < parentpx1) {apx1 = parentpx1; }
            Int_t apx2 = XtoAbsPixel(x2); if (apx2 > parentpx2) {apx2 = parentpx2; }
            Int_t apy1 = YtoAbsPixel(y1); if (apy1 > parentpy1) {apy1 = parentpy1; }
            Int_t apy2 = YtoAbsPixel(y2); if (apy2 < parentpy2) {apy2 = parentpy2; }

            // Compute new pad positions in the NDC space of parent
            fXlowNDC = Double_t(apx1 - parentpx1)/Double_t(parentpx2 - parentpx1);
            fYlowNDC = Double_t(apy1 - parentpy1)/Double_t(parentpy2 - parentpy1);
            fWNDC    = Double_t(apx2 - apx1)/Double_t(parentpx2 - parentpx1);
            fHNDC    = Double_t(apy2 - apy1)/Double_t(parentpy2 - parentpy1);
         }

         // Reset pad parameters and recompute conversion coefficients
         ResizePad();

         if (pINSIDE) gPad->ShowGuidelines(this, event);
         if (pTop) gPad->ShowGuidelines(this, event, 't', true);
         if (pBot) gPad->ShowGuidelines(this, event, 'b', true);
         if (pL) gPad->ShowGuidelines(this, event, 'l', true);
         if (pR) gPad->ShowGuidelines(this, event, 'r', true);
         if (pA) gPad->ShowGuidelines(this, event, '1', true);
         if (pB) gPad->ShowGuidelines(this, event, '2', true);
         if (pC) gPad->ShowGuidelines(this, event, '3', true);
         if (pD) gPad->ShowGuidelines(this, event, '4', true);

         Modified(kTRUE);
      }

      break;

   case kButton1Up:

      if (gROOT->IsEscaped()) {
         gROOT->SetEscape(kFALSE);
         break;
      }

      if (opaque||ropaque) {
         ShowGuidelines(this, event);
      } else {
         x1 = x2 = y1 = y2 = 0;

         if (pA) {
            x1 = AbsPixeltoX(pxold);
            y1 = AbsPixeltoY(pyt);
            x2 = AbsPixeltoX(pxt);
            y2 = AbsPixeltoY(pyold);
         }
         if (pB) {
            x1 = AbsPixeltoX(pxl);
            y1 = AbsPixeltoY(pyt);
            x2 = AbsPixeltoX(pxold);
            y2 = AbsPixeltoY(pyold);
         }
         if (pC) {
            x1 = AbsPixeltoX(pxl);
            y1 = AbsPixeltoY(pyold);
            x2 = AbsPixeltoX(pxold);
            y2 = AbsPixeltoY(pyl);
         }
         if (pD) {
            x1 = AbsPixeltoX(pxold);
            y1 = AbsPixeltoY(pyold);
            x2 = AbsPixeltoX(pxt);
            y2 = AbsPixeltoY(pyl);
         }
         if (pTop || pBot || pL || pR || pINSIDE) {
            x1 = AbsPixeltoX(px1);
            y1 = AbsPixeltoY(py1);
            x2 = AbsPixeltoX(px2);
            y2 = AbsPixeltoY(py2);
         }

         if (pA || pB || pC || pD || pTop || pL || pR || pBot)
            Modified(kTRUE);

         gVirtualX->SetLineColor(-1);
         gVirtualX->SetLineWidth(-1);

         if (px != pxorg || py != pyorg) {

            // Get parent corners pixels coordinates
            Int_t parentpx1 = fMother->XtoAbsPixel(parent->GetX1());
            Int_t parentpx2 = fMother->XtoAbsPixel(parent->GetX2());
            Int_t parentpy1 = fMother->YtoAbsPixel(parent->GetY1());
            Int_t parentpy2 = fMother->YtoAbsPixel(parent->GetY2());

            // Get pad new corners pixels coordinates
            Int_t apx1 = XtoAbsPixel(x1); if (apx1 < parentpx1) {apx1 = parentpx1; }
            Int_t apx2 = XtoAbsPixel(x2); if (apx2 > parentpx2) {apx2 = parentpx2; }
            Int_t apy1 = YtoAbsPixel(y1); if (apy1 > parentpy1) {apy1 = parentpy1; }
            Int_t apy2 = YtoAbsPixel(y2); if (apy2 < parentpy2) {apy2 = parentpy2; }

            // Compute new pad positions in the NDC space of parent
            fXlowNDC = Double_t(apx1 - parentpx1)/Double_t(parentpx2 - parentpx1);
            fYlowNDC = Double_t(apy1 - parentpy1)/Double_t(parentpy2 - parentpy1);
            fWNDC    = Double_t(apx2 - apx1)/Double_t(parentpx2 - parentpx1);
            fHNDC    = Double_t(apy2 - apy1)/Double_t(parentpy2 - parentpy1);
         }

         // Reset pad parameters and recompute conversion coefficients
         ResizePad();

         // emit signal
         RangeChanged();
      }

      break;

   case kButton1Locate:

      ExecuteEvent(kButton1Down, px, py);

      while (1) {
         px = py = 0;
         event = gVirtualX->RequestLocator(1, 1, px, py);

         ExecuteEvent(kButton1Motion, px, py);

         if (event != -1) {                     // button is released
            ExecuteEvent(kButton1Up, px, py);
            return;
         }
      }

   case kButton2Down:

      Pop();
      break;

   }
}


//______________________________________________________________________________
void TPad::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.

   if (!IsEditable()) return;

   SetCursor(kHand);

   TView *view = GetView();
   static Int_t axisNumber;
   static Double_t ratio1, ratio2;
   static Int_t px1old, py1old, px2old, py2old;
   Int_t bin1, bin2, first, last;
   Double_t temp, xmin,xmax;
   Bool_t opaque  = gPad->OpaqueMoving();
   static TBox *zoombox;
   Double_t zbx1=0,zbx2=0,zby1=0,zby2=0;

   // The CONT4 option, used to paint TH2, is a special case; it uses a 3D
   // drawing technique to paint a 2D plot.
   TString opt = axis->GetParent()->GetDrawOption();
   opt.ToLower();
   Bool_t kCont4 = kFALSE;
   if (strstr(opt,"cont4")) {
      view = 0;
      kCont4 = kTRUE;
   }

   switch (event) {

   case kButton1Down:
      axisNumber = 1;
      if (!strcmp(axis->GetName(),"xaxis")) {
         axisNumber = 1;
         if (!IsVertical()) axisNumber = 2;
      }
      if (!strcmp(axis->GetName(),"yaxis")) {
         axisNumber = 2;
         if (!IsVertical()) axisNumber = 1;
      }
      if (!strcmp(axis->GetName(),"zaxis")) {
         axisNumber = 3;
      }
      if (view) {
         view->GetDistancetoAxis(axisNumber, px, py, ratio1);
      } else {
         if (axisNumber == 1) {
            ratio1 = (AbsPixeltoX(px) - GetUxmin())/(GetUxmax() - GetUxmin());
            px1old = XtoAbsPixel(GetUxmin()+ratio1*(GetUxmax() - GetUxmin()));
            py1old = YtoAbsPixel(GetUymin());
            px2old = px1old;
            py2old = YtoAbsPixel(GetUymax());
         } else if (axisNumber == 2) {
            ratio1 = (AbsPixeltoY(py) - GetUymin())/(GetUymax() - GetUymin());
            py1old = YtoAbsPixel(GetUymin()+ratio1*(GetUymax() - GetUymin()));
            px1old = XtoAbsPixel(GetUxmin());
            px2old = XtoAbsPixel(GetUxmax());
            py2old = py1old;
         } else {
            ratio1 = (AbsPixeltoY(py) - GetUymin())/(GetUymax() - GetUymin());
            py1old = YtoAbsPixel(GetUymin()+ratio1*(GetUymax() - GetUymin()));
            px1old = XtoAbsPixel(GetUxmax());
            px2old = XtoAbsPixel(GetX2());
            py2old = py1old;
         }
         if (!opaque) {
            gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
         } else {
            if (axisNumber == 1) {
               zbx1 = AbsPixeltoX(px1old);
               zbx2 = AbsPixeltoX(px2old);
               zby1 = GetUymin();
               zby2 = GetUymax();
            } else if (axisNumber == 2) {
               zbx1 = GetUxmin();
               zbx2 = GetUxmax();
               zby1 = AbsPixeltoY(py1old);
               zby2 = AbsPixeltoY(py2old);
            }
            if (GetLogx()) {
               zbx1 = TMath::Power(10,zbx1);
               zbx2 = TMath::Power(10,zbx2);
            }
            if (GetLogy()) {
               zby1 = TMath::Power(10,zby1);
               zby2 = TMath::Power(10,zby2);
            }
            zoombox = new TBox(zbx1, zby1, zbx2, zby2);
            Int_t ci = TColor::GetColor("#7d7dff");
            TColor *zoomcolor = gROOT->GetColor(ci);
            if (!TCanvas::SupportAlpha() || !zoomcolor) zoombox->SetFillStyle(3002);
            else                                        zoomcolor->SetAlpha(0.5);
            zoombox->SetFillColor(ci);
            zoombox->Draw();
            gPad->Modified();
            gPad->Update();
         }
      }
      if (!opaque) gVirtualX->SetLineColor(-1);
      // No break !!!

   case kButton1Motion:
      if (view) {
         view->GetDistancetoAxis(axisNumber, px, py, ratio2);
      } else {
         if (!opaque) gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
         if (axisNumber == 1) {
            ratio2 = (AbsPixeltoX(px) - GetUxmin())/(GetUxmax() - GetUxmin());
            px2old = XtoAbsPixel(GetUxmin()+ratio2*(GetUxmax() - GetUxmin()));
         } else {
            ratio2 = (AbsPixeltoY(py) - GetUymin())/(GetUymax() - GetUymin());
            py2old = YtoAbsPixel(GetUymin()+ratio2*(GetUymax() - GetUymin()));
         }
         if (!opaque) {
            gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
         } else {
            if (axisNumber == 1) {
               zbx1 = AbsPixeltoX(px1old);
               zbx2 = AbsPixeltoX(px2old);
               zby1 = GetUymin();
               zby2 = GetUymax();
            } else if (axisNumber == 2) {
               zbx1 = GetUxmin();
               zbx2 = GetUxmax();
               zby1 = AbsPixeltoY(py1old);
               zby2 = AbsPixeltoY(py2old);
            }
            if (GetLogx()) {
               zbx1 = TMath::Power(10,zbx1);
               zbx2 = TMath::Power(10,zbx2);
            }
            if (GetLogy()) {
               zby1 = TMath::Power(10,zby1);
               zby2 = TMath::Power(10,zby2);
            }
            zoombox->SetX1(zbx1);
            zoombox->SetY1(zby1);
            zoombox->SetX2(zbx2);
            zoombox->SetY2(zby2);
            gPad->Modified();
            gPad->Update();
         }
      }
   break;

   case kWheelUp:
      bin1 = axis->GetFirst()+1;
      bin2 = axis->GetLast()-1;
      bin1 = TMath::Max(bin1, 1);
      bin2 = TMath::Min(bin2, axis->GetNbins());
      if (bin2>bin1) {
         axis->SetRange(bin1,bin2);
         gPad->Modified();
         gPad->Update();
      }
   break;

   case kWheelDown:
      bin1 = axis->GetFirst()-1;
      bin2 = axis->GetLast()+1;
      bin1 = TMath::Max(bin1, 1);
      bin2 = TMath::Min(bin2, axis->GetNbins());
      if (bin2>bin1) {
         axis->SetRange(bin1,bin2);
         gPad->Modified();
         gPad->Update();
      }
   break;

   case kButton1Up:
      if (gROOT->IsEscaped()) {
         gROOT->SetEscape(kFALSE);
         if (opaque && zoombox) {
            zoombox->Delete();
            zoombox = 0;
         }
         break;
      }

      if (view) {
         view->GetDistancetoAxis(axisNumber, px, py, ratio2);
         if (ratio1 > ratio2) {
            temp   = ratio1;
            ratio1 = ratio2;
            ratio2 = temp;
         }
         if (ratio2 - ratio1 > 0.05) {
            TH1 *hobj = (TH1*)axis->GetParent();
            if (axisNumber == 3 && hobj && hobj->GetDimension() != 3) {
               Float_t zmin = hobj->GetMinimum();
               Float_t zmax = hobj->GetMaximum();
               if(GetLogz()){
                  if (zmin <= 0 && zmax > 0) zmin = TMath::Min((Double_t)1,
                                                               (Double_t)0.001*zmax);
                  zmin = TMath::Log10(zmin);
                  zmax = TMath::Log10(zmax);
               }
               Float_t newmin = zmin + (zmax-zmin)*ratio1;
               Float_t newmax = zmin + (zmax-zmin)*ratio2;
               if(newmin < zmin)newmin = hobj->GetBinContent(hobj->GetMinimumBin());
               if(newmax > zmax)newmax = hobj->GetBinContent(hobj->GetMaximumBin());
               if(GetLogz()){
                  newmin = TMath::Exp(2.302585092994*newmin);
                  newmax = TMath::Exp(2.302585092994*newmax);
               }
               hobj->SetMinimum(newmin);
               hobj->SetMaximum(newmax);
               hobj->SetBit(TH1::kIsZoomed);
            } else {
               first = axis->GetFirst();
               last  = axis->GetLast();
               bin1 = first + Int_t((last-first+1)*ratio1);
               bin2 = first + Int_t((last-first+1)*ratio2);
               bin1 = TMath::Max(bin1, 1);
               bin2 = TMath::Min(bin2, axis->GetNbins());
               axis->SetRange(bin1, bin2);
            }
            delete view;
            SetView(0);
            Modified(kTRUE);
         }
      } else {
         if (axisNumber == 1) {
            ratio2 = (AbsPixeltoX(px) - GetUxmin())/(GetUxmax() - GetUxmin());
            xmin = GetUxmin() +ratio1*(GetUxmax() - GetUxmin());
            xmax = GetUxmin() +ratio2*(GetUxmax() - GetUxmin());
            if (GetLogx() && !kCont4) {
               xmin = PadtoX(xmin);
               xmax = PadtoX(xmax);
            }
         } else if (axisNumber == 2) {
            ratio2 = (AbsPixeltoY(py) - GetUymin())/(GetUymax() - GetUymin());
            xmin = GetUymin() +ratio1*(GetUymax() - GetUymin());
            xmax = GetUymin() +ratio2*(GetUymax() - GetUymin());
            if (GetLogy() && !kCont4) {
               xmin = PadtoY(xmin);
               xmax = PadtoY(xmax);
            }
         } else {
            ratio2 = (AbsPixeltoY(py) - GetUymin())/(GetUymax() - GetUymin());
            xmin = ratio1;
            xmax = ratio2;
         }
         if (xmin > xmax) {
            temp   = xmin;
            xmin   = xmax;
            xmax   = temp;
            temp   = ratio1;
            ratio1 = ratio2;
            ratio2 = temp;
         }

         // xmin and xmax need to be adjusted in case of CONT4.
         if (kCont4) {
            Double_t low = axis->GetBinLowEdge(axis->GetFirst());
            Double_t up  = axis->GetBinUpEdge(axis->GetLast());
            Double_t xmi = GetUxmin();
            Double_t xma = GetUxmax();
            xmin = ((xmin-xmi)/(xma-xmi))*(up-low)+low;
            xmax = ((xmax-xmi)/(xma-xmi))*(up-low)+low;
         }

         if (!strcmp(axis->GetName(),"xaxis")) axisNumber = 1;
         if (!strcmp(axis->GetName(),"yaxis")) axisNumber = 2;
         if (ratio2 - ratio1 > 0.05) {
            //update object owning this axis
            TH1 *hobj1 = (TH1*)axis->GetParent();
            bin1 = axis->FindFixBin(xmin);
            bin2 = axis->FindFixBin(xmax);
            bin1 = TMath::Max(bin1, 1);
            bin2 = TMath::Min(bin2, axis->GetNbins());
            if (axisNumber == 1) axis->SetRange(bin1,bin2);
            if (axisNumber == 2 && hobj1) {
               if (hobj1->GetDimension() == 1) {
                  if (hobj1->GetNormFactor() != 0) {
                     Double_t norm = hobj1->GetSumOfWeights()/hobj1->GetNormFactor();
                     xmin *= norm;
                     xmax *= norm;
                  }
                  hobj1->SetMinimum(xmin);
                  hobj1->SetMaximum(xmax);
                  hobj1->SetBit(TH1::kIsZoomed);
               } else {
                  axis->SetRange(bin1,bin2);
               }
            }
            //update all histograms in the pad
            TIter next(GetListOfPrimitives());
            TObject *obj;
            while ((obj= next())) {
               if (!obj->InheritsFrom(TH1::Class())) continue;
               TH1 *hobj = (TH1*)obj;
               if (hobj == hobj1) continue;
               bin1 = hobj->GetXaxis()->FindFixBin(xmin);
               bin2 = hobj->GetXaxis()->FindFixBin(xmax);
               if (axisNumber == 1) {
                  hobj->GetXaxis()->SetRange(bin1,bin2);
               } else if (axisNumber == 2) {
                  if (hobj->GetDimension() == 1) {
                     Double_t xxmin = xmin;
                     Double_t xxmax = xmax;
                     if (hobj->GetNormFactor() != 0) {
                        Double_t norm = hobj->GetSumOfWeights()/hobj->GetNormFactor();
                        xxmin *= norm;
                        xxmax *= norm;
                     }
                     hobj->SetMinimum(xxmin);
                     hobj->SetMaximum(xxmax);
                     hobj->SetBit(TH1::kIsZoomed);
                  } else {
                     bin1 = hobj->GetYaxis()->FindFixBin(xmin);
                     bin2 = hobj->GetYaxis()->FindFixBin(xmax);
                     hobj->GetYaxis()->SetRange(bin1,bin2);
                  }
               }
            }
            Modified(kTRUE);
         }
      }
      if (!opaque) {
         gVirtualX->SetLineColor(-1);
      } else {
         if (zoombox) {
            zoombox->Delete();
            zoombox = 0;
         }
      }
      break;
   }
}

//______________________________________________________________________________
TObject *TPad::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 subpads the first one is returned.

   if (!fPrimitives) return 0;
   TObject *found = fPrimitives->FindObject(name);
   if (found) return found;
   TObject *cur;
   TIter    next(GetListOfPrimitives());
   while ((cur = next())) {
      if (cur->InheritsFrom(TPad::Class())) {
         found = ((TPad*)cur)->FindObject(name);
         if (found) return found;
      }
   }
    return 0;
}


//______________________________________________________________________________
TObject *TPad::FindObject(const TObject *obj) const
{
   // Search if obj is in pad or in pads inside this pad.
   //
   //  In case obj is in several subpads the first one is returned.

   if (!fPrimitives) return 0;
   TObject *found = fPrimitives->FindObject(obj);
   if (found) return found;
   TObject *cur;
   TIter    next(GetListOfPrimitives());
   while ((cur = next())) {
      if (cur->InheritsFrom(TPad::Class())) {
         found = ((TPad*)cur)->FindObject(obj);
         if (found) return found;
      }
   }
   return 0;
}


//______________________________________________________________________________
Int_t TPad::GetCanvasID() const
{
   // Get canvas identifier.

   return fCanvas ? fCanvas->GetCanvasID() : -1;
}

//______________________________________________________________________________
TCanvasImp *TPad::GetCanvasImp() const
{
   // Get canvas implementation pointer if any

   return fCanvas ? fCanvas->GetCanvasImp() : 0;
}


//______________________________________________________________________________
Int_t TPad::GetEvent() const
{
   // Get Event.

   return  fCanvas ? fCanvas->GetEvent() : 0;
}


//______________________________________________________________________________
Int_t TPad::GetEventX() const
{
   // Get X event.

   return  fCanvas ? fCanvas->GetEventX() : 0;
}


//______________________________________________________________________________
Int_t TPad::GetEventY() const
{
   // Get Y event.

   return  fCanvas ? fCanvas->GetEventY() : 0;
}


//______________________________________________________________________________
TVirtualPad *TPad::GetVirtCanvas() const
{
   // Get virtual canvas.

   return  fCanvas ? (TVirtualPad*) fCanvas : 0;
}


//______________________________________________________________________________
Color_t TPad::GetHighLightColor() const
{
   // Get highlight color.

   return  fCanvas ? fCanvas->GetHighLightColor() : 0;
}


//______________________________________________________________________________
Int_t TPad::GetMaxPickDistance()
{
   // Static function (see also TPad::SetMaxPickDistance)

   return fgMaxPickDistance;
}


//______________________________________________________________________________
TObject *TPad::GetSelected() const
{
   // Get selected.

   if (fCanvas == this) return 0;
   return  fCanvas ? fCanvas->GetSelected() : 0;
}


//______________________________________________________________________________
TVirtualPad *TPad::GetSelectedPad() const
{
   // Get selected pad.

   if (fCanvas == this) return 0;
   return  fCanvas ? fCanvas->GetSelectedPad() : 0;
}


//______________________________________________________________________________
TVirtualPad *TPad::GetPadSave() const
{
   // Get save pad.

   if (fCanvas == this) return 0;
   return  fCanvas ? fCanvas->GetPadSave() : 0;
}


//______________________________________________________________________________
UInt_t TPad::GetWh() const
{
   // Get Wh.

   return  fCanvas ? fCanvas->GetWh() : 0;
}


//______________________________________________________________________________
UInt_t TPad::GetWw() const
{
   // Get Ww.

   return  fCanvas ? fCanvas->GetWw() : 0;
}


//______________________________________________________________________________
void TPad::HideToolTip(Int_t event)
{
   // Hide tool tip depending on the event type. Typically tool tips
   // are hidden when event is not a kMouseEnter and not a kMouseMotion
   // event.

   if (event != kMouseEnter && event != kMouseMotion && fTip)
      gPad->CloseToolTip(fTip);
}


//______________________________________________________________________________
Bool_t TPad::IsBatch() const
{
   // Is pad in batch mode ?

   return  fCanvas ? fCanvas->IsBatch() : 0;
}


//______________________________________________________________________________
Bool_t TPad::IsRetained() const
{
   // Is pad retained ?

   return  fCanvas ? fCanvas->IsRetained() : 0;
}


//______________________________________________________________________________
Bool_t TPad::OpaqueMoving() const
{
   // Is pad moving in opaque mode ?

   return  fCanvas ? fCanvas->OpaqueMoving() : 0;
}


//______________________________________________________________________________
Bool_t TPad::OpaqueResizing() const
{
   // Is pad resizing in opaque mode ?

   return  fCanvas ? fCanvas->OpaqueResizing() : 0;
}


//______________________________________________________________________________
void TPad::SetBatch(Bool_t batch)
{
   // Set pad in batch mode.

   if (fCanvas) fCanvas->SetBatch(batch);
}


//______________________________________________________________________________
void TPad::SetCanvasSize(UInt_t ww, UInt_t wh)
{
   // Set canvas size.

   if (fCanvas) fCanvas->SetCanvasSize(ww,wh);
}


//______________________________________________________________________________
void TPad::SetCursor(ECursor cursor)
{
   // Set cursor type.

   if (fCanvas) fCanvas->SetCursor(cursor);
}


//______________________________________________________________________________
void TPad::SetDoubleBuffer(Int_t mode)
{
   // Set double buffer mode ON or OFF.

   if (fCanvas) fCanvas->SetDoubleBuffer(mode);
}


//______________________________________________________________________________
void TPad::SetSelected(TObject *obj)
{
   // Set selected.

   if (fCanvas) fCanvas->SetSelected(obj);
}


//______________________________________________________________________________
void TPad::Update()
{
   // Update pad.

   if (fCanvas) fCanvas->Update();
}


//______________________________________________________________________________
TFrame *TPad::GetFrame()
{
   // Get frame.

   if (!fPrimitives) fPrimitives = new TList;
   TFrame     *frame = (TFrame*)GetListOfPrimitives()->FindObject(fFrame);
   if (!frame) frame = (TFrame*)GetListOfPrimitives()->FindObject("TFrame");
   fFrame = frame;
   if (!fFrame) {
      if (!frame) fFrame = new TFrame(0,0,1,1);
      Int_t framecolor = GetFrameFillColor();
      if (!framecolor) framecolor = GetFillColor();
      fFrame->SetFillColor(framecolor);
      fFrame->SetFillStyle(GetFrameFillStyle());
      fFrame->SetLineColor(GetFrameLineColor());
      fFrame->SetLineStyle(GetFrameLineStyle());
      fFrame->SetLineWidth(GetFrameLineWidth());
      fFrame->SetBorderSize(GetFrameBorderSize());
      fFrame->SetBorderMode(GetFrameBorderMode());
   }
   return fFrame;
}


//______________________________________________________________________________
TObject *TPad::GetPrimitive(const char *name) const
{
   // Get primitive.

   if (!fPrimitives) return 0;
   TIter next(fPrimitives);
   TObject *found, *obj;
   while ((obj=next())) {
      if (!strcmp(name, obj->GetName())) return obj;
      if (obj->InheritsFrom(TPad::Class())) continue;
      found = obj->FindObject(name);
      if (found) return found;
   }
   return 0;
}


//______________________________________________________________________________
TVirtualPad *TPad::GetPad(Int_t subpadnumber) const
{
   // Get a pointer to subpadnumber of this pad.

   if (!subpadnumber) {
      return (TVirtualPad*)this;
   }

   TObject *obj;
   if (!fPrimitives) return 0;
   TIter    next(GetListOfPrimitives());
   while ((obj = next())) {
      if (obj->InheritsFrom(TVirtualPad::Class())) {
         TVirtualPad *pad = (TVirtualPad*)obj;
         if (pad->GetNumber() == subpadnumber) return pad;
      }
   }
   return 0;
}


//______________________________________________________________________________
void TPad::GetPadPar(Double_t &xlow, Double_t &ylow, Double_t &xup, Double_t &yup)
{
   // Return lower and upper bounds of the pad in NDC coordinates.

   xlow = fXlowNDC;
   ylow = fYlowNDC;
   xup  = fXlowNDC+fWNDC;
   yup  = fYlowNDC+fHNDC;
}


//______________________________________________________________________________
void TPad::GetRange(Double_t &x1, Double_t &y1, Double_t &x2, Double_t &y2)
{
   // Return pad world coordinates range.

   x1 = fX1;
   y1 = fY1;
   x2 = fX2;
   y2 = fY2;
}


//______________________________________________________________________________
void TPad::GetRangeAxis(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax)
{
   // Return pad axis coordinates range.

   xmin = fUxmin;
   ymin = fUymin;
   xmax = fUxmax;
   ymax = fUymax;
}


//______________________________________________________________________________
void TPad::HighLight(Color_t color, Bool_t set)
{
   // Highlight pad.
   //do not highlight when printing on Postscript
   if (gVirtualPS && gVirtualPS->TestBit(kPrintingPS)) return;

   if (color <= 0) return;

   AbsCoordinates(kTRUE);

   // We do not want to have active(executable) buttons, etc highlighted
   // in this manner, unless we want to edit'em
   if (GetMother() && GetMother()->IsEditable() && !InheritsFrom(TButton::Class())) {
      //When doing a DrawClone from the GUI you would do
      //  - select an empty pad -
      //  - right click on object -
      //     - select DrawClone on menu -
      //
      // Without the SetSelectedPad(); in the HighLight function, the
      // above instruction lead to the clone to be drawn in the
      // same canvas as the original object.  This is because the
      // 'right clicking' (via TCanvas::HandleInput) changes gPad
      // momentarily such that when DrawClone is called, it is
      // not the right value (for DrawClone). Should be FIXED.
      gROOT->SetSelectedPad(this);
      if (set)
         PaintBorder(-color, kFALSE);
      else
         PaintBorder(-GetFillColor(), kFALSE);
   }

   AbsCoordinates(kFALSE);
}


//______________________________________________________________________________
void TPad::ls(Option_t *option) const
{
   // List all primitives in pad.

   TROOT::IndentLevel();
   std::cout <<IsA()->GetName()<<" fXlowNDC=" <<fXlowNDC<<" fYlowNDC="<<fYlowNDC<<" fWNDC="<<GetWNDC()<<" fHNDC="<<GetHNDC()
        <<" Name= "<<GetName()<<" Title= "<<GetTitle()<<" Option="<<option<<std::endl;
   TROOT::IncreaseDirLevel();
   if (!fPrimitives) return;
   fPrimitives->ls(option);
   TROOT::DecreaseDirLevel();
}


//______________________________________________________________________________
Double_t TPad::PadtoX(Double_t x) const
{
   // Convert x from pad to X.

   if (fLogx && x < 50) return Double_t(TMath::Exp(2.302585092994*x));
   return x;
}


//______________________________________________________________________________
Double_t TPad::PadtoY(Double_t y) const
{
   // Convert y from pad to Y.

   if (fLogy && y < 50) return Double_t(TMath::Exp(2.302585092994*y));
   return y;
}


//______________________________________________________________________________
Double_t TPad::XtoPad(Double_t x) const
{
   // Convert x from X to pad.

   if (fLogx) {
      if (x > 0) x = TMath::Log10(x);
      else       x = fUxmin;
   }
   return x;
}


//______________________________________________________________________________
Double_t TPad::YtoPad(Double_t y) const
{
   // Convert y from Y to pad.

   if (fLogy) {
      if (y > 0) y = TMath::Log10(y);
      else       y = fUymin;
   }
   return y;
}


//______________________________________________________________________________
void TPad::Paint(Option_t * /*option*/)
{
   // Paint all primitives in pad.

   if (!fPrimitives) fPrimitives = new TList;
   if (fViewer3D && fViewer3D->CanLoopOnPrimitives()) {
      fViewer3D->PadPaint(this);
      Modified(kFALSE);
      if (GetGLDevice()!=-1 && gVirtualPS) {
         TPad *padsav = (TPad*)gPad;
         gPad = this;
         gGLManager->PrintViewer(GetViewer3D());
         gPad = padsav;
      }
      return;
   }

   if (fCanvas) TColor::SetGrayscale(fCanvas->IsGrayscale());

   TPad *padsav = (TPad*)gPad;

   fPadPaint = 1;
   cd();

   PaintBorder(GetFillColor(), kTRUE);
   PaintDate();

   TObjOptLink *lnk = (TObjOptLink*)GetListOfPrimitives()->FirstLink();
   TObject *obj;

   Bool_t began3DScene = kFALSE;
   while (lnk) {
      obj = lnk->GetObject();

      // Create a pad 3D viewer if none exists and we encounter a 3D shape
      if (!fViewer3D && obj->InheritsFrom(TAtt3D::Class())) {
         GetViewer3D("pad");
      }

      // Open a 3D scene if required
      if (fViewer3D && !fViewer3D->BuildingScene()) {
         fViewer3D->BeginScene();
         began3DScene = kTRUE;
      }

      obj->Paint(lnk->GetOption());
      lnk = (TObjOptLink*)lnk->Next();
   }

   if (padsav) padsav->cd();
   fPadPaint = 0;
   Modified(kFALSE);

   // Close the 3D scene if we opened it. This must be done after modified
   // flag is cleared, as some viewers will invoke another paint by marking pad modified again
   if (began3DScene) {
      fViewer3D->EndScene();
   }

///// Generate the PS output using gl2ps
///if (GetGLDevice()!=-1 && gVirtualPS) {
///   gPad = this;
///   gGLManager->PrintViewer(GetViewer3D());
///   gPad = padsav;
///}
}


//______________________________________________________________________________
void TPad::PaintBorder(Color_t color, Bool_t tops)
{
   // Paint the pad border.
   // Draw first  a box as a normal filled box
   if(color >= 0) {
      TAttLine::Modify();  //Change line attributes only if necessary
      TAttFill::Modify();  //Change fill area attributes only if necessary

      //With Cocoa we have a transparency. But we also have
      //pixmaps, and if you just paint a new content over the old one
      //with alpha < 1., you'll be able to see the old content.
      if (!gROOT->IsBatch() && gVirtualX->InheritsFrom("TGCocoa") && GetPainter())
         GetPainter()->ClearDrawable();

      PaintBox(fX1,fY1,fX2,fY2);
   }
   if (color < 0) color = -color;
   // then paint 3d frame (depending on bordermode)
   if (IsTransparent()) return;
   // Paint a 3D frame around the pad.

   if (fBorderMode == 0) return;
   Int_t bordersize = fBorderSize;
   if (bordersize <= 0) bordersize = 2;

   const Double_t realBsX = bordersize / (GetAbsWNDC() * GetWw()) * (fX2 - fX1);
   const Double_t realBsY = bordersize / (GetAbsHNDC() * GetWh()) * (fY2 - fY1);

   Short_t px1,py1,px2,py2;
   Double_t xl, xt, yl, yt;

   // GetDarkColor() and GetLightColor() use GetFillColor()
   Color_t oldcolor = GetFillColor();
   SetFillColor(color);
   TAttFill::Modify();
   Color_t light = 0, dark = 0;
   if (color != 0) {
      light = TColor::GetColorBright(color);
      dark  = TColor::GetColorDark(color);
   }

   // Compute real left bottom & top right of the box in pixels
   px1 = XtoPixel(fX1);   py1 = YtoPixel(fY1);
   px2 = XtoPixel(fX2);   py2 = YtoPixel(fY2);
   if (px1 < px2) {xl = fX1; xt = fX2; }
   else           {xl = fX2; xt = fX1;}
   if (py1 > py2) {yl = fY1; yt = fY2;}
   else           {yl = fY2; yt = fY1;}

   Double_t frameXs[7] = {}, frameYs[7] = {};

   if (!IsBatch()) {
      // Draw top&left part of the box
      frameXs[0] = xl;           frameYs[0] = yl;
      frameXs[1] = xl + realBsX; frameYs[1] = yl + realBsY;
      frameXs[2] = frameXs[1];   frameYs[2] = yt - realBsY;
      frameXs[3] = xt - realBsX; frameYs[3] = frameYs[2];
      frameXs[4] = xt;           frameYs[4] = yt;
      frameXs[5] = xl;           frameYs[5] = yt;
      frameXs[6] = xl;           frameYs[6] = yl;

      if (fBorderMode == -1) GetPainter()->SetFillColor(dark);
      else                   GetPainter()->SetFillColor(light);
      GetPainter()->DrawFillArea(7, frameXs, frameYs);

      // Draw bottom&right part of the box
      frameXs[0] = xl;              frameYs[0] = yl;
      frameXs[1] = xl + realBsX;    frameYs[1] = yl + realBsY;
      frameXs[2] = xt - realBsX;    frameYs[2] = frameYs[1];
      frameXs[3] = frameXs[2];      frameYs[3] = yt - realBsY;
      frameXs[4] = xt;              frameYs[4] = yt;
      frameXs[5] = xt;              frameYs[5] = yl;
      frameXs[6] = xl;              frameYs[6] = yl;

      if (fBorderMode == -1) GetPainter()->SetFillColor(light);
      else                   GetPainter()->SetFillColor(dark);
      GetPainter()->DrawFillArea(7, frameXs, frameYs);

      // If this pad is a button, highlight it
      if (InheritsFrom(TButton::Class()) && fBorderMode == -1) {
         if (TestBit(kFraming)) {  // bit set in TButton::SetFraming
            if (GetFillColor() != 2) GetPainter()->SetLineColor(2);
            else                     GetPainter()->SetLineColor(4);
            GetPainter()->DrawBox(xl + realBsX, yl + realBsY, xt - realBsX, yt - realBsY, TVirtualPadPainter::kHollow);
         }
      }
      GetPainter()->SetFillColor(-1);
      SetFillColor(oldcolor);
   }

   if (!tops) return;

   PaintBorderPS(xl, yl, xt, yt, fBorderMode, bordersize, dark, light);
}


//______________________________________________________________________________
void TPad::PaintBorderPS(Double_t xl,Double_t yl,Double_t xt,Double_t yt,Int_t bmode,Int_t bsize,Int_t dark,Int_t light)
{
   // Paint a frame border with Postscript.

   if (!gVirtualPS) return;
   gVirtualPS->DrawFrame(xl, yl, xt, yt, bmode,bsize,dark,light);
}


//______________________________________________________________________________
void TPad::PaintDate()
{
   // Paint the current date and time if the option date is on.

   if (fCanvas == this && gStyle->GetOptDate()) {
      TDatime dt;
      const char *dates;
      char iso[16];
      if (gStyle->GetOptDate() < 10) {
         //by default use format like "Wed Sep 25 17:10:35 2002"
         dates = dt.AsString();
      } else if (gStyle->GetOptDate() < 20) {
         //use ISO format like 2002-09-25
         strlcpy(iso,dt.AsSQLString(),16);
         dates = iso;
      } else {
         //use ISO format like 2002-09-25 17:10:35
         dates = dt.AsSQLString();
      }
      TText tdate(gStyle->GetDateX(),gStyle->GetDateY(),dates);
      tdate.SetTextSize( gStyle->GetAttDate()->GetTextSize());
      tdate.SetTextFont( gStyle->GetAttDate()->GetTextFont());
      tdate.SetTextColor(gStyle->GetAttDate()->GetTextColor());
      tdate.SetTextAlign(gStyle->GetAttDate()->GetTextAlign());
      tdate.SetTextAngle(gStyle->GetAttDate()->GetTextAngle());
      tdate.SetNDC();
      tdate.Paint();
   }
}


//______________________________________________________________________________
void TPad::PaintPadFrame(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax)
{
   // Paint histogram/graph frame.

   if (!fPrimitives) fPrimitives = new TList;
   TList *glist  = GetListOfPrimitives();
   TFrame *frame = GetFrame();
   frame->SetX1(xmin);
   frame->SetX2(xmax);
   frame->SetY1(ymin);
   frame->SetY2(ymax);
   if (!glist->FindObject(fFrame)) {
      glist->AddFirst(frame);
      fFrame->SetBit(kMustCleanup);
   }
   frame->Paint();
}


//______________________________________________________________________________
void TPad::PaintModified()
{
   // Traverse pad hierarchy and (re)paint only modified pads.

   if (fViewer3D && fViewer3D->CanLoopOnPrimitives()) {
      if (IsModified()) {
         fViewer3D->PadPaint(this);
         Modified(kFALSE);
      }
      TList *pList = GetListOfPrimitives();
      TObjOptLink *lnk = 0;
      if (pList) lnk = (TObjOptLink*)pList->FirstLink();
      TObject *obj;
      while (lnk) {
         obj = lnk->GetObject();
         if (obj->InheritsFrom(TPad::Class()))
            ((TPad*)obj)->PaintModified();
         lnk = (TObjOptLink*)lnk->Next();
      }
      return;
   }

   if (fCanvas) TColor::SetGrayscale(fCanvas->IsGrayscale());

   TPad *padsav = (TPad*)gPad;
   TVirtualPS *saveps = gVirtualPS;
   if (gVirtualPS) {
      if (gVirtualPS->TestBit(kPrintingPS)) gVirtualPS = 0;
   }
   fPadPaint = 1;
   cd();
   if (IsModified() || IsTransparent()) {
      if ((fFillStyle < 3026) && (fFillStyle > 3000)) {
         if (!gPad->IsBatch()) GetPainter()->ClearDrawable();
      }
      PaintBorder(GetFillColor(), kTRUE);
   }

   PaintDate();

   TList *pList = GetListOfPrimitives();
   TObjOptLink *lnk = 0;
   if (pList) lnk = (TObjOptLink*)pList->FirstLink();
   TObject *obj;

   Bool_t began3DScene = kFALSE;

   while (lnk) {
      obj = lnk->GetObject();
      if (obj->InheritsFrom(TPad::Class())) {
         ((TPad*)obj)->PaintModified();
      } else if (IsModified() || IsTransparent()) {

         // Create a pad 3D viewer if none exists and we encounter a
         // 3D shape
         if (!fViewer3D && obj->InheritsFrom(TAtt3D::Class())) {
            GetViewer3D("pad");
         }

         // Open a 3D scene if required
         if (fViewer3D && !fViewer3D->BuildingScene()) {
            fViewer3D->BeginScene();
            began3DScene = kTRUE;
         }

         obj->Paint(lnk->GetOption());
      }
      lnk = (TObjOptLink*)lnk->Next();
   }

   if (padsav) padsav->cd();
   fPadPaint = 0;
   Modified(kFALSE);

   // This must be done after modified flag is cleared, as some
   // viewers will invoke another paint by marking pad modified again
   if (began3DScene) {
      fViewer3D->EndScene();
   }

   gVirtualPS = saveps;
}


//______________________________________________________________________________
void TPad::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
   if (!gPad->IsBatch()) {
      Int_t style0 = GetPainter()->GetFillStyle();
      Int_t style  = style0;
      if (option[0] == 's') {
         GetPainter()->SetFillStyle(0);
         style = 0;
      }
      if (style) {
         if (style > 3000 && style < 4000) {
            if (style < 3026) {
               // draw stipples with fFillColor foreground
               GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kFilled);
            }

            if (style >= 3100 && style < 4000) {
               Double_t xb[4], yb[4];
               xb[0] = x1; xb[1] = x1; xb[2] = x2; xb[3] = x2;
               yb[0] = y1; yb[1] = y2; yb[2] = y2; yb[3] = y1;
               PaintFillAreaHatches(4, xb, yb, style);
               return;
            }
            //special case for TAttFillCanvas
            if (GetPainter()->GetFillColor() == 10) {
               GetPainter()->SetFillColor(1);
               GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kFilled);
               GetPainter()->SetFillColor(10);
            }
         } else if (style >= 4000 && style <= 4100) {
            // For style >=4000 we make the window transparent.
            // From 4000 to 4100 the window is 100% transparent to 100% opaque

            //ignore this style option when this is the canvas itself
            if (this == fMother) {
               //It's clear, that virtual X checks a style (4000) and will render a hollow rect!
               const Style_t oldFillStyle = GetPainter()->GetFillStyle();
               if (gVirtualX->InheritsFrom("TGCocoa"))
                  GetPainter()->SetFillStyle(1000);
               GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kFilled);
               if (gVirtualX->InheritsFrom("TGCocoa"))
                  GetPainter()->SetFillStyle(oldFillStyle);
            } else {
               //draw background by blitting all bottom pads
               int px, py;
               XYtoAbsPixel(fX1, fY2, px, py);

               if (fMother) {
                  fMother->CopyBackgroundPixmap(px, py);
                  CopyBackgroundPixmaps(fMother, this, px, py);
               }

               GetPainter()->SetOpacity(style - 4000);
            }
         } else if (style >= 1000 && style <= 1999) {
            GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kFilled);
         } else {
            GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kHollow);
         }
         if (option[0] == 'l') GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kHollow);
      } else {
         GetPainter()->DrawBox(x1, y1, x2, y2, TVirtualPadPainter::kHollow);
         if (option[0] == 's') GetPainter()->SetFillStyle(style0);
      }
   }

   if (gVirtualPS) {
      Int_t style0 = gVirtualPS->GetFillStyle();
      if (option[0] == 's') {
         gVirtualPS->SetFillStyle(0);
      } else {
         if (style0 >= 3100 && style0 < 4000) {
            Double_t xb[4], yb[4];
            xb[0] = x1; xb[1] = x1; xb[2] = x2; xb[3] = x2;
            yb[0] = y1; yb[1] = y2; yb[2] = y2; yb[3] = y1;
            PaintFillAreaHatches(4, xb, yb, style0);
            return;
         }
      }
      gVirtualPS->DrawBox(x1, y1, x2, y2);
      if (option[0] == 'l') {
         gVirtualPS->SetFillStyle(0);
         gVirtualPS->DrawBox(x1, y1, x2, y2);
      }
      if (option[0] == 's' || option[0] == 'l') gVirtualPS->SetFillStyle(style0);
   }

   Modified();
}


//______________________________________________________________________________
void TPad::CopyBackgroundPixmaps(TPad *start, TPad *stop, Int_t x, Int_t y)
{
   // Copy pixmaps of pads laying below pad "stop" into pad "stop". This
   // gives the effect of pad "stop" being transparent.

   TObject *obj;
   if (!fPrimitives) fPrimitives = new TList;
   TIter next(start->GetListOfPrimitives());
   while ((obj = next())) {
      if (obj->InheritsFrom(TPad::Class())) {
         if (obj == stop) break;
         ((TPad*)obj)->CopyBackgroundPixmap(x, y);
         ((TPad*)obj)->CopyBackgroundPixmaps((TPad*)obj, stop, x, y);
      }
   }
}


//______________________________________________________________________________
void TPad::CopyBackgroundPixmap(Int_t x, Int_t y)
{
   // Copy pixmap of this pad as background of the current pad.

   int px, py;
   XYtoAbsPixel(fX1, fY2, px, py);
   GetPainter()->CopyDrawable(GetPixmapID(), px-x, py-y);
}


//______________________________________________________________________________
void TPad::PaintFillArea(Int_t, Float_t *, Float_t *, Option_t *)
{
   Warning("TPad::PaintFillArea", "Float_t signature is obsolete. Use Double_t signature.");
}


//______________________________________________________________________________
void TPad::PaintFillArea(Int_t nn, Double_t *xx, Double_t *yy, Option_t *)
{
   // Paint fill area in CurrentPad World coordinates.

   if (nn <3) return;
   Int_t n=0;
   Double_t xmin,xmax,ymin,ymax;
   if (TestBit(TGraph::kClipFrame)) {
      xmin = fUxmin; ymin = fUymin; xmax = fUxmax; ymax = fUymax;
   } else {
      xmin = fX1; ymin = fY1; xmax = fX2; ymax = fY2;
   }

   Int_t nc = 2*nn+1;
   Double_t *x = new Double_t[nc];
   Double_t *y = new Double_t[nc];
   memset(x,0,8*nc);
   memset(y,0,8*nc);

   n = ClipPolygon(nn, xx, yy, nc, x, y,xmin,ymin,xmax,ymax);
   if (!n) {
      delete [] x;
      delete [] y;
      return;
   }

   // Paint the fill area with hatches
   Int_t fillstyle = GetPainter()->GetFillStyle();
   if (gPad->IsBatch() && gVirtualPS) fillstyle = gVirtualPS->GetFillStyle();
   if (fillstyle >= 3100 && fillstyle < 4000) {
      PaintFillAreaHatches(nn, x, y, fillstyle);
      delete [] x;
      delete [] y;
      return;
   }

   if (!gPad->IsBatch())
      // invoke the graphics subsystem
      GetPainter()->DrawFillArea(n, x, y);

   if (gVirtualPS) {
      gVirtualPS->DrawPS(-n, x, y);
   }
   delete [] x;
   delete [] y;
   Modified();
}


//______________________________________________________________________________
void TPad::PaintFillAreaHatches(Int_t nn, Double_t *xx, Double_t *yy, Int_t FillStyle)
{
   //   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

   static Double_t ang1[10] = {0., 10., 20., 30., 45.,5., 60., 70., 80., 90.};
   static Double_t ang2[10] = {180.,170.,160.,150.,135.,5.,120.,110.,100., 90.};

   Int_t fasi  = FillStyle%1000;
   Int_t idSPA = (Int_t)(fasi/100);
   Int_t iAng2 = (Int_t)((fasi-100*idSPA)/10);
   Int_t iAng1 = fasi%10;
   Double_t dy = 0.003*(Double_t)(idSPA)*gStyle->GetHatchesSpacing();
   Int_t lw = gStyle->GetHatchesLineWidth();
   Short_t lws = 0;
   Int_t   lss = 0;
   Int_t   lcs = 0;

   // Save the current line attributes
   if (!gPad->IsBatch()) {
      lws = GetPainter()->GetLineWidth();
      lss = GetPainter()->GetLineStyle();
      lcs = GetPainter()->GetLineColor();
   } else {
      if (gVirtualPS) {
         lws = gVirtualPS->GetLineWidth();
         lss = gVirtualPS->GetLineStyle();
         lcs = gVirtualPS->GetLineColor();
      }
   }

   // Change the current line attributes to draw the hatches
   if (!gPad->IsBatch()) {
      GetPainter()->SetLineStyle(1);
      GetPainter()->SetLineWidth(Short_t(lw));
      GetPainter()->SetLineColor(GetPainter()->GetFillColor());
   }
   if (gVirtualPS) {
      gVirtualPS->SetLineStyle(1);
      gVirtualPS->SetLineWidth(Short_t(lw));
      gVirtualPS->SetLineColor(gVirtualPS->GetFillColor());
   }

   // Draw the hatches
   if (ang1[iAng1] != 5.) PaintHatches(dy, ang1[iAng1], nn, xx, yy);
   if (ang2[iAng2] != 5.) PaintHatches(dy, ang2[iAng2], nn, xx, yy);

   // Restore the line attributes
   if (!gPad->IsBatch()) {
      GetPainter()->SetLineStyle(lss);
      GetPainter()->SetLineWidth(lws);
      GetPainter()->SetLineColor(lcs);
   }
   if (gVirtualPS) {
      gVirtualPS->SetLineStyle(lss);
      gVirtualPS->SetLineWidth(lws);
      gVirtualPS->SetLineColor(lcs);
   }
}


//______________________________________________________________________________
void TPad::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.

   Int_t i, i1, i2, nbi, m, inv;
   Double_t ratiox, ratioy, ymin, ymax, yrot, ycur;
   const Double_t angr  = TMath::Pi()*(180-angle)/180.;
   const Double_t epsil = 0.0001;
   const Int_t maxnbi = 100;
   Double_t xli[maxnbi], xlh[2], ylh[2], xt1, xt2, yt1, yt2;
   Double_t ll, x, y, x1, x2, y1, y2, a, b, xi, xip, xin, yi, yip;

   Double_t rwxmin = gPad->GetX1();
   Double_t rwxmax = gPad->GetX2();
   Double_t rwymin = gPad->GetY1();
   Double_t rwymax = gPad->GetY2();
   ratiox = 1/(rwxmax-rwxmin);
   ratioy = 1/(rwymax-rwymin);

   Double_t sina = TMath::Sin(angr), sinb;
   Double_t cosa = TMath::Cos(angr), cosb;
   if (TMath::Abs(cosa) <= epsil) cosa=0.;
   if (TMath::Abs(sina) <= epsil) sina=0.;
   sinb = -sina;
   cosb = cosa;

   // Values needed to compute the hatches in TRUE normalized space (NDC)
   Int_t iw = gPad->GetWw();
   Int_t ih = gPad->GetWh();
   Double_t x1p,y1p,x2p,y2p;
   gPad->GetPadPar(x1p,y1p,x2p,y2p);
   iw  = (Int_t)(iw*x2p)-(Int_t)(iw*x1p);
   ih  = (Int_t)(ih*y2p)-(Int_t)(ih*y1p);
   Double_t wndc  = TMath::Min(1.,(Double_t)iw/(Double_t)ih);
   Double_t hndc  = TMath::Min(1.,(Double_t)ih/(Double_t)iw);

   // Search ymin and ymax
   ymin = 1.;
   ymax = 0.;
   for (i=1; i<=nn; i++) {
      x    = wndc*ratiox*(xx[i-1]-rwxmin);
      y    = hndc*ratioy*(yy[i-1]-rwymin);
      yrot = sina*x+cosa*y;
      if (yrot > ymax) ymax = yrot;
      if (yrot < ymin) ymin = yrot;
   }
   ymax = (Double_t)((Int_t)(ymax/dy))*dy;

   for (ycur=ymax; ycur>=ymin; ycur=ycur-dy) {
      nbi = 0;
      for (i=2; i<=nn+1; i++) {
         i2 = i;
         i1 = i-1;
         if (i == nn+1) i2=1;
         x1  = wndc*ratiox*(xx[i1-1]-rwxmin);
         y1  = hndc*ratioy*(yy[i1-1]-rwymin);
         x2  = wndc*ratiox*(xx[i2-1]-rwxmin);
         y2  = hndc*ratioy*(yy[i2-1]-rwymin);
         xt1 = cosa*x1-sina*y1;
         yt1 = sina*x1+cosa*y1;
         xt2 = cosa*x2-sina*y2;
         yt2 = sina*x2+cosa*y2;

         // Line segment parallel to oy
         if (xt1 == xt2) {
            if (yt1 < yt2) {
               yi  = yt1;
               yip = yt2;
            } else {
               yi  = yt2;
               yip = yt1;
            }
            if ((yi <= ycur) && (ycur < yip)) {
               nbi++;
               if (nbi >= maxnbi) return;
               xli[nbi-1] = xt1;
            }
            continue;
         }

         // Line segment parallel to ox
         if (yt1 == yt2) {
            if (yt1 == ycur) {
               nbi++;
               if (nbi >= maxnbi) return;
               xli[nbi-1] = xt1;
               nbi++;
               if (nbi >= maxnbi) return;
               xli[nbi-1] = xt2;
            }
            continue;
         }

         // Other line segment
         a = (yt1-yt2)/(xt1-xt2);
         b = (yt2*xt1-xt2*yt1)/(xt1-xt2);
         if (xt1 < xt2) {
            xi  = xt1;
            xip = xt2;
         } else {
            xi  = xt2;
            xip = xt1;
         }
         xin = (ycur-b)/a;
         if  ((xi <= xin) && (xin < xip) &&
              (TMath::Min(yt1,yt2) <= ycur) &&
              (ycur < TMath::Max(yt1,yt2))) {
            nbi++;
            if (nbi >= maxnbi) return;
            xli[nbi-1] = xin;
         }
      }

      // Sorting of the x coordinates intersections
      inv = 0;
      m   = nbi-1;
L30:
      for (i=1; i<=m; i++) {
         if (xli[i] < xli[i-1]) {
            inv++;
            ll       = xli[i-1];
            xli[i-1] = xli[i];
            xli[i]   = ll;
         }
      }
      m--;
      if (inv == 0) goto L50;
      inv = 0;
      goto L30;

      // Draw the hatches
L50:
      if (nbi%2 != 0) continue;

      for (i=1; i<=nbi; i=i+2) {
         // Rotate back the hatches
         xlh[0] = cosb*xli[i-1]-sinb*ycur;
         ylh[0] = sinb*xli[i-1]+cosb*ycur;
         xlh[1] = cosb*xli[i]  -sinb*ycur;
         ylh[1] = sinb*xli[i]  +cosb*ycur;
         // Convert hatches' positions from true NDC to WC
         xlh[0] = (xlh[0]/wndc)*(rwxmax-rwxmin)+rwxmin;
         ylh[0] = (ylh[0]/hndc)*(rwymax-rwymin)+rwymin;
         xlh[1] = (xlh[1]/wndc)*(rwxmax-rwxmin)+rwxmin;
         ylh[1] = (ylh[1]/hndc)*(rwymax-rwymin)+rwymin;
         gPad->PaintLine(xlh[0], ylh[0], xlh[1], ylh[1]);
      }
   }
}


//______________________________________________________________________________
void TPad::PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
{
   // Paint line in CurrentPad World coordinates.

   Double_t x[2], y[2];
   x[0] = x1;   x[1] = x2;   y[0] = y1;   y[1] = y2;

   //If line is totally clipped, return
   if (TestBit(TGraph::kClipFrame)) {
      if (Clip(x,y,fUxmin,fUymin,fUxmax,fUymax) == 2) return;
   } else {
      if (Clip(x,y,fX1,fY1,fX2,fY2) == 2) return;
   }

   if (!gPad->IsBatch())
      GetPainter()->DrawLine(x[0], y[0], x[1], y[1]);

   if (gVirtualPS) {
      gVirtualPS->DrawPS(2, x, y);
   }

   Modified();
}


//______________________________________________________________________________
void TPad::PaintLineNDC(Double_t u1, Double_t v1,Double_t u2, Double_t v2)
{
   static Double_t xw[2], yw[2];
   if (!gPad->IsBatch())
      GetPainter()->DrawLineNDC(u1, v1, u2, v2);

   if (gVirtualPS) {
      xw[0] = fX1 + u1*(fX2 - fX1);
      xw[1] = fX1 + u2*(fX2 - fX1);
      yw[0] = fY1 + v1*(fY2 - fY1);
      yw[1] = fY1 + v2*(fY2 - fY1);
      gVirtualPS->DrawPS(2, xw, yw);
   }

   Modified();
}


//______________________________________________________________________________
void TPad::PaintLine3D(Float_t *p1, Float_t *p2)
{
   // Paint 3-D line in the CurrentPad.

   if (!fView) return;

   // convert from 3-D to 2-D pad coordinate system
   Double_t xpad[6];
   Double_t temp[3];
   Int_t i;
   for (i=0;i<3;i++) temp[i] = p1[i];
   fView->WCtoNDC(temp, &xpad[0]);
   for (i=0;i<3;i++) temp[i] = p2[i];
   fView->WCtoNDC(temp, &xpad[3]);
   PaintLine(xpad[0],xpad[1],xpad[3],xpad[4]);
}


//______________________________________________________________________________
void TPad::PaintLine3D(Double_t *p1, Double_t *p2)
{
   // Paint 3-D line in the CurrentPad.

   //take into account perspective view
   if (!fView) return;
   // convert from 3-D to 2-D pad coordinate system
   Double_t xpad[6];
   Double_t temp[3];
   Int_t i;
   for (i=0;i<3;i++) temp[i] = p1[i];
   fView->WCtoNDC(temp, &xpad[0]);
   for (i=0;i<3;i++) temp[i] = p2[i];
   fView->WCtoNDC(temp, &xpad[3]);
   PaintLine(xpad[0],xpad[1],xpad[3],xpad[4]);
}


//______________________________________________________________________________
void TPad::PaintPolyLine(Int_t n, Float_t *x, Float_t *y, Option_t *)
{
   // Paint polyline in CurrentPad World coordinates.

   if (n < 2) return;

   Double_t xmin,xmax,ymin,ymax;
   if (TestBit(TGraph::kClipFrame)) {
      xmin = fUxmin; ymin = fUymin; xmax = fUxmax; ymax = fUymax;
   } else {
      xmin = fX1; ymin = fY1; xmax = fX2; ymax = fY2;
   }
   Int_t i, i1=-1,np=1;
   for (i=0; i<n-1; i++) {
      Double_t x1=x[i];
      Double_t y1=y[i];
      Double_t x2=x[i+1];
      Double_t y2=y[i+1];
      Int_t iclip = Clip(&x[i],&y[i],xmin,ymin,xmax,ymax);
      if (iclip == 2) {
         i1 = -1;
         continue;
      }
      np++;
      if (i1 < 0) i1 = i;
      if (iclip == 0 && i < n-2) continue;
      if (!gPad->IsBatch())
         GetPainter()->DrawPolyLine(np, &x[i1], &y[i1]);
      if (gVirtualPS) {
         gVirtualPS->DrawPS(np, &x[i1], &y[i1]);
      }
      if (iclip) {
         x[i] = x1;
         y[i] = y1;
         x[i+1] = x2;
         y[i+1] = y2;
      }
      i1 = -1;
      np = 1;
   }

   Modified();
}


//______________________________________________________________________________
void TPad::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

   if (n < 2) return;

   Double_t xmin,xmax,ymin,ymax;
   Bool_t mustClip = kTRUE;
   if (TestBit(TGraph::kClipFrame)) {
      xmin = fUxmin; ymin = fUymin; xmax = fUxmax; ymax = fUymax;
   } else {
      xmin = fX1; ymin = fY1; xmax = fX2; ymax = fY2;
      if (option && (option[0] == 'C')) mustClip = kFALSE;
   }

   Int_t i, i1=-1, np=1, iclip=0;

   for (i=0; i < n-1; i++) {
      Double_t x1=x[i];
      Double_t y1=y[i];
      Double_t x2=x[i+1];
      Double_t y2=y[i+1];
      if (mustClip) {
         iclip = Clip(&x[i],&y[i],xmin,ymin,xmax,ymax);
         if (iclip == 2) {
            i1 = -1;
            continue;
         }
      }
      np++;
      if (i1 < 0) i1 = i;
      if (iclip == 0 && i < n-2) continue;
      if (!gPad->IsBatch())
         GetPainter()->DrawPolyLine(np, &x[i1], &y[i1]);
      if (gVirtualPS) {
         gVirtualPS->DrawPS(np, &x[i1], &y[i1]);
      }
      if (iclip) {
         x[i] = x1;
         y[i] = y1;
         x[i+1] = x2;
         y[i+1] = y2;
      }
      i1 = -1;
      np = 1;
   }

   Modified();
}

//______________________________________________________________________________
void TPad::PaintPolyLineNDC(Int_t n, Double_t *x, Double_t *y, Option_t *)
{
   // Paint polyline in CurrentPad NDC coordinates.
   if (n <=0) return;

   if (!gPad->IsBatch())
      GetPainter()->DrawPolyLineNDC(n, x, y);

   if (gVirtualPS) {
      Double_t *xw = new Double_t[n];
      Double_t *yw = new Double_t[n];
      for (Int_t i=0; i<n; i++) {
         xw[i] = fX1 + x[i]*(fX2 - fX1);
         yw[i] = fY1 + y[i]*(fY2 - fY1);
      }
      gVirtualPS->DrawPS(n, xw, yw);
      delete [] xw;
      delete [] yw;
   }
   Modified();
}


//______________________________________________________________________________
void TPad::PaintPolyLine3D(Int_t n, Double_t *p)
{
   // Paint 3-D polyline in the CurrentPad.
   if (!fView) return;

   // Loop on each individual line
   for (Int_t i = 1; i < n; i++)
      PaintLine3D(&p[3*i-3], &p[3*i]);

   Modified();
}


//______________________________________________________________________________
void TPad::PaintPolyMarker(Int_t nn, Float_t *x, Float_t *y, Option_t *)
{
   // Paint polymarker in CurrentPad World coordinates.

   Int_t n = TMath::Abs(nn);
   Double_t xmin,xmax,ymin,ymax;
   if (nn > 0 || TestBit(TGraph::kClipFrame)) {
      xmin = fUxmin; ymin = fUymin; xmax = fUxmax; ymax = fUymax;
   } else {
      xmin = fX1; ymin = fY1; xmax = fX2; ymax = fY2;
   }
   Int_t i,i1=-1,np=0;
   for (i=0; i<n; i++) {
      if (x[i] >= xmin && x[i] <= xmax && y[i] >= ymin && y[i] <= ymax) {
         np++;
         if (i1 < 0) i1 = i;
         if (i < n-1) continue;
      }
      if (np == 0) continue;
      if (!gPad->IsBatch())
         GetPainter()->DrawPolyMarker(np, &x[i1], &y[i1]);
      if (gVirtualPS) {
         gVirtualPS->DrawPolyMarker(np, &x[i1], &y[i1]);
      }
      i1 = -1;
      np = 0;
   }
   Modified();
}


//______________________________________________________________________________
void TPad::PaintPolyMarker(Int_t nn, Double_t *x, Double_t *y, Option_t *)
{
   // Paint polymarker in CurrentPad World coordinates.

   Int_t n = TMath::Abs(nn);
   Double_t xmin,xmax,ymin,ymax;
   if (nn > 0 || TestBit(TGraph::kClipFrame)) {
      xmin = fUxmin; ymin = fUymin; xmax = fUxmax; ymax = fUymax;
   } else {
      xmin = fX1; ymin = fY1; xmax = fX2; ymax = fY2;
   }
   Int_t i,i1=-1,np=0;
   for (i=0; i<n; i++) {
      if (x[i] >= xmin && x[i] <= xmax && y[i] >= ymin && y[i] <= ymax) {
         np++;
         if (i1 < 0) i1 = i;
         if (i < n-1) continue;
      }
      if (np == 0) continue;
      if (!gPad->IsBatch())
         GetPainter()->DrawPolyMarker(np, &x[i1], &y[i1]);
      if (gVirtualPS) {
         gVirtualPS->DrawPolyMarker(np, &x[i1], &y[i1]);
      }
      i1 = -1;
      np = 0;
   }
   Modified();
}


//______________________________________________________________________________
void TPad::PaintText(Double_t x, Double_t y, const char *text)
{
   // Paint text in CurrentPad World coordinates.

   Modified();

   if (!gPad->IsBatch())
      GetPainter()->DrawText(x, y, text, TVirtualPadPainter::kClear);

   if (gVirtualPS) gVirtualPS->Text(x, y, text);
}


//______________________________________________________________________________
void TPad::PaintText(Double_t x, Double_t y, const wchar_t *text)
{
   // Paint text in CurrentPad World coordinates.

   Modified();

   if (!gPad->IsBatch())
      GetPainter()->DrawText(x, y, text, TVirtualPadPainter::kClear);

   if (gVirtualPS) gVirtualPS->Text(x, y, text);
}


//______________________________________________________________________________
void TPad::PaintTextNDC(Double_t u, Double_t v, const char *text)
{
   // Paint text in CurrentPad NDC coordinates.

   Modified();

   if (!gPad->IsBatch())
      GetPainter()->DrawTextNDC(u, v, text, TVirtualPadPainter::kClear);

   if (gVirtualPS) {
      Double_t x = fX1 + u*(fX2 - fX1);
      Double_t y = fY1 + v*(fY2 - fY1);
      gVirtualPS->Text(x, y, text);
   }
}


//______________________________________________________________________________
void TPad::PaintTextNDC(Double_t u, Double_t v, const wchar_t *text)
{
   // Paint text in CurrentPad NDC coordinates.

   Modified();

   if (!gPad->IsBatch())
      GetPainter()->DrawTextNDC(u, v, text, TVirtualPadPainter::kClear);

   if (gVirtualPS) {
      Double_t x = fX1 + u*(fX2 - fX1);
      Double_t y = fY1 + v*(fY2 - fY1);
      gVirtualPS->Text(x, y, text);
   }
}


//______________________________________________________________________________
TPad *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 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.
   //

   //the two following statements are necessary under NT (multithreaded)
   //when a TCanvas object is being created and a thread calling TPad::Pick
   //before the TPad constructor has completed in the other thread
   if (gPad == 0) return 0; //Andy Haas
   if (GetListOfPrimitives() == 0) return 0; //Andy Haas

   Int_t dist;
   // Search if point is in pad itself
   Double_t x = AbsPixeltoX(px);
   Double_t y = AbsPixeltoY(py);
   if (this != gPad->GetCanvas()) {
      if (!((x >= fX1 && x <= fX2) && (y >= fY1 && y <= fY2))) return 0;
   }

   // search for a primitive in this pad or its subpads
   static TObjOptLink dummyLink(0,"");  //place holder for when no link available
   TPad *padsav = (TPad*)gPad;
   gPad  = this;    // since no drawing will be done, don't use cd() for efficiency reasons
   TPad *pick   = 0;
   TPad *picked = this;
   pickobj      = 0;
   if (DistancetoPrimitive(px,py) < fgMaxPickDistance) {
      dummyLink.SetObject(this);
      pickobj = &dummyLink;
   }

   // Loop backwards over the list of primitives. The first non-pad primitive
   // found is the selected one. However, we have to keep going down the
   // list to see if there is maybe a pad overlaying the primitive. In that
   // case look into the pad for a possible primitive. Once a pad has been
   // found we can terminate the loop.
   Bool_t gotPrim = kFALSE;      // true if found a non pad primitive
   TObjLink *lnk = GetListOfPrimitives()->LastLink();

   //We can have 3d stuff in pad. If canvas prefers to draw
   //such stuff with OpenGL, the selection of 3d objects is
   //a gl viewer business so, in first cycle we do not
   //call DistancetoPrimitive for TAtt3D descendants.
   //In case of gl we first try to select 2d object first.

   while (lnk) {
      TObject *obj = lnk->GetObject();

      //If canvas prefers GL, all 3d objects must be drawn/selected by
      //gl viewer
      if (obj->InheritsFrom(TAtt3D::Class()) && fEmbeddedGL) {
         lnk = lnk->Prev();
         continue;
      }

      fPadPointer  = obj;
      if (obj->InheritsFrom(TPad::Class())) {
         pick = ((TPad*)obj)->Pick(px, py, pickobj);
         if (pick) {
            picked = pick;
            break;
         }
      } else if (!gROOT->GetEditorMode()) {
         if (!gotPrim) {
            if (!obj->TestBit(kCannotPick)) {
               dist = obj->DistancetoPrimitive(px, py);
               if (dist < fgMaxPickDistance) {
                  pickobj = lnk;
                  gotPrim = kTRUE;
                  if (dist == 0) break;
               }
            }
         }
      }

      lnk = lnk->Prev();
   }

   //if no primitive found, check if we have a TView
   //if yes, return the view except if you are in the lower or upper X range
   //of the pad.
   //In case canvas prefers gl, fView existance
   //automatically means viewer3d existance. (?)

   if (fView && !gotPrim) {
      Double_t dx = 0.05*(fUxmax-fUxmin);
      if ((x > fUxmin + dx) && (x < fUxmax-dx)) {

         if (fEmbeddedGL) {
            //No 2d stuff was selected, but we have gl-viewer. Let it select an object in
            //scene (or select itself). In any case it'll internally call
            //gPad->SetSelected(ptr) as, for example, hist painter does.
            py -= Int_t((1 - GetHNDC() - GetYlowNDC()) * GetWh());
            px -= Int_t(GetXlowNDC() * GetWw());
            fViewer3D->DistancetoPrimitive(px, py);
         }
         else
            dummyLink.SetObject(fView);
      }
   }

   if (picked->InheritsFrom(TButton::Class())) {
      TButton *button = (TButton*)picked;
      if (!button->IsEditable()) pickobj = 0;
   }

   gPad = padsav;
   return picked;
}


//___________________________________________________________________________
void TPad::Pop()
{
   // Pop pad to the top of the stack.

   if (!fMother) return;
   if (!fPrimitives) fPrimitives = new TList;
   if (this == fMother->GetListOfPrimitives()->Last()) return;

   TListIter next(fMother->GetListOfPrimitives());
   TObject *obj;
   while ((obj = next()))
      if (obj == this) {
         char *opt = StrDup(next.GetOption());
         fMother->GetListOfPrimitives()->Remove(this);
         fMother->GetListOfPrimitives()->AddLast(this, opt);
         delete [] opt;
         return;
      }
}


//______________________________________________________________________________
void TPad::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 sufix 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

   ((TPad*)this)->SaveAs(filename);
}


//______________________________________________________________________________
static Bool_t ContainsTImage(TList *li)
{
   // auxilary function. Returns kTRUE if list contains an object inherited
   // from TImage

   TIter next(li);
   TObject *obj;

   while ((obj = next())) {
      if (obj->InheritsFrom(TImage::Class())) {
         return kTRUE;
      } else if (obj->InheritsFrom(TPad::Class())) {
         if (ContainsTImage(((TPad*)obj)->GetListOfPrimitives())) {
            return kTRUE;
         }
      }
   }
   return kFALSE;
}


//______________________________________________________________________________
void TPad::Print(const char *filenam, Option_t *option)
{
   // Save Canvas 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)
   //            "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.
   //   Examples:
   //      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
   // 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 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. 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
   // }
   //
   //  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 ")".  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.
   //
   // 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 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.
   // 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

   TString psname, fs1, fs2;
   const char *filename;

   // "[" and "]" are special characters for ExpandPathName. When they are at the end
   // of the file name (see help) they must be removed before doing ExpandPathName.
   fs1 = filenam;
   if (fs1.EndsWith("[")) {
      fs1.Replace((fs1.Length()-1),1," ");
      fs2 = gSystem->ExpandPathName(fs1.Data());
      fs2.Replace((fs2.Length()-1),1,"[");
   } else if (fs1.EndsWith("]")) {
      fs1.Replace((fs1.Length()-1),1," ");
      fs2 = gSystem->ExpandPathName(fs1.Data());
      fs2.Replace((fs2.Length()-1),1,"]");
   } else {
      char* exppath = gSystem->ExpandPathName(fs1.Data());
      fs2 = exppath;
      delete [] exppath;
   }
   filename = fs2.Data();

   // Set the default option as "Postscript" (Should be a data member of TPad)
   const char *opt_default="ps";

   Int_t lenfil =  filename ? strlen(filename) : 0;
   TString opt = (!option) ? opt_default : option;
   Bool_t image = kFALSE;

   if ( !lenfil )  {
      psname = GetName();
      psname += opt;
   } else {
      psname = filename;
   }

   // lines below protected against case like c1->SaveAs( "../ps/cs.ps" );
   if (psname.BeginsWith('.') && (psname.Contains('/') == 0)) {
      psname = GetName();
      psname.Append(filename);
      psname.Prepend("/");
      psname.Prepend(gEnv->GetValue("Canvas.PrintDirectory","."));
   }
   if (!gPad->IsBatch() && fCanvas)
      GetPainter()->SelectDrawable(GetCanvasID());

   // Save pad/canvas in alternative formats
   TImage::EImageFileTypes gtype = TImage::kUnknown;
   if (strstr(opt, "gif+")) {
      gtype = TImage::kAnimGif;
      image = kTRUE;
   } else if (strstr(opt, "gif")) {
      gtype = TImage::kGif;
      image = kTRUE;
   } else if (strstr(opt, "png")) {
      gtype = TImage::kPng;
      image = kTRUE;
   } else if (strstr(opt, "jpg")) {
      gtype = TImage::kJpeg;
      image = kTRUE;
   } else if (strstr(opt, "tiff")) {
      gtype = TImage::kTiff;
      image = kTRUE;
   } else if (strstr(opt, "xpm")) {
      gtype = TImage::kXpm;
      image = kTRUE;
   } else if (strstr(opt, "bmp")) {
      gtype = TImage::kBmp;
      image = kTRUE;
   }

   Int_t wid = 0;
   if (!GetCanvas()) return;
   if (!gROOT->IsBatch() && image) {
      if ((gtype == TImage::kGif) && !ContainsTImage(fPrimitives)) {
         wid = (this == GetCanvas()) ? GetCanvas()->GetCanvasID() : GetPixmapID();
         Color_t hc = gPad->GetCanvas()->GetHighLightColor();
         gPad->GetCanvas()->SetHighLightColor(-1);
         gPad->Modified();
         gPad->Update();
         GetPainter()->SelectDrawable(wid);
         GetPainter()->SaveImage(this, psname.Data(), gtype);
         if (!gSystem->AccessPathName(psname.Data())) {
            Info("Print", "GIF file %s has been created", psname.Data());
         }
         gPad->GetCanvas()->SetHighLightColor(hc);
         return;
      }
      if (gtype != TImage::kUnknown) {
         Color_t hc = gPad->GetCanvas()->GetHighLightColor();
         gPad->GetCanvas()->SetHighLightColor(-1);
         gPad->Modified();
         gPad->Update();
         if (gVirtualX->InheritsFrom("TGQt")) {
            wid = (this == GetCanvas()) ? GetCanvas()->GetCanvasID() : GetPixmapID();
            gVirtualX->WritePixmap(wid,UtoPixel(1.),VtoPixel(0.),(char *)psname.Data());
         } else {
            Int_t saver = gErrorIgnoreLevel;
            gErrorIgnoreLevel = kFatal;
            gVirtualX->Update(1);
            gSystem->Sleep(30); // syncronize
            GetPainter()->SaveImage(this, psname, gtype);
            gErrorIgnoreLevel = saver;
         }
         if (!gSystem->AccessPathName(psname)) {
            Info("Print", "file %s has been created", psname.Data());
         }
         gPad->GetCanvas()->SetHighLightColor(hc);
      } else {
         Warning("Print", "Unsupported image format %s", psname.Data());
      }
      return;
   }

   //==============Save pad/canvas as a C++ script==============================
   if (strstr(opt,"cxx")) {
      GetCanvas()->SaveSource(psname, "");
      return;
   }

   //==============Save pad/canvas as a root file===============================
   if (strstr(opt,"root")) {
      if (gDirectory) gDirectory->SaveObjectAs(this,psname.Data(),"");
      return;
   }

   //==============Save pad/canvas as a XML file================================
   if (strstr(opt,"xml")) {
      // Plugin XML driver
      if (gDirectory) gDirectory->SaveObjectAs(this,psname.Data(),"");
      return;
   }

   //==============Save pad/canvas as a SVG file================================
   if (strstr(opt,"svg")) {
      gVirtualPS = (TVirtualPS*)gROOT->GetListOfSpecials()->FindObject(psname);

      Bool_t noScreen = kFALSE;
      if (!GetCanvas()->IsBatch() && GetCanvas()->GetCanvasID() == -1) {
         noScreen = kTRUE;
         GetCanvas()->SetBatch(kTRUE);
      }

      TPad *padsav = (TPad*)gPad;
      cd();

      if (!gVirtualPS) {
         // Plugin Postscript/SVG driver
         TPluginHandler *h;
         if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualPS", "svg"))) {
            if (h->LoadPlugin() == -1)
               return;
            h->ExecPlugin(0);
         }
      }

      // Create a new SVG file
      gVirtualPS->SetName(psname);
      gVirtualPS->Open(psname);
      gVirtualPS->SetBit(kPrintingPS);
      gVirtualPS->NewPage();
      Paint();
      if (noScreen)  GetCanvas()->SetBatch(kFALSE);

      if (!gSystem->AccessPathName(psname)) Info("Print", "SVG file %s has been created", psname.Data());

      delete gVirtualPS;
      gVirtualPS = 0;
      padsav->cd();

      return;
   }

   //==============Save pad/canvas as a TeX file================================
   if (strstr(opt,"tex")) {
      gVirtualPS = (TVirtualPS*)gROOT->GetListOfSpecials()->FindObject(psname);

      Bool_t noScreen = kFALSE;
      if (!GetCanvas()->IsBatch() && GetCanvas()->GetCanvasID() == -1) {
         noScreen = kTRUE;
         GetCanvas()->SetBatch(kTRUE);
      }

      TPad *padsav = (TPad*)gPad;
      cd();

      if (!gVirtualPS) {
         // Plugin Postscript/SVG driver
         TPluginHandler *h;
         if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualPS", "tex"))) {
            if (h->LoadPlugin() == -1)
               return;
            h->ExecPlugin(0);
         }
      }

      // Create a new SVG file
      gVirtualPS->SetName(psname);
      gVirtualPS->Open(psname);
      gVirtualPS->SetBit(kPrintingPS);
      gVirtualPS->NewPage();
      Paint();

      if (noScreen)  GetCanvas()->SetBatch(kFALSE);

      if (!gSystem->AccessPathName(psname)) Info("Print", "TeX file %s has been created", psname.Data());

      delete gVirtualPS;
      gVirtualPS = 0;
      padsav->cd();

      return;
   }

   //==============Save pad/canvas as a Postscript file=========================

   // in case we read directly from a Root file and the canvas
   // is not on the screen, set batch mode

   Bool_t mustOpen  = kTRUE;
   Bool_t mustClose = kTRUE;
   Bool_t copen=kFALSE, cclose=kFALSE, copenb=kFALSE, ccloseb=kFALSE;
   if (!image) {
      // The parenthesis mechanism is only valid for PS and PDF files.
      copen   = psname.EndsWith("("); if (copen)   psname[psname.Length()-1] = 0;
      cclose  = psname.EndsWith(")"); if (cclose)  psname[psname.Length()-1] = 0;
      copenb  = psname.EndsWith("["); if (copenb)  psname[psname.Length()-1] = 0;
      ccloseb = psname.EndsWith("]"); if (ccloseb) psname[psname.Length()-1] = 0;
   }
   gVirtualPS = (TVirtualPS*)gROOT->GetListOfSpecials()->FindObject(psname);
   if (gVirtualPS) {mustOpen = kFALSE; mustClose = kFALSE;}
   if (copen  || copenb)  mustClose = kFALSE;
   if (cclose || ccloseb) mustClose = kTRUE;

   Bool_t noScreen = kFALSE;
   if (!GetCanvas()->IsBatch() && GetCanvas()->GetCanvasID() == -1) {
      noScreen = kTRUE;
      GetCanvas()->SetBatch(kTRUE);
   }
   Int_t pstype = 111;
   Double_t xcanvas = GetCanvas()->XtoPixel(GetCanvas()->GetX2());
   Double_t ycanvas = GetCanvas()->YtoPixel(GetCanvas()->GetY1());
   Double_t ratio   = ycanvas/xcanvas;
   if (ratio < 1)               pstype = 112;
   if (strstr(opt,"Portrait"))  pstype = 111;
   if (strstr(opt,"Landscape")) pstype = 112;
   if (strstr(opt,"eps"))       pstype = 113;
   if (strstr(opt,"Preview"))   pstype = 113;
   TPad *padsav = (TPad*)gPad;
   cd();
   TVirtualPS *psave = gVirtualPS;

   if (!gVirtualPS || mustOpen) {
      // Plugin Postscript driver
      TPluginHandler *h;
      if (strstr(opt,"pdf") || strstr(opt,"Title:")) {
         if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualPS", "pdf"))) {
            if (h->LoadPlugin() == -1) return;
            h->ExecPlugin(0);
         }
      } else if (image) {
         // Plugin TImageDump driver
         if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualPS", "image"))) {
            if (h->LoadPlugin() == -1) return;
            h->ExecPlugin(0);
         }
      } else {
         if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualPS", "ps"))) {
            if (h->LoadPlugin() == -1) return;
            h->ExecPlugin(0);
         }
      }

      // Create a new Postscript, PDF or image file
      if (gVirtualPS) gVirtualPS->SetName(psname);
      const Ssiz_t titlePos = opt.Index("Title:");
      if (titlePos != kNPOS) {
         if (gVirtualPS) gVirtualPS->SetTitle(opt.Data()+titlePos+6);
         opt.Replace(titlePos,opt.Length(),"pdf");
      }
      if (gVirtualPS) gVirtualPS->Open(psname,pstype);
      if (gVirtualPS) gVirtualPS->SetBit(kPrintingPS);
      if (!copenb) {
         if (!strstr(opt,"pdf") || image) {
            if (gVirtualPS) gVirtualPS->NewPage();
         }
         Paint();
      }
      if (noScreen) GetCanvas()->SetBatch(kFALSE);

      if (mustClose) {
         gROOT->GetListOfSpecials()->Remove(gVirtualPS);
         delete gVirtualPS;
         gVirtualPS = psave;
      } else {
         gROOT->GetListOfSpecials()->Add(gVirtualPS);
         gVirtualPS = 0;
      }

      if (!gSystem->AccessPathName(psname)) Info("Print", "%s file %s has been created", opt.Data(), psname.Data());
   } else {
      // Append to existing Postscript, PDF or GIF file
      if (!ccloseb) {
         gVirtualPS->NewPage();
         Paint();
      }
      const Ssiz_t titlePos = opt.Index("Title:");
      if (titlePos != kNPOS) {
         gVirtualPS->SetTitle(opt.Data()+titlePos+6);
         opt.Replace(titlePos,opt.Length(),"pdf");
      } else {
         gVirtualPS->SetTitle("PDF");
      }
      Info("Print", "Current canvas added to %s file %s", opt.Data(), psname.Data());
      if (mustClose) {
         gROOT->GetListOfSpecials()->Remove(gVirtualPS);
         delete gVirtualPS;
         gVirtualPS = 0;
      } else {
         gVirtualPS = 0;
      }
   }

   if (strstr(opt,"Preview")) gSystem->Exec(Form("epstool --quiet -t6p %s %s",psname.Data(),psname.Data()));

   padsav->cd();
}


//______________________________________________________________________________
void TPad::Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
{
   // Set world coordinate system for the pad.
   // Emits signal "RangeChanged()", in the slot get the range
   // via GetRange().

   if ((x1 >= x2) || (y1 >= y2)) {
      Error("Range", "illegal world coordinates range: x1=%f, y1=%f, x2=%f, y2=%f",x1,y1,x2,y2);
      return;
   }

   fUxmin = x1;
   fUxmax = x2;
   fUymin = y1;
   fUymax = y2;

   if (fX1 == x1 && fY1 == y1 && fX2 == x2 && fY2 == y2) return;

   fX1  = x1;
   fY1  = y1;
   fX2  = x2;
   fY2  = y2;

   // compute pad conversion coefficients
   ResizePad();

   if (gPad == this)
      GetPainter()->InvalidateCS();

   // emit signal
   RangeChanged();
}


//______________________________________________________________________________
void TPad::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().

   if ((xmin >= xmax) || (ymin >= ymax)) {
      Error("RangeAxis", "illegal axis coordinates range: xmin=%f, ymin=%f, xmax=%f, ymax=%f",
            xmin, ymin, xmax, ymax);
      return;
   }

   fUxmin  = xmin;
   fUymin  = ymin;
   fUxmax  = xmax;
   fUymax  = ymax;

   // emit signal
   RangeAxisChanged();
}


//______________________________________________________________________________
void TPad::RecursiveRemove(TObject *obj)
{
   // Recursively remove object from a pad and its subpads.

   if (obj == fCanvas->GetSelected()) fCanvas->SetSelected(0);
   if (obj == fCanvas->GetClickSelected()) fCanvas->SetClickSelected(0);
   if (obj == fView) fView = 0;
   if (!fPrimitives) return;
   Int_t nold = fPrimitives->GetSize();
   fPrimitives->RecursiveRemove(obj);
   if (nold != fPrimitives->GetSize()) fModified = kTRUE;
}


//______________________________________________________________________________
void TPad::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

   // get first histogram in the list of primitives
   TString opt = option;
   opt.ToLower();

   TPad *padsav = (TPad*)gPad;
   cd();

   if (!fPrimitives) fPrimitives = new TList;
   TIter next(fPrimitives);
   TObject *obj;
   while ((obj = next())) {
      if (obj->InheritsFrom(TH1::Class())) {
         TH1 *hobj = (TH1*)obj;
         if (opt.Contains("g")) hobj->DrawCopy("sameaxig");
         else                   hobj->DrawCopy("sameaxis");
         return;
      }
      if (obj->InheritsFrom(TMultiGraph::Class())) {
         TMultiGraph *mg = (TMultiGraph*)obj;
         if (mg) {
            TH1F *h1f = mg->GetHistogram();
            if (h1f) h1f->DrawCopy("sameaxis");
         }
         return;
      }
      if (obj->InheritsFrom(TGraph::Class())) {
         TGraph *g = (TGraph*)obj;
         if (g) g->GetHistogram()->DrawCopy("sameaxis");
         return;
      }
      if (obj->InheritsFrom(THStack::Class())) {
         THStack *hs = (THStack*)obj;
         if (hs) {
            TH1 *h1 = hs->GetHistogram();
            if (h1) h1->DrawCopy("sameaxis");
         }
         return;
      }
   }

   if (padsav) padsav->cd();
}


//______________________________________________________________________________
void TPad::ResizePad(Option_t *option)
{
   // 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

   // Recompute subpad positions in case pad has been moved/resized
   TPad *parent = fMother;
   if (this == gPad->GetCanvas()) {
      fAbsXlowNDC  = fXlowNDC;
      fAbsYlowNDC  = fYlowNDC;
      fAbsWNDC     = fWNDC;
      fAbsHNDC     = fHNDC;
   }
   else {
      fAbsXlowNDC  = fXlowNDC*parent->GetAbsWNDC() + parent->GetAbsXlowNDC();
      fAbsYlowNDC  = fYlowNDC*parent->GetAbsHNDC() + parent->GetAbsYlowNDC();
      fAbsWNDC     = fWNDC*parent->GetAbsWNDC();
      fAbsHNDC     = fHNDC*parent->GetAbsHNDC();
   }

   Double_t ww = (Double_t)gPad->GetWw();
   Double_t wh = (Double_t)gPad->GetWh();
   Double_t pxlow   = fAbsXlowNDC*ww;
   Double_t pylow   = (1-fAbsYlowNDC)*wh;
   Double_t pxrange = fAbsWNDC*ww;
   Double_t pyrange = -fAbsHNDC*wh;

   // Linear X axis
   Double_t rounding = 0.00005;
   Double_t xrange  = fX2 - fX1;
   fXtoAbsPixelk = rounding + pxlow - pxrange*fX1/xrange;      //origin at left
   fXtoPixelk = rounding +  -pxrange*fX1/xrange;
   fXtoPixel  = pxrange/xrange;
   fAbsPixeltoXk = fX1 - pxlow*xrange/pxrange;
   fPixeltoXk = fX1;
   fPixeltoX  = xrange/pxrange;
   // Linear Y axis
   Double_t yrange  = fY2 - fY1;
   fYtoAbsPixelk = rounding + pylow - pyrange*fY1/yrange;      //origin at top
   fYtoPixelk = rounding +  -pyrange - pyrange*fY1/yrange;
   fYtoPixel  = pyrange/yrange;
   fAbsPixeltoYk = fY1 - pylow*yrange/pyrange;
   fPixeltoYk = fY1;
   fPixeltoY  = yrange/pyrange;

   // Coefficients to convert from pad NDC coordinates to pixel coordinates

   fUtoAbsPixelk = rounding + pxlow;
   fUtoPixelk = rounding;
   fUtoPixel  = pxrange;
   fVtoAbsPixelk = rounding + pylow;
   fVtoPixelk = -pyrange;
   fVtoPixel  = pyrange;

   // Coefficients to convert from canvas pixels to pad world coordinates

   // Resize all subpads
   TObject *obj;
   if (!fPrimitives) fPrimitives = new TList;
   TIter    next(GetListOfPrimitives());
   while ((obj = next())) {
      if (obj->InheritsFrom(TPad::Class()))
         ((TPad*)obj)->ResizePad(option);
   }

   // Reset all current sizes
   if (gPad->IsBatch())
      fPixmapID = 0;
   else {
      GetPainter()->SetLineWidth(-1);
      GetPainter()->SetTextSize(-1);

      // create or re-create off-screen pixmap
      if (fPixmapID) {
         int w = TMath::Abs(XtoPixel(fX2) - XtoPixel(fX1));
         int h = TMath::Abs(YtoPixel(fY2) - YtoPixel(fY1));
         //protection in case of wrong pad parameters.
         //without this protection, the OpenPixmap or ResizePixmap crashes with
         //the message "Error in <RootX11ErrorHandler>: BadValue (integer parameter out of range for operation)"
         //resulting in a frozen xterm
         if (   !(TMath::Finite(fX1)) || !(TMath::Finite(fX2))
             || !(TMath::Finite(fY1)) || !(TMath::Finite(fY2))
             || (TMath::IsNaN(fX1))  || (TMath::IsNaN(fX2))
             || (TMath::IsNaN(fY1))  || (TMath::IsNaN(fY2)))
            Warning("ResizePad", "Inf/NaN propagated to the pad. Check drawn objects.");
         if (w <= 0 || w > 10000) {
            Warning("ResizePad", "%s width changed from %d to %d\n",GetName(),w,10);
            w = 10;
         }
         if (h <= 0 || h > 10000) {
            Warning("ResizePad", "%s height changed from %d to %d\n",GetName(),h,10);
            h = 10;
         }
         if (fPixmapID == -1) {      // this case is handled via the ctor
            fPixmapID = GetPainter()->CreateDrawable(w, h);
         } else {
            if (gVirtualX->ResizePixmap(fPixmapID, w, h)) {
               Modified(kTRUE);
            }
         }
      }
   }
   if (fView) {
      TPad *padsav  = (TPad*)gPad;
      if (padsav == this) {
         fView->ResizePad();
      } else {
         cd();
         fView->ResizePad();
         padsav->cd();
      }
   }
}


//______________________________________________________________________________
void TPad::SaveAs(const char *filename, Option_t * /*option*/) 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 .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

   TString psname;
   Int_t lenfil =  filename ? strlen(filename) : 0;

   if (!lenfil)  { psname = GetName(); psname.Append(".ps"); }
   else            psname = filename;

   // lines below protected against case like c1->SaveAs( "../ps/cs.ps" );
   if (psname.BeginsWith('.') && (psname.Contains('/') == 0)) {
      psname = GetName();
      psname.Append(filename);
      psname.Prepend("/");
      psname.Prepend(gEnv->GetValue("Canvas.PrintDirectory","."));
   }

   if (psname.EndsWith(".gif"))
      ((TPad*)this)->Print(psname,"gif");
   else if (psname.Contains(".gif+"))
      ((TPad*)this)->Print(psname,"gif+");
   else if (psname.EndsWith(".C") || psname.EndsWith(".cxx") || psname.EndsWith(".cpp"))
      ((TPad*)this)->Print(psname,"cxx");
   else if (psname.EndsWith(".root"))
      ((TPad*)this)->Print(psname,"root");
   else if (psname.EndsWith(".xml"))
      ((TPad*)this)->Print(psname,"xml");
   else if (psname.EndsWith(".eps"))
      ((TPad*)this)->Print(psname,"eps");
   else if (psname.EndsWith(".pdf"))
      ((TPad*)this)->Print(psname,"pdf");
   else if (psname.EndsWith(".pdf["))
      ((TPad*)this)->Print(psname,"pdf");
   else if (psname.EndsWith(".pdf]"))
      ((TPad*)this)->Print(psname,"pdf");
   else if (psname.EndsWith(".pdf("))
      ((TPad*)this)->Print(psname,"pdf");
   else if (psname.EndsWith(".pdf)"))
      ((TPad*)this)->Print(psname,"pdf");
   else if (psname.EndsWith(".svg"))
      ((TPad*)this)->Print(psname,"svg");
   else if (psname.EndsWith(".tex"))
      ((TPad*)this)->Print(psname,"tex");
   else if (psname.EndsWith(".xpm"))
      ((TPad*)this)->Print(psname,"xpm");
   else if (psname.EndsWith(".png"))
      ((TPad*)this)->Print(psname,"png");
   else if (psname.EndsWith(".jpg"))
      ((TPad*)this)->Print(psname,"jpg");
   else if (psname.EndsWith(".jpeg"))
      ((TPad*)this)->Print(psname,"jpg");
   else if (psname.EndsWith(".bmp"))
      ((TPad*)this)->Print(psname,"bmp");
   else if (psname.EndsWith(".tiff"))
      ((TPad*)this)->Print(psname,"tiff");
   else
      ((TPad*)this)->Print(psname,"ps");
}


//______________________________________________________________________________
void TPad::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
{
   // Save primitives in this pad on the C++ source file out.

   TPad *padsav = (TPad*)gPad;
   gPad = this;
   char quote='"';
   char lcname[10];
   const char *cname = GetName();
   Int_t nch = strlen(cname);
   if (nch < 10) {
      strlcpy(lcname,cname,10);
      for (Int_t k=1;k<=nch;k++) {if (lcname[nch-k] == ' ') lcname[nch-k] = 0;}
      if (lcname[0] == 0) {
         if (this == gPad->GetCanvas()) {strlcpy(lcname,"c1",10);  nch = 2;}
         else                           {strlcpy(lcname,"pad",10); nch = 3;}
      }
      cname = lcname;
   }

   //   Write pad parameters
   if (this != gPad->GetCanvas()) {
      out <<"  "<<std::endl;
      out <<"// ------------>Primitives in pad: "<<GetName()<<std::endl;

      out<<"   TPad *"<<cname<<" = new TPad("<<quote<<GetName()<<quote<<", "<<quote<<GetTitle()
      <<quote
      <<","<<fXlowNDC
      <<","<<fYlowNDC
      <<","<<fXlowNDC+fWNDC
      <<","<<fYlowNDC+fHNDC
      <<");"<<std::endl;
      out<<"   "<<cname<<"->Draw();"<<std::endl;
      out<<"   "<<cname<<"->cd();"<<std::endl;
   }
   out<<"   "<<cname<<"->Range("<<fX1<<","<<fY1<<","<<fX2<<","<<fY2<<");"<<std::endl;
   TView *view = GetView();
   Double_t rmin[3], rmax[3];
   if (view) {
      view->GetRange(rmin, rmax);
      static Int_t viewNumber = 0;
      out<<"   TView *view"<<++viewNumber<<" = TView::CreateView(1);"<<std::endl;
      out<<"   view"<<viewNumber<<"->SetRange("<<rmin[0]<<","<<rmin[1]<<","<<rmin[2]<<","
                               <<rmax[0]<<","<<rmax[1]<<","<<rmax[2]<<");"<<std::endl;
   }
   if (GetFillColor() != 19) {
      if (GetFillColor() > 228) {
         TColor::SaveColor(out, GetFillColor());
         out<<"   "<<cname<<"->SetFillColor(ci);" << std::endl;
      } else
         out<<"   "<<cname<<"->SetFillColor("<<GetFillColor()<<");"<<std::endl;
   }
   if (GetFillStyle() != 1001) {
      out<<"   "<<cname<<"->SetFillStyle("<<GetFillStyle()<<");"<<std::endl;
   }
   if (GetBorderMode() != 1) {
      out<<"   "<<cname<<"->SetBorderMode("<<GetBorderMode()<<");"<<std::endl;
   }
   if (GetBorderSize() != 4) {
      out<<"   "<<cname<<"->SetBorderSize("<<GetBorderSize()<<");"<<std::endl;
   }
   if (GetLogx()) {
      out<<"   "<<cname<<"->SetLogx();"<<std::endl;
   }
   if (GetLogy()) {
      out<<"   "<<cname<<"->SetLogy();"<<std::endl;
   }
   if (GetLogz()) {
      out<<"   "<<cname<<"->SetLogz();"<<std::endl;
   }
   if (GetGridx()) {
      out<<"   "<<cname<<"->SetGridx();"<<std::endl;
   }
   if (GetGridy()) {
      out<<"   "<<cname<<"->SetGridy();"<<std::endl;
   }
   if (GetTickx()) {
      out<<"   "<<cname<<"->SetTickx("<<GetTickx()<<");"<<std::endl;
   }
   if (GetTicky()) {
      out<<"   "<<cname<<"->SetTicky("<<GetTicky()<<");"<<std::endl;
   }
   if (GetTheta() != 30) {
      out<<"   "<<cname<<"->SetTheta("<<GetTheta()<<");"<<std::endl;
   }
   if (GetPhi() != 30) {
      out<<"   "<<cname<<"->SetPhi("<<GetPhi()<<");"<<std::endl;
   }
   if (TMath::Abs(fLeftMargin-0.1) > 0.01) {
      out<<"   "<<cname<<"->SetLeftMargin("<<GetLeftMargin()<<");"<<std::endl;
   }
   if (TMath::Abs(fRightMargin-0.1) > 0.01) {
      out<<"   "<<cname<<"->SetRightMargin("<<GetRightMargin()<<");"<<std::endl;
   }
   if (TMath::Abs(fTopMargin-0.1) > 0.01) {
      out<<"   "<<cname<<"->SetTopMargin("<<GetTopMargin()<<");"<<std::endl;
   }
   if (TMath::Abs(fBottomMargin-0.1) > 0.01) {
      out<<"   "<<cname<<"->SetBottomMargin("<<GetBottomMargin()<<");"<<std::endl;
   }

   if (GetFrameFillColor() != GetFillColor()) {
      if (GetFrameFillColor() > 228) {
         TColor::SaveColor(out, GetFrameFillColor());
         out<<"   "<<cname<<"->SetFrameFillColor(ci);" << std::endl;
      } else
         out<<"   "<<cname<<"->SetFrameFillColor("<<GetFrameFillColor()<<");"<<std::endl;
   }
   if (GetFrameFillStyle() != 1001) {
      out<<"   "<<cname<<"->SetFrameFillStyle("<<GetFrameFillStyle()<<");"<<std::endl;
   }
   if (GetFrameLineStyle() != 1) {
      out<<"   "<<cname<<"->SetFrameLineStyle("<<GetFrameLineStyle()<<");"<<std::endl;
   }
   if (GetFrameLineColor() != 1) {
      if (GetFrameLineColor() > 228) {
         TColor::SaveColor(out, GetFrameLineColor());
         out<<"   "<<cname<<"->SetFrameLineColor(ci);" << std::endl;
      } else
         out<<"   "<<cname<<"->SetFrameLineColor("<<GetFrameLineColor()<<");"<<std::endl;
   }
   if (GetFrameLineWidth() != 1) {
      out<<"   "<<cname<<"->SetFrameLineWidth("<<GetFrameLineWidth()<<");"<<std::endl;
   }
   if (GetFrameBorderMode() != 1) {
      out<<"   "<<cname<<"->SetFrameBorderMode("<<GetFrameBorderMode()<<");"<<std::endl;
   }
   if (GetFrameBorderSize() != 1) {
         out<<"   "<<cname<<"->SetFrameBorderSize("<<GetFrameBorderSize()<<");"<<std::endl;
   }

   TFrame *frame = fFrame;
   if (!frame) frame = (TFrame*)GetPrimitive("TFrame");
   if (frame) {
      if (frame->GetFillColor() != GetFillColor()) {
         if (frame->GetFillColor() > 228) {
            TColor::SaveColor(out, frame->GetFillColor());
            out<<"   "<<cname<<"->SetFrameFillColor(ci);" << std::endl;
         } else
            out<<"   "<<cname<<"->SetFrameFillColor("<<frame->GetFillColor()<<");"<<std::endl;
      }
      if (frame->GetFillStyle() != 1001) {
         out<<"   "<<cname<<"->SetFrameFillStyle("<<frame->GetFillStyle()<<");"<<std::endl;
      }
      if (frame->GetLineStyle() != 1) {
         out<<"   "<<cname<<"->SetFrameLineStyle("<<frame->GetLineStyle()<<");"<<std::endl;
      }
      if (frame->GetLineColor() != 1) {
         if (frame->GetLineColor() > 228) {
            TColor::SaveColor(out, frame->GetLineColor());
            out<<"   "<<cname<<"->SetFrameLineColor(ci);" << std::endl;
         } else
            out<<"   "<<cname<<"->SetFrameLineColor("<<frame->GetLineColor()<<");"<<std::endl;
      }
      if (frame->GetLineWidth() != 1) {
         out<<"   "<<cname<<"->SetFrameLineWidth("<<frame->GetLineWidth()<<");"<<std::endl;
      }
      if (frame->GetBorderMode() != 1) {
         out<<"   "<<cname<<"->SetFrameBorderMode("<<frame->GetBorderMode()<<");"<<std::endl;
      }
      if (frame->GetBorderSize() != 1) {
         out<<"   "<<cname<<"->SetFrameBorderSize("<<frame->GetBorderSize()<<");"<<std::endl;
      }
   }

   TIter next(GetListOfPrimitives());
   TObject *obj;
   Int_t grnum = 0;

   while ((obj = next())) {
      if (obj->InheritsFrom(TGraph::Class()))
         if (!strcmp(obj->GetName(),"Graph")) ((TGraph*)obj)->SetName(Form("Graph%d",grnum++));
      obj->SavePrimitive(out, (Option_t *)next.GetOption());
   }
   out<<"   "<<cname<<"->Modified();"<<std::endl;
   out<<"   "<<GetMother()->GetName()<<"->cd();"<<std::endl;
   if (padsav) padsav->cd();
}


//______________________________________________________________________________
void TPad::SetFixedAspectRatio(Bool_t fixed)
{
   // Fix pad aspect ratio to current value if fixed is true.

   if (fixed) {
      if (!fFixedAspectRatio) {
         if (fHNDC != 0.)
            fAspectRatio = fWNDC / fHNDC;
         else {
            Error("SetAspectRatio", "cannot fix aspect ratio, height of pad is 0");
            return;
         }
         fFixedAspectRatio = kTRUE;
      }
   } else {
      fFixedAspectRatio = kFALSE;
      fAspectRatio = 0;
   }
}


//______________________________________________________________________________
void TPad::SetEditable(Bool_t mode)
{
   // 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

   fEditable = mode;

   TObject *obj;
   if (!fPrimitives) fPrimitives = new TList;
   TIter    next(GetListOfPrimitives());
   while ((obj = next())) {
      if (obj->InheritsFrom(TPad::Class())) {
         TPad *pad = (TPad*)obj;
         pad->SetEditable(mode);
      }
   }
}


//______________________________________________________________________________
void TPad::SetFillStyle(Style_t fstyle)
{
   // Overrride TAttFill::FillStyle for TPad because we want to handle style=0
   // as style 4000.

   if (fstyle == 0) fstyle = 4000;
   TAttFill::SetFillStyle(fstyle);
}


//______________________________________________________________________________
void TPad::SetLogx(Int_t value)
{
   // 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

   fLogx = value;
   delete fView; fView=0;
   Modified();
}


//______________________________________________________________________________
void TPad::SetLogy(Int_t value)
{
   // 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

   fLogy = value;
   delete fView; fView=0;
   Modified();
}


//______________________________________________________________________________
void TPad::SetLogz(Int_t value)
{
   // Set Lin/Log scale for Z

   fLogz = value;
   delete fView; fView=0;
   Modified();
}


//______________________________________________________________________________
void TPad::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.

   // Reorder points to make sure xlow,ylow is bottom left point and
   // xup,yup is top right point.
   if (xup < xlow) {
      Double_t x = xlow;
      xlow = xup;
      xup  = x;
   }
   if (yup < ylow) {
      Double_t y = ylow;
      ylow = yup;
      yup  = y;
   }

   fXlowNDC = xlow;
   fYlowNDC = ylow;
   fWNDC    = xup - xlow;
   fHNDC    = yup - ylow;

   SetFixedAspectRatio(kFALSE);

   ResizePad();
}


//______________________________________________________________________________
void TPad::SetPad(const char *name, const char *title,
                  Double_t xlow, Double_t ylow, Double_t xup, Double_t yup,
                  Color_t color, Short_t bordersize, Short_t bordermode)
{
   // Set all pad parameters.

   fName  = name;
   fTitle = title;
   SetFillStyle(1001);
   SetBottomMargin(gStyle->GetPadBottomMargin());
   SetTopMargin(gStyle->GetPadTopMargin());
   SetLeftMargin(gStyle->GetPadLeftMargin());
   SetRightMargin(gStyle->GetPadRightMargin());
   if (color >= 0)   SetFillColor(color);
   else              SetFillColor(gStyle->GetPadColor());
   if (bordersize <  0) fBorderSize = gStyle->GetPadBorderSize();
   else                 fBorderSize = bordersize;
   if (bordermode < -1) fBorderMode = gStyle->GetPadBorderMode();
   else                 fBorderMode = bordermode;

   SetPad(xlow, ylow, xup, yup);
}

//______________________________________________________________________________
void TPad::SetView(TView *view)
{
   // Set the current TView. Delete previous view if view=0

   if (!view) delete fView;
   fView = view;
}

//______________________________________________________________________________
void TPad::SetAttFillPS(Color_t color, Style_t style)
{
   // Set postscript fill area attributes.

   if (gVirtualPS) {
      gVirtualPS->SetFillColor(color);
      gVirtualPS->SetFillStyle(style);
   }
}


//______________________________________________________________________________
void TPad::SetAttLinePS(Color_t color, Style_t style, Width_t lwidth)
{
   // Set postscript line attributes.

   if (gVirtualPS) {
      gVirtualPS->SetLineColor(color);
      gVirtualPS->SetLineStyle(style);
      gVirtualPS->SetLineWidth(lwidth);
   }
}


//______________________________________________________________________________
void TPad::SetAttMarkerPS(Color_t color, Style_t style, Size_t msize)
{
   // Set postscript marker attributes.

   if (gVirtualPS) {
      gVirtualPS->SetMarkerColor(color);
      gVirtualPS->SetMarkerStyle(style);
      gVirtualPS->SetMarkerSize(msize);
   }
}


//______________________________________________________________________________
void TPad::SetAttTextPS(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize)
{
   // Set postscript text attributes.

   if (gVirtualPS) {
      gVirtualPS->SetTextAlign(align);
      gVirtualPS->SetTextAngle(angle);
      gVirtualPS->SetTextColor(color);
      gVirtualPS->SetTextFont(font);
      if (font%10 > 2) {
         Float_t wh = (Float_t)gPad->XtoPixel(gPad->GetX2());
         Float_t hh = (Float_t)gPad->YtoPixel(gPad->GetY1());
         Float_t dy;
         if (wh < hh)  {
            dy = AbsPixeltoX(Int_t(tsize)) - AbsPixeltoX(0);
            tsize = dy/(fX2-fX1);
         } else {
            dy = AbsPixeltoY(0) - AbsPixeltoY(Int_t(tsize));
            tsize = dy/(fY2-fY1);
         }
      }
      gVirtualPS->SetTextSize(tsize);
   }
}


//______________________________________________________________________________
void TPad::DrawDist(Rectangle_t aBBox, Rectangle_t bBBox, char mode)
{
   // Draw Arrows to indicated equal distances of Objects with given BBoxes.
   // Used by ShowGuidelines

   Int_t lineColor = TColor::GetColor(239, 202, 0);
   Int_t x1,x2,y1,y2;
   x1 = x2 = y1 = y2 = 0;
   if (mode == 'x') {
      if (aBBox.fX<bBBox.fX) {
         x1 = aBBox.fX+aBBox.fWidth;
         x2 = bBBox.fX;
      }
      else {
         x1 = bBBox.fX+bBBox.fWidth;
         x2 = aBBox.fX;
      }

      if ((aBBox.fY > bBBox.fY) && (aBBox.fY + aBBox.fHeight < bBBox.fY + bBBox.fHeight))
                                    y1 = y2 = aBBox.fY + TMath::Nint(0.5*(Double_t)(aBBox.fHeight))+1;
      else if ((bBBox.fY > aBBox.fY) && (bBBox.fY + bBBox.fHeight < aBBox.fY + aBBox.fHeight))
                                    y1 = y2 = bBBox.fY + TMath::Nint(0.5*(Double_t)(bBBox.fHeight))+1;
      else if (aBBox.fY>bBBox.fY)   y1 = y2 = aBBox.fY-TMath::Nint(0.5*(Double_t)(aBBox.fY-(bBBox.fY+bBBox.fHeight)));
      else                          y1 = y2 = bBBox.fY-TMath::Nint(0.5*(Double_t)(bBBox.fY-(aBBox.fY+aBBox.fHeight)));
   }
   else if (mode == 'y') {
      if (aBBox.fY<bBBox.fY) {
         y1 = aBBox.fY+aBBox.fHeight;
         y2 = bBBox.fY;
      }
      else {
         y1 = bBBox.fY+bBBox.fHeight;
         y2 = aBBox.fY;
      }
      if ((aBBox.fX > bBBox.fX) && (aBBox.fX + aBBox.fWidth < bBBox.fX + bBBox.fWidth))
                                    x1 = x2 = aBBox.fX + TMath::Nint(0.5*(Double_t)(aBBox.fWidth))+1;
      else if ((bBBox.fX > aBBox.fX) && (bBBox.fX + bBBox.fWidth < aBBox.fX + aBBox.fWidth))
                                    x1 = x2 = bBBox.fX + TMath::Nint(0.5*(Double_t)(bBBox.fWidth))+1;
      else if (aBBox.fX>bBBox.fX)   x1 = x2 = aBBox.fX+TMath::Nint(0.5*(Double_t)(bBBox.fX+bBBox.fWidth-aBBox.fX));
      else                          x1 = x2 = bBBox.fX+TMath::Nint(0.5*(Double_t)(aBBox.fX+aBBox.fWidth-bBBox.fX));
   }

   TArrow *A = new TArrow(gPad->PixeltoX(x1), gPad->PixeltoY(y1-gPad->VtoPixel(0)), gPad->PixeltoX(x2), gPad->PixeltoY(y2-gPad->VtoPixel(0)), 0.01, "<|>");
   A->SetBit(kCanDelete);
   A->SetFillColor(lineColor);
   A->SetLineWidth(1);
   A->SetLineColor(lineColor);
   A->Draw();

   return;
}


//______________________________________________________________________________
struct dField {

   // Used by ShowGuidelines to store the distance Field between
   // objects in the canvas

   TAttBBox2D *fa;
   TAttBBox2D *fb;
   Int_t fdist;
   char fdir;


   dField()
      : fa(0), fb(0), fdist(0), fdir(' ')
   {}

   dField(TAttBBox2D *a, TAttBBox2D *b, Int_t dist, char direction)
      : fa(a), fb(b), fdist(dist), fdir(direction)
   {}
};


//______________________________________________________________________________
void TPad::ShowGuidelines(TObject *object, const Int_t event, const char mode, const bool cling )
{
   // Shows lines to indicate if a TAttBBox2D object is alligned to
   // the centeror 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). The expected values are:
   //    1                    t                         2
   //     +--------------------------------------------+
   //     |                                            |
   //     |                                            |
   //     |                                            |
   //    l|                   i                        |r
   //     |                                            |
   //     |                                            |
   //     |                                            |
   //     |                                            |
   //     +--------------------------------------------+
   //    4                    b                         3

   // When the object is moved with arrow or when the ShowGuideLines flag
   // is off we do show guide lines.
   if ((event == kArrowKeyRelease) || (event == kArrowKeyPress) ||
       !gEnv->GetValue("Canvas.ShowGuideLines", 0)) return;

   std::vector<dField> curDist;
   std::vector<dField> otherDist;
   Int_t pMX, pMY;
   Double_t MX, MY;
   Int_t threshold;
   TList *prims;
   UInt_t n;
   Rectangle_t aBBox, bBBox;
   aBBox = bBBox = Rectangle_t();
   TLine *L;
   TArrow *A;
   Int_t dSizeArrow = 12;   // distance of arrows indicating same size from BBox in px
   Bool_t movedX, movedY;   // make sure the current object is moved just once
   movedX = movedY = false;
   Bool_t resize = false;   // indicates resize mode
   if (mode != 'i') resize = true;

   TPad *is_pad = dynamic_cast<TPad *>( object );
   TVirtualPad *padSave = 0;
   padSave = gPad;
   if (is_pad) is_pad->GetMother()->cd();

   static TPad * tmpGuideLinePad;

   //delete all existing Guidelines and create new invisible pad
   if (tmpGuideLinePad) {
      if (object == tmpGuideLinePad) { // in case of funny button click combination.
         tmpGuideLinePad->Delete();
         tmpGuideLinePad = 0;
         return;
      }
      tmpGuideLinePad->Delete();
      tmpGuideLinePad = 0;
   }

   // Get Primitives
   prims = gPad->GetListOfPrimitives();
   n     = TMath::Min(15,prims->GetSize());
   Int_t lineColor = TColor::GetColor(239, 202, 0);

   TAttBBox2D *cur = dynamic_cast<TAttBBox2D *>( object );
   if (cur) {
      //create invisible TPad above gPad
      if (!tmpGuideLinePad){
         tmpGuideLinePad = new TPad("tmpGuideLinePad", "tmpGuideLinePad", 0, 0, 1, 1);
         Double_t x1, y1, x2, y2;
         gPad->GetRange(x1, y1, x2, y2);
         tmpGuideLinePad->Range(x1, y1, x2, y2);
         tmpGuideLinePad->SetFillStyle(0);
         tmpGuideLinePad->SetFillColor(0);
         tmpGuideLinePad->Draw();
         tmpGuideLinePad->cd();
         gPad->GetRange(x1, y1, x2, y2);
      }
      if (cling) threshold = 7;
      else threshold = 1;

      Rectangle_t BBox = cur->GetBBox();
      TPoint center = cur->GetBBoxCenter();

      otherDist.clear();
      curDist.clear();

      switch (event) {

      case kButton1Down:
      case kButton1Motion:
         MX  = gPad->GetX1() + 0.5 * (gPad->GetX2()-gPad->GetX1());
         MY  = gPad->GetY1() + 0.5 * (gPad->GetY2()-gPad->GetY1());
         pMX = gPad->XtoPixel(MX);
         pMY = gPad->YtoPixel(MY);
         // Middlelines
         if (TMath::Abs(pMX-center.GetX())<threshold) {
            if (cling && (!resize)) {
               cur->SetBBoxCenterX(pMX);
               center = cur->GetBBoxCenter();
               BBox = cur->GetBBox();
               center = cur->GetBBoxCenter();
            }
            L = new TLine(MX, gPad->GetY1(), MX, gPad->GetY2());
            L->SetBit(kCanDelete);
            L->SetLineColor(lineColor);
            L->Draw();
         }
         if (TMath::Abs(pMY-center.GetY())<threshold) {
            if (cling && (!resize)) {
               cur->SetBBoxCenterY(pMY);
               center = cur->GetBBoxCenter();
               BBox = cur->GetBBox();
               center = cur->GetBBoxCenter();
            }
            L = new TLine(gPad->GetX1(), MY, gPad->GetX2(), MY);
            L->SetBit(kCanDelete);
            L->SetLineColor(lineColor);
            L->Draw();
         }
         // Alignment to other objects
         for (UInt_t i = 0; i<n; i++) {
            TAttBBox2D *other = dynamic_cast<TAttBBox2D *>( prims->At(i) );
            if (other) {
               if (other != cur) {
                  TPoint centerOther = other->GetBBoxCenter();
                  if (TMath::Abs(center.GetX()-centerOther.GetX())<threshold) {
                     if (cling && (!resize)) {
                        cur->SetBBoxCenterX(centerOther.GetX());
                        BBox   = cur->GetBBox();
                        center = cur->GetBBoxCenter();
                     }
                     L = new TLine(gPad->PixeltoX(centerOther.GetX()), gPad->PixeltoY(center.GetY()-gPad->VtoPixel(0)),
                                   gPad->PixeltoX(centerOther.GetX()), gPad->PixeltoY(centerOther.GetY()-gPad->VtoPixel(0)));
                     L->SetLineColor(lineColor);
                     L->Draw();
                     L->SetBit(kCanDelete);
                  }
                  if (TMath::Abs(center.GetY()-centerOther.GetY())<threshold) {
                     if (cling && (!resize)) {
                        cur->SetBBoxCenterY(centerOther.GetY());
                        BBox   = cur->GetBBox();
                        center = cur->GetBBoxCenter();
                     }
                     L = new TLine(gPad->PixeltoX(center.GetX()), gPad->PixeltoY(centerOther.GetY()-gPad->VtoPixel(0)),
                                   gPad->PixeltoX(centerOther.GetX()), gPad->PixeltoY(centerOther.GetY()-gPad->VtoPixel(0)));
                     L->SetBit(kCanDelete);
                     L->SetLineColor(lineColor);
                     L->Draw();
                  }
               }
            }
         }
         // Get Distances between objects
         for (UInt_t i = 0; i<n; i++) {
            TAttBBox2D *a = dynamic_cast<TAttBBox2D *>( prims->At(i) );
            if (a) {
               aBBox = a->GetBBox();
               for (UInt_t j = i+1; j<n; j++) {
                  TAttBBox2D *b = dynamic_cast<TAttBBox2D *>( prims->At(j) );
                  if (b) {
                     bBBox = b->GetBBox();

                     //only when bounding boxes overlap in x or y direction
                     if (((aBBox.fX<bBBox.fX)&&(bBBox.fX-aBBox.fX<=aBBox.fWidth))||((aBBox.fX>bBBox.fX)&&(aBBox.fX-bBBox.fX<=bBBox.fWidth))){ //BBoxes overlap in x direction
                        if ((aBBox.fY+aBBox.fHeight<bBBox.fY)||(bBBox.fY+bBBox.fHeight<aBBox.fY)) {//No overlap in Y-direction required
                           dField abDist = dField();
                           if (aBBox.fY>bBBox.fY) abDist = dField(a, b, TMath::Abs(aBBox.fY-(bBBox.fY+bBBox.fHeight)), 'y');
                           else                   abDist = dField(a, b, TMath::Abs(bBBox.fY-(aBBox.fY+aBBox.fHeight)), 'y');
                           if ((b != cur)&&(a != cur)) otherDist.push_back(abDist);
                           else curDist.push_back(abDist);
                        }
                     } else if (((aBBox.fY<bBBox.fY)&&(bBBox.fY-aBBox.fY<=aBBox.fHeight))||((aBBox.fY>bBBox.fY)&&(aBBox.fY-bBBox.fY<=bBBox.fHeight))) { //BBoxes overlap in y direction
                        if ((aBBox.fX+aBBox.fWidth<bBBox.fX)||(bBBox.fX+bBBox.fWidth<aBBox.fX)) {//No overlap in x-direction required
                           dField abDist = dField();
                           if (aBBox.fX>bBBox.fX) abDist = dField(a, b, TMath::Abs(aBBox.fX-(bBBox.fX+bBBox.fWidth)), 'x');
                           else                   abDist = dField(a, b, TMath::Abs(bBBox.fX-(aBBox.fX+aBBox.fWidth)), 'x');
                           if ((b != cur)&&(a != cur)) otherDist.push_back(abDist);
                           else                        curDist.push_back(abDist);
                        }
                     }
                  }
               }
            }
         }
         // Show equal distances
         for (UInt_t i = 0; i<curDist.size(); i++) {
            for (UInt_t j = 0; j<otherDist.size(); j++) {
               if ((curDist[i].fdir == otherDist[j].fdir)&&(otherDist[j].fdir=='x')&&(TMath::Abs(curDist[i].fdist-otherDist[j].fdist)<threshold)) {
                  if (cling && (!movedX) && (!resize)) {
                     if ((cur->GetBBoxCenter().fX < curDist[i].fb->GetBBoxCenter().fX)||(cur->GetBBoxCenter().fX < curDist[i].fa->GetBBoxCenter().fX))
                           cur->SetBBoxCenterX(cur->GetBBoxCenter().fX - otherDist[j].fdist + curDist[i].fdist);
                     else  cur->SetBBoxCenterX(cur->GetBBoxCenter().fX + otherDist[j].fdist - curDist[i].fdist);
                     movedX = true;
                  }
                  DrawDist(curDist[i].fa->GetBBox(), curDist[i].fb->GetBBox(), 'x');
                  DrawDist(otherDist[j].fa->GetBBox(), otherDist[j].fb->GetBBox(), 'x');
               }
               if ((curDist[i].fdir == otherDist[j].fdir)&&(otherDist[j].fdir=='y')&&(TMath::Abs(curDist[i].fdist-otherDist[j].fdist)<threshold)) {
                  if (cling && (!movedY) && (!resize)) {
                     if ((cur->GetBBoxCenter().fY < curDist[i].fb->GetBBoxCenter().fY)||(cur->GetBBoxCenter().fY < curDist[i].fa->GetBBoxCenter().fY))
                           cur->SetBBoxCenterY(cur->GetBBoxCenter().fY - otherDist[j].fdist + curDist[i].fdist);
                     else  cur->SetBBoxCenterY(cur->GetBBoxCenter().fY + otherDist[j].fdist - curDist[i].fdist);
                     movedY = true;
                  }
                  DrawDist(curDist[i].fa->GetBBox(), curDist[i].fb->GetBBox(), 'y');
                  DrawDist(otherDist[j].fa->GetBBox(), otherDist[j].fb->GetBBox(), 'y');
               }
            }
            for (UInt_t j = i; j<curDist.size(); j++) {
               if (i!=j) {
                  if ((curDist[i].fdir == curDist[j].fdir)&&(curDist[j].fdir=='x')&&(TMath::Abs(curDist[i].fdist-curDist[j].fdist)<threshold)) {
                     if (cling && (!movedX) && (!resize)) {
                        if ((cur->GetBBoxCenter().fX < curDist[i].fb->GetBBoxCenter().fX)||(cur->GetBBoxCenter().fX < curDist[i].fa->GetBBoxCenter().fX))
                              cur->SetBBoxCenterX(cur->GetBBoxCenter().fX - floor(0.5*(curDist[j].fdist - curDist[i].fdist)));
                        else  cur->SetBBoxCenterX(cur->GetBBoxCenter().fX + floor(0.5*(curDist[j].fdist - curDist[i].fdist)));
                     }
                     DrawDist(curDist[i].fa->GetBBox(), curDist[i].fb->GetBBox(), 'x');
                     DrawDist(curDist[j].fa->GetBBox(), curDist[j].fb->GetBBox(), 'x');
                  }

                  if ((curDist[i].fdir == curDist[j].fdir)&&(curDist[j].fdir=='y')&&(TMath::Abs(curDist[i].fdist-curDist[j].fdist)<threshold)) {
                     if (cling && (!movedY) && (!resize)) {
                        if ((cur->GetBBoxCenter().fY < curDist[i].fb->GetBBoxCenter().fY)||(cur->GetBBoxCenter().fY < curDist[i].fa->GetBBoxCenter().fY))
                              cur->SetBBoxCenterY(cur->GetBBoxCenter().fY - floor(0.5*(curDist[j].fdist - curDist[i].fdist)));
                        else  cur->SetBBoxCenterY(cur->GetBBoxCenter().fY + floor(0.5*(curDist[j].fdist - curDist[i].fdist)));
                     }
                     DrawDist(curDist[i].fa->GetBBox(), curDist[i].fb->GetBBox(), 'y');
                     DrawDist(curDist[j].fa->GetBBox(), curDist[j].fb->GetBBox(), 'y');
                  }
               }
            }
         }
         if (resize) {
            // Show equal Sizes
            for (UInt_t i = 0; i<n; i++) {
               TAttBBox2D *a = dynamic_cast<TAttBBox2D *>( prims->At(i) );
               if (a && (cur != a)) {
                  aBBox = a->GetBBox();

                  if ((TMath::Abs(aBBox.fWidth - BBox.fWidth)<threshold) && (mode != 't') && (mode != 'b')) {
                     if (cling) {
                        if (mode == 'l') cur->SetBBoxX1(BBox.fX + BBox.fWidth - aBBox.fWidth);
                        if (mode == 'r') cur->SetBBoxX2(BBox.fX + aBBox.fWidth);
                        if ((mode == '1')||(mode == '4')) cur->SetBBoxX1(BBox.fX + BBox.fWidth - aBBox.fWidth);
                        if ((mode == '2')||(mode == '3')) cur->SetBBoxX2(BBox.fX + aBBox.fWidth);
                        BBox = cur->GetBBox();
                     }

                     A = new TArrow(gPad->PixeltoX(aBBox.fX), gPad->PixeltoY(aBBox.fY-dSizeArrow-gPad->VtoPixel(0)),
                                    gPad->PixeltoX(aBBox.fX+aBBox.fWidth), gPad->PixeltoY(aBBox.fY-dSizeArrow-gPad->VtoPixel(0)), 0.01, "<|>");
                     A->SetBit(kCanDelete);
                     A->SetLineColor(lineColor);
                     A->SetFillColor(lineColor);
                     A->Draw();

                     A = new TArrow(gPad->PixeltoX(BBox.fX), gPad->PixeltoY(BBox.fY-dSizeArrow-gPad->VtoPixel(0)),
                                    gPad->PixeltoX(BBox.fX+BBox.fWidth), gPad->PixeltoY(BBox.fY-dSizeArrow-gPad->VtoPixel(0)), 0.01, "<|>");
                     A->SetBit(kCanDelete);
                     A->SetLineColor(lineColor);
                     A->SetFillColor(lineColor);
                     A->Draw();
                  }
                  if ((TMath::Abs(aBBox.fHeight - BBox.fHeight)<threshold) && (mode != 'r') && (mode != 'l')) {
                     if (cling) {
                        if (mode == 't') cur->SetBBoxY1(BBox.fY + BBox.fHeight - aBBox.fHeight);
                        if (mode == 'b') cur->SetBBoxY2(BBox.fY + aBBox.fHeight);
                        if ((mode == '1')||(mode == '2')) cur->SetBBoxY1(BBox.fY + BBox.fHeight - aBBox.fHeight);
                        if ((mode == '3')||(mode == '4')) cur->SetBBoxY2(BBox.fY + aBBox.fHeight);
                        BBox = cur->GetBBox();
                     }
                     A = new TArrow(gPad->PixeltoX(aBBox.fX-dSizeArrow), gPad->PixeltoY(aBBox.fY-gPad->VtoPixel(0)),
                                    gPad->PixeltoX(aBBox.fX-dSizeArrow), gPad->PixeltoY(aBBox.fY+aBBox.fHeight-gPad->VtoPixel(0)), 0.01, "<|>");
                     A->SetBit(kCanDelete);
                     A->SetLineColor(lineColor);
                     A->SetFillColor(lineColor);
                     A->Draw();

                     A = new TArrow(gPad->PixeltoX(BBox.fX-dSizeArrow), gPad->PixeltoY(BBox.fY-gPad->VtoPixel(0)),
                                   gPad->PixeltoX(BBox.fX-dSizeArrow), gPad->PixeltoY(BBox.fY+BBox.fHeight-gPad->VtoPixel(0)), 0.01, "<|>");
                     A->SetBit(kCanDelete);
                     A->SetLineColor(lineColor);
                     A->SetFillColor(lineColor);
                     A->Draw();
                  }
               }
            }
         }

         break;

      case kButton1Up:
         if (tmpGuideLinePad) {
            // All the arrows and lines in that pad are also deleted because
            // they all have the bit kCanDelete on.
            tmpGuideLinePad->Delete();
            tmpGuideLinePad = 0;
         }
         break;
      }
   }

   gPad->Modified(kTRUE);
   padSave->cd();
}


//______________________________________________________________________________
Bool_t TPad::HasCrosshair() const
{
   // Return kTRUE if the crosshair has been activated (via SetCrosshair).

   return (Bool_t)GetCrosshair();
}


//______________________________________________________________________________
Int_t TPad::GetCrosshair() const
{
   // Return the crosshair type (from the mother canvas)
   // crosshair type = 0 means no crosshair.

   if (this == (TPad*)fCanvas)
      return fCrosshair;
   return fCanvas ? fCanvas->GetCrosshair() : 0;
}


//______________________________________________________________________________
void TPad::SetCrosshair(Int_t crhair)
{
   // 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.

   fCrosshair = crhair;
   fCrosshairPos = 0;

   if (this != (TPad*)fCanvas) fCanvas->SetCrosshair(crhair);
}


//______________________________________________________________________________
void TPad::SetMaxPickDistance(Int_t maxPick)
{
   // 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

   fgMaxPickDistance = maxPick;
}


//______________________________________________________________________________
void TPad::SetToolTipText(const char *text, Long_t delayms)
{
   // Set tool tip text associated with this pad. The delay is in
   // milliseconds (minimum 250). To remove tool tip call method with
   // text = 0.

   if (fTip) {
      DeleteToolTip(fTip);
      fTip = 0;
   }

   if (text && strlen(text))
      fTip = CreateToolTip((TBox*)0, text, delayms);
}


//______________________________________________________________________________
void TPad::SetVertical(Bool_t vert)
{
   // Set pad vertical (default) or horizontal

   if (vert) ResetBit(kHori);
   else      SetBit(kHori);
}


//_______________________________________________________________________
void TPad::Streamer(TBuffer &b)
{
   // Stream a class object.

   UInt_t R__s, R__c;
   Int_t nch, nobjects;
   Float_t single;
   TObject *obj;
   if (b.IsReading()) {
      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v > 5) {
         if (!gPad) gPad = new TCanvas(GetName());
         TPad *padsave = (TPad*)gPad;
         fMother = (TPad*)gPad;
         if (fMother)  fCanvas = fMother->GetCanvas();
         gPad      = this;
         fPixmapID = -1;      // -1 means pixmap will be created by ResizePad()
         gReadLevel++;
         gROOT->SetReadingObject(kTRUE);

         b.ReadClassBuffer(TPad::Class(), this, v, R__s, R__c);

         //Set the kCanDelete bit in all objects in the pad such that when the pad
         //is deleted all objects in the pad are deleted too.
         TIter next(fPrimitives);
         while ((obj = next())) {
            obj->SetBit(kCanDelete);
         }

         fModified = kTRUE;
         fPadPointer = 0;
         gReadLevel--;
         if (gReadLevel == 0 && IsA() == TPad::Class()) ResizePad();
         gROOT->SetReadingObject(kFALSE);
         gPad = padsave;
         return;
      }

      //====process old versions before automatic schema evolution
      if (v < 5) {   //old TPad in single precision
         if (v < 3) {   //old TPad derived from TWbox
            b.ReadVersion();   //      TVirtualPad::Streamer(b)
            b.ReadVersion();   //      TWbox::Streamer(b)
            b.ReadVersion();   //      TBox::Streamer(b)
            TObject::Streamer(b);
            TAttLine::Streamer(b);
            TAttFill::Streamer(b);
            b >> single; fX1 = single;
            b >> single; fY1 = single;
            b >> single; fX2 = single;
            b >> single; fY2 = single;
            b >> fBorderSize;
            b >> fBorderMode;
            TAttPad::Streamer(b);
         } else {  //new TPad
            TVirtualPad::Streamer(b);
            TAttPad::Streamer(b);
            b >> single; fX1 = single;
            b >> single; fY1 = single;
            b >> single; fX2 = single;
            b >> single; fY2 = single;
            b >> fBorderSize;
            b >> fBorderMode;
         }
         b >> fLogx;
         b >> fLogy;
         b >> fLogz;
         b >> single; fXtoAbsPixelk = single;
         b >> single; fXtoPixelk    = single;
         b >> single; fXtoPixel     = single;
         b >> single; fYtoAbsPixelk = single;
         b >> single; fYtoPixelk    = single;
         b >> single; fYtoPixel     = single;
         b >> single; fUtoAbsPixelk = single;
         b >> single; fUtoPixelk    = single;
         b >> single; fUtoPixel     = single;
         b >> single; fVtoAbsPixelk = single;
         b >> single; fVtoPixelk    = single;
         b >> single; fVtoPixel     = single;
         b >> single; fAbsPixeltoXk = single;
         b >> single; fPixeltoXk    = single;
         b >> single; fPixeltoX     = single;
         b >> single; fAbsPixeltoYk = single;
         b >> single; fPixeltoYk    = single;
         b >> single; fPixeltoY     = single;
         b >> single; fXlowNDC      = single;
         b >> single; fYlowNDC      = single;
         b >> single; fWNDC         = single;
         b >> single; fHNDC         = single;
         b >> single; fAbsXlowNDC   = single;
         b >> single; fAbsYlowNDC   = single;
         b >> single; fAbsWNDC      = single;
         b >> single; fAbsHNDC      = single;
         b >> single; fUxmin        = single;
         b >> single; fUymin        = single;
         b >> single; fUxmax        = single;
         b >> single; fUymax        = single;
      } else {
         TVirtualPad::Streamer(b);
         TAttPad::Streamer(b);
         b >> fX1;
         b >> fY1;
         b >> fX2;
         b >> fY2;
         b >> fBorderSize;
         b >> fBorderMode;
         b >> fLogx;
         b >> fLogy;
         b >> fLogz;
         b >> fXtoAbsPixelk;
         b >> fXtoPixelk;
         b >> fXtoPixel;
         b >> fYtoAbsPixelk;
         b >> fYtoPixelk;
         b >> fYtoPixel;
         b >> fUtoAbsPixelk;
         b >> fUtoPixelk;
         b >> fUtoPixel;
         b >> fVtoAbsPixelk;
         b >> fVtoPixelk;
         b >> fVtoPixel;
         b >> fAbsPixeltoXk;
         b >> fPixeltoXk;
         b >> fPixeltoX;
         b >> fAbsPixeltoYk;
         b >> fPixeltoYk;
         b >> fPixeltoY;
         b >> fXlowNDC;
         b >> fYlowNDC;
         b >> fWNDC;
         b >> fHNDC;
         b >> fAbsXlowNDC;
         b >> fAbsYlowNDC;
         b >> fAbsWNDC;
         b >> fAbsHNDC;
         b >> fUxmin;
         b >> fUymin;
         b >> fUxmax;
         b >> fUymax;
      }

      if (!gPad) gPad = new TCanvas(GetName());
      if (gReadLevel == 0) fMother = (TPad*)gROOT->GetSelectedPad();
      else                fMother = (TPad*)gPad;
      if (!fMother) fMother = (TPad*)gPad;
      if (fMother)  fCanvas = fMother->GetCanvas();
      gPad      = fMother;
      fPixmapID = -1;      // -1 means pixmap will be created by ResizePad()
      //-------------------------
      // read objects and their drawing options
      //      b >> fPrimitives;
      gReadLevel++;
      gROOT->SetReadingObject(kTRUE);
      fPrimitives = new TList;
      b >> nobjects;
      if (nobjects > 0) {
         TPad *padsav = (TPad*)gPad;
         gPad = this;
         char drawoption[64];
         for (Int_t i = 0; i < nobjects; i++) {
            b >> obj;
            b >> nch;
            b.ReadFastArray(drawoption,nch);
            fPrimitives->AddLast(obj, drawoption);
            gPad = this; // gPad may be modified in b >> obj if obj is a pad
         }
         gPad = padsav;
      }
      gReadLevel--;
      gROOT->SetReadingObject(kFALSE);
      //-------------------------
      if (v > 3) {
         b >> fExecs;
      }
      fName.Streamer(b);
      fTitle.Streamer(b);
      b >> fPadPaint;
      fModified = kTRUE;
      b >> fGridx;
      b >> fGridy;
      b >> fFrame;
      b >> fView;
      if (v < 5) {
         b >> single; fTheta = single;
         b >> single; fPhi   = single;
      } else {
         b >> fTheta;
         b >> fPhi;
      }
      fPadPointer = 0;
      b >> fNumber;
      b >> fAbsCoord;
      if (v > 1) {
         b >> fTickx;
         b >> fTicky;
      } else {
         fTickx = fTicky = 0;
      }
      if (gReadLevel == 0 && IsA() == TPad::Class()) ResizePad();
      b.CheckByteCount(R__s, R__c, TPad::IsA());
      //====end of old versions

   } else {
      b.WriteClassBuffer(TPad::Class(),this);
   }
}


//______________________________________________________________________________
void TPad::UseCurrentStyle()
{
   // Force a copy of current style for all objects in pad.

   if (gStyle->IsReading()) {
      SetFillColor(gStyle->GetPadColor());
      SetBottomMargin(gStyle->GetPadBottomMargin());
      SetTopMargin(gStyle->GetPadTopMargin());
      SetLeftMargin(gStyle->GetPadLeftMargin());
      SetRightMargin(gStyle->GetPadRightMargin());
      fBorderSize = gStyle->GetPadBorderSize();
      fBorderMode = gStyle->GetPadBorderMode();
      fGridx = gStyle->GetPadGridX();
      fGridy = gStyle->GetPadGridY();
      fTickx = gStyle->GetPadTickX();
      fTicky = gStyle->GetPadTickY();
      fLogx  = gStyle->GetOptLogx();
      fLogy  = gStyle->GetOptLogy();
      fLogz  = gStyle->GetOptLogz();
   } else {
      gStyle->SetPadColor(GetFillColor());
      gStyle->SetPadBottomMargin(GetBottomMargin());
      gStyle->SetPadTopMargin(GetTopMargin());
      gStyle->SetPadLeftMargin(GetLeftMargin());
      gStyle->SetPadRightMargin(GetRightMargin());
      gStyle->SetPadBorderSize(GetBorderSize());
      gStyle->SetPadBorderMode(GetBorderMode());
      gStyle->SetPadGridX(fGridx);
      gStyle->SetPadGridY(fGridy);
      gStyle->SetPadTickX(fTickx);
      gStyle->SetPadTickY(fTicky);
      gStyle->SetOptLogx (fLogx);
      gStyle->SetOptLogy (fLogy);
      gStyle->SetOptLogz (fLogz);
   }

   if (!fPrimitives) fPrimitives = new TList;
   TIter next(GetListOfPrimitives());
   TObject *obj;

   while ((obj = next())) {
      obj->UseCurrentStyle();
   }

   TPaveText *title  = (TPaveText*)FindObject("title");
   if (title) {
      if (gStyle->IsReading()) {
         title->SetFillColor(gStyle->GetTitleFillColor());
         title->SetTextFont(gStyle->GetTitleFont(""));
         title->SetTextColor(gStyle->GetTitleTextColor());
         title->SetBorderSize(gStyle->GetTitleBorderSize());
         if (!gStyle->GetOptTitle()) delete title;
      } else {
         gStyle->SetTitleFillColor(title->GetFillColor());
         gStyle->SetTitleFont(title->GetTextFont());
         gStyle->SetTitleTextColor(title->GetTextColor());
         gStyle->SetTitleBorderSize(title->GetBorderSize());
      }
   }
   if (fFrame) fFrame->UseCurrentStyle();

   if (gStyle->IsReading()) Modified();
}


//______________________________________________________________________________
TObject *TPad::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
   //        = "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());
   //   }
   //}

   if (strlen(emode)) gROOT->SetEditorMode(emode);
   if (gROOT->GetEditorMode() == 0 && strlen(pname) > 2) gROOT->SetEditorMode(&pname[1]);

   if (!fPrimitives) fPrimitives = new TList;
   gSystem->ProcessEvents();
   TObject *oldlast = gPad->GetListOfPrimitives()->Last();
   TObject *obj = 0;
   Bool_t testlast = kFALSE;
   Bool_t hasname = strlen(pname) > 0;
   if (!pname[0] && !emode[0]) testlast = kTRUE;
   if (testlast) gROOT->SetEditorMode();
   while (!gSystem->ProcessEvents() && gROOT->GetSelectedPad()) {
      if (gROOT->GetEditorMode() == 0) {
         if (hasname) {
            obj = FindObject(pname);
            if (obj) return obj;
         }
         if (testlast) {
            obj = gPad->GetListOfPrimitives()->Last();
            if (obj != oldlast) return obj;
            Int_t event = GetEvent();
            if (event == kButton1Double || event == kKeyPress) {
               //the following statement is required against other loop executions
               //before returning
               fCanvas->HandleInput((EEventType)-1,0,0);
               return 0;
            }
         }
      }
      gSystem->Sleep(10);
   }

   return 0;
}


//______________________________________________________________________________
TObject *TPad::CreateToolTip(const TBox *box, const char *text, Long_t delayms)
{
   // Create a tool tip and return its pointer.

   if (gPad->IsBatch()) return 0;
   // return new TGToolTip(box, text, delayms);
   return (TObject*)gROOT->ProcessLineFast(Form("new TGToolTip((TBox*)0x%lx,\"%s\",%d)",
                                           (Long_t)box,text,(Int_t)delayms));
}


//______________________________________________________________________________
void TPad::DeleteToolTip(TObject *tip)
{
   // Delete tool tip object.

   // delete tip;
   if (!tip) return;
   gROOT->ProcessLineFast(Form("delete (TGToolTip*)0x%lx", (Long_t)tip));
}


//______________________________________________________________________________
void TPad::ResetToolTip(TObject *tip)
{
   // Reset tool tip, i.e. within time specified in CreateToolTip the
   // tool tip will pop up.

   if (!tip) return;
   // tip->Reset(this);
   gROOT->ProcessLineFast(Form("((TGToolTip*)0x%lx)->Reset((TPad*)0x%lx)",
                          (Long_t)tip,(Long_t)this));
}


//______________________________________________________________________________
void TPad::CloseToolTip(TObject *tip)
{
   // Hide tool tip.

   if (!tip) return;
   // tip->Hide();
   gROOT->ProcessLineFast(Form("((TGToolTip*)0x%lx)->Hide()",(Long_t)tip));
}


//______________________________________________________________________________
void TPad::x3d(Option_t *type)
{
   // Depreciated: use TPad::GetViewer3D() instead

   ::Info("TPad::x3d()", "Fn is depreciated - use TPad::GetViewer3D() instead");

   // Default on GetViewer3D is pad - for x3d
   // it was x3d...
   if (!type || !type[0]) {
      type = "x3d";
   }
   GetViewer3D(type);
}


//______________________________________________________________________________
TVirtualViewer3D *TPad::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

   Bool_t validType = kFALSE;

   if ( (!type || !type[0] || (strstr(type, "gl") && !strstr(type, "ogl"))) && !fCanvas->UseGL())
      type = "pad";

   if (type && type[0]) {

      if (gPluginMgr->FindHandler("TVirtualViewer3D", type))
         validType = kTRUE;

   }

   // Invalid/null type requested?
   if (!validType) {
      // Return current viewer if there is one
      if (fViewer3D) {
         return fViewer3D;
      }
      // otherwise default to the pad
      else {
         type = "pad";
      }
   }

   // Ensure we can create the new viewer before removing any exisiting one
   TVirtualViewer3D *newViewer = 0;

   Bool_t createdExternal = kFALSE;

   // External viewers need to be created via plugin manager via interface...
   if (!strstr(type,"pad")) {
      newViewer = TVirtualViewer3D::Viewer3D(this,type);

      if (!newViewer) {
         Warning("TPad::CreateViewer3D", "Cannot create 3D viewer of type: %s", type);

         // Return the existing viewer
         return fViewer3D;
      }

      if (strstr(type, "gl") && !strstr(type, "ogl"))
         fEmbeddedGL = kTRUE, fCopyGLDevice = kTRUE, Modified();
      else
         createdExternal = kTRUE;

   } else
      newViewer = new TViewer3DPad(*this);

   // If we had a previous viewer destroy it now
   // In this case we do take responsibility for destorying viewer
   // c.f. ReleaseViewer3D
   delete fViewer3D;

   // Set and return new viewer
   fViewer3D = newViewer;

   // Ensure any new external viewer is painted
   // For internal TViewer3DPad type we assume this is being
   // create on demand due to a paint - so this is not required
   if (createdExternal) {
      Modified();
      Update();
   }

   return fViewer3D;
}

//______________________________________________________________________________
void TPad::ReleaseViewer3D(Option_t * /*type*/ )
{
   // Release current (external) viewer
   // TODO: By type
   fViewer3D = 0;

   // We would like to ensure the pad is repainted
   // when external viewer is closed down. However
   // a modify/paint call here will repaint the pad
   // before the external viewer window actually closes.
   // So the pad would have to be redraw twice over.
   // Currenltly we just have to live with the pad staying blank
   // any click in pad will refresh.
}


//______________________________________________________________________________
Int_t TPad::GetGLDevice()
{
   // Get GL device.
   return fGLDevice;
}

//______________________________________________________________________________
void TPad::RecordPave(const TObject *obj)
{
   // Emit RecordPave() signal.

   Emit("RecordPave(const TObject*)", (Long_t)obj);
}

//______________________________________________________________________________
void TPad::RecordLatex(const TObject *obj)
{
   // Emit RecordLatex() signal.

   Emit("RecordLatex(const TObject*)", (Long_t)obj);
}

//______________________________________________________________________________
TVirtualPadPainter *TPad::GetPainter()
{
   // Get pad painter from TCanvas.

   if (!fCanvas) return 0;
   return fCanvas->GetCanvasPainter();
}

//______________________________________________________________________________
Rectangle_t TPad::GetBBox()
{
   // Return the bounding Box of the Pad

   Rectangle_t BBox;
   BBox.fX = gPad->XtoPixel(fXlowNDC*(gPad->GetX2()-gPad->GetX1()) + gPad->GetX1());
   BBox.fY = gPad->YtoPixel((fYlowNDC+fHNDC)*(gPad->GetY2()-gPad->GetY1()) + gPad->GetY1());
   BBox.fWidth = gPad->XtoPixel((fXlowNDC+fWNDC)*(gPad->GetX2()-gPad->GetX1()) + gPad->GetX1()) - gPad->XtoPixel(fXlowNDC*(gPad->GetX2()-gPad->GetX1()) + gPad->GetX1());
   BBox.fHeight = gPad->YtoPixel((fYlowNDC)*(gPad->GetY2()-gPad->GetY1()) + gPad->GetY1()) - gPad->YtoPixel((fYlowNDC+fHNDC)*(gPad->GetY2()-gPad->GetY1()) + gPad->GetY1());
   return (BBox);
}


//______________________________________________________________________________
TPoint TPad::GetBBoxCenter()
{
   // Return the center of the Pad as TPoint in pixels

   TPoint p;
   Double_t x = ((fXlowNDC+0.5*fWNDC)*(gPad->GetX2()-gPad->GetX1())) + gPad->GetX1();
   Double_t y = ((fYlowNDC+0.5*fHNDC)*(gPad->GetY2()-gPad->GetY1())) + gPad->GetY1();

   p.SetX(gPad->XtoPixel(x));
   p.SetY(gPad->YtoPixel(y));
   return(p);
}


//______________________________________________________________________________
void TPad::SetBBoxCenter(const TPoint &p)
{
   // Set center of the Pad

   fXlowNDC = (gPad->PixeltoX(p.GetX()) - gPad->GetX1())/(gPad->GetX2()-gPad->GetX1())-0.5*fWNDC;
   fYlowNDC = (gPad->PixeltoY(p.GetY()-gPad->VtoPixel(0)) - gPad->GetY1())/(gPad->GetY2()-gPad->GetY1())-0.5*fHNDC;
   ResizePad();
}


//______________________________________________________________________________
void TPad::SetBBoxCenterX(const Int_t x)
{
   // Set X coordinate of the center of the Pad

   fXlowNDC = (gPad->PixeltoX(x) - gPad->GetX1())/(gPad->GetX2()-gPad->GetX1())-0.5*fWNDC;
   ResizePad();
}


//______________________________________________________________________________
void TPad::SetBBoxCenterY(const Int_t y)
{
   // Set Y coordinate of the center of the Pad

   fYlowNDC = (gPad->PixeltoY(y-gPad->VtoPixel(0)) - gPad->GetY1())/(gPad->GetY2()-gPad->GetY1())-0.5*fHNDC;
   ResizePad();
}

//______________________________________________________________________________
void TPad::SetBBoxX1(const Int_t x)
{
   // Set lefthandside of BoundingBox to a value
   // (resize in x direction on left)

   fXlowNDC = (gPad->PixeltoX(x) - gPad->GetX1())/(gPad->GetX2()-gPad->GetX1());
   fWNDC = fXUpNDC - fXlowNDC;
   ResizePad();
}

//______________________________________________________________________________
void TPad::SetBBoxX2(const Int_t x)
{
   // Set righthandside of BoundingBox to a value
   // (resize in x direction on right)

   fWNDC = (gPad->PixeltoX(x) - gPad->GetX1())/(gPad->GetX2()-gPad->GetX1())-fXlowNDC;
   ResizePad();
}

//_______________________________________________________________________________
void TPad::SetBBoxY1(const Int_t y)
{
   // Set top of BoundingBox to a value (resize in y direction on top)

   fHNDC = (gPad->PixeltoY(y-gPad->VtoPixel(0)) - gPad->GetY1())/(gPad->GetY2()-gPad->GetY1())-fYlowNDC;
   ResizePad();
}

//_______________________________________________________________________________
void TPad::SetBBoxY2(const Int_t y)
{
   // Set bottom of BoundingBox to a value
   // (resize in y direction on bottom)

   fYlowNDC = (gPad->PixeltoY(y-gPad->VtoPixel(0)) - gPad->GetY1())/(gPad->GetY2()-gPad->GetY1());
   fHNDC = fYUpNDC - fYlowNDC;
   ResizePad();
}

 TPad.cxx:1
 TPad.cxx:2
 TPad.cxx:3
 TPad.cxx:4
 TPad.cxx:5
 TPad.cxx:6
 TPad.cxx:7
 TPad.cxx:8
 TPad.cxx:9
 TPad.cxx:10
 TPad.cxx:11
 TPad.cxx:12
 TPad.cxx:13
 TPad.cxx:14
 TPad.cxx:15
 TPad.cxx:16
 TPad.cxx:17
 TPad.cxx:18
 TPad.cxx:19
 TPad.cxx:20
 TPad.cxx:21
 TPad.cxx:22
 TPad.cxx:23
 TPad.cxx:24
 TPad.cxx:25
 TPad.cxx:26
 TPad.cxx:27
 TPad.cxx:28
 TPad.cxx:29
 TPad.cxx:30
 TPad.cxx:31
 TPad.cxx:32
 TPad.cxx:33
 TPad.cxx:34
 TPad.cxx:35
 TPad.cxx:36
 TPad.cxx:37
 TPad.cxx:38
 TPad.cxx:39
 TPad.cxx:40
 TPad.cxx:41
 TPad.cxx:42
 TPad.cxx:43
 TPad.cxx:44
 TPad.cxx:45
 TPad.cxx:46
 TPad.cxx:47
 TPad.cxx:48
 TPad.cxx:49
 TPad.cxx:50
 TPad.cxx:51
 TPad.cxx:52
 TPad.cxx:53
 TPad.cxx:54
 TPad.cxx:55
 TPad.cxx:56
 TPad.cxx:57
 TPad.cxx:58
 TPad.cxx:59
 TPad.cxx:60
 TPad.cxx:61
 TPad.cxx:62
 TPad.cxx:63
 TPad.cxx:64
 TPad.cxx:65
 TPad.cxx:66
 TPad.cxx:67
 TPad.cxx:68
 TPad.cxx:69
 TPad.cxx:70
 TPad.cxx:71
 TPad.cxx:72
 TPad.cxx:73
 TPad.cxx:74
 TPad.cxx:75
 TPad.cxx:76
 TPad.cxx:77
 TPad.cxx:78
 TPad.cxx:79
 TPad.cxx:80
 TPad.cxx:81
 TPad.cxx:82
 TPad.cxx:83
 TPad.cxx:84
 TPad.cxx:85
 TPad.cxx:86
 TPad.cxx:87
 TPad.cxx:88
 TPad.cxx:89
 TPad.cxx:90
 TPad.cxx:91
 TPad.cxx:92
 TPad.cxx:93
 TPad.cxx:94
 TPad.cxx:95
 TPad.cxx:96
 TPad.cxx:97
 TPad.cxx:98
 TPad.cxx:99
 TPad.cxx:100
 TPad.cxx:101
 TPad.cxx:102
 TPad.cxx:103
 TPad.cxx:104
 TPad.cxx:105
 TPad.cxx:106
 TPad.cxx:107
 TPad.cxx:108
 TPad.cxx:109
 TPad.cxx:110
 TPad.cxx:111
 TPad.cxx:112
 TPad.cxx:113
 TPad.cxx:114
 TPad.cxx:115
 TPad.cxx:116
 TPad.cxx:117
 TPad.cxx:118
 TPad.cxx:119
 TPad.cxx:120
 TPad.cxx:121
 TPad.cxx:122
 TPad.cxx:123
 TPad.cxx:124
 TPad.cxx:125
 TPad.cxx:126
 TPad.cxx:127
 TPad.cxx:128
 TPad.cxx:129
 TPad.cxx:130
 TPad.cxx:131
 TPad.cxx:132
 TPad.cxx:133
 TPad.cxx:134
 TPad.cxx:135
 TPad.cxx:136
 TPad.cxx:137
 TPad.cxx:138
 TPad.cxx:139
 TPad.cxx:140
 TPad.cxx:141
 TPad.cxx:142
 TPad.cxx:143
 TPad.cxx:144
 TPad.cxx:145
 TPad.cxx:146
 TPad.cxx:147
 TPad.cxx:148
 TPad.cxx:149
 TPad.cxx:150
 TPad.cxx:151
 TPad.cxx:152
 TPad.cxx:153
 TPad.cxx:154
 TPad.cxx:155
 TPad.cxx:156
 TPad.cxx:157
 TPad.cxx:158
 TPad.cxx:159
 TPad.cxx:160
 TPad.cxx:161
 TPad.cxx:162
 TPad.cxx:163
 TPad.cxx:164
 TPad.cxx:165
 TPad.cxx:166
 TPad.cxx:167
 TPad.cxx:168
 TPad.cxx:169
 TPad.cxx:170
 TPad.cxx:171
 TPad.cxx:172
 TPad.cxx:173
 TPad.cxx:174
 TPad.cxx:175
 TPad.cxx:176
 TPad.cxx:177
 TPad.cxx:178
 TPad.cxx:179
 TPad.cxx:180
 TPad.cxx:181
 TPad.cxx:182
 TPad.cxx:183
 TPad.cxx:184
 TPad.cxx:185
 TPad.cxx:186
 TPad.cxx:187
 TPad.cxx:188
 TPad.cxx:189
 TPad.cxx:190
 TPad.cxx:191
 TPad.cxx:192
 TPad.cxx:193
 TPad.cxx:194
 TPad.cxx:195
 TPad.cxx:196
 TPad.cxx:197
 TPad.cxx:198
 TPad.cxx:199
 TPad.cxx:200
 TPad.cxx:201
 TPad.cxx:202
 TPad.cxx:203
 TPad.cxx:204
 TPad.cxx:205
 TPad.cxx:206
 TPad.cxx:207
 TPad.cxx:208
 TPad.cxx:209
 TPad.cxx:210
 TPad.cxx:211
 TPad.cxx:212
 TPad.cxx:213
 TPad.cxx:214
 TPad.cxx:215
 TPad.cxx:216
 TPad.cxx:217
 TPad.cxx:218
 TPad.cxx:219
 TPad.cxx:220
 TPad.cxx:221
 TPad.cxx:222
 TPad.cxx:223
 TPad.cxx:224
 TPad.cxx:225
 TPad.cxx:226
 TPad.cxx:227
 TPad.cxx:228
 TPad.cxx:229
 TPad.cxx:230
 TPad.cxx:231
 TPad.cxx:232
 TPad.cxx:233
 TPad.cxx:234
 TPad.cxx:235
 TPad.cxx:236
 TPad.cxx:237
 TPad.cxx:238
 TPad.cxx:239
 TPad.cxx:240
 TPad.cxx:241
 TPad.cxx:242
 TPad.cxx:243
 TPad.cxx:244
 TPad.cxx:245
 TPad.cxx:246
 TPad.cxx:247
 TPad.cxx:248
 TPad.cxx:249
 TPad.cxx:250
 TPad.cxx:251
 TPad.cxx:252
 TPad.cxx:253
 TPad.cxx:254
 TPad.cxx:255
 TPad.cxx:256
 TPad.cxx:257
 TPad.cxx:258
 TPad.cxx:259
 TPad.cxx:260
 TPad.cxx:261
 TPad.cxx:262
 TPad.cxx:263
 TPad.cxx:264
 TPad.cxx:265
 TPad.cxx:266
 TPad.cxx:267
 TPad.cxx:268
 TPad.cxx:269
 TPad.cxx:270
 TPad.cxx:271
 TPad.cxx:272
 TPad.cxx:273
 TPad.cxx:274
 TPad.cxx:275
 TPad.cxx:276
 TPad.cxx:277
 TPad.cxx:278
 TPad.cxx:279
 TPad.cxx:280
 TPad.cxx:281
 TPad.cxx:282
 TPad.cxx:283
 TPad.cxx:284
 TPad.cxx:285
 TPad.cxx:286
 TPad.cxx:287
 TPad.cxx:288
 TPad.cxx:289
 TPad.cxx:290
 TPad.cxx:291
 TPad.cxx:292
 TPad.cxx:293
 TPad.cxx:294
 TPad.cxx:295
 TPad.cxx:296
 TPad.cxx:297
 TPad.cxx:298
 TPad.cxx:299
 TPad.cxx:300
 TPad.cxx:301
 TPad.cxx:302
 TPad.cxx:303
 TPad.cxx:304
 TPad.cxx:305
 TPad.cxx:306
 TPad.cxx:307
 TPad.cxx:308
 TPad.cxx:309
 TPad.cxx:310
 TPad.cxx:311
 TPad.cxx:312
 TPad.cxx:313
 TPad.cxx:314
 TPad.cxx:315
 TPad.cxx:316
 TPad.cxx:317
 TPad.cxx:318
 TPad.cxx:319
 TPad.cxx:320
 TPad.cxx:321
 TPad.cxx:322
 TPad.cxx:323
 TPad.cxx:324
 TPad.cxx:325
 TPad.cxx:326
 TPad.cxx:327
 TPad.cxx:328
 TPad.cxx:329
 TPad.cxx:330
 TPad.cxx:331
 TPad.cxx:332
 TPad.cxx:333
 TPad.cxx:334
 TPad.cxx:335
 TPad.cxx:336
 TPad.cxx:337
 TPad.cxx:338
 TPad.cxx:339
 TPad.cxx:340
 TPad.cxx:341
 TPad.cxx:342
 TPad.cxx:343
 TPad.cxx:344
 TPad.cxx:345
 TPad.cxx:346
 TPad.cxx:347
 TPad.cxx:348
 TPad.cxx:349
 TPad.cxx:350
 TPad.cxx:351
 TPad.cxx:352
 TPad.cxx:353
 TPad.cxx:354
 TPad.cxx:355
 TPad.cxx:356
 TPad.cxx:357
 TPad.cxx:358
 TPad.cxx:359
 TPad.cxx:360
 TPad.cxx:361
 TPad.cxx:362
 TPad.cxx:363
 TPad.cxx:364
 TPad.cxx:365
 TPad.cxx:366
 TPad.cxx:367
 TPad.cxx:368
 TPad.cxx:369
 TPad.cxx:370
 TPad.cxx:371
 TPad.cxx:372
 TPad.cxx:373
 TPad.cxx:374
 TPad.cxx:375
 TPad.cxx:376
 TPad.cxx:377
 TPad.cxx:378
 TPad.cxx:379
 TPad.cxx:380
 TPad.cxx:381
 TPad.cxx:382
 TPad.cxx:383
 TPad.cxx:384
 TPad.cxx:385
 TPad.cxx:386
 TPad.cxx:387
 TPad.cxx:388
 TPad.cxx:389
 TPad.cxx:390
 TPad.cxx:391
 TPad.cxx:392
 TPad.cxx:393
 TPad.cxx:394
 TPad.cxx:395
 TPad.cxx:396
 TPad.cxx:397
 TPad.cxx:398
 TPad.cxx:399
 TPad.cxx:400
 TPad.cxx:401
 TPad.cxx:402
 TPad.cxx:403
 TPad.cxx:404
 TPad.cxx:405
 TPad.cxx:406
 TPad.cxx:407
 TPad.cxx:408
 TPad.cxx:409
 TPad.cxx:410
 TPad.cxx:411
 TPad.cxx:412
 TPad.cxx:413
 TPad.cxx:414
 TPad.cxx:415
 TPad.cxx:416
 TPad.cxx:417
 TPad.cxx:418
 TPad.cxx:419
 TPad.cxx:420
 TPad.cxx:421
 TPad.cxx:422
 TPad.cxx:423
 TPad.cxx:424
 TPad.cxx:425
 TPad.cxx:426
 TPad.cxx:427
 TPad.cxx:428
 TPad.cxx:429
 TPad.cxx:430
 TPad.cxx:431
 TPad.cxx:432
 TPad.cxx:433
 TPad.cxx:434
 TPad.cxx:435
 TPad.cxx:436
 TPad.cxx:437
 TPad.cxx:438
 TPad.cxx:439
 TPad.cxx:440
 TPad.cxx:441
 TPad.cxx:442
 TPad.cxx:443
 TPad.cxx:444
 TPad.cxx:445
 TPad.cxx:446
 TPad.cxx:447
 TPad.cxx:448
 TPad.cxx:449
 TPad.cxx:450
 TPad.cxx:451
 TPad.cxx:452
 TPad.cxx:453
 TPad.cxx:454
 TPad.cxx:455
 TPad.cxx:456
 TPad.cxx:457
 TPad.cxx:458
 TPad.cxx:459
 TPad.cxx:460
 TPad.cxx:461
 TPad.cxx:462
 TPad.cxx:463
 TPad.cxx:464
 TPad.cxx:465
 TPad.cxx:466
 TPad.cxx:467
 TPad.cxx:468
 TPad.cxx:469
 TPad.cxx:470
 TPad.cxx:471
 TPad.cxx:472
 TPad.cxx:473
 TPad.cxx:474
 TPad.cxx:475
 TPad.cxx:476
 TPad.cxx:477
 TPad.cxx:478
 TPad.cxx:479
 TPad.cxx:480
 TPad.cxx:481
 TPad.cxx:482
 TPad.cxx:483
 TPad.cxx:484
 TPad.cxx:485
 TPad.cxx:486
 TPad.cxx:487
 TPad.cxx:488
 TPad.cxx:489
 TPad.cxx:490
 TPad.cxx:491
 TPad.cxx:492
 TPad.cxx:493
 TPad.cxx:494
 TPad.cxx:495
 TPad.cxx:496
 TPad.cxx:497
 TPad.cxx:498
 TPad.cxx:499
 TPad.cxx:500
 TPad.cxx:501
 TPad.cxx:502
 TPad.cxx:503
 TPad.cxx:504
 TPad.cxx:505
 TPad.cxx:506
 TPad.cxx:507
 TPad.cxx:508
 TPad.cxx:509
 TPad.cxx:510
 TPad.cxx:511
 TPad.cxx:512
 TPad.cxx:513
 TPad.cxx:514
 TPad.cxx:515
 TPad.cxx:516
 TPad.cxx:517
 TPad.cxx:518
 TPad.cxx:519
 TPad.cxx:520
 TPad.cxx:521
 TPad.cxx:522
 TPad.cxx:523
 TPad.cxx:524
 TPad.cxx:525
 TPad.cxx:526
 TPad.cxx:527
 TPad.cxx:528
 TPad.cxx:529
 TPad.cxx:530
 TPad.cxx:531
 TPad.cxx:532
 TPad.cxx:533
 TPad.cxx:534
 TPad.cxx:535
 TPad.cxx:536
 TPad.cxx:537
 TPad.cxx:538
 TPad.cxx:539
 TPad.cxx:540
 TPad.cxx:541
 TPad.cxx:542
 TPad.cxx:543
 TPad.cxx:544
 TPad.cxx:545
 TPad.cxx:546
 TPad.cxx:547
 TPad.cxx:548
 TPad.cxx:549
 TPad.cxx:550
 TPad.cxx:551
 TPad.cxx:552
 TPad.cxx:553
 TPad.cxx:554
 TPad.cxx:555
 TPad.cxx:556
 TPad.cxx:557
 TPad.cxx:558
 TPad.cxx:559
 TPad.cxx:560
 TPad.cxx:561
 TPad.cxx:562
 TPad.cxx:563
 TPad.cxx:564
 TPad.cxx:565
 TPad.cxx:566
 TPad.cxx:567
 TPad.cxx:568
 TPad.cxx:569
 TPad.cxx:570
 TPad.cxx:571
 TPad.cxx:572
 TPad.cxx:573
 TPad.cxx:574
 TPad.cxx:575
 TPad.cxx:576
 TPad.cxx:577
 TPad.cxx:578
 TPad.cxx:579
 TPad.cxx:580
 TPad.cxx:581
 TPad.cxx:582
 TPad.cxx:583
 TPad.cxx:584
 TPad.cxx:585
 TPad.cxx:586
 TPad.cxx:587
 TPad.cxx:588
 TPad.cxx:589
 TPad.cxx:590
 TPad.cxx:591
 TPad.cxx:592
 TPad.cxx:593
 TPad.cxx:594
 TPad.cxx:595
 TPad.cxx:596
 TPad.cxx:597
 TPad.cxx:598
 TPad.cxx:599
 TPad.cxx:600
 TPad.cxx:601
 TPad.cxx:602
 TPad.cxx:603
 TPad.cxx:604
 TPad.cxx:605
 TPad.cxx:606
 TPad.cxx:607
 TPad.cxx:608
 TPad.cxx:609
 TPad.cxx:610
 TPad.cxx:611
 TPad.cxx:612
 TPad.cxx:613
 TPad.cxx:614
 TPad.cxx:615
 TPad.cxx:616
 TPad.cxx:617
 TPad.cxx:618
 TPad.cxx:619
 TPad.cxx:620
 TPad.cxx:621
 TPad.cxx:622
 TPad.cxx:623
 TPad.cxx:624
 TPad.cxx:625
 TPad.cxx:626
 TPad.cxx:627
 TPad.cxx:628
 TPad.cxx:629
 TPad.cxx:630
 TPad.cxx:631
 TPad.cxx:632
 TPad.cxx:633
 TPad.cxx:634
 TPad.cxx:635
 TPad.cxx:636
 TPad.cxx:637
 TPad.cxx:638
 TPad.cxx:639
 TPad.cxx:640
 TPad.cxx:641
 TPad.cxx:642
 TPad.cxx:643
 TPad.cxx:644
 TPad.cxx:645
 TPad.cxx:646
 TPad.cxx:647
 TPad.cxx:648
 TPad.cxx:649
 TPad.cxx:650
 TPad.cxx:651
 TPad.cxx:652
 TPad.cxx:653
 TPad.cxx:654
 TPad.cxx:655
 TPad.cxx:656
 TPad.cxx:657
 TPad.cxx:658
 TPad.cxx:659
 TPad.cxx:660
 TPad.cxx:661
 TPad.cxx:662
 TPad.cxx:663
 TPad.cxx:664
 TPad.cxx:665
 TPad.cxx:666
 TPad.cxx:667
 TPad.cxx:668
 TPad.cxx:669
 TPad.cxx:670
 TPad.cxx:671
 TPad.cxx:672
 TPad.cxx:673
 TPad.cxx:674
 TPad.cxx:675
 TPad.cxx:676
 TPad.cxx:677
 TPad.cxx:678
 TPad.cxx:679
 TPad.cxx:680
 TPad.cxx:681
 TPad.cxx:682
 TPad.cxx:683
 TPad.cxx:684
 TPad.cxx:685
 TPad.cxx:686
 TPad.cxx:687
 TPad.cxx:688
 TPad.cxx:689
 TPad.cxx:690
 TPad.cxx:691
 TPad.cxx:692
 TPad.cxx:693
 TPad.cxx:694
 TPad.cxx:695
 TPad.cxx:696
 TPad.cxx:697
 TPad.cxx:698
 TPad.cxx:699
 TPad.cxx:700
 TPad.cxx:701
 TPad.cxx:702
 TPad.cxx:703
 TPad.cxx:704
 TPad.cxx:705
 TPad.cxx:706
 TPad.cxx:707
 TPad.cxx:708
 TPad.cxx:709
 TPad.cxx:710
 TPad.cxx:711
 TPad.cxx:712
 TPad.cxx:713
 TPad.cxx:714
 TPad.cxx:715
 TPad.cxx:716
 TPad.cxx:717
 TPad.cxx:718
 TPad.cxx:719
 TPad.cxx:720
 TPad.cxx:721
 TPad.cxx:722
 TPad.cxx:723
 TPad.cxx:724
 TPad.cxx:725
 TPad.cxx:726
 TPad.cxx:727
 TPad.cxx:728
 TPad.cxx:729
 TPad.cxx:730
 TPad.cxx:731
 TPad.cxx:732
 TPad.cxx:733
 TPad.cxx:734
 TPad.cxx:735
 TPad.cxx:736
 TPad.cxx:737
 TPad.cxx:738
 TPad.cxx:739
 TPad.cxx:740
 TPad.cxx:741
 TPad.cxx:742
 TPad.cxx:743
 TPad.cxx:744
 TPad.cxx:745
 TPad.cxx:746
 TPad.cxx:747
 TPad.cxx:748
 TPad.cxx:749
 TPad.cxx:750
 TPad.cxx:751
 TPad.cxx:752
 TPad.cxx:753
 TPad.cxx:754
 TPad.cxx:755
 TPad.cxx:756
 TPad.cxx:757
 TPad.cxx:758
 TPad.cxx:759
 TPad.cxx:760
 TPad.cxx:761
 TPad.cxx:762
 TPad.cxx:763
 TPad.cxx:764
 TPad.cxx:765
 TPad.cxx:766
 TPad.cxx:767
 TPad.cxx:768
 TPad.cxx:769
 TPad.cxx:770
 TPad.cxx:771
 TPad.cxx:772
 TPad.cxx:773
 TPad.cxx:774
 TPad.cxx:775
 TPad.cxx:776
 TPad.cxx:777
 TPad.cxx:778
 TPad.cxx:779
 TPad.cxx:780
 TPad.cxx:781
 TPad.cxx:782
 TPad.cxx:783
 TPad.cxx:784
 TPad.cxx:785
 TPad.cxx:786
 TPad.cxx:787
 TPad.cxx:788
 TPad.cxx:789
 TPad.cxx:790
 TPad.cxx:791
 TPad.cxx:792
 TPad.cxx:793
 TPad.cxx:794
 TPad.cxx:795
 TPad.cxx:796
 TPad.cxx:797
 TPad.cxx:798
 TPad.cxx:799
 TPad.cxx:800
 TPad.cxx:801
 TPad.cxx:802
 TPad.cxx:803
 TPad.cxx:804
 TPad.cxx:805
 TPad.cxx:806
 TPad.cxx:807
 TPad.cxx:808
 TPad.cxx:809
 TPad.cxx:810
 TPad.cxx:811
 TPad.cxx:812
 TPad.cxx:813
 TPad.cxx:814
 TPad.cxx:815
 TPad.cxx:816
 TPad.cxx:817
 TPad.cxx:818
 TPad.cxx:819
 TPad.cxx:820
 TPad.cxx:821
 TPad.cxx:822
 TPad.cxx:823
 TPad.cxx:824
 TPad.cxx:825
 TPad.cxx:826
 TPad.cxx:827
 TPad.cxx:828
 TPad.cxx:829
 TPad.cxx:830
 TPad.cxx:831
 TPad.cxx:832
 TPad.cxx:833
 TPad.cxx:834
 TPad.cxx:835
 TPad.cxx:836
 TPad.cxx:837
 TPad.cxx:838
 TPad.cxx:839
 TPad.cxx:840
 TPad.cxx:841
 TPad.cxx:842
 TPad.cxx:843
 TPad.cxx:844
 TPad.cxx:845
 TPad.cxx:846
 TPad.cxx:847
 TPad.cxx:848
 TPad.cxx:849
 TPad.cxx:850
 TPad.cxx:851
 TPad.cxx:852
 TPad.cxx:853
 TPad.cxx:854
 TPad.cxx:855
 TPad.cxx:856
 TPad.cxx:857
 TPad.cxx:858
 TPad.cxx:859
 TPad.cxx:860
 TPad.cxx:861
 TPad.cxx:862
 TPad.cxx:863
 TPad.cxx:864
 TPad.cxx:865
 TPad.cxx:866
 TPad.cxx:867
 TPad.cxx:868
 TPad.cxx:869
 TPad.cxx:870
 TPad.cxx:871
 TPad.cxx:872
 TPad.cxx:873
 TPad.cxx:874
 TPad.cxx:875
 TPad.cxx:876
 TPad.cxx:877
 TPad.cxx:878
 TPad.cxx:879
 TPad.cxx:880
 TPad.cxx:881
 TPad.cxx:882
 TPad.cxx:883
 TPad.cxx:884
 TPad.cxx:885
 TPad.cxx:886
 TPad.cxx:887
 TPad.cxx:888
 TPad.cxx:889
 TPad.cxx:890
 TPad.cxx:891
 TPad.cxx:892
 TPad.cxx:893
 TPad.cxx:894
 TPad.cxx:895
 TPad.cxx:896
 TPad.cxx:897
 TPad.cxx:898
 TPad.cxx:899
 TPad.cxx:900
 TPad.cxx:901
 TPad.cxx:902
 TPad.cxx:903
 TPad.cxx:904
 TPad.cxx:905
 TPad.cxx:906
 TPad.cxx:907
 TPad.cxx:908
 TPad.cxx:909
 TPad.cxx:910
 TPad.cxx:911
 TPad.cxx:912
 TPad.cxx:913
 TPad.cxx:914
 TPad.cxx:915
 TPad.cxx:916
 TPad.cxx:917
 TPad.cxx:918
 TPad.cxx:919
 TPad.cxx:920
 TPad.cxx:921
 TPad.cxx:922
 TPad.cxx:923
 TPad.cxx:924
 TPad.cxx:925
 TPad.cxx:926
 TPad.cxx:927
 TPad.cxx:928
 TPad.cxx:929
 TPad.cxx:930
 TPad.cxx:931
 TPad.cxx:932
 TPad.cxx:933
 TPad.cxx:934
 TPad.cxx:935
 TPad.cxx:936
 TPad.cxx:937
 TPad.cxx:938
 TPad.cxx:939
 TPad.cxx:940
 TPad.cxx:941
 TPad.cxx:942
 TPad.cxx:943
 TPad.cxx:944
 TPad.cxx:945
 TPad.cxx:946
 TPad.cxx:947
 TPad.cxx:948
 TPad.cxx:949
 TPad.cxx:950
 TPad.cxx:951
 TPad.cxx:952
 TPad.cxx:953
 TPad.cxx:954
 TPad.cxx:955
 TPad.cxx:956
 TPad.cxx:957
 TPad.cxx:958
 TPad.cxx:959
 TPad.cxx:960
 TPad.cxx:961
 TPad.cxx:962
 TPad.cxx:963
 TPad.cxx:964
 TPad.cxx:965
 TPad.cxx:966
 TPad.cxx:967
 TPad.cxx:968
 TPad.cxx:969
 TPad.cxx:970
 TPad.cxx:971
 TPad.cxx:972
 TPad.cxx:973
 TPad.cxx:974
 TPad.cxx:975
 TPad.cxx:976
 TPad.cxx:977
 TPad.cxx:978
 TPad.cxx:979
 TPad.cxx:980
 TPad.cxx:981
 TPad.cxx:982
 TPad.cxx:983
 TPad.cxx:984
 TPad.cxx:985
 TPad.cxx:986
 TPad.cxx:987
 TPad.cxx:988
 TPad.cxx:989
 TPad.cxx:990
 TPad.cxx:991
 TPad.cxx:992
 TPad.cxx:993
 TPad.cxx:994
 TPad.cxx:995
 TPad.cxx:996
 TPad.cxx:997
 TPad.cxx:998
 TPad.cxx:999
 TPad.cxx:1000
 TPad.cxx:1001
 TPad.cxx:1002
 TPad.cxx:1003
 TPad.cxx:1004
 TPad.cxx:1005
 TPad.cxx:1006
 TPad.cxx:1007
 TPad.cxx:1008
 TPad.cxx:1009
 TPad.cxx:1010
 TPad.cxx:1011
 TPad.cxx:1012
 TPad.cxx:1013
 TPad.cxx:1014
 TPad.cxx:1015
 TPad.cxx:1016
 TPad.cxx:1017
 TPad.cxx:1018
 TPad.cxx:1019
 TPad.cxx:1020
 TPad.cxx:1021
 TPad.cxx:1022
 TPad.cxx:1023
 TPad.cxx:1024
 TPad.cxx:1025
 TPad.cxx:1026
 TPad.cxx:1027
 TPad.cxx:1028
 TPad.cxx:1029
 TPad.cxx:1030
 TPad.cxx:1031
 TPad.cxx:1032
 TPad.cxx:1033
 TPad.cxx:1034
 TPad.cxx:1035
 TPad.cxx:1036
 TPad.cxx:1037
 TPad.cxx:1038
 TPad.cxx:1039
 TPad.cxx:1040
 TPad.cxx:1041
 TPad.cxx:1042
 TPad.cxx:1043
 TPad.cxx:1044
 TPad.cxx:1045
 TPad.cxx:1046
 TPad.cxx:1047
 TPad.cxx:1048
 TPad.cxx:1049
 TPad.cxx:1050
 TPad.cxx:1051
 TPad.cxx:1052
 TPad.cxx:1053
 TPad.cxx:1054
 TPad.cxx:1055
 TPad.cxx:1056
 TPad.cxx:1057
 TPad.cxx:1058
 TPad.cxx:1059
 TPad.cxx:1060
 TPad.cxx:1061
 TPad.cxx:1062
 TPad.cxx:1063
 TPad.cxx:1064
 TPad.cxx:1065
 TPad.cxx:1066
 TPad.cxx:1067
 TPad.cxx:1068
 TPad.cxx:1069
 TPad.cxx:1070
 TPad.cxx:1071
 TPad.cxx:1072
 TPad.cxx:1073
 TPad.cxx:1074
 TPad.cxx:1075
 TPad.cxx:1076
 TPad.cxx:1077
 TPad.cxx:1078
 TPad.cxx:1079
 TPad.cxx:1080
 TPad.cxx:1081
 TPad.cxx:1082
 TPad.cxx:1083
 TPad.cxx:1084
 TPad.cxx:1085
 TPad.cxx:1086
 TPad.cxx:1087
 TPad.cxx:1088
 TPad.cxx:1089
 TPad.cxx:1090
 TPad.cxx:1091
 TPad.cxx:1092
 TPad.cxx:1093
 TPad.cxx:1094
 TPad.cxx:1095
 TPad.cxx:1096
 TPad.cxx:1097
 TPad.cxx:1098
 TPad.cxx:1099
 TPad.cxx:1100
 TPad.cxx:1101
 TPad.cxx:1102
 TPad.cxx:1103
 TPad.cxx:1104
 TPad.cxx:1105
 TPad.cxx:1106
 TPad.cxx:1107
 TPad.cxx:1108
 TPad.cxx:1109
 TPad.cxx:1110
 TPad.cxx:1111
 TPad.cxx:1112
 TPad.cxx:1113
 TPad.cxx:1114
 TPad.cxx:1115
 TPad.cxx:1116
 TPad.cxx:1117
 TPad.cxx:1118
 TPad.cxx:1119
 TPad.cxx:1120
 TPad.cxx:1121
 TPad.cxx:1122
 TPad.cxx:1123
 TPad.cxx:1124
 TPad.cxx:1125
 TPad.cxx:1126
 TPad.cxx:1127
 TPad.cxx:1128
 TPad.cxx:1129
 TPad.cxx:1130
 TPad.cxx:1131
 TPad.cxx:1132
 TPad.cxx:1133
 TPad.cxx:1134
 TPad.cxx:1135
 TPad.cxx:1136
 TPad.cxx:1137
 TPad.cxx:1138
 TPad.cxx:1139
 TPad.cxx:1140
 TPad.cxx:1141
 TPad.cxx:1142
 TPad.cxx:1143
 TPad.cxx:1144
 TPad.cxx:1145
 TPad.cxx:1146
 TPad.cxx:1147
 TPad.cxx:1148
 TPad.cxx:1149
 TPad.cxx:1150
 TPad.cxx:1151
 TPad.cxx:1152
 TPad.cxx:1153
 TPad.cxx:1154
 TPad.cxx:1155
 TPad.cxx:1156
 TPad.cxx:1157
 TPad.cxx:1158
 TPad.cxx:1159
 TPad.cxx:1160
 TPad.cxx:1161
 TPad.cxx:1162
 TPad.cxx:1163
 TPad.cxx:1164
 TPad.cxx:1165
 TPad.cxx:1166
 TPad.cxx:1167
 TPad.cxx:1168
 TPad.cxx:1169
 TPad.cxx:1170
 TPad.cxx:1171
 TPad.cxx:1172
 TPad.cxx:1173
 TPad.cxx:1174
 TPad.cxx:1175
 TPad.cxx:1176
 TPad.cxx:1177
 TPad.cxx:1178
 TPad.cxx:1179
 TPad.cxx:1180
 TPad.cxx:1181
 TPad.cxx:1182
 TPad.cxx:1183
 TPad.cxx:1184
 TPad.cxx:1185
 TPad.cxx:1186
 TPad.cxx:1187
 TPad.cxx:1188
 TPad.cxx:1189
 TPad.cxx:1190
 TPad.cxx:1191
 TPad.cxx:1192
 TPad.cxx:1193
 TPad.cxx:1194
 TPad.cxx:1195
 TPad.cxx:1196
 TPad.cxx:1197
 TPad.cxx:1198
 TPad.cxx:1199
 TPad.cxx:1200
 TPad.cxx:1201
 TPad.cxx:1202
 TPad.cxx:1203
 TPad.cxx:1204
 TPad.cxx:1205
 TPad.cxx:1206
 TPad.cxx:1207
 TPad.cxx:1208
 TPad.cxx:1209
 TPad.cxx:1210
 TPad.cxx:1211
 TPad.cxx:1212
 TPad.cxx:1213
 TPad.cxx:1214
 TPad.cxx:1215
 TPad.cxx:1216
 TPad.cxx:1217
 TPad.cxx:1218
 TPad.cxx:1219
 TPad.cxx:1220
 TPad.cxx:1221
 TPad.cxx:1222
 TPad.cxx:1223
 TPad.cxx:1224
 TPad.cxx:1225
 TPad.cxx:1226
 TPad.cxx:1227
 TPad.cxx:1228
 TPad.cxx:1229
 TPad.cxx:1230
 TPad.cxx:1231
 TPad.cxx:1232
 TPad.cxx:1233
 TPad.cxx:1234
 TPad.cxx:1235
 TPad.cxx:1236
 TPad.cxx:1237
 TPad.cxx:1238
 TPad.cxx:1239
 TPad.cxx:1240
 TPad.cxx:1241
 TPad.cxx:1242
 TPad.cxx:1243
 TPad.cxx:1244
 TPad.cxx:1245
 TPad.cxx:1246
 TPad.cxx:1247
 TPad.cxx:1248
 TPad.cxx:1249
 TPad.cxx:1250
 TPad.cxx:1251
 TPad.cxx:1252
 TPad.cxx:1253
 TPad.cxx:1254
 TPad.cxx:1255
 TPad.cxx:1256
 TPad.cxx:1257
 TPad.cxx:1258
 TPad.cxx:1259
 TPad.cxx:1260
 TPad.cxx:1261
 TPad.cxx:1262
 TPad.cxx:1263
 TPad.cxx:1264
 TPad.cxx:1265
 TPad.cxx:1266
 TPad.cxx:1267
 TPad.cxx:1268
 TPad.cxx:1269
 TPad.cxx:1270
 TPad.cxx:1271
 TPad.cxx:1272
 TPad.cxx:1273
 TPad.cxx:1274
 TPad.cxx:1275
 TPad.cxx:1276
 TPad.cxx:1277
 TPad.cxx:1278
 TPad.cxx:1279
 TPad.cxx:1280
 TPad.cxx:1281
 TPad.cxx:1282
 TPad.cxx:1283
 TPad.cxx:1284
 TPad.cxx:1285
 TPad.cxx:1286
 TPad.cxx:1287
 TPad.cxx:1288
 TPad.cxx:1289
 TPad.cxx:1290
 TPad.cxx:1291
 TPad.cxx:1292
 TPad.cxx:1293
 TPad.cxx:1294
 TPad.cxx:1295
 TPad.cxx:1296
 TPad.cxx:1297
 TPad.cxx:1298
 TPad.cxx:1299
 TPad.cxx:1300
 TPad.cxx:1301
 TPad.cxx:1302
 TPad.cxx:1303
 TPad.cxx:1304
 TPad.cxx:1305
 TPad.cxx:1306
 TPad.cxx:1307
 TPad.cxx:1308
 TPad.cxx:1309
 TPad.cxx:1310
 TPad.cxx:1311
 TPad.cxx:1312
 TPad.cxx:1313
 TPad.cxx:1314
 TPad.cxx:1315
 TPad.cxx:1316
 TPad.cxx:1317
 TPad.cxx:1318
 TPad.cxx:1319
 TPad.cxx:1320
 TPad.cxx:1321
 TPad.cxx:1322
 TPad.cxx:1323
 TPad.cxx:1324
 TPad.cxx:1325
 TPad.cxx:1326
 TPad.cxx:1327
 TPad.cxx:1328
 TPad.cxx:1329
 TPad.cxx:1330
 TPad.cxx:1331
 TPad.cxx:1332
 TPad.cxx:1333
 TPad.cxx:1334
 TPad.cxx:1335
 TPad.cxx:1336
 TPad.cxx:1337
 TPad.cxx:1338
 TPad.cxx:1339
 TPad.cxx:1340
 TPad.cxx:1341
 TPad.cxx:1342
 TPad.cxx:1343
 TPad.cxx:1344
 TPad.cxx:1345
 TPad.cxx:1346
 TPad.cxx:1347
 TPad.cxx:1348
 TPad.cxx:1349
 TPad.cxx:1350
 TPad.cxx:1351
 TPad.cxx:1352
 TPad.cxx:1353
 TPad.cxx:1354
 TPad.cxx:1355
 TPad.cxx:1356
 TPad.cxx:1357
 TPad.cxx:1358
 TPad.cxx:1359
 TPad.cxx:1360
 TPad.cxx:1361
 TPad.cxx:1362
 TPad.cxx:1363
 TPad.cxx:1364
 TPad.cxx:1365
 TPad.cxx:1366
 TPad.cxx:1367
 TPad.cxx:1368
 TPad.cxx:1369
 TPad.cxx:1370
 TPad.cxx:1371
 TPad.cxx:1372
 TPad.cxx:1373
 TPad.cxx:1374
 TPad.cxx:1375
 TPad.cxx:1376
 TPad.cxx:1377
 TPad.cxx:1378
 TPad.cxx:1379
 TPad.cxx:1380
 TPad.cxx:1381
 TPad.cxx:1382
 TPad.cxx:1383
 TPad.cxx:1384
 TPad.cxx:1385
 TPad.cxx:1386
 TPad.cxx:1387
 TPad.cxx:1388
 TPad.cxx:1389
 TPad.cxx:1390
 TPad.cxx:1391
 TPad.cxx:1392
 TPad.cxx:1393
 TPad.cxx:1394
 TPad.cxx:1395
 TPad.cxx:1396
 TPad.cxx:1397
 TPad.cxx:1398
 TPad.cxx:1399
 TPad.cxx:1400
 TPad.cxx:1401
 TPad.cxx:1402
 TPad.cxx:1403
 TPad.cxx:1404
 TPad.cxx:1405
 TPad.cxx:1406
 TPad.cxx:1407
 TPad.cxx:1408
 TPad.cxx:1409
 TPad.cxx:1410
 TPad.cxx:1411
 TPad.cxx:1412
 TPad.cxx:1413
 TPad.cxx:1414
 TPad.cxx:1415
 TPad.cxx:1416
 TPad.cxx:1417
 TPad.cxx:1418
 TPad.cxx:1419
 TPad.cxx:1420
 TPad.cxx:1421
 TPad.cxx:1422
 TPad.cxx:1423
 TPad.cxx:1424
 TPad.cxx:1425
 TPad.cxx:1426
 TPad.cxx:1427
 TPad.cxx:1428
 TPad.cxx:1429
 TPad.cxx:1430
 TPad.cxx:1431
 TPad.cxx:1432
 TPad.cxx:1433
 TPad.cxx:1434
 TPad.cxx:1435
 TPad.cxx:1436
 TPad.cxx:1437
 TPad.cxx:1438
 TPad.cxx:1439
 TPad.cxx:1440
 TPad.cxx:1441
 TPad.cxx:1442
 TPad.cxx:1443
 TPad.cxx:1444
 TPad.cxx:1445
 TPad.cxx:1446
 TPad.cxx:1447
 TPad.cxx:1448
 TPad.cxx:1449
 TPad.cxx:1450
 TPad.cxx:1451
 TPad.cxx:1452
 TPad.cxx:1453
 TPad.cxx:1454
 TPad.cxx:1455
 TPad.cxx:1456
 TPad.cxx:1457
 TPad.cxx:1458
 TPad.cxx:1459
 TPad.cxx:1460
 TPad.cxx:1461
 TPad.cxx:1462
 TPad.cxx:1463
 TPad.cxx:1464
 TPad.cxx:1465
 TPad.cxx:1466
 TPad.cxx:1467
 TPad.cxx:1468
 TPad.cxx:1469
 TPad.cxx:1470
 TPad.cxx:1471
 TPad.cxx:1472
 TPad.cxx:1473
 TPad.cxx:1474
 TPad.cxx:1475
 TPad.cxx:1476
 TPad.cxx:1477
 TPad.cxx:1478
 TPad.cxx:1479
 TPad.cxx:1480
 TPad.cxx:1481
 TPad.cxx:1482
 TPad.cxx:1483
 TPad.cxx:1484
 TPad.cxx:1485
 TPad.cxx:1486
 TPad.cxx:1487
 TPad.cxx:1488
 TPad.cxx:1489
 TPad.cxx:1490
 TPad.cxx:1491
 TPad.cxx:1492
 TPad.cxx:1493
 TPad.cxx:1494
 TPad.cxx:1495
 TPad.cxx:1496
 TPad.cxx:1497
 TPad.cxx:1498
 TPad.cxx:1499
 TPad.cxx:1500
 TPad.cxx:1501
 TPad.cxx:1502
 TPad.cxx:1503
 TPad.cxx:1504
 TPad.cxx:1505
 TPad.cxx:1506
 TPad.cxx:1507
 TPad.cxx:1508
 TPad.cxx:1509
 TPad.cxx:1510
 TPad.cxx:1511
 TPad.cxx:1512
 TPad.cxx:1513
 TPad.cxx:1514
 TPad.cxx:1515
 TPad.cxx:1516
 TPad.cxx:1517
 TPad.cxx:1518
 TPad.cxx:1519
 TPad.cxx:1520
 TPad.cxx:1521
 TPad.cxx:1522
 TPad.cxx:1523
 TPad.cxx:1524
 TPad.cxx:1525
 TPad.cxx:1526
 TPad.cxx:1527
 TPad.cxx:1528
 TPad.cxx:1529
 TPad.cxx:1530
 TPad.cxx:1531
 TPad.cxx:1532
 TPad.cxx:1533
 TPad.cxx:1534
 TPad.cxx:1535
 TPad.cxx:1536
 TPad.cxx:1537
 TPad.cxx:1538
 TPad.cxx:1539
 TPad.cxx:1540
 TPad.cxx:1541
 TPad.cxx:1542
 TPad.cxx:1543
 TPad.cxx:1544
 TPad.cxx:1545
 TPad.cxx:1546
 TPad.cxx:1547
 TPad.cxx:1548
 TPad.cxx:1549
 TPad.cxx:1550
 TPad.cxx:1551
 TPad.cxx:1552
 TPad.cxx:1553
 TPad.cxx:1554
 TPad.cxx:1555
 TPad.cxx:1556
 TPad.cxx:1557
 TPad.cxx:1558
 TPad.cxx:1559
 TPad.cxx:1560
 TPad.cxx:1561
 TPad.cxx:1562
 TPad.cxx:1563
 TPad.cxx:1564
 TPad.cxx:1565
 TPad.cxx:1566
 TPad.cxx:1567
 TPad.cxx:1568
 TPad.cxx:1569
 TPad.cxx:1570
 TPad.cxx:1571
 TPad.cxx:1572
 TPad.cxx:1573
 TPad.cxx:1574
 TPad.cxx:1575
 TPad.cxx:1576
 TPad.cxx:1577
 TPad.cxx:1578
 TPad.cxx:1579
 TPad.cxx:1580
 TPad.cxx:1581
 TPad.cxx:1582
 TPad.cxx:1583
 TPad.cxx:1584
 TPad.cxx:1585
 TPad.cxx:1586
 TPad.cxx:1587
 TPad.cxx:1588
 TPad.cxx:1589
 TPad.cxx:1590
 TPad.cxx:1591
 TPad.cxx:1592
 TPad.cxx:1593
 TPad.cxx:1594
 TPad.cxx:1595
 TPad.cxx:1596
 TPad.cxx:1597
 TPad.cxx:1598
 TPad.cxx:1599
 TPad.cxx:1600
 TPad.cxx:1601
 TPad.cxx:1602
 TPad.cxx:1603
 TPad.cxx:1604
 TPad.cxx:1605
 TPad.cxx:1606
 TPad.cxx:1607
 TPad.cxx:1608
 TPad.cxx:1609
 TPad.cxx:1610
 TPad.cxx:1611
 TPad.cxx:1612
 TPad.cxx:1613
 TPad.cxx:1614
 TPad.cxx:1615
 TPad.cxx:1616
 TPad.cxx:1617
 TPad.cxx:1618
 TPad.cxx:1619
 TPad.cxx:1620
 TPad.cxx:1621
 TPad.cxx:1622
 TPad.cxx:1623
 TPad.cxx:1624
 TPad.cxx:1625
 TPad.cxx:1626
 TPad.cxx:1627
 TPad.cxx:1628
 TPad.cxx:1629
 TPad.cxx:1630
 TPad.cxx:1631
 TPad.cxx:1632
 TPad.cxx:1633
 TPad.cxx:1634
 TPad.cxx:1635
 TPad.cxx:1636
 TPad.cxx:1637
 TPad.cxx:1638
 TPad.cxx:1639
 TPad.cxx:1640
 TPad.cxx:1641
 TPad.cxx:1642
 TPad.cxx:1643
 TPad.cxx:1644
 TPad.cxx:1645
 TPad.cxx:1646
 TPad.cxx:1647
 TPad.cxx:1648
 TPad.cxx:1649
 TPad.cxx:1650
 TPad.cxx:1651
 TPad.cxx:1652
 TPad.cxx:1653
 TPad.cxx:1654
 TPad.cxx:1655
 TPad.cxx:1656
 TPad.cxx:1657
 TPad.cxx:1658
 TPad.cxx:1659
 TPad.cxx:1660
 TPad.cxx:1661
 TPad.cxx:1662
 TPad.cxx:1663
 TPad.cxx:1664
 TPad.cxx:1665
 TPad.cxx:1666
 TPad.cxx:1667
 TPad.cxx:1668
 TPad.cxx:1669
 TPad.cxx:1670
 TPad.cxx:1671
 TPad.cxx:1672
 TPad.cxx:1673
 TPad.cxx:1674
 TPad.cxx:1675
 TPad.cxx:1676
 TPad.cxx:1677
 TPad.cxx:1678
 TPad.cxx:1679
 TPad.cxx:1680
 TPad.cxx:1681
 TPad.cxx:1682
 TPad.cxx:1683
 TPad.cxx:1684
 TPad.cxx:1685
 TPad.cxx:1686
 TPad.cxx:1687
 TPad.cxx:1688
 TPad.cxx:1689
 TPad.cxx:1690
 TPad.cxx:1691
 TPad.cxx:1692
 TPad.cxx:1693
 TPad.cxx:1694
 TPad.cxx:1695
 TPad.cxx:1696
 TPad.cxx:1697
 TPad.cxx:1698
 TPad.cxx:1699
 TPad.cxx:1700
 TPad.cxx:1701
 TPad.cxx:1702
 TPad.cxx:1703
 TPad.cxx:1704
 TPad.cxx:1705
 TPad.cxx:1706
 TPad.cxx:1707
 TPad.cxx:1708
 TPad.cxx:1709
 TPad.cxx:1710
 TPad.cxx:1711
 TPad.cxx:1712
 TPad.cxx:1713
 TPad.cxx:1714
 TPad.cxx:1715
 TPad.cxx:1716
 TPad.cxx:1717
 TPad.cxx:1718
 TPad.cxx:1719
 TPad.cxx:1720
 TPad.cxx:1721
 TPad.cxx:1722
 TPad.cxx:1723
 TPad.cxx:1724
 TPad.cxx:1725
 TPad.cxx:1726
 TPad.cxx:1727
 TPad.cxx:1728
 TPad.cxx:1729
 TPad.cxx:1730
 TPad.cxx:1731
 TPad.cxx:1732
 TPad.cxx:1733
 TPad.cxx:1734
 TPad.cxx:1735
 TPad.cxx:1736
 TPad.cxx:1737
 TPad.cxx:1738
 TPad.cxx:1739
 TPad.cxx:1740
 TPad.cxx:1741
 TPad.cxx:1742
 TPad.cxx:1743
 TPad.cxx:1744
 TPad.cxx:1745
 TPad.cxx:1746
 TPad.cxx:1747
 TPad.cxx:1748
 TPad.cxx:1749
 TPad.cxx:1750
 TPad.cxx:1751
 TPad.cxx:1752
 TPad.cxx:1753
 TPad.cxx:1754
 TPad.cxx:1755
 TPad.cxx:1756
 TPad.cxx:1757
 TPad.cxx:1758
 TPad.cxx:1759
 TPad.cxx:1760
 TPad.cxx:1761
 TPad.cxx:1762
 TPad.cxx:1763
 TPad.cxx:1764
 TPad.cxx:1765
 TPad.cxx:1766
 TPad.cxx:1767
 TPad.cxx:1768
 TPad.cxx:1769
 TPad.cxx:1770
 TPad.cxx:1771
 TPad.cxx:1772
 TPad.cxx:1773
 TPad.cxx:1774
 TPad.cxx:1775
 TPad.cxx:1776
 TPad.cxx:1777
 TPad.cxx:1778
 TPad.cxx:1779
 TPad.cxx:1780
 TPad.cxx:1781
 TPad.cxx:1782
 TPad.cxx:1783
 TPad.cxx:1784
 TPad.cxx:1785
 TPad.cxx:1786
 TPad.cxx:1787
 TPad.cxx:1788
 TPad.cxx:1789
 TPad.cxx:1790
 TPad.cxx:1791
 TPad.cxx:1792
 TPad.cxx:1793
 TPad.cxx:1794
 TPad.cxx:1795
 TPad.cxx:1796
 TPad.cxx:1797
 TPad.cxx:1798
 TPad.cxx:1799
 TPad.cxx:1800
 TPad.cxx:1801
 TPad.cxx:1802
 TPad.cxx:1803
 TPad.cxx:1804
 TPad.cxx:1805
 TPad.cxx:1806
 TPad.cxx:1807
 TPad.cxx:1808
 TPad.cxx:1809
 TPad.cxx:1810
 TPad.cxx:1811
 TPad.cxx:1812
 TPad.cxx:1813
 TPad.cxx:1814
 TPad.cxx:1815
 TPad.cxx:1816
 TPad.cxx:1817
 TPad.cxx:1818
 TPad.cxx:1819
 TPad.cxx:1820
 TPad.cxx:1821
 TPad.cxx:1822
 TPad.cxx:1823
 TPad.cxx:1824
 TPad.cxx:1825
 TPad.cxx:1826
 TPad.cxx:1827
 TPad.cxx:1828
 TPad.cxx:1829
 TPad.cxx:1830
 TPad.cxx:1831
 TPad.cxx:1832
 TPad.cxx:1833
 TPad.cxx:1834
 TPad.cxx:1835
 TPad.cxx:1836
 TPad.cxx:1837
 TPad.cxx:1838
 TPad.cxx:1839
 TPad.cxx:1840
 TPad.cxx:1841
 TPad.cxx:1842
 TPad.cxx:1843
 TPad.cxx:1844
 TPad.cxx:1845
 TPad.cxx:1846
 TPad.cxx:1847
 TPad.cxx:1848
 TPad.cxx:1849
 TPad.cxx:1850
 TPad.cxx:1851
 TPad.cxx:1852
 TPad.cxx:1853
 TPad.cxx:1854
 TPad.cxx:1855
 TPad.cxx:1856
 TPad.cxx:1857
 TPad.cxx:1858
 TPad.cxx:1859
 TPad.cxx:1860
 TPad.cxx:1861
 TPad.cxx:1862
 TPad.cxx:1863
 TPad.cxx:1864
 TPad.cxx:1865
 TPad.cxx:1866
 TPad.cxx:1867
 TPad.cxx:1868
 TPad.cxx:1869
 TPad.cxx:1870
 TPad.cxx:1871
 TPad.cxx:1872
 TPad.cxx:1873
 TPad.cxx:1874
 TPad.cxx:1875
 TPad.cxx:1876
 TPad.cxx:1877
 TPad.cxx:1878
 TPad.cxx:1879
 TPad.cxx:1880
 TPad.cxx:1881
 TPad.cxx:1882
 TPad.cxx:1883
 TPad.cxx:1884
 TPad.cxx:1885
 TPad.cxx:1886
 TPad.cxx:1887
 TPad.cxx:1888
 TPad.cxx:1889
 TPad.cxx:1890
 TPad.cxx:1891
 TPad.cxx:1892
 TPad.cxx:1893
 TPad.cxx:1894
 TPad.cxx:1895
 TPad.cxx:1896
 TPad.cxx:1897
 TPad.cxx:1898
 TPad.cxx:1899
 TPad.cxx:1900
 TPad.cxx:1901
 TPad.cxx:1902
 TPad.cxx:1903
 TPad.cxx:1904
 TPad.cxx:1905
 TPad.cxx:1906
 TPad.cxx:1907
 TPad.cxx:1908
 TPad.cxx:1909
 TPad.cxx:1910
 TPad.cxx:1911
 TPad.cxx:1912
 TPad.cxx:1913
 TPad.cxx:1914
 TPad.cxx:1915
 TPad.cxx:1916
 TPad.cxx:1917
 TPad.cxx:1918
 TPad.cxx:1919
 TPad.cxx:1920
 TPad.cxx:1921
 TPad.cxx:1922
 TPad.cxx:1923
 TPad.cxx:1924
 TPad.cxx:1925
 TPad.cxx:1926
 TPad.cxx:1927
 TPad.cxx:1928
 TPad.cxx:1929
 TPad.cxx:1930
 TPad.cxx:1931
 TPad.cxx:1932
 TPad.cxx:1933
 TPad.cxx:1934
 TPad.cxx:1935
 TPad.cxx:1936
 TPad.cxx:1937
 TPad.cxx:1938
 TPad.cxx:1939
 TPad.cxx:1940
 TPad.cxx:1941
 TPad.cxx:1942
 TPad.cxx:1943
 TPad.cxx:1944
 TPad.cxx:1945
 TPad.cxx:1946
 TPad.cxx:1947
 TPad.cxx:1948
 TPad.cxx:1949
 TPad.cxx:1950
 TPad.cxx:1951
 TPad.cxx:1952
 TPad.cxx:1953
 TPad.cxx:1954
 TPad.cxx:1955
 TPad.cxx:1956
 TPad.cxx:1957
 TPad.cxx:1958
 TPad.cxx:1959
 TPad.cxx:1960
 TPad.cxx:1961
 TPad.cxx:1962
 TPad.cxx:1963
 TPad.cxx:1964
 TPad.cxx:1965
 TPad.cxx:1966
 TPad.cxx:1967
 TPad.cxx:1968
 TPad.cxx:1969
 TPad.cxx:1970
 TPad.cxx:1971
 TPad.cxx:1972
 TPad.cxx:1973
 TPad.cxx:1974
 TPad.cxx:1975
 TPad.cxx:1976
 TPad.cxx:1977
 TPad.cxx:1978
 TPad.cxx:1979
 TPad.cxx:1980
 TPad.cxx:1981
 TPad.cxx:1982
 TPad.cxx:1983
 TPad.cxx:1984
 TPad.cxx:1985
 TPad.cxx:1986
 TPad.cxx:1987
 TPad.cxx:1988
 TPad.cxx:1989
 TPad.cxx:1990
 TPad.cxx:1991
 TPad.cxx:1992
 TPad.cxx:1993
 TPad.cxx:1994
 TPad.cxx:1995
 TPad.cxx:1996
 TPad.cxx:1997
 TPad.cxx:1998
 TPad.cxx:1999
 TPad.cxx:2000
 TPad.cxx:2001
 TPad.cxx:2002
 TPad.cxx:2003
 TPad.cxx:2004
 TPad.cxx:2005
 TPad.cxx:2006
 TPad.cxx:2007
 TPad.cxx:2008
 TPad.cxx:2009
 TPad.cxx:2010
 TPad.cxx:2011
 TPad.cxx:2012
 TPad.cxx:2013
 TPad.cxx:2014
 TPad.cxx:2015
 TPad.cxx:2016
 TPad.cxx:2017
 TPad.cxx:2018
 TPad.cxx:2019
 TPad.cxx:2020
 TPad.cxx:2021
 TPad.cxx:2022
 TPad.cxx:2023
 TPad.cxx:2024
 TPad.cxx:2025
 TPad.cxx:2026
 TPad.cxx:2027
 TPad.cxx:2028
 TPad.cxx:2029
 TPad.cxx:2030
 TPad.cxx:2031
 TPad.cxx:2032
 TPad.cxx:2033
 TPad.cxx:2034
 TPad.cxx:2035
 TPad.cxx:2036
 TPad.cxx:2037
 TPad.cxx:2038
 TPad.cxx:2039
 TPad.cxx:2040
 TPad.cxx:2041
 TPad.cxx:2042
 TPad.cxx:2043
 TPad.cxx:2044
 TPad.cxx:2045
 TPad.cxx:2046
 TPad.cxx:2047
 TPad.cxx:2048
 TPad.cxx:2049
 TPad.cxx:2050
 TPad.cxx:2051
 TPad.cxx:2052
 TPad.cxx:2053
 TPad.cxx:2054
 TPad.cxx:2055
 TPad.cxx:2056
 TPad.cxx:2057
 TPad.cxx:2058
 TPad.cxx:2059
 TPad.cxx:2060
 TPad.cxx:2061
 TPad.cxx:2062
 TPad.cxx:2063
 TPad.cxx:2064
 TPad.cxx:2065
 TPad.cxx:2066
 TPad.cxx:2067
 TPad.cxx:2068
 TPad.cxx:2069
 TPad.cxx:2070
 TPad.cxx:2071
 TPad.cxx:2072
 TPad.cxx:2073
 TPad.cxx:2074
 TPad.cxx:2075
 TPad.cxx:2076
 TPad.cxx:2077
 TPad.cxx:2078
 TPad.cxx:2079
 TPad.cxx:2080
 TPad.cxx:2081
 TPad.cxx:2082
 TPad.cxx:2083
 TPad.cxx:2084
 TPad.cxx:2085
 TPad.cxx:2086
 TPad.cxx:2087
 TPad.cxx:2088
 TPad.cxx:2089
 TPad.cxx:2090
 TPad.cxx:2091
 TPad.cxx:2092
 TPad.cxx:2093
 TPad.cxx:2094
 TPad.cxx:2095
 TPad.cxx:2096
 TPad.cxx:2097
 TPad.cxx:2098
 TPad.cxx:2099
 TPad.cxx:2100
 TPad.cxx:2101
 TPad.cxx:2102
 TPad.cxx:2103
 TPad.cxx:2104
 TPad.cxx:2105
 TPad.cxx:2106
 TPad.cxx:2107
 TPad.cxx:2108
 TPad.cxx:2109
 TPad.cxx:2110
 TPad.cxx:2111
 TPad.cxx:2112
 TPad.cxx:2113
 TPad.cxx:2114
 TPad.cxx:2115
 TPad.cxx:2116
 TPad.cxx:2117
 TPad.cxx:2118
 TPad.cxx:2119
 TPad.cxx:2120
 TPad.cxx:2121
 TPad.cxx:2122
 TPad.cxx:2123
 TPad.cxx:2124
 TPad.cxx:2125
 TPad.cxx:2126
 TPad.cxx:2127
 TPad.cxx:2128
 TPad.cxx:2129
 TPad.cxx:2130
 TPad.cxx:2131
 TPad.cxx:2132
 TPad.cxx:2133
 TPad.cxx:2134
 TPad.cxx:2135
 TPad.cxx:2136
 TPad.cxx:2137
 TPad.cxx:2138
 TPad.cxx:2139
 TPad.cxx:2140
 TPad.cxx:2141
 TPad.cxx:2142
 TPad.cxx:2143
 TPad.cxx:2144
 TPad.cxx:2145
 TPad.cxx:2146
 TPad.cxx:2147
 TPad.cxx:2148
 TPad.cxx:2149
 TPad.cxx:2150
 TPad.cxx:2151
 TPad.cxx:2152
 TPad.cxx:2153
 TPad.cxx:2154
 TPad.cxx:2155
 TPad.cxx:2156
 TPad.cxx:2157
 TPad.cxx:2158
 TPad.cxx:2159
 TPad.cxx:2160
 TPad.cxx:2161
 TPad.cxx:2162
 TPad.cxx:2163
 TPad.cxx:2164
 TPad.cxx:2165
 TPad.cxx:2166
 TPad.cxx:2167
 TPad.cxx:2168
 TPad.cxx:2169
 TPad.cxx:2170
 TPad.cxx:2171
 TPad.cxx:2172
 TPad.cxx:2173
 TPad.cxx:2174
 TPad.cxx:2175
 TPad.cxx:2176
 TPad.cxx:2177
 TPad.cxx:2178
 TPad.cxx:2179
 TPad.cxx:2180
 TPad.cxx:2181
 TPad.cxx:2182
 TPad.cxx:2183
 TPad.cxx:2184
 TPad.cxx:2185
 TPad.cxx:2186
 TPad.cxx:2187
 TPad.cxx:2188
 TPad.cxx:2189
 TPad.cxx:2190
 TPad.cxx:2191
 TPad.cxx:2192
 TPad.cxx:2193
 TPad.cxx:2194
 TPad.cxx:2195
 TPad.cxx:2196
 TPad.cxx:2197
 TPad.cxx:2198
 TPad.cxx:2199
 TPad.cxx:2200
 TPad.cxx:2201
 TPad.cxx:2202
 TPad.cxx:2203
 TPad.cxx:2204
 TPad.cxx:2205
 TPad.cxx:2206
 TPad.cxx:2207
 TPad.cxx:2208
 TPad.cxx:2209
 TPad.cxx:2210
 TPad.cxx:2211
 TPad.cxx:2212
 TPad.cxx:2213
 TPad.cxx:2214
 TPad.cxx:2215
 TPad.cxx:2216
 TPad.cxx:2217
 TPad.cxx:2218
 TPad.cxx:2219
 TPad.cxx:2220
 TPad.cxx:2221
 TPad.cxx:2222
 TPad.cxx:2223
 TPad.cxx:2224
 TPad.cxx:2225
 TPad.cxx:2226
 TPad.cxx:2227
 TPad.cxx:2228
 TPad.cxx:2229
 TPad.cxx:2230
 TPad.cxx:2231
 TPad.cxx:2232
 TPad.cxx:2233
 TPad.cxx:2234
 TPad.cxx:2235
 TPad.cxx:2236
 TPad.cxx:2237
 TPad.cxx:2238
 TPad.cxx:2239
 TPad.cxx:2240
 TPad.cxx:2241
 TPad.cxx:2242
 TPad.cxx:2243
 TPad.cxx:2244
 TPad.cxx:2245
 TPad.cxx:2246
 TPad.cxx:2247
 TPad.cxx:2248
 TPad.cxx:2249
 TPad.cxx:2250
 TPad.cxx:2251
 TPad.cxx:2252
 TPad.cxx:2253
 TPad.cxx:2254
 TPad.cxx:2255
 TPad.cxx:2256
 TPad.cxx:2257
 TPad.cxx:2258
 TPad.cxx:2259
 TPad.cxx:2260
 TPad.cxx:2261
 TPad.cxx:2262
 TPad.cxx:2263
 TPad.cxx:2264
 TPad.cxx:2265
 TPad.cxx:2266
 TPad.cxx:2267
 TPad.cxx:2268
 TPad.cxx:2269
 TPad.cxx:2270
 TPad.cxx:2271
 TPad.cxx:2272
 TPad.cxx:2273
 TPad.cxx:2274
 TPad.cxx:2275
 TPad.cxx:2276
 TPad.cxx:2277
 TPad.cxx:2278
 TPad.cxx:2279
 TPad.cxx:2280
 TPad.cxx:2281
 TPad.cxx:2282
 TPad.cxx:2283
 TPad.cxx:2284
 TPad.cxx:2285
 TPad.cxx:2286
 TPad.cxx:2287
 TPad.cxx:2288
 TPad.cxx:2289
 TPad.cxx:2290
 TPad.cxx:2291
 TPad.cxx:2292
 TPad.cxx:2293
 TPad.cxx:2294
 TPad.cxx:2295
 TPad.cxx:2296
 TPad.cxx:2297
 TPad.cxx:2298
 TPad.cxx:2299
 TPad.cxx:2300
 TPad.cxx:2301
 TPad.cxx:2302
 TPad.cxx:2303
 TPad.cxx:2304
 TPad.cxx:2305
 TPad.cxx:2306
 TPad.cxx:2307
 TPad.cxx:2308
 TPad.cxx:2309
 TPad.cxx:2310
 TPad.cxx:2311
 TPad.cxx:2312
 TPad.cxx:2313
 TPad.cxx:2314
 TPad.cxx:2315
 TPad.cxx:2316
 TPad.cxx:2317
 TPad.cxx:2318
 TPad.cxx:2319
 TPad.cxx:2320
 TPad.cxx:2321
 TPad.cxx:2322
 TPad.cxx:2323
 TPad.cxx:2324
 TPad.cxx:2325
 TPad.cxx:2326
 TPad.cxx:2327
 TPad.cxx:2328
 TPad.cxx:2329
 TPad.cxx:2330
 TPad.cxx:2331
 TPad.cxx:2332
 TPad.cxx:2333
 TPad.cxx:2334
 TPad.cxx:2335
 TPad.cxx:2336
 TPad.cxx:2337
 TPad.cxx:2338
 TPad.cxx:2339
 TPad.cxx:2340
 TPad.cxx:2341
 TPad.cxx:2342
 TPad.cxx:2343
 TPad.cxx:2344
 TPad.cxx:2345
 TPad.cxx:2346
 TPad.cxx:2347
 TPad.cxx:2348
 TPad.cxx:2349
 TPad.cxx:2350
 TPad.cxx:2351
 TPad.cxx:2352
 TPad.cxx:2353
 TPad.cxx:2354
 TPad.cxx:2355
 TPad.cxx:2356
 TPad.cxx:2357
 TPad.cxx:2358
 TPad.cxx:2359
 TPad.cxx:2360
 TPad.cxx:2361
 TPad.cxx:2362
 TPad.cxx:2363
 TPad.cxx:2364
 TPad.cxx:2365
 TPad.cxx:2366
 TPad.cxx:2367
 TPad.cxx:2368
 TPad.cxx:2369
 TPad.cxx:2370
 TPad.cxx:2371
 TPad.cxx:2372
 TPad.cxx:2373
 TPad.cxx:2374
 TPad.cxx:2375
 TPad.cxx:2376
 TPad.cxx:2377
 TPad.cxx:2378
 TPad.cxx:2379
 TPad.cxx:2380
 TPad.cxx:2381
 TPad.cxx:2382
 TPad.cxx:2383
 TPad.cxx:2384
 TPad.cxx:2385
 TPad.cxx:2386
 TPad.cxx:2387
 TPad.cxx:2388
 TPad.cxx:2389
 TPad.cxx:2390
 TPad.cxx:2391
 TPad.cxx:2392
 TPad.cxx:2393
 TPad.cxx:2394
 TPad.cxx:2395
 TPad.cxx:2396
 TPad.cxx:2397
 TPad.cxx:2398
 TPad.cxx:2399
 TPad.cxx:2400
 TPad.cxx:2401
 TPad.cxx:2402
 TPad.cxx:2403
 TPad.cxx:2404
 TPad.cxx:2405
 TPad.cxx:2406
 TPad.cxx:2407
 TPad.cxx:2408
 TPad.cxx:2409
 TPad.cxx:2410
 TPad.cxx:2411
 TPad.cxx:2412
 TPad.cxx:2413
 TPad.cxx:2414
 TPad.cxx:2415
 TPad.cxx:2416
 TPad.cxx:2417
 TPad.cxx:2418
 TPad.cxx:2419
 TPad.cxx:2420
 TPad.cxx:2421
 TPad.cxx:2422
 TPad.cxx:2423
 TPad.cxx:2424
 TPad.cxx:2425
 TPad.cxx:2426
 TPad.cxx:2427
 TPad.cxx:2428
 TPad.cxx:2429
 TPad.cxx:2430
 TPad.cxx:2431
 TPad.cxx:2432
 TPad.cxx:2433
 TPad.cxx:2434
 TPad.cxx:2435
 TPad.cxx:2436
 TPad.cxx:2437
 TPad.cxx:2438
 TPad.cxx:2439
 TPad.cxx:2440
 TPad.cxx:2441
 TPad.cxx:2442
 TPad.cxx:2443
 TPad.cxx:2444
 TPad.cxx:2445
 TPad.cxx:2446
 TPad.cxx:2447
 TPad.cxx:2448
 TPad.cxx:2449
 TPad.cxx:2450
 TPad.cxx:2451
 TPad.cxx:2452
 TPad.cxx:2453
 TPad.cxx:2454
 TPad.cxx:2455
 TPad.cxx:2456
 TPad.cxx:2457
 TPad.cxx:2458
 TPad.cxx:2459
 TPad.cxx:2460
 TPad.cxx:2461
 TPad.cxx:2462
 TPad.cxx:2463
 TPad.cxx:2464
 TPad.cxx:2465
 TPad.cxx:2466
 TPad.cxx:2467
 TPad.cxx:2468
 TPad.cxx:2469
 TPad.cxx:2470
 TPad.cxx:2471
 TPad.cxx:2472
 TPad.cxx:2473
 TPad.cxx:2474
 TPad.cxx:2475
 TPad.cxx:2476
 TPad.cxx:2477
 TPad.cxx:2478
 TPad.cxx:2479
 TPad.cxx:2480
 TPad.cxx:2481
 TPad.cxx:2482
 TPad.cxx:2483
 TPad.cxx:2484
 TPad.cxx:2485
 TPad.cxx:2486
 TPad.cxx:2487
 TPad.cxx:2488
 TPad.cxx:2489
 TPad.cxx:2490
 TPad.cxx:2491
 TPad.cxx:2492
 TPad.cxx:2493
 TPad.cxx:2494
 TPad.cxx:2495
 TPad.cxx:2496
 TPad.cxx:2497
 TPad.cxx:2498
 TPad.cxx:2499
 TPad.cxx:2500
 TPad.cxx:2501
 TPad.cxx:2502
 TPad.cxx:2503
 TPad.cxx:2504
 TPad.cxx:2505
 TPad.cxx:2506
 TPad.cxx:2507
 TPad.cxx:2508
 TPad.cxx:2509
 TPad.cxx:2510
 TPad.cxx:2511
 TPad.cxx:2512
 TPad.cxx:2513
 TPad.cxx:2514
 TPad.cxx:2515
 TPad.cxx:2516
 TPad.cxx:2517
 TPad.cxx:2518
 TPad.cxx:2519
 TPad.cxx:2520
 TPad.cxx:2521
 TPad.cxx:2522
 TPad.cxx:2523
 TPad.cxx:2524
 TPad.cxx:2525
 TPad.cxx:2526
 TPad.cxx:2527
 TPad.cxx:2528
 TPad.cxx:2529
 TPad.cxx:2530
 TPad.cxx:2531
 TPad.cxx:2532
 TPad.cxx:2533
 TPad.cxx:2534
 TPad.cxx:2535
 TPad.cxx:2536
 TPad.cxx:2537
 TPad.cxx:2538
 TPad.cxx:2539
 TPad.cxx:2540
 TPad.cxx:2541
 TPad.cxx:2542
 TPad.cxx:2543
 TPad.cxx:2544
 TPad.cxx:2545
 TPad.cxx:2546
 TPad.cxx:2547
 TPad.cxx:2548
 TPad.cxx:2549
 TPad.cxx:2550
 TPad.cxx:2551
 TPad.cxx:2552
 TPad.cxx:2553
 TPad.cxx:2554
 TPad.cxx:2555
 TPad.cxx:2556
 TPad.cxx:2557
 TPad.cxx:2558
 TPad.cxx:2559
 TPad.cxx:2560
 TPad.cxx:2561
 TPad.cxx:2562
 TPad.cxx:2563
 TPad.cxx:2564
 TPad.cxx:2565
 TPad.cxx:2566
 TPad.cxx:2567
 TPad.cxx:2568
 TPad.cxx:2569
 TPad.cxx:2570
 TPad.cxx:2571
 TPad.cxx:2572
 TPad.cxx:2573
 TPad.cxx:2574
 TPad.cxx:2575
 TPad.cxx:2576
 TPad.cxx:2577
 TPad.cxx:2578
 TPad.cxx:2579
 TPad.cxx:2580
 TPad.cxx:2581
 TPad.cxx:2582
 TPad.cxx:2583
 TPad.cxx:2584
 TPad.cxx:2585
 TPad.cxx:2586
 TPad.cxx:2587
 TPad.cxx:2588
 TPad.cxx:2589
 TPad.cxx:2590
 TPad.cxx:2591
 TPad.cxx:2592
 TPad.cxx:2593
 TPad.cxx:2594
 TPad.cxx:2595
 TPad.cxx:2596
 TPad.cxx:2597
 TPad.cxx:2598
 TPad.cxx:2599
 TPad.cxx:2600
 TPad.cxx:2601
 TPad.cxx:2602
 TPad.cxx:2603
 TPad.cxx:2604
 TPad.cxx:2605
 TPad.cxx:2606
 TPad.cxx:2607
 TPad.cxx:2608
 TPad.cxx:2609
 TPad.cxx:2610
 TPad.cxx:2611
 TPad.cxx:2612
 TPad.cxx:2613
 TPad.cxx:2614
 TPad.cxx:2615
 TPad.cxx:2616
 TPad.cxx:2617
 TPad.cxx:2618
 TPad.cxx:2619
 TPad.cxx:2620
 TPad.cxx:2621
 TPad.cxx:2622
 TPad.cxx:2623
 TPad.cxx:2624
 TPad.cxx:2625
 TPad.cxx:2626
 TPad.cxx:2627
 TPad.cxx:2628
 TPad.cxx:2629
 TPad.cxx:2630
 TPad.cxx:2631
 TPad.cxx:2632
 TPad.cxx:2633
 TPad.cxx:2634
 TPad.cxx:2635
 TPad.cxx:2636
 TPad.cxx:2637
 TPad.cxx:2638
 TPad.cxx:2639
 TPad.cxx:2640
 TPad.cxx:2641
 TPad.cxx:2642
 TPad.cxx:2643
 TPad.cxx:2644
 TPad.cxx:2645
 TPad.cxx:2646
 TPad.cxx:2647
 TPad.cxx:2648
 TPad.cxx:2649
 TPad.cxx:2650
 TPad.cxx:2651
 TPad.cxx:2652
 TPad.cxx:2653
 TPad.cxx:2654
 TPad.cxx:2655
 TPad.cxx:2656
 TPad.cxx:2657
 TPad.cxx:2658
 TPad.cxx:2659
 TPad.cxx:2660
 TPad.cxx:2661
 TPad.cxx:2662
 TPad.cxx:2663
 TPad.cxx:2664
 TPad.cxx:2665
 TPad.cxx:2666
 TPad.cxx:2667
 TPad.cxx:2668
 TPad.cxx:2669
 TPad.cxx:2670
 TPad.cxx:2671
 TPad.cxx:2672
 TPad.cxx:2673
 TPad.cxx:2674
 TPad.cxx:2675
 TPad.cxx:2676
 TPad.cxx:2677
 TPad.cxx:2678
 TPad.cxx:2679
 TPad.cxx:2680
 TPad.cxx:2681
 TPad.cxx:2682
 TPad.cxx:2683
 TPad.cxx:2684
 TPad.cxx:2685
 TPad.cxx:2686
 TPad.cxx:2687
 TPad.cxx:2688
 TPad.cxx:2689
 TPad.cxx:2690
 TPad.cxx:2691
 TPad.cxx:2692
 TPad.cxx:2693
 TPad.cxx:2694
 TPad.cxx:2695
 TPad.cxx:2696
 TPad.cxx:2697
 TPad.cxx:2698
 TPad.cxx:2699
 TPad.cxx:2700
 TPad.cxx:2701
 TPad.cxx:2702
 TPad.cxx:2703
 TPad.cxx:2704
 TPad.cxx:2705
 TPad.cxx:2706
 TPad.cxx:2707
 TPad.cxx:2708
 TPad.cxx:2709
 TPad.cxx:2710
 TPad.cxx:2711
 TPad.cxx:2712
 TPad.cxx:2713
 TPad.cxx:2714
 TPad.cxx:2715
 TPad.cxx:2716
 TPad.cxx:2717
 TPad.cxx:2718
 TPad.cxx:2719
 TPad.cxx:2720
 TPad.cxx:2721
 TPad.cxx:2722
 TPad.cxx:2723
 TPad.cxx:2724
 TPad.cxx:2725
 TPad.cxx:2726
 TPad.cxx:2727
 TPad.cxx:2728
 TPad.cxx:2729
 TPad.cxx:2730
 TPad.cxx:2731
 TPad.cxx:2732
 TPad.cxx:2733
 TPad.cxx:2734
 TPad.cxx:2735
 TPad.cxx:2736
 TPad.cxx:2737
 TPad.cxx:2738
 TPad.cxx:2739
 TPad.cxx:2740
 TPad.cxx:2741
 TPad.cxx:2742
 TPad.cxx:2743
 TPad.cxx:2744
 TPad.cxx:2745
 TPad.cxx:2746
 TPad.cxx:2747
 TPad.cxx:2748
 TPad.cxx:2749
 TPad.cxx:2750
 TPad.cxx:2751
 TPad.cxx:2752
 TPad.cxx:2753
 TPad.cxx:2754
 TPad.cxx:2755
 TPad.cxx:2756
 TPad.cxx:2757
 TPad.cxx:2758
 TPad.cxx:2759
 TPad.cxx:2760
 TPad.cxx:2761
 TPad.cxx:2762
 TPad.cxx:2763
 TPad.cxx:2764
 TPad.cxx:2765
 TPad.cxx:2766
 TPad.cxx:2767
 TPad.cxx:2768
 TPad.cxx:2769
 TPad.cxx:2770
 TPad.cxx:2771
 TPad.cxx:2772
 TPad.cxx:2773
 TPad.cxx:2774
 TPad.cxx:2775
 TPad.cxx:2776
 TPad.cxx:2777
 TPad.cxx:2778
 TPad.cxx:2779
 TPad.cxx:2780
 TPad.cxx:2781
 TPad.cxx:2782
 TPad.cxx:2783
 TPad.cxx:2784
 TPad.cxx:2785
 TPad.cxx:2786
 TPad.cxx:2787
 TPad.cxx:2788
 TPad.cxx:2789
 TPad.cxx:2790
 TPad.cxx:2791
 TPad.cxx:2792
 TPad.cxx:2793
 TPad.cxx:2794
 TPad.cxx:2795
 TPad.cxx:2796
 TPad.cxx:2797
 TPad.cxx:2798
 TPad.cxx:2799
 TPad.cxx:2800
 TPad.cxx:2801
 TPad.cxx:2802
 TPad.cxx:2803
 TPad.cxx:2804
 TPad.cxx:2805
 TPad.cxx:2806
 TPad.cxx:2807
 TPad.cxx:2808
 TPad.cxx:2809
 TPad.cxx:2810
 TPad.cxx:2811
 TPad.cxx:2812
 TPad.cxx:2813
 TPad.cxx:2814
 TPad.cxx:2815
 TPad.cxx:2816
 TPad.cxx:2817
 TPad.cxx:2818
 TPad.cxx:2819
 TPad.cxx:2820
 TPad.cxx:2821
 TPad.cxx:2822
 TPad.cxx:2823
 TPad.cxx:2824
 TPad.cxx:2825
 TPad.cxx:2826
 TPad.cxx:2827
 TPad.cxx:2828
 TPad.cxx:2829
 TPad.cxx:2830
 TPad.cxx:2831
 TPad.cxx:2832
 TPad.cxx:2833
 TPad.cxx:2834
 TPad.cxx:2835
 TPad.cxx:2836
 TPad.cxx:2837
 TPad.cxx:2838
 TPad.cxx:2839
 TPad.cxx:2840
 TPad.cxx:2841
 TPad.cxx:2842
 TPad.cxx:2843
 TPad.cxx:2844
 TPad.cxx:2845
 TPad.cxx:2846
 TPad.cxx:2847
 TPad.cxx:2848
 TPad.cxx:2849
 TPad.cxx:2850
 TPad.cxx:2851
 TPad.cxx:2852
 TPad.cxx:2853
 TPad.cxx:2854
 TPad.cxx:2855
 TPad.cxx:2856
 TPad.cxx:2857
 TPad.cxx:2858
 TPad.cxx:2859
 TPad.cxx:2860
 TPad.cxx:2861
 TPad.cxx:2862
 TPad.cxx:2863
 TPad.cxx:2864
 TPad.cxx:2865
 TPad.cxx:2866
 TPad.cxx:2867
 TPad.cxx:2868
 TPad.cxx:2869
 TPad.cxx:2870
 TPad.cxx:2871
 TPad.cxx:2872
 TPad.cxx:2873
 TPad.cxx:2874
 TPad.cxx:2875
 TPad.cxx:2876
 TPad.cxx:2877
 TPad.cxx:2878
 TPad.cxx:2879
 TPad.cxx:2880
 TPad.cxx:2881
 TPad.cxx:2882
 TPad.cxx:2883
 TPad.cxx:2884
 TPad.cxx:2885
 TPad.cxx:2886
 TPad.cxx:2887
 TPad.cxx:2888
 TPad.cxx:2889
 TPad.cxx:2890
 TPad.cxx:2891
 TPad.cxx:2892
 TPad.cxx:2893
 TPad.cxx:2894
 TPad.cxx:2895
 TPad.cxx:2896
 TPad.cxx:2897
 TPad.cxx:2898
 TPad.cxx:2899
 TPad.cxx:2900
 TPad.cxx:2901
 TPad.cxx:2902
 TPad.cxx:2903
 TPad.cxx:2904
 TPad.cxx:2905
 TPad.cxx:2906
 TPad.cxx:2907
 TPad.cxx:2908
 TPad.cxx:2909
 TPad.cxx:2910
 TPad.cxx:2911
 TPad.cxx:2912
 TPad.cxx:2913
 TPad.cxx:2914
 TPad.cxx:2915
 TPad.cxx:2916
 TPad.cxx:2917
 TPad.cxx:2918
 TPad.cxx:2919
 TPad.cxx:2920
 TPad.cxx:2921
 TPad.cxx:2922
 TPad.cxx:2923
 TPad.cxx:2924
 TPad.cxx:2925
 TPad.cxx:2926
 TPad.cxx:2927
 TPad.cxx:2928
 TPad.cxx:2929
 TPad.cxx:2930
 TPad.cxx:2931
 TPad.cxx:2932
 TPad.cxx:2933
 TPad.cxx:2934
 TPad.cxx:2935
 TPad.cxx:2936
 TPad.cxx:2937
 TPad.cxx:2938
 TPad.cxx:2939
 TPad.cxx:2940
 TPad.cxx:2941
 TPad.cxx:2942
 TPad.cxx:2943
 TPad.cxx:2944
 TPad.cxx:2945
 TPad.cxx:2946
 TPad.cxx:2947
 TPad.cxx:2948
 TPad.cxx:2949
 TPad.cxx:2950
 TPad.cxx:2951
 TPad.cxx:2952
 TPad.cxx:2953
 TPad.cxx:2954
 TPad.cxx:2955
 TPad.cxx:2956
 TPad.cxx:2957
 TPad.cxx:2958
 TPad.cxx:2959
 TPad.cxx:2960
 TPad.cxx:2961
 TPad.cxx:2962
 TPad.cxx:2963
 TPad.cxx:2964
 TPad.cxx:2965
 TPad.cxx:2966
 TPad.cxx:2967
 TPad.cxx:2968
 TPad.cxx:2969
 TPad.cxx:2970
 TPad.cxx:2971
 TPad.cxx:2972
 TPad.cxx:2973
 TPad.cxx:2974
 TPad.cxx:2975
 TPad.cxx:2976
 TPad.cxx:2977
 TPad.cxx:2978
 TPad.cxx:2979
 TPad.cxx:2980
 TPad.cxx:2981
 TPad.cxx:2982
 TPad.cxx:2983
 TPad.cxx:2984
 TPad.cxx:2985
 TPad.cxx:2986
 TPad.cxx:2987
 TPad.cxx:2988
 TPad.cxx:2989
 TPad.cxx:2990
 TPad.cxx:2991
 TPad.cxx:2992
 TPad.cxx:2993
 TPad.cxx:2994
 TPad.cxx:2995
 TPad.cxx:2996
 TPad.cxx:2997
 TPad.cxx:2998
 TPad.cxx:2999
 TPad.cxx:3000
 TPad.cxx:3001
 TPad.cxx:3002
 TPad.cxx:3003
 TPad.cxx:3004
 TPad.cxx:3005
 TPad.cxx:3006
 TPad.cxx:3007
 TPad.cxx:3008
 TPad.cxx:3009
 TPad.cxx:3010
 TPad.cxx:3011
 TPad.cxx:3012
 TPad.cxx:3013
 TPad.cxx:3014
 TPad.cxx:3015
 TPad.cxx:3016
 TPad.cxx:3017
 TPad.cxx:3018
 TPad.cxx:3019
 TPad.cxx:3020
 TPad.cxx:3021
 TPad.cxx:3022
 TPad.cxx:3023
 TPad.cxx:3024
 TPad.cxx:3025
 TPad.cxx:3026
 TPad.cxx:3027
 TPad.cxx:3028
 TPad.cxx:3029
 TPad.cxx:3030
 TPad.cxx:3031
 TPad.cxx:3032
 TPad.cxx:3033
 TPad.cxx:3034
 TPad.cxx:3035
 TPad.cxx:3036
 TPad.cxx:3037
 TPad.cxx:3038
 TPad.cxx:3039
 TPad.cxx:3040
 TPad.cxx:3041
 TPad.cxx:3042
 TPad.cxx:3043
 TPad.cxx:3044
 TPad.cxx:3045
 TPad.cxx:3046
 TPad.cxx:3047
 TPad.cxx:3048
 TPad.cxx:3049
 TPad.cxx:3050
 TPad.cxx:3051
 TPad.cxx:3052
 TPad.cxx:3053
 TPad.cxx:3054
 TPad.cxx:3055
 TPad.cxx:3056
 TPad.cxx:3057
 TPad.cxx:3058
 TPad.cxx:3059
 TPad.cxx:3060
 TPad.cxx:3061
 TPad.cxx:3062
 TPad.cxx:3063
 TPad.cxx:3064
 TPad.cxx:3065
 TPad.cxx:3066
 TPad.cxx:3067
 TPad.cxx:3068
 TPad.cxx:3069
 TPad.cxx:3070
 TPad.cxx:3071
 TPad.cxx:3072
 TPad.cxx:3073
 TPad.cxx:3074
 TPad.cxx:3075
 TPad.cxx:3076
 TPad.cxx:3077
 TPad.cxx:3078
 TPad.cxx:3079
 TPad.cxx:3080
 TPad.cxx:3081
 TPad.cxx:3082
 TPad.cxx:3083
 TPad.cxx:3084
 TPad.cxx:3085
 TPad.cxx:3086
 TPad.cxx:3087
 TPad.cxx:3088
 TPad.cxx:3089
 TPad.cxx:3090
 TPad.cxx:3091
 TPad.cxx:3092
 TPad.cxx:3093
 TPad.cxx:3094
 TPad.cxx:3095
 TPad.cxx:3096
 TPad.cxx:3097
 TPad.cxx:3098
 TPad.cxx:3099
 TPad.cxx:3100
 TPad.cxx:3101
 TPad.cxx:3102
 TPad.cxx:3103
 TPad.cxx:3104
 TPad.cxx:3105
 TPad.cxx:3106
 TPad.cxx:3107
 TPad.cxx:3108
 TPad.cxx:3109
 TPad.cxx:3110
 TPad.cxx:3111
 TPad.cxx:3112
 TPad.cxx:3113
 TPad.cxx:3114
 TPad.cxx:3115
 TPad.cxx:3116
 TPad.cxx:3117
 TPad.cxx:3118
 TPad.cxx:3119
 TPad.cxx:3120
 TPad.cxx:3121
 TPad.cxx:3122
 TPad.cxx:3123
 TPad.cxx:3124
 TPad.cxx:3125
 TPad.cxx:3126
 TPad.cxx:3127
 TPad.cxx:3128
 TPad.cxx:3129
 TPad.cxx:3130
 TPad.cxx:3131
 TPad.cxx:3132
 TPad.cxx:3133
 TPad.cxx:3134
 TPad.cxx:3135
 TPad.cxx:3136
 TPad.cxx:3137
 TPad.cxx:3138
 TPad.cxx:3139
 TPad.cxx:3140
 TPad.cxx:3141
 TPad.cxx:3142
 TPad.cxx:3143
 TPad.cxx:3144
 TPad.cxx:3145
 TPad.cxx:3146
 TPad.cxx:3147
 TPad.cxx:3148
 TPad.cxx:3149
 TPad.cxx:3150
 TPad.cxx:3151
 TPad.cxx:3152
 TPad.cxx:3153
 TPad.cxx:3154
 TPad.cxx:3155
 TPad.cxx:3156
 TPad.cxx:3157
 TPad.cxx:3158
 TPad.cxx:3159
 TPad.cxx:3160
 TPad.cxx:3161
 TPad.cxx:3162
 TPad.cxx:3163
 TPad.cxx:3164
 TPad.cxx:3165
 TPad.cxx:3166
 TPad.cxx:3167