THistPainterStock.cxx

Go to the documentation of this file.

#include "THistPainterStock.h"

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TClass.h"
#include "TSystem.h"

#include "ObjectStock/THStock.h"
// really needed ??
#include "ObjectStock/TPadStock.h"
#include "ObjectStock/ObjectStock.h"
// because need info about First list data, may use CommonAxis or other
// and avoids the dependence
#include "../src_cpp/ListDataStock.h"

#include "TMath.h"
#include "TAxis.h"
#include "TGaxis.h"
#include "TLine.h"
#include "TBox.h"
#include "TStyle.h"

#include "TProfile.h"
#include "TPainter3dAlgorithms.h" // was defined as class in THistPainter, certainly the difference

#include "Hoption_stock.h"
#include "Hparam_stock.h"


ClassImp(THistPainterStock)

// from doc "Each histogram has a pointer to its own painter (to be usable in a multithreaded program). When the canvas has to be redrawn, the Paint function of each objects in the pad is called. In case of histograms, TH1::Paint invokes directly THistPainter::Paint."
// In my case , associated to each THStock, so can be drawn (let say updated first) by a simple openmp program ??

//new structure, optimized for stock
Hoption_stock_t Hoption_stock;
Hparam_stock_t  Hparam_stock;

/*
 * To see later, because copy of the common axis is done, could use the normal fXaxis ??
 */
//constructor of THistPainter has no arguement anyway
THistPainterStock::THistPainterStock() : THistPainter()
{
#ifdef DEBUG_HISTPAINTER
    std::cout << "For test Constructor THistPainterStock" << std::endl;
#endif
}

//destructor
THistPainterStock::~THistPainterStock()
{
#ifdef DEBUG_HISTPAINTER
    std::cout << "For test Destructor THistPainterStock" << std::endl;
#endif
}

//first copy from original code
// good idea, no need to modify, ckecked
Int_t THistPainterStock::MakeChopt( Option_t *choptin )
{
   //std::cout << "My MakeChopt " << std::endl;
   //keep only what needed, see original file  /usr/local/root/hist/histpainter/src/THistPainter.cxx
   char *l;
   char chopt[128];
   Int_t nch = strlen(choptin);
   //strlcpy(chopt,choptin,128);
   strncpy (chopt,choptin,128);

   Hoption_stock.Axis = Hoption_stock.Bar    = Hoption_stock.Curve   = Hoption_stock.Error = 0;
   Hoption_stock.Hist = Hoption_stock.Line   = Hoption_stock.Mark    = Hoption_stock.Fill  = 0;
   Hoption_stock.Same = Hoption_stock.Func   = Hoption_stock.Plus     = Hoption_stock.Scat    = 0;
   Hoption_stock.Star = Hoption_stock.Arrow  = Hoption_stock.Box     = Hoption_stock.Text  = 0;
   Hoption_stock.Char = Hoption_stock.Color  = Hoption_stock.Contour = Hoption_stock.Logx  = 0;
   Hoption_stock.Logy = Hoption_stock.Logz   = Hoption_stock.Lego    = Hoption_stock.Surf  = 0;
   Hoption_stock.Off  = Hoption_stock.Tri    = Hoption_stock.Proj    = Hoption_stock.AxisPos = 0;
   Hoption_stock.Spec = Hoption_stock.Pie    = 0;

   //std::cout << "Hoption_stock.Proj " << Hoption_stock.Proj << std::endl;
   //Add
   Hoption_stock.Candle = 0;
  // Bar and Line already exist
  // to add later Line2, Line3 for drawing STO or Bollinger for instance

   //    special 2D options
   Hoption_stock.List     = 0;
   Hoption_stock.Zscale   = 0;
   Hoption_stock.FrontBox = 1;
   Hoption_stock.BackBox  = 1;
   Hoption_stock.System   = kCARTESIAN;

   Hoption_stock.HighRes  = 0;

   //do not find in Hoption
   Hoption_stock.Zero     = 0;

   //check for graphical cuts
   MakeCuts(chopt);
/*
   for (Int_t i=0;i<nch;i++) chopt[i] = toupper(chopt[i]);
   if (fH->GetDimension() > 1) Hoption_stock.Scat = 1;
   if (!nch) Hoption_stock.Hist = 1;
   if (fFunctions->First()) Hoption_stock.Func = 2;
   if (fH->GetSumw2N() && fH->GetDimension() == 1) Hoption_stock.Error = 2;

   l = strstr(chopt,"SPEC");
   if (l) {
      Hoption_stock.Scat = 0;
      strncpy(l,"    ",4);
      Int_t bs=0;
      l = strstr(chopt,"BF(");
      if (l) {
         if (sscanf(&l[3],"%d",&bs) > 0) {
            Int_t i=0;
            while (l[i]!=')') {
               l[i] = ' ';
               i++;
            }
            l[i] = ' ';
         }
      }
      Hoption_stock.Spec = TMath::Max(1600,bs);
      return 1;
   }
*/
   l = strstr(chopt,"GL");
   if (l) {
      strncpy(l,"  ",2);
   }
   l = strstr(chopt,"X+");
   if (l) {
      Hoption_stock.AxisPos = 10;
      strncpy(l,"  ",2);
   }
   l = strstr(chopt,"Y+");
   if (l) {
      Hoption_stock.AxisPos += 1;
      strncpy(l,"  ",2);
   }
   if((Hoption_stock.AxisPos == 10 || Hoption_stock.AxisPos == 1) && (nch == 2)) Hoption_stock.Hist = 1;
   if(Hoption_stock.AxisPos == 11 && nch == 4) Hoption_stock.Hist = 1;

   l = strstr(chopt,"SAMES");
   if (l) {
      if (nch == 5) Hoption_stock.Hist = 1;
      Hoption_stock.Same = 2;
      strncpy(l,"     ",5);
   }
   l = strstr(chopt,"SAME");
   if (l) {
      if (nch == 4) Hoption_stock.Hist = 1;
      Hoption_stock.Same = 1;
      strncpy(l,"    ",4);
   }

   l = strstr(chopt,"BAR");
   if (l) {
      Hoption_stock.Hist = 0;
      Hoption_stock.Bar = 10; strncpy(l,"   ",3);
      if (l[3] == '1') { Hoption_stock.Bar = 11; l[3] = ' '; }
      if (l[3] == '2') { Hoption_stock.Bar = 12; l[3] = ' '; }
      if (l[3] == '3') { Hoption_stock.Bar = 13; l[3] = ' '; }
      if (l[3] == '4') { Hoption_stock.Bar = 14; l[3] = ' '; }
   }

    //added, present in last source code
    l = strstr(chopt,"+-");   if (l) { Hoption_stock.Plus = 2; strncpy(l,"  ",2); }
    l = strstr(chopt,"-+");   if (l) { Hoption_stock.Plus = 2; strncpy(l,"  ",2); }

   l = strstr(chopt,"HIST"); if (l) { Hoption_stock.Hist   = 2; strncpy(l,"    ",4); Hoption_stock.Func = 0; Hoption_stock.Error = 0;}
   l = strstr(chopt,"AXIS"); if (l) { Hoption_stock.Axis   = 1; strncpy(l,"    ",4); }
   l = strstr(chopt,"AXIG"); if (l) { Hoption_stock.Axis   = 2; strncpy(l,"    ",4); }
   l = strstr(chopt,"TEXT");
   if (l) {
      Int_t angle;
      if (sscanf(&l[4],"%d",&angle) > 0) {
         if (angle < 0)  angle=0;
         if (angle > 90) angle=90;
         Hoption_stock.Text = 1000+angle;
      } else {
         Hoption_stock.Text = 1;
      }
      strncpy(l,"    ", 4);
      Hoption_stock.Scat = 0;
   }

/*
   l = strstr(chopt,"AITOFF");
   if (l) {
      Hoption_stock.Proj = 1; strncpy(l,"     ",6);       //Aitoff projection
   }
   l = strstr(chopt,"MERCATOR");
   if (l) {
      Hoption_stock.Proj = 2; strncpy(l,"       ",8);     //Mercator projection
   }
   l = strstr(chopt,"SINUSOIDAL");
   if (l) {
      Hoption_stock.Proj = 3; strncpy(l,"         ",10);  //Sinusoidal projection
   }
   l = strstr(chopt,"PARABOLIC");
   if (l) {
      Hoption_stock.Proj = 4; strncpy(l,"        ",9);    //Parabolic projection
   }
   if (Hoption_stock.Proj > 0) {
      std::cout << "Problem with Proj" << std::endl;
      Hoption_stock.Scat = 0;
      Hoption_stock.Contour = 14;
   }
*/
   if (strstr(chopt,"A"))   Hoption_stock.Axis = -1;
   if (strstr(chopt,"B"))   Hoption_stock.Bar  = 1;
/*
    if (strstr(chopt,"+"))   Hoption_stock.Plus =1;
    if (strstr(chopt,"-"))   Hoption_stock.Plus =-1;
    if (strstr(chopt,"*"))   Hoption_stock.Star =1;
    if (strstr(chopt,"H"))   Hoption_stock.Hist =2;
//   if (strstr(chopt,"P0"))  Hoption_stock.Mark =10;
*/

/*
   if (strstr(chopt,"E")) {
      if (fH->GetDimension() == 1) {
         Hoption_stock.Error = 1;
         if (strstr(chopt,"E0"))  Hoption_stock.Error = 10;
         if (strstr(chopt,"E1"))  Hoption_stock.Error = 11;
         if (strstr(chopt,"E2"))  Hoption_stock.Error = 12;
         if (strstr(chopt,"E3"))  Hoption_stock.Error = 13;
         if (strstr(chopt,"E4"))  Hoption_stock.Error = 14;
         if (strstr(chopt,"E5"))  Hoption_stock.Error = 15;
         if (strstr(chopt,"E6"))  Hoption_stock.Error = 16;
         if (strstr(chopt,"X0")) {
            if (Hoption_stock.Error == 1)  Hoption_stock.Error += 20;
            Hoption_stock.Error += 10;
         }
         if (Hoption_stock.Text && fH->InheritsFrom(TProfile::Class())) {
            Hoption_stock.Text += 2000;
            Hoption_stock.Error = 0;
         }
      } else {
         if (Hoption_stock.Error == 0) {
            Hoption_stock.Error = 100;
            Hoption_stock.Scat  = 0;
         }
         if (Hoption_stock.Text) {
            Hoption_stock.Text += 2000;
            Hoption_stock.Error = 0;
         }
      }
   }
*/

/*
   if (strstr(chopt,"9"))  Hoption_stock.HighRes = 1;

   if (Hoption_stock.Surf == 15) {
      if (Hoption_stock.System == kPOLAR || Hoption_stock.System == kCARTESIAN) {
         Hoption_stock.Surf = 13;
         Warning("MakeChopt","option SURF5 is not supported in Cartesian and Polar modes");
      }
   }
*/
   //      Copy options from current style
   Hoption_stock.Logx = gPad->GetLogx();
   Hoption_stock.Logy = gPad->GetLogy();
   Hoption_stock.Logz = gPad->GetLogz();

   //       Check options incompatibilities
   // if (Hoption_stock.Bar  == 1) Hoption_stock.Hist = -1;

/*
   if (Hoption_stock.Same && Hoption_stock.Plus) {
      Error("MakeChopt", "select only one of the options S,+");
      return 0;
   }
   if (Hoption_stock.Plus) {
      if (Hoption_stock.Line || Hoption_stock.Curve || Hoption_stock.Text || Hoption_stock.Mark) {
         Error("MakeChopt", "options L,C,T,P are incompatible with options U and K");
         if (Hoption_stock.Hist && Hoption_stock.Bar) return 0;
      }
   }
   if (Hoption_stock.Error || Hoption_stock.Func || Hoption_stock.Star) {
      if (Hoption_stock.Plus) {
         Error("MakeChopt", "U, + options incompatible with errors/function");
         return 0;
      }
   }
*/
   return 1;
}

//Ok checked, no need to change
void THistPainterStock::PaintFrame()
{
#ifdef DEBUG_HISTPAINTER
   std::cout << "Entry Paint Frame, is Hoption_stock.Same " << Hoption_stock.Same << std::endl;
   //PrintInfo();
#endif

   if (Hoption_stock.Same) {
#ifdef DEBUG_HISTPAINTER
      std::cout << "Entry Paint Frame, is Hoption_stock.Same true" << std::endl;//<< Hoption_stock.Same << std::endl;
#endif
      return;
   }

   //complex stuff, use Hparam as well
   RecalculateRange();

/*
   if (Hoption_stock.Lego || Hoption_stock.Surf || Hoption_stock.Tri ||
       Hoption_stock.Contour == 14 || Hoption_stock.Error >= 100) {
      TObject *frame = gPad->FindObject("TFrame");
      if (frame) gPad->GetListOfPrimitives()->Remove(frame);
      return;
   }
*/

/* if deleted this, works !! just miss some border...TPadStockExecute is Ok
   gPad->PaintPadFrame(Hparam_stock.xmin,Hparam_stock.ymin,Hparam_stock.xmax,Hparam_stock.ymax);
*/
   //make own version
   ((TPadStock *)gPad)->PaintPadFrameStock(Hparam_stock.xmin,Hparam_stock.ymin,Hparam_stock.xmax,Hparam_stock.ymax);
}

//ok checked, taken from last version or not modified
void THistPainterStock::RecalculateRange()
{
#ifdef DEBUG_HISTPAINTER
   std::cout << "Entry RecalculateRange Proj=" << Hoption_stock.Proj << std::endl;
#endif
   if (Hoption_stock.Same) return;

   //     Compute x,y rangen
   Double_t xmin = Hparam_stock.xmin;
   Double_t xmax = Hparam_stock.xmax;
   Double_t ymin = Hparam_stock.ymin;
   Double_t ymax = Hparam_stock.ymax;

   Double_t dx   = xmax-xmin;
   Double_t dy   = ymax-ymin;
   Double_t dxr  = dx/(1 - gPad->GetLeftMargin()   - gPad->GetRightMargin());
   Double_t dyr  = dy/(1 - gPad->GetBottomMargin() - gPad->GetTopMargin());

   // Range() could change the size of the pad pixmap and therefore should
   // be called before the other paint routines
   gPad->Range(xmin - dxr*gPad->GetLeftMargin(),
                      ymin - dyr*gPad->GetBottomMargin(),
                      xmax + dxr*gPad->GetRightMargin(),
                      ymax + dyr*gPad->GetTopMargin());
   gPad->RangeAxis( xmin, ymin, xmax, ymax );
}

// now one THstock owns all other could be much simpler
void THistPainterStock::PaintTitle()
{
#ifdef DEBUG_HISTPAINTER
  std::cout << "\n\t Entry PaintTitle()" << std::endl;
  //std::cout << " Get Size Title " << ((THStock*)fH)->GetSizeTitle() << std::endl;
  //std::cout << " Get Title " << ((THStock*)fH)->GetTitle() << std::endl;
  //std::cout << " Get Name " << ((THStock*)fH)->GetName() << std::endl;
#endif

  // if Hoption.Same return
  if (Hoption_stock.Same) return;
  if (fH->TestBit(TH1::kNoTitle)) return;

  Int_t nt = strlen(fH->GetTitle());
  TPaveText *title = 0;
  TObject *obj;
  TIter next(gPad->GetListOfPrimitives());
  while ((obj = next())) {
      if (!obj->InheritsFrom(TPaveText::Class())) continue;
      title = (TPaveText*)obj;
      if (strcmp(title->GetName(),"title")) {title = 0; continue;}
      break;
  }
  if (nt == 0 || gStyle->GetOptTitle() <= 0) {
      if (title) delete title;
      return;
  }

  //here get placement from gStyle and get FontSize
  Double_t ht = gStyle->GetTitleH();
  Double_t wt = gStyle->GetTitleW();
  //std::cout << "ht " << ht << " wt " << wt << " gstyle FontSize " << gStyle->GetTitleFontSize() << std::endl;

  //here modify size, if not default
  // now only one title, no Same, could simplify it
  if ( ((THStock*)fH)->GetSizeTitle() != 0. ) {
      //std::cout << " not default behaviour set ht " << std::endl;
      //ht = 1.1*((THStock*)fH)->GetSizeTitle();
      ht = 1.05*((THStock*)fH)->GetSizeTitle();
  }
  //default behavior
  else {
      //if (ht <= 0) ht = 1.1*gStyle->GetTitleFontSize();
      if (ht <= 0) ht = 1.05 * gStyle->GetTitleFontSize();
      if (ht <= 0) ht = 0.05;
  }
  if (wt <= 0) {
      //std::cout << "after default ht " << ht << " wt " << wt << " gstyle FontSize " << gStyle->GetTitleFontSize() << std::endl;
      TLatex l;
      l.SetTextSize(ht);
      l.SetTitle(fH->GetTitle());
      // adjustment in case the title has several lines (#splitline)
      //ht = TMath::Max(ht, 1.2*l.GetYsize()/(gPad->GetY2() - gPad->GetY1()));
      ht = TMath::Max(ht, 2.0*l.GetYsize()/(gPad->GetY2() - gPad->GetY1()));
      Double_t wndc = l.GetXsize()/(gPad->GetX2() - gPad->GetX1());
      wt = TMath::Min(0.7, 0.02+wndc);
  }
  if ( title ) {
      TText *t0 = (TText*)title->GetLine(0);
      //std::cout << "title present return " << std::endl;
      if (t0) {
         if (!strcmp(t0->GetTitle(),fH->GetTitle())) return;
         t0->SetTitle(fH->GetTitle());
         if (wt > 0) title->SetX2NDC(title->GetX1NDC()+wt);
      }
      return;
  }

  // here certainly never used, to delete
  // NO make the title !
  //std::cout << " never used in PaintTitle to delete" << std::endl;

  Int_t talh = gStyle->GetTitleAlign()/10;
  if (talh < 1) talh = 1; if (talh > 3) talh = 3;
  Int_t talv = gStyle->GetTitleAlign()%10;
  if (talv < 1) talv = 1; if (talv > 3) talv = 3;
  Double_t xpos, ypos;
  xpos = gStyle->GetTitleX();
  ypos = gStyle->GetTitleY();
  if (talh == 2) xpos = xpos-wt/2.;
  if (talh == 3) xpos = xpos-wt;
  if (talv == 2) ypos = ypos+ht/2.;
  if (talv == 1) ypos = ypos+ht;
  //default talh 1 talv 3

  //std::cout << "final ht " << ht << " wt " << wt << " talh " << talh << " talv " << talv << std::endl;
  //std::cout << " xpos, ypos-ht, xpos+wt, ypos " << xpos << " " << ypos-ht << " " << xpos+wt << " " << ypos << std::endl;
  TPaveText *ptitle = new TPaveText(xpos, ypos-ht, xpos+wt, ypos,"blNDC");
  //Play with margin as well, do not see difference
  //ptitle->SetMargin(0.01); //default 0.05

  //     box with the histogram title
  ptitle->SetFillColor(gStyle->GetTitleFillColor());
  ptitle->SetFillStyle(gStyle->GetTitleStyle());
  ptitle->SetName("title");
  ptitle->SetBorderSize(gStyle->GetTitleBorderSize());
  ptitle->SetTextColor(gStyle->GetTitleTextColor());
  ptitle->SetTextFont(gStyle->GetTitleFont(""));

  //test
  if (gStyle->GetTitleFont("")%10 > 2) {
      // not called
      std::cout << "Test condition font " << std::endl;
      ptitle->SetTextSize(gStyle->GetTitleFontSize());
  }

  /*
   std::cout << " GetTitle " << fH->GetTitle() << std::endl;
   string short_title= Utils::toString<const char *>( fH->GetTitle() ) ;
   if ( short_title.size() > 4 ) {
      std::cout << " size " << short_title.size() << std::endl;
      short_title.erase( 4, short_title.size()-3 );
      //title_canvas.push_back(".");
      short_title.replace( 4, 1, "." );
      //Set the new title
     }
   */
   // no nned to cast, TH1 method
   ptitle->AddText(fH->GetTitle());
   //ptitle->AddText( short_title.c_str() );
   ptitle->SetBit(kCanDelete);
   ptitle->Draw();
   ptitle->Paint();

}


Int_t THistPainterStock::PaintInit()
{
    //static const char *where = "PaintInit";

#ifdef DEBUG_HISTPAINTER
    std::cout << "Entry THistPainterStock::PaintInit latest version " << std::endl;
    // seems ok, different pointer by THStock
    std::cout << " this = " << this << std::endl;
    //std::cout << "  Test if data are conserved " << std::endl;
    PrintInfo();
#endif

    Int_t size_data_axis; // whatever common or not (so shift=0)
    Int_t size_data_listd; // real size of data size_axis-size_list = shift_left
    // keep copy of initial value before modification of xaxis
    Int_t shift_futur, shift_left; // shift_left = size_data_axis - size_data_listd;

    Double_t bigp = TMath::Power( 10, 32 );
    Double_t ymax = -bigp;
    Double_t ymin = bigp;

    //Change logic, if there is a common axis, associates the pointer of axis of THistPainter
    fXaxis = ( (THStock *)fH )->GetCommonXAxis()->GetXAxis();
    //  used for comptuing xlast, only one in Hparam_stock
    // use the first list by default
    size_data_axis = fXaxis->GetNbins();

    //std::cout << "( (THStock *)fH )->GetFirstListData()->GetName() " <<  ( (THStock *)fH )->GetFirstListData()->GetName() << std::endl;
    // need to check if correctly associated
    ListDataStockBase *ldata = ( (THStock *)fH )->GetFirstListData();
    if ( ldata == nullptr ) {
        std::cout << "THsitPainterStock::PaintInit Error ldata is null " << std::endl;
        // send exception ? bug in programming
        // or just draw without any indicator, not possible at the moment
        exit(1);
    }
    size_data_listd = ldata->GetSize();

#ifdef DEBUG_HISTPAINTER
    std::cout << "size_data_axis = fXaxis->GetNbins() " << size_data_axis << std::endl;
    std::cout << "size_data_listd " << size_data_listd << std::endl;
#endif

    // copy data from common_xaxis to Hparam , similar to original ?? could use (THStock *)fH all along !
    // certainly break the logic here, but Hparam is correct after
    Hparam_stock.xlast    = fXaxis->GetLast();
    Hparam_stock.xfirst   = fXaxis->GetFirst();
    Hparam_stock.xlowedge = fXaxis->GetBinLowEdge( Hparam_stock.xfirst );
    Hparam_stock.xbinsize = fXaxis->GetBinWidth( Hparam_stock.xfirst );
    //Hparam_stock.xmin     = fXaxis->GetBinLowEdge( Hparam_stock.xfirst )+ fXaxis->GetBinWidth( Hparam_stock.xfirst );
    //std::cout << " fXaxis->GetBinLowEdge( Hparam_stock.xlast) " << fXaxis->GetBinLowEdge( Hparam_stock.xlast) << std::endl;
    //std::cout << " fXaxis->GetBinLowEdge( Hparam_stock.xfirst) " << fXaxis->GetBinLowEdge( Hparam_stock.xfirst) << std::endl;
    //std::cout << " fXaxis->GetBinWidth(last) " << fXaxis->GetBinWidth(last) << std::endl;

    //stange here..., xmin, xmax overitten after ?? not sure, to check
    Hparam_stock.xmin     = Hparam_stock.xlowedge;
    Hparam_stock.xmax     = fXaxis->GetBinLowEdge( Hparam_stock.xlast ) + fXaxis->GetBinWidth( Hparam_stock.xlast );

    //     Compute X axis parameters, let commented for the moment
    // reneeded for Log...deactivate for the moment, not yet implemented anyway
 /*
    Int_t last      = fXaxis->GetLast();
    Int_t first     = fXaxis->GetFirst();

    //log for x is done here, not used yet for X never ??
    //       if log scale in X, replace xmin,max by the log
     if (Hoption_stock.Logx) {
        if (Hparam_stock.xlowedge <=0 ) {
           if (Hoption_stock.Same) {
              Hparam_stock.xlowedge = TMath::Power(10, gPad->GetUxmin());
           } else {
              Hparam_stock.xlowedge = 0.1*Hparam_stock.xbinsize;
           }
           Hparam_stock.xmin  = Hparam_stock.xlowedge;
        }
        if (Hparam_stock.xmin <=0 || Hparam_stock.xmax <=0) {
           Error(where, "cannot set X axis to log scale");
           return 0;
        }
        Hparam_stock.xfirst= fXaxis->FindFixBin(Hparam_stock.xmin);
        Hparam_stock.xlast = fXaxis->FindFixBin(Hparam_stock.xmax);
        Hparam_stock.xmin  = TMath::Log10(Hparam_stock.xmin);
        Hparam_stock.xmax  = TMath::Log10(Hparam_stock.xmax);
        if (Hparam_stock.xlast  > last)  Hparam_stock.xlast  = last; //Hparam.xlast    = last;
        if (Hparam_stock.xfirst < first) Hparam_stock.xfirst = first;//Hparam.xfirst   = first;
     }
*/

    // add other data for later needed for drawing, specific shift_futur, shift_left
    // ok, property of the common_axis
    shift_futur = ( (THStock *)fH )-> GetCommonXAxis() -> GetShift();
    //shift_futur = fXaxis->GetShift();, cannot here, should change intern pointer ?
    // certainly never used
    // still assign for the moment, but can get it from CommonAxis in Object
    Hparam_stock.shift_futur = shift_futur;

    // strange shift left with only the first ldata ?? yes first is indicatr csv by default. Can find better ??
    // why not the first one fix limits, others follow and overwritte shift left ??
    // here tricky expression, shift_left is a property of ldatastock, can know about it !..

    // Hparam.shift_left, not used, recomputed for each list
    // used only for xlast, not anymore in Hparam_stock
    // keep for the moment, present in SetLabel, to check if necessary,
    // First should be 0 shift !!
    // to delete from Hparam_stock if not used anymore
    Hparam_stock.shift_left = size_data_axis - size_data_listd - shift_futur;

    shift_left = size_data_axis - size_data_listd - shift_futur;

#ifdef DEBUG_HISTPAINTER
    std::cout << "First set Hparam.shift_left " <<  Hparam_stock.shift_left << std::endl;
    std::cout << "First set Hparam.shift_futur " <<  Hparam_stock.shift_futur << std::endl;
    std::cout << "First set Hparam.xlast " << Hparam_stock.xlast << std::endl;
#endif

    // ok seems fine here, need the test only if shift futur
    // if slider between,  shift_futur still keep > 0
    // here set up xlast, not recomputed after
    //if ( Hparam_stock.shift_futur > 0 ) {
    if ( shift_futur > 0 ) {
       Hparam_stock.xlast = TMath::Min ( Hparam_stock.xlast,  size_data_listd + shift_left );
#ifdef DEBUG_HISTPAINTER
       std::cout << "Take min between Hparam.xlast " <<  Hparam_stock.xlast << std::endl;
       std::cout << "and size_data_listd + shift_left " << size_data_listd + shift_left << std::endl;
       std::cout << "shift_futur > 0, Took Min for xlast " << Hparam_stock.xlast << std::endl;
#endif
    }

    // here deal with xfirst
    // apply only for SMA, need to shift both
    // here xfirtst recomputed
    // needed for MACD for instance, need a correct set up of Hparam_stock.xfirst in SetLabel ??
    if ( shift_left ) {
#ifdef DEBUG_HISTPAINTER
        std::cout << "shift_left is true, before Max Hparam_stock.xfirst " << Hparam_stock.xfirst << " Hparam_stock.shift_left " << Hparam_stock.shift_left << std::endl;
#endif
        Hparam_stock.xfirst = TMath::Max( Hparam_stock.xfirst, Hparam_stock.shift_left +1 );
        //std::cout << "after max Hparam_stock.xfirst " << Hparam_stock.xfirst << std::endl;
    }

    // here assum Object in Chronological order
 #ifdef DEBUG_HISTPAINTER
    std::cout << "All Hparam_stock set up ? " << std::endl;
    PrintInfo();
    std::cout << " Look for maximum, minimum " << std::endl;
    std::cout << "Hparam.xfirst/xlast " <<   Hparam_stock.xfirst << " xlast " << Hparam_stock.xlast << std::endl;
    std::cout << "First set Hparam.shift_left " <<  Hparam_stock.shift_left << std::endl;
    std::cout << "First set Hparam.shift_futur " <<  Hparam_stock.shift_futur << std::endl;
 #endif

    // could compute Extrema at the same time, more efficient
    ((THStock *)fH)->SetObjectStock( Hparam_stock );

#ifdef DEBUG_HISTPAINTER
    std::cout << "Before GetObjectExtrema " << std::endl;
#endif
    // no Hparam_stock here ?? SetObejct assue draw only the minimum needed
    // Get max and min values over Object Candle/Volume/Indicator not included ObjectLine
    ((THStock *)fH)->GetObjectExtrema( ymin, ymax );

#ifdef DEBUG_HISTPAINTER
    std::cout << " After GetObjectExtrema ymin " << ymin << " ymax " << ymax << std::endl;
#endif
    // let a marge
    // need to check if not done again in PaintFrame
    // not bad add 5% around, certainly the best !!
    // strange with Volume, give negative number, but final paint is ok..
    // Should be in ObjectStock::GetObjectExtrema ??
    Hparam_stock.ymin = ymin - (ymax-ymin)*0.05;
    Hparam_stock.ymax = ymax + (ymax-ymin)*0.05;

  #ifdef DEBUG_HISTPAINTER
      std::cout << "After setup 5% of Hparam_stock.ymin/ymax " << Hparam_stock.ymin << " " << Hparam_stock.ymax << std::endl;
      PrintInfo();
      std::cout << "Exit THistPainterStock::PaintInit()\n" << std::endl;
  #endif

    return 1;
}


// new version
// PaintXAxis first, Paint Y after
// maybe need to change the order for THStock axis
//Overwritte PaintAxis, invert order paint Y first, and if option A do not paint X
//void THistPainterStock::PaintAxis( Bool_t option_noopt, Bool_t drawGridOnly )
void THistPainterStock::PaintAxis(Bool_t drawGridOnly)
{
#ifdef DEBUG_HISTPAINTER
  std::cout << "\n\tEntry THistPainterStock::PaintAxis " << std::endl;
#endif
  //first one was commented ??
  //if (Hoption_stock.Axis == -1) return;
  if (Hoption_stock.Same && Hoption_stock.Axis <= 0) return;

  //std::cout << " Will paint something " << std::endl;

  // Repainting alphanumeric labels axis on a plot done with
  // the option HBAR (horizontal) needs some adjustements. deleted, see source code

  static char chopt[10] = "";
  //add option for desactivation optimisation, should be able with option ???
  //Option_t *chopt2;

  Double_t gridl = 0;
  Int_t ndiv, ndivx, ndivy, nx1, nx2, ndivsave;
  Int_t useHparam = 0;
  Double_t umin, umax, uminsave, umaxsave;
  Short_t xAxisPos = Hoption_stock.AxisPos/10;
  Short_t yAxisPos = Hoption_stock.AxisPos - 10*xAxisPos;

  Double_t axmin = gPad->GetUxmin();
  Double_t axmax = gPad->GetUxmax();
  Double_t aymin = gPad->GetUymin();
  Double_t aymax = gPad->GetUymax();
  char *cw = 0;
  TGaxis axis;

  //if ( option_noopt )
  //chopt2="N";
  //else
  //chopt2="";

  // In case of option 'cont4' or in case of option 'same' over a 'cont4 plot'
     
  // Invert order Paint Y axis first
  ndivy = fYaxis->GetNdivisions();
  //std::cout << " will paint Yaxis ndivy=" << ndivy << std::endl;
  axis.ImportAxisAttributes(fYaxis);

  chopt[0] = 0;
  strcat(chopt, "SDH");
  if (ndivy < 0) strcat(chopt, "N");
  if (gPad->GetGridy()) {
       gridl = (axmax-axmin)/(gPad->GetX2() - gPad->GetX1());
       strcat(chopt, "W");
  }

  // Define Y-Axis limits
  if (Hoption_stock.Logy) {
       strcat(chopt, "G");
       ndiv = TMath::Abs(ndivy);
       if (useHparam) {
           umin = TMath::Power(10,Hparam_stock.ymin);
           umax = TMath::Power(10,Hparam_stock.ymax);
       } 
       else {
           umin = TMath::Power(10,aymin);
           umax = TMath::Power(10,aymax);
      }
  } 
  else {
      ndiv = TMath::Abs(ndivy);
      if (useHparam) {
          umin = Hparam_stock.ymin;
          umax = Hparam_stock.ymax;
      } 
      else {
          umin = aymin;
          umax = aymax;
      }
  }

  // Display axis as time
  if (fYaxis->GetTimeDisplay()) {
       std::cout << "Paint Display " << std::endl;
       strcat(chopt,"t");
       if (strlen(fYaxis->GetTimeFormatOnly()) == 0) {
           axis.SetTimeFormat(fYaxis->ChooseTimeFormat(Hparam_stock.ymax-Hparam_stock.ymin));
       }
  }

  // The main Y axis can be on the left or on the right of the pad
  Double_t yAxisXPos1, yAxisXPos2;
  if (yAxisPos == 1) {
       // Main Y axis left
       yAxisXPos1 = axmax;
       yAxisXPos2 = axmin;
  } 
  else {
       // Main Y axis right
       yAxisXPos1 = axmin;
       yAxisXPos2 = axmax;
  }

  // Paint the main Y axis (always)
  uminsave = umin;
  umaxsave = umax;
  ndivsave = ndiv;
  axis.SetOption(chopt);
  if (yAxisPos) {
       strcat(chopt, "+L");
       gridl = -gridl;
  }

  if (Hoption_stock.Same && Hoption_stock.Axis) { // Axis repainted (TPad::RedrawAxis)
       axis.SetLabelSize(0.);
       axis.SetTitle("");
  }
  //std::cout << "Really Paint Yaxis, chopt " << chopt << " ndiv=" << ndiv << std::endl;
  axis.PaintAxis(yAxisXPos1, aymin,
                 yAxisXPos1, aymax,
                 umin, umax,  ndiv, chopt, gridl, drawGridOnly);

  // Paint the additional Y axis (if needed)
  if (gPad->GetTicky()) {
       if (gPad->GetTicky() < 2) {
           strcat(chopt, "U");
           axis.SetTickSize(-fYaxis->GetTickLength());
       } 
       else {
           strcat(chopt, "+L");
       }
       if ((cw=strstr(chopt,"W"))) *cw='z';
       axis.SetTitle("");
       axis.PaintAxis(yAxisXPos2, aymin, yAxisXPos2, aymax,
                      uminsave, umaxsave,  ndivsave, chopt, gridl, drawGridOnly);
  }

  // Reset the axis if they have been inverted in case of option HBAR, noramlly last command of Paint

  //if more complex, use a new option
  if (Hoption_stock.Axis == -1) return;

  // Paint X axis, inverted for THStock draw after Y axis
  ndivx = fXaxis->GetNdivisions();
  //std::cout << "PaintAxis Xaxis fXaxis->GetNdivision  =" << ndivx << std::endl;

  if (ndivx > 1000) {
       nx2   = ndivx/100;
       nx1   = TMath::Max(1, ndivx%100);
       ndivx = 100*nx2 + Int_t(Float_t(nx1)*gPad->GetAbsWNDC());
  }
  axis.SetTextAngle(0);
  axis.ImportAxisAttributes(fXaxis);

  chopt[0] = 0;
  strcat(chopt, "SDH");
  if (ndivx < 0) strcat(chopt, "N");
  if (gPad->GetGridx()) {
       gridl = (aymax-aymin)/(gPad->GetY2() - gPad->GetY1());
       strcat(chopt, "W");
  }

  // Define X-Axis limits
  if (Hoption_stock.Logx) {
       strcat(chopt, "G");
       ndiv = TMath::Abs(ndivx);
       if (useHparam) {
           umin = TMath::Power(10,Hparam_stock.xmin);
           umax = TMath::Power(10,Hparam_stock.xmax);
       } 
       else {
           umin = TMath::Power(10,axmin);
           umax = TMath::Power(10,axmax);
       }
  } 
  else {
      ndiv = TMath::Abs(ndivx);
      if (useHparam) {
          umin = Hparam_stock.xmin;
          umax = Hparam_stock.xmax;
      } 
      else {
          umin = axmin;
          umax = axmax;
      }
  }

  // Display axis as time
  if (fXaxis->GetTimeDisplay()) {
      strcat(chopt,"t");
      if (strlen(fXaxis->GetTimeFormatOnly()) == 0) {
          axis.SetTimeFormat(fXaxis->ChooseTimeFormat(Hparam_stock.xmax-Hparam_stock.xmin));
      }
  }
  // The main X axis can be on the bottom or on the top of the pad
  Double_t xAxisYPos1, xAxisYPos2;
  if (xAxisPos == 1) {
      // Main X axis top
      xAxisYPos1 = aymax;
      xAxisYPos2 = aymin;
  } 
  else {
      // Main X axis bottom
      xAxisYPos1 = aymin;
      xAxisYPos2 = aymax;
  }
  // Paint the main X axis (always)
  uminsave = umin;
  umaxsave = umax;
  ndivsave = ndiv;
  axis.SetOption(chopt);
  if (xAxisPos) {
      strcat(chopt, "-");
      gridl = -gridl;
  }

  if (Hoption_stock.Same && Hoption_stock.Axis) { // Axis repainted (TPad::RedrawAxis)
      axis.SetLabelSize(0.);
      axis.SetTitle("");
  }

  //01/02/2011
  // here force with chopt2 = "N" to force no optimisation
  // but web not actualised, from code there is a big change, SetNdivision is in TAttAxis (and not in TGAxis)
  //                         and accepts a new argument kFALSE, but because the code is copied from the net,
  //                         it is not used well here, TODO update my version of PaintAxis !! all function takken from net ??
  //std::cout << "Really PaintAxis X ndiv=" << ndiv << std::endl;
  //std::cout << "axmin " << axmin << " axmax " << axmax << " xAxisYPos1 " << " chopt2 " << chopt2 << std::endl;
  //std::cout << "umin " << umin << std::endl;
   
  axis.PaintAxis(axmin, xAxisYPos1, axmax, xAxisYPos1,
                 umin, umax,  ndiv, chopt, gridl, drawGridOnly);

  // Paint additional X axis (if needed)
  if (gPad->GetTickx()) {
      if (xAxisPos) {
          cw=strstr(chopt,"-");
          *cw='z';
      } 
      else {
          strcat(chopt, "-");
      }
      if (gPad->GetTickx() < 2) strcat(chopt, "U");
      if ((cw=strstr(chopt,"W"))) *cw='z';
      axis.SetTitle("");
      axis.PaintAxis(axmin, xAxisYPos2, axmax, xAxisYPos2,
                     uminsave, umaxsave,  ndivsave, chopt, gridl, drawGridOnly);
  }

#ifdef DEBUG_HISTPAINTER
  std::cout << "Exit PaintAxis" << std::endl;
#endif
}

// A Paint() method uses only the drawing methods defined in the TVirtualPad class
// to draw itself PaintBox(), PaintFillArea(), PaintLine(), PaintLine3D(), PaintPolyLine(), PaintText()
// Make a big difference in the implementation. 
// in test by root, not concluent to use pad->PaintBox or canvas->PaintBox (disappear when resized)
// but can be used internally in the Paint method, no need to create objects !!
// 1. can use for tests, access to data from listdatastock and do not create object, no interaction
// 2. create each TBox, or better a set of TCandle, with their own Paint method, can interact
//    implemented in ObjectStock
void THistPainterStock::Paint( Option_t* option )
{
#ifdef DEBUG_HISTPAINTER
  std::cout << "\n\t Entry Paint in THistPainterStock" << std::endl;
  // StockCSV
  std::cout << "will paint fH->GetName() " << fH->GetName() << std::endl;
#endif

  // just copy, do not understand why
  // fH pointeur to the histogram to be painted
  if (fH->GetBuffer()) fH->BufferEmpty(-1);

  gPad->SetVertical(kTRUE);

  if (!MakeChopt(option)) {
      // never happens
      std::cout << "Return from THistPainterStock::Paint because MakeChopt returned false" << std::endl;
      return; //check options and fill Hoption structure
  }
  //std::cout << " Option: .Axis=" << Hoption_stock.Axis << std::endl;

  //No axis will be drawn, but need to increase ymin or ymax if necessary
  // no point anymore, until 2 StockCSV in one... keep for later
  if (Hoption_stock.Same)
      std::cout << "Option SAME" << std::endl;
  else if (Hoption_stock.Axis == -1)
      std::cout << "Option A" << std::endl;
#ifdef DEBUG_HISTPAINTER
  else
      std::cout << "No Option, default" << std::endl;
#endif


  // Paint using TSpectrum2Painter, Paint Pie
  // fill Hparam_stock structure with min, max parameters
  // last version, call again PaintInit
  if ( !PaintInit() ) {
      //delete [] fXbuf; delete [] fYbuf;
      std::cout << "\n\tPaintInit return 0, IMPOSSIBLE \n" << std::endl;
      return;
  }

  //here ok, fXaxis point to common normally ( to check ), to test if no Canvas, when no slider
  // to check return 4 when 5 is apllied !!

  // strange Ndivisions output negtive, and NOT used !
  /*
  fXaxis->SetNdivisions ( (Hparam_stock.xlast - Hparam_stock.xfirst + Hparam_stock.shift_futur), kFALSE );
  // with 42 data (StockCSV set to 41 divisions, used later ??
  std::cout << "after return from PaintInit SetNdivisions to " << Hparam_stock.xlast - Hparam_stock.xfirst + Hparam_stock.shift_futur << std::endl;
  */

  //in my version, done at the end for value of axis
  //          Picture surround (if new page) and page number (if requested).
  //          Histogram surround (if not option "Same").
  PaintFrame();

  //          Paint histogram axis only
#ifdef DEBUG_HISTPAINTER
  std::cout << "Hoption_stock.Axis " << Hoption_stock.Axis << std::endl;
#endif

  Bool_t gridx = gPad->GetGridx();
  Bool_t gridy = gPad->GetGridy();
  if (Hoption_stock.Axis > 0) {
      if (Hoption_stock.Axis > 1) 
          PaintAxis(kTRUE);  //axis with grid
      else {
          if (gridx) gPad->SetGridx(0);
          if (gridy) gPad->SetGridy(0);
          PaintAxis(kFALSE);
          if (gridx) gPad->SetGridx(1);
          if (gridy) gPad->SetGridy(1);
      }
      if (Hoption_stock.Same ==1) Hoption_stock.Same = 2;
      //goto paintstat;
  }
  if (gridx || gridy) PaintAxis(kTRUE); //    Draw the grid only

  //  test for associated function
  if (gridx) gPad->SetGridx(0);
  if (gridy) gPad->SetGridy(0);
  //PaintAxis(kFALSE);
  if (gridx) gPad->SetGridx(1);
  if (gridy) gPad->SetGridy(1);

  PaintTitle();  // Draw histogram title

  // new version, here after getting max and frame setup
  // now only Paint, important after than frame is setup correctly
  ((THStock *)fH)->PaintObjectStock();

  //Remake PaintAxis after PaintCandle, ok works when update ?? before ??

  //label of axis before painting the axis
  SetLabelXAxis();
  PaintAxis(kFALSE);

  // think it works now , to retest
  //fXaxis->SetTickLength(0.0);
}

void THistPainterStock::SetLabelXAxis()
{
  //std::cout << "\n\tEntry SetLabelXAxis " << std::endl;
   
  //test
  //if (Hoption_stock.Same && Hoption_stock.Axis <= 0) {
  //e.g. Volume draw A, EMA draw SAME, maybe not the best but ok like tihd
  if ( ( Hoption_stock.Axis < 0 ) || ( Hoption_stock.Same ) ) {
#ifdef DEBUG_HISTPAINTER
      std::cout << "option Axis or SAME return " << std::endl;
#endif
      return; 
  }

  struct tm date_tm;
  char tmp_date[30]="";
  char tmp_date_opt[15]="";
  char memo_opt[15]="";
  int size_data;
  ETime tmscl;
  Int_t frequence,count=0;
   
  ListDataStockBase *ldata = ((THStock *)fH)->GetFirstListData();
  //std::cout << " GetName of the data " << ldata->GetName() << std::endl;
  //std::cout << " GetName of the thstock " << ((THStock *)fH)->GetName() << std::endl;

  tmscl = ldata->GetTimeScale();
  size_data = ldata->GetSize();
  // here crash, seems the wrong ldata is called, should be the first one, the candle !
#ifdef DEBUG_HISTPAINTER
  std::cout << "SetLabelAxis " << std::endl;
  std::cout << " ldata " << ldata << std::endl;
  std::cout << " ETime " << tmscl << std::endl;
  std::cout << " size_data " << size_data << std::endl;
  std::cout << " Hparam.shift_left " << Hparam_stock.shift_left << std::endl;
  std::cout << " name " << ldata->GetName() << std::endl;
#endif

  //come from PHPlot, only for print data
  if ( size_data > 8 ) 
      frequence = ( size_data+4 )/8;
  else
      frequence = 1;
  //std::cout << "frequence " << frequence << std::endl;
  //std::cout << "Hparam_stock.xfirst " << Hparam_stock.xfirst << std::endl;
  //std::cout << "Hparam_stock.xlast " << Hparam_stock.xlast << std::endl;
  //std::cout << "Hparam_stock.shift_left " << Hparam_stock.shift_left << std::endl;

  // will fill the bin==bin, logic, need to use shift_left, no need of shift_futur, print until xlast < Ndivision !
  for ( Int_t bin = Hparam_stock.xfirst; bin <= Hparam_stock.xlast ; bin++ ) {
      // original
          // Not a bug original [] checks if offset > 0 and label is wrong anyway
          // ok but still a shift of one is needed between bin and vector starts from 0
          //std::cout << "bin - Hparam_stock.shift_left -1 " << bin - Hparam_stock.shift_left -1 << std::endl;
          date_tm = ldata->ChronologicAt( bin - Hparam_stock.shift_left -1 ).GetDateTm();

      // format depend on timescale
      // month or trimester, to check has changed ?? much better with real type
      //if ( (tmscl == 5) or (tmscl == 6) ) {
          if ( ( tmscl == ETime::DAY ) or ( tmscl == ETime::WEEK) ) {
          strftime(tmp_date,25,"%d",&date_tm);
          strftime( tmp_date_opt, 25, "-%m", &date_tm);
          //std::cout << " tmp_date_opt " << tmp_date_opt << std::endl;
      }
      //else if ( tmscl < 4  ) {
          // int works here
          else if ( tmscl < ETime::H1 ) {
          strftime(tmp_date,25,"%H:%M",&date_tm);
          strftime( tmp_date_opt, 25, "-%d", &date_tm);
      }
      //else if (( tmscl == 7) or (tmscl == 8)) {
          else if (( tmscl == ETime::TRIM) or (tmscl == ETime::YEAR) ) {
          strftime(tmp_date,25,"%m",&date_tm);
          strftime( tmp_date_opt, 25, "%y", &date_tm);
      }
      else if ( tmscl == ETime::H1 ) {
          strftime(tmp_date,25,"%H",&date_tm);
      }
      else if ( tmscl == ETime::YEAR ) //9
          strftime(tmp_date,25,"%y",&date_tm);

      // works for the first bin by default !
      if ( strcmp( memo_opt, tmp_date_opt ) ) { // different
          //std::cout << "different memo " << std::endl;
          // to be sure it will be printed, otherwise keep old memo
          if (count % frequence == 0 ) {
              strcpy ( memo_opt, tmp_date_opt );
              strcat( tmp_date, tmp_date_opt );
          }
      }

      // Use bin, not division
      //std::cout << "Set label " << std::endl;
      //print or erase previous data
      if (count % frequence == 0 ) {
          fXaxis->SetBinLabel(bin,tmp_date);
          //std::cout << "bin " << bin << " ,count " << count << " label " << tmp_date << std::endl;
      }
      else fXaxis->SetBinLabel(bin,"");
      count+=1;
  }
}


// a lot of code deleted, coming from THistPainter::DtP
Int_t THistPainterStock::DistancetoPrimitive(Int_t px, Int_t py)
{

#ifdef DEBUG_HISTPAINTER
    std::cout << "Entry THistPainterStock::DistancetoPrimitive  " << std::endl;
#endif

   const Int_t kMaxDiff = 7;
   Int_t puxmin = gPad->XtoAbsPixel(gPad->GetUxmin());
   Int_t puymin = gPad->YtoAbsPixel(gPad->GetUymin());
   Int_t puxmax = gPad->XtoAbsPixel(gPad->GetUxmax());
   Int_t puymax = gPad->YtoAbsPixel(gPad->GetUymax());
   Int_t yxaxis, dyaxis,xyaxis, dxaxis;
   Bool_t dsame;
   TString doption = gPad->GetPadPointer()->GetDrawOption();

   //     check if point is close to an axis
   doption.ToLower();
   dsame = kFALSE;
   if (doption.Contains("same")) dsame = kTRUE;

   dyaxis = Int_t(2*(puymin-puymax)*fYaxis->GetLabelSize());
   if (doption.Contains("y+")) {
      xyaxis = puxmax + Int_t((puxmax-puxmin)*fYaxis->GetLabelOffset());
      if (px <= xyaxis+dyaxis && px >= xyaxis && py >puymax && py < puymin) {
         if (!dsame) {
            if (gPad->IsVertical()) gPad->SetSelected(fYaxis);
            else                    gPad->SetSelected(fXaxis);
            return 0;
         }
      }
   } else {
      xyaxis = puxmin - Int_t((puxmax-puxmin)*fYaxis->GetLabelOffset());
      if (px >= xyaxis-dyaxis && px <= xyaxis && py >puymax && py < puymin) {
         if (!dsame) {
            if (gPad->IsVertical()) gPad->SetSelected(fYaxis);
            else                    gPad->SetSelected(fXaxis);
            return 0;
         }
      }
   }

   dxaxis = Int_t((puymin-puymax)*fXaxis->GetLabelSize());
   if (doption.Contains("x+")) {
      yxaxis = puymax - Int_t((puymin-puymax)*fXaxis->GetLabelOffset());
      if (py >= yxaxis-dxaxis && py <= yxaxis && px <puxmax && px > puxmin) {
         if (!dsame) {
            if (gPad->IsVertical()) gPad->SetSelected(fXaxis);
            else                    gPad->SetSelected(fYaxis);
            return 0;
         }
      }
   } else {
      yxaxis = puymin + Int_t((puymin-puymax)*fXaxis->GetLabelOffset());
      if (yxaxis < puymin) yxaxis = puymin;
      if (py <= yxaxis+dxaxis && py >= yxaxis && px <puxmax && px > puxmin) {
         if (!dsame) {
            if (gPad->IsVertical()) gPad->SetSelected(fXaxis);
            else                    gPad->SetSelected(fYaxis);
            return 0;
         }
      }
   }

   //std::cout <<"THistPainterStock::Distance call TH1 Distance" << std::endl;

   //AbstractObjectStock* obj_stock = 0;
   TObject* obj_stock = 0;
   Int_t dist = 9999;

   // broadcast to THStock
   Int_t dist_stock = ((THStock*) fH)->DistancetoPrimitive( px, py, &(obj_stock) );
   //std::cout << "THistStoctkPainter dist from object stock " << dist_stock << " kMaxDiff " << kMaxDiff << std::endl;
   //std::cout << "obj_stock " << obj_stock << " " << obj_stock->ClassName() << std::endl;

   if ( dist_stock <= dist ) {
        dist = dist_stock;
        // kMaxDiff important to get TFrame if not in inside Candle for instance
        if ( dist < kMaxDiff ) {

#ifdef DEBUG_HISTPAINTER
            std::cout << "select an ObjectStock " << obj_stock->ClassName() << std::endl;
            //std::cout << "select object " <<  obj_stock << " dist " << dist << std::endl;
            //std::cout << "before gPad->SetSelected(obj_stock)" << std::endl;
#endif
            gPad->SetSelected(obj_stock);
            // nothing happens between
            // NOT TRUE, if click left on object, THStockFrame::GetSignalSelected is call
            // need to retest

#ifdef DEBUG_HISTPAINTER
            std:cout << "After gPad->SeSelected, reutrn dist " << dist << std::endl;
#endif

            return dist;
        }
   }

#ifdef DEBUG_HISTPAINTER
   std::cout << "Exit THistPainterStock::DistancetoPrimitive, no selection return previous curdist dist= " << dist << std::endl;
#endif

   return dist;
}

void THistPainterStock::PrintInfo()
{
  std::cout << "\n\tPrintInfo THistPainterStock " << std::endl;
  std::cout << " Hparam.xfirst  "<< Hparam_stock.xfirst  <<  " xlast " << Hparam_stock.xlast << std::endl;
  std::cout << " Hparam.xmin " << Hparam_stock.xmin << " xmax " << Hparam_stock.xmax << std::endl;
  std::cout << " Hparam.ymin " << Hparam_stock.ymin << " ymax " << Hparam_stock.ymax << std::endl;
  //std::cout << " xbinsize " << Hparam_stock.xbinsize <<  " xlowedge " <<  Hparam_stock.xlowedge << std::endl;
  std::cout << " Hparam.shift_left " << Hparam_stock.shift_left << " shift_futur " << Hparam_stock.shift_futur << std::endl;
  std::cout << "\t Exit THistPainterStock::PrintInfo\n" << std::endl;
}