GUI/TFndGeb2hdtGUI.cxx

// @(#)fROOT/GUI:$Name:  $:$Id: TFndGeb2hdtGUI.cxx,v 1.24 2007/09/07 15:37:19 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/06/05

#include "TApplication.h"

#include "TFndGeb2hdtGUI.h"

  ClassImp(TFndGeb2hdtGUI)

//_____________________________
TFndGeb2hdtGUI::TFndGeb2hdtGUI():
  TGMainFrame(gClient->GetRoot(),100,100),
  fCurMan()
{
//   SetLayoutBroken(kTRUE);
//   SetCleanup(kDeepCleanup);

}

//_____________________________
TFndGeb2hdtGUI::TFndGeb2hdtGUI(TFndGeb2hdtMan *Geb2hMan):
  TGMainFrame(gClient->GetRoot(),100,100),
  fCurMan()
{
  fCurMan = Geb2hMan;
}

//_____________________________
TFndGeb2hdtGUI::~TFndGeb2hdtGUI(){
  
  Cleanup();
}

//_____________________________
void TFndGeb2hdtGUI::CloseWindow(){
  
  Info("TFndGeb2hdtGUI::CloseWindow","   ...closing GUI..."); 
  delete this;
}

//_____________________________
void TFndGeb2hdtGUI::BuildGUI(){
 
  //  TThread::Lock();
  Info("BuildGUI","Building GUI");
  Bool_t is_online = kFALSE;

  if(!fCurMan){
    Error("BuildGUI","This GUI is not useful without a manager (TFndGeb2hdtMan)");
    return;
  }
  is_online = fCurMan->GetOnlFlag();
  
  //--------- buttons (in fButFrame) ---------//
  fButFrame = new TGVerticalFrame(this);
  fStopBut =  new TGTextButton(this, "&STOP", 1);
  fPauseBut = new TGTextButton(this, "&PAUSE", 2);

  if(is_online){ // shared memories reset in online-mode only
    fResetGtsBut = new TGTextButton(this, "&Reset GTS", 3);
    fResetTofBut = new TGTextButton(this, "&Reset TOF", 4);
    fResetSilBut = new TGTextButton(this, "&Reset SIL", 5);
    fResetLmdBut = new TGTextButton(this, "&Reset LMD", 6);
    fResetStbBut = new TGTextButton(this, "&Reset STB", 7);
  }
  
  
  fTextGroup = new TGGroupFrame(this, "Producer real-time messages", kVerticalFrame);
  fTextGroup->SetTitlePos(TGGroupFrame::kCenter);
  // ---
  fTextMessages = new TGTextEntry(fTextGroup,"...initializing monitor producer...");
  fTextMessages->SetAlignment(kTextCenterX);

  fTextGroup->AddFrame(fTextMessages, new TGLayoutHints(kLHintsExpandX, 0, 0, 20, 5));
  
  fButFrame->AddFrame(fStopBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 20));
  fButFrame->AddFrame(fPauseBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 20));
  if(is_online){ // shared memories reset in online-mode only
    fButFrame->AddFrame(fResetGtsBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 5));
    fButFrame->AddFrame(fResetTofBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 5));
    fButFrame->AddFrame(fResetSilBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 5));
    fButFrame->AddFrame(fResetLmdBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 5));
    fButFrame->AddFrame(fResetStbBut, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 5));
  }
  // ---
  fButFrame->AddFrame(fTextGroup, new TGLayoutHints(kLHintsExpandX, 0, 0, 20, 5));
  fButFrame->Resize(fButFrame->GetDefaultSize());
  
  AddFrame(fButFrame, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 20));
  SetWindowName("Producer Control");
  
  DontCallClose(); 
  //  MoveResizeSafe(5,150,300,500,this);
  Resize(GetDefaultSize());

  //   if(is_online)  MoveResizeSafe(5,150,250,350,this);
  //   else           MoveResizeSafe(5,150,250,150,this);
  

  MakeConnections();

  Info("BuildGUI","GUI built");

  RemapMainWindow();
  is_online ? MoveResizeSafe(5,130,250,550,this) : MoveResizeSafe(5,130,250,350,this);
  
  RemapMainWindow();
  usleep(300000);
  
  if(is_online) WriteTextMessage("...checking socket connection...");
  else WriteTextMessage("...initializing producer for file...");

  Info("BuildGUI","GUI re-mapped");

  //  Connect("HandleEvent(Event_t* event)","TFndGeb2hdtGUI",this,"HandleMouseActions(Event_t*)");

  //   SetDragType(0);
  //   SetDropType(0);
  //   SetEditable(0);
  //  gClient->GetRoot()->SetEditable(kFALSE);
  
  //   fResetGtsBut->SetState(kButtonDisabled);
  //   fResetTofBut->SetState(kButtonDisabled);
  //   fResetSilBut->SetState(kButtonDisabled);
  //   fResetLmdBut->SetState(kButtonDisabled);
  //   fResetStbBut->SetState(kButtonDisabled);
  
  //   fTextMessages;
  //  TThread::UnLock();
  return;
}

//____________________________________
// void TFndGeb2hdtGUI::HandleMouseActions(Event_t *event){

  
//   cout << "Event " << event << endl;

// }

//_____________________________
void TFndGeb2hdtGUI::MakeConnections(){

  Bool_t is_online = kFALSE;

  if(!fCurMan){
    Error("MakeConnections","If you are reading this message you just have found a BUG!");
    gApplication->Terminate();
  }
  is_online = fCurMan->GetOnlFlag();

  fCurMan->Connect("SendRealTimeInfo(Int_t)","TFndGeb2hdtGUI",this,"ReceiveRealTimeInfo(Int_t)");
  
  // --- buttons
  fStopBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "StopProducer()");
  fPauseBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "PauseProducer()");
  
  if(is_online){ // shared memories reset in online-mode only
    fResetGtsBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "ResetGts()");
    fResetTofBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "ResetTof()");
    fResetSilBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "ResetSil()");
    fResetLmdBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "ResetLmd()");
    fResetStbBut->Connect("Clicked()", "TFndGeb2hdtMan", fCurMan, "ResetStb()");
  }

}

//______________________________________________________________________________
void TFndGeb2hdtGUI::RemapMainWindow(){

  Layout();
  MapSubwindows();
  MapWindow();
  //   gClient->NeedRedraw(this);
  //   gClient->ProcessEventsFor(this);
}

//______________________________________________________________________________
void TFndGeb2hdtGUI::WriteTextMessage(TString msg){
  
  fTextMessages->SetText(msg);
  gClient->NeedRedraw(fTextMessages);
  gClient->ProcessEventsFor(fTextMessages);
}

//______________________________________________________________________________
void TFndGeb2hdtGUI::FlashTextMessage(TString msg,TString next_msg,Int_t time_ms){
  // used to display a message for "time_ms" milliseconds
  // if next_msg is passed, it will be displayed after flashing "msg"
  // otherwise the previous message will be used
  
  TString prev_msg = fTextMessages->GetText();
  //   Info("FlashTextMessage","     msg: \"%s\"",msg.Data());
  //   Info("FlashTextMessage","prev_msg: \"%s\"",prev_msg.Data());
  if(next_msg.IsNull()) next_msg = prev_msg;
  //   Info("FlashTextMessage","next_msg: \"%s\"",next_msg.Data());
  
  WriteTextMessage(msg);
  gSystem->Sleep(time_ms);
  //   gClient->NeedRedraw(this);
  //   gClient->ProcessEventsFor(this);
  WriteTextMessage(next_msg);

}

//______________________________________________________________________________
void TFndGeb2hdtGUI::ReceiveRealTimeInfo(Int_t Info_id){
  // Values of Info_id are described in GUI::EFndGeb2hdt_GuiInfo
  // remember to check for "TFndGeb2hdtMan::fIstop" and "TFndGeb2hdtMan::fManStop" in case of "Info_id==G2H_INFO_FINISH_RUN"
  //
  // Get the signal from TFndGeb2hdtMan::PrintInfo and check the number of events!

  //  TThread::Lock();

  if(gClient) gClient->SetEditDisabled(kTRUE);
  Info("ReceiveRealTimeInfo","Real-Time Information received (id: %d)",Info_id);
  TString info_msg;

  switch(Info_id){
  case G2H_INFO_NO_ANSWER:            // no answer from DAQ
    WriteTextMessage("No answer received from DAQ: retrying...");
    break;
  case G2H_INFO_SEND_REQ_TO_DAQ:      // sending a new request for events to DAQ
    WriteTextMessage("Sending new event request to DAQ...");
    break;
    case G2H_INFO_CONNECTING_DB:      // connecting to the required DB host
      //      WriteTextMessage("Connecting to database");
    break;
    case G2H_INFO_DB_CONN_CLOSED:     // connection to database completed
      //      WriteTextMessage("Database information stored");
    break;
  case G2H_INFO_CAN_START_CONS:       // any consumer can start
    WriteTextMessage("Consumers can start");
    break;
  case G2H_INFO_EV_LOOP_START:        // event-loop just started
    WriteTextMessage("Starting event loop...");
    break;
  case G2H_INFO_SEND_FIRST_REQ:       // sending request for the first event
    WriteTextMessage("Sending request for first event");
    break;
  case G2H_INFO_STARTING_MONITORS:    // starting producer monitors
    WriteTextMessage("Monitors (histogram filling) Started");
    break;
  case G2H_INFO_FILLING_MONITORS:     // filling producer monitors
    WriteTextMessage("Filling monitor histograms");
    break;
  case G2H_INFO_UPDATING_PROD_SHR:    // updating producer shared memories
    info_msg.Form("Run %d - ev. %d (%u ev. tot)",
                  fndrun->GetCurOnlineRunNmber(),
                  fndrun->GetEvNum_Raw(),
                  fCurMan->GetCurrentEvent());
    
    //     if(fCurMan->GetRate() > 0){
    //       info_msg.Form("Run %d - ev. %d (running at %d ev/s)",
    //              fndrun->GetCurOnlineRunNmber(),
    //              fCurMan->GetCurrentEvent(),
    //              fCurMan->GetRate());
    //     }
    //     else{ 
    //       info_msg.Form("Run %d - ev. %d",fndrun->GetCurOnlineRunNmber(),fCurMan->GetCurrentEvent());
    //     }
    
    FlashTextMessage("Updating producer shared memories",info_msg.Data());
    //WriteTextMessage(info_msg.Data());
    break;
  case G2H_INFO_PAUSED:               // producer event-loop paused
    WriteTextMessage("PAUSED");
    break;
  case G2H_INFO_RESTARTED:            // producer event-loop restarted
    WriteTextMessage("Producer restarted");
    break;
  case G2H_INFO_TIMED_OUT:            // producer process has timed-out: exiting
    WriteTextMessage("Current geb2hdt process has timed out");
    break;
  case G2H_INFO_FINISH_RUN:           // run completed (performing end-of-run operations)
    WriteTextMessage("Current run completed: exiting...");
    break;
  case G2H_INFO_STOPPING:             // stopping current producer (normally due to a button action)
    WriteTextMessage("Stopping producer: please wait...");
    break;
  case G2H_INFO_EXITING:              // all producer processes completed: exiting froot
    WriteTextMessage("Cleaning memory...please wait.");
    break;
  case G2H_INFO_PRINT:                // printing information about the running producer
    if(fndrun->GetEvNum_Raw() == 0) break;
    info_msg.Form("Run %d - ev. %d (%u ev. tot)",
                  fndrun->GetCurOnlineRunNmber(),
                  fndrun->GetEvNum_Raw(),
                  fCurMan->GetCurrentEvent());
    
    //     if(fCurMan->GetRate() > 0){
    //       info_msg.Form("Run %d - ev. %d (running at %d ev/s)",
    //              fndrun->GetCurOnlineRunNmber(),
    //              fCurMan->GetCurrentEvent(),
    //              fCurMan->GetRate());
    //     }
    //     else{ 
    //       info_msg.Form("Run %d - ev. %d",fndrun->GetCurOnlineRunNmber(),fCurMan->GetCurrentEvent());
    //     }
    
    FlashTextMessage("Writing info (GUI)",info_msg.Data());
    //WriteTextMessage(info_msg.Data());
    break;
  case G2H_INFO_RESET_GTS:            // reset GTS producer histograms
    FlashTextMessage("...resetting GTS histograms...");
    break;
  case G2H_INFO_RESET_TOF:            // reset TOF producer histograms
    FlashTextMessage("...resetting TOF histograms...");
    break;
  case G2H_INFO_RESET_SIL:            // reset SIL producer histograms
    FlashTextMessage("...resetting SIL histograms...");
    break;
  case G2H_INFO_RESET_LMD:            // reset LMD producer histograms
    FlashTextMessage("...resetting TOF histograms...");
    break;
  case G2H_INFO_RESET_STB:            // reset STB producer histograms
    FlashTextMessage("...resetting STB histograms...");
    break;
  default:
    WriteTextMessage("ERROR (maybe a bug!)");
    Error("ReceiveRealTimeInfo","Received information not accepted.");
    return;
  }
  //  gClient->ProcessEventsFor(this);

  //  TThread::UnLock();

  if(gClient) gClient->SetEditDisabled(kFALSE);
  return;
}

---