ROOT logo
// @(#)root/hist:$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 "Riostream.h"
#include "TAxis.h"
#include "TVirtualPad.h"
#include "TStyle.h"
#include "TError.h"
#include "THashList.h"
#include "TH1.h"
#include "TObjString.h"
#include "TDatime.h"
#include "TTimeStamp.h"
#include "TROOT.h"
#include "TClass.h"
#include "TMath.h"
#include <time.h>

ClassImp(TAxis)

//______________________________________________________________________________
//
// This class manages histogram axis. It is referenced by TH1 and TGraph.
// To make a graphical representation of an histogram axis, this class
// references the TGaxis class.
//
// TAxis supports axis with fixed or variable bin sizes.
// Labels may be associated to individual bins.
//
//    see examples of various axis representations drawn by class TGaxis.
//

//______________________________________________________________________________
TAxis::TAxis(): TNamed(), TAttAxis()
{
   // Default constructor.

   fNbins   = 1;
   fXmin    = 0;
   fXmax    = 1;
   fFirst   = 0;
   fLast    = 0;
   fParent  = 0;
   fLabels  = 0;
   fBits2   = 0;
   fTimeDisplay = 0;
}

//______________________________________________________________________________
TAxis::TAxis(Int_t nbins,Double_t xlow,Double_t xup): TNamed(), TAttAxis()
{
   // Axis constructor for axis with fix bin size

   fParent  = 0;
   fLabels  = 0;
   Set(nbins,xlow,xup);
}

//______________________________________________________________________________
TAxis::TAxis(Int_t nbins,const Double_t *xbins): TNamed(), TAttAxis()
{
   // Axis constructor for variable bin size

   fParent  = 0;
   fLabels  = 0;
   Set(nbins,xbins);
}

//______________________________________________________________________________
TAxis::~TAxis()
{
   // Destructor.

   if (fLabels) {
      fLabels->Delete();
      delete fLabels;
      fLabels = 0;
   }
}

//______________________________________________________________________________
TAxis::TAxis(const TAxis &axis) : TNamed(axis), TAttAxis(axis), fLabels(0)
{
   // Copy constructor.

   axis.Copy(*this);
}

//______________________________________________________________________________
TAxis& TAxis::operator=(const TAxis &orig)
{
   // Assignment operator.

   orig.Copy( *this );
   return *this;
}

//______________________________________________________________________________
void TAxis::CenterLabels(Bool_t center)
{
   //   if center = kTRUE axis labels will be centered (hori axes only)
   //   on the bin center
   //   default is to center on the primary tick marks
   //   This option does not make sense if there are more bins than tick marks

   if (center) SetBit(kCenterLabels);
   else        ResetBit(kCenterLabels);
}

//______________________________________________________________________________
Bool_t TAxis::GetCenterLabels() const
{
   // Return kTRUE if kCenterLabels bit is set, kFALSE otherwise.

   return TestBit(kCenterLabels) ? kTRUE : kFALSE;
}

//______________________________________________________________________________
void TAxis::CenterTitle(Bool_t center)
{
   //   if center = kTRUE axis title will be centered
   //   default is right adjusted

   if (center) SetBit(kCenterTitle);
   else        ResetBit(kCenterTitle);
}

//______________________________________________________________________________
Bool_t TAxis::GetCenterTitle() const
{
   // Return kTRUE if kCenterTitle bit is set, kFALSE otherwise.

   return TestBit(kCenterTitle) ? kTRUE : kFALSE;
}

//______________________________________________________________________________
const char *TAxis::ChooseTimeFormat(Double_t axislength)
{
   // Choose a reasonable time format from the coordinates in the active pad
   // and the number of divisions in this axis
   // If orientation = "X", the horizontal axis of the pad will be used for ref.
   // If orientation = "Y", the vertical axis of the pad will be used for ref.

   const char *formatstr;
   Int_t reasformat = 0;
   Int_t ndiv,nx1,nx2,n;
   Double_t awidth;
   Double_t length;

   if (!axislength) {
      length = gPad->GetUxmax() - gPad->GetUxmin();
   } else {
      length = axislength;
   }

   ndiv = GetNdivisions();
   if (ndiv > 1000) {
      nx2   = ndiv/100;
      nx1   = TMath::Max(1, ndiv%100);
      ndiv = 100*nx2 + Int_t(Double_t(nx1)*gPad->GetAbsWNDC());
   }
   ndiv = TMath::Abs(ndiv);
   n = ndiv - (ndiv/100)*100;
   awidth = length/n;

//  width in seconds ?
   if (awidth>=.5) {
      reasformat = 1;
//  width in minutes ?
      if (awidth>=30) {
         awidth /= 60; reasformat = 2;
//   width in hours ?
         if (awidth>=30) {
            awidth /=60; reasformat = 3;
//   width in days ?
            if (awidth>=12) {
               awidth /= 24; reasformat = 4;
//   width in months ?
               if (awidth>=15.218425) {
                  awidth /= 30.43685; reasformat = 5;
//   width in years ?
                  if (awidth>=6) {
                     awidth /= 12; reasformat = 6;
                     if (awidth>=2) {
                        awidth /= 12; reasformat = 7;
                     }
                  }
               }
            }
         }
      }
   }
//   set reasonable format
   switch (reasformat) {
      case 0:
        formatstr = "%S";
        break;
      case 1:
        formatstr = "%Mm%S";
        break;
      case 2:
        formatstr = "%Hh%M";
        break;
      case 3:
        formatstr = "%d-%Hh";
        break;
      case 4:
        formatstr = "%d/%m";
        break;
      case 5:
        formatstr = "%d/%m/%y";
        break;
      case 6:
        formatstr = "%d/%m/%y";
        break;
      case 7:
        formatstr = "%m/%y";
        break;
   }
   return formatstr;
}

//______________________________________________________________________________
void TAxis::Copy(TObject &obj) const
{
   // Copy axis structure to another axis

   TNamed::Copy(obj);
   TAttAxis::Copy(((TAxis&)obj));
   TAxis &axis( ((TAxis&)obj) );
   axis.fNbins  = fNbins;
   axis.fXmin   = fXmin;
   axis.fXmax   = fXmax;
   axis.fFirst  = fFirst;
   axis.fLast   = fLast;
   axis.fBits2  = fBits2;
   fXbins.Copy(axis.fXbins);
   axis.fTimeFormat   = fTimeFormat;
   axis.fTimeDisplay  = fTimeDisplay;
   axis.fParent       = fParent;
   if (axis.fLabels) {
      axis.fLabels->Delete();
      delete axis.fLabels;
      axis.fLabels = 0;
   }
   if (fLabels) {
      //Properly handle case where not all bins have labels
      TIter next(fLabels);
      TObjString *label;
      if(! axis.fLabels) {
	axis.fLabels = new THashList(axis.fNbins, 3);
      }
      while( (label=(TObjString*)next()) ) {
	TObjString *copyLabel = new TObjString(*label);
	axis.fLabels->Add(copyLabel);
	copyLabel->SetUniqueID(label->GetUniqueID());
      }
   }
}

//______________________________________________________________________________
Int_t TAxis::DistancetoPrimitive(Int_t, Int_t)
{
   // Compute distance from point px,py to an axis

   return 9999;
}

//______________________________________________________________________________
void TAxis::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // Execute action corresponding to one event
   //
   //  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 (!gPad) return;
   gPad->ExecuteEventAxis(event,px,py,this);
}

//______________________________________________________________________________
Int_t TAxis::FindBin(Double_t x)
{
   // Find bin number corresponding to abscissa x
   //
   // If x is underflow or overflow, attempt to rebin histogram
   // if the TH1::kCanRebin bit is set otherwise return 0 or fNbins+1

   Int_t bin;
   if (x < fXmin) {              //*-* underflow
      bin = 0;
      if (fParent == 0) return bin;
      if (!fParent->TestBit(TH1::kCanRebin)) return bin;
      ((TH1*)fParent)->RebinAxis(x,this);
      return FindFixBin(x);
   } else  if ( !(x < fXmax)) {     //*-* overflow  (note the way to catch NaN
      bin = fNbins+1;
      if (fParent == 0) return bin;
      if (!fParent->TestBit(TH1::kCanRebin)) return bin;
      ((TH1*)fParent)->RebinAxis(x,this);
      return FindFixBin(x);
   } else {
      if (!fXbins.fN) {        //*-* fix bins
         bin = 1 + int (fNbins*(x-fXmin)/(fXmax-fXmin) );
      } else {                  //*-* variable bin sizes
         //for (bin =1; x >= fXbins.fArray[bin]; bin++);
         bin = 1 + TMath::BinarySearch(fXbins.fN,fXbins.fArray,x);
      }
   }
   return bin;
}

//______________________________________________________________________________
Int_t TAxis::FindBin(const char *label)
{
   // Find bin number with label.
   // If the List of labels does not exist create it
   // If label is not in the list of labels do the following depending on the
   // bit TH1::kCanRebin of the parent histogram.
   //   - if the bit is set add the new label and if the number of labels exceeds
   //      the number of bins, double the number of bins via TH1::LabelsInflate
   //   - if the bit is not set return 0 (underflow bin)
   //
   // -1 is returned only when the Axis has no parent histogram

   //create list of labels if it does not exist yet
   if (!fLabels) {
      if (!fParent) return -1;
      fLabels = new THashList(1,1);
      fParent->SetBit(TH1::kCanRebin);
      if (fXmax <= fXmin) {
         //L.M. Dec 2010 in case of no min and max specified use 0 ->NBINS
         fXmin = 0;
         fXmax = fNbins;
      }
   }

   // search for label in the existing list
   TObjString *obj = (TObjString*)fLabels->FindObject(label);
   if (obj) return (Int_t)obj->GetUniqueID();

   //Not yet in the list. Can we rebin the histogram ?
   // if we cannot re-bin put label in the underflow bins
   if (!fParent->TestBit(TH1::kCanRebin)) {
      if (gDebug>0)
         Info("FindBin","Label %s is not in the list and the axis cannot be rebinned - the entry will be added in the underflow bin",label);
      return 0;
   }

   Int_t n = fLabels->GetEntries();
   TH1 *h = (TH1*)fParent;

   //may be we have to resize the histogram (doubling number of channels)
   if (n >= fNbins) h->LabelsInflate(GetName());

   //add new label to the list: assign bin number
   obj = new TObjString(label);
   fLabels->Add(obj);
   obj->SetUniqueID(n+1);
   return n+1;
}

//______________________________________________________________________________
Int_t TAxis::FindFixBin(Double_t x) const
{
   // Find bin number corresponding to abscissa x
   //
   // Identical to TAxis::FindBin except that if x is an underflow/overflow
   // no attempt is made to rebin the histogram if TH1::kCanRebin bit is set

   Int_t bin;
   if (x < fXmin) {              //*-* underflow
      bin = 0;
   } else  if ( !(x < fXmax)) {     //*-* overflow  (note the way to catch NaN
      bin = fNbins+1;
   } else {
      if (!fXbins.fN) {        //*-* fix bins
         bin = 1 + int (fNbins*(x-fXmin)/(fXmax-fXmin) );
      } else {                  //*-* variable bin sizes
//         for (bin =1; x >= fXbins.fArray[bin]; bin++);
         bin = 1 + TMath::BinarySearch(fXbins.fN,fXbins.fArray,x);
      }
   }
   return bin;
}

//______________________________________________________________________________
const char *TAxis::GetBinLabel(Int_t bin) const
{
   // Return label for bin

   if (!fLabels) return "";
   if (bin <= 0 || bin > fNbins) return "";
   TIter next(fLabels);
   TObjString *obj;
   while ((obj=(TObjString*)next())) {
      Int_t binid = (Int_t)obj->GetUniqueID();
      if (binid == bin) return obj->GetName();
   }
   return "";
}

//______________________________________________________________________________
Int_t TAxis::GetFirst() const
{
   //             return first bin on the axis
   //       ie 1 if no range defined
   //       NOTE: in some cases a zero is returned (see TAxis::SetRange)

   if (!TestBit(kAxisRange)) return 1;
   return fFirst;
}

//______________________________________________________________________________
Int_t TAxis::GetLast() const
{
   //             return last bin on the axis
   //       ie fNbins if no range defined
   //       NOTE: in some cases a zero is returned (see TAxis::SetRange)

   if (!TestBit(kAxisRange)) return fNbins;
   return fLast;
}

//______________________________________________________________________________
Double_t TAxis::GetBinCenter(Int_t bin) const
{
   // Return center of bin

   Double_t binwidth;
   if (!fXbins.fN || bin<1 || bin>fNbins) {
      binwidth = (fXmax - fXmin) / Double_t(fNbins);
      return fXmin + (bin-1) * binwidth + 0.5*binwidth;
   } else {
      binwidth = fXbins.fArray[bin] - fXbins.fArray[bin-1];
      return fXbins.fArray[bin-1] + 0.5*binwidth;
   }
}

//______________________________________________________________________________
Double_t TAxis::GetBinCenterLog(Int_t bin) const
{
   // Return center of bin in log
   // With a log-equidistant binning for a bin with low and up edges, the mean is :
   // 0.5*(ln low + ln up) i.e. sqrt(low*up) in logx (e.g. sqrt(10^0*10^2) = 10).
   //Imagine a bin with low=1 and up=100 :
   // - the center in lin is (100-1)/2=50.5
   // - the center in log would be sqrt(1*100)=10 (!=log(50.5))
   // NB: if the low edge of the bin is negative, the function returns the bin center
   //     as computed by TAxis::GetBinCenter

   Double_t low,up;
   if (!fXbins.fN || bin<1 || bin>fNbins) {
      Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
      low = fXmin + (bin-1) * binwidth;
      up  = low+binwidth;
   } else {
      low = fXbins.fArray[bin-1];
      up  = fXbins.fArray[bin];
   }
   if (low <=0 ) return GetBinCenter(bin);
   return TMath::Sqrt(low*up);
}
//______________________________________________________________________________
Double_t TAxis::GetBinLowEdge(Int_t bin) const
{
   // Return low edge of bin

   if (fXbins.fN && bin > 0 && bin <=fNbins) return fXbins.fArray[bin-1];
   Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
   return fXmin + (bin-1) * binwidth;
}

//______________________________________________________________________________
Double_t TAxis::GetBinUpEdge(Int_t bin) const
{
   // Return up edge of bin

   if (!fXbins.fN || bin < 1 || bin>fNbins) {
      Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
      return fXmin + bin*binwidth;
   } 
   return fXbins.fArray[bin]; 
}

//______________________________________________________________________________
Double_t TAxis::GetBinWidth(Int_t bin) const
{
   // Return bin width

   if (fNbins <= 0) return 0;
   if (fXbins.fN <= 0)  return (fXmax - fXmin) / Double_t(fNbins);
   if (bin >fNbins) bin = fNbins;
   if (bin <1 ) bin = 1;
   return fXbins.fArray[bin] - fXbins.fArray[bin-1];
}


//______________________________________________________________________________
void TAxis::GetCenter(Double_t *center) const
{
   // Return an array with the center of all bins

   Int_t bin;
   for (bin=1; bin<=fNbins; bin++) *(center + bin-1) = GetBinCenter(bin);
}

//______________________________________________________________________________
void TAxis::GetLowEdge(Double_t *edge) const
{
   // Return an array with the lod edge of all bins

   Int_t bin;
   for (bin=1; bin<=fNbins; bin++) *(edge + bin-1) = GetBinLowEdge(bin);
}

//______________________________________________________________________________
const char *TAxis::GetTimeFormatOnly() const
{
   // Return *only* the time format from the string fTimeFormat

   static TString timeformat;
   Int_t idF = fTimeFormat.Index("%F");
   if (idF>=0) {
      timeformat = fTimeFormat(0,idF);
   } else {
      timeformat = fTimeFormat;
   }
   return timeformat.Data();
}

//______________________________________________________________________________
const char *TAxis::GetTicks() const
{
   // Return the ticks option (see SetTicks)

   if (TestBit(kTickPlus) && TestBit(kTickMinus)) return "+-";
   if (TestBit(kTickMinus)) return "-";
   return "+";
}

//______________________________________________________________________________
void TAxis::LabelsOption(Option_t *option)
{
   //  Set option(s) to draw axis with labels
   //  option = "a" sort by alphabetic order
   //         = ">" sort by decreasing values
   //         = "<" sort by increasing values
   //         = "h" draw labels horizonthal
   //         = "v" draw labels vertical
   //         = "u" draw labels up (end of label right adjusted)
   //         = "d" draw labels down (start of label left adjusted)

   if (!fLabels) {
      Warning("Sort","Cannot sort. No labels");
      return;
   }
   TH1 *h = (TH1*)GetParent();
   if (!h) {
      Error("Sort","Axis has no parent");
      return;
   }

   h->LabelsOption(option,GetName());
}

//___________________________________________________________________________
Bool_t TAxis::GetRotateTitle() const
{
   // Return kTRUE if kRotateTitle bit is set, kFALSE otherwise.

   return TestBit(kRotateTitle) ? kTRUE : kFALSE;
}

//______________________________________________________________________________
void TAxis::ImportAttributes(const TAxis *axis)
{
   // Copy axis attributes to this

   SetTitle(axis->GetTitle());
   SetNdivisions(axis->GetNdivisions());
   SetAxisColor(axis->GetAxisColor());
   SetLabelColor(axis->GetLabelColor());
   SetLabelFont(axis->GetLabelFont());
   SetLabelOffset(axis->GetLabelOffset());
   SetLabelSize(axis->GetLabelSize());
   SetTickLength(axis->GetTickLength());
   SetTitleOffset(axis->GetTitleOffset());
   SetTitleSize(axis->GetTitleSize());
   SetTitleColor(axis->GetTitleColor());
   SetTitleFont(axis->GetTitleFont());
   SetBit(TAxis::kCenterTitle,   axis->TestBit(TAxis::kCenterTitle));
   SetBit(TAxis::kCenterLabels,  axis->TestBit(TAxis::kCenterLabels));
   SetBit(TAxis::kRotateTitle,   axis->TestBit(TAxis::kRotateTitle));
   SetBit(TAxis::kNoExponent,    axis->TestBit(TAxis::kNoExponent));
   SetBit(TAxis::kTickPlus,      axis->TestBit(TAxis::kTickPlus));
   SetBit(TAxis::kTickMinus,     axis->TestBit(TAxis::kTickMinus));
   SetBit(TAxis::kMoreLogLabels, axis->TestBit(TAxis::kMoreLogLabels));
   if (axis->GetDecimals())      SetBit(TAxis::kDecimals); //the bit is in TAxis::fAxis2
   SetTimeFormat(axis->GetTimeFormat());
}

//___________________________________________________________________________
void TAxis::RotateTitle(Bool_t rotate)
{
   //    rotate title by 180 degrees
   //    by default the title is drawn right adjusted.
   //    if rotate is TRUE, the title is left adjusted at the end of the axis
   //    and rotated by 180 degrees

   if (rotate) SetBit(kRotateTitle);
   else        ResetBit(kRotateTitle);
}

//______________________________________________________________________________
void TAxis::SaveAttributes(std::ostream &out, const char *name, const char *subname)
{
    // Save axis attributes as C++ statement(s) on output stream out

   char quote = '"';
   if (strlen(GetTitle())) {
      TString t(GetTitle());
      t.ReplaceAll("\\","\\\\");
      out<<"   "<<name<<subname<<"->SetTitle("<<quote<<t.Data()<<quote<<");"<<std::endl;
   }
   if (fTimeDisplay) {
      out<<"   "<<name<<subname<<"->SetTimeDisplay(1);"<<std::endl;
      out<<"   "<<name<<subname<<"->SetTimeFormat("<<quote<<GetTimeFormat()<<quote<<");"<<std::endl;
   }
   if (fLabels) {
      TIter next(fLabels);
      TObjString *obj;
      while ((obj=(TObjString*)next())) {
         out<<"   "<<name<<subname<<"->SetBinLabel("<<obj->GetUniqueID()<<","<<quote<<obj->GetName()<<quote<<");"<<std::endl;
      }
   }

   if (fFirst || fLast) {
      out<<"   "<<name<<subname<<"->SetRange("<<fFirst<<","<<fLast<<");"<<std::endl;
   }

   if (TestBit(kLabelsHori)) {
      out<<"   "<<name<<subname<<"->SetBit(TAxis::kLabelsHori);"<<std::endl;
   }

   if (TestBit(kLabelsVert)) {
      out<<"   "<<name<<subname<<"->SetBit(TAxis::kLabelsVert);"<<std::endl;
   }

   if (TestBit(kLabelsDown)) {
      out<<"   "<<name<<subname<<"->SetBit(TAxis::kLabelsDown);"<<std::endl;
   }

   if (TestBit(kLabelsUp)) {
      out<<"   "<<name<<subname<<"->SetBit(TAxis::kLabelsUp);"<<std::endl;
   }

   if (TestBit(kCenterTitle)) {
      out<<"   "<<name<<subname<<"->CenterTitle(true);"<<std::endl;
   }

   if (TestBit(kRotateTitle)) {
      out<<"   "<<name<<subname<<"->RotateTitle(true);"<<std::endl;
   }

   if (TestBit(kMoreLogLabels)) {
      out<<"   "<<name<<subname<<"->SetMoreLogLabels();"<<std::endl;
   }

   if (TestBit(kNoExponent)) {
      out<<"   "<<name<<subname<<"->SetNoExponent();"<<std::endl;
   }

   TAttAxis::SaveAttributes(out,name,subname);
}

//______________________________________________________________________________
void TAxis::Set(Int_t nbins, Double_t xlow, Double_t xup)
{
   // Initialize axis with fix bins

   fNbins   = nbins;
   fXmin    = xlow;
   fXmax    = xup;
   if (!fParent) SetDefaults();
   if (fXbins.fN > 0) fXbins.Set(0);
}

//______________________________________________________________________________
void TAxis::Set(Int_t nbins, const Float_t *xbins)
{
   // Initialize axis with variable bins

   Int_t bin;
   fNbins  = nbins;
   fXbins.Set(fNbins+1);
   for (bin=0; bin<= fNbins; bin++)
      fXbins.fArray[bin] = xbins[bin];
   for (bin=1; bin<= fNbins; bin++)
      if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
         Error("TAxis::Set", "bins must be in increasing order");
   fXmin      = fXbins.fArray[0];
   fXmax      = fXbins.fArray[fNbins];
   if (!fParent) SetDefaults();
}

//______________________________________________________________________________
void TAxis::Set(Int_t nbins, const Double_t *xbins)
{
   // Initialize axis with variable bins

   Int_t bin;
   fNbins  = nbins;
   fXbins.Set(fNbins+1);
   for (bin=0; bin<= fNbins; bin++)
      fXbins.fArray[bin] = xbins[bin];
   for (bin=1; bin<= fNbins; bin++)
      if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
         Error("TAxis::Set", "bins must be in increasing order");
   fXmin      = fXbins.fArray[0];
   fXmax      = fXbins.fArray[fNbins];
   if (!fParent) SetDefaults();
}

//______________________________________________________________________________
void TAxis::SetDefaults()
{
   // Set axis default values (from TStyle)

   fFirst   = 0;
   fLast    = 0;
   fBits2   = 0;
   char name[2];
   strlcpy(name,GetName(),2);
   name[1] = 0;
   TAttAxis::ResetAttAxis(name);
   fTimeDisplay = 0;
   SetTimeFormat();
}

//______________________________________________________________________________
Bool_t TAxis::GetDecimals() const
{
   // Returns kTRUE if kDecimals bit is set, kFALSE otherwise.
   // see TAxis::SetDecimals

   if ((fBits2 & kDecimals) != 0) return kTRUE;
   else                           return kFALSE;
}


//______________________________________________________________________________
void TAxis::SetDecimals(Bool_t dot)
{
   // Set the Decimals flag
   // By default, blank characters are stripped, and then the
   // label is correctly aligned. The dot, if last character of the string,
   // is also stripped, unless this option is specified.
   // One can disable the option by calling axis.SetDecimals(kTRUE).
   // The flag (in fBits2) is passed to the drawing function TGaxis::PaintAxis

   if (dot) fBits2 |=  kDecimals;
   else     fBits2 &= ~kDecimals;
}

//______________________________________________________________________________
void TAxis::SetBinLabel(Int_t bin, const char *label)
{
   // Set label for bin
   // In this case we create a label list in the axis but we do not
   // set the kCanRebin bit.
   // New labels will not be added with the Fill method but will end-up in the
   // underflow bin. See documentation of TAxis::FindBin(const char*)

   if (!fLabels) fLabels = new THashList(fNbins,3);

   if (bin <= 0 || bin > fNbins) {
      Error("SetBinLabel","Illegal bin number: %d",bin);
      return;
   }

   // Check whether this bin already has a label.
   TIter next(fLabels);
   TObjString *obj;
   while ((obj=(TObjString*)next())) {
      if ( obj->GetUniqueID()==(UInt_t)bin ) {
         // It does. Overwrite it.
         obj->SetString(label);
         // LM need to rehash the labels list (see ROOT-5025)
         fLabels->Rehash(fLabels->GetSize() );
         return;
      }
   }
   // It doesn't. Add this new label.
   obj = new TObjString(label);
   fLabels->Add(obj);
   obj->SetUniqueID((UInt_t)bin);
}

//______________________________________________________________________________
void TAxis::SetLimits(Double_t xmin, Double_t xmax)
{
   //          Set the axis limits

   fXmin = xmin;
   fXmax = xmax;
}

//______________________________________________________________________________
Bool_t TAxis::GetMoreLogLabels() const
{
   // Return kTRUE if kMoreLogLabels bit is set, kFALSE otherwise.

   return TestBit(kMoreLogLabels) ? kTRUE : kFALSE;
}

//______________________________________________________________________________
void TAxis::SetMoreLogLabels(Bool_t more)
{
   // Set the kMoreLogLabels bit flag
   // When this option is selected more labels are drawn when in log scale
   // and there is a small number of decades  (<3).
   // The flag (in fBits) is passed to the drawing function TGaxis::PaintAxis

   if (more) SetBit(kMoreLogLabels);
   else      ResetBit(kMoreLogLabels);
}

//______________________________________________________________________________
Bool_t TAxis::GetNoExponent() const
{
   // Returns kTRUE if kNoExponent bit is set, kFALSE otherwise.
   // see TAxis::SetNoExponent

   return TestBit(kNoExponent) ? kTRUE : kFALSE;
}

//______________________________________________________________________________
void TAxis::SetNoExponent(Bool_t noExponent)
{
   // Set the NoExponent flag
   // By default, an exponent of the form 10^N is used when the label values
   // are either all very small or very large.
   // One can disable the exponent by calling axis.SetNoExponent(kTRUE).
   // The flag (in fBits) is passed to the drawing function TGaxis::PaintAxis

   if (noExponent) SetBit(kNoExponent);
   else            ResetBit(kNoExponent);
}

//______________________________________________________________________________
void TAxis::SetRange(Int_t first, Int_t last)
{
   //  Set the viewing range for the axis from bin first to last
   //  To set a range using the axis coordinates, use TAxis::SetRangeUser.

   //  If first == last == 0 or if last < first or if the range specified does
   //  not intersect at all with the maximum available range [0, fNbins + 1],
   //  then the range is reset by removing the bit TAxis::kAxisRange. In this 
   //  case the functions TAxis::GetFirst() and TAxis::GetLast() will return 1 
   //  and fNbins.

   //  If the range specified partially intersects [0, fNbins + 1], then the
   //  intersection range is set. For instance, if first == -2 and last == fNbins,
   //  then the set range is [0, fNbins] (fFirst = 0 and fLast = fNbins).
   // 
   //  NOTE: for historical reasons, SetRange(0,0) resets the range even though Bin 0 is 
   //       technically reserved for the underflow; in order to set the range of the axis
   //       so that it only includes the underflow, use SetRange(a,0), where a < 0

   Int_t nCells = fNbins + 1; // bins + overflow

   // special reset range cases
   if (last < first || (first < 0 && last < 0) ||
         (first > nCells && last > nCells) || (first == 0 && last == 0)
   ) {
      fFirst = 1;
      fLast = fNbins;
      SetBit(kAxisRange, 0);
   } else {
      fFirst = std::max(first, 0);
      fLast = std::min(last, nCells);
      SetBit(kAxisRange, 1);
   }

}


//______________________________________________________________________________
void TAxis::SetRangeUser(Double_t ufirst, Double_t ulast)
{
   //  Set the viewing range for the axis from ufirst to ulast (in user coordinates)
   //  To set a range using the axis bin numbers, use TAxis::SetRange.

   if (!strstr(GetName(),"xaxis")) {
      TH1 *hobj = (TH1*)GetParent();
      if (hobj &&
          ((hobj->GetDimension() == 2 && strstr(GetName(),"zaxis"))
           || (hobj->GetDimension() == 1 && strstr(GetName(),"yaxis")))) {
         hobj->SetMinimum(ufirst);
         hobj->SetMaximum(ulast);
         return;
      }
   }
   Int_t ifirst = FindFixBin(ufirst); 
   Int_t ilast = FindFixBin(ulast); 
   // fixes for numerical error and for https://savannah.cern.ch/bugs/index.php?99777
   if (GetBinUpEdge(ifirst) <= ufirst ) ifirst += 1;
   if (GetBinLowEdge(ilast) >= ulast ) ilast -= 1;
   SetRange(ifirst, ilast);
}

//______________________________________________________________________________
void TAxis::SetTicks(Option_t *option)
{
   //  set ticks orientation
   //  option = "+"  ticks drawn on the "positive side" (default)
   //  option = "-"  ticks drawn on the "negative side"
   //  option = "+-" ticks drawn on both sides

   ResetBit(kTickPlus);
   ResetBit(kTickMinus);
   if (strchr(option,'+')) SetBit(kTickPlus);
   if (strchr(option,'-')) SetBit(kTickMinus);
}

//______________________________________________________________________________
void TAxis::SetTimeFormat(const char *tformat)
{
   // Change the format used for time plotting
   //
   //  The format string for date and time use the same options as the one used
   //  in the standard strftime C function, i.e. :
   //    for date :
   //      %a abbreviated weekday name
   //      %b abbreviated month name
   //      %d day of the month (01-31)
   //      %m month (01-12)
   //      %y year without century
   //
   //    for time :
   //      %H hour (24-hour clock)
   //      %I hour (12-hour clock)
   //      %p local equivalent of AM or PM
   //      %M minute (00-59)
   //      %S seconds (00-61)
   //      %% %
   //
   //    This function allows also to define the time offset. It is done via %F
   //    which should be appended at the end of the format string. The time
   //    offset has the following format: 'yyyy-mm-dd hh:mm:ss'
   //    Example:
   //
   //          h = new TH1F("Test","h",3000,0.,200000.);
   //          h->GetXaxis()->SetTimeDisplay(1);
   //          h->GetXaxis()->SetTimeFormat("%d\/%m\/%y%F2000-02-28 13:00:01");
   //
   //    This defines the time format being "dd/mm/yy" and the time offset as the
   //    February 28th 2003 at 13:00:01
   //
   //    If %F is not specified, the time offset used will be the one defined by:
   //    gStyle->SetTimeOffset. For example like that:
   //
   //          TDatime da(2003,02,28,12,00,00);
   //          gStyle->SetTimeOffset(da.Convert());

   TString timeformat = tformat;

   if (timeformat.Index("%F")>=0 || timeformat.IsNull()) {
      fTimeFormat = timeformat;
      return;
   }

   Int_t idF = fTimeFormat.Index("%F");
   if (idF>=0) {
      Int_t lnF = fTimeFormat.Length();
      TString stringtimeoffset = fTimeFormat(idF,lnF);
      fTimeFormat = tformat;
      fTimeFormat.Append(stringtimeoffset);
   } else {
      fTimeFormat = tformat;
      SetTimeOffset(gStyle->GetTimeOffset());
   }
}


//______________________________________________________________________________
void TAxis::SetTimeOffset(Double_t toffset, Option_t *option)
{
   // Change the time offset
   // If option = "gmt", set display mode to GMT.

   TString opt = option;
   opt.ToLower();

   char tmp[20];
   time_t timeoff;
   struct tm* utctis;
   Int_t idF = fTimeFormat.Index("%F");
   if (idF>=0) fTimeFormat.Remove(idF);
   fTimeFormat.Append("%F");

   timeoff = (time_t)((Long_t)(toffset));
   // offset is always saved in GMT to allow file transport
   // to different time zones
   utctis = gmtime(&timeoff);
   
   strftime(tmp,20,"%Y-%m-%d %H:%M:%S",utctis);
   fTimeFormat.Append(tmp);

   // append the decimal part of the time offset
   Double_t ds = toffset-(Int_t)toffset;
   snprintf(tmp,20,"s%g",ds);
   fTimeFormat.Append(tmp);

   // add GMT/local option
   if (opt.Contains("gmt")) fTimeFormat.Append(" GMT");
}


//______________________________________________________________________________
void TAxis::Streamer(TBuffer &R__b)
{
   // Stream an object of class TAxis.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 5) {
         R__b.ReadClassBuffer(TAxis::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TNamed::Streamer(R__b);
      TAttAxis::Streamer(R__b);
      R__b >> fNbins;
      if (R__v < 5) {
         Float_t xmin,xmax;
         R__b >> xmin; fXmin = xmin;
         R__b >> xmax; fXmax = xmax;
         Float_t *xbins = 0;
         Int_t n = R__b.ReadArray(xbins);
         fXbins.Set(n);
         for (Int_t i=0;i<n;i++) fXbins.fArray[i] = xbins[i];
         delete [] xbins;
      } else {
         R__b >> fXmin;
         R__b >> fXmax;
         fXbins.Streamer(R__b);
      }
      if (R__v > 2) {
         R__b >> fFirst;
         R__b >> fLast;
          // following lines required to repair for a bug in Root version 1.03
         if (fFirst < 0 || fFirst > fNbins) fFirst = 0;
         if (fLast  < 0 || fLast  > fNbins) fLast  = 0;
         if (fLast  < fFirst) { fFirst = 0; fLast = 0;}
         if (fFirst ==0 && fLast == 0) SetBit(kAxisRange,0);
      }
      if (R__v > 3) {
         R__b >> fTimeDisplay;
         fTimeFormat.Streamer(R__b);
      } else {
         SetTimeFormat();
      }
      R__b.CheckByteCount(R__s, R__c, TAxis::IsA());
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TAxis::Class(),this);
   }
}

//______________________________________________________________________________
void TAxis::UnZoom()
{
   // Reset first & last bin to the full range

   if (!gPad) return;
   gPad->SetView();

   //unzoom object owning this axis
   SetRange(0,0);
   TH1 *hobj1 = (TH1*)GetParent();
   if (!strstr(GetName(),"xaxis")) {
      if (!hobj1) return;
      if (hobj1->GetDimension() == 2) {
         if (strstr(GetName(),"zaxis")) {
            hobj1->SetMinimum();
            hobj1->SetMaximum();
            hobj1->ResetBit(TH1::kIsZoomed);
         }
         return;
      }
      if (strcmp(hobj1->GetName(),"hframe") == 0 ) {
         hobj1->SetMinimum(fXmin);
         hobj1->SetMaximum(fXmax);
      } else {
         if (fXmin==hobj1->GetMinimum() && fXmax==hobj1->GetMaximum()) {
            hobj1->SetMinimum(fXmin);
            hobj1->SetMaximum(fXmax);
         } else {
            hobj1->SetMinimum();
            hobj1->SetMaximum();
         }
         hobj1->ResetBit(TH1::kIsZoomed);
      }
   }
   //must unzoom all histograms in the pad
   TIter next(gPad->GetListOfPrimitives());
   TObject *obj;
   while ((obj= next())) {
      if (!obj->InheritsFrom(TH1::Class())) continue;
      TH1 *hobj = (TH1*)obj;
      if (hobj == hobj1) continue;
      if (!strstr(GetName(),"xaxis")) {
         if (hobj->GetDimension() == 2) {
            if (strstr(GetName(),"zaxis")) {
               hobj->SetMinimum();
               hobj->SetMaximum();
               hobj->ResetBit(TH1::kIsZoomed);
            } else {
               hobj->GetYaxis()->SetRange(0,0);
            }
            return;
         }
         if (strcmp(hobj->GetName(),"hframe") == 0 ) {
            hobj->SetMinimum(fXmin);
            hobj->SetMaximum(fXmax);
         } else {
            hobj->SetMinimum();
            hobj->SetMaximum();
            hobj->ResetBit(TH1::kIsZoomed);
         }
      } else {
         hobj->GetXaxis()->SetRange(0,0);
      }
   }
}

//______________________________________________________________________________
void TAxis::ZoomOut(Double_t factor, Double_t offset)
{
   // Zoom out by a factor of 'factor' (default =2)
   //   uses previous zoom factor by default
   // Keep center defined by 'offset' fixed
   //   ie. -1 at left of current range, 0 in center, +1 at right


   if (factor <= 0) factor = 2;
   Double_t center = (GetFirst()*(1-offset) + GetLast()*(1+offset))/2.;
   Int_t first = int(TMath::Floor(center+(GetFirst()-center)*factor + 0.4999999));
   Int_t last  = int(TMath::Floor(center+(GetLast() -center)*factor + 0.5000001));
   if (first==GetFirst() && last==GetLast()) { first--; last++; }
   SetRange(first,last);
}
 TAxis.cxx:1
 TAxis.cxx:2
 TAxis.cxx:3
 TAxis.cxx:4
 TAxis.cxx:5
 TAxis.cxx:6
 TAxis.cxx:7
 TAxis.cxx:8
 TAxis.cxx:9
 TAxis.cxx:10
 TAxis.cxx:11
 TAxis.cxx:12
 TAxis.cxx:13
 TAxis.cxx:14
 TAxis.cxx:15
 TAxis.cxx:16
 TAxis.cxx:17
 TAxis.cxx:18
 TAxis.cxx:19
 TAxis.cxx:20
 TAxis.cxx:21
 TAxis.cxx:22
 TAxis.cxx:23
 TAxis.cxx:24
 TAxis.cxx:25
 TAxis.cxx:26
 TAxis.cxx:27
 TAxis.cxx:28
 TAxis.cxx:29
 TAxis.cxx:30
 TAxis.cxx:31
 TAxis.cxx:32
 TAxis.cxx:33
 TAxis.cxx:34
 TAxis.cxx:35
 TAxis.cxx:36
 TAxis.cxx:37
 TAxis.cxx:38
 TAxis.cxx:39
 TAxis.cxx:40
 TAxis.cxx:41
 TAxis.cxx:42
 TAxis.cxx:43
 TAxis.cxx:44
 TAxis.cxx:45
 TAxis.cxx:46
 TAxis.cxx:47
 TAxis.cxx:48
 TAxis.cxx:49
 TAxis.cxx:50
 TAxis.cxx:51
 TAxis.cxx:52
 TAxis.cxx:53
 TAxis.cxx:54
 TAxis.cxx:55
 TAxis.cxx:56
 TAxis.cxx:57
 TAxis.cxx:58
 TAxis.cxx:59
 TAxis.cxx:60
 TAxis.cxx:61
 TAxis.cxx:62
 TAxis.cxx:63
 TAxis.cxx:64
 TAxis.cxx:65
 TAxis.cxx:66
 TAxis.cxx:67
 TAxis.cxx:68
 TAxis.cxx:69
 TAxis.cxx:70
 TAxis.cxx:71
 TAxis.cxx:72
 TAxis.cxx:73
 TAxis.cxx:74
 TAxis.cxx:75
 TAxis.cxx:76
 TAxis.cxx:77
 TAxis.cxx:78
 TAxis.cxx:79
 TAxis.cxx:80
 TAxis.cxx:81
 TAxis.cxx:82
 TAxis.cxx:83
 TAxis.cxx:84
 TAxis.cxx:85
 TAxis.cxx:86
 TAxis.cxx:87
 TAxis.cxx:88
 TAxis.cxx:89
 TAxis.cxx:90
 TAxis.cxx:91
 TAxis.cxx:92
 TAxis.cxx:93
 TAxis.cxx:94
 TAxis.cxx:95
 TAxis.cxx:96
 TAxis.cxx:97
 TAxis.cxx:98
 TAxis.cxx:99
 TAxis.cxx:100
 TAxis.cxx:101
 TAxis.cxx:102
 TAxis.cxx:103
 TAxis.cxx:104
 TAxis.cxx:105
 TAxis.cxx:106
 TAxis.cxx:107
 TAxis.cxx:108
 TAxis.cxx:109
 TAxis.cxx:110
 TAxis.cxx:111
 TAxis.cxx:112
 TAxis.cxx:113
 TAxis.cxx:114
 TAxis.cxx:115
 TAxis.cxx:116
 TAxis.cxx:117
 TAxis.cxx:118
 TAxis.cxx:119
 TAxis.cxx:120
 TAxis.cxx:121
 TAxis.cxx:122
 TAxis.cxx:123
 TAxis.cxx:124
 TAxis.cxx:125
 TAxis.cxx:126
 TAxis.cxx:127
 TAxis.cxx:128
 TAxis.cxx:129
 TAxis.cxx:130
 TAxis.cxx:131
 TAxis.cxx:132
 TAxis.cxx:133
 TAxis.cxx:134
 TAxis.cxx:135
 TAxis.cxx:136
 TAxis.cxx:137
 TAxis.cxx:138
 TAxis.cxx:139
 TAxis.cxx:140
 TAxis.cxx:141
 TAxis.cxx:142
 TAxis.cxx:143
 TAxis.cxx:144
 TAxis.cxx:145
 TAxis.cxx:146
 TAxis.cxx:147
 TAxis.cxx:148
 TAxis.cxx:149
 TAxis.cxx:150
 TAxis.cxx:151
 TAxis.cxx:152
 TAxis.cxx:153
 TAxis.cxx:154
 TAxis.cxx:155
 TAxis.cxx:156
 TAxis.cxx:157
 TAxis.cxx:158
 TAxis.cxx:159
 TAxis.cxx:160
 TAxis.cxx:161
 TAxis.cxx:162
 TAxis.cxx:163
 TAxis.cxx:164
 TAxis.cxx:165
 TAxis.cxx:166
 TAxis.cxx:167
 TAxis.cxx:168
 TAxis.cxx:169
 TAxis.cxx:170
 TAxis.cxx:171
 TAxis.cxx:172
 TAxis.cxx:173
 TAxis.cxx:174
 TAxis.cxx:175
 TAxis.cxx:176
 TAxis.cxx:177
 TAxis.cxx:178
 TAxis.cxx:179
 TAxis.cxx:180
 TAxis.cxx:181
 TAxis.cxx:182
 TAxis.cxx:183
 TAxis.cxx:184
 TAxis.cxx:185
 TAxis.cxx:186
 TAxis.cxx:187
 TAxis.cxx:188
 TAxis.cxx:189
 TAxis.cxx:190
 TAxis.cxx:191
 TAxis.cxx:192
 TAxis.cxx:193
 TAxis.cxx:194
 TAxis.cxx:195
 TAxis.cxx:196
 TAxis.cxx:197
 TAxis.cxx:198
 TAxis.cxx:199
 TAxis.cxx:200
 TAxis.cxx:201
 TAxis.cxx:202
 TAxis.cxx:203
 TAxis.cxx:204
 TAxis.cxx:205
 TAxis.cxx:206
 TAxis.cxx:207
 TAxis.cxx:208
 TAxis.cxx:209
 TAxis.cxx:210
 TAxis.cxx:211
 TAxis.cxx:212
 TAxis.cxx:213
 TAxis.cxx:214
 TAxis.cxx:215
 TAxis.cxx:216
 TAxis.cxx:217
 TAxis.cxx:218
 TAxis.cxx:219
 TAxis.cxx:220
 TAxis.cxx:221
 TAxis.cxx:222
 TAxis.cxx:223
 TAxis.cxx:224
 TAxis.cxx:225
 TAxis.cxx:226
 TAxis.cxx:227
 TAxis.cxx:228
 TAxis.cxx:229
 TAxis.cxx:230
 TAxis.cxx:231
 TAxis.cxx:232
 TAxis.cxx:233
 TAxis.cxx:234
 TAxis.cxx:235
 TAxis.cxx:236
 TAxis.cxx:237
 TAxis.cxx:238
 TAxis.cxx:239
 TAxis.cxx:240
 TAxis.cxx:241
 TAxis.cxx:242
 TAxis.cxx:243
 TAxis.cxx:244
 TAxis.cxx:245
 TAxis.cxx:246
 TAxis.cxx:247
 TAxis.cxx:248
 TAxis.cxx:249
 TAxis.cxx:250
 TAxis.cxx:251
 TAxis.cxx:252
 TAxis.cxx:253
 TAxis.cxx:254
 TAxis.cxx:255
 TAxis.cxx:256
 TAxis.cxx:257
 TAxis.cxx:258
 TAxis.cxx:259
 TAxis.cxx:260
 TAxis.cxx:261
 TAxis.cxx:262
 TAxis.cxx:263
 TAxis.cxx:264
 TAxis.cxx:265
 TAxis.cxx:266
 TAxis.cxx:267
 TAxis.cxx:268
 TAxis.cxx:269
 TAxis.cxx:270
 TAxis.cxx:271
 TAxis.cxx:272
 TAxis.cxx:273
 TAxis.cxx:274
 TAxis.cxx:275
 TAxis.cxx:276
 TAxis.cxx:277
 TAxis.cxx:278
 TAxis.cxx:279
 TAxis.cxx:280
 TAxis.cxx:281
 TAxis.cxx:282
 TAxis.cxx:283
 TAxis.cxx:284
 TAxis.cxx:285
 TAxis.cxx:286
 TAxis.cxx:287
 TAxis.cxx:288
 TAxis.cxx:289
 TAxis.cxx:290
 TAxis.cxx:291
 TAxis.cxx:292
 TAxis.cxx:293
 TAxis.cxx:294
 TAxis.cxx:295
 TAxis.cxx:296
 TAxis.cxx:297
 TAxis.cxx:298
 TAxis.cxx:299
 TAxis.cxx:300
 TAxis.cxx:301
 TAxis.cxx:302
 TAxis.cxx:303
 TAxis.cxx:304
 TAxis.cxx:305
 TAxis.cxx:306
 TAxis.cxx:307
 TAxis.cxx:308
 TAxis.cxx:309
 TAxis.cxx:310
 TAxis.cxx:311
 TAxis.cxx:312
 TAxis.cxx:313
 TAxis.cxx:314
 TAxis.cxx:315
 TAxis.cxx:316
 TAxis.cxx:317
 TAxis.cxx:318
 TAxis.cxx:319
 TAxis.cxx:320
 TAxis.cxx:321
 TAxis.cxx:322
 TAxis.cxx:323
 TAxis.cxx:324
 TAxis.cxx:325
 TAxis.cxx:326
 TAxis.cxx:327
 TAxis.cxx:328
 TAxis.cxx:329
 TAxis.cxx:330
 TAxis.cxx:331
 TAxis.cxx:332
 TAxis.cxx:333
 TAxis.cxx:334
 TAxis.cxx:335
 TAxis.cxx:336
 TAxis.cxx:337
 TAxis.cxx:338
 TAxis.cxx:339
 TAxis.cxx:340
 TAxis.cxx:341
 TAxis.cxx:342
 TAxis.cxx:343
 TAxis.cxx:344
 TAxis.cxx:345
 TAxis.cxx:346
 TAxis.cxx:347
 TAxis.cxx:348
 TAxis.cxx:349
 TAxis.cxx:350
 TAxis.cxx:351
 TAxis.cxx:352
 TAxis.cxx:353
 TAxis.cxx:354
 TAxis.cxx:355
 TAxis.cxx:356
 TAxis.cxx:357
 TAxis.cxx:358
 TAxis.cxx:359
 TAxis.cxx:360
 TAxis.cxx:361
 TAxis.cxx:362
 TAxis.cxx:363
 TAxis.cxx:364
 TAxis.cxx:365
 TAxis.cxx:366
 TAxis.cxx:367
 TAxis.cxx:368
 TAxis.cxx:369
 TAxis.cxx:370
 TAxis.cxx:371
 TAxis.cxx:372
 TAxis.cxx:373
 TAxis.cxx:374
 TAxis.cxx:375
 TAxis.cxx:376
 TAxis.cxx:377
 TAxis.cxx:378
 TAxis.cxx:379
 TAxis.cxx:380
 TAxis.cxx:381
 TAxis.cxx:382
 TAxis.cxx:383
 TAxis.cxx:384
 TAxis.cxx:385
 TAxis.cxx:386
 TAxis.cxx:387
 TAxis.cxx:388
 TAxis.cxx:389
 TAxis.cxx:390
 TAxis.cxx:391
 TAxis.cxx:392
 TAxis.cxx:393
 TAxis.cxx:394
 TAxis.cxx:395
 TAxis.cxx:396
 TAxis.cxx:397
 TAxis.cxx:398
 TAxis.cxx:399
 TAxis.cxx:400
 TAxis.cxx:401
 TAxis.cxx:402
 TAxis.cxx:403
 TAxis.cxx:404
 TAxis.cxx:405
 TAxis.cxx:406
 TAxis.cxx:407
 TAxis.cxx:408
 TAxis.cxx:409
 TAxis.cxx:410
 TAxis.cxx:411
 TAxis.cxx:412
 TAxis.cxx:413
 TAxis.cxx:414
 TAxis.cxx:415
 TAxis.cxx:416
 TAxis.cxx:417
 TAxis.cxx:418
 TAxis.cxx:419
 TAxis.cxx:420
 TAxis.cxx:421
 TAxis.cxx:422
 TAxis.cxx:423
 TAxis.cxx:424
 TAxis.cxx:425
 TAxis.cxx:426
 TAxis.cxx:427
 TAxis.cxx:428
 TAxis.cxx:429
 TAxis.cxx:430
 TAxis.cxx:431
 TAxis.cxx:432
 TAxis.cxx:433
 TAxis.cxx:434
 TAxis.cxx:435
 TAxis.cxx:436
 TAxis.cxx:437
 TAxis.cxx:438
 TAxis.cxx:439
 TAxis.cxx:440
 TAxis.cxx:441
 TAxis.cxx:442
 TAxis.cxx:443
 TAxis.cxx:444
 TAxis.cxx:445
 TAxis.cxx:446
 TAxis.cxx:447
 TAxis.cxx:448
 TAxis.cxx:449
 TAxis.cxx:450
 TAxis.cxx:451
 TAxis.cxx:452
 TAxis.cxx:453
 TAxis.cxx:454
 TAxis.cxx:455
 TAxis.cxx:456
 TAxis.cxx:457
 TAxis.cxx:458
 TAxis.cxx:459
 TAxis.cxx:460
 TAxis.cxx:461
 TAxis.cxx:462
 TAxis.cxx:463
 TAxis.cxx:464
 TAxis.cxx:465
 TAxis.cxx:466
 TAxis.cxx:467
 TAxis.cxx:468
 TAxis.cxx:469
 TAxis.cxx:470
 TAxis.cxx:471
 TAxis.cxx:472
 TAxis.cxx:473
 TAxis.cxx:474
 TAxis.cxx:475
 TAxis.cxx:476
 TAxis.cxx:477
 TAxis.cxx:478
 TAxis.cxx:479
 TAxis.cxx:480
 TAxis.cxx:481
 TAxis.cxx:482
 TAxis.cxx:483
 TAxis.cxx:484
 TAxis.cxx:485
 TAxis.cxx:486
 TAxis.cxx:487
 TAxis.cxx:488
 TAxis.cxx:489
 TAxis.cxx:490
 TAxis.cxx:491
 TAxis.cxx:492
 TAxis.cxx:493
 TAxis.cxx:494
 TAxis.cxx:495
 TAxis.cxx:496
 TAxis.cxx:497
 TAxis.cxx:498
 TAxis.cxx:499
 TAxis.cxx:500
 TAxis.cxx:501
 TAxis.cxx:502
 TAxis.cxx:503
 TAxis.cxx:504
 TAxis.cxx:505
 TAxis.cxx:506
 TAxis.cxx:507
 TAxis.cxx:508
 TAxis.cxx:509
 TAxis.cxx:510
 TAxis.cxx:511
 TAxis.cxx:512
 TAxis.cxx:513
 TAxis.cxx:514
 TAxis.cxx:515
 TAxis.cxx:516
 TAxis.cxx:517
 TAxis.cxx:518
 TAxis.cxx:519
 TAxis.cxx:520
 TAxis.cxx:521
 TAxis.cxx:522
 TAxis.cxx:523
 TAxis.cxx:524
 TAxis.cxx:525
 TAxis.cxx:526
 TAxis.cxx:527
 TAxis.cxx:528
 TAxis.cxx:529
 TAxis.cxx:530
 TAxis.cxx:531
 TAxis.cxx:532
 TAxis.cxx:533
 TAxis.cxx:534
 TAxis.cxx:535
 TAxis.cxx:536
 TAxis.cxx:537
 TAxis.cxx:538
 TAxis.cxx:539
 TAxis.cxx:540
 TAxis.cxx:541
 TAxis.cxx:542
 TAxis.cxx:543
 TAxis.cxx:544
 TAxis.cxx:545
 TAxis.cxx:546
 TAxis.cxx:547
 TAxis.cxx:548
 TAxis.cxx:549
 TAxis.cxx:550
 TAxis.cxx:551
 TAxis.cxx:552
 TAxis.cxx:553
 TAxis.cxx:554
 TAxis.cxx:555
 TAxis.cxx:556
 TAxis.cxx:557
 TAxis.cxx:558
 TAxis.cxx:559
 TAxis.cxx:560
 TAxis.cxx:561
 TAxis.cxx:562
 TAxis.cxx:563
 TAxis.cxx:564
 TAxis.cxx:565
 TAxis.cxx:566
 TAxis.cxx:567
 TAxis.cxx:568
 TAxis.cxx:569
 TAxis.cxx:570
 TAxis.cxx:571
 TAxis.cxx:572
 TAxis.cxx:573
 TAxis.cxx:574
 TAxis.cxx:575
 TAxis.cxx:576
 TAxis.cxx:577
 TAxis.cxx:578
 TAxis.cxx:579
 TAxis.cxx:580
 TAxis.cxx:581
 TAxis.cxx:582
 TAxis.cxx:583
 TAxis.cxx:584
 TAxis.cxx:585
 TAxis.cxx:586
 TAxis.cxx:587
 TAxis.cxx:588
 TAxis.cxx:589
 TAxis.cxx:590
 TAxis.cxx:591
 TAxis.cxx:592
 TAxis.cxx:593
 TAxis.cxx:594
 TAxis.cxx:595
 TAxis.cxx:596
 TAxis.cxx:597
 TAxis.cxx:598
 TAxis.cxx:599
 TAxis.cxx:600
 TAxis.cxx:601
 TAxis.cxx:602
 TAxis.cxx:603
 TAxis.cxx:604
 TAxis.cxx:605
 TAxis.cxx:606
 TAxis.cxx:607
 TAxis.cxx:608
 TAxis.cxx:609
 TAxis.cxx:610
 TAxis.cxx:611
 TAxis.cxx:612
 TAxis.cxx:613
 TAxis.cxx:614
 TAxis.cxx:615
 TAxis.cxx:616
 TAxis.cxx:617
 TAxis.cxx:618
 TAxis.cxx:619
 TAxis.cxx:620
 TAxis.cxx:621
 TAxis.cxx:622
 TAxis.cxx:623
 TAxis.cxx:624
 TAxis.cxx:625
 TAxis.cxx:626
 TAxis.cxx:627
 TAxis.cxx:628
 TAxis.cxx:629
 TAxis.cxx:630
 TAxis.cxx:631
 TAxis.cxx:632
 TAxis.cxx:633
 TAxis.cxx:634
 TAxis.cxx:635
 TAxis.cxx:636
 TAxis.cxx:637
 TAxis.cxx:638
 TAxis.cxx:639
 TAxis.cxx:640
 TAxis.cxx:641
 TAxis.cxx:642
 TAxis.cxx:643
 TAxis.cxx:644
 TAxis.cxx:645
 TAxis.cxx:646
 TAxis.cxx:647
 TAxis.cxx:648
 TAxis.cxx:649
 TAxis.cxx:650
 TAxis.cxx:651
 TAxis.cxx:652
 TAxis.cxx:653
 TAxis.cxx:654
 TAxis.cxx:655
 TAxis.cxx:656
 TAxis.cxx:657
 TAxis.cxx:658
 TAxis.cxx:659
 TAxis.cxx:660
 TAxis.cxx:661
 TAxis.cxx:662
 TAxis.cxx:663
 TAxis.cxx:664
 TAxis.cxx:665
 TAxis.cxx:666
 TAxis.cxx:667
 TAxis.cxx:668
 TAxis.cxx:669
 TAxis.cxx:670
 TAxis.cxx:671
 TAxis.cxx:672
 TAxis.cxx:673
 TAxis.cxx:674
 TAxis.cxx:675
 TAxis.cxx:676
 TAxis.cxx:677
 TAxis.cxx:678
 TAxis.cxx:679
 TAxis.cxx:680
 TAxis.cxx:681
 TAxis.cxx:682
 TAxis.cxx:683
 TAxis.cxx:684
 TAxis.cxx:685
 TAxis.cxx:686
 TAxis.cxx:687
 TAxis.cxx:688
 TAxis.cxx:689
 TAxis.cxx:690
 TAxis.cxx:691
 TAxis.cxx:692
 TAxis.cxx:693
 TAxis.cxx:694
 TAxis.cxx:695
 TAxis.cxx:696
 TAxis.cxx:697
 TAxis.cxx:698
 TAxis.cxx:699
 TAxis.cxx:700
 TAxis.cxx:701
 TAxis.cxx:702
 TAxis.cxx:703
 TAxis.cxx:704
 TAxis.cxx:705
 TAxis.cxx:706
 TAxis.cxx:707
 TAxis.cxx:708
 TAxis.cxx:709
 TAxis.cxx:710
 TAxis.cxx:711
 TAxis.cxx:712
 TAxis.cxx:713
 TAxis.cxx:714
 TAxis.cxx:715
 TAxis.cxx:716
 TAxis.cxx:717
 TAxis.cxx:718
 TAxis.cxx:719
 TAxis.cxx:720
 TAxis.cxx:721
 TAxis.cxx:722
 TAxis.cxx:723
 TAxis.cxx:724
 TAxis.cxx:725
 TAxis.cxx:726
 TAxis.cxx:727
 TAxis.cxx:728
 TAxis.cxx:729
 TAxis.cxx:730
 TAxis.cxx:731
 TAxis.cxx:732
 TAxis.cxx:733
 TAxis.cxx:734
 TAxis.cxx:735
 TAxis.cxx:736
 TAxis.cxx:737
 TAxis.cxx:738
 TAxis.cxx:739
 TAxis.cxx:740
 TAxis.cxx:741
 TAxis.cxx:742
 TAxis.cxx:743
 TAxis.cxx:744
 TAxis.cxx:745
 TAxis.cxx:746
 TAxis.cxx:747
 TAxis.cxx:748
 TAxis.cxx:749
 TAxis.cxx:750
 TAxis.cxx:751
 TAxis.cxx:752
 TAxis.cxx:753
 TAxis.cxx:754
 TAxis.cxx:755
 TAxis.cxx:756
 TAxis.cxx:757
 TAxis.cxx:758
 TAxis.cxx:759
 TAxis.cxx:760
 TAxis.cxx:761
 TAxis.cxx:762
 TAxis.cxx:763
 TAxis.cxx:764
 TAxis.cxx:765
 TAxis.cxx:766
 TAxis.cxx:767
 TAxis.cxx:768
 TAxis.cxx:769
 TAxis.cxx:770
 TAxis.cxx:771
 TAxis.cxx:772
 TAxis.cxx:773
 TAxis.cxx:774
 TAxis.cxx:775
 TAxis.cxx:776
 TAxis.cxx:777
 TAxis.cxx:778
 TAxis.cxx:779
 TAxis.cxx:780
 TAxis.cxx:781
 TAxis.cxx:782
 TAxis.cxx:783
 TAxis.cxx:784
 TAxis.cxx:785
 TAxis.cxx:786
 TAxis.cxx:787
 TAxis.cxx:788
 TAxis.cxx:789
 TAxis.cxx:790
 TAxis.cxx:791
 TAxis.cxx:792
 TAxis.cxx:793
 TAxis.cxx:794
 TAxis.cxx:795
 TAxis.cxx:796
 TAxis.cxx:797
 TAxis.cxx:798
 TAxis.cxx:799
 TAxis.cxx:800
 TAxis.cxx:801
 TAxis.cxx:802
 TAxis.cxx:803
 TAxis.cxx:804
 TAxis.cxx:805
 TAxis.cxx:806
 TAxis.cxx:807
 TAxis.cxx:808
 TAxis.cxx:809
 TAxis.cxx:810
 TAxis.cxx:811
 TAxis.cxx:812
 TAxis.cxx:813
 TAxis.cxx:814
 TAxis.cxx:815
 TAxis.cxx:816
 TAxis.cxx:817
 TAxis.cxx:818
 TAxis.cxx:819
 TAxis.cxx:820
 TAxis.cxx:821
 TAxis.cxx:822
 TAxis.cxx:823
 TAxis.cxx:824
 TAxis.cxx:825
 TAxis.cxx:826
 TAxis.cxx:827
 TAxis.cxx:828
 TAxis.cxx:829
 TAxis.cxx:830
 TAxis.cxx:831
 TAxis.cxx:832
 TAxis.cxx:833
 TAxis.cxx:834
 TAxis.cxx:835
 TAxis.cxx:836
 TAxis.cxx:837
 TAxis.cxx:838
 TAxis.cxx:839
 TAxis.cxx:840
 TAxis.cxx:841
 TAxis.cxx:842
 TAxis.cxx:843
 TAxis.cxx:844
 TAxis.cxx:845
 TAxis.cxx:846
 TAxis.cxx:847
 TAxis.cxx:848
 TAxis.cxx:849
 TAxis.cxx:850
 TAxis.cxx:851
 TAxis.cxx:852
 TAxis.cxx:853
 TAxis.cxx:854
 TAxis.cxx:855
 TAxis.cxx:856
 TAxis.cxx:857
 TAxis.cxx:858
 TAxis.cxx:859
 TAxis.cxx:860
 TAxis.cxx:861
 TAxis.cxx:862
 TAxis.cxx:863
 TAxis.cxx:864
 TAxis.cxx:865
 TAxis.cxx:866
 TAxis.cxx:867
 TAxis.cxx:868
 TAxis.cxx:869
 TAxis.cxx:870
 TAxis.cxx:871
 TAxis.cxx:872
 TAxis.cxx:873
 TAxis.cxx:874
 TAxis.cxx:875
 TAxis.cxx:876
 TAxis.cxx:877
 TAxis.cxx:878
 TAxis.cxx:879
 TAxis.cxx:880
 TAxis.cxx:881
 TAxis.cxx:882
 TAxis.cxx:883
 TAxis.cxx:884
 TAxis.cxx:885
 TAxis.cxx:886
 TAxis.cxx:887
 TAxis.cxx:888
 TAxis.cxx:889
 TAxis.cxx:890
 TAxis.cxx:891
 TAxis.cxx:892
 TAxis.cxx:893
 TAxis.cxx:894
 TAxis.cxx:895
 TAxis.cxx:896
 TAxis.cxx:897
 TAxis.cxx:898
 TAxis.cxx:899
 TAxis.cxx:900
 TAxis.cxx:901
 TAxis.cxx:902
 TAxis.cxx:903
 TAxis.cxx:904
 TAxis.cxx:905
 TAxis.cxx:906
 TAxis.cxx:907
 TAxis.cxx:908
 TAxis.cxx:909
 TAxis.cxx:910
 TAxis.cxx:911
 TAxis.cxx:912
 TAxis.cxx:913
 TAxis.cxx:914
 TAxis.cxx:915
 TAxis.cxx:916
 TAxis.cxx:917
 TAxis.cxx:918
 TAxis.cxx:919
 TAxis.cxx:920
 TAxis.cxx:921
 TAxis.cxx:922
 TAxis.cxx:923
 TAxis.cxx:924
 TAxis.cxx:925
 TAxis.cxx:926
 TAxis.cxx:927
 TAxis.cxx:928
 TAxis.cxx:929
 TAxis.cxx:930
 TAxis.cxx:931
 TAxis.cxx:932
 TAxis.cxx:933
 TAxis.cxx:934
 TAxis.cxx:935
 TAxis.cxx:936
 TAxis.cxx:937
 TAxis.cxx:938
 TAxis.cxx:939
 TAxis.cxx:940
 TAxis.cxx:941
 TAxis.cxx:942
 TAxis.cxx:943
 TAxis.cxx:944
 TAxis.cxx:945
 TAxis.cxx:946
 TAxis.cxx:947
 TAxis.cxx:948
 TAxis.cxx:949
 TAxis.cxx:950
 TAxis.cxx:951
 TAxis.cxx:952
 TAxis.cxx:953
 TAxis.cxx:954
 TAxis.cxx:955
 TAxis.cxx:956
 TAxis.cxx:957
 TAxis.cxx:958
 TAxis.cxx:959
 TAxis.cxx:960
 TAxis.cxx:961
 TAxis.cxx:962
 TAxis.cxx:963
 TAxis.cxx:964
 TAxis.cxx:965
 TAxis.cxx:966
 TAxis.cxx:967
 TAxis.cxx:968
 TAxis.cxx:969
 TAxis.cxx:970
 TAxis.cxx:971
 TAxis.cxx:972
 TAxis.cxx:973
 TAxis.cxx:974
 TAxis.cxx:975
 TAxis.cxx:976
 TAxis.cxx:977
 TAxis.cxx:978
 TAxis.cxx:979
 TAxis.cxx:980
 TAxis.cxx:981
 TAxis.cxx:982
 TAxis.cxx:983
 TAxis.cxx:984
 TAxis.cxx:985
 TAxis.cxx:986
 TAxis.cxx:987
 TAxis.cxx:988
 TAxis.cxx:989
 TAxis.cxx:990
 TAxis.cxx:991
 TAxis.cxx:992
 TAxis.cxx:993
 TAxis.cxx:994
 TAxis.cxx:995
 TAxis.cxx:996
 TAxis.cxx:997
 TAxis.cxx:998
 TAxis.cxx:999
 TAxis.cxx:1000
 TAxis.cxx:1001
 TAxis.cxx:1002
 TAxis.cxx:1003
 TAxis.cxx:1004
 TAxis.cxx:1005
 TAxis.cxx:1006
 TAxis.cxx:1007
 TAxis.cxx:1008
 TAxis.cxx:1009
 TAxis.cxx:1010
 TAxis.cxx:1011
 TAxis.cxx:1012
 TAxis.cxx:1013
 TAxis.cxx:1014
 TAxis.cxx:1015
 TAxis.cxx:1016
 TAxis.cxx:1017
 TAxis.cxx:1018
 TAxis.cxx:1019
 TAxis.cxx:1020
 TAxis.cxx:1021
 TAxis.cxx:1022
 TAxis.cxx:1023
 TAxis.cxx:1024
 TAxis.cxx:1025
 TAxis.cxx:1026
 TAxis.cxx:1027
 TAxis.cxx:1028
 TAxis.cxx:1029
 TAxis.cxx:1030
 TAxis.cxx:1031
 TAxis.cxx:1032
 TAxis.cxx:1033
 TAxis.cxx:1034
 TAxis.cxx:1035
 TAxis.cxx:1036
 TAxis.cxx:1037
 TAxis.cxx:1038
 TAxis.cxx:1039
 TAxis.cxx:1040
 TAxis.cxx:1041
 TAxis.cxx:1042
 TAxis.cxx:1043
 TAxis.cxx:1044
 TAxis.cxx:1045
 TAxis.cxx:1046
 TAxis.cxx:1047
 TAxis.cxx:1048
 TAxis.cxx:1049
 TAxis.cxx:1050
 TAxis.cxx:1051
 TAxis.cxx:1052
 TAxis.cxx:1053
 TAxis.cxx:1054
 TAxis.cxx:1055
 TAxis.cxx:1056
 TAxis.cxx:1057
 TAxis.cxx:1058
 TAxis.cxx:1059
 TAxis.cxx:1060
 TAxis.cxx:1061
 TAxis.cxx:1062
 TAxis.cxx:1063
 TAxis.cxx:1064
 TAxis.cxx:1065
 TAxis.cxx:1066
 TAxis.cxx:1067
 TAxis.cxx:1068
 TAxis.cxx:1069
 TAxis.cxx:1070
 TAxis.cxx:1071
 TAxis.cxx:1072
 TAxis.cxx:1073
 TAxis.cxx:1074
 TAxis.cxx:1075
 TAxis.cxx:1076
 TAxis.cxx:1077
 TAxis.cxx:1078
 TAxis.cxx:1079
 TAxis.cxx:1080
 TAxis.cxx:1081
 TAxis.cxx:1082
 TAxis.cxx:1083
 TAxis.cxx:1084
 TAxis.cxx:1085
 TAxis.cxx:1086
 TAxis.cxx:1087
 TAxis.cxx:1088
 TAxis.cxx:1089
 TAxis.cxx:1090
 TAxis.cxx:1091
 TAxis.cxx:1092
 TAxis.cxx:1093
 TAxis.cxx:1094
 TAxis.cxx:1095
 TAxis.cxx:1096
 TAxis.cxx:1097
 TAxis.cxx:1098
 TAxis.cxx:1099
 TAxis.cxx:1100
 TAxis.cxx:1101
 TAxis.cxx:1102
 TAxis.cxx:1103
 TAxis.cxx:1104
 TAxis.cxx:1105
 TAxis.cxx:1106
 TAxis.cxx:1107
 TAxis.cxx:1108
 TAxis.cxx:1109
 TAxis.cxx:1110
 TAxis.cxx:1111
 TAxis.cxx:1112
 TAxis.cxx:1113
 TAxis.cxx:1114
 TAxis.cxx:1115
 TAxis.cxx:1116
 TAxis.cxx:1117
 TAxis.cxx:1118
 TAxis.cxx:1119
 TAxis.cxx:1120
 TAxis.cxx:1121
 TAxis.cxx:1122
 TAxis.cxx:1123
 TAxis.cxx:1124
 TAxis.cxx:1125
 TAxis.cxx:1126
 TAxis.cxx:1127
 TAxis.cxx:1128
 TAxis.cxx:1129
 TAxis.cxx:1130
 TAxis.cxx:1131
 TAxis.cxx:1132
 TAxis.cxx:1133
 TAxis.cxx:1134
 TAxis.cxx:1135
 TAxis.cxx:1136
 TAxis.cxx:1137
 TAxis.cxx:1138
 TAxis.cxx:1139
 TAxis.cxx:1140
 TAxis.cxx:1141
 TAxis.cxx:1142
 TAxis.cxx:1143
 TAxis.cxx:1144
 TAxis.cxx:1145
 TAxis.cxx:1146
 TAxis.cxx:1147
 TAxis.cxx:1148
 TAxis.cxx:1149
 TAxis.cxx:1150
 TAxis.cxx:1151
 TAxis.cxx:1152
 TAxis.cxx:1153
 TAxis.cxx:1154
 TAxis.cxx:1155
 TAxis.cxx:1156
 TAxis.cxx:1157
 TAxis.cxx:1158
 TAxis.cxx:1159
 TAxis.cxx:1160
 TAxis.cxx:1161
 TAxis.cxx:1162
 TAxis.cxx:1163
 TAxis.cxx:1164
 TAxis.cxx:1165
 TAxis.cxx:1166
 TAxis.cxx:1167
 TAxis.cxx:1168
 TAxis.cxx:1169
 TAxis.cxx:1170