ROOT logo
// @(#)root/fitpanel:$Id: TFitEditor.cxx 31790 2009-12-10 14:14:17Z bellenot $
// Author: Ilka Antcheva, Lorenzo Moneta 10/08/2006

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


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFitEditor                                                           //
//                                                                      //
// Allows to perform, explore and compare various fits.                 //
//                                                                      //
// To display the new Fit panel interface right click on a histogram    //
// or a graph to pop up the context menu and then select the menu       //
// entry 'Fit Panel'.                                                   //
//                                                                      //
// "General" Tab                                                        //
//                                                                      //
// The first set of GUI elements is related to the function choice      //
// and settings. The status bar on the bottom provides information      //
// about the current minimization settings using the following          //
// abbreviations:                                                       //
// LIB - shows the current choice between Minuit/Minuit2/Fumili         //
// MIGRAD or FUMILI points to the current minimization method in use.   //
// Itr: - shows the maximum number of iterations nnnn set for the fit.  //
// Prn: - can be DEF/VER/QT and shows the current print option in use.  //
//                                                                      //
// "Predefined" combo box - contains a list of predefined functions     //
// in ROOT. The default one is Gaussian.                                //
//                                                                      //
// "Operation" radio button group defines selected operational mode     //
// between functions: NOP - no operation (default); ADD - addition      //
// CONV - convolution (will be implemented in the future).              //
//                                                                      //
// Users can enter the function expression in a text entry field.       //
// The entered string is checked after Enter key was pressed. An        //
// error message shows up if the string is not accepted. The current    //
// prototype is limited and users have no freedom to enter file/user    //
// function names in this field.                                        //
//                                                                      //
// "Set Parameters" button opens a dialog for parameters settings.      //
//                                                                      //
// "Fit Settings" provides user interface elements related to the       //
// fitter. Currently there are two method choices: Chi-square and       //
// Binned Likelihood.                                                   //
//                                                                      //
// "Linear Fit" check button sets the use of Linear fitter is it is     //
// selected. Otherwise the option 'F' is applied if polN is selected.   //
// "Robust" number entry sets the robust value when fitting graphs.     //
// "No Chi-square" check button sets ON/OFF option 'C' - do not         //
// calculate Chi-square (for Linear fitter).                            //
//                                                                      //
// Fit options:                                                         //
// "Integral" check button switch ON/OFF option 'I' - use integral      //
// of function instead of value in bin center.                          //
// "Best Errors" sets ON/OFF option 'E' - better errors estimation      //
// using Minos technique.                                               //
// "All weights = 1" sets ON/OFF option 'W' - all weights set to 1,     //
// excluding empty bins and ignoring error bars.                        //
// "Empty bins, weights=1" sets ON/OFF option 'WW' -  all weights       //
// equal to 1, including  empty bins, error bars ignored.               //
// "Use range" sets ON/OFF option 'R' - fit only data within the        //
// specified function range with the slider.                            //
// "Improve fit results" sets ON/OFF option 'M' - after minimum is      //
// found, search for a new one.                                         //
// "Add to list" sets On/Off option '+'- add function to the list       //
// without deleting the previous.                                       //
//                                                                      //
// Draw options:                                                        //
// "SAME" sets On/Off function drawing on the same pad.                 //
// "No drawing" sets On/Off option '0'- do not draw function graphics.  //
// "Do not store/draw" sets On/Off option 'N'- do not store the         //
// function, do not draw it.                                            //
//                                                                      //
// Sliders settings are used if option 'R' - use range is active.       //
// Users can change min/max values by pressing the left mouse button    //
// near to the left/right slider edges. It is possible o change both    //
// values simultaneously by pressing the left mouse button near to its  //
// center and moving it to a new desire position.                       //
//                                                                      //
// "Minimization" Tab                                                   //
//                                                                      //
// "Library" group allows you to use Minuit, Minuit2 or Fumili          //
// minimization packages for your fit.                                  //
//  "Minuit" - the popular Minuit minimization package.                 //
//  "Minuit2" - a new object-oriented implementation of Minuit in C++.  //
//  "Fumili" - the popular Fumili minimization package.                 //
//                                                                      //
// "Method" group has currently restricted functionality.               //
//  "MIGRAD" method is available for Minuit and Minuit2                 //
//  "FUMILI" method is available for Fumili and Minuit2                 //
//  "SIMPLEX" method is disabled (will come with the new fitter design) //
//                                                                      //
// "Minimization Settings' group allows users to set values for:        //
//  "Error definition" - between 0.0 and 100.0  (default is 1.0).       //
//  "Maximum tolerance" - the fit relative precision in use.            //
//  "Maximum number of iterations" - default is 5000.                   //
//                                                                      //
// Print options:                                                       //
//  "Default" - between Verbose and Quiet.                              //
//  "Verbose" - prints results after each iteration.                    //
//  "Quiet" - no fit information is printed.                            //
//                                                                      //
// Fit button - performs a fit.                                         //
// Reset - resets all GUI elements and related fit settings to the      //
// default ones.                                                        //
// Close - closes this window.                                          //
//                                                                      //
// Begin_Html                                                           //
/*
<img src="gif/TFitEditor.gif">
*/
//End_Html
//////////////////////////////////////////////////////////////////////////

#include "TFitEditor.h"
#include "TROOT.h"
#include "TClass.h"
#include "TCanvas.h"
#include "TGTab.h"
#include "TGLabel.h"
#include "TG3DLine.h"
#include "TGComboBox.h"
#include "TGTextEntry.h"
#include "TGFont.h"
#include "TGGC.h"
#include "TGButtonGroup.h"
#include "TGNumberEntry.h"
#include "TGDoubleSlider.h"
#include "TGStatusBar.h"
#include "TFitParametersDialog.h"
#include "TGMsgBox.h"
#include "TAxis.h"
#include "TGraph.h"
#include "TGraph2D.h"
#include "TH1.h"
#include "TH2.h"
#include "HFitInterface.h"
#include "TF1.h"
#include "TF2.h"
#include "TF3.h"
#include "TTimer.h"
#include "THStack.h"
#include "TMath.h"
#include "Fit/UnBinData.h"
#include "Fit/BinData.h"
#include "Fit/BinData.h"
#include "TMultiGraph.h"
#include "TTree.h"
#include "TTreePlayer.h"
#include "TTreeInput.h"
#include "TAdvancedGraphicsDialog.h"

#include "RConfigure.h"
#include "TPluginManager.h"

#include <sstream>
#include <vector>
#include <queue>
using std::vector;
using std::queue;
using std::pair;
using std::ostringstream;
using std::make_pair;

#include "CommonDefs.h"

// #include <iostream>
// using std::cout;
// using std::endl;

void SearchCanvases(TSeqCollection* canvases, vector<TObject*>& objects);

typedef std::multimap<TObject*, TF1*> FitFuncMap_t;

//______________________________________________________________________________
TF1* TFitEditor::FindFunction()
{
   // This method looks among the functions stored by the fitpanel, the
   // one that is currently selected in the fFuncList

   // Get the list of functions from the system
   std::vector<TF1*>& funcList(fSystemFuncs);

   // Get the title/name of the function from fFuncList
   TGTextLBEntry *te = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
   if ( !te ) return 0;
   TString name(te->GetTitle());

   // Look for a system function if it's USER DEFINED function
   if ( fTypeFit->GetSelected() == kFP_UFUNC ) {
      for ( fSystemFuncIter it = funcList.begin(); 
            it != funcList.end(); ++it ) {
         TF1* f = (*it);
         if ( strcmp( f->GetName(), name ) == 0 )
            // If found, return it.
            return f;
      }
   // If we are looking for previously fitted functions, look in the
   // fPrevFit data structure.
   } else if ( fTypeFit->GetSelected() == kFP_PREVFIT ) {
      pair<fPrevFitIter, fPrevFitIter> look = fPrevFit.equal_range(fFitObject);
      for ( fPrevFitIter it = look.first; it != look.second; ++it ) {
         TF1* f = it->second;
         if ( strcmp( f->GetName(), name ) == 0 )
            // If found, return it
            return f;
      }
   }

   // Return a pointer to null if the function does not exist. This
   // will eventually create a segmentation fault, but the line should
   // never be executed.
   return 0;
}

//______________________________________________________________________________
TF1* copyTF1(TF1* f)
{
   //Copies f into a new TF1 to be stored in the fitpanel with it's
   //own ownership. This is taken from Fit::StoreAndDrawFitFunction in
   //HFitImpl.cxx

   double xmin = 0, xmax = 0, ymin = 0, ymax = 0, zmin = 0, zmax = 0; 

   if ( dynamic_cast<TF3*>(f) != 0 ) {
      TF3* fnew = (TF3*)f->IsA()->New();
      f->Copy(*fnew);
      f->GetRange(xmin,ymin,zmin,xmax,ymax,zmax);
      fnew->SetRange(xmin,ymin,zmin,xmax,ymax,zmax);
      fnew->SetParent( 0 );
      fnew->SetBit(TFormula::kNotGlobal);
      return fnew;
   } else if ( dynamic_cast<TF2*>(f) != 0 ) {
      TF2* fnew = (TF2*)f->IsA()->New();
      f->Copy(*fnew);
      f->GetRange(xmin,ymin,xmax,ymax);
      fnew->SetRange(xmin,ymin,xmax,ymax);
      fnew->Save(xmin,xmax,ymin,ymax,0,0);
      fnew->SetParent( 0 );
      fnew->SetBit(TFormula::kNotGlobal);
      return fnew;
   } else {
      TF1* fnew = (TF1*)f->IsA()->New();
      f->Copy(*fnew);
      f->GetRange(xmin,xmax);
      fnew->SetRange(xmin,xmax);
      // This next line is added, as fnew-Save fails with gausND! As
      // the number of dimensions is unknown...
      if ( '\0' != fnew->GetExpFormula()[0] )
         fnew->Save(xmin,xmax,0,0,0,0);
      fnew->SetParent( 0 );
      fnew->SetBit(TFormula::kNotGlobal);
      return fnew;
   }
}

//______________________________________________________________________________
void GetParameters(TFitEditor::FuncParams_t & pars, TF1* func)
{
   // Stores the parameters of the given function into pars

   int npar = func->GetNpar(); 
   if (npar != (int) pars.size() ) pars.resize(npar);
   for ( Int_t i = 0; i < npar; ++i )
   {
      Double_t par_min, par_max;
      pars[i][PAR_VAL] = func->GetParameter(i);
      func->GetParLimits(i, par_min, par_max);
      pars[i][PAR_MIN] = par_min;
      pars[i][PAR_MAX] = par_max;
   }
}

//______________________________________________________________________________
void SetParameters(TFitEditor::FuncParams_t & pars, TF1* func)
{
   // Restore the parameters from pars into the function

   int npar = func->GetNpar(); 
   if (npar > (int) pars.size() ) pars.resize(npar);
   for ( Int_t i = 0; i < npar; ++i )
   {
      func->SetParameter(i, pars[i][PAR_VAL]);
      func->SetParLimits(i, pars[i][PAR_MIN], pars[i][PAR_MAX]);
   }
}

//______________________________________________________________________________
template<class FitObject>
void InitParameters(TF1* func, FitObject * fitobj)
{
   // Parameter initialization for the function

   const int special = func->GetNumber(); 
   if (100 == special || 400 == special) { 
      ROOT::Fit::BinData data; 
      ROOT::Fit::FillData(data,fitobj,func); 
      ROOT::Fit::InitGaus(data, func);
      // case gaussian or Landau
   } else if ( 110 == special || 410 == special ) {
      ROOT::Fit::BinData data;
      ROOT::Fit::FillData(data,fitobj,func);
      ROOT::Fit::Init2DGaus(data,func);
   }
}

//______________________________________________________________________________
void GetTreeVarsAndCuts(TGComboBox* dataSet, TString& variablesStr, TString& cutsStr)
{
   // Splits the entry in fDataSet to get the selected variables and cuts
   // from the text.

   // Get the entry
   TGTextLBEntry* textEntry = 
      static_cast<TGTextLBEntry*>( dataSet->GetListBox()->GetEntry( dataSet->GetSelected() ) );
   // Get the name of the tree
   TString nameStr ( textEntry->GetText()->GetString() );
   // Get the variables selected
   variablesStr = nameStr(nameStr.First('(') + 2, nameStr.First(',') - nameStr.First('(') - 3);
   // Get the cuts selected
   cutsStr = nameStr( nameStr.First(',') + 3, nameStr.First(')') - nameStr.First(',') - 4 );

   return;
}


ClassImp(TFitEditor)

TFitEditor *TFitEditor::fgFitDialog = 0;

//______________________________________________________________________________
TFitEditor * TFitEditor::GetInstance(TVirtualPad* pad, TObject *obj)
{
   // Static method - opens the fit panel.

   // Get the default pad if not provided.
   if (!pad)
   {
      if (!gPad)
         gROOT->MakeDefCanvas();
      pad = gPad;
   }

   if (!fgFitDialog) {
      fgFitDialog = new TFitEditor(pad, obj);
   } else {
      fgFitDialog->Show(pad, obj);
   }
   return fgFitDialog;
}

//______________________________________________________________________________
TFitEditor::TFitEditor(TVirtualPad* pad, TObject *obj) :
   TGMainFrame(gClient->GetRoot(), 20, 20),
   fParentPad   (0),
   fFitObject   (0),
   fDim         (0),
   fXaxis       (0),
   fYaxis       (0),
   fZaxis       (0),
   fFuncPars    (0)

{
   // Constructor of fit editor. 'obj' is the object to be fitted and
   // 'pad' where it is drawn.

   fType = kObjectHisto;
   SetCleanup(kDeepCleanup);

   TGCompositeFrame *tf = new TGCompositeFrame(this, 350, 26,
                                                kHorizontalFrame);
   TGLabel *label = new TGLabel(tf,"Data Set: ");
   tf->AddFrame(label, new TGLayoutHints(kLHintsNormal, 15, 0, 5, 0));

   fDataSet = new TGComboBox(tf, kFP_DATAS);
   FillDataSetList();
   fDataSet->Resize(264, 20);

   tf->AddFrame(fDataSet, new TGLayoutHints(kLHintsNormal, 13, 0, 5, 0));
   fDataSet->Associate(this);

   this->AddFrame(tf, new TGLayoutHints(kLHintsNormal | kLHintsExpandX,0,0,5,5));

   CreateFunctionGroup();
   
   fTab = new TGTab(this, 10, 10);
   AddFrame(fTab, new TGLayoutHints(kLHintsExpandY | kLHintsExpandX));
   fTab->SetCleanup(kDeepCleanup);
   fTab->Associate(this);
   
   TGHorizontalFrame *cf1 = new TGHorizontalFrame(this, 350, 20, kFixedWidth);
   cf1->SetCleanup(kDeepCleanup);
   fUpdateButton = new TGTextButton(cf1, "&Update", kFP_UPDATE);
   fUpdateButton->Associate(this);
   cf1->AddFrame(fUpdateButton, new TGLayoutHints(kLHintsTop |
                                                  kLHintsExpandX, 0, 20, 2, 2));


   fFitButton = new TGTextButton(cf1, "&Fit", kFP_FIT);
   fFitButton->Associate(this);
   cf1->AddFrame(fFitButton, new TGLayoutHints(kLHintsTop |
                                               kLHintsExpandX, 15, -6, 2, 2));

   fResetButton = new TGTextButton(cf1, "&Reset", kFP_RESET);
   fResetButton->Associate(this);
   cf1->AddFrame(fResetButton, new TGLayoutHints(kLHintsTop |
                                                 kLHintsExpandX, 11, -2, 2, 2));

   fCloseButton = new TGTextButton(cf1, "&Close", kFP_CLOSE);
   fCloseButton->Associate(this);
   cf1->AddFrame(fCloseButton, new TGLayoutHints(kLHintsTop |
                                                 kLHintsExpandX, 7, 2, 2, 2));
   AddFrame(cf1, new TGLayoutHints(kLHintsNormal |
                                   kLHintsRight, 0, 5, 5, 5));

   // Create status bar
   int parts[] = { 20, 20, 20, 20, 20 };
   fStatusBar = new TGStatusBar(this, 10, 10);
   fStatusBar->SetParts(parts, 5);
   AddFrame(fStatusBar, new TGLayoutHints(kLHintsBottom | 
                                          kLHintsLeft   | 
                                          kLHintsExpandX));

   CreateGeneralTab();
   CreateMinimizationTab();

   gROOT->GetListOfCleanups()->Add(this);

   MapSubwindows();
   fGeneral->HideFrame(fSliderZParent);

   // do not allow resizing
   TGDimension size = GetDefaultSize();
   SetWindowName("Fit Panel");
   SetIconName("Fit Panel");
   SetClassHints("Fit Panel", "Fit Panel");

   SetMWMHints(kMWMDecorAll | kMWMDecorResizeH  | kMWMDecorMaximize |
                              kMWMDecorMinimize | kMWMDecorMenu,
               kMWMFuncAll  | kMWMFuncResize    | kMWMFuncMaximize |
                              kMWMFuncMinimize,
               kMWMInputModeless);

   ConnectSlots();

   GetFunctionsFromSystem();

   if (!obj) {
      TList* l = new TList();
      l->Add(pad);
      vector<TObject*> v;
      SearchCanvases(l, v);
      if ( v.size() ) 
         obj = v[0];
      delete l;
   }

   SetFitObject(pad, obj, kButton1Down);

   // In case we want to make it without a default canvas. This will
   // be implemented after the 5.21/06 Release. Remember to take out
   // any reference to the pad/canvas when the fitpanel is shown
   // and/or built.

   //SetCanvas(0 /*pad->GetCanvas()*/); 

   if ( pad ) {
      SetCanvas(pad->GetCanvas());
      if ( obj )
         pad->GetCanvas()->Selected(pad, obj, kButton1Down);
   }

   UInt_t dw = fClient->GetDisplayWidth();
   UInt_t cw = 0;
   UInt_t cx = 0;
   UInt_t cy = 0;
   if (pad && pad->GetCanvas() ) {
      cw = pad->GetCanvas()->GetWindowWidth();
      cx = (UInt_t)pad->GetCanvas()->GetWindowTopX();
      cy = (UInt_t)pad->GetCanvas()->GetWindowTopY();
   }
      
   Resize(size);
   MapWindow();

   if (cw + size.fWidth < dw) {
      Int_t gedx = 0, gedy = 0;
      gedx = cx+cw+4;
      gedy = cy-20;
      MoveResize(gedx, gedy,size.fWidth, size.fHeight);
      SetWMPosition(gedx, gedy);
   } 

   gVirtualX->RaiseWindow(GetId());

   ChangeOptions(GetOptions() | kFixedSize);
   SetWMSize(size.fWidth, size.fHeight);
   SetWMSizeHints(size.fWidth, size.fHeight, size.fWidth, size.fHeight, 0, 0);
}

//______________________________________________________________________________
TFitEditor::~TFitEditor()
{
   // Fit editor destructor.

   DisconnectSlots();

   // Disconnect all the slot that were no disconnected in DisconnecSlots
   fCloseButton->Disconnect("Clicked()");
   fDataSet->Disconnect("Selected(Int_t)");
   fUpdateButton->Disconnect("Clicked()");
   TQObject::Disconnect("TCanvas", "Selected(TVirtualPad *, TObject *, Int_t)",
                        this, "SetFitObject(TVirtualPad *, TObject *, Int_t)");
   gROOT->GetListOfCleanups()->Remove(this);

   //Clean up the members that are not automatically cleaned.
   Cleanup();
   delete fLayoutNone;
   delete fLayoutAdd;
   delete fLayoutConv;

   // Set the singleton reference to null
   fgFitDialog = 0;
}

//______________________________________________________________________________
void TFitEditor::CreateFunctionGroup()
{
   // Creates the Frame that contains oll the information about the
   // function.
   TGGroupFrame *gf1 = new TGGroupFrame(this, "Fit Function", kFitWidth);
      
   TGCompositeFrame *tf0 = new TGCompositeFrame(gf1, 350, 26,
                                                kHorizontalFrame);
   TGLabel *label1 = new TGLabel(tf0,"Type:");
   tf0->AddFrame(label1, new TGLayoutHints(kLHintsNormal, 0, 0, 5, 0));

   fTypeFit = new TGComboBox(tf0, kFP_TLIST);
   fTypeFit->AddEntry("User Func", kFP_UFUNC);
   fTypeFit->AddEntry("Predef-1D", kFP_PRED1D);
   fTypeFit->Resize(90, 20);
   fTypeFit->Select(kFP_PRED1D, kFALSE);

   TGListBox *lb = fTypeFit->GetListBox();
   lb->Resize(lb->GetWidth(), 200);
   tf0->AddFrame(fTypeFit, new TGLayoutHints(kLHintsNormal, 5, 0, 5, 0));
   fTypeFit->Associate(this);

   fFuncList = new TGComboBox(tf0, kFP_FLIST);
   FillFunctionList();
   fFuncList->Resize(194, 20);
   fFuncList->Select(kFP_GAUS, kFALSE);

   lb = fFuncList->GetListBox();
   lb->Resize(lb->GetWidth(), 500);
   tf0->AddFrame(fFuncList, new TGLayoutHints(kLHintsNormal, 5, 0, 5, 0));
   fFuncList->Associate(this);

   gf1->AddFrame(tf0, new TGLayoutHints(kLHintsNormal | kLHintsExpandX));

   TGCompositeFrame *tf1 = new TGCompositeFrame(gf1, 350, 26,
                                                kHorizontalFrame);
   TGHButtonGroup *bgr = new TGHButtonGroup(tf1,"Operation");
   bgr->SetRadioButtonExclusive();
   fNone = new TGRadioButton(bgr, "Nop", kFP_NONE);
   fNone->SetToolTipText("No operation defined");
   fNone->SetState(kButtonDown, kFALSE);
   fAdd = new TGRadioButton(bgr, "Add", kFP_ADD);
   fAdd->SetToolTipText("Addition");
   fConv = new TGRadioButton(bgr, "Conv", kFP_CONV);
   fConv->SetToolTipText("Convolution (not implemented yet)");
   fConv->SetState(kButtonDisabled);
   fLayoutNone = new TGLayoutHints(kLHintsLeft,0,5,3,-10);
   fLayoutAdd  = new TGLayoutHints(kLHintsLeft,10,5,3,-10);
   fLayoutConv = new TGLayoutHints(kLHintsLeft,10,5,3,-10);
   bgr->SetLayoutHints(fLayoutNone,fNone);
   bgr->SetLayoutHints(fLayoutAdd,fAdd);
   bgr->SetLayoutHints(fLayoutConv,fConv);
   bgr->Show();
   bgr->ChangeOptions(kFitWidth | kHorizontalFrame);
   tf1->AddFrame(bgr, new TGLayoutHints(kLHintsNormal, 15, 0, 3, 0));

   gf1->AddFrame(tf1, new TGLayoutHints(kLHintsNormal | kLHintsExpandX));

   TGCompositeFrame *tf2 = new TGCompositeFrame(gf1, 350, 26,
                                                kHorizontalFrame);
   fEnteredFunc = new TGTextEntry(tf2, new TGTextBuffer(0), kFP_FILE);
   //fEnteredFunc->SetMaxLength(4000);  // use default value (~4000)
   fEnteredFunc->SetAlignment(kTextLeft);
   TGTextLBEntry *te = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
   assert(te);
   fEnteredFunc->SetText(te->GetTitle());
   fEnteredFunc->SetToolTipText("Enter file_name/function_name or a function expression");
   fEnteredFunc->Resize(250,fEnteredFunc->GetDefaultHeight());
   tf2->AddFrame(fEnteredFunc, new TGLayoutHints(kLHintsLeft    |
                                                 kLHintsCenterY |
                                                 kLHintsExpandX, 2, 2, 2, 2));
   gf1->AddFrame(tf2, new TGLayoutHints(kLHintsNormal |
                                        kLHintsExpandX, 0, 0, 2, 0));

   TGHorizontalFrame *s1 = new TGHorizontalFrame(gf1);
   TGLabel *label21 = new TGLabel(s1, "Selected: ");
   s1->AddFrame(label21, new TGLayoutHints(kLHintsNormal |
                                           kLHintsCenterY, 2, 2, 2, 0));
   TGHorizontal3DLine *hlines = new TGHorizontal3DLine(s1);
   s1->AddFrame(hlines, new TGLayoutHints(kLHintsCenterY | kLHintsExpandX));
   gf1->AddFrame(s1, new TGLayoutHints(kLHintsExpandX));

   TGCompositeFrame *tf4 = new TGCompositeFrame(gf1, 350, 26,
                                                kHorizontalFrame);
   TGTextLBEntry *txt = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
   TString s = txt->GetTitle();
   fSelLabel = new TGLabel(tf4, s.Sizeof()>30?s(0,30)+"...":s);
   tf4->AddFrame(fSelLabel, new TGLayoutHints(kLHintsNormal |
                                              kLHintsCenterY, 0, 6, 2, 0));
   Pixel_t color;
   gClient->GetColorByName("#336666", color);
   fSelLabel->SetTextColor(color, kFALSE);
   TGCompositeFrame *tf5 = new TGCompositeFrame(tf4, 120, 20,
                                                kHorizontalFrame | kFixedWidth);
   fSetParam = new TGTextButton(tf5, "Set Parameters...", kFP_PARS);
   tf5->AddFrame(fSetParam, new TGLayoutHints(kLHintsRight   |
                                              kLHintsCenterY |
                                              kLHintsExpandX));
   fSetParam->SetToolTipText("Open a dialog for parameter(s) settings");
   tf4->AddFrame(tf5, new TGLayoutHints(kLHintsRight |
                                        kLHintsTop, 5, 0, 2, 2));
   gf1->AddFrame(tf4, new TGLayoutHints(kLHintsNormal |
                                             kLHintsExpandX, 5, 0, 0, 0));

   this->AddFrame(gf1, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));

}

//______________________________________________________________________________
void TFitEditor::CreateGeneralTab()
{
   // Create 'General' tab.

   fTabContainer = fTab->AddTab("General");
   fGeneral = new TGCompositeFrame(fTabContainer, 10, 10, kVerticalFrame);
   fTabContainer->AddFrame(fGeneral, new TGLayoutHints(kLHintsTop |
                                                       kLHintsExpandX,
                                                       5, 5, 2, 2));

   // 'options' group frame
   TGGroupFrame *gf = new TGGroupFrame(fGeneral, "Fit Settings", kFitWidth);

   // 'method' sub-group
   TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);
   TGLabel *label4 = new TGLabel(h1, "Method");
   h1->AddFrame(label4, new TGLayoutHints(kLHintsNormal |
                                          kLHintsCenterY, 2, 2, 0, 0));
   TGHorizontal3DLine *hline1 = new TGHorizontal3DLine(h1);
   h1->AddFrame(hline1, new TGLayoutHints(kLHintsCenterY | kLHintsExpandX));
   gf->AddFrame(h1, new TGLayoutHints(kLHintsExpandX));

   TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);
   TGVerticalFrame *v1 = new TGVerticalFrame(h2);
   fMethodList = BuildMethodList(v1, kFP_MLIST);
   fMethodList->Select(1, kFALSE);
   fMethodList->Resize(140, 20);
   TGListBox *lb = fMethodList->GetListBox();
   Int_t lbe = lb->GetNumberOfEntries();
   lb->Resize(lb->GetWidth(), lbe*16);
   v1->AddFrame(fMethodList, new TGLayoutHints(kLHintsLeft, 0, 0, 2, 5));

   fLinearFit = new TGCheckButton(v1, "Linear fit", kFP_MLINF);
   fLinearFit->Associate(this);
   fLinearFit->SetToolTipText("Perform Linear fitter if selected");
   v1->AddFrame(fLinearFit, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   TGHorizontalFrame *v1h = new TGHorizontalFrame(v1);
   TGLabel *label41 = new TGLabel(v1h, "Robust:");
   v1h->AddFrame(label41, new TGLayoutHints(kLHintsNormal |
                                            kLHintsCenterY, 25, 5, 5, 2));
   fRobustValue = new TGNumberEntry(v1h, 1., 5, kFP_RBUST,
                                    TGNumberFormat::kNESRealTwo,
                                    TGNumberFormat::kNEAPositive,
                                    TGNumberFormat::kNELLimitMinMax,0.,1.);
   v1h->AddFrame(fRobustValue, new TGLayoutHints(kLHintsLeft));
   v1->AddFrame(v1h, new TGLayoutHints(kLHintsNormal));
   fRobustValue->SetState(kFALSE);
   fRobustValue->GetNumberEntry()->SetToolTipText("Available only for graphs");

   h2->AddFrame(v1, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));

   TGVerticalFrame *v2 = new TGVerticalFrame(h2);
   TGCompositeFrame *v21 = new TGCompositeFrame(v2, 120, 20,
                                                kHorizontalFrame | kFixedWidth);
   fUserButton = new TGTextButton(v21, "User-Defined...", kFP_MUSR);
   v21->AddFrame(fUserButton, new TGLayoutHints(kLHintsRight   |
                                                kLHintsCenterY |
                                                kLHintsExpandX));
   fUserButton->SetToolTipText("Open a dialog for entering a user-defined method");
   fUserButton->SetState(kButtonDisabled);
   v2->AddFrame(v21, new TGLayoutHints(kLHintsRight | kLHintsTop));

   fNoChi2 = new TGCheckButton(v2, "No Chi-square", kFP_NOCHI);
   fNoChi2->Associate(this);
   fNoChi2->SetToolTipText("'C'- do not calculate Chi-square (for Linear fitter)");
   v2->AddFrame(fNoChi2, new TGLayoutHints(kLHintsNormal, 0, 0, 34, 2));

   h2->AddFrame(v2, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 20, 0, 0, 0));
   gf->AddFrame(h2, new TGLayoutHints(kLHintsExpandX, 20, 0, 0, 0));

   // 'fit option' sub-group
   TGHorizontalFrame *h3 = new TGHorizontalFrame(gf);
   TGLabel *label5 = new TGLabel(h3, "Fit Options");
   h3->AddFrame(label5, new TGLayoutHints(kLHintsNormal |
                                          kLHintsCenterY, 2, 2, 0, 0));
   TGHorizontal3DLine *hline2 = new TGHorizontal3DLine(h3);
   h3->AddFrame(hline2, new TGLayoutHints(kLHintsCenterY | kLHintsExpandX));
   gf->AddFrame(h3, new TGLayoutHints(kLHintsExpandX));

   TGHorizontalFrame *h = new TGHorizontalFrame(gf);
   TGVerticalFrame *v3 = new TGVerticalFrame(h);
   fIntegral = new TGCheckButton(v3, "Integral", kFP_INTEG);
   fIntegral->Associate(this);
   fIntegral->SetToolTipText("'I'- use integral of function instead of value in bin center");
   v3->AddFrame(fIntegral, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fBestErrors = new TGCheckButton(v3, "Best errors", kFP_IMERR);
   fBestErrors->Associate(this);
   fBestErrors->SetToolTipText("'E'- better errors estimation using Minos technique");
   v3->AddFrame(fBestErrors, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fAllWeights1 = new TGCheckButton(v3, "All weights = 1", kFP_ALLW1);
   fAllWeights1->Associate(this);
   fAllWeights1->SetToolTipText("'W'- all weights=1 for non empty bins; error bars ignored");
   v3->AddFrame(fAllWeights1, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fEmptyBinsWghts1 = new TGCheckButton(v3, "Empty bins, weights=1", kFP_EMPW1);
   fEmptyBinsWghts1->Associate(this);
   fEmptyBinsWghts1->SetToolTipText("'WW'- all weights=1 including empty bins; error bars ignored");
   v3->AddFrame(fEmptyBinsWghts1, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   h->AddFrame(v3, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));

   TGVerticalFrame *v4 = new TGVerticalFrame(h);
   fUseRange = new TGCheckButton(v4, "Use range", kFP_USERG);
   fUseRange->Associate(this);
   fUseRange->SetToolTipText("'R'- fit only data within the specified function range");
   v4->AddFrame(fUseRange, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fImproveResults = new TGCheckButton(v4, "Improve fit results", kFP_IFITR);
   fImproveResults->Associate(this);
   fImproveResults->SetToolTipText("'M'- after minimum is found, search for a new one");
   v4->AddFrame(fImproveResults, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fAdd2FuncList = new TGCheckButton(v4, "Add to list", kFP_ADDLS);
   fAdd2FuncList->Associate(this);
   fAdd2FuncList->SetToolTipText("'+'- add function to the list without deleting the previous");
   v4->AddFrame(fAdd2FuncList, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fUseGradient = new TGCheckButton(v4, "Use Gradient", kFP_ADDLS);
   fUseGradient->Associate(this);
   fUseGradient->SetToolTipText("'G'- Use the gradient as an aid for the fitting");
   v4->AddFrame(fUseGradient, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   h->AddFrame(v4, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 20, 0, 0, 0));
   gf->AddFrame(h, new TGLayoutHints(kLHintsExpandX, 20, 0, 0, 0));

   // 'draw option' sub-group
   TGHorizontalFrame *h5 = new TGHorizontalFrame(gf);
   TGLabel *label6 = new TGLabel(h5, "Draw Options");
   h5->AddFrame(label6, new TGLayoutHints(kLHintsNormal |
                                          kLHintsCenterY, 2, 2, 2, 2));
   TGHorizontal3DLine *hline3 = new TGHorizontal3DLine(h5);
   h5->AddFrame(hline3, new TGLayoutHints(kLHintsCenterY | kLHintsExpandX));
   gf->AddFrame(h5, new TGLayoutHints(kLHintsExpandX));

   TGHorizontalFrame *h6 = new TGHorizontalFrame(gf);
   TGVerticalFrame *v5 = new TGVerticalFrame(h6);

   fDrawSame = new TGCheckButton(v5, "SAME", kFP_DSAME);
   fDrawSame->Associate(this);
   fDrawSame->SetToolTipText("Superimpose on previous picture in the same pad");
   v5->AddFrame(fDrawSame, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fNoDrawing = new TGCheckButton(v5, "No drawing", kFP_DNONE);
   fNoDrawing->Associate(this);
   fNoDrawing->SetToolTipText("'0'- do not draw function graphics");
   v5->AddFrame(fNoDrawing, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   fNoStoreDrawing = new TGCheckButton(v5, "Do not store/draw", kFP_DNOST);
   fNoStoreDrawing->Associate(this);
   fNoStoreDrawing->SetToolTipText("'N'- do not store the function, do not draw it");
   v5->AddFrame(fNoStoreDrawing, new TGLayoutHints(kLHintsNormal, 0, 0, 2, 2));

   h6->AddFrame(v5, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));

   TGVerticalFrame *v6 = new TGVerticalFrame(h6);
   TGCompositeFrame *v61 = new TGCompositeFrame(v6, 120, 20,
                                                kHorizontalFrame | kFixedWidth);
   fDrawAdvanced = new TGTextButton(v61, "&Advanced...", kFP_DADVB);
   v61->AddFrame(fDrawAdvanced, new TGLayoutHints(kLHintsRight   |
                                                  kLHintsCenterY |
                                                  kLHintsExpandX));
   fDrawAdvanced->SetToolTipText("Open a dialog for advanced draw options");
   fDrawAdvanced->SetState(kButtonDisabled);

   v6->AddFrame(v61, new TGLayoutHints(kLHintsRight | kLHintsTop,
                                       0, 0, (4+fDrawSame->GetHeight())*2, 0));

   h6->AddFrame(v6, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
   gf->AddFrame(h6, new TGLayoutHints(kLHintsExpandX, 20, 0, 2, 0));

   fGeneral->AddFrame(gf, new TGLayoutHints(kLHintsExpandX |
                                            kLHintsExpandY, 5, 5, 0, 0));
   // sliderX
   fSliderXParent = new TGHorizontalFrame(fGeneral);
   TGLabel *label8 = new TGLabel(fSliderXParent, "X");
   fSliderXParent->AddFrame(label8, new TGLayoutHints(kLHintsLeft |
                                                      kLHintsCenterY, 0, 5, 0, 0));

   fSliderXMin = new TGNumberEntry(fSliderXParent, 0, 5, kFP_XMIN,
                                   TGNumberFormat::kNESRealTwo,
                                   TGNumberFormat::kNEAAnyNumber,
                                   TGNumberFormat::kNELLimitMinMax, -1,1);
   fSliderXParent->AddFrame(fSliderXMin, new TGLayoutHints(kLHintsLeft | kLHintsCenterY));

   fSliderX = new TGDoubleHSlider(fSliderXParent, 1, kDoubleScaleBoth);
   fSliderX->SetScale(5);
   fSliderXParent->AddFrame(fSliderX, new TGLayoutHints(kLHintsExpandX | kLHintsCenterY));


   fSliderXMax = new TGNumberEntry(fSliderXParent, 0, 5, kFP_XMIN,
                                   TGNumberFormat::kNESRealTwo,
                                   TGNumberFormat::kNEAAnyNumber,
                                   TGNumberFormat::kNELLimitMinMax, -1,1);
   fSliderXParent->AddFrame(fSliderXMax, new TGLayoutHints(kLHintsRight | kLHintsCenterY));
   fGeneral->AddFrame(fSliderXParent, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));

   // sliderY
   fSliderYParent = new TGHorizontalFrame(fGeneral);
   TGLabel *label9 = new TGLabel(fSliderYParent, "Y");
   fSliderYParent->AddFrame(label9, new TGLayoutHints(kLHintsLeft |
                                                      kLHintsCenterY, 0, 5, 0, 0));

   fSliderYMin = new TGNumberEntry(fSliderYParent, 0, 5, kFP_YMIN,
                                   TGNumberFormat::kNESRealTwo,
                                   TGNumberFormat::kNEAAnyNumber,
                                   TGNumberFormat::kNELLimitMinMax, -1,1);
   fSliderYParent->AddFrame(fSliderYMin, new TGLayoutHints(kLHintsLeft | kLHintsCenterY));

   fSliderY = new TGDoubleHSlider(fSliderYParent, 1, kDoubleScaleBoth);
   fSliderY->SetScale(5);
   fSliderYParent->AddFrame(fSliderY, new TGLayoutHints(kLHintsExpandX | kLHintsCenterY));

   fSliderYMax = new TGNumberEntry(fSliderYParent, 0, 5, kFP_YMIN,
                                   TGNumberFormat::kNESRealTwo,
                                   TGNumberFormat::kNEAAnyNumber,
                                   TGNumberFormat::kNELLimitMinMax, -1,1);
   fSliderYParent->AddFrame(fSliderYMax, new TGLayoutHints(kLHintsRight | kLHintsCenterY));
   fGeneral->AddFrame(fSliderYParent, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));

   // sliderZ
   fSliderZParent = new TGHorizontalFrame(fGeneral);
   TGLabel *label10 = new TGLabel(fSliderZParent, "Z:");
   fSliderZParent->AddFrame(label10, new TGLayoutHints(kLHintsLeft |
                                                       kLHintsCenterY, 0, 5, 0, 0));
   fSliderZ = new TGDoubleHSlider(fSliderZParent, 1, kDoubleScaleBoth);
   fSliderZ->SetScale(5);
   fSliderZParent->AddFrame(fSliderZ, new TGLayoutHints(kLHintsExpandX | 
                                                        kLHintsCenterY));
   fGeneral->AddFrame(fSliderZParent, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
}


//______________________________________________________________________________
void TFitEditor::CreateMinimizationTab()
{
   // Create 'Minimization' tab.
   
   fTabContainer = fTab->AddTab("Minimization");
   fMinimization = new TGCompositeFrame(fTabContainer, 10, 10, kVerticalFrame);
   fTabContainer->AddFrame(fMinimization, new TGLayoutHints(kLHintsTop |
                                                            kLHintsExpandX,
                                                            5, 5, 2, 2));
   MakeTitle(fMinimization, "Library");

   TGHorizontalFrame *hl = new TGHorizontalFrame(fMinimization);
   fLibMinuit = new TGRadioButton(hl, "Minuit", kFP_LMIN);
   fLibMinuit->Associate(this);
   fLibMinuit->SetToolTipText("Use minimization from libMinuit (default)");
   hl->AddFrame(fLibMinuit, new TGLayoutHints(kLHintsNormal, 40, 0, 0, 1));
   fStatusBar->SetText("LIB Minuit",1);

   fLibMinuit2 = new TGRadioButton(hl, "Minuit2", kFP_LMIN2);
   fLibMinuit2->Associate(this);
   fLibMinuit2->SetToolTipText("New C++ version of Minuit");
   hl->AddFrame(fLibMinuit2, new TGLayoutHints(kLHintsNormal, 35, 0, 0, 1));

   fLibFumili = new TGRadioButton(hl, "Fumili", kFP_LFUM);
   fLibFumili->Associate(this);
   fLibFumili->SetToolTipText("Use minimization from libFumili");
   hl->AddFrame(fLibFumili, new TGLayoutHints(kLHintsNormal, 30, 0, 0, 1));
   fMinimization->AddFrame(hl, new TGLayoutHints(kLHintsExpandX, 20, 0, 5, 1));

   TGHorizontalFrame *hl2 = new TGHorizontalFrame(fMinimization);

   fLibGSL = new TGRadioButton(hl2, "GSL", kFP_LGSL);
   #ifdef R__HAS_MATHMORE
   fLibGSL->Associate(this);
   fLibGSL->SetToolTipText("Use minimization from libGSL");
   #else
   fLibGSL->SetState(kButtonDisabled);
   fLibGSL->SetToolTipText("Needs GSL to be compiled");
   #endif
   hl2->AddFrame(fLibGSL, new TGLayoutHints(kLHintsNormal, 40, 0, 0, 1));

   fLibGenetics = new TGRadioButton(hl2, "Genetics", kFP_LGAS);
   if (gPluginMgr->FindHandler("ROOT::Math::Minimizer","Genetic") ||
       gPluginMgr->FindHandler("ROOT::Math::Minimizer","GAlibMin") )
   {
      fLibGenetics->Associate(this);
      fLibGenetics->SetToolTipText("Different GAs implementations");
   } else {
      fLibGenetics->SetState(kButtonDisabled);
      fLibGenetics->SetToolTipText("Needs any of the genetic" 
                                   "minimizers to be compiled");
   }
   hl2->AddFrame(fLibGenetics, new TGLayoutHints(kLHintsNormal, 45, 0, 0, 1));

   fMinimization->AddFrame(hl2, new TGLayoutHints(kLHintsExpandX, 20, 0, 5, 1));

   MakeTitle(fMinimization, "Method");

   TGHorizontalFrame *hm0 = new TGHorizontalFrame(fMinimization);
   fMinMethodList = new TGComboBox(hm0, kFP_MINMETHOD);
   fMinMethodList->Resize(290, 20);
   fMinMethodList->Select(kFP_GAUS, kFALSE);

   TGListBox *lb = fMinMethodList->GetListBox();
   lb->Resize(lb->GetWidth(), 500);
   fMinMethodList->Associate(this);

   hm0->AddFrame(fMinMethodList, new TGLayoutHints(kLHintsNormal));
   fMinimization->AddFrame(hm0, new TGLayoutHints(kLHintsExpandX, 60, 0, 5, 1));

   // Set the status to the default minimization options!
   if ( ROOT::Math::MinimizerOptions::DefaultMinimizerType() == "Fumili" ) {
      fLibFumili->SetState(kButtonDown);
   } else if ( ROOT::Math::MinimizerOptions::DefaultMinimizerType() == "Minuit" ) {
      fLibMinuit->SetState(kButtonDown);
   } else {
      fLibMinuit2->SetState(kButtonDown);
   }
   FillMinMethodList();

   MakeTitle(fMinimization, "Settings");
   TGLabel *hslabel1 = new TGLabel(fMinimization,"Use ENTER key to validate a new value or click");
   fMinimization->AddFrame(hslabel1, new TGLayoutHints(kLHintsNormal, 61, 0, 5, 1));
   TGLabel *hslabel2 = new TGLabel(fMinimization,"on Reset button to set the defaults.");
   fMinimization->AddFrame(hslabel2, new TGLayoutHints(kLHintsNormal, 61, 0, 1, 10));

   TGHorizontalFrame *hs = new TGHorizontalFrame(fMinimization);
   
   TGVerticalFrame *hsv1 = new TGVerticalFrame(hs, 180, 10, kFixedWidth);
   TGLabel *errlabel = new TGLabel(hsv1,"Error definition (default = 1): ");
   hsv1->AddFrame(errlabel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 
                                              1, 1, 5, 7));
   TGLabel *tollabel = new TGLabel(hsv1,"Max tolerance (precision): ");
   hsv1->AddFrame(tollabel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 
                                              1, 1, 5, 7));
   TGLabel *itrlabel = new TGLabel(hsv1,"Max number of iterations: ");
   hsv1->AddFrame(itrlabel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 
                                              1, 1, 5, 5));
   hs->AddFrame(hsv1, new TGLayoutHints(kLHintsNormal, 60, 0, 0, 0));
   
   TGVerticalFrame *hsv2 = new TGVerticalFrame(hs, 90,10, kFixedWidth);
   fErrorScale = new TGNumberEntryField(hsv2, kFP_MERR, ROOT::Math::MinimizerOptions::DefaultErrorDef(),
                                        TGNumberFormat::kNESRealTwo,
                                        TGNumberFormat::kNEAPositive,
                                        TGNumberFormat::kNELLimitMinMax,0.,100.);
   hsv2->AddFrame(fErrorScale, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 
                                                 1, 1, 0, 3));
   fTolerance = new TGNumberEntryField(hsv2, kFP_MTOL, ROOT::Math::MinimizerOptions::DefaultTolerance(), 
                                       TGNumberFormat::kNESReal,
                                       TGNumberFormat::kNEAPositive,
                                       TGNumberFormat::kNELLimitMinMax, 0., 1.);
   fTolerance->SetNumber(ROOT::Math::MinimizerOptions::DefaultTolerance());
   hsv2->AddFrame(fTolerance, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 
                                                1, 1, 3, 3));
   fIterations = new TGNumberEntryField(hsv2, kFP_MITR, 5000, 
                                   TGNumberFormat::kNESInteger,
                                   TGNumberFormat::kNEAPositive,
                                   TGNumberFormat::kNELNoLimits);
   fIterations->SetNumber(ROOT::Math::MinimizerOptions::DefaultMaxIterations());
   hsv2->AddFrame(fIterations, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 
                                                 1, 1, 3, 3));
   hs->AddFrame(hsv2, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
   fMinimization->AddFrame(hs, new TGLayoutHints(kLHintsExpandX, 0, 0, 1, 1));
   fStatusBar->SetText(Form("Itr: %d",ROOT::Math::MinimizerOptions::DefaultMaxIterations()),3);

   MakeTitle(fMinimization, "Print Options");

   TGHorizontalFrame *h8 = new TGHorizontalFrame(fMinimization);
   fOptDefault = new TGRadioButton(h8, "Default", kFP_PDEF);
   fOptDefault->Associate(this);
   fOptDefault->SetToolTipText("Default is between Verbose and Quiet");
   h8->AddFrame(fOptDefault, new TGLayoutHints(kLHintsNormal, 40, 0, 0, 1));
   fOptDefault->SetState(kButtonDown);
   fStatusBar->SetText("Prn: DEF",4);

   fOptVerbose = new TGRadioButton(h8, "Verbose", kFP_PVER);
   fOptVerbose->Associate(this);
   fOptVerbose->SetToolTipText("'V'- print results after each iteration");
   h8->AddFrame(fOptVerbose, new TGLayoutHints(kLHintsNormal, 30, 0, 0, 1));

   fOptQuiet = new TGRadioButton(h8, "Quiet", kFP_PQET);
   fOptQuiet->Associate(this);
   fOptQuiet->SetToolTipText("'Q'- no print");
   h8->AddFrame(fOptQuiet, new TGLayoutHints(kLHintsNormal, 25, 0, 0, 1));

   fMinimization->AddFrame(h8, new TGLayoutHints(kLHintsExpandX, 20, 0, 5, 1));

}

//______________________________________________________________________________
void TFitEditor::ConnectSlots()
{
   // Connect GUI signals to fit panel slots.

   // list of data sets to fit
   fDataSet->Connect("Selected(Int_t)", "TFitEditor", this, "DoDataSet(Int_t)");
   // list of predefined functions
   fTypeFit->Connect("Selected(Int_t)", "TFitEditor", this, "FillFunctionList(Int_t)");
   // list of predefined functions
   fFuncList->Connect("Selected(Int_t)", "TFitEditor", this, "DoFunction(Int_t)");
   // entered formula or function name
   fEnteredFunc->Connect("ReturnPressed()", "TFitEditor", this, "DoEnteredFunction()");
   // set parameters dialog
   fSetParam->Connect("Clicked()", "TFitEditor", this, "DoSetParameters()");
   // allowed function operations
   fAdd->Connect("Toggled(Bool_t)","TFitEditor", this, "DoAddition(Bool_t)");

   // fit options
   fAllWeights1->Connect("Toggled(Bool_t)","TFitEditor",this,"DoAllWeights1()");
   fUseRange->Connect("Toggled(Bool_t)","TFitEditor",this,"DoUseFuncRange()");
   fEmptyBinsWghts1->Connect("Toggled(Bool_t)","TFitEditor",this,"DoEmptyBinsAllWeights1()");

   // linear fit
   fLinearFit->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLinearFit()");
   fNoChi2->Connect("Toggled(Bool_t)","TFitEditor",this,"DoNoChi2()");

   // draw options
   fNoStoreDrawing->Connect("Toggled(Bool_t)","TFitEditor",this,"DoNoStoreDrawing()");

   // fit, reset, close buttons
   fUpdateButton->Connect("Clicked()", "TFitEditor", this, "DoUpdate()");
   fFitButton->Connect("Clicked()", "TFitEditor", this, "DoFit()");
   fResetButton->Connect("Clicked()", "TFitEditor", this, "DoReset()");
   fCloseButton->Connect("Clicked()", "TFitEditor", this, "DoClose()");

   // user method button
   fUserButton->Connect("Clicked()", "TFitEditor", this, "DoUserDialog()");
   // advanced draw options
   fDrawAdvanced->Connect("Clicked()", "TFitEditor", this, "DoAdvancedOptions()");

   if (fType != kObjectTree) {
      fSliderX->Connect("PositionChanged()","TFitEditor",this, "DoSliderXMoved()");
      fSliderXMax->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderXChanged()");
      fSliderXMin->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderXChanged()");
   }
   if (fDim > 1) {
      fSliderY->Connect("PositionChanged()","TFitEditor",this, "DoSliderYMoved()");
      fSliderYMax->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderYChanged()");
      fSliderYMin->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderYChanged()");
   }
   if (fDim > 2)
      fSliderZ->Connect("PositionChanged()","TFitEditor",this, "DoSliderZMoved()");

   if ( fParentPad )
      fParentPad->Connect("RangeAxisChanged()", "TFitEditor", this, "UpdateGUI()");
   
   // 'Minimization' tab
   // library
   fLibMinuit->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLibrary(Bool_t)");
   fLibMinuit2->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLibrary(Bool_t)");
   fLibFumili->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLibrary(Bool_t)");
   fLibGSL->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLibrary(Bool_t)");
   fLibGenetics->Connect("Toggled(Bool_t)","TFitEditor",this,"DoLibrary(Bool_t)");

   // minimization method
   fMinMethodList->Connect("Selected(Int_t)", "TFitEditor", this, "DoMinMethod(Int_t)");

   // fitter settings
   fIterations->Connect("ReturnPressed()", "TFitEditor", this, "DoMaxIterations()");
   
   // print options
   fOptDefault->Connect("Toggled(Bool_t)","TFitEditor",this,"DoPrintOpt(Bool_t)");
   fOptVerbose->Connect("Toggled(Bool_t)","TFitEditor",this,"DoPrintOpt(Bool_t)");
   fOptQuiet->Connect("Toggled(Bool_t)","TFitEditor",this,"DoPrintOpt(Bool_t)");

}

//______________________________________________________________________________
void TFitEditor::DisconnectSlots()
{
   // Disconnect GUI signals from fit panel slots.

   Disconnect("CloseWindow()");

   fFuncList->Disconnect("Selected(Int_t)");
   fEnteredFunc->Disconnect("ReturnPressed()");
   fSetParam->Disconnect("Clicked()");
   fAdd->Disconnect("Toggled(Bool_t)");

   // fit options
   fAllWeights1->Disconnect("Toggled(Bool_t)");
   fEmptyBinsWghts1->Disconnect("Toggled(Bool_t)");

   // linear fit
   fLinearFit->Disconnect("Toggled(Bool_t)");
   fNoChi2->Disconnect("Toggled(Bool_t)");

   // draw options
   fNoStoreDrawing->Disconnect("Toggled(Bool_t)");

   // fit, reset, close buttons
   fFitButton->Disconnect("Clicked()");
   fResetButton->Disconnect("Clicked()");
   
   // other methods
   fUserButton->Disconnect("Clicked()");
   fDrawAdvanced->Disconnect("Clicked()");

   if (fType != kObjectTree) {
      fSliderX->Disconnect("PositionChanged()");
      fSliderXMax->Disconnect("ValueChanged(Long_t)");
      fSliderXMin->Disconnect("ValueChanged(Long_t)");
   }
   if (fDim > 1) {
      fSliderY->Disconnect("PositionChanged()");
      fSliderYMax->Disconnect("ValueChanged(Long_t)");
      fSliderYMin->Disconnect("ValueChanged(Long_t)");
   }
   if (fDim > 2) 
      fSliderZ->Disconnect("PositionChanged()");
   
   // slots related to 'Minimization' tab
   fLibMinuit->Disconnect("Toggled(Bool_t)");
   fLibMinuit2->Disconnect("Toggled(Bool_t)");
   fLibFumili->Disconnect("Toggled(Bool_t)");
   fLibGSL->Disconnect("Toggled(Bool_t)");
   fLibGenetics->Disconnect("Toggled(Bool_t)");

   // minimization method
   fMinMethodList->Disconnect("Selected(Int_t)");
   
   // fitter settings
   fIterations->Disconnect("ReturnPressed()");

   // print options
   fOptDefault->Disconnect("Toggled(Bool_t)");
   fOptVerbose->Disconnect("Toggled(Bool_t)");
   fOptQuiet->Disconnect("Toggled(Bool_t)");

}

//______________________________________________________________________________
void TFitEditor::SetCanvas(TCanvas * /*newcan*/)
{
   // Connect to another canvas.

   // The next line is commented because it is stablishing a
   // connection with the particular canvas, while right the following
   // line will connect all the canvas in a general way.

   // It would also make the fitpanel crash if there is no object
   // defined to be fitted in the construction (as a side effect of
   // it).

//    newcan->Connect("Selected(TVirtualPad*,TObject*,Int_t)", "TFitEditor",
//                    this, "SetFitObject(TVirtualPad *, TObject *, Int_t)");

   TQObject::Connect("TCanvas", "Selected(TVirtualPad *, TObject *, Int_t)", 
                     "TFitEditor",this, 
                     "SetFitObject(TVirtualPad *, TObject *, Int_t)");
   TQObject::Connect("TCanvas", "Closed()", "TFitEditor", this, "DoNoSelection()");
}

//______________________________________________________________________________
void TFitEditor::Hide()
{
   // Hide the fit panel and set it to non-active state. 

   if (fgFitDialog) {
      fgFitDialog->UnmapWindow();
   }
   if (fParentPad) {
      fParentPad->Disconnect("RangeAxisChanged()");
      DoReset();
   }
   fParentPad = 0;
   fFitObject = 0;
   gROOT->GetListOfCleanups()->Remove(this);
}

//______________________________________________________________________________
void TFitEditor::Show(TVirtualPad* pad, TObject *obj)
{
   // Show the fit panel (possible only via context menu).

   if (!gROOT->GetListOfCleanups()->FindObject(this))
      gROOT->GetListOfCleanups()->Add(this);   

   if (!fgFitDialog->IsMapped()) {
      fgFitDialog->MapWindow();
      gVirtualX->RaiseWindow(GetId());
   }
   fParentPad = static_cast<TPad*>(pad);
   SetCanvas(pad->GetCanvas());
   SetFitObject(pad, obj, kButton1Down);
}

//______________________________________________________________________________
void TFitEditor::CloseWindow()
{
   // Close fit panel window.

   Hide();
}

//______________________________________________________________________________
// TFitEditor *&TFitEditor::GetFP()
// {
//    // Static: return main fit panel
//    return fgFitDialog;
// }

//______________________________________________________________________________
void TFitEditor::Terminate()
{
   //  Called to delete the fit panel. 

   TQObject::Disconnect("TCanvas", "Closed()");
   delete fgFitDialog;
   fgFitDialog = 0;
}

//______________________________________________________________________________
void TFitEditor::UpdateGUI()
{
   //  Set the fit panel GUI according to the selected object. 

   if (!fFitObject) return;

   DrawSelection(true);

   if ( fType == kObjectTree )
      // Don't do anything with the sliders, as they work with TAxis
      // that are not defined for the TTree
      return;

   // sliders
   if (fType != kObjectTree) { // This is as fDim > 0
      TH1* hist = 0;
      switch (fType) {
         case kObjectHisto:
            hist = (TH1*)fFitObject;
            break;

         case kObjectGraph:
            hist = ((TGraph*)fFitObject)->GetHistogram();
            break;

         case kObjectMultiGraph:
            hist = ((TMultiGraph*)fFitObject)->GetHistogram();
            break;

         case kObjectGraph2D:
            hist = ((TGraph2D*)fFitObject)->GetHistogram("empty");
            break;

         case kObjectHStack: 
            hist = (TH1 *)((THStack *)fFitObject)->GetHists()->First();

         case kObjectTree:
         default:
            break;
      }
      

      if (!hist) {
         Error("UpdateGUI","No hist is present - this should not happen, please report."
               "The FitPanel might be in an inconsistent state");
         //assert(hist);
         return;
      }

      fSliderX->Disconnect("PositionChanged()");
      fSliderXMin->Disconnect("ValueChanged()");
      fSliderXMax->Disconnect("ValueChanged()");

      if (!fSliderXParent->IsMapped())
         fSliderXParent->MapWindow();

      fXaxis = hist->GetXaxis();
      fYaxis = hist->GetYaxis();
      fZaxis = hist->GetZaxis();
      Int_t ixrange = fXaxis->GetNbins();
      Int_t ixmin = fXaxis->GetFirst();
      Int_t ixmax = fXaxis->GetLast();

      if (ixmin > 1 || ixmax < ixrange) {
	fSliderX->SetRange(ixmin,ixmax);
	fSliderX->SetPosition(ixmin, ixmax);
      } else {
	fSliderX->SetRange(1,ixrange);
	fSliderX->SetPosition(ixmin,ixmax);
      }
      
      fSliderX->SetScale(5);

      fSliderXMin->SetLimits(TGNumberFormat::kNELLimitMinMax,
                             fXaxis->GetBinLowEdge( static_cast<Int_t>( fSliderX->GetMinPosition() ) ), 
                             fXaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderX->GetMaxPosition() ) ));
      fSliderXMin->SetNumber( fXaxis->GetBinLowEdge( static_cast<Int_t>( fSliderX->GetMinPosition() ) ));
      fSliderXMax->SetLimits(TGNumberFormat::kNELLimitMinMax,
                             fXaxis->GetBinLowEdge( static_cast<Int_t>( fSliderX->GetMinPosition() ) ), 
                             fXaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderX->GetMaxPosition() ) ));
      fSliderXMax->SetNumber( fXaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderX->GetMaxPosition() ) ));

      fSliderX->Connect("PositionChanged()","TFitEditor",this, "DoSliderXMoved()");
      fSliderXMax->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderXChanged()");
      fSliderXMin->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderXChanged()");
   }

   if (fDim > 1) {
      fSliderY->Disconnect("PositionChanged()");
      fSliderYMin->Disconnect("ValueChanged()");
      fSliderYMax->Disconnect("ValueChanged()");

      if (!fSliderYParent->IsMapped())
         fSliderYParent->MapWindow();
      if (fSliderZParent->IsMapped())
         fSliderZParent->UnmapWindow();

      Int_t iymin = 0, iymax = 0, iyrange = 0;
      switch (fType) {
         case kObjectHisto: 
         case kObjectGraph2D:
         case kObjectHStack: 
            iyrange = fYaxis->GetNbins();
            iymin = fYaxis->GetFirst();
            iymax = fYaxis->GetLast();
            break;
         
         case kObjectGraph: 
         case kObjectMultiGraph: 
         case kObjectTree:
         default:
            //not implemented
            break;
      }

      if (iymin > 1 || iymax < iyrange) {
	fSliderY->SetRange(iymin,iymax);
	fSliderY->SetPosition(iymin, iymax);
      } else {
	fSliderY->SetRange(1,iyrange);
	fSliderY->SetPosition(iymin,iymax);
      }

      fSliderY->SetScale(5);

      fSliderYMin->SetLimits(TGNumberFormat::kNELLimitMinMax,
                             fYaxis->GetBinLowEdge( static_cast<Int_t>( fSliderY->GetMinPosition() ) ), 
                             fYaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderY->GetMaxPosition() ) ));
      fSliderYMin->SetNumber(fYaxis->GetBinLowEdge( static_cast<Int_t>( fSliderY->GetMinPosition() ) ));
      fSliderYMax->SetLimits(TGNumberFormat::kNELLimitMinMax,
                             fYaxis->GetBinLowEdge( static_cast<Int_t>( fSliderY->GetMinPosition() ) ), 
                             fYaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderY->GetMaxPosition() ) ));
      fSliderYMax->SetNumber( fYaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderY->GetMaxPosition() ) ));

      fSliderY->Connect("PositionChanged()","TFitEditor",this, "DoSliderYMoved()");
      fSliderYMax->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderYChanged()");
      fSliderYMin->Connect("ValueSet(Long_t)", "TFitEditor", this, "DoNumericSliderYChanged()");
   }

   
   if (fDim > 2) {
      fSliderZ->Disconnect("PositionChanged()");

      if (!fSliderZParent->IsMapped())
         fSliderZParent->MapWindow();

      Int_t izmin = 0, izmax = 0, izrange = 0;
      switch (fType) {
         case kObjectHStack:
         case kObjectHisto:
            izrange = fZaxis->GetNbins();
            izmin = fZaxis->GetFirst();
            izmax = fZaxis->GetLast();
            break;

         case kObjectGraph:
         case kObjectGraph2D:
         case kObjectMultiGraph:
         case kObjectTree:
         default:
            //not implemented
            break;
      }

      if (izmin > 1 || izmax < izrange) {
	fSliderZ->SetRange(izmin,izmax);
	fSliderZ->SetPosition(izmin, izmax);
      } else {
	fSliderZ->SetRange(1,izrange);
	fSliderZ->SetPosition(izmin,izmax);
      }

      fSliderZ->SetScale(5);
      fSliderZ->Connect("PositionChanged()","TFitEditor",this, "DoSliderZMoved()");
   }
}

//______________________________________________________________________________
void TFitEditor::SetFitObject(TVirtualPad *pad, TObject *obj, Int_t event)
{
   // Slot called when the user clicks on an object inside a canvas. 
   // Updates pointers to the parent pad and the selected object
   // for fitting (if suitable).

   if (event != kButton1Down) return;

   if ( !obj ) {
      DoNoSelection();
      return;
   }
   
   // is obj suitable for fitting?
   if (!SetObjectType(obj)) return;

   fParentPad = pad;
   fFitObject = obj;
   ShowObjectName(obj);
   UpdateGUI();

   ConnectSlots();
   
   TF1* fitFunc = HasFitFunction();

   if (fitFunc) {
      //fFuncPars = FuncParams_t( fitFunc->GetNpar() );
      GetParameters(fFuncPars, fitFunc);

      TString tmpStr = fitFunc->GetExpFormula();
      TGLBEntry *en = 0;
      // If the function comes from a C raw function.
      if ( tmpStr.Length() == 0 )
      {
         // Show the name of the function
         fEnteredFunc->SetText(fitFunc->GetName());
         en= fFuncList->FindEntry(fitFunc->GetName());
         // Don't allow edition!
         SetEditable(kFALSE);
      }
      // otherwise, it's got a formula
      else
      {
         // Show the formula
         fEnteredFunc->SetText(fitFunc->GetExpFormula().Data());
         en= fFuncList->FindEntry(fitFunc->GetExpFormula().Data());
         SetEditable(kTRUE);
      }
      // Select the proper entry in the function list
      if (en) fFuncList->Select(en->EntryId());
   } else { // if there is no fit function in the object
      // Use the selected function in fFuncList
      TGTextLBEntry *te = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
      // Add the text to fEnteredFunc
      if (te && fNone->GetState() == kButtonDown)
         fEnteredFunc->SetText(te->GetTitle());
      else if (te && fAdd->GetState() == kButtonDown) {
         TString tmpStr = fEnteredFunc->GetText();
         tmpStr += '+';
         tmpStr +=te->GetTitle();
         fEnteredFunc->SetText(tmpStr);
      } else if ( !te )
         // If there is no space, an error message is shown:
         // Error in <TString::AssertElement>: out of bounds: i = -1, Length = 0
         // If there is no function selected, then put nothing.
         fEnteredFunc->SetText(" ");
   }
   fEnteredFunc->SelectAll();


   // Update the information about the selected object.
   if (fSetParam->GetState() == kButtonDisabled)
      fSetParam->SetEnabled(kTRUE);
   if (fFitButton->GetState() == kButtonDisabled)
      fFitButton->SetEnabled(kTRUE);
   if (fResetButton->GetState() == kButtonDisabled)
      fResetButton->SetEnabled(kTRUE);
   DoLinearFit();
}

//______________________________________________________________________________
void TFitEditor::DoNoSelection()
{
   // Slot called when users close a TCanvas or when the user select
   // no object.

   if (gROOT->GetListOfCanvases()->IsEmpty()) {
      Terminate();
      return;
   }
   
   // Minimize user interaction until an object is selected
   DisconnectSlots();
   fParentPad = 0;
   fFitObject = 0;
   fStatusBar->SetText("No selection",0);
   fDataSet->Select(kFP_NOSEL, kFALSE);
   Layout();

   fSetParam->SetEnabled(kFALSE);
   fFitButton->SetEnabled(kFALSE);
   fResetButton->SetEnabled(kFALSE);
   fDrawAdvanced->SetState(kButtonDisabled);
}

//______________________________________________________________________________
void TFitEditor::RecursiveRemove(TObject* obj)
{
   // When obj is deleted, clear fFitObject if fFitObject = obj.

   if (obj == fFitObject) {
      fFitObject = 0;
      DisconnectSlots();
      fStatusBar->SetText("No selection",0);
      fDataSet->Select(kFP_NOSEL, kFALSE);
      Layout();

      fFitButton->SetEnabled(kFALSE);
      fResetButton->SetEnabled(kFALSE);
      fSetParam->SetEnabled(kFALSE);
      
      TQObject::Connect("TCanvas", "Selected(TVirtualPad *, TObject *, Int_t)", 
                        "TFitEditor",this, 
                        "SetFitObject(TVirtualPad *, TObject *, Int_t)");
      TQObject::Connect("TCanvas", "Closed()", "TFitEditor", this, 
                        "DoNoSelection()");

      DoUpdate();
      return;
   }
   if (obj == fParentPad) {
      fFitObject = 0;
      fParentPad = 0;
      DisconnectSlots();
      fStatusBar->SetText("No selection",0);
      fDataSet->Select(kFP_NOSEL, kFALSE);
      Layout();

      fFitButton->SetEnabled(kFALSE);
      fResetButton->SetEnabled(kFALSE);
      fSetParam->SetEnabled(kFALSE);
   }
}

//______________________________________________________________________________
void TFitEditor::FillFunctionList(Int_t)
{
   // Fills the list of functions depending on the type of fit
   // selected.

   fFuncList->RemoveAll();
   // Case when the user has selected predefined functions in 1D.
   if ( fTypeFit->GetSelected() == kFP_PRED1D && fDim <= 1 ) {
      // Fill function list combo box.
      fFuncList->AddEntry("gaus" ,  kFP_GAUS);
      fFuncList->AddEntry("gausn",  kFP_GAUSN);
      fFuncList->AddEntry("expo",   kFP_EXPO);
      fFuncList->AddEntry("landau", kFP_LAND);
      fFuncList->AddEntry("landaun",kFP_LANDN);
      fFuncList->AddEntry("pol0",   kFP_POL0);
      fFuncList->AddEntry("pol1",   kFP_POL1);
      fFuncList->AddEntry("pol2",   kFP_POL2);
      fFuncList->AddEntry("pol3",   kFP_POL3);
      fFuncList->AddEntry("pol4",   kFP_POL4);
      fFuncList->AddEntry("pol5",   kFP_POL5);
      fFuncList->AddEntry("pol6",   kFP_POL6);
      fFuncList->AddEntry("pol7",   kFP_POL7);
      fFuncList->AddEntry("pol8",   kFP_POL8);
      fFuncList->AddEntry("pol9",   kFP_POL9);
      fFuncList->AddEntry("user",   kFP_USER);

      // Need to be setted this way, otherwise when the functions
      // are removed, the list doesn't show them.
      TGListBox *lb = fFuncList->GetListBox();
      lb->Resize(lb->GetWidth(), 200);

      // Select Gaus1D by default
      fFuncList->Select(kFP_GAUS);
   }
   // Case for predefined 2D functions
   else if ( fTypeFit->GetSelected() == kFP_PRED2D && fDim == 2 ) {
      fFuncList->AddEntry("xygaus", kFP_XYGAUS);
      fFuncList->AddEntry("xyexpo", kFP_XYEXP);
      fFuncList->AddEntry("xylandau", kFP_XYLAN);
      fFuncList->AddEntry("xylandaun", kFP_XYLANN);

      // Need to be setted this way, otherwise when the functions
      // are removed, the list doesn't show them.x
      TGListBox *lb = fFuncList->GetListBox(); 
      lb->Resize(lb->GetWidth(), 200);

      // Select Gaus2D by default
      fFuncList->Select(kFP_XYGAUS);
   }
   // Case for user defined functions. References to these functions
   // are kept by the fitpanel, so the information is gathered from
   // there.
   else if ( fTypeFit->GetSelected() == kFP_UFUNC ) {
      Int_t newid = kFP_ALTFUNC;

      // Add system functions
      for ( fSystemFuncIter it = fSystemFuncs.begin();
            it != fSystemFuncs.end(); ++it ) {
         TF1* f = (*it);
         // Don't include system functions that has been previously
         // used to fit, as those are included under the kFP_PREVFIT
         // section.
         if ( strncmp(f->GetName(), "PrevFit", 7) != 0 ) {
            // If the dimension of the object coincides with the
            // dimension of the function, then include the function in
            // the list. It will also include de function if the
            // dimension of the object is 0 (i.e. a multivariable
            // TTree) as it is currently imposible to know how many
            // dimensions a TF1 coming from a C raw function has.
            if ( f->GetNdim() == fDim || fDim == 0) {
               fFuncList->AddEntry(f->GetName(), newid++); 
            }
         }
      }

      // If no function was added
      if ( newid != kFP_ALTFUNC )
         fFuncList->Select(newid-1);
      else if( fDim == 1 ) {
         // Select predefined 1D functions for 1D objects
         fTypeFit->Select(kFP_PRED1D, kTRUE);
      } else if( fDim == 2 ) {
         // Select predefined 2D functions for 2D objects
         fTypeFit->Select(kFP_PRED2D, kTRUE);
      }
   } 
   // Case for previously used functions.
   else if ( fTypeFit->GetSelected() == kFP_PREVFIT ) {
      Int_t newid = kFP_ALTFUNC;
      
      // Look only for those functions used in the selected object
      pair<fPrevFitIter, fPrevFitIter> look = fPrevFit.equal_range(fFitObject);
      // Then go over all those functions and add them to the list
      for ( fPrevFitIter it = look.first; it != look.second; ++it ) {
         fFuncList->AddEntry(it->second->GetName(), newid++);
      }

      // If no functions were added.
      if ( newid == kFP_ALTFUNC ) {
         // Remove the entry previous fit from fTypeFit
         fTypeFit->RemoveEntry(kFP_PREVFIT);
         if( fDim == 1 )
            // Select predefined 1D functions for 1D objects
            fTypeFit->Select(kFP_PRED1D, kTRUE);
         else if ( fDim == 2 )
            // Select predefined 2D functions for 2D objects
            fTypeFit->Select(kFP_PRED2D, kTRUE);
         else
            // For more than 2 dimensions, select the user functions.
            fTypeFit->Select(kFP_UFUNC, kTRUE);
      }
      else
         // If there is there are previously used functions, select
         // the last one inserted.
         fFuncList->Select(newid-1, kTRUE);
   }
}

//______________________________________________________________________________
void TFitEditor::FillMinMethodList(Int_t)
{
   // Fills the list of methods depending on the minimization library
   // selected.

   fMinMethodList->RemoveAll();
   
   if ( fLibMinuit->GetState() == kButtonDown ) 
   {
      fMinMethodList->AddEntry("MIGRAD" ,       kFP_MIGRAD);
      fMinMethodList->AddEntry("SIMPLEX" ,      kFP_SIMPLX);
      fMinMethodList->AddEntry("SCAN" ,         kFP_SCAN);
      fMinMethodList->AddEntry("Combination" ,  kFP_COMBINATION);
      fMinMethodList->Select(kFP_MIGRAD, kFALSE);
      fStatusBar->SetText("MIGRAD",2);
   } else if ( fLibFumili->GetState() == kButtonDown ) 
   {
      fMinMethodList->AddEntry("FUMILI" , kFP_FUMILI);
      fMinMethodList->Select(kFP_FUMILI, kFALSE);
      fStatusBar->SetText("FUMILI",2);
   } else if ( fLibGSL->GetState() == kButtonDown ) 
   {
      fMinMethodList->AddEntry("Fletcher-Reeves conjugate gradient" , kFP_GSLFR);
      fMinMethodList->AddEntry("Polak-Ribiere conjugate gradient" ,   kFP_GSLPR);
      fMinMethodList->AddEntry("BFGS conjugate gradient" ,            kFP_BFGS);
      fMinMethodList->AddEntry("BFGS conjugate gradient (Version 2)", kFP_BFGS2);
      fMinMethodList->AddEntry("Levenberg-Marquardt" ,                kFP_GSLLM);
      fMinMethodList->AddEntry("Simulated Annealing" ,                kFP_GSLSA);
      fMinMethodList->Select(kFP_GSLFR, kFALSE);
      fStatusBar->SetText("CONJFR",2);
   } else if ( fLibGenetics->GetState() == kButtonDown ) 
   {
      if ( gPluginMgr->FindHandler("ROOT::Math::Minimizer","GAlibMin") ) {
         fMinMethodList->AddEntry("GA Lib Genetic Algorithm" , kFP_GALIB);
         fMinMethodList->Select(kFP_GALIB, kFALSE);
      } else if (gPluginMgr->FindHandler("ROOT::Math::Minimizer","Genetic")) {
         fMinMethodList->AddEntry("TMVA Genetic Algorithm" ,   kFP_TMVAGA);
         fMinMethodList->Select(kFP_TMVAGA, kFALSE);
      }
   } else // if ( fLibMinuit2->GetState() == kButtonDown )
   {
      fMinMethodList->AddEntry("MIGRAD" ,       kFP_MIGRAD);
      fMinMethodList->AddEntry("SIMPLEX" ,      kFP_SIMPLX);
      fMinMethodList->AddEntry("FUMILI" ,       kFP_FUMILI);
      fMinMethodList->AddEntry("SCAN" ,         kFP_SCAN);
      fMinMethodList->AddEntry("Combination" ,  kFP_COMBINATION);
      fMinMethodList->Select(kFP_MIGRAD, kFALSE);
      fStatusBar->SetText("MIGRAD",2);
   }
}

void SearchCanvases(TSeqCollection* canvases, vector<TObject*>& objects)
{
   // Auxiliary function to recursively search for objects inside the
   // current canvases.

   TIter canvasIter(canvases);
   // Iterate over all the canvases in canvases.
   while(TObject* obj = (TObject*) canvasIter()) {
      // If the object is another canvas, call this function
      // recursively.
      if ( TPad* can = dynamic_cast<TPad*>(obj))
         SearchCanvases(can->GetListOfPrimitives(), objects);
      // Otherwhise, if it's a recognised object, add it to the vector
      else if (    dynamic_cast<TH1*>(obj)
                || dynamic_cast<TGraph*>(obj)
                || dynamic_cast<TGraph2D*>(obj)
                || dynamic_cast<TMultiGraph*>(obj)
                || dynamic_cast<THStack*>(obj)
                || dynamic_cast<TTree*>(obj) ) {
         bool insertNew = true;
         // Be careful no to insert the same element twice.
         for ( vector<TObject*>::iterator i = objects.begin(); i != objects.end(); ++i )
            if ( (*i) == obj ) {
               insertNew = false;
               break;
            }
         // If the object is not already in the vector, then insert
         // it.
         if ( insertNew ) objects.push_back(obj);
      }
   }
}

//______________________________________________________________________________
void TFitEditor::FillDataSetList()
{
   // Create a combo box with all the possible objects to be fitted.

   // Get the title of the entry selected, so that we can select it
   // again once the fDataSet has been refilled.
   TGTextLBEntry * entry = (TGTextLBEntry*) fDataSet->GetSelectedEntry();
   TString selEntryStr;
   if ( entry ) {
      selEntryStr = entry->GetTitle();
   }

   // Remove all the elements
   fDataSet->RemoveAll();
   vector<TObject*> objects;

   // Get all the objects registered in gDirectory
   TIter next(gDirectory->GetList());
   TObject* obj = NULL;
   while ( (obj = (TObject*) next()) ) {
      // But only if they are of a type recognized by the FitPanel
      if ( dynamic_cast<TH1*>(obj) || 
           dynamic_cast<TGraph2D*>(obj) ||
           dynamic_cast<TTree*>(obj) ) {
         objects.push_back(obj);
      }
   }

   // Look for all the drawn objects. The method will take care the
   // same objects are not inserted twice.
   SearchCanvases(gROOT->GetListOfCanvases(), objects);

   // Add all the objects stored in the vector
   int selected = kFP_NOSEL;
   // Add the No selection.
   Int_t newid = kFP_NOSEL;
   fDataSet->AddEntry("No Selection", newid++);
   for ( vector<TObject*>::iterator i = objects.begin(); i != objects.end(); ++i ) {
      // Insert the name as the class name followed by the name of the
      // object.
      TString name = (*i)->ClassName(); name.Append("::"); name.Append((*i)->GetName());
      // Check whether the names are the same!
      if ( selEntryStr && name == selEntryStr )
         selected = newid;
      fDataSet->AddEntry(name, newid++);
   }

   // If there was an entry selected (which should be always the case
   // except the first time this method is executed), then make it the
   // selected one again.
   if (entry) {
      fDataSet->Select(selected);
   }
}

//______________________________________________________________________________
TGComboBox* TFitEditor::BuildMethodList(TGFrame* parent, Int_t id)
{
   // Create method list in a combo box.

   TGComboBox *c = new TGComboBox(parent, id);
   c->AddEntry("Chi-square", kFP_MCHIS);
   c->AddEntry("Binned Likelihood", kFP_MBINL);
   c->AddEntry("Unbinned Likelihood", kFP_MUBIN);
   //c->AddEntry("User", kFP_MUSER);                //for later use
   c->Select(kFP_MCHIS);
   return c;
}

//______________________________________________________________________________
void TFitEditor::DoAdvancedOptions()
{
   // Slot connected to advanced option button (opens a dialog).

   new TAdvancedGraphicsDialog( fClient->GetRoot(), GetMainFrame());
}

//______________________________________________________________________________
void TFitEditor::DoEmptyBinsAllWeights1()
{
   // Slot connected to 'include emtry bins and forse all weights to 1' setting.

   if (fEmptyBinsWghts1->GetState() == kButtonDown)
      if (fAllWeights1->GetState() == kButtonDown)
         fAllWeights1->SetState(kButtonUp, kTRUE);
}

//______________________________________________________________________________
void TFitEditor::DoUseFuncRange()
{
   
   if ( fUseRange->GetState() == kButtonDown ) {
      if (fNone->GetState() == kButtonDown || fNone->GetState() == kButtonDisabled) {
         // Get the function
         TF1* tmpTF1 = FindFunction();
         if ( !tmpTF1 ) {
            if (GetFitObjectListOfFunctions()) {
               TGTextLBEntry *te = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
               tmpTF1 = (TF1*) GetFitObjectListOfFunctions()->FindObject( te->GetTitle() );
            }
         }
         // If the function has been retrieved, i.e. is a registered function.
         if ( tmpTF1 ) {
            Double_t xmin, ymin, zmin, xmax, ymax, zmax;
            // Get the range
            tmpTF1->GetRange(xmin, ymin, zmin, xmax, ymax, zmax);
            // And set the sliders
            if ( fType != kObjectTree ) {
               fSliderXMin->SetNumber( xmin );
               fSliderXMax->SetNumber( xmax );
               DoNumericSliderXChanged();
               if ( fDim > 1 ) {
                  fSliderYMin->SetNumber( ymin );
                  fSliderYMax->SetNumber( ymax );
                  DoNumericSliderYChanged();
               }
            }
         }
      }
      fUseRange->SetState(kButtonDown);
   }
}

//______________________________________________________________________________
void TFitEditor::DoAllWeights1()
{
   // Slot connected to 'set all weights to 1' setting.

   if (fAllWeights1->GetState() == kButtonDown)
      if (fEmptyBinsWghts1->GetState() == kButtonDown)
         fEmptyBinsWghts1->SetState(kButtonUp, kTRUE);
}

//______________________________________________________________________________
void TFitEditor::DoClose()
{
   // Close the fit panel.

   Hide();
}

//______________________________________________________________________________
void TFitEditor::DoUpdate()
{
   // Easy here!
   GetFunctionsFromSystem();
   FillDataSetList();
}

//______________________________________________________________________________
void TFitEditor::DoFit()
{
   // Perform a fit with current parameters' settings.

   if (!fFitObject) return;
   //if (!fParentPad) return;

   // If fNone->GetState() == kButtonDisabled means the function is
   // not editable, i.e. it comes from a raw C function. So in this
   // case, it is editable and we have to check wheather the formula
   // is well built.
   if ( fNone->GetState() != kButtonDisabled && CheckFunctionString(fEnteredFunc->GetText()) )
   {
      // If not, then show an error message and leave.
      new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                   "Error...", "DoFit\nVerify the entered function string!",
                   kMBIconStop,kMBOk, 0);
      return;
   }

   // Set the button so that the user cannot use it while fitting, set
   // the mouse to watch type and so on.
   fFitButton->SetState(kButtonEngaged);
   if (gPad) gPad->GetVirtCanvas()->SetCursor(kWatch);
   gVirtualX->SetCursor(GetId(), gVirtualX->CreateCursor(kWatch));

   TVirtualPad *save = 0;
   if ( fParentPad ) {
      fParentPad->Disconnect("RangeAxisChanged()");
      save = gPad;
      gPad = fParentPad;
      fParentPad->cd();

      fParentPad->GetCanvas()->SetCursor(kWatch);
   }

   // Get the ranges from the sliders
   ROOT::Fit::DataRange drange; 
   GetRanges(drange);

   // Create a static pointer to fitFunc. Every second call to the
   // DoFit method, the old fitFunc is deleted. We need not to delete
   // the function after the fitting in case we want to do Advaced
   // graphics. The VirtualFitter need the function to be alived. One
   // problem, after the last fit the function is never deleted, but
   // ROOT's garbage collector will do the job for us.
   static TF1 *fitFunc = 0;
   if ( fitFunc )
      delete fitFunc;
   fitFunc = GetFitFunction();
   // This assert
   assert(fitFunc && "This should have never happend, the fitfunc pointer is NULL!"
          " Please report");
   // set parameters from panel in function
   SetParameters(fFuncPars, fitFunc);
   // Get the options stored in the GUI elements.
   ROOT::Math::MinimizerOptions mopts;
   Foption_t fitOpts;
   TString strDrawOpts;
   RetrieveOptions(fitOpts, strDrawOpts, mopts, fitFunc->GetNpar());

   // Call the fit method, depending on the object to fit.
   switch (fType) {
      case kObjectHisto: {
         
         TH1 *hist = dynamic_cast<TH1*>(fFitObject);
         if (hist)
            ROOT::Fit::FitObject(hist, fitFunc, fitOpts, mopts, strDrawOpts, drange);

         break;
      }
      case kObjectGraph: {

         TGraph *gr = dynamic_cast<TGraph*>(fFitObject);
         if (gr)
            FitObject(gr, fitFunc, fitOpts, mopts, strDrawOpts, drange);
         break;
      }
      case kObjectMultiGraph: {

         TMultiGraph *mg = dynamic_cast<TMultiGraph*>(fFitObject);
         if (mg)
            FitObject(mg, fitFunc, fitOpts, mopts, strDrawOpts, drange);

         break;
      }
      case kObjectGraph2D: {

         TGraph2D *g2d = dynamic_cast<TGraph2D*>(fFitObject);
         if (g2d)
            FitObject(g2d, fitFunc, fitOpts, mopts, strDrawOpts, drange);

         break;
      }
      case kObjectHStack: {
         // N/A
         break;
      }
      case kObjectTree:  {
         // The three is a much more special case. The steps for
         // fitting have to be done manually here until they are
         // properly implemented within a FitObject method in
         // THFitImpl.cxx

         // Retrieve the variables and cuts selected from the current
         // tree.
         TString variables;
         TString cuts;
         GetTreeVarsAndCuts(fDataSet, variables, cuts);

         // This should be straight forward and the return should
         // never be called.
         TTree *tree = dynamic_cast<TTree*>(fFitObject);
         if ( !tree ) return;

         // These method calls are just to set up everything for the
         // fitting. It's taken from another script.
         gROOT->ls();
         tree->Draw(variables,cuts,"goff candle");

         TTreePlayer * player = (TTreePlayer*) tree->GetPlayer();
         if ( !player ) {
            Error("DoFit","Player reference is NULL"); 
            return; 
         }

         TSelectorDraw * selector = (TSelectorDraw* ) player->GetSelector(); 
         if ( !selector ) {
            Error("DoFit","Selector reference is NULL"); 
            return; 
         }

         // use pointer stored in the tree (not copy the data in)
         unsigned int ndim = player->GetDimension();
         if ( ndim == 0 ) {
            Error("DoFit","NDIM == 0"); 
            return; 
         }

         std::vector<double *> vlist; 
         for (unsigned int i = 0; i < ndim; ++i) {  
            double * v =  selector->GetVal(i);
            if (v != 0) vlist.push_back(v);
            else 
               std::cerr << "pointer for variable " << i << " is zero" << std::endl;
         } 
         if (vlist.size() != ndim) { 
            Error("DoFit","Vector is not complete"); 
            return; 
         }
         
         // fill the data 
         Long64_t nrows = player->GetSelectedRows();
         if ( !nrows ) {
            Error("DoFit","NROWS == 0"); 
            return; 
         }

         ROOT::Fit::UnBinData * fitdata = new ROOT::Fit::UnBinData(nrows, ndim, vlist.begin());
         
         for ( int i = 0; i < std::min(int(fitdata->Size()),10); ++i) { 
            // print j coordinate 
            for (unsigned int j = 0; j < ndim; ++j) {  
               printf(" x_%d [%d] = %f  \n", j, i,*(fitdata->Coords(i)+j) );
            } 
            printf("\n");
         }
         
   
         //TVirtualFitter::SetDefaultFitter("Minuit");
         Foption_t fitOption; 
         ROOT::Math::MinimizerOptions minOption;
         fitOption.Verbose=1;

         // After all the set up is performed, then do the Fit!!
         ROOT::Fit::UnBinFit(fitdata, fitFunc, fitOption, minOption);
         
         break;
      }
   }

   // if SAME is set re-plot the function
   // useful in case histogram was drawn with HIST 
   //  and no function will be drawm)
   if (fDrawSame->GetState() == kButtonDown && fitFunc) 
      fitFunc->Draw("same");


   // update parameters value shown in dialog 
   //if (!fFuncPars) fFuncPars = new Double_t[fitFunc->GetNpar()][3];
   GetParameters(fFuncPars,fitFunc);

   // Save fit data for future use as a PrevFit function.
   TF1* tmpTF1 = static_cast<TF1*>( copyTF1(fitFunc) );
   ostringstream name;
   name << "PrevFit-" << fPrevFit.size() + 1;
   if ( strcmp(tmpTF1->GetName(), "PrevFitTMP") != 0 )
      name << "-" << tmpTF1->GetName();
   tmpTF1->SetName(name.str().c_str());
   fPrevFit.insert(FitFuncMap_t::value_type(fFitObject, tmpTF1));
   fSystemFuncs.push_back( copyTF1(tmpTF1) );

   float xmin, xmax, ymin, ymax, zmin, zmax;
   if ( fParentPad ) {
      fParentPad->Modified();
      // As the range is not changed, save the old values and restore
      // after the GUI has been updated.  It would be more elegant to
      // disconnect the signal from fParentPad, however, this doesn't
      // work for unknown reasons.
      if ( fType != kObjectTree ) fSliderX->GetPosition(xmin, xmax);
      if ( fDim > 1 ) fSliderY->GetPosition(ymin, ymax);
      if ( fDim > 2 ) fSliderZ->GetPosition(zmin, zmax);
      fParentPad->Update();
   }

   // In case the fit method draws something! Set the canvas!
   fParentPad = gPad;
   UpdateGUI();

   // Change the sliders if necessary.
   if ( fParentPad ) {
      if ( fType != kObjectTree ) { fSliderX->SetPosition(xmin, xmax); DoSliderXMoved(); }
      if ( fType != kObjectTree && fDim > 1 ) { fSliderY->SetPosition(ymin, ymax); DoSliderYMoved(); }
      if ( fType != kObjectTree && fDim > 2 ) { fSliderZ->SetPosition(zmin, zmax); DoSliderZMoved(); }
      fParentPad->GetCanvas()->SetCursor(kPointer);
      fParentPad->Connect("RangeAxisChanged()", "TFitEditor", this, "UpdateGUI()");
      
      if (save) gPad = save;
      if (fSetParam->GetState() == kButtonDisabled && 
          fLinearFit->GetState() == kButtonUp)
         fSetParam->SetState(kButtonUp);
   }

   // Restore the Fit button and mouse cursor to their proper state.
   if (gPad) gPad->GetVirtCanvas()->SetCursor(kPointer);
   gVirtualX->SetCursor(GetId(), gVirtualX->CreateCursor(kPointer));
   fFitButton->SetState(kButtonUp);

   if ( !fTypeFit->FindEntry("Prev. Fit") )
      fTypeFit->InsertEntry("Prev. Fit",kFP_PREVFIT, kFP_UFUNC);

   fDrawAdvanced->SetState(kButtonUp);
}

//______________________________________________________________________________
Int_t TFitEditor::CheckFunctionString(const char *fname)
{
   // Check entered function string.
   Int_t rvalue = 0;
   if ( fDim == 1 || fDim == 0 ) {
      TF1 form("tmpCheck", fname);
      rvalue = form.Compile();
   } else if ( fDim == 2 ) {
      TF2 form("tmpCheck", fname);
      rvalue = form.Compile();
   } else if ( fDim == 3 ) {
      TF3 form("tmpCheck", fname);
      rvalue = form.Compile();
   }

   return rvalue;
}

//______________________________________________________________________________
void TFitEditor::DoAddition(Bool_t on)
{
   // Slot connected to addition of predefined functions. It will
   // insert the next selected function with a plus sign so that it
   // doesn't override the current content of the formula.

   static Bool_t first = kFALSE;
   TString s = fEnteredFunc->GetText();
   if (on) {
      if (!first) {
         fSelLabel->SetText(s.Sizeof()>30?s(0,30)+"...":s);
         s += "(0)";
         fEnteredFunc->SetText(s.Data());
         first = kTRUE;
         ((TGCompositeFrame *)fSelLabel->GetParent())->Layout();
      }
   } else {
      first = kFALSE;
   }
}

//______________________________________________________________________________
void TFitEditor::DoDataSet(Int_t selected)
{
   // Selects the data set to be fitted
   if ( selected == kFP_NOSEL ) {
      DoNoSelection();
      return;
   }

   // Get the name and class of the selected object.
   TGTextLBEntry* textEntry = static_cast<TGTextLBEntry*>(fDataSet->GetListBox()->GetEntry(selected));
   TString textEntryStr = textEntry->GetText()->GetString();
   TString name = textEntry->GetText()->GetString()+textEntry->GetText()->First(':')+2;
   TString className = textEntryStr(0,textEntry->GetText()->First(':'));
   
   // Check the object exists in the ROOT session and it is registered
   TObject* objSelected(0);
   if ( className == "TTree" ) {
      // It's a tree, so the name is before the space (' ')
      TString lookStr;
      if ( name.First(' ') == kNPOS )
         lookStr = name;
      else 
         lookStr = name(0, name.First(' '));
      //cout << "\t1 SITREE: '" << lookStr << "'" << endl;
      objSelected = gROOT->FindObject(lookStr);
   } else {
      // It's not a tree, so the name is the complete string
      //cout << "\t1 NOTREE: '" << name << "'" << endl;
      objSelected = gROOT->FindObject(name);
   }
   if ( !objSelected ) 
   {
      //cerr << "Object not found! Please report the error! " << endl;
      return;
   }

   // If it is a tree, and there are no variables selected, show a dialog
   if ( objSelected->InheritsFrom("TTree") && 
        name.First(' ') == kNPOS ) {
      char variables[256] = {0}; char cuts[256] = {0};
      strcpy(variables, "Sin input!");
      new TTreeInput( fClient->GetRoot(), GetMainFrame(), variables, cuts );
      if ( strcmp ( variables, "" ) == 0 ) {
         DoNoSelection();
         return;
      }
      ProcessTreeInput(objSelected, selected, variables, cuts);
   }

   // Search the canvas where the object is drawn, if any
   TPad* currentPad = NULL;
   bool found = false;
   queue<TPad*> stPad;
   TIter padIter( gROOT->GetListOfCanvases() );
   while ( TObject* canvas = static_cast<TObject*>(padIter() ) ) {
      if ( dynamic_cast<TPad*>(canvas) )
         stPad.push(dynamic_cast<TPad*>(canvas));
   }

   while ( !stPad.empty() && !found ) {
      currentPad = stPad.front();
      stPad.pop();
      TIter elemIter( currentPad->GetListOfPrimitives() );
      while ( TObject* elem = static_cast<TObject*>(elemIter() ) ) {
         if ( elem == objSelected ) {
            found = true;
            break;
         } else if ( dynamic_cast<TPad*>(elem) )
            stPad.push( dynamic_cast<TPad*>(elem) );
      }
   }

   // Set the proper object and canvas (if found!)
   SetFitObject( found?currentPad:NULL, objSelected, kButton1Down);
}

void TFitEditor::ProcessTreeInput(TObject* objSelected, Int_t selected, TString variables, TString cuts)
{
   // If the input is valid, insert the tree with the selections as an entry to fDataSet
   TString entryName = (objSelected)->ClassName(); entryName.Append("::"); entryName.Append((objSelected)->GetName());
   entryName.Append(" (\""); entryName.Append(variables); entryName.Append("\", \"");
   entryName.Append(cuts); entryName.Append("\")");
   Int_t newid = fDataSet->GetNumberOfEntries() + kFP_NOSEL;
   fDataSet->InsertEntry(entryName, newid, selected );
   fDataSet->Select(newid);
}

//______________________________________________________________________________
void TFitEditor::DoFunction(Int_t selected)
{
   // Slot connected to predefined fit function settings.

   TGTextLBEntry *te = (TGTextLBEntry *)fFuncList->GetSelectedEntry();
   bool editable = false;
   if (fNone->GetState() == kButtonDown || fNone->GetState() == kButtonDisabled) {
      // Get the function selected and check weather it is a raw C
      // function or not
      TF1* tmpTF1 = FindFunction();
      if ( !tmpTF1 ) {
         if (GetFitObjectListOfFunctions())
            tmpTF1 = (TF1*) GetFitObjectListOfFunctions()->FindObject( te->GetTitle() );
      }
      if ( tmpTF1 && strcmp(tmpTF1->GetExpFormula(), "") ) 
      {
         editable = kTRUE;
         fEnteredFunc->SetText(tmpTF1->GetExpFormula());
      }
      else
      {
         if ( selected <= kFP_USER )
            editable = kTRUE;
         else
            editable = kFALSE;
         fEnteredFunc->SetText(te->GetTitle());
      }
      // Once you have the function, set the editable.
      SetEditable(editable);
   } else if (fAdd->GetState() == kButtonDown) {
      // If the add button is down don't replace the fEnteredFunc text
      Int_t np = 0;
      TString s = "";
      if (!strcmp(fEnteredFunc->GetText(), "")) {
         fEnteredFunc->SetText(te->GetTitle());
      } else {
         s = fEnteredFunc->GetTitle();
         TFormula tmp("tmp", fEnteredFunc->GetText());
         np = tmp.GetNpar();
      }
      if (np)
         s += TString::Format("+%s(%d)", te->GetTitle(), np);
      else
         s += TString::Format("%s(%d)", te->GetTitle(), np);
      fEnteredFunc->SetText(s.Data());
      editable = true;
   }

   // Get the final name in fEnteredFunc to process the function that
   // it would create
   TString tmpStr = fEnteredFunc->GetText();

   // create TF1 with the passed string. Delete previous one if existing
   if (tmpStr.Contains("pol") || tmpStr.Contains("++")) {
      fLinearFit->SetState(kButtonDown, kTRUE);
   } else {
      fLinearFit->SetState(kButtonUp, kTRUE);
   }

   fEnteredFunc->SelectAll();
   fSelLabel->SetText(tmpStr.Sizeof()>30?tmpStr(0,30)+"...":tmpStr);
   ((TGCompositeFrame *)fSelLabel->GetParent())->Layout();

   // reset function parameters if the number of parameters of the new
   // function is different from the old one!
   TF1* fitFunc = GetFitFunction();

   if ( fitFunc && (unsigned int) fitFunc->GetNpar() != fFuncPars.size() )
      fFuncPars.clear();
   if ( fitFunc ) delete fitFunc;
}

//______________________________________________________________________________
void TFitEditor::DoEnteredFunction()
{
   // Slot connected to entered function in text entry.

   if (!strcmp(fEnteredFunc->GetText(), "")) return;
   
   // Check if the function is well built
   Int_t ok = CheckFunctionString(fEnteredFunc->GetText());

   if (ok != 0) {
      new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                   "Error...", "DoEnteredFunction\nVerify the entered function string!",
                   kMBIconStop,kMBOk, 0);
      return;
   }

   // And set the label with the entered text if everything is fine.
   TString s = fEnteredFunc->GetText();
   fSelLabel->SetText(s.Sizeof()>30?s(0,30)+"...":s);
   ((TGCompositeFrame *)fSelLabel->GetParent())->Layout();
}

//______________________________________________________________________________
void TFitEditor::DoLinearFit()
{
   // Slot connected to linear fit settings.

   if (fLinearFit->GetState() == kButtonDown) {
      //fSetParam->SetState(kButtonDisabled);
      fBestErrors->SetState(kButtonDisabled);
      fImproveResults->SetState(kButtonDisabled);
      fRobustValue->SetState(kTRUE);
   } else {
      //fSetParam->SetState(kButtonUp);
      fBestErrors->SetState(kButtonUp);
      fImproveResults->SetState(kButtonUp);
      fRobustValue->SetState(kFALSE);
   }
}

//______________________________________________________________________________
void TFitEditor::DoNoChi2()
{
   // Slot connected to 'no chi2' option settings.

   if (fLinearFit->GetState() == kButtonUp)
      fLinearFit->SetState(kButtonDown, kTRUE);
}

//______________________________________________________________________________
void TFitEditor::DoNoStoreDrawing()
{
   // Slot connected to 'no storing, no drawing' settings.
   if (fNoDrawing->GetState() == kButtonUp)
      fNoDrawing->SetState(kButtonDown);
}

//______________________________________________________________________________
void TFitEditor::DoPrintOpt(Bool_t on)
{
   // Slot connected to print option settings.

   // Change the states of the buttons depending of which one is
   // selected.
   TGButton *btn = (TGButton *) gTQSender;
   Int_t id = btn->WidgetId();
   switch (id) {
      case kFP_PDEF:
         if (on) {
            fOptDefault->SetState(kButtonDown);
            fOptVerbose->SetState(kButtonUp);
            fOptQuiet->SetState(kButtonUp);
         }
         fStatusBar->SetText("Prn: DEF",4);
         break;
      case kFP_PVER:
         if (on) {
            fOptVerbose->SetState(kButtonDown);
            fOptDefault->SetState(kButtonUp);
            fOptQuiet->SetState(kButtonUp);
         }
         fStatusBar->SetText("Prn: VER",4);
         break;
      case kFP_PQET:
         if (on) {
            fOptQuiet->SetState(kButtonDown);
            fOptDefault->SetState(kButtonUp);
            fOptVerbose->SetState(kButtonUp);
         }
         fStatusBar->SetText("Prn: QT",4);
      default:
         break;
   }
}

//______________________________________________________________________________
void TFitEditor::DoReset()
{
   // Reset all fit parameters.

   if ( fParentPad ) {
      fParentPad->Modified();
      fParentPad->Update();
   }
   fEnteredFunc->SetText("gaus");

   // To restore temporary points and sliders
   UpdateGUI();

   if (fLinearFit->GetState() == kButtonDown)
      fLinearFit->SetState(kButtonUp, kTRUE);
   if (fBestErrors->GetState() == kButtonDown)
      fBestErrors->SetState(kButtonUp, kFALSE);
   if (fUseRange->GetState() == kButtonDown)
      fUseRange->SetState(kButtonUp, kFALSE);
   if (fAllWeights1->GetState() == kButtonDown)
      fAllWeights1->SetState(kButtonUp, kFALSE);
   if (fEmptyBinsWghts1->GetState() == kButtonDown)
      fEmptyBinsWghts1->SetState(kButtonUp, kFALSE);
   if (fImproveResults->GetState() == kButtonDown)
      fImproveResults->SetState(kButtonUp, kFALSE);
   if (fAdd2FuncList->GetState() == kButtonDown)
      fAdd2FuncList->SetState(kButtonUp, kFALSE);
   if (fUseGradient->GetState() == kButtonDown)
      fUseGradient->SetState(kButtonUp, kFALSE);
   if (fNoChi2->GetState() == kButtonDown)
      fNoChi2->SetState(kButtonUp, kFALSE);
   if (fDrawSame->GetState() == kButtonDown)
      fDrawSame->SetState(kButtonUp, kFALSE);
   if (fNoDrawing->GetState() == kButtonDown)
      fNoDrawing->SetState(kButtonUp, kFALSE);
   if (fNoStoreDrawing->GetState() == kButtonDown)
      fNoStoreDrawing->SetState(kButtonUp, kFALSE);
   fNone->SetState(kButtonDown, kTRUE);
   fFuncList->Select(1, kTRUE);

   // minimization tab
   if (fLibMinuit->GetState() != kButtonDown)
      fLibMinuit->SetState(kButtonDown, kTRUE);
   FillMinMethodList();
   if (fOptDefault->GetState() != kButtonDown)
      fOptDefault->SetState(kButtonDown, kTRUE);
   if (fErrorScale->GetNumber() != ROOT::Math::MinimizerOptions::DefaultErrorDef()) {
      fErrorScale->SetNumber(ROOT::Math::MinimizerOptions::DefaultErrorDef());
      fErrorScale->ReturnPressed();
   }   
   if (fTolerance->GetNumber() != ROOT::Math::MinimizerOptions::DefaultTolerance()) {
      fTolerance->SetNumber(ROOT::Math::MinimizerOptions::DefaultTolerance());
      fTolerance->ReturnPressed();
   }
   if (fIterations->GetNumber() != ROOT::Math::MinimizerOptions::DefaultMaxIterations()) {
      fIterations->SetIntNumber(ROOT::Math::MinimizerOptions::DefaultMaxIterations());
      fIterations->ReturnPressed();
   }
}

//______________________________________________________________________________
void TFitEditor::DoSetParameters()
{
   // Open set parameters dialog.

   // Get the function.
   TF1* fitFunc = GetFitFunction();

   if (!fitFunc) { Error("DoSetParameters","NUll function"); return; }

   // case of special functions (gaus, expo, etc...) if the function
   // has not defined the parameters yet. For those, don't let the
   // parameters to be all equal to 0, as we can provide some good
   // starting value.
   if (fFuncPars.size() == 0) { 
      switch (fType) {
      case kObjectHisto:
         InitParameters( fitFunc, (TH1*)fFitObject) ;
         break;
      case kObjectGraph:
         InitParameters( fitFunc, ((TGraph*)fFitObject));
         break;
      case kObjectMultiGraph:
         InitParameters( fitFunc, ((TMultiGraph*)fFitObject));
         break;
      case kObjectGraph2D:
         InitParameters( fitFunc, ((TGraph2D*)fFitObject));
         break;
      case kObjectHStack: 
      case kObjectTree:  
      default:
         break;
      }
      // The put these parameters into the fFuncPars structure
      GetParameters(fFuncPars, fitFunc);
   }                            
   else {
      // Otherwise, put the parameters in the function
      SetParameters(fFuncPars, fitFunc);
   }

   if ( fParentPad ) fParentPad->Disconnect("RangeAxisChanged()");
   Int_t ret = 0;
   new TFitParametersDialog(gClient->GetDefaultRoot(), GetMainFrame(), 
                            fitFunc, fParentPad, &ret);
   
   // Once the parameters are set in the fitfunction, save them.
   GetParameters(fFuncPars, fitFunc);
   
   if ( fParentPad ) fParentPad->Connect("RangeAxisChanged()", "TFitEditor", this, "UpdateGUI()");

   if ( fNone->GetState() != kButtonDisabled ) delete fitFunc;
}

//______________________________________________________________________________
void TFitEditor::DoSliderXMoved()
{
   // Slot connected to range settings on x-axis.

   if ( !fFitObject ) return;
   
   fSliderXMin->SetNumber( fXaxis->GetBinLowEdge( static_cast<Int_t>( fSliderX->GetMinPosition() ) ) );
   fSliderXMax->SetNumber( fXaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderX->GetMaxPosition() ) ) );

   fUseRange->SetState(kButtonUp);

   DrawSelection();
}

//______________________________________________________________________________
void TFitEditor::DrawSelection(bool restore)
{
   // Draws the square around the object showing where the limits for
   // fitting are.

   static Int_t  px1old, py1old, px2old, py2old; // to remember the square drawn.

   if ( !fParentPad ) return;

   if (restore) {
      px1old = fParentPad->XtoAbsPixel(fParentPad->GetUxmin());
      py1old = fParentPad->YtoAbsPixel(fParentPad->GetUymin());
      px2old = fParentPad->XtoAbsPixel(fParentPad->GetUxmax());
      py2old = fParentPad->YtoAbsPixel(fParentPad->GetUymax());
      return;
   }

   Int_t px1,py1,px2,py2;

   TVirtualPad *save = 0;
   save = gPad;
   gPad = fParentPad;
   gPad->cd();

   Double_t xleft = 0;
   Double_t xright = 0;
   xleft  = fXaxis->GetBinLowEdge((Int_t)((fSliderX->GetMinPosition())+0.5));
   xright = fXaxis->GetBinUpEdge((Int_t)((fSliderX->GetMaxPosition())+0.5));

   Float_t ymin, ymax;
   if ( fDim > 1 )
   {
      ymin = fYaxis->GetBinLowEdge((Int_t)((fSliderY->GetMinPosition())+0.5));//gPad->GetUymin();
      ymax = fYaxis->GetBinUpEdge((Int_t)((fSliderY->GetMaxPosition())+0.5));//gPad->GetUymax();
   }
   else 
   {
      ymin = gPad->GetUymin();
      ymax = gPad->GetUymax();
   }

   px1 = gPad->XtoAbsPixel(xleft);
   py1 = gPad->YtoAbsPixel(ymin);
   px2 = gPad->XtoAbsPixel(xright);
   py2 = gPad->YtoAbsPixel(ymax);

   gPad->GetCanvas()->FeedbackMode(kTRUE);
   gPad->SetLineWidth(1);
   gPad->SetLineColor(2);
   
   gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
   gVirtualX->DrawBox(px1, py1, px2, py2, TVirtualX::kHollow);

   px1old = px1;
   py1old = py1;
   px2old = px2 ;
   py2old = py2;

   if(save) gPad = save;
}

//______________________________________________________________________________
void TFitEditor::DoNumericSliderXChanged()
{
   // Sincronize the numeric sliders with the graphical one.
   if ( fSliderXMin->GetNumber() > fSliderXMax->GetNumber() ) {
      float xmin, xmax;
      fSliderX->GetPosition(xmin, xmax);
      fSliderXMin->SetNumber( fXaxis->GetBinLowEdge( static_cast<Int_t>( xmin ) ) );
      fSliderXMax->SetNumber( fXaxis->GetBinUpEdge ( static_cast<Int_t>( xmax ) ) );
      return;
   }

   fSliderX->SetPosition(fXaxis->FindBin( fSliderXMin->GetNumber() ),
                         fXaxis->FindBin( fSliderXMax->GetNumber() ));

   fUseRange->SetState(kButtonUp);

   DrawSelection();
}

//______________________________________________________________________________
void TFitEditor::DoSliderYMoved()
{
   // Slot connected to range settings on y-axis.

   if ( !fFitObject ) return;

   fSliderYMin->SetNumber( fYaxis->GetBinLowEdge( static_cast<Int_t>( fSliderY->GetMinPosition() ) ) );
   fSliderYMax->SetNumber( fYaxis->GetBinUpEdge ( static_cast<Int_t>( fSliderY->GetMaxPosition() ) ) );
   
   fUseRange->SetState(kButtonUp);

   DrawSelection();
}

//______________________________________________________________________________
void TFitEditor::DoNumericSliderYChanged()
{
   //syncronize the numeric slider with the graphical one.
   if ( fSliderYMin->GetNumber() > fSliderYMax->GetNumber() ) {
      float ymin, ymax;
      fSliderY->GetPosition(ymin, ymax);
      fSliderYMin->SetNumber( fYaxis->GetBinLowEdge( static_cast<Int_t>( ymin ) ) );
      fSliderYMax->SetNumber( fYaxis->GetBinUpEdge ( static_cast<Int_t>( ymax ) ) );
      return;
   }

   fSliderY->SetPosition( fYaxis->FindBin( fSliderYMin->GetNumber() ),
                          fYaxis->FindBin( fSliderYMax->GetNumber() ));

   fUseRange->SetState(kButtonUp);

   DrawSelection();
}

//______________________________________________________________________________
void TFitEditor::DoSliderZMoved()
{
   // Slot connected to range settings on z-axis.

}

//______________________________________________________________________________
void TFitEditor::DoUserDialog()
{
   // Open a dialog for getting a user defined method.

   new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                "Info", "Dialog of user method is not implemented yet",
                kMBIconAsterisk,kMBOk, 0);
}

//______________________________________________________________________________
void TFitEditor::SetFunction(const char *function)
{
   // Set the function to be used in performed fit.

   fEnteredFunc->SetText(function);
}

//______________________________________________________________________________
Bool_t TFitEditor::SetObjectType(TObject* obj)
{
   // Check whether the object suitable for fitting and set 
   // its type, dimension and method combo box accordingly.
   
   Bool_t set = kFALSE;

   // For each kind of object, set a different status in the fit
   // panel.
   if (obj->InheritsFrom("TGraph")) {
      fType = kObjectGraph;
      set = kTRUE;
      fDim = 1;
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Chi-square", kFP_MCHIS);
      fMethodList->Select(kFP_MCHIS, kFALSE);
      fRobustValue->SetState(kTRUE);
      fRobustValue->GetNumberEntry()->SetToolTipText("Set robust value");
   } else if (obj->InheritsFrom("TGraph2D")) {
      fType = kObjectGraph2D;
      set = kTRUE;
      fDim = 2;
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Chi-square", kFP_MCHIS);
      fMethodList->Select(kFP_MCHIS, kFALSE);
   } else if (obj->InheritsFrom("THStack")) {
      fType = kObjectHStack;
      set = kTRUE;
      TH1 *hist = (TH1 *)((THStack *)obj)->GetHists()->First();
      fDim = hist->GetDimension();
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Chi-square", kFP_MCHIS);
      fMethodList->Select(kFP_MCHIS, kFALSE);
   } else if (obj->InheritsFrom("TTree")) {
      fType = kObjectTree;
      set = kTRUE;
      TString variables, cuts;
      GetTreeVarsAndCuts(fDataSet, variables, cuts);
      fDim = 1;
      for ( int i = 0; i < variables.Length() && fDim <= 2; ++i )
         if ( ':' == variables[i] ) fDim += 1;
      // For any three  of dimension bigger than 2,  set the dimension
      // to 0,  as we cannot infer  the dimension from  the TF1s, it's
      // better to have 0 as reference.
      if ( fDim > 2 ) fDim = 0;
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Unbinned Likelihood", kFP_MUBIN);
      fMethodList->Select(kFP_MUBIN, kFALSE);      
   } else if (obj->InheritsFrom("TH1")){
      fType = kObjectHisto;
      set = kTRUE;
      fDim = ((TH1*)obj)->GetDimension();
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Chi-square", kFP_MCHIS);
      fMethodList->AddEntry("Binned Likelihood", kFP_MBINL);
      fMethodList->Select(kFP_MCHIS, kFALSE);
   } else if (obj->InheritsFrom("TMultiGraph")) {
      fType = kObjectMultiGraph;
      set = kTRUE;
      fDim = 1;
      fMethodList->RemoveAll();
      fMethodList->AddEntry("Chi-square", kFP_MCHIS);
      fMethodList->Select(kFP_MCHIS, kFALSE);
      fRobustValue->SetState(kTRUE);
      fRobustValue->GetNumberEntry()->SetToolTipText("Set robust value");
   }

   // Depending on the dimension of the object, allow the
   // visualization of sliders.
   if ( fDim < 2 || fType == kObjectTree )
      fGeneral->HideFrame(fSliderYParent);
   else
      fGeneral->ShowFrame(fSliderYParent);

   if ( fDim < 1 || fType == kObjectTree )
      fGeneral->HideFrame(fSliderXParent);
   else
      fGeneral->ShowFrame(fSliderXParent);

   // And also, depending on the dimension, add predefined functions.
   if ( fDim == 1 ) {
      if ( !fTypeFit->FindEntry("Predef-1D") ) 
         fTypeFit->InsertEntry("Predef-1D", kFP_PRED1D, kFP_PREVFIT);
   } else {
      if ( fTypeFit->FindEntry("Predef-1D") )
         fTypeFit->RemoveEntry(kFP_PRED1D);
   }

   if ( fDim == 2 ) {
      if ( !fTypeFit->FindEntry("Predef-2D") ) 
         fTypeFit->InsertEntry("Predef-2D", kFP_PRED2D, kFP_PREVFIT);
   } else {
      if ( fTypeFit->FindEntry("Predef-2D") )
         fTypeFit->RemoveEntry(kFP_PRED2D);
   }

   return set;
}

//______________________________________________________________________________
void TFitEditor::ShowObjectName(TObject* obj)
{
   // Show object name on the top.

   TString name;
   bool isTree = false;
   
   // Build the string to be compared to look for the object.
   if (obj) {
      name = obj->ClassName();
      name.Append("::");
      name.Append(obj->GetName());
      isTree = strcmp(obj->ClassName(), "TTree") == 0;
   } else {
      name = "No object selected";
   }
   fStatusBar->SetText(name.Data(),0);

   // If the selection was done in the fDataSet combo box, there is no need
   // to search through the list
   TGTextLBEntry* selectedEntry = static_cast<TGTextLBEntry*> ( fDataSet->GetSelectedEntry());
   if ( selectedEntry ) {
      TString selectedName = selectedEntry->GetText()->GetString();
      if ( isTree )
         selectedName = selectedName(0, selectedName.First(' '));
      if ( name.CompareTo(selectedName) == 0 ) {
         Layout();
         return;
      }
   }

   // Search through the list for the object
   Int_t entryId = kFP_NOSEL+1;
   bool found = false;
   while ( TGTextLBEntry* entry = static_cast<TGTextLBEntry*> 
           ( fDataSet->GetListBox()->GetEntry(entryId)) ) {
      TString compareName = entry->GetText()->GetString();
      if ( isTree ) 
         compareName = compareName(0, compareName.First(' '));
      if ( name.CompareTo(compareName) == 0 ) {
         // If the object is found, select it
         fDataSet->Select(entryId, false);
         found = true;
         break;
      }
      entryId += 1;
   }

   // If the object was not found, add it and select it.
   if ( !found ) {
      fDataSet->AddEntry(name.Data(), entryId);
      fDataSet->Select(entryId, kTRUE);
   }
   
   Layout();
}

//______________________________________________________________________________
Option_t *TFitEditor::GetDrawOption() const
{
   // Get draw options of the selected object.

   if (!fParentPad) return "";

   TListIter next(fParentPad->GetListOfPrimitives());
   TObject *obj;
   while ((obj = next())) {
      if (obj == fFitObject) return next.GetOption();
   }
   return "";
}

//______________________________________________________________________________
void TFitEditor::DoLibrary(Bool_t on)
{
   // Set selected minimization library in use.

   TGButton *bt = (TGButton *)gTQSender;
   Int_t id = bt->WidgetId(); 

   switch (id) {

      // Depending on the selected library, set the state of the rest
      // of the buttons.
      case kFP_LMIN:
         {
            if (on) {
               fLibMinuit->SetState(kButtonDown);
               fLibMinuit2->SetState(kButtonUp);
               fLibFumili->SetState(kButtonUp);
               if ( fLibGSL->GetState() != kButtonDisabled )
                  fLibGSL->SetState(kButtonUp);
               if ( fLibGenetics->GetState() != kButtonDisabled )
               fLibGenetics->SetState(kButtonUp);
               fStatusBar->SetText("LIB Minuit", 1);
            }
            
         }
         break;
      
      case kFP_LMIN2:
         {
            if (on) {
               fLibMinuit->SetState(kButtonUp);
               fLibMinuit2->SetState(kButtonDown);
               fLibFumili->SetState(kButtonUp);
               if ( fLibGSL->GetState() != kButtonDisabled )
                  fLibGSL->SetState(kButtonUp);
               if ( fLibGenetics->GetState() != kButtonDisabled )
                  fLibGenetics->SetState(kButtonUp);
               fStatusBar->SetText("LIB Minuit2", 1);
            }
         }
         break;
      
      case kFP_LFUM:
         {
            if (on) {
               fLibMinuit->SetState(kButtonUp);
               fLibMinuit2->SetState(kButtonUp);
               fLibFumili->SetState(kButtonDown);
               if ( fLibGSL->GetState() != kButtonDisabled )
                  fLibGSL->SetState(kButtonUp);
               if ( fLibGenetics->GetState() != kButtonDisabled )
                  fLibGenetics->SetState(kButtonUp);
               fStatusBar->SetText("LIB Fumili", 1);
            }
         }
         break;
      case kFP_LGSL:
         {
            if (on) {
               fLibMinuit->SetState(kButtonUp);
               fLibMinuit2->SetState(kButtonUp);
               fLibFumili->SetState(kButtonUp);
               if ( fLibGSL->GetState() != kButtonDisabled )
                  fLibGSL->SetState(kButtonDown);
               if ( fLibGenetics->GetState() != kButtonDisabled )
                  fLibGenetics->SetState(kButtonUp);
               fStatusBar->SetText("LIB GSL", 1);
            }
         }
         break;
      case kFP_LGAS:
      {
         if (on) {
            fLibMinuit->SetState(kButtonUp);
            fLibMinuit2->SetState(kButtonUp);
            fLibFumili->SetState(kButtonUp);
            if ( fLibGSL->GetState() != kButtonDisabled )
               fLibGSL->SetState(kButtonUp);
            if ( fLibGenetics->GetState() != kButtonDisabled )
               fLibGenetics->SetState(kButtonDown);
            fStatusBar->SetText("LIB Genetics", 1);
         }
      }
      default:
         break;
   }
   FillMinMethodList();
}

//______________________________________________________________________________
void TFitEditor::DoMinMethod(Int_t )
{
   // Set selected minimization method in use.

   if ( fMinMethodList->GetSelected() == kFP_MIGRAD )
      fStatusBar->SetText("MIGRAD",2);
   else if ( fMinMethodList->GetSelected() == kFP_FUMILI)
      fStatusBar->SetText("FUMILI",2);
   else if ( fMinMethodList->GetSelected() == kFP_SIMPLX )
      fStatusBar->SetText("SIMPLEX",2);
   else if ( fMinMethodList->GetSelected() == kFP_SCAN )
      fStatusBar->SetText("SCAN",2);
   else if ( fMinMethodList->GetSelected() == kFP_COMBINATION )
      fStatusBar->SetText("Combination",2);
   else if ( fMinMethodList->GetSelected() == kFP_GSLFR )
      fStatusBar->SetText("CONJFR",2);
   else if ( fMinMethodList->GetSelected() == kFP_GSLPR )
      fStatusBar->SetText("CONJPR",2);
   else if ( fMinMethodList->GetSelected() == kFP_BFGS )
      fStatusBar->SetText("BFGS",2);
   else if ( fMinMethodList->GetSelected() == kFP_BFGS2 )
      fStatusBar->SetText("BFGS2",2);
   else if ( fMinMethodList->GetSelected() == kFP_GSLLM )
      fStatusBar->SetText("GSLLM",2);
   else if ( fMinMethodList->GetSelected() == kFP_GSLSA)
      fStatusBar->SetText("SimAn",2);
   else if ( fMinMethodList->GetSelected() == kFP_TMVAGA )
      fStatusBar->SetText("TMVAGA",2);
   else if ( fMinMethodList->GetSelected() == kFP_GALIB )
      fStatusBar->SetText("GALIB",2);


}

//______________________________________________________________________________
void TFitEditor::DoMaxIterations()
{
   // Set the maximum number of iterations.

   Long_t itr = fIterations->GetIntNumber();
   fStatusBar->SetText(Form("Itr: %ld",itr),2);
}

//______________________________________________________________________________
void TFitEditor::MakeTitle(TGCompositeFrame *parent, const char *title)
{
   // Create section title in the GUI.

   TGCompositeFrame *ht = new TGCompositeFrame(parent, 350, 10, 
                                               kFixedWidth | kHorizontalFrame);
   ht->AddFrame(new TGLabel(ht, title),
                new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
   ht->AddFrame(new TGHorizontal3DLine(ht),
                new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 5, 5, 2, 2));
   parent->AddFrame(ht, new TGLayoutHints(kLHintsTop, 5, 0, 5, 0));
}

//______________________________________________________________________________
TF1* TFitEditor::HasFitFunction()
{
   // Look in the list of function for TF1. If a TF1 is
   // found in the list of functions, it will be returned
   
   // Get the list of functions of the fit object
   TList *lf = GetFitObjectListOfFunctions();

   // If it exists
   if ( lf ) {
      // Add the posibility to select previous fit function
      if ( !fTypeFit->FindEntry("Prev. Fit") )
         fTypeFit->InsertEntry("Prev. Fit",kFP_PREVFIT, kFP_UFUNC);

      // Then add all these functions to the fPrefFit structure.
      TObject *obj2;
      TIter next(lf, kIterBackward);
      // Go over all the elements in lf
      while ((obj2 = next())) {
         if (obj2->InheritsFrom(TF1::Class())) {
            TF1* func = (TF1 *)obj2;
            fPrevFitIter it;
            // No go over all elements in fPrevFit
            for ( it = fPrevFit.begin(); it != fPrevFit.end(); ++it) {
               // To see wheather the object corresponds with fFitObject
               if ( it->first != fFitObject ) continue;
               // And if so, whether the function is already included
               if ( strcmp( func->GetName(), it->second->GetName() ) == 0 )
                  break;
               if ( strcmp( func->GetName(), "PrevFitTMP" ) == 0 )
                  break;
            }
            // Only if the function is not already in fPrevFit, the
            // breaks in the loops would make it to be different to
            // fPrevFit.end() if the function is already stored
            if ( it == fPrevFit.end() ) {
               fPrevFit.insert( FitFuncMap_t::value_type( fFitObject, static_cast<TF1*>( copyTF1( func ) ) ) );
            }
         }
      }

      // Select the PrevFit set
      fTypeFit->Select(kFP_PREVFIT);
      // And fill the function list
      FillFunctionList();
      fDrawAdvanced->SetState(kButtonUp);

   } else {
      // If there is no prev fit functions.
      fTypeFit->Select(kFP_UFUNC);
      // Call FillFunctionList as it might happen that the user is
      // changing from a TTree to another one, and thus the fFuncList
      // if not properly filled
      FillFunctionList();
   }

   fDrawAdvanced->SetState(kButtonDisabled);
   return 0;
}

//______________________________________________________________________________
void TFitEditor::RetrieveOptions(Foption_t& fitOpts, TString& drawOpts, ROOT::Math::MinimizerOptions& minOpts, Int_t npar)
{
   // Retrieve the fitting options from all the widgets.

   drawOpts = "";

   fitOpts.Range    = (fUseRange->GetState() == kButtonDown);
   fitOpts.Integral = (fIntegral->GetState() == kButtonDown);
   fitOpts.More     = (fImproveResults->GetState() == kButtonDown);
   fitOpts.Errors   = (fBestErrors->GetState() == kButtonDown);
   fitOpts.Like = (fMethodList->GetSelected() != kFP_MCHIS);

   if (fEmptyBinsWghts1->GetState() == kButtonDown)
      fitOpts.W1 = 2;
   else if (fAllWeights1->GetState() == kButtonDown)
      fitOpts.W1 = 1;

   TString tmpStr = fEnteredFunc->GetText();
   if ( !(fLinearFit->GetState() == kButtonDown) &&
        (tmpStr.Contains("pol") || tmpStr.Contains("++")) )
      fitOpts.Minuit = 1;

   if ( (int) fFuncPars.size() == npar )
      for ( Int_t i = 0; i < npar; ++i )
         if ( fFuncPars[i][PAR_MIN] != fFuncPars[i][PAR_MAX] )
         {
            fitOpts.Bound = 1;
            break;
         }
   
   fitOpts.Nochisq  = (fNoChi2->GetState() == kButtonDown);
   fitOpts.Nostore  = (fNoStoreDrawing->GetState() == kButtonDown);
   fitOpts.Nograph  = (fNoDrawing->GetState() == kButtonDown);
   fitOpts.Plus     = (fAdd2FuncList->GetState() == kButtonDown);
   fitOpts.Gradient = (fUseGradient->GetState() == kButtonDown);
   fitOpts.Quiet    = ( fOptQuiet->GetState() == kButtonDown );
   fitOpts.Verbose  = ( fOptVerbose->GetState() == kButtonDown );

   if ( !(fType != kObjectGraph) && (fLinearFit->GetState() == kButtonDown) )
   {
      fitOpts.Robust = 1;
      fitOpts.hRobust = fRobustValue->GetNumber();
   }

   drawOpts = GetDrawOption();

   if ( fLibMinuit->GetState() == kButtonDown )
      minOpts.SetMinimizerType ( "Minuit");
   else if ( fLibMinuit2->GetState() == kButtonDown)
      minOpts.SetMinimizerType ( "Minuit2" );
   else if ( fLibFumili->GetState() == kButtonDown )
      minOpts.SetMinimizerType ("Fumili" );
   else if ( fLibGSL->GetState() == kButtonDown )
      minOpts.SetMinimizerType ("GSLMultiMin" );

   if ( fMinMethodList->GetSelected() == kFP_MIGRAD )
      minOpts.SetMinimizerAlgorithm( "Migrad" );
   else if ( fMinMethodList->GetSelected() == kFP_FUMILI)
      if ( fLibMinuit2->GetState() == kButtonDown )
         minOpts.SetMinimizerAlgorithm( "Fumili2" );
      else 
         minOpts.SetMinimizerAlgorithm( "Fumili" );
   else if ( fMinMethodList->GetSelected() == kFP_SIMPLX )
      minOpts.SetMinimizerAlgorithm( "Simplex" );
   else if ( fMinMethodList->GetSelected() == kFP_SCAN )
      minOpts.SetMinimizerAlgorithm( "Scan" );
   else if ( fMinMethodList->GetSelected() == kFP_COMBINATION )
      minOpts.SetMinimizerAlgorithm( "Minimize" );
   else if ( fMinMethodList->GetSelected() == kFP_GSLFR )
      minOpts.SetMinimizerAlgorithm( "conjugatefr" );
   else if ( fMinMethodList->GetSelected() == kFP_GSLPR )
      minOpts.SetMinimizerAlgorithm( "conjugatepr" );
   else if ( fMinMethodList->GetSelected() == kFP_BFGS )
      minOpts.SetMinimizerAlgorithm( "bfgs" );
   else if ( fMinMethodList->GetSelected() == kFP_BFGS2 )
      minOpts.SetMinimizerAlgorithm( "bfgs2" );
   else if ( fMinMethodList->GetSelected() == kFP_GSLLM ) {
      minOpts.SetMinimizerType ("GSLMultiFit" );
      minOpts.SetMinimizerAlgorithm( "" );
   } else if ( fMinMethodList->GetSelected() == kFP_GSLSA) {
      minOpts.SetMinimizerType ("GSLSimAn" );
      minOpts.SetMinimizerAlgorithm( "" );
   } else if ( fMinMethodList->GetSelected() == kFP_TMVAGA) {
      minOpts.SetMinimizerType ("Geneti2c" );
      minOpts.SetMinimizerAlgorithm( "" );
   } else if ( fMinMethodList->GetSelected() == kFP_GALIB) {
      minOpts.SetMinimizerType ("GAlibMin" );
      minOpts.SetMinimizerAlgorithm( "" );
   }

   minOpts.SetErrorDef ( fErrorScale->GetNumber() );
   minOpts.SetTolerance( fTolerance->GetNumber() );
   minOpts.SetMaxIterations(fIterations->GetIntNumber());
   minOpts.SetMaxFunctionCalls(fIterations->GetIntNumber());
}

void TFitEditor::SetEditable(Bool_t state)
{
   // Set the state of some input widgets depending on whether the fit
   // function can be defined by text or if it is an existing one.
   if ( state )
   {
      fEnteredFunc->SetState(kTRUE);
      fAdd->SetState(kButtonUp, kFALSE);
      // fNone::State is the one used as reference
      fNone->SetState(kButtonDown, kFALSE);
   } else {
      fEnteredFunc->SetState(kFALSE);
      fAdd->SetState(kButtonDisabled, kFALSE);
      fNone->SetState(kButtonDisabled, kFALSE);
   }
}

void TFitEditor::GetRanges(ROOT::Fit::DataRange& drange)
{
   // Return the ranges selected by the sliders.
   
   // It's not working for trees as they don't have TAxis.
   if ( fType == kObjectTree ) return;

   if ( fType != kObjectTree ) {
      Int_t ixmin = (Int_t)(fSliderX->GetMinPosition()); 
      Int_t ixmax = (Int_t)(fSliderX->GetMaxPosition()); 
      Double_t xmin = fXaxis->GetBinLowEdge(ixmin);
      Double_t xmax = fXaxis->GetBinUpEdge(ixmax);
      drange.AddRange(0,xmin, xmax);
   }

   if ( fDim > 1 ) {
      assert(fYaxis); 
      Int_t iymin = (Int_t)(fSliderY->GetMinPosition()); 
      Int_t iymax = (Int_t)(fSliderY->GetMaxPosition()); 
      Double_t ymin = fYaxis->GetBinLowEdge(iymin);
      Double_t ymax = fYaxis->GetBinUpEdge(iymax);
      drange.AddRange(1,ymin, ymax);
   }
   if ( fDim > 2 ) {
      assert(fZaxis); 
      Int_t izmin = (Int_t)(fSliderZ->GetMinPosition()); 
      Int_t izmax = (Int_t)(fSliderZ->GetMaxPosition()); 
      Double_t zmin = fZaxis->GetBinLowEdge(izmin);
      Double_t zmax = fZaxis->GetBinUpEdge(izmax);
      drange.AddRange(2,zmin, zmax);
   }
}

TList* TFitEditor::GetFitObjectListOfFunctions()
{
   // Get the list of functions previously used in the fitobject.

   TList *listOfFunctions = 0;
   if ( fFitObject ) {
      switch (fType) {
            
      case kObjectHisto:
         listOfFunctions = ((TH1 *)fFitObject)->GetListOfFunctions();
         break;
            
      case kObjectGraph:
         listOfFunctions = ((TGraph *)fFitObject)->GetListOfFunctions();
         break;
            
      case kObjectMultiGraph:
         listOfFunctions = ((TMultiGraph *)fFitObject)->GetListOfFunctions();
         break;
         
      case kObjectGraph2D:
         listOfFunctions = ((TGraph2D *)fFitObject)->GetListOfFunctions();
         break;
         
      case kObjectHStack:
      case kObjectTree: 
      default:
         break;
      }
   }
   return listOfFunctions;
}

void TFitEditor::GetFunctionsFromSystem()
{
   // Looks for all the functions registered in the current ROOT
   // session.

   // First, clean the copies stored in fSystemFunc
   for ( fSystemFuncIter it = fSystemFuncs.begin();
         it != fSystemFuncs.end();
         ++it ) {
      delete (*it);
   }

   fSystemFuncs.clear();

   // Be carefull not to store functions that will be in the
   // predefined section
   const unsigned int nfuncs = 16;
   const char* fnames[nfuncs] = { "gaus" ,   "gausn", "expo", "landau",
                                  "landaun", "pol0",  "pol1", "pol2",
                                  "pol3",    "pol4",  "pol5", "pol6",
                                  "pol7",    "pol8",  "pol9", "user"
   };

   // No go through all the objects registered in gROOT
   TIter functionsIter(gROOT->GetListOfFunctions());
   TObject* obj;
   while( ( obj = (TObject*) functionsIter() ) ) {
      // And if they are TF1s
      if ( TF1* func = dynamic_cast<TF1*>(obj) ) {
         bool addFunction = true;
         // And they are not already registered in fSystemFunc
         for ( unsigned int i = 0; i < nfuncs; ++i ) {
            if ( strcmp( func->GetName(), fnames[i] ) == 0 ) {
               addFunction = false;
               break;
            }
         }
         // Add them.
         if ( addFunction )
            fSystemFuncs.push_back( copyTF1(func) ); 
      }
   }
}

TList* TFitEditor::GetListOfFittingFunctions(TObject* obj)
{
   // This function returns a TList with all the functions used in the
   // FitPanel to fit a given object. If the object passed is NULL,
   // then the object used is the currently selected one. It is
   // important to notice that the FitPanel is still the owner of
   // those functions. This means that the user SHOULD NOT delete any
   // of these functions, as the FitPanel will do so in the
   // destructor.

   if (!obj) obj = fFitObject;

   TList *retList = new TList();

   pair<fPrevFitIter, fPrevFitIter> look = fPrevFit.equal_range(obj);
   for ( fPrevFitIter it = look.first; it != look.second; ++it ) {
      retList->Add(it->second);
   }

   return retList;
}

TF1* TFitEditor::GetFitFunction() 
{
   // Get the fit function selected or declared in the fiteditor

   TF1 *fitFunc = 0;
   // If the function is not editable ==> it means it is registered in
   // gROOT
   if ( fNone->GetState() == kButtonDisabled )
   {
      // So we find it
      TF1* tmpF1 = FindFunction();
      // And if we don't find it, then it means there is something wrong!
      if ( tmpF1 == 0 )
      {
               new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                            "Error...", "GetFitFunction\nVerify the entered function string!",
                            kMBIconStop,kMBOk, 0);
               return 0;
      }

      // Now we make a copy that will be used temporary. The caller of
      // the function should delete the returned function.
      fitFunc = (TF1*)tmpF1->IsA()->New();
      tmpF1->Copy(*fitFunc);
      // Copy the parameters of the function, if and only if the
      // parameters stored does not correspond with the ones of these
      // functions. Perhaps the user has already called
      // DoSetParameters. There is no way to know whether the
      // parameters have been modified, so we check the size of
      // fFuncPars against number of parameters.
      if ( int(fFuncPars.size()) != tmpF1->GetNpar() )
      {
         fitFunc->SetParameters(tmpF1->GetParameters());
         GetParameters(fFuncPars, fitFunc);
      } else {
         SetParameters(fFuncPars, fitFunc);
      }
   }

   // If, we have no function at this point, it means that is is
   // described in fEnteredFunc, so we create it from scratch.
   if ( fitFunc == 0 )
   {
      ROOT::Fit::DataRange drange; 
      GetRanges(drange);
      double xmin, xmax, ymin, ymax, zmin, zmax;
      drange.GetRange(xmin, xmax, ymin, ymax, zmin, zmax);

      // Depending of course on the number of dimensions the object
      // has. These commands will raise an error message if the user
      // has not defined the function properly
      if ( fDim == 1 || fDim == 0 ) {
         fitFunc = new TF1("PrevFitTMP",fEnteredFunc->GetText(), xmin, xmax );
      }
      else if ( fDim == 2 ) {
         fitFunc = new TF2("PrevFitTMP",fEnteredFunc->GetText(), xmin, xmax, ymin, ymax );
      }
      else if ( fDim == 3 ) {
         fitFunc = new TF3("PrevFitTMP",fEnteredFunc->GetText(), xmin, xmax, ymin, ymax, zmin, zmax );
      }

      // if the function is not a C defined
      if ( fNone->GetState() != kButtonDisabled )
      {
         // and the formulas are the same
         TF1* tmpF1 = FindFunction();
         if ( tmpF1 != 0 && fitFunc != 0 && 
              strcmp(tmpF1->GetExpFormula(), fEnteredFunc->GetText()) == 0 ) {
            // copy the parameters!
            if ( int(fFuncPars.size()) != tmpF1->GetNpar() )
            {
               fitFunc->SetParameters(tmpF1->GetParameters());
               GetParameters(fFuncPars, fitFunc);
            } else 
               SetParameters(fFuncPars, fitFunc);
         }
      }
   }

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