MainIndicatorTHStockFrame.cxx

Go to the documentation of this file.

#include "MainIndicatorTHStockFrame.h"
#include "../Controllers/MainControllerIndicatorTHStock.h"
#include "IndicatorFrame.h"
#include "THStockFrame.h"

// nicer graph for doxygen, because included by MainControllerIndicatorTHStock.h but lose its meaning !
//#include "THStockFrame.h"
// needed for signal ?? certainly ! not sure and seems to compile without !
#include "../ObjectStock/EditorObjStock.h"
#include "../ObjectStock/AbstractObjectStock.h"

// add exception, could be in a base class of View
#include "../GUIException.h"
#include "../TransientFrame.h"

//For ROOT dictionnary, necessary to get the slot working ??
ClassImp(MainIndicatorTHStockFrame)

// all declared static, not a problem because all common to all classes
// make a namespace, better than global, or set as private variable of the class (like GUIMainFrame)
const char * MainIndicatorTHStockFrame::xpms[] = {
   "./pictures/support.xpm",
   "./pictures/tendance.xpm",
   "./pictures/ancre.xpm",
   "./pictures/realtime.xpm",
   0
};

const char * MainIndicatorTHStockFrame::tips[] = {
   "Support/Resistance",
   "Line Tendance",
   "Anchor",
   "Real Time",
   //"Other..", fibo
   0
};

const char * MainIndicatorTHStockFrame::ListTimeScaleLabel[] = { "INST", "M5", "M10", "M30", "H1", "DAY", "WEEK", "MONTH", "TRIM", "YEAR" };

// first is x,y perfect, third is date, is exactly the good size with date+hour
Int_t MainIndicatorTHStockFrame::statbar_parts[] = {17, 12, 15, 56};


MainIndicatorTHStockFrame::MainIndicatorTHStockFrame( const TGWindow *p, MainControllerIndicatorTHStock *parent_control,
      std::string name_frame, UInt_t w,UInt_t h ) :
TGMainFrame( p, w, h), fcontroller ( parent_control )
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tConstructor MainIndicatorTHStockFrame h= " << h << " w " << w << std::endl;
    std::cout << "Value of the parent frame " << p << std::endl;
    std::cout << "Value of the parent controller " << parent_control << std::endl;
    std::cout << "name_frame " << name_frame << std::endl;
#endif

    SetName( name_frame.c_str() );
    // all child frame should be deleted in destructor, or when calling Cleanup()
    // see CloseWindow
    SetCleanup ( kDeepCleanup );

    if ( p == 0 ) {
#ifdef DEBUG_CONT_FRAME
        std::cout << "p == 0, create a kMainFrame " << std::endl;
#endif
        //ChangeOptions, no effect
        //frame->ChangeOptions((frame->GetOptions()& ~kVerticalFrame)| kHorizontalFrame);
        // do not change anything, make independent if p == 0., that's all !
        //ChangeOptions( (GetOptions() & ~kChildFrame)| kMainFrame );
        //try other option for correct fit with screen
        // not a problem with the main frame, scale to the screen exactly
        // but inside do not rescale, problem seems really not form here
        //ChangeOptions( (GetOptions() & ~kFixedWidth )| kFitWidth );
        //ChangeOptions( (GetOptions() & ~kFixedHeight )| kFitHeight );
        //std::cout << "Option kMainFrame has been setup " << std::endl;

        SetWindowName("IndependentMainFrame");

        // need something for clean closing, ok call the correct function
        Connect("CloseWindow()", "MainIndicatorTHStockFrame", this, "CloseWindow()");
    }


    // create vertical layout for main drawing
    // VMain really necessary ?? this is already a Vertical one !!
    TGVerticalFrame *fVMain = new TGVerticalFrame( this , 120, h );
    AddFrame( fVMain, new TGLayoutHints( kLHintsLeft | kLHintsExpandX | kLHintsExpandY ,2,2,2,2));

    // first make the toolbar bar and text box, inside fVMain
    CreateToolBar( fVMain );

    // then creates findic_thstock, new one, belong to fVMain
    TGHorizontalFrame * fHIndicTHStock = new TGHorizontalFrame( this, 100, h);
    fVMain->AddFrame( fHIndicTHStock, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY , 2, 2, 2, 2) );

    // draw inside fHIndicTHStock, theses frame need to be in *.h to retrieve easily
    fVframe_indicator = new TGVerticalFrame ( fHIndicTHStock, 120, h);
    fHIndicTHStock->AddFrame(fVframe_indicator, new TGLayoutHints( kLHintsExpandY , 2, 2, 2, 2) );
    // THStockFrame, MainTHStockFrame could be the name
    fHframe_c_stock = new TGHorizontalFrame( fHIndicTHStock, 100, h);
    fHIndicTHStock->AddFrame( fHframe_c_stock, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY , 2, 2, 2, 2) );

    // creates status bar
    fStatusBar = new TGStatusBar(fVMain, 50, 10, kHorizontalFrame);
    fStatusBar->SetParts (statbar_parts, 4);
    //fStatusBar->Draw3DCorner(kFALSE);
    fVMain->AddFrame (fStatusBar, new TGLayoutHints(kLHintsBottom | kLHintsLeft | kLHintsExpandX,0,0,2,0) );

#ifdef DEBUG_CONT_FRAME
    std::cout << "Newly created " << std::endl;
    std::cout << "fHframe_c_stock " << fHframe_c_stock << std::endl;
    std::cout << "fVframe_indicator " << fVframe_indicator << std::endl;
    //right to do this, object not yet created, seems ok get findic_thstock !
    std::cout << "MainIndicatorTHStockFrame this " << this << std::endl;
#endif
    // selection works, but cannot HideFrame yet here
    fComboTime->Select(15);
    fComboIndic->Select(20);
}

MainIndicatorTHStockFrame::~MainIndicatorTHStockFrame()
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "Destructor MainIndicatorTHStockFrame " << std::endl;
#endif
    fcontroller = 0;
    // should delete all subframes, ok done with solved bug
    // a priori done with the Cleanup call
    Cleanup();
    std::cout << "End destructor MainIndicatorTHStockFrame " << std::endl;
}

// strange because want to kill himself, what happens when coming back from the function ? CloseWindow ok ?
// better would be a signal to GUIMainController ?
void MainIndicatorTHStockFrame::CloseWindow()
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "Entry MainIndicatorTHStockFrame::CloseWindow() this " << this << std::endl;
    std::cout << "this " << this << " name controller " << GetName() << std::endl;
#endif
    // avoid to be called 2 times, see TGMAinFrame.CloseWindow()
    DontCallClose();
    // call function of the controller, will pass to GUIMainController
    fcontroller->DeleteIndicatorTHstock();
    // will call the destructor of this class
    TGMainFrame::CloseWindow();
}
// need the frame to which to paint
void MainIndicatorTHStockFrame::CreateToolBar( TGVerticalFrame * fVMain )
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "Entry MainIndicatorTHStockFrame::CreateToolBar " << std::endl;
#endif
  //no need to be outside, it was THE bug, no value for the first loop
  int separator_gtool=5;
  //same for the other ??
  char tmp[50];

  // here maybe many could be only intern to the function, not saved as member

  // creation of a horizontal bar to include toolbar, combo box and research text
  // the size is not takken into account
  fHframe_toolbar= new TGHorizontalFrame( fVMain, 100 , 40);
  fVMain->AddFrame( fHframe_toolbar, new TGLayoutHints( kLHintsLeft | kLHintsExpandX ,2,2,2,2) );
  // creation of a toolbar object as a child of main frame
  ftoolbar = new TGToolBar( fHframe_toolbar, 520, 160);
  //connect
  ftoolbar->Connect( "Clicked( Int_t )", "MainIndicatorTHStockFrame", this, "HandleToolBar( Int_t )" );
  //good place for kLHintsCenterY
  fHframe_toolbar->AddFrame( ftoolbar, new TGLayoutHints( kLHintsCenterY | kLHintsExpandY , 2, 20, 2, 2) );

  //Fill TGToolBar
  ToolBarData_t ftoolbd[6];
  for (int i = 0; i < 4; i++) {
      // filling the ToolBarData_t with information
      ftoolbd[i].fPixmap    = xpms[i];  // icon file
      ftoolbd[i].fTipText   = tips[i];    // tool tip text

      //Lines, anchor and RealTime
      if ( (i==0) || (i==1) || ( i==2) || (i==3) )
          ftoolbd[i].fStayDown = kTRUE;    // buttons stay pressed
      else
          ftoolbd[i].fStayDown = kFALSE;    // button behavior if clicked

      ftoolbd[i].fId = i+1;             // button id
      ftoolbd[i].fButton = NULL;        // button pointer

      // Make a test, keep this, should handle the message not fHframe_toolbar
      // test seem to work, but see later make strict
      separator_gtool = 1;
      if ( i == 3 ) separator_gtool = 25;
      ftoolbar->AddButton( fHframe_toolbar, &ftoolbd[i], separator_gtool);
  } //end loop for

  //std::cout << "TGtoolBar GetHeight " << ftoolbar->GetHeight() << std::endl;

  fLabelSearch = new TGLabel ( fHframe_toolbar, "Search" );
  //do not work here ...
  //fLabelSearch->SetHeight(100);
  fHframe_toolbar->AddFrame( fLabelSearch, new TGLayoutHints( kLHintsCenterY | kLHintsExpandY , 0, 5, 2, 2) );

  fTextResearch = new TGTextEntry ( fHframe_toolbar, "", kTextSearch);
  //signal TabPressed(), ReturnPressed(), TextChanged
  // respond to return, but no response, not implemented, only Validation is implemented !!
  fTextResearch->Connect("ReturnPressed()","MainIndicatorTHStockFrame",this,"HandleButtons(Int_t)");
  fHframe_toolbar->AddFrame( fTextResearch, new TGLayoutHints( kLHintsCenterY, 5, 5, 2, 2) );
  fTextResearch->Resize(70, 20);

  // combo box layout hints
  fComboTime = new TGComboBox( fHframe_toolbar, kChoiceTime ); //100 );
  fHframe_toolbar->AddFrame( fComboTime, new TGLayoutHints( kLHintsCenterY, 2, 2, 2, 2 ) );

  for (int i = 0; i < 10; i++) {
     sprintf(tmp, ListTimeScaleLabel[i], i+10);
     fComboTime->AddEntry(tmp, i+10);
  }
  fComboTime->Resize(70, 20);
  //select default, DAY
  //fComboTime->Select(15);

  fComboTime->Connect( "Selected(Int_t, Int_t )", "MainIndicatorTHStockFrame", this, "HandleComboBox( Int_t, Int_t )");

  std::vector<std::string> tmp_indic= Indicator::GetListAllIndicator();

  fComboIndic = new TGComboBox( fHframe_toolbar, kChoiceIndic ); //101 );
  // try the expand Y, ok effect
  fHframe_toolbar->AddFrame(fComboIndic ,new TGLayoutHints( kLHintsCenterY | kLHintsExpandY | kLHintsLeft ) );

  for ( unsigned int i=0; i < tmp_indic.size(); i++ ) {
       fComboIndic->AddEntry( tmp_indic[i].c_str(), i+20 );
    }
  fComboIndic->Resize(100,20);
  //fComboIndic->Select(20);
  fComboIndic->Connect( "Selected(Int_t, Int_t )", "MainIndicatorTHStockFrame", this, "HandleComboBox( Int_t, Int_t )");

  fParamEntry[0] = new TGTextEntry ( fHframe_toolbar, "", kParamEntry0);
  fHframe_toolbar->AddFrame( fParamEntry[0], new TGLayoutHints( kLHintsCenterY, 5, 5, 2, 2) );
  fParamEntry[0]->SetAlignment ( kTextRight );
  fParamEntry[0]->Resize(40,20);
  fHframe_toolbar->HideFrame( fParamEntry[0] );

  fParamEntry[1] = new TGTextEntry ( fHframe_toolbar, "", kParamEntry1);
  fHframe_toolbar->AddFrame( fParamEntry[1], new TGLayoutHints( kLHintsCenterY, 5, 5, 2, 2) );
  fParamEntry[1]->SetAlignment ( kTextRight );
  fParamEntry[1]->Resize(40,20);
  fHframe_toolbar->HideFrame( fParamEntry[1] );

  fParamEntry[2] = new TGTextEntry ( fHframe_toolbar, "", kParamEntry2);
  fHframe_toolbar->AddFrame( fParamEntry[2], new TGLayoutHints( kLHintsCenterY, 5, 5, 2, 2) );
  fParamEntry[2]->SetAlignment ( kTextRight );
  fParamEntry[2]->Resize(40,20);
  fHframe_toolbar->HideFrame( fParamEntry[2] );

  //TGCheckButton *check_to_add_canvas = new TGCheckButton(p, "Event Status",1);
  check_to_add_canvas = new TGCheckButton( fHframe_toolbar, "New CS", kAddCanvas );
  check_to_add_canvas->Connect("Clicked()","MainIndicatorTHStockFrame",this,"HandleButtons(Int_t)");
  fHframe_toolbar->AddFrame( check_to_add_canvas, new TGLayoutHints( kLHintsCenterY | kLHintsLeft , 5,2,2,2) );

  check_to_make_main = new TGCheckButton( fHframe_toolbar, "New Frame", kMakeMain );
  check_to_make_main->Connect("Clicked()","MainIndicatorTHStockFrame",this,"HandleButtons(Int_t)");
  fHframe_toolbar->AddFrame( check_to_make_main, new TGLayoutHints( kLHintsCenterY | kLHintsLeft , 5,2,2,2) );

  //check_to_add_canvas->SetState(kButtonDown);
  //check_to_add_canvas->SetState( kButtonDown );

  //button of validation of previous widget
  fValidB = new TGTextButton ( fHframe_toolbar, "&Valid", kValidB );
  fValidB->Connect("Clicked()", "MainIndicatorTHStockFrame", this, "HandleButtons(Int_t)");
  fHframe_toolbar->AddFrame ( fValidB, new TGLayoutHints( kLHintsCenterY | kLHintsExpandY | kLHintsRight, 1,1,3,3) );

  TGHorizontal3DLine *line_separator = new TGHorizontal3DLine(fVMain);
  fVMain->AddFrame(line_separator, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
}

// keep same idea, but more general, may add option for the stock
void MainIndicatorTHStockFrame::ResetEntries()
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "Entry Reset Entries" << std::endl;
#endif

    std::vector<std::string> tmp_indic= Indicator::GetListAllIndicator();
    Int_t nb_param = 0;
    bool b_default = false;
    std::vector<int> default_values;

    // always set off the check button
    check_to_add_canvas->SetState(kButtonUp);
    check_to_make_main->SetState(kButtonUp);

    // get indicator for the ComboBox
    Indicator indic = Indicator::GetIndicator( tmp_indic[ fComboIndic->GetSelected() - 20 ] );

    nb_param = indic.nb_param();
    b_default = indic.HasDefaultValues();

    //std::cout << "nb_param " << nb_param << " has default values " << b_default << std::endl;
    if ( b_default ) {
        default_values = indic.GetDefaultValues();
        //std::cout << "has default values " << std::endl;
    } /*else {
        std::cout << "no default values " << std::endl;
    }*/

    //reset all to hide, here need nothing
#ifdef DEBUG_CONT_FRAME
        std::cout << "Hide all fParamEntry" << std::endl;
#endif
    for ( int i=0; i < 3; i++ )
        fHframe_toolbar->HideFrame( fParamEntry[i] );

    //set entry param and default values if exists
    // can have param, but no default values
    if ( nb_param > 0 )  {
        for ( int i=0; i< nb_param; i ++ ) {
            //std::cout << "ShowFrame fParamEntry[i]" << i << std::endl;
            fHframe_toolbar->ShowFrame( fParamEntry[i] );
            // working or if i < size
            if ( b_default )
                fParamEntry[i]->SetText( (Utils::toString<Float_t>(default_values[i])).c_str(), false );
        }
    }
}

void MainIndicatorTHStockFrame::ExtractInfoForValidation( std::string & longname )
{
#ifdef DEBUG_CONT_FRAME
  std::cout << " \n\t Entry MainIndicatorTHStockFrame::ExtractInfoForValidation" << std::endl;
  std::cout << " pointer to fcontroller " << fcontroller << std::endl;
  //std::cout << "fStatusBar " << fStatusBar << std::endl;
#endif
  // to extract from toolbar
  std::string namestock;
  std::string tmscl_str;
  std::string indic_str;
  std::vector<std::string> tmp_indic= Indicator::GetListAllIndicator();

  // Get namestock
  namestock = fTextResearch->GetText();
  std::cout << "name stock: " << namestock << std::endl;
  // Get TimeScale
  tmscl_str = ListTimeScaleLabel[ fComboTime->GetSelected() - 10 ];
  //Get Indicator
  indic_str = tmp_indic[ fComboIndic->GetSelected() - 20 ];
  //std::cout << " indic_str " << tmscl_str << std::endl;

  longname = namestock+ '_' + tmscl_str + '_' + indic_str;
  // May add parameters to reconstruct fullname
  if ( fHframe_toolbar->IsVisible ( fParamEntry[0] ) ) {
       longname += '_' + Utils::toString<const char *> ( fParamEntry[0]->GetText() );
  }
  if ( fHframe_toolbar->IsVisible ( fParamEntry[1] ) ) {
       longname += '_' + Utils::toString<const char *> ( fParamEntry[1]->GetText() );
  }
  if ( fHframe_toolbar->IsVisible ( fParamEntry[2] ) ) {
       longname += '_' + Utils::toString<const char *>( fParamEntry[2]->GetText() );
  }

#ifdef DEBUG_CONT_FRAME
  std::cout << "End Extract fullname " << longname << std::endl;
#endif
}

void MainIndicatorTHStockFrame::HandleButtons(Int_t id)
{
#ifdef DEBUG_CONT_FRAME
  std::cout << " Entry MainIndicatorTHStockFrame::HandleButtons(Int_t id) " << std::endl;
#endif

  // Handle all buttons of this class
  TGButton *btn;
  if (id == -1) {
      //TGButton *btn = (TGButton *) gTQSender;
      btn = (TGButton *) gTQSender;
      id = btn->WidgetId();
      //std::cout << "get btn->widgetid " << id << std::endl;
  }

  switch (id) {
      //could be apart
      case kTextSearch:
          //std::cout << "Return in text search id: " << id << std::endl;
          //std::cout << "text search: " << ((TGTextEntry *)btn)->GetText() << std::endl;
          break;

      case kAddCanvas:
          //std::cout << "kAddCanvas state " << btn->IsOn() << std::endl;
          break;

      case kMakeMain:
          //std::cout << "kMakeMain state " << btn->IsOn() << std::endl;
          break;

      case kValidB:
#ifdef DEBUG_CONT_FRAME
          std::cout << "Valid button has been pressed, will call MainControllerIndicatorTHStockFrame::Validation " << std::endl;
#endif
          std::string longname;
          ExtractInfoForValidation( longname );

          // validation may encounter various exception laoding stock, computing TA...
          // easy to call from here and get all (otherwise call controller, which call an other controller function)
          // now get an exception
          try {
              // only one controller for a MainIndicatorFrame
              fcontroller->Validation( longname );
          // here should deal with GUIExeption
          } catch ( const GUIException & e ) {
#ifdef DEBUG_EXCEPT
              std::cout << "\nMainIndicatorTHStockFrame:Caugth GUIException from HandleButton " << std::endl;
              // ok send the correct initial message
              std::cout << "what(): " << e.what() << std::endl;
#endif
              // could clean the label, or reset to default here

              //new TransFrameError( fClient->GetRoot(), this, const_cast<GUIException &>(e) );
              new TransFrameError( fClient->GetRoot(), this, e );

          }
          //std::cout << "End of Validation " << std::endl;
          //std::cout << "fStatusBar " << fStatusBar << std::endl;
          break;
  }
#ifdef DEBUG_CONT_FRAME
  std::cout << " Exit MainIndicatorTHStockFrame::HandleButtons(Int_t id) " << std::endl;
#endif
}

void MainIndicatorTHStockFrame::HandleComboBox(Int_t widgetId, Int_t id)
{
#ifdef DEBUG_CONT_FRAME
 std::cout << "Entry HandleComboBox " << std::endl;
 std::cout << "widget " << widgetId << " id " << id << std::endl;
#endif

 // used before, no need anymore, simpler to read the new value
 // TGComboBox *tg=(TGComboBox *)gTQSender;

 // keep only id, need to refer to the tab
 switch ( widgetId ) {
        //deal only with TimeScale, nothing to do
    case kChoiceTime:
        //std::cout << "text " << ListTimeScaleLabel[id-10] << std::endl;
        break;
        //deal with indicator, need to set nb parameters and default values
    case kChoiceIndic:
        // modification done alone
#ifdef DEBUG_CONT_FRAME
        std::cout << "Modify ChoiceIndic ResetEntries" << std::endl;
#endif
        // can use the entry in the function
        ResetEntries();
        break;
 } // end switch

}

// Handle Line/Resistance, RealTime,...
void MainIndicatorTHStockFrame::HandleToolBar(Int_t id)
{
#ifdef DEBUG_CONT_FRAME
 std::cout << "Entry HandleToolBar id " << id << std::endl;
#endif
 //virtual TGButton*    GetButton(Int_t id) const
 TGButton * but = ftoolbar->GetButton(id);

 switch ( id ) {
    case 1:
                {
#ifdef DEBUG_CONT_FRAME
          std::cout << " Support/Resistance " << std::endl;
#endif
                  //first try, should call constructor
                  //EditorObjStock *feditor;
                  //std::cout << "feditor status " << feditor->GetStatus() << std::endl;
                  //EditorObjStock *feditor= EditorObjStock::getInstance();
                  // moved to pure static methods
                  if ( but->IsDown() ) {
#ifdef DEBUG_CONT_FRAME
                      std::cout << " IsDown, EditorObject set to Support " << std::endl;
#endif
                      //feditor->SetMode("Support");
                      EditorObjStock::SetMode("Support");
                  } else {
#ifdef DEBUG_CONT_FRAME
                      std::cout << " IsUp, EditorObject set to None " << std::endl;
#endif
                      //feditor->SetMode("None");
                      EditorObjStock::SetMode("None");
                  }
                  //std::cout << "feditor status " << feditor->GetStatus() << std::endl;
                  // need an EditorGetMode which return a string
                  //std::cout << "GetMode " <<  EditorObjStock::GetMode() << std::endl;
                }
                break;
        case 2:
                {
                  //EditorObjStock *feditor= EditorObjStock::getInstance();
                  if ( but->IsDown() ) {
#ifdef DEBUG_CONT_FRAME
                      std::cout << " IsDown, run EditorObject " << std::endl;
#endif
                      //feditor->SetMode("Tendance");
                      EditorObjStock::SetMode("Tendance");
                  } else {
                     //feditor->SetMode("None");
                     EditorObjStock::SetMode("None");
                  }
                }
                break;
        case 3:
                {
                  //EditorObjStock *feditor= EditorObjStock::getInstance();
                  if ( but->IsDown() ) {
#ifdef DEBUG_CONT_FRAME
                      std::cout << " IsDown, run EditorObject Anchor " << std::endl;
#endif
                      EditorObjStock::SetAnchor( true );
                      //EditorObjStock::SetMode("Anchor");
                  } else {
#ifdef DEBUG_CONT_FRAME
                     std::cout << "IsUp Disable Anchor" << std::endl;
#endif
                     EditorObjStock::SetAnchor( false );
                     //feditor->SetMode("None");
                     //EditorObjStock::SetMode("None");
                  }
                }
                break;
    case 4:
        {/*
         std::cout << " Real Time " << std::endl;
                 if ( but->IsDown() ) {
            std::cout << " IsDown, run RealTime " << std::endl;
                    frealtime->Start(10000);
         }
         else {
                    std::cout << " Is Not Down, stop RealTime " << std::endl;
                    frealtime->Stop();
         }
         */
        }
        break;
    }//end case
  //could test if both button Support and Tendance are down, only one or delete !
  //...
}

void MainIndicatorTHStockFrame::SetStatusBar( std::vector<std::string> & vec_str_text )
{
/*
#ifdef DEBUG_CONT_FRAME
    std::cout << "Entry MainIndicatorTHStockFrame::SetStatusBar " << std::endl;
    // works give the function, but not the class
    //std::cout << "Entry " << typeid(*this).name() << "::" << __func__ << std::endl;
    // g++ dependent, in capital letter ! for function does not change anything
    // pretty function is the keyword, all arguments are showed
    std::cout << "Entry pretty_function " << __PRETTY_FUNCTION__ << "::" << __FUNCTION__ << std::endl;
    //std::cout << "size  vec_str_text " << vec_str_text.size() << std::endl;
#endif
*/
    unsigned int size_entry = vec_str_text.size();
    unsigned int i = 0;

    // can clean all entries here, easier for caller, but only EventInfo for the moment
    // seems not the good one to call
    //fStatusBar->Clear();

    // can make a loop over the entry
    // make a test on the size ?? should do it
    for ( i = 0; i < size_entry; ++i ) {
        fStatusBar->SetText( vec_str_text[i].c_str(),i);
    }
    // set up to four if size_entry is smaller < 4, with empty
    for ( unsigned int j = i;j <4; j++ )
        fStatusBar->SetText("",j);

}

// More complexe, than thinking, how is it called ? do not reproduce...
// called 3 times, if a Candle Stock is selected with
//  - Pad Event 53
//  - CandleStock event 52
//  - CandleStock event 51
// should test in an example, from TGFrame.cxx
// signalslist = (TList*)el->fFrame->GetListOfSignals();
// TList *lsl = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfSlots");

// Slot, from TCanvasStock, should send string to Controller which will decide
// ok can get it from here, increase dependence with EditorObject, avoid if this is done from IndicatorFrame
// anyway only one active, and it here, here could choose ( send to MainController or GUIMainController )

// advantage here centralize, may have different type than THStock with who to interact, shorter path for the signal
// disadvantage : need EditorObject, need slot so Dictionary, need full access to parent controller ( better than THStockFrame->Controller->MainController. )
void MainIndicatorTHStockFrame::EventInfo(Int_t event, Int_t px, Int_t py, TObject *selected)
{
/*
#ifdef DEBUG_CONT_FRAME
  std::cout << "Entry MainIndicatorTHStockFrame::EventInfo" << std::endl;
  //std::cout << "selected " << selected << std::endl;
  //std::cout << " event " << event << std::endl;
  std::cout << " selected->ClassName " << selected->ClassName() << std::endl;
  std::cout << " selected->GetName " << selected->GetName() << std::endl;
#endif
*/
  std::vector < std::string > vec_str_text;
  std::string text_str0, text_str1, text_str2, text_str3;
  // for all dates
  time_t date = 0;
  std::string indic_str;

  text_str0 = Utils::toString( selected->GetObjectInfo(px,py) );
  //std::cout << "text_str0 " << text_str0 << std::endl;
  // return TObject if no dictionnary
  text_str1 = Utils::toString( selected->ClassName() );
  //std::cout << "text_str1 " << text_str1 << std::endl;
  vec_str_text.push_back( text_str0 );
  vec_str_text.push_back( text_str1 );

  //Printing values
  std::vector<Float_t> values;
  std::vector<std::string> add_strings;
  //std::cout << "Before test selected " << std::endl;

  AbstractObjectStock * obj_stock = 0;

  // need to test if the cast is correct, could be a pad or something else
  obj_stock = dynamic_cast<AbstractObjectStock *>(selected);
  //std::cout << "obj_stock " << obj_stock << std::endl;

  // set dates and values in the last two cases
  if ( obj_stock != 0 ) {
          // more general
          add_strings = obj_stock->MakeStringForStatusBar( px, py );
          //std::cout << "add_strings[0] " << add_strings[0] << std::endl;
          vec_str_text.push_back( add_strings[0] );
          vec_str_text.push_back( add_strings[1] );
  }
  // here can set status bar directly, no need to send to controller
  SetStatusBar( vec_str_text );
  //std::cout << "After MainIndicator SetText " << std::endl;
}