GUI/TFndMonFrame.cxx

// @(#)fROOT/GUI:$Name:  $:$Id: TFndMonFrame.cxx,v 1.19 2007/09/24 07:32:41 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2006/05/16
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>, 2002

//     GUI Monitor base class for the FINUDA online monitoring       //
//                                                                   //
//      - Mouse actions are considered                               //
//                                                                   //
//      - The CloseCanvas mouse-action is redirected to the          //
//        local method CloseMainCanvas in order to guarantee an      //
//        appropriated "close-delete-reinitialize" sequence          //
//                                                                   //
//      - Automatic update is available                              //
//        by means of the virtual method UpdateDaughters             //
//                                                                   //

#include <TROOT.h>
#include <TSystem.h>
#include <TCanvas.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TH1D.h>
#include <TList.h>
#include <TText.h>
#include <TPaveText.h>
#include <TPaveStats.h>
#include <TTimer.h>
#include <TThread.h>

//#include "TROOT.h"

#include "FROOT.h"
#include "TFndRun.h"
#include "TFndMonFrame.h" 

ClassImp(TFndMonFrame)

//_______________________________________________
TFndMonFrame::TFndMonFrame(TString filename, TString filename2):
  fRF(),fRF2(),fIsOnline(),fCanStartGUI(),fClosed(kTRUE),
  fMainCanvCoord(),fMainCanvas(),fMainRootCanvas(),
  fDisplayPad(),fUpdateFlashCol(),fHighlightCol(),
  fBigCanvas(),fBigRootCanvas(),
  fBigHis1F(),fBigHis2F(),fBigHis3F(),fBigHis1D(),
  fTimer(),fUpdateInterval(),fAutoUpdate(),fWhichPop()
{
  // The default constructor is overloaded by this constructor
  // if files are specified, they are opened and kept in memory
  //   (data-members: fRF and fRF2)
  // NOTE: "root-files" only are accepted
  // Constructor for online monitoring: both arguments equal to zero

  if(filename.IsNull() && filename2.IsNull()){
    fIsOnline = kTRUE;  
    fCanStartGUI = kTRUE;
  }
  fAutoUpdate = fIsOnline;

  //  Printf("DEBUG!!!!!!!!! \"%s\" --- \"%s\"",filename.Data(),filename2.Data());
  // FROOT::ExpandPathName(...) is used for backward compatibility
  if(!filename.IsNull()){
    if(gSystem->AccessPathName(FROOT::ExpandPathName(filename.Data()))){
      Printf("file \"%s\" not found: can't open the monitor GUI.",filename.Data());
      fCanStartGUI = kFALSE;
    }
    else{
      fRF = new TFile(filename);
      fCanStartGUI = kTRUE;
    }
  }
  // ---
  if(!filename2.IsNull()){
    if(gSystem->AccessPathName(FROOT::ExpandPathName(filename2))){
      Printf("file \"%s\" not found: can't open the monitor GUI.",filename2.Data());
      fCanStartGUI = kFALSE;
    }
    else{
      fRF2 = new TFile(filename2);
      fCanStartGUI = kTRUE;
    }  
  }  

  InitAll();
}

//____________________________________
TFndMonFrame::~TFndMonFrame() {

  delete fBigHis1F;
  delete fBigHis2F;
  delete fBigHis3F;
  delete fBigHis1D;

  if(fRF) { fRF->Close(); fRF->Delete(); }
  delete fRF;
  if(fRF2) { fRF2->Close(); fRF2->Delete(); }
  delete fRF2;
  for(Int_t i=0;i<2;i++){  
    if(!fClosed) delete fDisplayPad[i];
    delete fMainCanvas[i];
  }

  delete fBigCanvas;

  delete fTimer;
}

//____________________________________
TPaveStats *TFndMonFrame::GetPadStats(TVirtualPad *pad){
  // default (pad=0) uses gPad

  if(!gPad){
    gROOT->Warning("TFndMonFrame::GetPadStats","gPad not available");
    return 0;
  }
  return pad ? 
    (TPaveStats *)(pad->GetPrimitive("stats")):
    (TPaveStats *)(gPad->GetPrimitive("stats"));

}

//____________________________________
void TFndMonFrame::SetMonitorTitle(Int_t cnum,Char_t *detector_name){
  // cnum: MainCanvas array index [0-1]

  TString mainctit = TString(detector_name);
  mainctit+=" Display monitor (";
  if (!fRF) mainctit+="ONLINE";
  else{
    mainctit+=fndrun->GetRunType();
    mainctit+="-";
    mainctit+=fndrun->GetRunNumber();
  }
  mainctit+=")";
  fMainCanvas[cnum]->SetTitle(mainctit.Data());
}

//____________________________________
void TFndMonFrame::InitAll(){
  // All GUI is dependent on the
  // screen resolution (from froot-8.00.04)

  /*
  fMainCanvCoord[0] = 305;
  fMainCanvCoord[1] = 130;
  fMainCanvCoord[2] = 970;
  fMainCanvCoord[3] = 680;
  */

  UInt_t wstart = (UInt_t) (gClient->GetDisplayWidth() / 5 + gClient->GetDisplayWidth() / 150 );
  UInt_t hstart = (UInt_t) (gClient->GetDisplayHeight() / 9 + gClient->GetDisplayHeight() /  30 );

  fMainCanvCoord[0] = wstart;
  fMainCanvCoord[1] = hstart;
  fMainCanvCoord[2] = (UInt_t) (gClient->GetDisplayWidth())  - (UInt_t)(1.05 * wstart);  // window borders considered
  fMainCanvCoord[3] = (UInt_t) (gClient->GetDisplayHeight()) - (UInt_t)(1.95 * hstart); // bottom linux taskbar considered

  fUpdateFlashCol = 3;

  fHighlightCol[0]=5;
  fHighlightCol[1]=5;

  fUpdateInterval = 30; // seconds
  fTimer = new TTimer();  
  fTimer->Connect("Timeout()","TFndMonFrame",this,"RefreshSingleMonView()");
  //  Connect(timer, "Timeout()", "myObjectClassName",myObject, "TimerDone()");                         
  fTimer->Start(fUpdateInterval*1000, kFALSE);   // kTRUE:single-shot ; kFALSE:repetitive          
  if(fAutoUpdate) fTimer->TurnOn();
  else fTimer->TurnOff();
}

//____________________________________
void TFndMonFrame::SetStyle(Int_t style_id){
  // You can select the style used by all
  // frames of the froot-online monitor GUI

  switch(style_id){
  case 0:
    gStyle->SetTitleW(0.75);
    gStyle->SetTitleH(0.08);
    gStyle->SetPalette(1,0);
    break;
  case 1:
    gStyle->SetTitleW(0.7);
    gStyle->SetTitleH(0.06);
    gStyle->SetPalette(1,0);
    break;  
  default: break;
  }
}


//____________________________________
void TFndMonFrame::BuildConnections(){

  for(Int_t i=0;i<2;i++) if(fMainCanvas[i]){
    //    fMainCanvas[i]->ToggleEventStatus();
    fMainCanvas[i]->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)","TFndMonFrame",this,"HandleMouseActions(Int_t,Int_t,Int_t,TObject*)");
    
    fMainRootCanvas[i] = (TRootCanvas*)fMainCanvas[i]->GetCanvasImp();
    fMainRootCanvas[i]->DontCallClose(); // disable manual close
    //    fMainRootCanvas[i]->Connect("CloseWindow()", "TFndMonFrame", this,"CloseMainCanvas()");
  }
  
}

//____________________________________
void TFndMonFrame::FlashDisplayPad(Int_t padnum){
  // Flash on fDisplayCanvas and refresh histograms (implemented in each daughter)
  
  //  gROOT->Info("Monitor consumer","Refreshing Histograms view");
  
  if(fDisplayPad[padnum]){
    Int_t ColOri = fDisplayPad[padnum]->GetFillColor();
    fDisplayPad[padnum]->SetFillColor(fUpdateFlashCol);
    fDisplayPad[padnum]->Modified();
    fDisplayPad[padnum]->Update();
    gSystem->Sleep(300);
    fDisplayPad[padnum]->SetFillColor(ColOri);
    fDisplayPad[padnum]->Modified();
    fDisplayPad[padnum]->Update();
    gSystem->Sleep(300);
  }
  //  gSystem->ProcessEvents();
  
}
//____________________________________
void TFndMonFrame::PopMainCanvas(){
  // Show the selected Main Canvas
  //
  //  ___________________________________________________________
  // |  Development NOTE (Diego):                                |
  // |   TCanvas::Pop() doesn't work with TG* classes            |
  // |   under Fedora/Gentoo Linux: that's why all               |
  // |   canvases are iconifyied before showing the selected one |
  // |   (it is simply a work-around..non needed under SLC)      |
  //  -----------------------------------------------------------


  // Search for active canvas and iconify them

  TString CanvNames[6];
  CanvNames[0] = "Stb_MainCanvas";
  CanvNames[1] = "Lmd_MainCanvas";
  CanvNames[2] = "tof_MainCanvas";
  CanvNames[3] = "TOF_MainCanvas";
  CanvNames[4] = "Gts_MainCanvas";
  CanvNames[5] = "SIL_MainCanvas";

  
  TCanvas *curcan = 0;
  for(Int_t i=0;i<7;i++){
    curcan = ((TCanvas *)gROOT->FindObjectAny(CanvNames[i].Data()));
    if(!curcan) continue;
    cout << " Iconifying ============> " << curcan->GetName() << endl;
    curcan->GetCanvasImp()->Iconify();
    curcan->Modified();
    curcan->Update();
    
  }
  curcan = 0;
  usleep(300000);
  
  
  fWhichPop=!fWhichPop;
  if(!fMainRootCanvas[1])fWhichPop = kFALSE;
  
  if(!fWhichPop){
    cout << " Now Showing ===> " << fMainCanvas[0]->GetName() << endl;
    fMainCanvas[0]->Show();
    fMainCanvas[0]->Modified();
    fMainCanvas[0]->Update();
  }
  else{
    cout << " Now Showing ===> " << fMainCanvas[1]->GetName() << endl;
    fMainCanvas[1]->Show();
    fMainCanvas[1]->Modified();
    fMainCanvas[1]->Update();
  }
  
}

//____________________________________
Bool_t TFndMonFrame::SwitchUpdateMethod(){
  
  fAutoUpdate=!fAutoUpdate;
  cout << "Autoupdate option is now: " << fAutoUpdate << endl;

  if(fAutoUpdate) fTimer->TurnOn();
  else fTimer->TurnOff();
  return fAutoUpdate;

}

//____________________________________
Int_t TFndMonFrame::CheckProducerMessages(){
  // Simply wait if producer is denying any consumer action
  // (shared text file check: see geb2hdt.C)
  //
  // return value:
  //              0: ok
  //             -1: message file not found in $FND_SHR
  //             -2: shared memories existent, but busy

#if !defined _FND_USE_HANDLE_CONSUMER_ACTIONS
  return 0;
#endif

  TString sh_msg_file = TString(gSystem->Getenv("FND_SHR"));
  sh_msg_file += "/.shared_msg.txt";

  //  Int_t interval = 10;

  //  while(1){
  FILE *f_sh = fopen(sh_msg_file.Data(),"r");
  if(!f_sh){
    cout << "Messages shared file not found." << endl;
    return -1;
  }
  Char_t msg[10];
  Int_t scan = fscanf(f_sh,"%s",msg);
  fclose(f_sh);
  
  if(!strcmp(msg,"go")) return 0;
  
  // --- if you are here it means that shared memories exist, but they are busy
  gROOT->Info("TFndMonFrame::CheckProducerMessages","Shared memories busy...waiting for producer");
  //  cout << "TFndMonFrame::CheckProducerMessages(): Shared memories busy...waiting for producer" << endl;
  //    usleep(500000);
  //    gSystem->Sleep(1000);
  //  }
  return -2;
}

//____________________________________
void TFndMonFrame::HandleMouseActions(Int_t event, Int_t x, Int_t y, TObject *selected){

  //cout << "event: " << event << " ===> (" << x << ";" << y << "): " << selected->ClassName() << " -> " << selected->GetName() << endl;
  // 51: move
  // 53: leave pad
  // 52: enter subpad
  //
  //  1: left  click (press left mouse button)
  // 11: left  release (release left mouse button)
  // 61: left  double-click (after "1-11-1" combo)
  // 21: left  drag (keep left mouse button clicked and move mouse)
  //
  //  2: right click (press left mouse button)
  // 12: right release (release left mouse button)
  // 62: right double-click (after "1-11-1" combo)
  //
  //  3: right click (press left mouse button)
  // 13: right release (release left mouse button)
  // 63: right double-click (after "1-11-1" combo)

  //  if(event == 11 && !strcmp(selected->ClassName(),"TH1F"))
  //  cout << "Clicked on " << selected->ClassName() << " " << selected->GetName() << endl;


  switch(event){
    // ------------
    // --- move ---
  case 51: // move inside the canvas (or sub-pads)
    //cout << "Moving on " << selected->ClassName() << " " << selected->GetName() << endl << endl;
    break;
  case 53: // leave the main pad
    break;
  case 52: // enter sub-pad
    break;
    // -------------
    // --- click ---
  case  1: // left click (before releasing mouse button)
    
    break;
    //
  case 11: // left click (after having releasing mouse button)
    
    break;
    //
  case 61: // left double-click
    cout << "Double-click received on object: \"" << selected->ClassName() 
         << "\"; name: \"" << selected->GetName() 
         << "\"; title: \"" << selected->GetTitle() << "\"." << endl;
    
    if(!strncmp(selected->ClassName(),"TH",2)) EnlargeHisto(selected);
    if(!strncmp(selected->ClassName(),"TPave",5)) PrintPaveInfo(selected);
    break;
    //
  default: break;    
  }

}

//____________________________________
void TFndMonFrame::EnlargeHisto(TObject *selected){

  //  if(fMainCanvas[0]) cout << "first  main canvas address: " << fMainCanvas[0] << endl;
  //  if(fMainCanvas[1]) cout << "second main canvas address: " << fMainCanvas[1] << endl;
  delete fBigHis1F; fBigHis1F = 0;
  delete fBigHis2F; fBigHis2F = 0;
  delete fBigHis3F; fBigHis3F = 0;
  delete fBigHis1D; fBigHis1D = 0;

  TString CurDrawOpt = "";
  //  if(!fBigCanvas){
  fBigCanvas = new TCanvas("EnlargedViewCanv1","Big Canvas 1",300,100,1000,750);
  fBigCanvas->ToggleEventStatus();
  // --- canvas main mouse actions management
  fBigRootCanvas = (TRootCanvas*)fBigCanvas->GetCanvasImp();
  fBigRootCanvas->DontCallClose(); // disable manual close
  fBigRootCanvas->Connect("CloseWindow()", "TFndMonFrame", this,"CloseBigCanvas()");
  fBigCanvas->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)","TFndMonFrame",this,"FollowBigCanvas(Int_t,Int_t,Int_t,TObject*)");
  //CurDrawOpt = "";
  //  }
  //  fBigCanvas->cd();
  
  const Char_t *clnam = (Char_t *) selected->ClassName();
  if(!strcmp(clnam,"TH1F")){
    fBigHis1F = (TH1F *)selected->Clone("ZoomedHisto");
    fBigHis1F->SetLineWidth(2);
    fBigHis1F->SetLineColor(2);
    fBigHis1F->SetFillColor(5);
    fBigHis1F->Draw(CurDrawOpt.Data());
  }
  else if(!strcmp(clnam,"TH2F")){
    fBigHis2F = (TH2F *)selected->Clone("ZoomedHisto");
    fBigHis2F->Draw(CurDrawOpt.Data());
  }
  else if(!strcmp(clnam,"TH3F")){
    fBigHis3F = (TH3F *)selected->Clone("ZoomedHisto");
    fBigHis3F->Draw(CurDrawOpt.Data());
  }
  else if(!strcmp(clnam,"TH1D")){
    fBigHis1D = (TH1D *)selected->Clone("ZoomedHisto");
    fBigHis1D->SetLineWidth(2);
    fBigHis1D->SetLineColor(2);
    fBigHis1D->SetFillColor(5);
    fBigHis1D->Draw(CurDrawOpt.Data());
  }
  else{
    fBigCanvas->Close(); delete fBigCanvas; fBigCanvas = 0;
  }

}

//____________________________________
void TFndMonFrame::PrintPaveInfo(TObject *selected){
  
  const Char_t *clnam = (Char_t *) selected->ClassName();
  
  Printf("");
  Printf(" ----------------------------------------");
  Printf(" Selected object general properties:");
  Printf("   Object type: \"%s\"",clnam);
  
  //  if(!strcmp(clnam,"TPaveText")){
  
  if(!strcmp(clnam,"TPaveText")){
    Printf("   Histogram title ====> \"%s\".",((TPaveText *)selected)->GetLine(0)->GetTitle());
  }
  else if(!strcmp(clnam,"TPaveStats")){
    for(Int_t i=0;i<50;i++){
      TText *curtxt = (TText*)(((TPaveText *)selected)->GetListOfLines())->At(i);   
      if(!curtxt) break;
      Printf("   - %s",curtxt->GetTitle());
    }
  }
  //  cout << "   Text Align =======> " << ((TPaveText *)selected)->GetTextAlign() << endl;
  //  cout << "   Text Color =======> " << ((TPaveText *)selected)->GetTextColor() << endl;
  //  cout << "   Text Font ========> " << ((TPaveText *)selected)->GetTextFont() << endl;  
  cout << " ----------------------------------------" << endl;
}

//____________________________________
void TFndMonFrame::CloseBigCanvas(){
  
  fBigCanvas->Close();
  delete fBigCanvas; fBigCanvas = 0;
  //  cout << "The big canvas has just been closed!" << endl;
}

//____________________________________
void TFndMonFrame::CloseMainCanvas(){
  for(Int_t i=0;i<2;i++){
    if(!fMainCanvas[i]) continue;
    delete fDisplayPad[i]; fDisplayPad[i] = 0;
    fMainCanvas[i]->Close();
    delete fMainCanvas[i]; fMainCanvas[i] = 0;
    cout << "Main canvas has just been closed! i = " << i << endl;
  } 
  fClosed = kTRUE;
}

//____________________________________
void TFndMonFrame::FollowBigCanvas(Int_t event, Int_t x, Int_t y, TObject *selected){
  // You can implement this method as you need
  // in order to follow mouse actions in the Canvas with the enlarged histogram.

  //  cout << "event: " << event << " ===> (" << x << ";" << y << "): " << selected->ClassName() << " -> " << selected->GetName() << endl;

}

---