ROOT logo
// @(#)root/treeplayer:$Id$
// Author: Rene Brun   08/01/2003

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TSelectorDraw                                                        //
//                                                                      //
// A specialized TSelector for TTree::Draw.                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TSelectorDraw.h"
#include "TROOT.h"
#include "TH2.h"
#include "TH3.h"
#include "TView.h"
#include "TGraph.h"
#include "TPolyMarker3D.h"
#include "TDirectory.h"
#include "TVirtualPad.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TTreeFormulaManager.h"
#include "TEnv.h"
#include "TTree.h"
#include "TCut.h"
#include "TEntryList.h"
#include "TEventList.h"
#include "TEntryListArray.h"
#include "THLimitsFinder.h"
#include "TStyle.h"
#include "TClass.h"
#include "TColor.h"

ClassImp(TSelectorDraw)

const Int_t kCustomHistogram = BIT(17);

//______________________________________________________________________________
TSelectorDraw::TSelectorDraw()
{
   // Default selector constructor.

   fTree           = 0;
   fW              = 0;
   fValSize        = 4;
   fVal            = new Double_t*[fValSize];
   fVmin           = new Double_t[fValSize];
   fVmax           = new Double_t[fValSize];
   fNbins          = new Int_t[fValSize];
   fVarMultiple    = new Bool_t[fValSize];
   fVar            = new TTreeFormula*[fValSize];
   for (Int_t i = 0; i < fValSize; ++i) {
      fVal[i] = 0;
      fVar[i] = 0;
   }
   fManager        = 0;
   fMultiplicity   = 0;
   fSelect         = 0;
   fSelectedRows   = 0;
   fDraw           = 0;
   fObject         = 0;
   fOldHistogram   = 0;
   fObjEval        = kFALSE;
   fSelectMultiple = kFALSE;
   fCleanElist     = kFALSE;
   fTreeElist      = 0;
   fAction         = 0;
   fNfill          = 0;
   fDimension      = 0;
   fOldEstimate    = 0;
   fForceRead      = 0;
   fWeight         = 1;
   fCurrentSubEntry = -1;
   fTreeElistArray  = 0;
}

//______________________________________________________________________________
TSelectorDraw::~TSelectorDraw()
{
   // Selector destructor.

   ClearFormula();
   delete [] fVar;
   if (fVal) {
      for (Int_t i = 0; i < fValSize; ++i)
         delete [] fVal[i];
      delete [] fVal;
   }
   if (fVmin) delete [] fVmin;
   if (fVmax) delete [] fVmax;
   if (fNbins) delete [] fNbins;
   if (fVarMultiple) delete [] fVarMultiple;
   if (fW)     delete [] fW;
}

//______________________________________________________________________________
void TSelectorDraw::Begin(TTree *tree)
{
   // Called everytime a loop on the tree(s) starts.

   SetStatus(0);
   ResetAbort();
   ResetBit(kCustomHistogram);
   fSelectedRows   = 0;
   fTree = tree;
   fDimension = 0;
   fAction = 0;

   TObject *obj = fInput->FindObject("varexp");
   const char *varexp0   = obj ? obj->GetTitle() : "";
   obj = fInput->FindObject("selection");
   const char *selection = obj ? obj->GetTitle() : "";
   const char *option    = GetOption();

   TString  opt, abrt;
   char *hdefault = (char *)"htemp";
   char *varexp;
   Int_t i, j, hkeep;
   opt = option;
   opt.ToLower();
   fOldHistogram = 0;
   TEntryList *enlist = 0;
   TEventList *evlist = 0;
   TString htitle;
   Bool_t profile = kFALSE;
   Bool_t optSame = kFALSE;
   Bool_t optEnlist = kFALSE;
   Bool_t optEnlistArray = kFALSE;
   Bool_t optpara = kFALSE;
   Bool_t optcandle = kFALSE;
   Bool_t opt5d = kFALSE;
   if (opt.Contains("same")) {
      optSame = kTRUE;
      opt.ReplaceAll("same", "");
   }
   if (opt.Contains("entrylist")) {
      optEnlist = kTRUE;
      if (opt.Contains("entrylistarray")) {
         optEnlistArray = kTRUE;
         opt.ReplaceAll("entrylistarray", "");
      } else {
         opt.ReplaceAll("entrylist", "");
      }
   }
   if (opt.Contains("para")) {
      optpara = kTRUE;
      opt.ReplaceAll("para", "");
   }
   if (opt.Contains("candle")) {
      optcandle = kTRUE;
      opt.ReplaceAll("candle", "");
   }
   if (opt.Contains("gl5d")) {
      opt5d = kTRUE;
      opt.ReplaceAll("gl5d", "");
   }
   TCut realSelection(selection);
   //input list - only TEntryList
   TEntryList *inElist = fTree->GetEntryList();
   evlist = fTree->GetEventList();
   if (evlist && inElist) {
      //this is needed because the input entry list was created
      //by the fTree from the input TEventList and is owned by the fTree.
      //Calling GetEntryList function changes ownership and here
      //we want fTree to still delete this entry list

      inElist->SetBit(kCanDelete, kTRUE);
   }
   fCleanElist = kFALSE;
   fTreeElist = inElist;

   fTreeElistArray = inElist ? dynamic_cast<TEntryListArray*>(fTreeElist) : 0;


   if (inElist && inElist->GetReapplyCut()) {
      realSelection *= inElist->GetTitle();
   }

   // what each variable should contain:
   //   varexp0   - original expression eg "a:b>>htest"
   //   hname     - name of new or old histogram
   //   hkeep     - flag if to keep new histogram
   //   hnameplus - flag if to add to current histo
   //   i         - length of variable expression stipped of everything after ">>"
   //   varexp    - variable expression stipped of everything after ">>"
   //   fOldHistogram     - pointer to hist hname
   //   elist     - pointer to selection list of hname

   Bool_t canRebin = kTRUE;
   if (optSame) canRebin = kFALSE;

   Int_t nbinsx = 0, nbinsy = 0, nbinsz = 0;
   Double_t xmin = 0, xmax = 0, ymin = 0, ymax = 0, zmin = 0, zmax = 0;

   fObject  = 0;
   char *hname = 0;
   char *hnamealloc = 0;
   i = 0;
   if (varexp0 && strlen(varexp0)) {
      for (UInt_t k = strlen(varexp0) - 1; k > 0; k--) {
         if (varexp0[k] == '>' && varexp0[k-1] == '>') {
            i = (int)(&(varexp0[k-1]) - varexp0);    //  length of varexp0 before ">>"
            hnamealloc = new char[strlen(&(varexp0[k+1])) + 1];
            hname = hnamealloc;
            strcpy(hname, &(varexp0[k+1]));
            break;
         }
      }
   }
   //   char *hname = (char*)strstr(varexp0,">>");
   if (hname) {
      hkeep  = 1;
      varexp = new char[i+1];
      varexp[0] = 0; //necessary if i=0
      Bool_t hnameplus = kFALSE;
      while (*hname == ' ') hname++;
      if (*hname == '+') {
         hnameplus = kTRUE;
         hname++;
         while (*hname == ' ') hname++; //skip ' '
      }
      j = strlen(hname) - 1;   // skip ' '  at the end
      while (j) {
         if (hname[j] != ' ') break;
         hname[j] = 0;
         j--;
      }

      if (i) {
         strlcpy(varexp,varexp0,i+1);

         Int_t mustdelete = 0;
         SetBit(kCustomHistogram);

         // parse things that follow the name of the histo between '(' and ')'.
         // At this point hname contains the name of the specified histogram.
         //   Now the syntax is exended to handle an hname of the following format
         //   hname(nBIN [[,[xlow]][,xhigh]],...)
         //   so enclosed in brackets is the binning information, xlow, xhigh, and
         //   the same for the other dimensions

         char *pstart;    // pointer to '('
         char *pend;      // pointer to ')'
         char *cdummy;    // dummy pointer
         int ncomma;      // number of commas between '(' and ')', later number of arguments
         int ncols;       // number of columns in varexpr
         Double_t value;  // parsed value (by sscanf)

         const Int_t maxvalues = 9;

         pstart = strchr(hname, '(');
         pend =  strchr(hname, ')');
         if (pstart != 0) {   // found the bracket

            mustdelete = 1;

            // check that there is only one open and close bracket
            if (pstart == strrchr(hname, '(')  &&  pend == strrchr(hname, ')')) {

               // count number of ',' between '(' and ')'
               ncomma = 0;
               cdummy = pstart;
               cdummy = strchr(&cdummy[1], ',');
               while (cdummy != 0) {
                  cdummy = strchr(&cdummy[1], ',');
                  ncomma++;
               }

               if (ncomma + 1 > maxvalues) {
                  Error("DrawSelect", "ncomma+1>maxvalues, ncomma=%d, maxvalues=%d", ncomma, maxvalues);
                  ncomma = maxvalues - 1;
               }

               ncomma++; // number of arguments
               cdummy = pstart;

               //   number of columns
               ncols  = 1;
               for (j = 0; j < i; j++) {
                  if (varexp[j] == ':'
                      && !((j > 0 && varexp[j-1] == ':') || varexp[j+1] == ':')
                     ) {
                     ncols++;
                  }
               }
               if (ncols > 3) {   // max 3 columns
                  Error("DrawSelect", "ncols > 3, ncols=%d", ncols);
                  ncols = 0;
               }

               // check dimensions before and after ">>"
               if (ncols * 3 < ncomma) {
                  Error("DrawSelect", "ncols*3 < ncomma ncols=%d, ncomma=%d", ncols, ncomma);
                  ncomma = ncols * 3;
               }

               // scan the values one after the other
               for (j = 0; j < ncomma; j++) {
                  cdummy++;  // skip '(' or ','
                  if (sscanf(cdummy, " %lf ", &value) == 1) {
                     cdummy = strchr(&cdummy[1], ',');

                     switch (j) {  // do certain settings depending on position of argument
                        case 0:  // binning x-axis
                           nbinsx = (Int_t)value;
                           if (ncols < 2) {
                              gEnv->SetValue("Hist.Binning.1D.x", nbinsx);
                           } else if (ncols < 3) {
                              gEnv->SetValue("Hist.Binning.2D.x", nbinsx);
                              gEnv->SetValue("Hist.Binning.2D.Prof", nbinsx);
                           } else {
                              gEnv->SetValue("Hist.Binning.3D.x", nbinsx);
                              gEnv->SetValue("Hist.Binning.3D.Profx", nbinsx);
                           }

                           break;
                        case 1:  // lower limit x-axis
                           xmin = value;
                           break;
                        case 2:  // upper limit x-axis
                           xmax = value;
                           break;
                        case 3:  // binning y-axis
                           nbinsy = (Int_t)value;
                           if (ncols < 3) gEnv->SetValue("Hist.Binning.2D.y", nbinsy);
                           else {
                              gEnv->SetValue("Hist.Binning.3D.y", nbinsy);
                              gEnv->SetValue("Hist.Binning.3D.Profy", nbinsy);
                           }
                           break;
                        case 4:  // lower limit y-axis
                           ymin = value;
                           break;
                        case 5:  // upper limit y-axis
                           ymax = value;
                           break;
                        case 6:  // binning z-axis
                           nbinsz = (Int_t)value;
                           gEnv->SetValue("Hist.Binning.3D.z", nbinsz);
                           break;
                        case 7:  // lower limit z-axis
                           zmin = value;
                           break;
                        case 8:  // upper limit z-axis
                           zmax = value;
                           break;
                        default:
                           Error("DrawSelect", "j>8");
                           break;
                     }
                  }  // if sscanf == 1
               } // for j=0;j<ncomma;j++
            } else {
               Error("Begin", "Two open or close brackets found, hname=%s", hname);
            }

            // fix up hname
            pstart[0] = '\0'; // removes things after (and including) '('
         } // if '(' is found

         j = strlen(hname) - 1; // skip ' '  at the end
         while (j > 0) {
            if (hname[j] != ' ') break; // skip ' '  at the end
            hname[j] = 0;
            j--;
         }

         TObject *oldObject = gDirectory->Get(hname);  // if hname contains '(...)' the return values is NULL, which is what we want
         fOldHistogram = oldObject ? dynamic_cast<TH1*>(oldObject) : 0;

         if (!fOldHistogram && oldObject && !oldObject->InheritsFrom(TH1::Class())) {
            abrt.Form("An object of type '%s' has the same name as the requested histo (%s)", oldObject->IsA()->GetName(), hname);
            Abort(abrt);
            return;
         }
         if (fOldHistogram && !hnameplus) fOldHistogram->Reset();  // reset unless adding is wanted

         if (mustdelete) {
            if (gDebug) {
               Warning("Begin", "Deleting old histogram, since (possibly new) limits and binnings have been given");
            }
            delete fOldHistogram; fOldHistogram=0;
         }

      } else {
         // make selection list (i.e. varexp0 starts with ">>")
         TObject *oldObject = gDirectory->Get(hname);
         if (optEnlist) {
            //write into a TEntryList
            enlist = oldObject ? dynamic_cast<TEntryList*>(oldObject) : 0;

            if (!enlist && oldObject) {
               abrt.Form("An object of type '%s' has the same name as the requested event list (%s)",
                         oldObject->IsA()->GetName(), hname);
               Abort(abrt);
               return;
            }
            if (!enlist) {
               if (optEnlistArray) {
                  enlist = new TEntryListArray(hname, realSelection.GetTitle());
               } else {
                  enlist = new TEntryList(hname, realSelection.GetTitle());
               }
            }
            if (enlist) {
               if (!hnameplus) {
                  if (enlist == inElist) {
                     // We have been asked to reset the input list!!
                     // Let's set it aside for now ...
                     if (optEnlistArray) {
                        inElist = new TEntryListArray(*enlist);
                     } else {
                        inElist = new TEntryList(*enlist);
                     }
                     fCleanElist = kTRUE;
                     fTree->SetEntryList(inElist);
                  }
                  enlist->Reset();
                  enlist->SetTitle(realSelection.GetTitle());
               } else {
                  TCut old = enlist->GetTitle();
                  TCut upd = old || realSelection.GetTitle();
                  enlist->SetTitle(upd.GetTitle());
               }
            }
         } else {
            //write into a TEventList
            evlist = oldObject ? dynamic_cast<TEventList*>(oldObject) : 0;

            if (!evlist && oldObject) {
               abrt.Form("An object of type '%s' has the same name as the requested event list (%s)",
                          oldObject->IsA()->GetName(), hname);
               Abort(abrt);
               return;
            }
            if (!evlist) {
               evlist = new TEventList(hname, realSelection.GetTitle(), 1000, 0);
            }
            if (evlist) {
               if (!hnameplus) {
                  if (evlist == fTree->GetEventList()) {
                     // We have been asked to reset the input list!!
                     // Let's set it aside for now ...
                     Abort("Input and output lists are the same!");
                     delete [] varexp;
                     return;
                  }
                  evlist->Reset();
                  evlist->SetTitle(realSelection.GetTitle());
               } else {
                  TCut old = evlist->GetTitle();
                  TCut upd = old || realSelection.GetTitle();
                  evlist->SetTitle(upd.GetTitle());
               }
            }
         }

      }  // if (i)
   } else { // if (hname)
      hname  = hdefault;
      hkeep  = 0;
      const size_t varexpLen = strlen(varexp0) + 1;
      varexp = new char[varexpLen];
      strlcpy(varexp, varexp0, varexpLen);
      if (gDirectory) {
         fOldHistogram = (TH1*)gDirectory->Get(hname);
         if (fOldHistogram) { fOldHistogram->Delete(); fOldHistogram = 0;}
      }
   }

   // Decode varexp and selection
   if (!CompileVariables(varexp, realSelection.GetTitle())) {
      abrt.Form("Variable compilation failed: {%s,%s}", varexp, realSelection.GetTitle());
      Abort(abrt);
      delete [] varexp;
      return;
   }
   if (fDimension > 4 && !(optpara || optcandle || opt5d)) {
      Abort("Too many variables. Use the option \"para\", \"gl5d\" or \"candle\" to display more than 4 variables.");
      delete [] varexp;
      return;
   }

   // In case fOldHistogram exists, check dimensionality
   Int_t nsel = strlen(selection);
   if (nsel > 1) {
      htitle.Form("%s {%s}", varexp, selection);
   } else {
      htitle = varexp;
   }
   if (fOldHistogram) {
      Int_t olddim = fOldHistogram->GetDimension();
      Int_t mustdelete = 0;
      if (fOldHistogram->InheritsFrom(TProfile::Class())) {
         profile = kTRUE;
         olddim = 2;
      }
      if (fOldHistogram->InheritsFrom(TProfile2D::Class())) {
         profile = kTRUE;
         olddim = 3;
      }
      if (opt.Contains("prof") && fDimension > 1) {
         // ignore "prof" for 1D.
         if (!profile || olddim != fDimension) mustdelete = 1;
      } else if (opt.Contains("col") && fDimension>2) {
         if (olddim+1 != fDimension) mustdelete = 1;
      } else {
         if (olddim != fDimension) mustdelete = 1;
      }
      if (mustdelete) {
         Warning("Begin", "Deleting old histogram with different dimensions");
         delete fOldHistogram;
         fOldHistogram = 0;
      }
   }

   // Create a default canvas if none exists
   fDraw = 0;
   if (!gPad && !opt.Contains("goff") && fDimension > 0) {
      gROOT->MakeDefCanvas();
      if (!gPad) {
         Abort("Creation of default canvas failed");
         return;
      }
   }

   // 1-D distribution
   TH1 *hist;
   if (fDimension == 1) {
      fAction = 1;
      if (!fOldHistogram) {
         fNbins[0] = gEnv->GetValue("Hist.Binning.1D.x", 100);
         if (gPad && optSame) {
            TListIter np(gPad->GetListOfPrimitives());
            TObject *op;
            TH1 *oldhtemp = 0;
            while ((op = np()) && !oldhtemp) {
               if (op->InheritsFrom(TH1::Class())) oldhtemp = (TH1 *)op;
            }
            if (oldhtemp) {
               fNbins[0] = oldhtemp->GetXaxis()->GetNbins();
               fVmin[0]  = oldhtemp->GetXaxis()->GetXmin();
               fVmax[0]  = oldhtemp->GetXaxis()->GetXmax();
            } else {
               fVmin[0]  = gPad->GetUxmin();
               fVmax[0]  = gPad->GetUxmax();
            }
         } else {
            fAction   = -1;
            fVmin[0] = xmin;
            fVmax[0] = xmax;
            if (xmin < xmax) canRebin = kFALSE;
         }
      }
      if (fOldHistogram) {
         hist    = fOldHistogram;
         fNbins[0] = hist->GetXaxis()->GetNbins();
      } else {
         hist = new TH1F(hname, htitle.Data(), fNbins[0], fVmin[0], fVmax[0]);
         hist->SetLineColor(fTree->GetLineColor());
         hist->SetLineWidth(fTree->GetLineWidth());
         hist->SetLineStyle(fTree->GetLineStyle());
         hist->SetFillColor(fTree->GetFillColor());
         hist->SetFillStyle(fTree->GetFillStyle());
         hist->SetMarkerStyle(fTree->GetMarkerStyle());
         hist->SetMarkerColor(fTree->GetMarkerColor());
         hist->SetMarkerSize(fTree->GetMarkerSize());
         if (canRebin)hist->SetBit(TH1::kCanRebin);
         if (!hkeep) {
            hist->GetXaxis()->SetTitle(fVar[0]->GetTitle());
            hist->SetBit(kCanDelete);
            if (!opt.Contains("goff")) hist->SetDirectory(0);
         }
         if (opt.Length() && opt.Contains("e")) hist->Sumw2();
      }
      fVar[0]->SetAxis(hist->GetXaxis());
      fObject = hist;

      // 2-D distribution
   } else if (fDimension == 2 && !(optpara || optcandle)) {
      fAction = 2;
      if (!fOldHistogram || !optSame) {
         fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
         fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
         if (opt.Contains("prof")) fNbins[1] = gEnv->GetValue("Hist.Binning.2D.Prof", 100);
         if (optSame) {
            TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
            if (oldhtemp) {
               fNbins[1] = oldhtemp->GetXaxis()->GetNbins();
               fVmin[1]  = oldhtemp->GetXaxis()->GetXmin();
               fVmax[1]  = oldhtemp->GetXaxis()->GetXmax();
               fNbins[0] = oldhtemp->GetYaxis()->GetNbins();
               fVmin[0]  = oldhtemp->GetYaxis()->GetXmin();
               fVmax[0]  = oldhtemp->GetYaxis()->GetXmax();
            } else {
               fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
               fVmin[1]  = gPad->GetUxmin();
               fVmax[1]  = gPad->GetUxmax();
               fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
               fVmin[0]  = gPad->GetUymin();
               fVmax[0]  = gPad->GetUymax();
            }
         } else {
            if (!fOldHistogram) fAction = -2;
            fVmin[1] = xmin;
            fVmax[1] = xmax;
            fVmin[0] = ymin;
            fVmax[0] = ymax;
            if (xmin < xmax && ymin < ymax) canRebin = kFALSE;
         }
      }
      if (profile || opt.Contains("prof")) {
         TProfile *hp;
         if (fOldHistogram) {
            fAction = 4;
            hp = (TProfile*)fOldHistogram;
         } else {
            if (fAction < 0) {
               fAction = -4;
               fVmin[1] = xmin;
               fVmax[1] = xmax;
               if (xmin < xmax) canRebin = kFALSE;
            }
            if (fAction == 2) {
               //we come here when option = "same prof"
               fAction = -4;
               TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
               if (oldhtemp) {
                  fNbins[1] = oldhtemp->GetXaxis()->GetNbins();
                  fVmin[1]  = oldhtemp->GetXaxis()->GetXmin();
                  fVmax[1]  = oldhtemp->GetXaxis()->GetXmax();
               }
            }
            if (opt.Contains("profs")) {
               hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "s");
            } else if (opt.Contains("profi")) {
               hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "i");
            } else if (opt.Contains("profg")) {
               hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "g");
            } else {
               hp = new TProfile(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], "");
            }
            if (!hkeep) {
               hp->SetBit(kCanDelete);
               if (!opt.Contains("goff")) hp->SetDirectory(0);
            }
            hp->SetLineColor(fTree->GetLineColor());
            hp->SetLineWidth(fTree->GetLineWidth());
            hp->SetLineStyle(fTree->GetLineStyle());
            hp->SetFillColor(fTree->GetFillColor());
            hp->SetFillStyle(fTree->GetFillStyle());
            hp->SetMarkerStyle(fTree->GetMarkerStyle());
            hp->SetMarkerColor(fTree->GetMarkerColor());
            hp->SetMarkerSize(fTree->GetMarkerSize());
            if (canRebin)hp->SetBit(TH1::kCanRebin);
         }
         fVar[1]->SetAxis(hp->GetXaxis());
         fObject = hp;

      } else {
         TH2F *h2;
         if (fOldHistogram) {
            h2 = (TH2F*)fOldHistogram;
         } else {
            h2 = new TH2F(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
            h2->SetLineColor(fTree->GetLineColor());
            h2->SetLineWidth(fTree->GetLineWidth());
            h2->SetLineStyle(fTree->GetLineStyle());
            h2->SetFillColor(fTree->GetFillColor());
            h2->SetFillStyle(fTree->GetFillStyle());
            h2->SetMarkerStyle(fTree->GetMarkerStyle());
            h2->SetMarkerColor(fTree->GetMarkerColor());
            h2->SetMarkerSize(fTree->GetMarkerSize());
            if (canRebin)h2->SetBit(TH1::kCanRebin);
            if (!hkeep) {
               h2->GetXaxis()->SetTitle(fVar[1]->GetTitle());
               h2->GetYaxis()->SetTitle(fVar[0]->GetTitle());
               h2->SetBit(TH1::kNoStats);
               h2->SetBit(kCanDelete);
               if (!opt.Contains("goff")) h2->SetDirectory(0);
            }
         }
         fVar[0]->SetAxis(h2->GetYaxis());
         fVar[1]->SetAxis(h2->GetXaxis());
         Bool_t graph = kFALSE;
         Int_t l = opt.Length();
         if (l == 0 || optSame) graph = kTRUE;
         if (opt.Contains("p")     || opt.Contains("*")    || opt.Contains("l"))    graph = kTRUE;
         if (opt.Contains("surf")  || opt.Contains("lego") || opt.Contains("cont")) graph = kFALSE;
         if (opt.Contains("col")   || opt.Contains("hist") || opt.Contains("scat")) graph = kFALSE;
         if (opt.Contains("box"))                                                   graph = kFALSE;
         fObject = h2;
         if (graph) {
            fAction = 12;
            if (!fOldHistogram && !optSame) fAction = -12;
         }
      }

      // 3-D distribution
   } else if ((fDimension == 3 || fDimension == 4) && !(optpara || optcandle)) {
      fAction = 3;
      if (fDimension == 4) fAction = 40;
      if (!fOldHistogram || !optSame) {
         fNbins[0] = gEnv->GetValue("Hist.Binning.3D.z", 20);
         fNbins[1] = gEnv->GetValue("Hist.Binning.3D.y", 20);
         fNbins[2] = gEnv->GetValue("Hist.Binning.3D.x", 20);
         if (fDimension == 3 && opt.Contains("prof")) {
            fNbins[1] = gEnv->GetValue("Hist.Binning.3D.Profy", 20);
            fNbins[2] = gEnv->GetValue("Hist.Binning.3D.Profx", 20);
         }
         if (fDimension == 3 && opt.Contains("col")) {
            fNbins[0] = gEnv->GetValue("Hist.Binning.2D.y", 40);
            fNbins[1] = gEnv->GetValue("Hist.Binning.2D.x", 40);
         }
         if (optSame) {
            TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
            if (oldhtemp) {
               fNbins[2] = oldhtemp->GetXaxis()->GetNbins();
               fVmin[2]  = oldhtemp->GetXaxis()->GetXmin();
               fVmax[2]  = oldhtemp->GetXaxis()->GetXmax();
               fNbins[1] = oldhtemp->GetYaxis()->GetNbins();
               fVmin[1]  = oldhtemp->GetYaxis()->GetXmin();
               fVmax[1]  = oldhtemp->GetYaxis()->GetXmax();
               fNbins[0] = oldhtemp->GetZaxis()->GetNbins();
               fVmin[0]  = oldhtemp->GetZaxis()->GetXmin();
               fVmax[0]  = oldhtemp->GetZaxis()->GetXmax();
            } else {
               TView *view = gPad->GetView();
               if (!view) {
                  Error("Begin", "You cannot use option same when no 3D view exists");
                  fVmin[0] = fVmin[1] = fVmin[2] = -1;
                  fVmax[0] = fVmax[1] = fVmax[2] = 1;
                  view = TView::CreateView(1, fVmin, fVmax);
               }
               Double_t *rmin = view->GetRmin();
               Double_t *rmax = view->GetRmax();
               fNbins[2] = gEnv->GetValue("Hist.Binning.3D.z", 20);
               fVmin[2]  = rmin[0];
               fVmax[2]  = rmax[0];
               fNbins[1] = gEnv->GetValue("Hist.Binning.3D.y", 20);
               fVmin[1]  = rmin[1];
               fVmax[1]  = rmax[1];
               fNbins[0] = gEnv->GetValue("Hist.Binning.3D.x", 20);
               fVmin[0]  = rmin[2];
               fVmax[0]  = rmax[2];
            }
         } else {
            if (!fOldHistogram && fDimension == 3) fAction = -3;
            fVmin[2] = xmin;
            fVmax[2] = xmax;
            fVmin[1] = ymin;
            fVmax[1] = ymax;
            fVmin[0] = zmin;
            fVmax[0] = zmax;
            if (xmin < xmax && ymin < ymax && zmin < zmax) canRebin = kFALSE;
         }
      }
      if ((fDimension == 3) && (profile || opt.Contains("prof"))) {
         TProfile2D *hp;
         if (fOldHistogram) {
            fAction = 23;
            hp = (TProfile2D*)fOldHistogram;
         } else {
            if (fAction < 0) {
               fAction = -23;
               fVmin[2] = xmin;
               fVmax[2] = xmax;
               fVmin[1] = ymin;
               fVmax[1] = ymax;
               if (xmin < xmax && ymin < ymax) canRebin = kFALSE;
            }
            if (opt.Contains("profs")) {
               hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "s");
            } else if (opt.Contains("profi")) {
               hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "i");
            } else if (opt.Contains("profg")) {
               hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "g");
            } else {
               hp = new TProfile2D(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], "");
            }
            if (!hkeep) {
               hp->SetBit(kCanDelete);
               if (!opt.Contains("goff")) hp->SetDirectory(0);
            }
            hp->SetLineColor(fTree->GetLineColor());
            hp->SetLineWidth(fTree->GetLineWidth());
            hp->SetLineStyle(fTree->GetLineStyle());
            hp->SetFillColor(fTree->GetFillColor());
            hp->SetFillStyle(fTree->GetFillStyle());
            hp->SetMarkerStyle(fTree->GetMarkerStyle());
            hp->SetMarkerColor(fTree->GetMarkerColor());
            hp->SetMarkerSize(fTree->GetMarkerSize());
            if (canRebin)hp->SetBit(TH1::kCanRebin);
         }
         fVar[1]->SetAxis(hp->GetYaxis());
         fVar[2]->SetAxis(hp->GetXaxis());
         fObject = hp;
      } else if (fDimension == 3 && opt.Contains("col")) {
         TH2F *h2;
         if (fOldHistogram) {
            h2 = (TH2F*)fOldHistogram;
         } else {
            h2 = new TH2F(hname, htitle.Data(), fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
            h2->SetLineColor(fTree->GetLineColor());
            h2->SetLineWidth(fTree->GetLineWidth());
            h2->SetLineStyle(fTree->GetLineStyle());
            h2->SetFillColor(fTree->GetFillColor());
            h2->SetFillStyle(fTree->GetFillStyle());
            h2->SetMarkerStyle(fTree->GetMarkerStyle());
            h2->SetMarkerColor(fTree->GetMarkerColor());
            h2->SetMarkerSize(fTree->GetMarkerSize());
            if (canRebin)h2->SetBit(TH1::kCanRebin);
            if (!hkeep) {
               h2->GetXaxis()->SetTitle(fVar[1]->GetTitle());
               h2->GetYaxis()->SetTitle(fVar[0]->GetTitle());
               h2->GetZaxis()->SetTitle(fVar[2]->GetTitle());
               h2->SetBit(TH1::kNoStats);
               h2->SetBit(kCanDelete);
               if (!opt.Contains("goff")) h2->SetDirectory(0);
            }
         }
         fVar[0]->SetAxis(h2->GetYaxis());
         fVar[1]->SetAxis(h2->GetXaxis());
         fObject = h2;
         fAction = 33;
      } else {
         TH3F *h3;
         if (fOldHistogram) {
            h3 = (TH3F*)fOldHistogram;
         } else {
            h3 = new TH3F(hname, htitle.Data(), fNbins[2], fVmin[2], fVmax[2], fNbins[1], fVmin[1], fVmax[1], fNbins[0], fVmin[0], fVmax[0]);
            h3->SetLineColor(fTree->GetLineColor());
            h3->SetLineWidth(fTree->GetLineWidth());
            h3->SetLineStyle(fTree->GetLineStyle());
            h3->SetFillColor(fTree->GetFillColor());
            h3->SetFillStyle(fTree->GetFillStyle());
            h3->SetMarkerStyle(fTree->GetMarkerStyle());
            h3->SetMarkerColor(fTree->GetMarkerColor());
            h3->SetMarkerSize(fTree->GetMarkerSize());
            if (canRebin)h3->SetBit(TH1::kCanRebin);
            if (!hkeep) {
               //small correction for the title offsets in x,y to take into account the angles
               Double_t xoffset = h3->GetXaxis()->GetTitleOffset();
               Double_t yoffset = h3->GetYaxis()->GetTitleOffset();
               h3->GetXaxis()->SetTitleOffset(1.2 * xoffset);
               h3->GetYaxis()->SetTitleOffset(1.2 * yoffset);
               h3->GetXaxis()->SetTitle(fVar[2]->GetTitle());
               h3->GetYaxis()->SetTitle(fVar[1]->GetTitle());
               h3->GetZaxis()->SetTitle(fVar[0]->GetTitle());
               h3->SetBit(kCanDelete);
               h3->SetBit(TH1::kNoStats);
               if (!opt.Contains("goff")) h3->SetDirectory(0);
            }
         }
         fVar[0]->SetAxis(h3->GetZaxis());
         fVar[1]->SetAxis(h3->GetYaxis());
         fVar[2]->SetAxis(h3->GetXaxis());
         fObject = h3;
         Int_t noscat = strlen(option);
         if (optSame) noscat -= 4;
         if (!noscat && fDimension == 3) {
            fAction = 13;
            if (!fOldHistogram && !optSame) fAction = -13;
         }
      }
      // An Event List
   } else if (enlist) {
      fAction = 5;
      fOldEstimate = fTree->GetEstimate();
      fTree->SetEstimate(1);
      fObject = enlist;
   } else if (evlist) {
      fAction = 5;
      fOldEstimate = fTree->GetEstimate();
      fTree->SetEstimate(1);
      fObject = evlist;
   } else if (optcandle || optpara || opt5d) {
      if (optcandle)  fAction = 7;
      else if (opt5d) fAction = 8;
      else            fAction = 6;
   }
   if (hkeep) delete [] varexp;
   if (hnamealloc) delete [] hnamealloc;
   for (i = 0; i < fValSize; ++i)
      fVarMultiple[i] = kFALSE;
   fSelectMultiple = kFALSE;
   for (i = 0; i < fDimension; ++i) {
      if (fVar[i] && fVar[i]->GetMultiplicity()) fVarMultiple[i] = kTRUE;
   }

   if (fSelect && fSelect->GetMultiplicity()) fSelectMultiple = kTRUE;

   fForceRead = fTree->TestBit(TTree::kForceRead);
   fWeight  = fTree->GetWeight();
   fNfill   = 0;

   for (i = 0; i < fDimension; ++i) {
      if (!fVal[i] && fVar[i]) {
         fVal[i] = new Double_t[(Int_t)fTree->GetEstimate()];
      }
   }

   if (!fW)             fW  = new Double_t[(Int_t)fTree->GetEstimate()];

   for (i = 0; i < fValSize; ++i) {
      fVmin[i] = DBL_MAX;
      fVmax[i] = -DBL_MAX;
   }
}

//______________________________________________________________________________
void TSelectorDraw::ClearFormula()
{
   // Delete internal buffers.

   ResetBit(kWarn);
   for (Int_t i = 0; i < fValSize; ++i) {
      delete fVar[i];
      fVar[i] = 0;
   }
   delete fSelect; fSelect = 0;
   fManager = 0;
   fMultiplicity = 0;
}

//______________________________________________________________________________
Bool_t TSelectorDraw::CompileVariables(const char *varexp, const char *selection)
{
   // Compile input variables and selection expression.
   //
   //  varexp is an expression of the general form e1:e2:e3
   //    where e1,etc is a formula referencing a combination of the columns
   //  Example:
   //     varexp = x  simplest case: draw a 1-Dim distribution of column named x
   //            = sqrt(x)         : draw distribution of sqrt(x)
   //            = x*y/z
   //            = y:sqrt(x) 2-Dim dsitribution of y versus sqrt(x)
   //
   //  selection is an expression with a combination of the columns
   //  Example:
   //      selection = "x<y && sqrt(z)>3.2"
   //       in a selection all the C++ operators are authorized
   //
   //  Return kFALSE if any of the variable is not compilable.

   Int_t i, nch, ncols;

   // Compile selection expression if there is one
   fDimension = 0;
   ClearFormula();
   fMultiplicity = 0;
   fObjEval = kFALSE;

   if (strlen(selection)) {
      fSelect = new TTreeFormula("Selection", selection, fTree);
      fSelect->SetQuickLoad(kTRUE);
      if (!fSelect->GetNdim()) {
         delete fSelect;
         fSelect = 0;
         return kFALSE;
      }
   }

   // if varexp is empty, take first column by default
   nch = strlen(varexp);
   if (nch == 0) {
      fDimension = 0;
      fManager = new TTreeFormulaManager();
      if (fSelect) fManager->Add(fSelect);
      fTree->ResetBit(TTree::kForceRead);

      fManager->Sync();

      if (fManager->GetMultiplicity() == -1) fTree->SetBit(TTree::kForceRead);
      if (fManager->GetMultiplicity() >= 1) fMultiplicity = fManager->GetMultiplicity();

      return kTRUE;
   }

   // otherwise select only the specified columns
   std::vector<TString> varnames;
   ncols  = SplitNames(varexp, varnames);

   InitArrays(ncols);

   fManager = new TTreeFormulaManager();
   if (fSelect) fManager->Add(fSelect);
   fTree->ResetBit(TTree::kForceRead);
   for (i = 0; i < ncols; ++i) {
      fVar[i] = new TTreeFormula(TString::Format("Var%i", i + 1), varnames[i].Data(), fTree);
      fVar[i]->SetQuickLoad(kTRUE);
      if(!fVar[i]->GetNdim()) { ClearFormula(); return kFALSE; }
      fManager->Add(fVar[i]);
   }
   fManager->Sync();

   if (fManager->GetMultiplicity() == -1) fTree->SetBit(TTree::kForceRead);
   if (fManager->GetMultiplicity() >= 1) fMultiplicity = fManager->GetMultiplicity();

   fDimension    = ncols;

   if (ncols == 1) {
      TClass *cl = fVar[0]->EvalClass();
      if (cl) {
         fObjEval = kTRUE;
      }
   }
   return kTRUE;
}

//______________________________________________________________________________
Double_t* TSelectorDraw::GetVal(Int_t i) const
{
   // Return the last values corresponding to the i-th component
   // of the formula being processed (where the component are ':' separated).
   // The actual number of entries is:
   //     GetSelectedRows() % tree->GetEstimate()
   // Note GetSelectedRows currently returns the actual number of values plotted
   // and thus if the formula contains arrays, this number might be greater than
   // the number of entries in the trees.
   // By default TTree::Draw creates the arrays obtained
   //    with all GetVal and GetW with a length corresponding to the
   //    parameter fEstimate. By default fEstimate=10000 and can be modified
   //    via TTree::SetEstimate. A possible recipee is to do
   //       tree->SetEstimate(tree->GetEntries());
   //    You must call SetEstimate if the expected number of selected rows
   //    is greater than 10000.
   // See TTree::Draw for additional details.

   if (i < 0 || i >= fDimension)
      return 0;
   else
      return fVal[i];
}

//______________________________________________________________________________
TTreeFormula* TSelectorDraw::GetVar(Int_t i) const
{
   // Return the TTreeFormula corresponding to the i-th component
   // of the request formula (where the component are ':' separated).

   if (i < 0 || i >= fDimension)
      return 0;
   else
      return fVar[i];
}

//______________________________________________________________________________
void TSelectorDraw::InitArrays(Int_t newsize)
{
   // Initialization of the primitive type arrays if the new size is bigger than the available space.

   if (newsize > fValSize) {
      Int_t oldsize = fValSize;
      while (fValSize < newsize)
         fValSize *= 2;          // Double the available space until it matches the new size.
      if (fNbins) delete [] fNbins;
      if (fVmin) delete [] fVmin;
      if (fVmax) delete [] fVmax;
      if (fVarMultiple) delete [] fVarMultiple;

      fNbins = new Int_t[fValSize];
      fVmin = new Double_t[fValSize];
      fVmax = new Double_t[fValSize];
      fVarMultiple = new Bool_t[fValSize];

      for (Int_t i = 0; i < oldsize; ++i)
         delete [] fVal[i];
      delete [] fVal;
      delete [] fVar;
      fVal = new Double_t*[fValSize];
      fVar = new TTreeFormula*[fValSize];
      for (Int_t i = 0; i < fValSize; ++i) {
         fVal[i] = 0;
         fVar[i] = 0;
      }
   }
}

//______________________________________________________________________________
UInt_t TSelectorDraw::SplitNames(const TString &varexp, std::vector<TString> &names)
{
   // Build Index array for names in varexp.
   // This will allocated a C style array of TString and Ints

   names.clear();

   Bool_t ternary = kFALSE;
   Int_t prev = 0;
   for (Int_t i = 0; i < varexp.Length(); i++) {
      if (varexp[i] == ':'
          && !((i > 0 && varexp[i-1] == ':') || varexp[i+1] == ':')
         ) {
         if (ternary) {
            ternary = kFALSE;
         } else {
            names.push_back(varexp(prev, i - prev));
            prev = i + 1;
         }
      }
      if (varexp[i] == '?') {
         ternary = kTRUE;
      }
   }
   names.push_back(varexp(prev, varexp.Length() - prev));
   return names.size();
}


//______________________________________________________________________________
Bool_t TSelectorDraw::Notify()
{
   // This function is called at the first entry of a new tree in a chain.

   if (fTree) fWeight  = fTree->GetWeight();
   if (fVar) {
      for (Int_t i = 0; i < fDimension; ++i) {
         if (fVar[i]) fVar[i]->UpdateFormulaLeaves();
      }
   }
   if (fSelect) fSelect->UpdateFormulaLeaves();
   return kTRUE;
}

//______________________________________________________________________________
void TSelectorDraw::ProcessFill(Long64_t entry)
{
   // Called in the entry loop for all entries accepted by Select.

   if (fObjEval) {
      ProcessFillObject(entry);
      return;
   }

   if (fMultiplicity) {
      ProcessFillMultiple(entry);
      return;
   }

   // simple case with no multiplicity
   if (fForceRead && fManager->GetNdata() <= 0) return;

   if (fSelect) {
      fW[fNfill] = fWeight * fSelect->EvalInstance(0);
      if (!fW[fNfill]) return;
   } else fW[fNfill] = fWeight;
   if (fVal) {
      for (Int_t i = 0; i < fDimension; ++i) {
         if (fVar[i]) fVal[i][fNfill] = fVar[i]->EvalInstance(0);
      }
   }
   fNfill++;
   if (fNfill >= fTree->GetEstimate()) {
      TakeAction();
      fNfill = 0;
   }
}

//______________________________________________________________________________
void TSelectorDraw::ProcessFillMultiple(Long64_t entry)
{
   // Called in the entry loop for all entries accepted by Select.
   // Complex case with multiplicity.

   // Grab the array size of the formulas for this entry
   Int_t ndata = fManager->GetNdata();

   // No data at all, let's move on to the next entry.
   if (!ndata) return;

   // If the entry list is a TEntryListArray, get the selected subentries for this entry
   TEntryList *subList = 0;
   if (fTreeElistArray) {
      subList = fTreeElistArray->GetSubListForEntry(entry, fTree->GetTree());
   }

   Int_t nfill0 = fNfill;

   // Calculate the first values
   if (fSelect) {
      // coverity[var_deref_model] fSelectMultiple==kTRUE => fSelect != 0
      fW[fNfill] = fWeight * fSelect->EvalInstance(0);
      if (!fW[fNfill] && !fSelectMultiple) return;
   } else fW[fNfill] = fWeight;

   // Always call EvalInstance(0) to insure the loading
   // of the branches.
   if (fW[fNfill] && (!subList || subList->Contains(0))) {
      if (fDimension == 0 && fSelectMultiple) fCurrentSubEntry = (Long64_t) 0; // to fill TEntryListArray
      for (Int_t i = 0; i < fDimension; ++i) {
         if (fVar[i]) fVal[i][fNfill] = fVar[i]->EvalInstance(0);
      }
      fNfill++;
      if (fNfill >= fTree->GetEstimate()) {
         TakeAction();
         fNfill = 0;
      }
   } else {
      for (Int_t i = 0; i < fDimension; ++i) {
         if (fVar[i]) fVar[i]->ResetLoading();
      }
   }
   Double_t ww = fW[nfill0];

   for (Int_t i = 1; i < ndata; i++) {
      if (subList && !subList->Contains(i)) continue;
      if (fSelectMultiple) {
         // coverity[var_deref_model] fSelectMultiple==kTRUE => fSelect != 0
         ww = fWeight * fSelect->EvalInstance(i);
         if (ww == 0) continue;
         if (fNfill == nfill0) {
            for (Int_t k = 0; k < fDimension; ++k) {
               if (!fVarMultiple[k]) fVal[k][fNfill] = fVar[k]->EvalInstance(0);
            }
         }
         if (fDimension == 0) fCurrentSubEntry = (Long64_t) i; // to fill TEntryListArray
      }
      for (Int_t k = 0; k < fDimension; ++k) {
         if (fVarMultiple[k]) fVal[k][fNfill] = fVar[k]->EvalInstance(i);
         else                 fVal[k][fNfill] = fVal[k][nfill0];
      }
      fW[fNfill] = ww;

      fNfill++;
      if (fNfill >= fTree->GetEstimate()) {
         TakeAction();
         fNfill = 0;
      }
   }
}

//______________________________________________________________________________
void TSelectorDraw::ProcessFillObject(Long64_t /*entry*/)
{
   // Called in the entry loop for all entries accepted by Select.
   // Case where the only variable returns an object (or pointer to).

   // Complex case with multiplicity.

   // Grab the array size of the formulas for this entry
   Int_t ndata = fManager->GetNdata();

   // No data at all, let's move on to the next entry.
   if (!ndata) return;

   Int_t nfill0 = fNfill;
   Double_t ww = 0;

   for (Int_t i = 0; i < ndata; i++) {
      if (i == 0) {
         if (fSelect) {
            fW[fNfill] = fWeight * fSelect->EvalInstance(0);
            if (!fW[fNfill] && !fSelectMultiple) return;
         } else fW[fNfill] = fWeight;
         ww = fW[nfill0];
      } else if (fSelectMultiple) {
         ww = fWeight * fSelect->EvalInstance(i);
         if (ww == 0) continue;
      }
      if (fDimension >= 1 && fVar[0]) {
         TClass *cl = fVar[0]->EvalClass();
         if (cl == TBits::Class()) {

            void *obj = fVar[0]->EvalObject(i);

            if (obj) {
               TBits *bits = (TBits*)obj;
               Int_t nbits = bits->GetNbits();

               Int_t nextbit = -1;
               while (1) {
                  nextbit = bits->FirstSetBit(nextbit + 1);
                  if (nextbit >= nbits) break;
                  fVal[0][fNfill] = nextbit;
                  fW[fNfill] =  ww;
                  fNfill++;
               }
            }

         } else {

            if (!TestBit(kWarn)) {
               Warning("ProcessFillObject",
                       "Not implemented for %s",
                       cl ? cl->GetName() : "unknown class");
               SetBit(kWarn);
            }

         }
      }
      if (fNfill >= fTree->GetEstimate()) {
         TakeAction();
         fNfill = 0;
      }
   }

}

//_______________________________________________________________________
void TSelectorDraw::SetEstimate(Long64_t)
{
   // Set number of entries to estimate variable limits.

   if (fVal) {
      for (Int_t i = 0; i < fValSize; ++i) {
         delete [] fVal[i];
         fVal[i] = 0;
      }
   }
   delete [] fW;   fW  = 0;
}

//______________________________________________________________________________
void TSelectorDraw::TakeAction()
{
   // Execute action for object obj fNfill times.

   Int_t i;
   //__________________________1-D histogram_______________________
   if (fAction ==  1)((TH1*)fObject)->FillN(fNfill, fVal[0], fW);
   //__________________________2-D histogram_______________________
   else if (fAction ==  2) {
      TH2 *h2 = (TH2*)fObject;
      for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
   }
   //__________________________Profile histogram_______________________
   else if (fAction ==  4)((TProfile*)fObject)->FillN(fNfill, fVal[1], fVal[0], fW);
   //__________________________Event List______________________________
   else if (fAction ==  5) {
      if (fObject->InheritsFrom(TEntryListArray::Class())) {
         TEntryListArray *enlistarray = (TEntryListArray*)fObject;
         Long64_t enumb = fTree->GetTree()->GetReadEntry();
         enlistarray->Enter(enumb, 0, fCurrentSubEntry);
      } else if (fObject->InheritsFrom(TEntryList::Class())) {
         TEntryList *enlist = (TEntryList*)fObject;
         Long64_t enumb = fTree->GetTree()->GetReadEntry();
         enlist->Enter(enumb);
      } else {
         TEventList *evlist = (TEventList*)fObject;
         Long64_t enumb = fTree->GetChainOffset() + fTree->GetTree()->GetReadEntry();
         if (evlist->GetIndex(enumb) < 0) evlist->Enter(enumb);
      }
   }
   //__________________________2D scatter plot_______________________
   else if (fAction == 12) {
      TH2 *h2 = (TH2*)fObject;
      if (h2->TestBit(TH1::kCanRebin) && h2->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
      }
      TGraph *pm = new TGraph(fNfill, fVal[1], fVal[0]);
      pm->SetEditable(kFALSE);
      pm->SetBit(kCanDelete);
      pm->SetMarkerStyle(fTree->GetMarkerStyle());
      pm->SetMarkerColor(fTree->GetMarkerColor());
      pm->SetMarkerSize(fTree->GetMarkerSize());
      pm->SetLineColor(fTree->GetLineColor());
      pm->SetLineWidth(fTree->GetLineWidth());
      pm->SetLineStyle(fTree->GetLineStyle());
      pm->SetFillColor(fTree->GetFillColor());
      pm->SetFillStyle(fTree->GetFillStyle());

      if (!fDraw && !strstr(fOption.Data(), "goff")) {
         if (fOption.Length() == 0 || strcasecmp(fOption.Data(), "same") == 0)  pm->Draw("p");
         else                                                                pm->Draw(fOption.Data());
      }
      if (!h2->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
      }
   }
   //__________________________3D scatter plot_______________________
   else if (fAction ==  3) {
      TH3 *h3 = (TH3*)fObject;
      if (!h3->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
      }
   } else if (fAction == 13) {
      TPolyMarker3D *pm3d = new TPolyMarker3D(fNfill);
      pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
      pm3d->SetMarkerColor(fTree->GetMarkerColor());
      pm3d->SetMarkerSize(fTree->GetMarkerSize());
      for (i = 0; i < fNfill; i++) {
         pm3d->SetPoint(i, fVal[2][i], fVal[1][i], fVal[0][i]);
      }
      pm3d->Draw();
      TH3 *h3 = (TH3*)fObject;
      if (!h3->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
      }
   }
   //__________________________3D scatter plot (3rd variable = col)__
   else if (fAction == 33) {
      TH2 *h2 = (TH2*)fObject;
      TakeEstimate();
      Int_t ncolors  = gStyle->GetNumberOfColors();
      TObjArray *grs = (TObjArray*)h2->GetListOfFunctions()->FindObject("graphs");
      Int_t col;
      TGraph *gr;
      if (!grs) {
         grs = new TObjArray(ncolors);
         grs->SetOwner();
         grs->SetName("graphs");
         h2->GetListOfFunctions()->Add(grs, "P");
         for (col = 0; col < ncolors; col++) {
            gr = new TGraph();
            gr->SetMarkerColor(gStyle->GetColorPalette(col));
            gr->SetMarkerStyle(fTree->GetMarkerStyle());
            gr->SetMarkerSize(fTree->GetMarkerSize());
            grs->AddAt(gr, col);
         }
      }
      h2->SetEntries(fNfill);
      h2->SetMinimum(fVmin[2]);
      h2->SetMaximum(fVmax[2]);
      // Fill the graphs acording to the color
      for (i = 0; i < fNfill; i++) {
         col = Int_t(ncolors * ((fVal[2][i] - fVmin[2]) / (fVmax[2] - fVmin[2])));
         if (col < 0) col = 0;
         if (col > ncolors - 1) col = ncolors - 1;
         gr = (TGraph*)grs->UncheckedAt(col);
         if (gr) gr->SetPoint(gr->GetN(), fVal[1][i], fVal[0][i]);
      }
      // Remove potential empty graphs
      for (col = 0; col < ncolors; col++) {
         gr = (TGraph*)grs->At(col);
         if (gr && gr->GetN() <= 0) grs->Remove(gr);
      }
   }
   //__________________________2D Profile Histogram__________________
   else if (fAction == 23) {
      TProfile2D *hp2 = (TProfile2D*)fObject;
      for (i = 0; i < fNfill; i++) hp2->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
   }
   //__________________________4D scatter plot_______________________
   else if (fAction ==  40) {
      TakeEstimate();
      TH3 *h3 = (TH3*)fObject;
      Int_t ncolors  = gStyle->GetNumberOfColors();
      if (ncolors == 0) {
         TColor::InitializeColors();
         ncolors  = gStyle->GetNumberOfColors();
      }
      TObjArray *pms = (TObjArray*)h3->GetListOfFunctions()->FindObject("polymarkers");
      Int_t col;
      TPolyMarker3D *pm3d;
      if (!pms) {
         pms = new TObjArray(ncolors);
         pms->SetOwner();
         pms->SetName("polymarkers");
         h3->GetListOfFunctions()->Add(pms);
         for (col = 0; col < ncolors; col++) {
            pm3d = new TPolyMarker3D();
            pm3d->SetMarkerColor(gStyle->GetColorPalette(col));
            pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
            pm3d->SetMarkerSize(fTree->GetMarkerSize());
            pms->AddAt(pm3d, col);
         }
      }
      h3->SetEntries(fNfill);
      h3->SetMinimum(fVmin[3]);
      h3->SetMaximum(fVmax[3]);
      for (i = 0; i < fNfill; i++) {
         col = Int_t(ncolors * ((fVal[3][i] - fVmin[3]) / (fVmax[3] - fVmin[3])));
         if (col > ncolors-1) col = ncolors-1;
         if (col < 0) col = 0;
         pm3d = (TPolyMarker3D*)pms->UncheckedAt(col);
         pm3d->SetPoint(pm3d->GetLastPoint() + 1, fVal[2][i], fVal[1][i], fVal[0][i]);
      }
   }
   //__________________________Parallel coordinates / candle chart_______________________
   else if (fAction == 6 || fAction == 7) {
      TakeEstimate();
      Bool_t candle = (fAction == 7);
      // Using CINT to avoid a dependency in TParallelCoord
      if (!fOption.Contains("goff"))
         gROOT->ProcessLineFast(TString::Format("TParallelCoord::BuildParallelCoord((TSelectorDraw*)0x%lx,0x%lx",
                                (ULong_t)this, (ULong_t)candle));
   } else if (fAction == 8) {
      //gROOT->ProcessLineFast(TString::Format("(new TGL5DDataSet((TTree *)0x%1x))->Draw(\"%s\");", fTree, fOption.Data()));
   }
   //__________________________something else_______________________
   else if (fAction < 0) {
      fAction = -fAction;
      TakeEstimate();
   }

   // Do we need to update screen?
   fSelectedRows += fNfill;
   if (!fTree->GetUpdate()) return;
   if (fSelectedRows > fDraw + fTree->GetUpdate()) {
      if (fDraw) gPad->Modified();
      else       fObject->Draw(fOption.Data());
      gPad->Update();
      fDraw = fSelectedRows;
   }
}

//______________________________________________________________________________
void TSelectorDraw::TakeEstimate()
{
   // Estimate limits for 1-D, 2-D or 3-D objects.

   Int_t i;
   Double_t rmin[3], rmax[3];
   Double_t vminOld[4], vmaxOld[4];
   for (i = 0; i < fValSize && i < 4; i++) {
      vminOld[i] = fVmin[i];
      vmaxOld[i] = fVmax[i];
   }
   for (i = 0; i < fValSize; ++i) {
      fVmin[i] = DBL_MAX;
      fVmax[i] = - DBL_MAX;
   }
   //__________________________1-D histogram_______________________
   if (fAction ==  1) {
      TH1 *h1 = (TH1*)fObject;
      if (fObject->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h1, fVmin[0], fVmax[0]);
      }
      h1->FillN(fNfill, fVal[0], fW);
   //__________________________2-D histogram_______________________
   } else if (fAction ==  2) {
      TH2 *h2 = (TH2*)fObject;
      if (fObject->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
      }
      for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
   //__________________________Profile histogram_______________________
   } else if (fAction ==  4) {
      TProfile *hp = (TProfile*)fObject;
      if (fObject->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hp, fVmin[1], fVmax[1]);
      }
      hp->FillN(fNfill, fVal[1], fVal[0], fW);
   //__________________________2D scatter plot_______________________
   } else if (fAction == 12) {
      TH2 *h2 = (TH2*)fObject;
      if (h2->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
         // In case the new lower limits of h2 axis are 0, it is better to set them to the minimum of
         // the data set (which should be >0) to avoid data cut when plotting in log scale.
         TAxis *aX = h2->GetXaxis();
         TAxis *aY = h2->GetYaxis();
         Double_t xmin = aX->GetXmin();
         Double_t ymin = aY->GetXmin();
         if (xmin == 0 || ymin == 0) {
            if (aX->GetBinUpEdge(aX->FindFixBin(0.01*aX->GetBinWidth(aX->GetFirst()))) > fVmin[1]) xmin = fVmin[1];
            if (aY->GetBinUpEdge(aY->FindFixBin(0.01*aY->GetBinWidth(aY->GetFirst()))) > fVmin[0]) ymin = fVmin[0];
            h2->SetBins(aX->GetNbins(), xmin, aX->GetXmax(), aY->GetNbins(), ymin, aY->GetXmax());
         }
      }

      if (!strstr(fOption.Data(), "same") && !strstr(fOption.Data(), "goff")) {
         if (!h2->TestBit(kCanDelete)) {
            // case like: T.Draw("y:x>>myhist")
            // we must draw a copy before filling the histogram h2=myhist
            // because h2 will be filled below and we do not want to show
            // the binned scatter-plot, the TGraph being better.
            TH1 *h2c = h2->DrawCopy(fOption.Data());
            if (h2c) h2c->SetStats(kFALSE);
         } else {
            // case like: T.Draw("y:x")
            // h2 is a temporary histogram (htemp). This histogram
            // will be automatically deleted by TPad::Clear
            h2->Draw();
         }
         gPad->Update();
      }
      TGraph *pm = new TGraph(fNfill, fVal[1], fVal[0]);
      pm->SetEditable(kFALSE);
      pm->SetBit(kCanDelete);
      pm->SetMarkerStyle(fTree->GetMarkerStyle());
      pm->SetMarkerColor(fTree->GetMarkerColor());
      pm->SetMarkerSize(fTree->GetMarkerSize());
      pm->SetLineColor(fTree->GetLineColor());
      pm->SetLineWidth(fTree->GetLineWidth());
      pm->SetLineStyle(fTree->GetLineStyle());
      pm->SetFillColor(fTree->GetFillColor());
      pm->SetFillStyle(fTree->GetFillStyle());
      if (!fDraw && !strstr(fOption.Data(),"goff")) {
         if (fOption.Length() == 0 || strcasecmp(fOption.Data(),"same")==0) {
            pm->Draw("p");
         }
         else {
            TString opt = fOption;
            opt.ToLower();
            if (opt.Contains("a")) {
               TString temp(opt);
               temp.ReplaceAll("same","");
               if (temp.Contains("a")) {
                  if (h2->TestBit(kCanDelete)) {
                     // h2 will be deleted, the axis setting is delegated to only
                     // the TGraph.
                     h2 = 0;
                  }
               }
            }
            pm->Draw(fOption.Data());
         }
      }
      if (h2 && !h2->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) h2->Fill(fVal[1][i], fVal[0][i], fW[i]);
      }
   //__________________________3D scatter plot with option col_______________________
   } else if (fAction == 33) {
      TH2 *h2 = (TH2*)fObject;
      Bool_t process2 = kFALSE;
      if (h2->TestBit(TH1::kCanRebin)) {
         if (vminOld[2] == DBL_MAX)
            process2 = kTRUE;
         for (i = 0; i < fValSize && i < 4; i++) {
            fVmin[i] = vminOld[i];
            fVmax[i] = vmaxOld[i];
         }
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
            if (process2) {
               if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
               if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
            }
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h2, fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
         // In case the new lower limits of h2 axis are 0, it is better to set them to the minimum of
         // the data set (which should be >0) to avoid data cut when plotting in log scale.
         TAxis *aX = h2->GetXaxis();
         TAxis *aY = h2->GetYaxis();
         Double_t xmin = aX->GetXmin();
         Double_t ymin = aY->GetXmin();
         if (xmin == 0 || ymin == 0) {
            if (aX->GetBinUpEdge(aX->FindFixBin(0.01*aX->GetBinWidth(aX->GetFirst()))) > fVmin[1]) xmin = fVmin[1];
            if (aY->GetBinUpEdge(aY->FindFixBin(0.01*aY->GetBinWidth(aY->GetFirst()))) > fVmin[0]) ymin = fVmin[0];
            h2->SetBins(aX->GetNbins(), xmin, aX->GetXmax(), aY->GetNbins(), ymin, aY->GetXmax());
         }
      } else {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
            if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
         }
      }
      //__________________________3D scatter plot_______________________
   } else if (fAction == 3 || fAction == 13) {
      TH3 *h3 = (TH3*)fObject;
      if (fObject->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
            if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
            if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h3, fVmin[2], fVmax[2], fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
      }
      if (fAction == 3) {
         for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
         return;
      }
      if (!strstr(fOption.Data(), "same") && !strstr(fOption.Data(), "goff")) {
         if (!h3->TestBit(kCanDelete)) {
            // case like: T.Draw("y:x>>myhist")
            // we must draw a copy before filling the histogram h3=myhist
            // because h3 will be filled below and we do not want to show
            // the binned scatter-plot, the TGraph being better.
            TH1 *h3c = h3->DrawCopy(fOption.Data());
            if (h3c) h3c->SetStats(kFALSE);
         } else {
            // case like: T.Draw("y:x")
            // h3 is a temporary histogram (htemp). This histogram
            // will be automatically deleted by TPad::Clear
            h3->Draw(fOption.Data());
         }
         gPad->Update();
      } else {
         rmin[0] = fVmin[2]; rmin[1] = fVmin[1]; rmin[2] = fVmin[0];
         rmax[0] = fVmax[2]; rmax[1] = fVmax[1]; rmax[2] = fVmax[0];
         gPad->Clear();
         gPad->Range(-1, -1, 1, 1);
         TView::CreateView(1, rmin, rmax);
      }
      TPolyMarker3D *pm3d = new TPolyMarker3D(fNfill);
      pm3d->SetMarkerStyle(fTree->GetMarkerStyle());
      pm3d->SetMarkerColor(fTree->GetMarkerColor());
      pm3d->SetMarkerSize(fTree->GetMarkerSize());
      for (i = 0; i < fNfill; i++) {
         pm3d->SetPoint(i, fVal[2][i], fVal[1][i], fVal[0][i]);
      }
      if (!fDraw && !strstr(fOption.Data(), "goff")) pm3d->Draw();
      if (!h3->TestBit(kCanDelete)) {
         for (i = 0; i < fNfill; i++) h3->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
      }

   //__________________________2D Profile Histogram__________________
   } else if (fAction == 23) {
      TProfile2D *hp = (TProfile2D*)fObject;
      if (hp->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
            if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
            if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(hp, fVmin[2], fVmax[2], fVmin[1], fVmax[1]);
      }
      for (i = 0; i < fNfill; i++) hp->Fill(fVal[2][i], fVal[1][i], fVal[0][i], fW[i]);
   //__________________________4D scatter plot_______________________
   } else if (fAction == 40) {
      TH3 *h3 = (TH3*)fObject;
      if (fObject->TestBit(TH1::kCanRebin)) {
         for (i = 0; i < fValSize && i < 4; i++) {
            fVmin[i] = vminOld[i];
            fVmax[i] = vmaxOld[i];
         }
         for (i = 0; i < fNfill; i++) {
            if (fVmin[0] > fVal[0][i]) fVmin[0] = fVal[0][i];
            if (fVmax[0] < fVal[0][i]) fVmax[0] = fVal[0][i];
            if (fVmin[1] > fVal[1][i]) fVmin[1] = fVal[1][i];
            if (fVmax[1] < fVal[1][i]) fVmax[1] = fVal[1][i];
            if (fVmin[2] > fVal[2][i]) fVmin[2] = fVal[2][i];
            if (fVmax[2] < fVal[2][i]) fVmax[2] = fVal[2][i];
            if (fVmin[3] > fVal[3][i]) fVmin[3] = fVal[3][i];
            if (fVmax[3] < fVal[3][i]) fVmax[3] = fVal[3][i];
         }
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(h3, fVmin[2], fVmax[2], fVmin[1], fVmax[1], fVmin[0], fVmax[0]);
      } else {
         for (i = 0; i < fNfill; i++) {
            if (fVmin[3] > fVal[3][i]) fVmin[3] = fVal[3][i];
            if (fVmax[3] < fVal[3][i]) fVmax[3] = fVal[3][i];
         }
      }
   }
   //__________________________Parallel coordinates plot / candle chart_______________________
   else if (fAction == 6 || fAction == 7) {
      for (i = 0; i < fDimension; ++i) {
         for (Long64_t entry = 0; entry < fNfill; entry++) {
            if (fVmin[i] > fVal[i][entry]) fVmin[i] = fVal[i][entry];
            if (fVmax[i] < fVal[i][entry]) fVmax[i] = fVal[i][entry];
         }
      }
   }
}

//______________________________________________________________________________
void TSelectorDraw::Terminate()
{
   // Called at the end of a loop on a TTree.

   if (fNfill) TakeAction();

   if ((fSelectedRows == 0) && (TestBit(kCustomHistogram) == 0)) fDraw = 1; // do not draw

   SetStatus(fSelectedRows);
}
 TSelectorDraw.cxx:1
 TSelectorDraw.cxx:2
 TSelectorDraw.cxx:3
 TSelectorDraw.cxx:4
 TSelectorDraw.cxx:5
 TSelectorDraw.cxx:6
 TSelectorDraw.cxx:7
 TSelectorDraw.cxx:8
 TSelectorDraw.cxx:9
 TSelectorDraw.cxx:10
 TSelectorDraw.cxx:11
 TSelectorDraw.cxx:12
 TSelectorDraw.cxx:13
 TSelectorDraw.cxx:14
 TSelectorDraw.cxx:15
 TSelectorDraw.cxx:16
 TSelectorDraw.cxx:17
 TSelectorDraw.cxx:18
 TSelectorDraw.cxx:19
 TSelectorDraw.cxx:20
 TSelectorDraw.cxx:21
 TSelectorDraw.cxx:22
 TSelectorDraw.cxx:23
 TSelectorDraw.cxx:24
 TSelectorDraw.cxx:25
 TSelectorDraw.cxx:26
 TSelectorDraw.cxx:27
 TSelectorDraw.cxx:28
 TSelectorDraw.cxx:29
 TSelectorDraw.cxx:30
 TSelectorDraw.cxx:31
 TSelectorDraw.cxx:32
 TSelectorDraw.cxx:33
 TSelectorDraw.cxx:34
 TSelectorDraw.cxx:35
 TSelectorDraw.cxx:36
 TSelectorDraw.cxx:37
 TSelectorDraw.cxx:38
 TSelectorDraw.cxx:39
 TSelectorDraw.cxx:40
 TSelectorDraw.cxx:41
 TSelectorDraw.cxx:42
 TSelectorDraw.cxx:43
 TSelectorDraw.cxx:44
 TSelectorDraw.cxx:45
 TSelectorDraw.cxx:46
 TSelectorDraw.cxx:47
 TSelectorDraw.cxx:48
 TSelectorDraw.cxx:49
 TSelectorDraw.cxx:50
 TSelectorDraw.cxx:51
 TSelectorDraw.cxx:52
 TSelectorDraw.cxx:53
 TSelectorDraw.cxx:54
 TSelectorDraw.cxx:55
 TSelectorDraw.cxx:56
 TSelectorDraw.cxx:57
 TSelectorDraw.cxx:58
 TSelectorDraw.cxx:59
 TSelectorDraw.cxx:60
 TSelectorDraw.cxx:61
 TSelectorDraw.cxx:62
 TSelectorDraw.cxx:63
 TSelectorDraw.cxx:64
 TSelectorDraw.cxx:65
 TSelectorDraw.cxx:66
 TSelectorDraw.cxx:67
 TSelectorDraw.cxx:68
 TSelectorDraw.cxx:69
 TSelectorDraw.cxx:70
 TSelectorDraw.cxx:71
 TSelectorDraw.cxx:72
 TSelectorDraw.cxx:73
 TSelectorDraw.cxx:74
 TSelectorDraw.cxx:75
 TSelectorDraw.cxx:76
 TSelectorDraw.cxx:77
 TSelectorDraw.cxx:78
 TSelectorDraw.cxx:79
 TSelectorDraw.cxx:80
 TSelectorDraw.cxx:81
 TSelectorDraw.cxx:82
 TSelectorDraw.cxx:83
 TSelectorDraw.cxx:84
 TSelectorDraw.cxx:85
 TSelectorDraw.cxx:86
 TSelectorDraw.cxx:87
 TSelectorDraw.cxx:88
 TSelectorDraw.cxx:89
 TSelectorDraw.cxx:90
 TSelectorDraw.cxx:91
 TSelectorDraw.cxx:92
 TSelectorDraw.cxx:93
 TSelectorDraw.cxx:94
 TSelectorDraw.cxx:95
 TSelectorDraw.cxx:96
 TSelectorDraw.cxx:97
 TSelectorDraw.cxx:98
 TSelectorDraw.cxx:99
 TSelectorDraw.cxx:100
 TSelectorDraw.cxx:101
 TSelectorDraw.cxx:102
 TSelectorDraw.cxx:103
 TSelectorDraw.cxx:104
 TSelectorDraw.cxx:105
 TSelectorDraw.cxx:106
 TSelectorDraw.cxx:107
 TSelectorDraw.cxx:108
 TSelectorDraw.cxx:109
 TSelectorDraw.cxx:110
 TSelectorDraw.cxx:111
 TSelectorDraw.cxx:112
 TSelectorDraw.cxx:113
 TSelectorDraw.cxx:114
 TSelectorDraw.cxx:115
 TSelectorDraw.cxx:116
 TSelectorDraw.cxx:117
 TSelectorDraw.cxx:118
 TSelectorDraw.cxx:119
 TSelectorDraw.cxx:120
 TSelectorDraw.cxx:121
 TSelectorDraw.cxx:122
 TSelectorDraw.cxx:123
 TSelectorDraw.cxx:124
 TSelectorDraw.cxx:125
 TSelectorDraw.cxx:126
 TSelectorDraw.cxx:127
 TSelectorDraw.cxx:128
 TSelectorDraw.cxx:129
 TSelectorDraw.cxx:130
 TSelectorDraw.cxx:131
 TSelectorDraw.cxx:132
 TSelectorDraw.cxx:133
 TSelectorDraw.cxx:134
 TSelectorDraw.cxx:135
 TSelectorDraw.cxx:136
 TSelectorDraw.cxx:137
 TSelectorDraw.cxx:138
 TSelectorDraw.cxx:139
 TSelectorDraw.cxx:140
 TSelectorDraw.cxx:141
 TSelectorDraw.cxx:142
 TSelectorDraw.cxx:143
 TSelectorDraw.cxx:144
 TSelectorDraw.cxx:145
 TSelectorDraw.cxx:146
 TSelectorDraw.cxx:147
 TSelectorDraw.cxx:148
 TSelectorDraw.cxx:149
 TSelectorDraw.cxx:150
 TSelectorDraw.cxx:151
 TSelectorDraw.cxx:152
 TSelectorDraw.cxx:153
 TSelectorDraw.cxx:154
 TSelectorDraw.cxx:155
 TSelectorDraw.cxx:156
 TSelectorDraw.cxx:157
 TSelectorDraw.cxx:158
 TSelectorDraw.cxx:159
 TSelectorDraw.cxx:160
 TSelectorDraw.cxx:161
 TSelectorDraw.cxx:162
 TSelectorDraw.cxx:163
 TSelectorDraw.cxx:164
 TSelectorDraw.cxx:165
 TSelectorDraw.cxx:166
 TSelectorDraw.cxx:167
 TSelectorDraw.cxx:168
 TSelectorDraw.cxx:169
 TSelectorDraw.cxx:170
 TSelectorDraw.cxx:171
 TSelectorDraw.cxx:172
 TSelectorDraw.cxx:173
 TSelectorDraw.cxx:174
 TSelectorDraw.cxx:175
 TSelectorDraw.cxx:176
 TSelectorDraw.cxx:177
 TSelectorDraw.cxx:178
 TSelectorDraw.cxx:179
 TSelectorDraw.cxx:180
 TSelectorDraw.cxx:181
 TSelectorDraw.cxx:182
 TSelectorDraw.cxx:183
 TSelectorDraw.cxx:184
 TSelectorDraw.cxx:185
 TSelectorDraw.cxx:186
 TSelectorDraw.cxx:187
 TSelectorDraw.cxx:188
 TSelectorDraw.cxx:189
 TSelectorDraw.cxx:190
 TSelectorDraw.cxx:191
 TSelectorDraw.cxx:192
 TSelectorDraw.cxx:193
 TSelectorDraw.cxx:194
 TSelectorDraw.cxx:195
 TSelectorDraw.cxx:196
 TSelectorDraw.cxx:197
 TSelectorDraw.cxx:198
 TSelectorDraw.cxx:199
 TSelectorDraw.cxx:200
 TSelectorDraw.cxx:201
 TSelectorDraw.cxx:202
 TSelectorDraw.cxx:203
 TSelectorDraw.cxx:204
 TSelectorDraw.cxx:205
 TSelectorDraw.cxx:206
 TSelectorDraw.cxx:207
 TSelectorDraw.cxx:208
 TSelectorDraw.cxx:209
 TSelectorDraw.cxx:210
 TSelectorDraw.cxx:211
 TSelectorDraw.cxx:212
 TSelectorDraw.cxx:213
 TSelectorDraw.cxx:214
 TSelectorDraw.cxx:215
 TSelectorDraw.cxx:216
 TSelectorDraw.cxx:217
 TSelectorDraw.cxx:218
 TSelectorDraw.cxx:219
 TSelectorDraw.cxx:220
 TSelectorDraw.cxx:221
 TSelectorDraw.cxx:222
 TSelectorDraw.cxx:223
 TSelectorDraw.cxx:224
 TSelectorDraw.cxx:225
 TSelectorDraw.cxx:226
 TSelectorDraw.cxx:227
 TSelectorDraw.cxx:228
 TSelectorDraw.cxx:229
 TSelectorDraw.cxx:230
 TSelectorDraw.cxx:231
 TSelectorDraw.cxx:232
 TSelectorDraw.cxx:233
 TSelectorDraw.cxx:234
 TSelectorDraw.cxx:235
 TSelectorDraw.cxx:236
 TSelectorDraw.cxx:237
 TSelectorDraw.cxx:238
 TSelectorDraw.cxx:239
 TSelectorDraw.cxx:240
 TSelectorDraw.cxx:241
 TSelectorDraw.cxx:242
 TSelectorDraw.cxx:243
 TSelectorDraw.cxx:244
 TSelectorDraw.cxx:245
 TSelectorDraw.cxx:246
 TSelectorDraw.cxx:247
 TSelectorDraw.cxx:248
 TSelectorDraw.cxx:249
 TSelectorDraw.cxx:250
 TSelectorDraw.cxx:251
 TSelectorDraw.cxx:252
 TSelectorDraw.cxx:253
 TSelectorDraw.cxx:254
 TSelectorDraw.cxx:255
 TSelectorDraw.cxx:256
 TSelectorDraw.cxx:257
 TSelectorDraw.cxx:258
 TSelectorDraw.cxx:259
 TSelectorDraw.cxx:260
 TSelectorDraw.cxx:261
 TSelectorDraw.cxx:262
 TSelectorDraw.cxx:263
 TSelectorDraw.cxx:264
 TSelectorDraw.cxx:265
 TSelectorDraw.cxx:266
 TSelectorDraw.cxx:267
 TSelectorDraw.cxx:268
 TSelectorDraw.cxx:269
 TSelectorDraw.cxx:270
 TSelectorDraw.cxx:271
 TSelectorDraw.cxx:272
 TSelectorDraw.cxx:273
 TSelectorDraw.cxx:274
 TSelectorDraw.cxx:275
 TSelectorDraw.cxx:276
 TSelectorDraw.cxx:277
 TSelectorDraw.cxx:278
 TSelectorDraw.cxx:279
 TSelectorDraw.cxx:280
 TSelectorDraw.cxx:281
 TSelectorDraw.cxx:282
 TSelectorDraw.cxx:283
 TSelectorDraw.cxx:284
 TSelectorDraw.cxx:285
 TSelectorDraw.cxx:286
 TSelectorDraw.cxx:287
 TSelectorDraw.cxx:288
 TSelectorDraw.cxx:289
 TSelectorDraw.cxx:290
 TSelectorDraw.cxx:291
 TSelectorDraw.cxx:292
 TSelectorDraw.cxx:293
 TSelectorDraw.cxx:294
 TSelectorDraw.cxx:295
 TSelectorDraw.cxx:296
 TSelectorDraw.cxx:297
 TSelectorDraw.cxx:298
 TSelectorDraw.cxx:299
 TSelectorDraw.cxx:300
 TSelectorDraw.cxx:301
 TSelectorDraw.cxx:302
 TSelectorDraw.cxx:303
 TSelectorDraw.cxx:304
 TSelectorDraw.cxx:305
 TSelectorDraw.cxx:306
 TSelectorDraw.cxx:307
 TSelectorDraw.cxx:308
 TSelectorDraw.cxx:309
 TSelectorDraw.cxx:310
 TSelectorDraw.cxx:311
 TSelectorDraw.cxx:312
 TSelectorDraw.cxx:313
 TSelectorDraw.cxx:314
 TSelectorDraw.cxx:315
 TSelectorDraw.cxx:316
 TSelectorDraw.cxx:317
 TSelectorDraw.cxx:318
 TSelectorDraw.cxx:319
 TSelectorDraw.cxx:320
 TSelectorDraw.cxx:321
 TSelectorDraw.cxx:322
 TSelectorDraw.cxx:323
 TSelectorDraw.cxx:324
 TSelectorDraw.cxx:325
 TSelectorDraw.cxx:326
 TSelectorDraw.cxx:327
 TSelectorDraw.cxx:328
 TSelectorDraw.cxx:329
 TSelectorDraw.cxx:330
 TSelectorDraw.cxx:331
 TSelectorDraw.cxx:332
 TSelectorDraw.cxx:333
 TSelectorDraw.cxx:334
 TSelectorDraw.cxx:335
 TSelectorDraw.cxx:336
 TSelectorDraw.cxx:337
 TSelectorDraw.cxx:338
 TSelectorDraw.cxx:339
 TSelectorDraw.cxx:340
 TSelectorDraw.cxx:341
 TSelectorDraw.cxx:342
 TSelectorDraw.cxx:343
 TSelectorDraw.cxx:344
 TSelectorDraw.cxx:345
 TSelectorDraw.cxx:346
 TSelectorDraw.cxx:347
 TSelectorDraw.cxx:348
 TSelectorDraw.cxx:349
 TSelectorDraw.cxx:350
 TSelectorDraw.cxx:351
 TSelectorDraw.cxx:352
 TSelectorDraw.cxx:353
 TSelectorDraw.cxx:354
 TSelectorDraw.cxx:355
 TSelectorDraw.cxx:356
 TSelectorDraw.cxx:357
 TSelectorDraw.cxx:358
 TSelectorDraw.cxx:359
 TSelectorDraw.cxx:360
 TSelectorDraw.cxx:361
 TSelectorDraw.cxx:362
 TSelectorDraw.cxx:363
 TSelectorDraw.cxx:364
 TSelectorDraw.cxx:365
 TSelectorDraw.cxx:366
 TSelectorDraw.cxx:367
 TSelectorDraw.cxx:368
 TSelectorDraw.cxx:369
 TSelectorDraw.cxx:370
 TSelectorDraw.cxx:371
 TSelectorDraw.cxx:372
 TSelectorDraw.cxx:373
 TSelectorDraw.cxx:374
 TSelectorDraw.cxx:375
 TSelectorDraw.cxx:376
 TSelectorDraw.cxx:377
 TSelectorDraw.cxx:378
 TSelectorDraw.cxx:379
 TSelectorDraw.cxx:380
 TSelectorDraw.cxx:381
 TSelectorDraw.cxx:382
 TSelectorDraw.cxx:383
 TSelectorDraw.cxx:384
 TSelectorDraw.cxx:385
 TSelectorDraw.cxx:386
 TSelectorDraw.cxx:387
 TSelectorDraw.cxx:388
 TSelectorDraw.cxx:389
 TSelectorDraw.cxx:390
 TSelectorDraw.cxx:391
 TSelectorDraw.cxx:392
 TSelectorDraw.cxx:393
 TSelectorDraw.cxx:394
 TSelectorDraw.cxx:395
 TSelectorDraw.cxx:396
 TSelectorDraw.cxx:397
 TSelectorDraw.cxx:398
 TSelectorDraw.cxx:399
 TSelectorDraw.cxx:400
 TSelectorDraw.cxx:401
 TSelectorDraw.cxx:402
 TSelectorDraw.cxx:403
 TSelectorDraw.cxx:404
 TSelectorDraw.cxx:405
 TSelectorDraw.cxx:406
 TSelectorDraw.cxx:407
 TSelectorDraw.cxx:408
 TSelectorDraw.cxx:409
 TSelectorDraw.cxx:410
 TSelectorDraw.cxx:411
 TSelectorDraw.cxx:412
 TSelectorDraw.cxx:413
 TSelectorDraw.cxx:414
 TSelectorDraw.cxx:415
 TSelectorDraw.cxx:416
 TSelectorDraw.cxx:417
 TSelectorDraw.cxx:418
 TSelectorDraw.cxx:419
 TSelectorDraw.cxx:420
 TSelectorDraw.cxx:421
 TSelectorDraw.cxx:422
 TSelectorDraw.cxx:423
 TSelectorDraw.cxx:424
 TSelectorDraw.cxx:425
 TSelectorDraw.cxx:426
 TSelectorDraw.cxx:427
 TSelectorDraw.cxx:428
 TSelectorDraw.cxx:429
 TSelectorDraw.cxx:430
 TSelectorDraw.cxx:431
 TSelectorDraw.cxx:432
 TSelectorDraw.cxx:433
 TSelectorDraw.cxx:434
 TSelectorDraw.cxx:435
 TSelectorDraw.cxx:436
 TSelectorDraw.cxx:437
 TSelectorDraw.cxx:438
 TSelectorDraw.cxx:439
 TSelectorDraw.cxx:440
 TSelectorDraw.cxx:441
 TSelectorDraw.cxx:442
 TSelectorDraw.cxx:443
 TSelectorDraw.cxx:444
 TSelectorDraw.cxx:445
 TSelectorDraw.cxx:446
 TSelectorDraw.cxx:447
 TSelectorDraw.cxx:448
 TSelectorDraw.cxx:449
 TSelectorDraw.cxx:450
 TSelectorDraw.cxx:451
 TSelectorDraw.cxx:452
 TSelectorDraw.cxx:453
 TSelectorDraw.cxx:454
 TSelectorDraw.cxx:455
 TSelectorDraw.cxx:456
 TSelectorDraw.cxx:457
 TSelectorDraw.cxx:458
 TSelectorDraw.cxx:459
 TSelectorDraw.cxx:460
 TSelectorDraw.cxx:461
 TSelectorDraw.cxx:462
 TSelectorDraw.cxx:463
 TSelectorDraw.cxx:464
 TSelectorDraw.cxx:465
 TSelectorDraw.cxx:466
 TSelectorDraw.cxx:467
 TSelectorDraw.cxx:468
 TSelectorDraw.cxx:469
 TSelectorDraw.cxx:470
 TSelectorDraw.cxx:471
 TSelectorDraw.cxx:472
 TSelectorDraw.cxx:473
 TSelectorDraw.cxx:474
 TSelectorDraw.cxx:475
 TSelectorDraw.cxx:476
 TSelectorDraw.cxx:477
 TSelectorDraw.cxx:478
 TSelectorDraw.cxx:479
 TSelectorDraw.cxx:480
 TSelectorDraw.cxx:481
 TSelectorDraw.cxx:482
 TSelectorDraw.cxx:483
 TSelectorDraw.cxx:484
 TSelectorDraw.cxx:485
 TSelectorDraw.cxx:486
 TSelectorDraw.cxx:487
 TSelectorDraw.cxx:488
 TSelectorDraw.cxx:489
 TSelectorDraw.cxx:490
 TSelectorDraw.cxx:491
 TSelectorDraw.cxx:492
 TSelectorDraw.cxx:493
 TSelectorDraw.cxx:494
 TSelectorDraw.cxx:495
 TSelectorDraw.cxx:496
 TSelectorDraw.cxx:497
 TSelectorDraw.cxx:498
 TSelectorDraw.cxx:499
 TSelectorDraw.cxx:500
 TSelectorDraw.cxx:501
 TSelectorDraw.cxx:502
 TSelectorDraw.cxx:503
 TSelectorDraw.cxx:504
 TSelectorDraw.cxx:505
 TSelectorDraw.cxx:506
 TSelectorDraw.cxx:507
 TSelectorDraw.cxx:508
 TSelectorDraw.cxx:509
 TSelectorDraw.cxx:510
 TSelectorDraw.cxx:511
 TSelectorDraw.cxx:512
 TSelectorDraw.cxx:513
 TSelectorDraw.cxx:514
 TSelectorDraw.cxx:515
 TSelectorDraw.cxx:516
 TSelectorDraw.cxx:517
 TSelectorDraw.cxx:518
 TSelectorDraw.cxx:519
 TSelectorDraw.cxx:520
 TSelectorDraw.cxx:521
 TSelectorDraw.cxx:522
 TSelectorDraw.cxx:523
 TSelectorDraw.cxx:524
 TSelectorDraw.cxx:525
 TSelectorDraw.cxx:526
 TSelectorDraw.cxx:527
 TSelectorDraw.cxx:528
 TSelectorDraw.cxx:529
 TSelectorDraw.cxx:530
 TSelectorDraw.cxx:531
 TSelectorDraw.cxx:532
 TSelectorDraw.cxx:533
 TSelectorDraw.cxx:534
 TSelectorDraw.cxx:535
 TSelectorDraw.cxx:536
 TSelectorDraw.cxx:537
 TSelectorDraw.cxx:538
 TSelectorDraw.cxx:539
 TSelectorDraw.cxx:540
 TSelectorDraw.cxx:541
 TSelectorDraw.cxx:542
 TSelectorDraw.cxx:543
 TSelectorDraw.cxx:544
 TSelectorDraw.cxx:545
 TSelectorDraw.cxx:546
 TSelectorDraw.cxx:547
 TSelectorDraw.cxx:548
 TSelectorDraw.cxx:549
 TSelectorDraw.cxx:550
 TSelectorDraw.cxx:551
 TSelectorDraw.cxx:552
 TSelectorDraw.cxx:553
 TSelectorDraw.cxx:554
 TSelectorDraw.cxx:555
 TSelectorDraw.cxx:556
 TSelectorDraw.cxx:557
 TSelectorDraw.cxx:558
 TSelectorDraw.cxx:559
 TSelectorDraw.cxx:560
 TSelectorDraw.cxx:561
 TSelectorDraw.cxx:562
 TSelectorDraw.cxx:563
 TSelectorDraw.cxx:564
 TSelectorDraw.cxx:565
 TSelectorDraw.cxx:566
 TSelectorDraw.cxx:567
 TSelectorDraw.cxx:568
 TSelectorDraw.cxx:569
 TSelectorDraw.cxx:570
 TSelectorDraw.cxx:571
 TSelectorDraw.cxx:572
 TSelectorDraw.cxx:573
 TSelectorDraw.cxx:574
 TSelectorDraw.cxx:575
 TSelectorDraw.cxx:576
 TSelectorDraw.cxx:577
 TSelectorDraw.cxx:578
 TSelectorDraw.cxx:579
 TSelectorDraw.cxx:580
 TSelectorDraw.cxx:581
 TSelectorDraw.cxx:582
 TSelectorDraw.cxx:583
 TSelectorDraw.cxx:584
 TSelectorDraw.cxx:585
 TSelectorDraw.cxx:586
 TSelectorDraw.cxx:587
 TSelectorDraw.cxx:588
 TSelectorDraw.cxx:589
 TSelectorDraw.cxx:590
 TSelectorDraw.cxx:591
 TSelectorDraw.cxx:592
 TSelectorDraw.cxx:593
 TSelectorDraw.cxx:594
 TSelectorDraw.cxx:595
 TSelectorDraw.cxx:596
 TSelectorDraw.cxx:597
 TSelectorDraw.cxx:598
 TSelectorDraw.cxx:599
 TSelectorDraw.cxx:600
 TSelectorDraw.cxx:601
 TSelectorDraw.cxx:602
 TSelectorDraw.cxx:603
 TSelectorDraw.cxx:604
 TSelectorDraw.cxx:605
 TSelectorDraw.cxx:606
 TSelectorDraw.cxx:607
 TSelectorDraw.cxx:608
 TSelectorDraw.cxx:609
 TSelectorDraw.cxx:610
 TSelectorDraw.cxx:611
 TSelectorDraw.cxx:612
 TSelectorDraw.cxx:613
 TSelectorDraw.cxx:614
 TSelectorDraw.cxx:615
 TSelectorDraw.cxx:616
 TSelectorDraw.cxx:617
 TSelectorDraw.cxx:618
 TSelectorDraw.cxx:619
 TSelectorDraw.cxx:620
 TSelectorDraw.cxx:621
 TSelectorDraw.cxx:622
 TSelectorDraw.cxx:623
 TSelectorDraw.cxx:624
 TSelectorDraw.cxx:625
 TSelectorDraw.cxx:626
 TSelectorDraw.cxx:627
 TSelectorDraw.cxx:628
 TSelectorDraw.cxx:629
 TSelectorDraw.cxx:630
 TSelectorDraw.cxx:631
 TSelectorDraw.cxx:632
 TSelectorDraw.cxx:633
 TSelectorDraw.cxx:634
 TSelectorDraw.cxx:635
 TSelectorDraw.cxx:636
 TSelectorDraw.cxx:637
 TSelectorDraw.cxx:638
 TSelectorDraw.cxx:639
 TSelectorDraw.cxx:640
 TSelectorDraw.cxx:641
 TSelectorDraw.cxx:642
 TSelectorDraw.cxx:643
 TSelectorDraw.cxx:644
 TSelectorDraw.cxx:645
 TSelectorDraw.cxx:646
 TSelectorDraw.cxx:647
 TSelectorDraw.cxx:648
 TSelectorDraw.cxx:649
 TSelectorDraw.cxx:650
 TSelectorDraw.cxx:651
 TSelectorDraw.cxx:652
 TSelectorDraw.cxx:653
 TSelectorDraw.cxx:654
 TSelectorDraw.cxx:655
 TSelectorDraw.cxx:656
 TSelectorDraw.cxx:657
 TSelectorDraw.cxx:658
 TSelectorDraw.cxx:659
 TSelectorDraw.cxx:660
 TSelectorDraw.cxx:661
 TSelectorDraw.cxx:662
 TSelectorDraw.cxx:663
 TSelectorDraw.cxx:664
 TSelectorDraw.cxx:665
 TSelectorDraw.cxx:666
 TSelectorDraw.cxx:667
 TSelectorDraw.cxx:668
 TSelectorDraw.cxx:669
 TSelectorDraw.cxx:670
 TSelectorDraw.cxx:671
 TSelectorDraw.cxx:672
 TSelectorDraw.cxx:673
 TSelectorDraw.cxx:674
 TSelectorDraw.cxx:675
 TSelectorDraw.cxx:676
 TSelectorDraw.cxx:677
 TSelectorDraw.cxx:678
 TSelectorDraw.cxx:679
 TSelectorDraw.cxx:680
 TSelectorDraw.cxx:681
 TSelectorDraw.cxx:682
 TSelectorDraw.cxx:683
 TSelectorDraw.cxx:684
 TSelectorDraw.cxx:685
 TSelectorDraw.cxx:686
 TSelectorDraw.cxx:687
 TSelectorDraw.cxx:688
 TSelectorDraw.cxx:689
 TSelectorDraw.cxx:690
 TSelectorDraw.cxx:691
 TSelectorDraw.cxx:692
 TSelectorDraw.cxx:693
 TSelectorDraw.cxx:694
 TSelectorDraw.cxx:695
 TSelectorDraw.cxx:696
 TSelectorDraw.cxx:697
 TSelectorDraw.cxx:698
 TSelectorDraw.cxx:699
 TSelectorDraw.cxx:700
 TSelectorDraw.cxx:701
 TSelectorDraw.cxx:702
 TSelectorDraw.cxx:703
 TSelectorDraw.cxx:704
 TSelectorDraw.cxx:705
 TSelectorDraw.cxx:706
 TSelectorDraw.cxx:707
 TSelectorDraw.cxx:708
 TSelectorDraw.cxx:709
 TSelectorDraw.cxx:710
 TSelectorDraw.cxx:711
 TSelectorDraw.cxx:712
 TSelectorDraw.cxx:713
 TSelectorDraw.cxx:714
 TSelectorDraw.cxx:715
 TSelectorDraw.cxx:716
 TSelectorDraw.cxx:717
 TSelectorDraw.cxx:718
 TSelectorDraw.cxx:719
 TSelectorDraw.cxx:720
 TSelectorDraw.cxx:721
 TSelectorDraw.cxx:722
 TSelectorDraw.cxx:723
 TSelectorDraw.cxx:724
 TSelectorDraw.cxx:725
 TSelectorDraw.cxx:726
 TSelectorDraw.cxx:727
 TSelectorDraw.cxx:728
 TSelectorDraw.cxx:729
 TSelectorDraw.cxx:730
 TSelectorDraw.cxx:731
 TSelectorDraw.cxx:732
 TSelectorDraw.cxx:733
 TSelectorDraw.cxx:734
 TSelectorDraw.cxx:735
 TSelectorDraw.cxx:736
 TSelectorDraw.cxx:737
 TSelectorDraw.cxx:738
 TSelectorDraw.cxx:739
 TSelectorDraw.cxx:740
 TSelectorDraw.cxx:741
 TSelectorDraw.cxx:742
 TSelectorDraw.cxx:743
 TSelectorDraw.cxx:744
 TSelectorDraw.cxx:745
 TSelectorDraw.cxx:746
 TSelectorDraw.cxx:747
 TSelectorDraw.cxx:748
 TSelectorDraw.cxx:749
 TSelectorDraw.cxx:750
 TSelectorDraw.cxx:751
 TSelectorDraw.cxx:752
 TSelectorDraw.cxx:753
 TSelectorDraw.cxx:754
 TSelectorDraw.cxx:755
 TSelectorDraw.cxx:756
 TSelectorDraw.cxx:757
 TSelectorDraw.cxx:758
 TSelectorDraw.cxx:759
 TSelectorDraw.cxx:760
 TSelectorDraw.cxx:761
 TSelectorDraw.cxx:762
 TSelectorDraw.cxx:763
 TSelectorDraw.cxx:764
 TSelectorDraw.cxx:765
 TSelectorDraw.cxx:766
 TSelectorDraw.cxx:767
 TSelectorDraw.cxx:768
 TSelectorDraw.cxx:769
 TSelectorDraw.cxx:770
 TSelectorDraw.cxx:771
 TSelectorDraw.cxx:772
 TSelectorDraw.cxx:773
 TSelectorDraw.cxx:774
 TSelectorDraw.cxx:775
 TSelectorDraw.cxx:776
 TSelectorDraw.cxx:777
 TSelectorDraw.cxx:778
 TSelectorDraw.cxx:779
 TSelectorDraw.cxx:780
 TSelectorDraw.cxx:781
 TSelectorDraw.cxx:782
 TSelectorDraw.cxx:783
 TSelectorDraw.cxx:784
 TSelectorDraw.cxx:785
 TSelectorDraw.cxx:786
 TSelectorDraw.cxx:787
 TSelectorDraw.cxx:788
 TSelectorDraw.cxx:789
 TSelectorDraw.cxx:790
 TSelectorDraw.cxx:791
 TSelectorDraw.cxx:792
 TSelectorDraw.cxx:793
 TSelectorDraw.cxx:794
 TSelectorDraw.cxx:795
 TSelectorDraw.cxx:796
 TSelectorDraw.cxx:797
 TSelectorDraw.cxx:798
 TSelectorDraw.cxx:799
 TSelectorDraw.cxx:800
 TSelectorDraw.cxx:801
 TSelectorDraw.cxx:802
 TSelectorDraw.cxx:803
 TSelectorDraw.cxx:804
 TSelectorDraw.cxx:805
 TSelectorDraw.cxx:806
 TSelectorDraw.cxx:807
 TSelectorDraw.cxx:808
 TSelectorDraw.cxx:809
 TSelectorDraw.cxx:810
 TSelectorDraw.cxx:811
 TSelectorDraw.cxx:812
 TSelectorDraw.cxx:813
 TSelectorDraw.cxx:814
 TSelectorDraw.cxx:815
 TSelectorDraw.cxx:816
 TSelectorDraw.cxx:817
 TSelectorDraw.cxx:818
 TSelectorDraw.cxx:819
 TSelectorDraw.cxx:820
 TSelectorDraw.cxx:821
 TSelectorDraw.cxx:822
 TSelectorDraw.cxx:823
 TSelectorDraw.cxx:824
 TSelectorDraw.cxx:825
 TSelectorDraw.cxx:826
 TSelectorDraw.cxx:827
 TSelectorDraw.cxx:828
 TSelectorDraw.cxx:829
 TSelectorDraw.cxx:830
 TSelectorDraw.cxx:831
 TSelectorDraw.cxx:832
 TSelectorDraw.cxx:833
 TSelectorDraw.cxx:834
 TSelectorDraw.cxx:835
 TSelectorDraw.cxx:836
 TSelectorDraw.cxx:837
 TSelectorDraw.cxx:838
 TSelectorDraw.cxx:839
 TSelectorDraw.cxx:840
 TSelectorDraw.cxx:841
 TSelectorDraw.cxx:842
 TSelectorDraw.cxx:843
 TSelectorDraw.cxx:844
 TSelectorDraw.cxx:845
 TSelectorDraw.cxx:846
 TSelectorDraw.cxx:847
 TSelectorDraw.cxx:848
 TSelectorDraw.cxx:849
 TSelectorDraw.cxx:850
 TSelectorDraw.cxx:851
 TSelectorDraw.cxx:852
 TSelectorDraw.cxx:853
 TSelectorDraw.cxx:854
 TSelectorDraw.cxx:855
 TSelectorDraw.cxx:856
 TSelectorDraw.cxx:857
 TSelectorDraw.cxx:858
 TSelectorDraw.cxx:859
 TSelectorDraw.cxx:860
 TSelectorDraw.cxx:861
 TSelectorDraw.cxx:862
 TSelectorDraw.cxx:863
 TSelectorDraw.cxx:864
 TSelectorDraw.cxx:865
 TSelectorDraw.cxx:866
 TSelectorDraw.cxx:867
 TSelectorDraw.cxx:868
 TSelectorDraw.cxx:869
 TSelectorDraw.cxx:870
 TSelectorDraw.cxx:871
 TSelectorDraw.cxx:872
 TSelectorDraw.cxx:873
 TSelectorDraw.cxx:874
 TSelectorDraw.cxx:875
 TSelectorDraw.cxx:876
 TSelectorDraw.cxx:877
 TSelectorDraw.cxx:878
 TSelectorDraw.cxx:879
 TSelectorDraw.cxx:880
 TSelectorDraw.cxx:881
 TSelectorDraw.cxx:882
 TSelectorDraw.cxx:883
 TSelectorDraw.cxx:884
 TSelectorDraw.cxx:885
 TSelectorDraw.cxx:886
 TSelectorDraw.cxx:887
 TSelectorDraw.cxx:888
 TSelectorDraw.cxx:889
 TSelectorDraw.cxx:890
 TSelectorDraw.cxx:891
 TSelectorDraw.cxx:892
 TSelectorDraw.cxx:893
 TSelectorDraw.cxx:894
 TSelectorDraw.cxx:895
 TSelectorDraw.cxx:896
 TSelectorDraw.cxx:897
 TSelectorDraw.cxx:898
 TSelectorDraw.cxx:899
 TSelectorDraw.cxx:900
 TSelectorDraw.cxx:901
 TSelectorDraw.cxx:902
 TSelectorDraw.cxx:903
 TSelectorDraw.cxx:904
 TSelectorDraw.cxx:905
 TSelectorDraw.cxx:906
 TSelectorDraw.cxx:907
 TSelectorDraw.cxx:908
 TSelectorDraw.cxx:909
 TSelectorDraw.cxx:910
 TSelectorDraw.cxx:911
 TSelectorDraw.cxx:912
 TSelectorDraw.cxx:913
 TSelectorDraw.cxx:914
 TSelectorDraw.cxx:915
 TSelectorDraw.cxx:916
 TSelectorDraw.cxx:917
 TSelectorDraw.cxx:918
 TSelectorDraw.cxx:919
 TSelectorDraw.cxx:920
 TSelectorDraw.cxx:921
 TSelectorDraw.cxx:922
 TSelectorDraw.cxx:923
 TSelectorDraw.cxx:924
 TSelectorDraw.cxx:925
 TSelectorDraw.cxx:926
 TSelectorDraw.cxx:927
 TSelectorDraw.cxx:928
 TSelectorDraw.cxx:929
 TSelectorDraw.cxx:930
 TSelectorDraw.cxx:931
 TSelectorDraw.cxx:932
 TSelectorDraw.cxx:933
 TSelectorDraw.cxx:934
 TSelectorDraw.cxx:935
 TSelectorDraw.cxx:936
 TSelectorDraw.cxx:937
 TSelectorDraw.cxx:938
 TSelectorDraw.cxx:939
 TSelectorDraw.cxx:940
 TSelectorDraw.cxx:941
 TSelectorDraw.cxx:942
 TSelectorDraw.cxx:943
 TSelectorDraw.cxx:944
 TSelectorDraw.cxx:945
 TSelectorDraw.cxx:946
 TSelectorDraw.cxx:947
 TSelectorDraw.cxx:948
 TSelectorDraw.cxx:949
 TSelectorDraw.cxx:950
 TSelectorDraw.cxx:951
 TSelectorDraw.cxx:952
 TSelectorDraw.cxx:953
 TSelectorDraw.cxx:954
 TSelectorDraw.cxx:955
 TSelectorDraw.cxx:956
 TSelectorDraw.cxx:957
 TSelectorDraw.cxx:958
 TSelectorDraw.cxx:959
 TSelectorDraw.cxx:960
 TSelectorDraw.cxx:961
 TSelectorDraw.cxx:962
 TSelectorDraw.cxx:963
 TSelectorDraw.cxx:964
 TSelectorDraw.cxx:965
 TSelectorDraw.cxx:966
 TSelectorDraw.cxx:967
 TSelectorDraw.cxx:968
 TSelectorDraw.cxx:969
 TSelectorDraw.cxx:970
 TSelectorDraw.cxx:971
 TSelectorDraw.cxx:972
 TSelectorDraw.cxx:973
 TSelectorDraw.cxx:974
 TSelectorDraw.cxx:975
 TSelectorDraw.cxx:976
 TSelectorDraw.cxx:977
 TSelectorDraw.cxx:978
 TSelectorDraw.cxx:979
 TSelectorDraw.cxx:980
 TSelectorDraw.cxx:981
 TSelectorDraw.cxx:982
 TSelectorDraw.cxx:983
 TSelectorDraw.cxx:984
 TSelectorDraw.cxx:985
 TSelectorDraw.cxx:986
 TSelectorDraw.cxx:987
 TSelectorDraw.cxx:988
 TSelectorDraw.cxx:989
 TSelectorDraw.cxx:990
 TSelectorDraw.cxx:991
 TSelectorDraw.cxx:992
 TSelectorDraw.cxx:993
 TSelectorDraw.cxx:994
 TSelectorDraw.cxx:995
 TSelectorDraw.cxx:996
 TSelectorDraw.cxx:997
 TSelectorDraw.cxx:998
 TSelectorDraw.cxx:999
 TSelectorDraw.cxx:1000
 TSelectorDraw.cxx:1001
 TSelectorDraw.cxx:1002
 TSelectorDraw.cxx:1003
 TSelectorDraw.cxx:1004
 TSelectorDraw.cxx:1005
 TSelectorDraw.cxx:1006
 TSelectorDraw.cxx:1007
 TSelectorDraw.cxx:1008
 TSelectorDraw.cxx:1009
 TSelectorDraw.cxx:1010
 TSelectorDraw.cxx:1011
 TSelectorDraw.cxx:1012
 TSelectorDraw.cxx:1013
 TSelectorDraw.cxx:1014
 TSelectorDraw.cxx:1015
 TSelectorDraw.cxx:1016
 TSelectorDraw.cxx:1017
 TSelectorDraw.cxx:1018
 TSelectorDraw.cxx:1019
 TSelectorDraw.cxx:1020
 TSelectorDraw.cxx:1021
 TSelectorDraw.cxx:1022
 TSelectorDraw.cxx:1023
 TSelectorDraw.cxx:1024
 TSelectorDraw.cxx:1025
 TSelectorDraw.cxx:1026
 TSelectorDraw.cxx:1027
 TSelectorDraw.cxx:1028
 TSelectorDraw.cxx:1029
 TSelectorDraw.cxx:1030
 TSelectorDraw.cxx:1031
 TSelectorDraw.cxx:1032
 TSelectorDraw.cxx:1033
 TSelectorDraw.cxx:1034
 TSelectorDraw.cxx:1035
 TSelectorDraw.cxx:1036
 TSelectorDraw.cxx:1037
 TSelectorDraw.cxx:1038
 TSelectorDraw.cxx:1039
 TSelectorDraw.cxx:1040
 TSelectorDraw.cxx:1041
 TSelectorDraw.cxx:1042
 TSelectorDraw.cxx:1043
 TSelectorDraw.cxx:1044
 TSelectorDraw.cxx:1045
 TSelectorDraw.cxx:1046
 TSelectorDraw.cxx:1047
 TSelectorDraw.cxx:1048
 TSelectorDraw.cxx:1049
 TSelectorDraw.cxx:1050
 TSelectorDraw.cxx:1051
 TSelectorDraw.cxx:1052
 TSelectorDraw.cxx:1053
 TSelectorDraw.cxx:1054
 TSelectorDraw.cxx:1055
 TSelectorDraw.cxx:1056
 TSelectorDraw.cxx:1057
 TSelectorDraw.cxx:1058
 TSelectorDraw.cxx:1059
 TSelectorDraw.cxx:1060
 TSelectorDraw.cxx:1061
 TSelectorDraw.cxx:1062
 TSelectorDraw.cxx:1063
 TSelectorDraw.cxx:1064
 TSelectorDraw.cxx:1065
 TSelectorDraw.cxx:1066
 TSelectorDraw.cxx:1067
 TSelectorDraw.cxx:1068
 TSelectorDraw.cxx:1069
 TSelectorDraw.cxx:1070
 TSelectorDraw.cxx:1071
 TSelectorDraw.cxx:1072
 TSelectorDraw.cxx:1073
 TSelectorDraw.cxx:1074
 TSelectorDraw.cxx:1075
 TSelectorDraw.cxx:1076
 TSelectorDraw.cxx:1077
 TSelectorDraw.cxx:1078
 TSelectorDraw.cxx:1079
 TSelectorDraw.cxx:1080
 TSelectorDraw.cxx:1081
 TSelectorDraw.cxx:1082
 TSelectorDraw.cxx:1083
 TSelectorDraw.cxx:1084
 TSelectorDraw.cxx:1085
 TSelectorDraw.cxx:1086
 TSelectorDraw.cxx:1087
 TSelectorDraw.cxx:1088
 TSelectorDraw.cxx:1089
 TSelectorDraw.cxx:1090
 TSelectorDraw.cxx:1091
 TSelectorDraw.cxx:1092
 TSelectorDraw.cxx:1093
 TSelectorDraw.cxx:1094
 TSelectorDraw.cxx:1095
 TSelectorDraw.cxx:1096
 TSelectorDraw.cxx:1097
 TSelectorDraw.cxx:1098
 TSelectorDraw.cxx:1099
 TSelectorDraw.cxx:1100
 TSelectorDraw.cxx:1101
 TSelectorDraw.cxx:1102
 TSelectorDraw.cxx:1103
 TSelectorDraw.cxx:1104
 TSelectorDraw.cxx:1105
 TSelectorDraw.cxx:1106
 TSelectorDraw.cxx:1107
 TSelectorDraw.cxx:1108
 TSelectorDraw.cxx:1109
 TSelectorDraw.cxx:1110
 TSelectorDraw.cxx:1111
 TSelectorDraw.cxx:1112
 TSelectorDraw.cxx:1113
 TSelectorDraw.cxx:1114
 TSelectorDraw.cxx:1115
 TSelectorDraw.cxx:1116
 TSelectorDraw.cxx:1117
 TSelectorDraw.cxx:1118
 TSelectorDraw.cxx:1119
 TSelectorDraw.cxx:1120
 TSelectorDraw.cxx:1121
 TSelectorDraw.cxx:1122
 TSelectorDraw.cxx:1123
 TSelectorDraw.cxx:1124
 TSelectorDraw.cxx:1125
 TSelectorDraw.cxx:1126
 TSelectorDraw.cxx:1127
 TSelectorDraw.cxx:1128
 TSelectorDraw.cxx:1129
 TSelectorDraw.cxx:1130
 TSelectorDraw.cxx:1131
 TSelectorDraw.cxx:1132
 TSelectorDraw.cxx:1133
 TSelectorDraw.cxx:1134
 TSelectorDraw.cxx:1135
 TSelectorDraw.cxx:1136
 TSelectorDraw.cxx:1137
 TSelectorDraw.cxx:1138
 TSelectorDraw.cxx:1139
 TSelectorDraw.cxx:1140
 TSelectorDraw.cxx:1141
 TSelectorDraw.cxx:1142
 TSelectorDraw.cxx:1143
 TSelectorDraw.cxx:1144
 TSelectorDraw.cxx:1145
 TSelectorDraw.cxx:1146
 TSelectorDraw.cxx:1147
 TSelectorDraw.cxx:1148
 TSelectorDraw.cxx:1149
 TSelectorDraw.cxx:1150
 TSelectorDraw.cxx:1151
 TSelectorDraw.cxx:1152
 TSelectorDraw.cxx:1153
 TSelectorDraw.cxx:1154
 TSelectorDraw.cxx:1155
 TSelectorDraw.cxx:1156
 TSelectorDraw.cxx:1157
 TSelectorDraw.cxx:1158
 TSelectorDraw.cxx:1159
 TSelectorDraw.cxx:1160
 TSelectorDraw.cxx:1161
 TSelectorDraw.cxx:1162
 TSelectorDraw.cxx:1163
 TSelectorDraw.cxx:1164
 TSelectorDraw.cxx:1165
 TSelectorDraw.cxx:1166
 TSelectorDraw.cxx:1167
 TSelectorDraw.cxx:1168
 TSelectorDraw.cxx:1169
 TSelectorDraw.cxx:1170
 TSelectorDraw.cxx:1171
 TSelectorDraw.cxx:1172
 TSelectorDraw.cxx:1173
 TSelectorDraw.cxx:1174
 TSelectorDraw.cxx:1175
 TSelectorDraw.cxx:1176
 TSelectorDraw.cxx:1177
 TSelectorDraw.cxx:1178
 TSelectorDraw.cxx:1179
 TSelectorDraw.cxx:1180
 TSelectorDraw.cxx:1181
 TSelectorDraw.cxx:1182
 TSelectorDraw.cxx:1183
 TSelectorDraw.cxx:1184
 TSelectorDraw.cxx:1185
 TSelectorDraw.cxx:1186
 TSelectorDraw.cxx:1187
 TSelectorDraw.cxx:1188
 TSelectorDraw.cxx:1189
 TSelectorDraw.cxx:1190
 TSelectorDraw.cxx:1191
 TSelectorDraw.cxx:1192
 TSelectorDraw.cxx:1193
 TSelectorDraw.cxx:1194
 TSelectorDraw.cxx:1195
 TSelectorDraw.cxx:1196
 TSelectorDraw.cxx:1197
 TSelectorDraw.cxx:1198
 TSelectorDraw.cxx:1199
 TSelectorDraw.cxx:1200
 TSelectorDraw.cxx:1201
 TSelectorDraw.cxx:1202
 TSelectorDraw.cxx:1203
 TSelectorDraw.cxx:1204
 TSelectorDraw.cxx:1205
 TSelectorDraw.cxx:1206
 TSelectorDraw.cxx:1207
 TSelectorDraw.cxx:1208
 TSelectorDraw.cxx:1209
 TSelectorDraw.cxx:1210
 TSelectorDraw.cxx:1211
 TSelectorDraw.cxx:1212
 TSelectorDraw.cxx:1213
 TSelectorDraw.cxx:1214
 TSelectorDraw.cxx:1215
 TSelectorDraw.cxx:1216
 TSelectorDraw.cxx:1217
 TSelectorDraw.cxx:1218
 TSelectorDraw.cxx:1219
 TSelectorDraw.cxx:1220
 TSelectorDraw.cxx:1221
 TSelectorDraw.cxx:1222
 TSelectorDraw.cxx:1223
 TSelectorDraw.cxx:1224
 TSelectorDraw.cxx:1225
 TSelectorDraw.cxx:1226
 TSelectorDraw.cxx:1227
 TSelectorDraw.cxx:1228
 TSelectorDraw.cxx:1229
 TSelectorDraw.cxx:1230
 TSelectorDraw.cxx:1231
 TSelectorDraw.cxx:1232
 TSelectorDraw.cxx:1233
 TSelectorDraw.cxx:1234
 TSelectorDraw.cxx:1235
 TSelectorDraw.cxx:1236
 TSelectorDraw.cxx:1237
 TSelectorDraw.cxx:1238
 TSelectorDraw.cxx:1239
 TSelectorDraw.cxx:1240
 TSelectorDraw.cxx:1241
 TSelectorDraw.cxx:1242
 TSelectorDraw.cxx:1243
 TSelectorDraw.cxx:1244
 TSelectorDraw.cxx:1245
 TSelectorDraw.cxx:1246
 TSelectorDraw.cxx:1247
 TSelectorDraw.cxx:1248
 TSelectorDraw.cxx:1249
 TSelectorDraw.cxx:1250
 TSelectorDraw.cxx:1251
 TSelectorDraw.cxx:1252
 TSelectorDraw.cxx:1253
 TSelectorDraw.cxx:1254
 TSelectorDraw.cxx:1255
 TSelectorDraw.cxx:1256
 TSelectorDraw.cxx:1257
 TSelectorDraw.cxx:1258
 TSelectorDraw.cxx:1259
 TSelectorDraw.cxx:1260
 TSelectorDraw.cxx:1261
 TSelectorDraw.cxx:1262
 TSelectorDraw.cxx:1263
 TSelectorDraw.cxx:1264
 TSelectorDraw.cxx:1265
 TSelectorDraw.cxx:1266
 TSelectorDraw.cxx:1267
 TSelectorDraw.cxx:1268
 TSelectorDraw.cxx:1269
 TSelectorDraw.cxx:1270
 TSelectorDraw.cxx:1271
 TSelectorDraw.cxx:1272
 TSelectorDraw.cxx:1273
 TSelectorDraw.cxx:1274
 TSelectorDraw.cxx:1275
 TSelectorDraw.cxx:1276
 TSelectorDraw.cxx:1277
 TSelectorDraw.cxx:1278
 TSelectorDraw.cxx:1279
 TSelectorDraw.cxx:1280
 TSelectorDraw.cxx:1281
 TSelectorDraw.cxx:1282
 TSelectorDraw.cxx:1283
 TSelectorDraw.cxx:1284
 TSelectorDraw.cxx:1285
 TSelectorDraw.cxx:1286
 TSelectorDraw.cxx:1287
 TSelectorDraw.cxx:1288
 TSelectorDraw.cxx:1289
 TSelectorDraw.cxx:1290
 TSelectorDraw.cxx:1291
 TSelectorDraw.cxx:1292
 TSelectorDraw.cxx:1293
 TSelectorDraw.cxx:1294
 TSelectorDraw.cxx:1295
 TSelectorDraw.cxx:1296
 TSelectorDraw.cxx:1297
 TSelectorDraw.cxx:1298
 TSelectorDraw.cxx:1299
 TSelectorDraw.cxx:1300
 TSelectorDraw.cxx:1301
 TSelectorDraw.cxx:1302
 TSelectorDraw.cxx:1303
 TSelectorDraw.cxx:1304
 TSelectorDraw.cxx:1305
 TSelectorDraw.cxx:1306
 TSelectorDraw.cxx:1307
 TSelectorDraw.cxx:1308
 TSelectorDraw.cxx:1309
 TSelectorDraw.cxx:1310
 TSelectorDraw.cxx:1311
 TSelectorDraw.cxx:1312
 TSelectorDraw.cxx:1313
 TSelectorDraw.cxx:1314
 TSelectorDraw.cxx:1315
 TSelectorDraw.cxx:1316
 TSelectorDraw.cxx:1317
 TSelectorDraw.cxx:1318
 TSelectorDraw.cxx:1319
 TSelectorDraw.cxx:1320
 TSelectorDraw.cxx:1321
 TSelectorDraw.cxx:1322
 TSelectorDraw.cxx:1323
 TSelectorDraw.cxx:1324
 TSelectorDraw.cxx:1325
 TSelectorDraw.cxx:1326
 TSelectorDraw.cxx:1327
 TSelectorDraw.cxx:1328
 TSelectorDraw.cxx:1329
 TSelectorDraw.cxx:1330
 TSelectorDraw.cxx:1331
 TSelectorDraw.cxx:1332
 TSelectorDraw.cxx:1333
 TSelectorDraw.cxx:1334
 TSelectorDraw.cxx:1335
 TSelectorDraw.cxx:1336
 TSelectorDraw.cxx:1337
 TSelectorDraw.cxx:1338
 TSelectorDraw.cxx:1339
 TSelectorDraw.cxx:1340
 TSelectorDraw.cxx:1341
 TSelectorDraw.cxx:1342
 TSelectorDraw.cxx:1343
 TSelectorDraw.cxx:1344
 TSelectorDraw.cxx:1345
 TSelectorDraw.cxx:1346
 TSelectorDraw.cxx:1347
 TSelectorDraw.cxx:1348
 TSelectorDraw.cxx:1349
 TSelectorDraw.cxx:1350
 TSelectorDraw.cxx:1351
 TSelectorDraw.cxx:1352
 TSelectorDraw.cxx:1353
 TSelectorDraw.cxx:1354
 TSelectorDraw.cxx:1355
 TSelectorDraw.cxx:1356
 TSelectorDraw.cxx:1357
 TSelectorDraw.cxx:1358
 TSelectorDraw.cxx:1359
 TSelectorDraw.cxx:1360
 TSelectorDraw.cxx:1361
 TSelectorDraw.cxx:1362
 TSelectorDraw.cxx:1363
 TSelectorDraw.cxx:1364
 TSelectorDraw.cxx:1365
 TSelectorDraw.cxx:1366
 TSelectorDraw.cxx:1367
 TSelectorDraw.cxx:1368
 TSelectorDraw.cxx:1369
 TSelectorDraw.cxx:1370
 TSelectorDraw.cxx:1371
 TSelectorDraw.cxx:1372
 TSelectorDraw.cxx:1373
 TSelectorDraw.cxx:1374
 TSelectorDraw.cxx:1375
 TSelectorDraw.cxx:1376
 TSelectorDraw.cxx:1377
 TSelectorDraw.cxx:1378
 TSelectorDraw.cxx:1379
 TSelectorDraw.cxx:1380
 TSelectorDraw.cxx:1381
 TSelectorDraw.cxx:1382
 TSelectorDraw.cxx:1383
 TSelectorDraw.cxx:1384
 TSelectorDraw.cxx:1385
 TSelectorDraw.cxx:1386
 TSelectorDraw.cxx:1387
 TSelectorDraw.cxx:1388
 TSelectorDraw.cxx:1389
 TSelectorDraw.cxx:1390
 TSelectorDraw.cxx:1391
 TSelectorDraw.cxx:1392
 TSelectorDraw.cxx:1393
 TSelectorDraw.cxx:1394
 TSelectorDraw.cxx:1395
 TSelectorDraw.cxx:1396
 TSelectorDraw.cxx:1397
 TSelectorDraw.cxx:1398
 TSelectorDraw.cxx:1399
 TSelectorDraw.cxx:1400
 TSelectorDraw.cxx:1401
 TSelectorDraw.cxx:1402
 TSelectorDraw.cxx:1403
 TSelectorDraw.cxx:1404
 TSelectorDraw.cxx:1405
 TSelectorDraw.cxx:1406
 TSelectorDraw.cxx:1407
 TSelectorDraw.cxx:1408
 TSelectorDraw.cxx:1409
 TSelectorDraw.cxx:1410
 TSelectorDraw.cxx:1411
 TSelectorDraw.cxx:1412
 TSelectorDraw.cxx:1413
 TSelectorDraw.cxx:1414
 TSelectorDraw.cxx:1415
 TSelectorDraw.cxx:1416
 TSelectorDraw.cxx:1417
 TSelectorDraw.cxx:1418
 TSelectorDraw.cxx:1419
 TSelectorDraw.cxx:1420
 TSelectorDraw.cxx:1421
 TSelectorDraw.cxx:1422
 TSelectorDraw.cxx:1423
 TSelectorDraw.cxx:1424
 TSelectorDraw.cxx:1425
 TSelectorDraw.cxx:1426
 TSelectorDraw.cxx:1427
 TSelectorDraw.cxx:1428
 TSelectorDraw.cxx:1429
 TSelectorDraw.cxx:1430
 TSelectorDraw.cxx:1431
 TSelectorDraw.cxx:1432
 TSelectorDraw.cxx:1433
 TSelectorDraw.cxx:1434
 TSelectorDraw.cxx:1435
 TSelectorDraw.cxx:1436
 TSelectorDraw.cxx:1437
 TSelectorDraw.cxx:1438
 TSelectorDraw.cxx:1439
 TSelectorDraw.cxx:1440
 TSelectorDraw.cxx:1441
 TSelectorDraw.cxx:1442
 TSelectorDraw.cxx:1443
 TSelectorDraw.cxx:1444
 TSelectorDraw.cxx:1445
 TSelectorDraw.cxx:1446
 TSelectorDraw.cxx:1447
 TSelectorDraw.cxx:1448
 TSelectorDraw.cxx:1449
 TSelectorDraw.cxx:1450
 TSelectorDraw.cxx:1451
 TSelectorDraw.cxx:1452
 TSelectorDraw.cxx:1453
 TSelectorDraw.cxx:1454
 TSelectorDraw.cxx:1455
 TSelectorDraw.cxx:1456
 TSelectorDraw.cxx:1457
 TSelectorDraw.cxx:1458
 TSelectorDraw.cxx:1459
 TSelectorDraw.cxx:1460
 TSelectorDraw.cxx:1461
 TSelectorDraw.cxx:1462
 TSelectorDraw.cxx:1463
 TSelectorDraw.cxx:1464
 TSelectorDraw.cxx:1465
 TSelectorDraw.cxx:1466
 TSelectorDraw.cxx:1467
 TSelectorDraw.cxx:1468
 TSelectorDraw.cxx:1469
 TSelectorDraw.cxx:1470
 TSelectorDraw.cxx:1471
 TSelectorDraw.cxx:1472
 TSelectorDraw.cxx:1473
 TSelectorDraw.cxx:1474
 TSelectorDraw.cxx:1475
 TSelectorDraw.cxx:1476
 TSelectorDraw.cxx:1477
 TSelectorDraw.cxx:1478
 TSelectorDraw.cxx:1479
 TSelectorDraw.cxx:1480
 TSelectorDraw.cxx:1481
 TSelectorDraw.cxx:1482
 TSelectorDraw.cxx:1483
 TSelectorDraw.cxx:1484
 TSelectorDraw.cxx:1485
 TSelectorDraw.cxx:1486
 TSelectorDraw.cxx:1487
 TSelectorDraw.cxx:1488
 TSelectorDraw.cxx:1489
 TSelectorDraw.cxx:1490
 TSelectorDraw.cxx:1491
 TSelectorDraw.cxx:1492
 TSelectorDraw.cxx:1493
 TSelectorDraw.cxx:1494
 TSelectorDraw.cxx:1495
 TSelectorDraw.cxx:1496
 TSelectorDraw.cxx:1497
 TSelectorDraw.cxx:1498
 TSelectorDraw.cxx:1499
 TSelectorDraw.cxx:1500
 TSelectorDraw.cxx:1501
 TSelectorDraw.cxx:1502
 TSelectorDraw.cxx:1503
 TSelectorDraw.cxx:1504
 TSelectorDraw.cxx:1505
 TSelectorDraw.cxx:1506
 TSelectorDraw.cxx:1507
 TSelectorDraw.cxx:1508
 TSelectorDraw.cxx:1509
 TSelectorDraw.cxx:1510
 TSelectorDraw.cxx:1511
 TSelectorDraw.cxx:1512
 TSelectorDraw.cxx:1513
 TSelectorDraw.cxx:1514
 TSelectorDraw.cxx:1515
 TSelectorDraw.cxx:1516
 TSelectorDraw.cxx:1517
 TSelectorDraw.cxx:1518
 TSelectorDraw.cxx:1519
 TSelectorDraw.cxx:1520
 TSelectorDraw.cxx:1521
 TSelectorDraw.cxx:1522
 TSelectorDraw.cxx:1523
 TSelectorDraw.cxx:1524
 TSelectorDraw.cxx:1525
 TSelectorDraw.cxx:1526
 TSelectorDraw.cxx:1527
 TSelectorDraw.cxx:1528
 TSelectorDraw.cxx:1529
 TSelectorDraw.cxx:1530
 TSelectorDraw.cxx:1531
 TSelectorDraw.cxx:1532
 TSelectorDraw.cxx:1533
 TSelectorDraw.cxx:1534
 TSelectorDraw.cxx:1535
 TSelectorDraw.cxx:1536
 TSelectorDraw.cxx:1537
 TSelectorDraw.cxx:1538
 TSelectorDraw.cxx:1539
 TSelectorDraw.cxx:1540
 TSelectorDraw.cxx:1541
 TSelectorDraw.cxx:1542
 TSelectorDraw.cxx:1543
 TSelectorDraw.cxx:1544
 TSelectorDraw.cxx:1545
 TSelectorDraw.cxx:1546
 TSelectorDraw.cxx:1547
 TSelectorDraw.cxx:1548
 TSelectorDraw.cxx:1549
 TSelectorDraw.cxx:1550
 TSelectorDraw.cxx:1551
 TSelectorDraw.cxx:1552
 TSelectorDraw.cxx:1553
 TSelectorDraw.cxx:1554
 TSelectorDraw.cxx:1555
 TSelectorDraw.cxx:1556
 TSelectorDraw.cxx:1557
 TSelectorDraw.cxx:1558
 TSelectorDraw.cxx:1559
 TSelectorDraw.cxx:1560
 TSelectorDraw.cxx:1561
 TSelectorDraw.cxx:1562
 TSelectorDraw.cxx:1563
 TSelectorDraw.cxx:1564
 TSelectorDraw.cxx:1565
 TSelectorDraw.cxx:1566
 TSelectorDraw.cxx:1567
 TSelectorDraw.cxx:1568
 TSelectorDraw.cxx:1569
 TSelectorDraw.cxx:1570
 TSelectorDraw.cxx:1571
 TSelectorDraw.cxx:1572
 TSelectorDraw.cxx:1573
 TSelectorDraw.cxx:1574
 TSelectorDraw.cxx:1575
 TSelectorDraw.cxx:1576
 TSelectorDraw.cxx:1577
 TSelectorDraw.cxx:1578
 TSelectorDraw.cxx:1579
 TSelectorDraw.cxx:1580
 TSelectorDraw.cxx:1581
 TSelectorDraw.cxx:1582
 TSelectorDraw.cxx:1583
 TSelectorDraw.cxx:1584
 TSelectorDraw.cxx:1585
 TSelectorDraw.cxx:1586
 TSelectorDraw.cxx:1587
 TSelectorDraw.cxx:1588
 TSelectorDraw.cxx:1589
 TSelectorDraw.cxx:1590
 TSelectorDraw.cxx:1591
 TSelectorDraw.cxx:1592
 TSelectorDraw.cxx:1593
 TSelectorDraw.cxx:1594
 TSelectorDraw.cxx:1595
 TSelectorDraw.cxx:1596
 TSelectorDraw.cxx:1597
 TSelectorDraw.cxx:1598
 TSelectorDraw.cxx:1599
 TSelectorDraw.cxx:1600
 TSelectorDraw.cxx:1601
 TSelectorDraw.cxx:1602
 TSelectorDraw.cxx:1603
 TSelectorDraw.cxx:1604
 TSelectorDraw.cxx:1605
 TSelectorDraw.cxx:1606
 TSelectorDraw.cxx:1607
 TSelectorDraw.cxx:1608
 TSelectorDraw.cxx:1609
 TSelectorDraw.cxx:1610
 TSelectorDraw.cxx:1611
 TSelectorDraw.cxx:1612
 TSelectorDraw.cxx:1613
 TSelectorDraw.cxx:1614
 TSelectorDraw.cxx:1615
 TSelectorDraw.cxx:1616
 TSelectorDraw.cxx:1617
 TSelectorDraw.cxx:1618
 TSelectorDraw.cxx:1619
 TSelectorDraw.cxx:1620
 TSelectorDraw.cxx:1621
 TSelectorDraw.cxx:1622
 TSelectorDraw.cxx:1623
 TSelectorDraw.cxx:1624
 TSelectorDraw.cxx:1625
 TSelectorDraw.cxx:1626
 TSelectorDraw.cxx:1627
 TSelectorDraw.cxx:1628
 TSelectorDraw.cxx:1629
 TSelectorDraw.cxx:1630
 TSelectorDraw.cxx:1631
 TSelectorDraw.cxx:1632
 TSelectorDraw.cxx:1633
 TSelectorDraw.cxx:1634
 TSelectorDraw.cxx:1635
 TSelectorDraw.cxx:1636
 TSelectorDraw.cxx:1637
 TSelectorDraw.cxx:1638
 TSelectorDraw.cxx:1639
 TSelectorDraw.cxx:1640
 TSelectorDraw.cxx:1641
 TSelectorDraw.cxx:1642
 TSelectorDraw.cxx:1643
 TSelectorDraw.cxx:1644
 TSelectorDraw.cxx:1645
 TSelectorDraw.cxx:1646
 TSelectorDraw.cxx:1647
 TSelectorDraw.cxx:1648
 TSelectorDraw.cxx:1649
 TSelectorDraw.cxx:1650
 TSelectorDraw.cxx:1651
 TSelectorDraw.cxx:1652
 TSelectorDraw.cxx:1653
 TSelectorDraw.cxx:1654
 TSelectorDraw.cxx:1655
 TSelectorDraw.cxx:1656
 TSelectorDraw.cxx:1657
 TSelectorDraw.cxx:1658
 TSelectorDraw.cxx:1659
 TSelectorDraw.cxx:1660
 TSelectorDraw.cxx:1661
 TSelectorDraw.cxx:1662
 TSelectorDraw.cxx:1663
 TSelectorDraw.cxx:1664
 TSelectorDraw.cxx:1665
 TSelectorDraw.cxx:1666
 TSelectorDraw.cxx:1667
 TSelectorDraw.cxx:1668
 TSelectorDraw.cxx:1669
 TSelectorDraw.cxx:1670
 TSelectorDraw.cxx:1671
 TSelectorDraw.cxx:1672
 TSelectorDraw.cxx:1673
 TSelectorDraw.cxx:1674
 TSelectorDraw.cxx:1675
 TSelectorDraw.cxx:1676
 TSelectorDraw.cxx:1677
 TSelectorDraw.cxx:1678
 TSelectorDraw.cxx:1679
 TSelectorDraw.cxx:1680
 TSelectorDraw.cxx:1681
 TSelectorDraw.cxx:1682
 TSelectorDraw.cxx:1683
 TSelectorDraw.cxx:1684
 TSelectorDraw.cxx:1685
 TSelectorDraw.cxx:1686
 TSelectorDraw.cxx:1687
 TSelectorDraw.cxx:1688
 TSelectorDraw.cxx:1689
 TSelectorDraw.cxx:1690
 TSelectorDraw.cxx:1691
 TSelectorDraw.cxx:1692
 TSelectorDraw.cxx:1693
 TSelectorDraw.cxx:1694
 TSelectorDraw.cxx:1695
 TSelectorDraw.cxx:1696
 TSelectorDraw.cxx:1697
 TSelectorDraw.cxx:1698
 TSelectorDraw.cxx:1699
 TSelectorDraw.cxx:1700
 TSelectorDraw.cxx:1701
 TSelectorDraw.cxx:1702
 TSelectorDraw.cxx:1703
 TSelectorDraw.cxx:1704
 TSelectorDraw.cxx:1705
 TSelectorDraw.cxx:1706
 TSelectorDraw.cxx:1707
 TSelectorDraw.cxx:1708
 TSelectorDraw.cxx:1709
 TSelectorDraw.cxx:1710
 TSelectorDraw.cxx:1711
 TSelectorDraw.cxx:1712
 TSelectorDraw.cxx:1713
 TSelectorDraw.cxx:1714
 TSelectorDraw.cxx:1715
 TSelectorDraw.cxx:1716
 TSelectorDraw.cxx:1717
 TSelectorDraw.cxx:1718
 TSelectorDraw.cxx:1719
 TSelectorDraw.cxx:1720
 TSelectorDraw.cxx:1721
 TSelectorDraw.cxx:1722
 TSelectorDraw.cxx:1723
 TSelectorDraw.cxx:1724
 TSelectorDraw.cxx:1725
 TSelectorDraw.cxx:1726
 TSelectorDraw.cxx:1727
 TSelectorDraw.cxx:1728
 TSelectorDraw.cxx:1729
 TSelectorDraw.cxx:1730
 TSelectorDraw.cxx:1731
 TSelectorDraw.cxx:1732
 TSelectorDraw.cxx:1733
 TSelectorDraw.cxx:1734
 TSelectorDraw.cxx:1735
 TSelectorDraw.cxx:1736
 TSelectorDraw.cxx:1737
 TSelectorDraw.cxx:1738
 TSelectorDraw.cxx:1739
 TSelectorDraw.cxx:1740
 TSelectorDraw.cxx:1741
 TSelectorDraw.cxx:1742
 TSelectorDraw.cxx:1743
 TSelectorDraw.cxx:1744
 TSelectorDraw.cxx:1745
 TSelectorDraw.cxx:1746
 TSelectorDraw.cxx:1747
 TSelectorDraw.cxx:1748
 TSelectorDraw.cxx:1749
 TSelectorDraw.cxx:1750
 TSelectorDraw.cxx:1751
 TSelectorDraw.cxx:1752
 TSelectorDraw.cxx:1753
 TSelectorDraw.cxx:1754
 TSelectorDraw.cxx:1755
 TSelectorDraw.cxx:1756
 TSelectorDraw.cxx:1757
 TSelectorDraw.cxx:1758
 TSelectorDraw.cxx:1759
 TSelectorDraw.cxx:1760
 TSelectorDraw.cxx:1761
 TSelectorDraw.cxx:1762
 TSelectorDraw.cxx:1763
 TSelectorDraw.cxx:1764
 TSelectorDraw.cxx:1765
 TSelectorDraw.cxx:1766
 TSelectorDraw.cxx:1767
 TSelectorDraw.cxx:1768
 TSelectorDraw.cxx:1769
 TSelectorDraw.cxx:1770
 TSelectorDraw.cxx:1771
 TSelectorDraw.cxx:1772
 TSelectorDraw.cxx:1773
 TSelectorDraw.cxx:1774
 TSelectorDraw.cxx:1775
 TSelectorDraw.cxx:1776
 TSelectorDraw.cxx:1777
 TSelectorDraw.cxx:1778
 TSelectorDraw.cxx:1779
 TSelectorDraw.cxx:1780
 TSelectorDraw.cxx:1781
 TSelectorDraw.cxx:1782
 TSelectorDraw.cxx:1783
 TSelectorDraw.cxx:1784
 TSelectorDraw.cxx:1785
 TSelectorDraw.cxx:1786
 TSelectorDraw.cxx:1787
 TSelectorDraw.cxx:1788
 TSelectorDraw.cxx:1789
 TSelectorDraw.cxx:1790
 TSelectorDraw.cxx:1791
 TSelectorDraw.cxx:1792
 TSelectorDraw.cxx:1793