SCC/TFndSCCgui.cxx

// @(#)fROOT/SCC:$Name:  $:$Id: TFndSCCgui.cxx,v 1.43 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/03/03

//                                                    //
//  Class for the FINUDA Slow Control Center main GUI //
//                                                    //


#include "TFndSCCgui.h"

ClassImp(TFndSCCgui)

//_______________________
TFndSCCgui::TFndSCCgui():
  fMainFrame()
{

  fCurPicture = 0;
  fFontType = "-adobe-helvetica-medium-r-*-*-";
  fFontSize = 10;
  fFontISO = "-*-*-*-*-*-iso8859-1";

  UInt_t NewHeightWidth = (Int_t)(Gui::GetTGadj(0) * 109);

  if(gClient){
    fPictureList[0] = gClient->GetPicture("$FROOTSYS/images/fnd_logo.gif",NewHeightWidth,NewHeightWidth);
    fPictureList[1] = gClient->GetPicture("$FROOTSYS/images/CAD_SpectrometerDesign.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[2] = gClient->GetPicture("$FROOTSYS/images/ISIM_OSIM_scheme_3D.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[3] = gClient->GetPicture("$FROOTSYS/images/InteractionRegionScheme.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[4] = gClient->GetPicture("$FROOTSYS/images/LMD_Photo.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[5] = gClient->GetPicture("$FROOTSYS/images/StrawsAssembled.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[6] = gClient->GetPicture("$FROOTSYS/images/TofinoSlabsMontate.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[7] = gClient->GetPicture("$FROOTSYS/images/TofinoSlabsMontateInterno.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[8] = gClient->GetPicture("$FROOTSYS/images/TofinoSlabsMontateInterno_2.jpg",NewHeightWidth,NewHeightWidth);
    fPictureList[9] = gClient->GetPicture("$FROOTSYS/images/Tofone_Assembled.jpg",NewHeightWidth,NewHeightWidth);
  }

  // ---
  TString BaseVocalMessage = "Error detected: ";

  fVocalErrorMessage[TOFI].Form("%s TOFINO",BaseVocalMessage.Data()) ;
  fVocalErrorMessage[TOFO].Form("%s TOFONI",BaseVocalMessage.Data()) ;
  fVocalErrorMessage[LMD].Form("%s DRIFT CHAMBERS",BaseVocalMessage.Data()) ;
  fVocalErrorMessage[STB].Form("%s STRAW TUBES",   BaseVocalMessage.Data()) ;
  fVocalErrorMessage[GAS].Form("%s GAS SYSTEM",    BaseVocalMessage.Data()) ;
  fVocalErrorMessage[SIL].Form("%s SILICON DETECTORS",BaseVocalMessage.Data()) ;
  fVocalErrorMessage[MAG].Form("%s MAGNETIC FIELD",   BaseVocalMessage.Data()) ;
  
  for(Int_t i=0;i<K_N_SLOWS;i++) fLastErrorSolved[i] = kTRUE;
}

//_______________________
TFndSCCgui::~TFndSCCgui(){
  
  //  fMainFrame->Cleanup();
  if(K_DEBUG_LEV > 0) Printf("TFndSCCgui Destructor succesfully called");
}

//_______________________
void TFndSCCgui::Relax(Bool_t more){
  // This method has been added in order
  // to allow GUI operations (for example pressing buttons)
  // while receiving data

  //  unsigned long how_much = 5;
  //  if(more)
  //  how_much = 100;
  //  gSystem->Sleep(how_much);
  //  fMainFrame->Layout(); 
  //  fMainFrame->RequestFocus();
  //gClient->ProcessEventsFor(fMainFrame); // don't use this method within button methods
  gClient->NeedRedraw(fMainFrame);
  if(more) gClient->ProcessEventsFor(fMainFrame); // don't use this method within button methods
}

//_______________________
void TFndSCCgui::BuildGUI(){

  fMainFrame = new TGMainFrame(gClient->GetRoot(),10,10,kMainFrame | kVerticalFrame);
  //
  //  fMainFrame->SetLayoutBroken(kTRUE);
  fMainFrame->SetCleanup(kDeepCleanup);
  // ---

  fCompFrame = new TGCompositeFrame(fMainFrame,10,10,kVerticalFrame);
  fCompFrame->SetLayoutBroken(kTRUE);


  SetFontType(fFontType);
  SetFontSize(18);
  //   fontstring+=(Int_t)(Gui::GetTGadj(1) * 18.);
  //   fontstring+=fFontISO;
  TGFont *u_title_font = gClient->GetFont(fFontString.Data());
  TGGC   *u_title_GC;           
  GCValues_t g_context_title;
  g_context_title.fMask = kGCForeground | kGCBackground | kGCFillStyle | kGCFont | kGCGraphicsExposures;
  gClient->GetColorByName("#000000",g_context_title.fForeground);
  gClient->GetColorByName("#c6c2c6",g_context_title.fBackground);
  g_context_title.fFillStyle = kFillSolid;
  g_context_title.fFont = u_title_font->GetFontHandle();
  g_context_title.fGraphicsExposures = kFALSE;
  u_title_GC = gClient->GetGC(&g_context_title, kTRUE);

  fLblTitle = new TGLabel(fCompFrame,"SCC (the FINUDA Slow Control Center)",u_title_GC->GetGC(),u_title_font->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fCompFrame->AddFrame(fLblTitle, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(1.46,1., 899,29,fLblTitle);

  // Build Control Group frame for all detectors (slow-controls)
  //  enum SlowDetectors_e {TOFI = 0, TOFO, LMD, STB, GAS, SIL, MAG};
  BuildSingleSlwFrame(TOFI);
  BuildSingleSlwFrame(TOFO);
  BuildSingleSlwFrame(LMD);
  BuildSingleSlwFrame(STB);
  BuildSingleSlwFrame(GAS);
  BuildSingleSlwFrame(SIL);
  BuildSingleSlwFrame(MAG);
  for(Int_t i=0;i<K_N_SLOWS;i++) AdjustSingleSlwFrame(i);

  // graphics context changes
  // TGFont will reflect user font changes
  // TGGC will reflect user GC changes
  SetFontType(fFontType);
  SetFontSize(8.7);
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 8.7);
  //   fFontString+=fFontISO;

  TGFont *ufont = gClient->GetFont(fFontString.Data());
  TGGC   *uGC;           
  GCValues_t g_context_default;
  g_context_default.fMask = kGCForeground | kGCBackground | kGCFillStyle | kGCFont | kGCGraphicsExposures;
  gClient->GetColorByName("#000000",g_context_default.fForeground);
  gClient->GetColorByName("#c6c2c6",g_context_default.fBackground);
  g_context_default.fFillStyle = kFillSolid;
  g_context_default.fFont = ufont->GetFontHandle();
  g_context_default.fGraphicsExposures = kFALSE;
  uGC = gClient->GetGC(&g_context_default, kTRUE);

  // "Receivers control" group frame
  fGrpFrmRcvCntrl = new TGGroupFrame(fCompFrame,"Receivers control frame");
  fGrpFrmRcvCntrl->SetLayoutBroken(kTRUE);
  fGrpFrmRcvCntrl->SetTitlePos(TGGroupFrame::kCenter);
 
  fPictBut = new TGPictureButton(fGrpFrmRcvCntrl,fPictureList[0]);
  fGrpFrmRcvCntrl->AddFrame(fPictBut, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(14.6, 22,117,117,fPictBut);
  
  fQuitBut = new TGTextButton(fGrpFrmRcvCntrl,"QUIT");

  SetFontType(fFontType);
  SetFontSize(18.);
//   fFontString+=(Int_t)(Gui::GetTGadj(1) * 18.);
//   fFontString+=fFontISO;
  fQuitBut->SetFont(fFontString.Data(),kTRUE);

  fGrpFrmRcvCntrl->AddFrame(fQuitBut, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(14.6,146, 117,36.5,fQuitBut);

  // --- Single detector SCC run control
  //  enum SlowDetectors_e {TOFI = 0, TOFO, LMD, STB, GAS, SIL, MAG};
  Float_t RunButStart = 150;
  Float_t RunButGap = 19;
  TString StrSet = "";  
  
  for(Int_t i=0;i<K_N_SLOWS+1;i++){
    StrSet="START "; 
    if(i==K_N_SLOWS) StrSet+= "Low voltage";
    else StrSet+=fSlowDetNames[i];
    fButSCCRunReceiver[i] = new TGTextButton(fGrpFrmRcvCntrl,StrSet.Data());
    fGrpFrmRcvCntrl->AddFrame(fButSCCRunReceiver[i], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe(14.6,(RunButStart + RunButGap*(i+2)), 117,18,fButSCCRunReceiver[i]); 
  }

  SetFontType(fFontType);
  SetFontSize(10.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
  //   fFontString+=fFontISO;

  // --- START/STOP ALL receivers buttons
  fButStartAllRcv = new TGTextButton(fGrpFrmRcvCntrl,"START ALL");
  fGrpFrmRcvCntrl->AddFrame(fButStartAllRcv, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fButStartAllRcv->SetFont(fFontString.Data(),kTRUE);
  fButStartAllRcv->SetTextJustify(kTextCenterX);
  Gui::MoveResizeSafe(14.6,360, 117,20,fButStartAllRcv);
  
  fButStopAllRcv = new TGTextButton(fGrpFrmRcvCntrl,"STOP ALL");
  fGrpFrmRcvCntrl->AddFrame(fButStopAllRcv, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fButStopAllRcv->SetFont(fFontString.Data(),kTRUE);
  fButStopAllRcv->SetTextJustify(kTextCenterX);
  Gui::MoveResizeSafe(14.6,385, 117,20,fButStopAllRcv);
  
  // --- Global PrintInfo  button
  fButPrintAllInfo = new TGTextButton(fGrpFrmRcvCntrl,"PRINT ALL INFO");
  fGrpFrmRcvCntrl->AddFrame(fButPrintAllInfo, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));

  fButPrintAllInfo->SetFont(fFontString.Data(),kTRUE);
  fButPrintAllInfo->SetTextJustify(kTextCenterX);
  Gui::MoveResizeSafe(14.6,420, 117,50,fButPrintAllInfo);

  // "SCC 2 DAQ frame" group frame
  fGrpFrmSCC2DAQ = new TGGroupFrame(fCompFrame,"SCC 2 DAQ frame");
  fGrpFrmSCC2DAQ->SetLayoutBroken(kTRUE);
  fGrpFrmSCC2DAQ->SetTitlePos(TGGroupFrame::kCenter);

  // ---

  // ---
  fLblSCCLastEvts = new TGLabel(fGrpFrmSCC2DAQ,"Last 5 events stored");
  fGrpFrmSCC2DAQ->AddFrame(fLblSCCLastEvts, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  SetFontType(fFontType);
  SetFontSize(10.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
  //   fFontString+=fFontISO;
  fLblSCCLastEvts->SetTextFont(fFontString.Data(),kTRUE);
  fLblSCCLastEvts->SetTextJustify(kTextCenterX);
  Gui::MoveResizeSafe(7.3,20, 131.6,14.6,fLblSCCLastEvts);
  // ---
  fLblSCCDateLastEvts = new TGLabel(fGrpFrmSCC2DAQ,"date");
  fGrpFrmSCC2DAQ->AddFrame(fLblSCCDateLastEvts, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fLblSCCDateLastEvts->SetTextFont(fFontString.Data(),kTRUE);
  Gui::MoveResizeSafe(7.3,35, 44, 14.6,fLblSCCDateLastEvts);
  // ---
  fLblSCCTimeLastEvts = new TGLabel(fGrpFrmSCC2DAQ,"time");
  fGrpFrmSCC2DAQ->AddFrame(fLblSCCTimeLastEvts, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fLblSCCTimeLastEvts->SetTextFont(fFontString.Data(),kTRUE);
  Gui::MoveResizeSafe(51,35, 44,14.6,fLblSCCTimeLastEvts);
  // ---
  fLblSCCBytesLastEvts = new TGLabel(fGrpFrmSCC2DAQ,"bytes");
  fGrpFrmSCC2DAQ->AddFrame(fLblSCCBytesLastEvts, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fLblSCCBytesLastEvts->SetTextFont(fFontString.Data(),kTRUE);
  Gui::MoveResizeSafe(95,35, 44,14.6,fLblSCCBytesLastEvts);
  // ---

  Float_t Start_x[3] = {7.3, 51, 95};
  Float_t Start_y = 50.;
  Float_t Gap_y = 14.6;
  Float_t LastEvsTxtSize[2] = {44, 14.6};

  for(Int_t ilast=0;ilast<5;ilast++){
    fTxtSCC_LastDate[ilast] = new TGTextEntry(fGrpFrmSCC2DAQ, new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
    fTxtSCC_LastDate[ilast]->SetMaxLength(255);
    fTxtSCC_LastDate[ilast]->SetAlignment(kTextLeft);
    fTxtSCC_LastDate[ilast]->SetText("--/--/--");
    fGrpFrmSCC2DAQ->AddFrame(fTxtSCC_LastDate[ilast], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe(  Start_x[0], (Start_y + ilast * Gap_y),
                          LastEvsTxtSize[0],LastEvsTxtSize[1],
                          fTxtSCC_LastDate[ilast]);
    
    fTxtSCC_LastTime[ilast] = new TGTextEntry(fGrpFrmSCC2DAQ, new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
    fTxtSCC_LastTime[ilast]->SetMaxLength(255);
    fTxtSCC_LastTime[ilast]->SetAlignment(kTextLeft);
    fTxtSCC_LastTime[ilast]->SetText("--:--:--");
    fGrpFrmSCC2DAQ->AddFrame(fTxtSCC_LastTime[ilast], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe( Start_x[1],(Start_y + ilast * Gap_y),
                         LastEvsTxtSize[0],LastEvsTxtSize[1],
                         fTxtSCC_LastTime[ilast]);
    
    fTxtSCC_LastBytes[ilast] = new TGTextEntry(fGrpFrmSCC2DAQ, new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
    fTxtSCC_LastBytes[ilast]->SetMaxLength(255);
    fTxtSCC_LastBytes[ilast]->SetAlignment(kTextLeft);
    fTxtSCC_LastBytes[ilast]->SetText(" --- ");
    fGrpFrmSCC2DAQ->AddFrame(fTxtSCC_LastBytes[ilast], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe( Start_x[2],(Start_y + ilast * Gap_y),
                         LastEvsTxtSize[0],LastEvsTxtSize[1],
                         fTxtSCC_LastBytes[ilast]);
  }
  
  // ---
  
  // status bar
  fStatusSCC2DAQ = new TGStatusBar(fGrpFrmSCC2DAQ,10,10);
  fGrpFrmSCC2DAQ->AddFrame(fStatusSCC2DAQ, new TGLayoutHints(kLHintsBottom | kLHintsExpandX));
  Gui::MoveResizeSafe(Start_x[0],130, 131.6,14.6,fStatusSCC2DAQ);
  
  // --- 
  fGrpFrmRcvCntrl->SetLayoutManager( new TGVerticalLayout(fGrpFrmRcvCntrl));
  fGrpFrmSCC2DAQ->SetLayoutManager( new TGVerticalLayout(fGrpFrmSCC2DAQ));

  fCompFrame->AddFrame(fGrpFrmRcvCntrl, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  fCompFrame->AddFrame(fGrpFrmSCC2DAQ, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));

  Gui::MoveResizeSafe(750,31, 146,490,fGrpFrmRcvCntrl);
  
  
  Gui::MoveResizeSafe(750,518, 146,160,fGrpFrmSCC2DAQ);
  
  //---------------
  fMainFrame->AddFrame(fCompFrame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));


}

//_______________________
void TFndSCCgui::BuildSingleSlwFrame(Int_t slow_id){


  SetFontType(fFontType);
  SetFontSize(14.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 14.);
  //   fFontString+=fFontISO;
  TGFont *u_subtitle_font = gClient->GetFont(fFontString.Data());
  TGGC   *u_subtitle_GC;
  GCValues_t g_context_subtitle;
  g_context_subtitle.fMask = kGCForeground | kGCBackground | kGCFillStyle | kGCFont | kGCGraphicsExposures;
  gClient->GetColorByName("#000000",g_context_subtitle.fForeground);
  gClient->GetColorByName("#c6c2c6",g_context_subtitle.fBackground);
  g_context_subtitle.fFillStyle = kFillSolid;
  g_context_subtitle.fFont = u_subtitle_font->GetFontHandle();
  g_context_subtitle.fGraphicsExposures = kFALSE;
  u_subtitle_GC = gClient->GetGC(&g_context_subtitle, kTRUE);

  fGrpFrm[slow_id] = new TGGroupFrame(fCompFrame,fSlowDetNames[slow_id],kVerticalFrame,u_subtitle_GC->GetGC(),u_subtitle_font->GetFontStruct());
  fGrpFrm[slow_id]->SetTitlePos(TGGroupFrame::kCenter);
  fGrpFrm[slow_id]->SetLayoutBroken(kTRUE);
  fGrpFrm[slow_id]->SetBackgroundColor(TColor::RGB2Pixel(0xbb,0xbb,0xbb));

  // graphics context changes
  // TGFont will reflect user font changes
  // TGGC will reflect user GC changes
  SetFontType(fFontType);
  SetFontSize(10.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 10);
  //   fFontString+=fFontISO;
  TGFont *ufont = gClient->GetFont(fFontString.Data());
  TGGC   *uGC;           
  GCValues_t g_context_default;
  g_context_default.fMask = kGCForeground | kGCBackground | kGCFillStyle | kGCFont | kGCGraphicsExposures;
  gClient->GetColorByName("#000000",g_context_default.fForeground);
  gClient->GetColorByName("#c6c2c6",g_context_default.fBackground);
  g_context_default.fFillStyle = kFillSolid;
  g_context_default.fFont = ufont->GetFontHandle();
  g_context_default.fGraphicsExposures = kFALSE;
  uGC = gClient->GetGC(&g_context_default, kTRUE);


  fTxtDateMsg[slow_id] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fTxtDateMsg[slow_id]->SetMaxLength(255);
  fTxtDateMsg[slow_id]->SetAlignment(kTextLeft);
  //  fTxtDateMsg[slow_id]->SetText("11/11/11");
  fTxtDateMsg[slow_id]->SetText("--/--/--");
  fGrpFrm[slow_id]->AddFrame(fTxtDateMsg[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(110,15.5, 65.,16,fTxtDateMsg[slow_id]);
  
  fTxtTimeMsg[slow_id] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fTxtTimeMsg[slow_id]->SetMaxLength(255);
  fTxtTimeMsg[slow_id]->SetAlignment(kTextLeft);
  //  fTxtTimeMsg[slow_id]->SetText("11:11:11");
  fTxtTimeMsg[slow_id]->SetText("--:--:--");
  fGrpFrm[slow_id]->AddFrame(fTxtTimeMsg[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(175,15.5, 65.,16,fTxtTimeMsg[slow_id]);
  
  fTxtMsg[slow_id] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fTxtMsg[slow_id]->SetMaxLength(255);
  fTxtMsg[slow_id]->SetAlignment(kTextLeft);
  if(slow_id == SIL) fTxtMsg[slow_id]->SetText("Waiting for first complete buffer...");
  else fTxtMsg[slow_id]->SetText("No data received yet.");
  fGrpFrm[slow_id]->AddFrame(fTxtMsg[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(240,15.5, 500,16,fTxtMsg[slow_id]);
  
  fTxtSockMsg[slow_id] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fTxtSockMsg[slow_id]->SetMaxLength(255);
  fTxtSockMsg[slow_id]->SetAlignment(kTextCenterX);
  fTxtSockMsg[slow_id]->SetText("just created");
  ModifyTextEntry(fTxtSockMsg[slow_id],"Stopped",TColor::RGB2Pixel(0x99,0x99,0x99));
  fGrpFrm[slow_id]->AddFrame(fTxtSockMsg[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(3.,15.5, 102,16,fTxtSockMsg[slow_id]);
  
  fStatusReceiveRun[slow_id] = new TGStatusBar(fGrpFrm[slow_id],10,10);
  fGrpFrm[slow_id]->AddFrame(fStatusReceiveRun[slow_id], new TGLayoutHints(kLHintsBottom | kLHintsExpandX));
  Gui::MoveResizeSafe(3.,35, 102,16,fStatusReceiveRun[slow_id]);
  // ---
  fButPrintInfo[slow_id] = new TGTextButton(fGrpFrm[slow_id],"PRINT INFO");
  fGrpFrm[slow_id]->AddFrame(fButPrintInfo[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  SetFontType(fFontType);
  SetFontSize(10.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
  //   fFontString+=fFontISO;
  fButPrintInfo[slow_id]->SetFont(fFontString.Data(),kTRUE);
  fButPrintInfo[slow_id]->SetTextJustify(kTextCenterX);
  Gui::MoveResizeSafe(3.,52, 102,20,fButPrintInfo[slow_id]);
  
  
  // status bar
  fStatusReceiveMsg[slow_id] = new TGStatusBar(fGrpFrm[slow_id],10,10);
  fGrpFrm[slow_id]->AddFrame(fStatusReceiveMsg[slow_id], new TGLayoutHints(kLHintsBottom | kLHintsExpandX));
  Gui::MoveResizeSafe(110,57, 630,16,fStatusReceiveMsg[slow_id]);
  // ---
  fLblEvtSize[slow_id] = new TGLabel(fGrpFrm[slow_id],"evt size (B):  ");
  SetFontType(fFontType);
  SetFontSize(8);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 6.);
  //   fFontString+=fFontISO;
  fLblEvtSize[slow_id]->SetTextJustify(kTextCenterX);
  fLblEvtSize[slow_id]->SetTextFont(fFontString.Data(),kTRUE);
  fGrpFrm[slow_id]->AddFrame(fLblEvtSize[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(110,35, 80,16,fLblEvtSize[slow_id]);
  
  fTxtEvtSize[slow_id] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
  fTxtEvtSize[slow_id]->SetMaxLength(255);
  fTxtEvtSize[slow_id]->SetAlignment(kTextLeft);
  fTxtEvtSize[slow_id]->SetText("evt size");
  fGrpFrm[slow_id]->AddFrame(fTxtEvtSize[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(190,35, 50,16,fTxtEvtSize[slow_id]);
  
  fGrpFrm[slow_id]->SetLayoutManager( new TGVerticalLayout(fGrpFrm[slow_id]));
  fCompFrame->AddFrame(fGrpFrm[slow_id], new TGLayoutHints(kLHintsLeft | kLHintsCenterX | kLHintsTop,5,5,5,5));
  Gui::MoveResizeSafe(2.2, (29+(83*slow_id)),
                      745, 83,
                      fGrpFrm[slow_id]);
  
}

//_______________________
void TFndSCCgui::AdjustSingleSlwFrame(Int_t slow_id){
  // used for GAS/LMD/(STB?)
  //  enum SlowDetectors_e {TOFI = 0, TOFO, LMD, STB, GAS, SIL, MAG};  // SlowDetectors_e = -1 is used for the "Global Header"

  SetFontType(fFontType);
  SetFontSize(10.);  
  //   fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
  //   fFontString+=fFontISO;
  TGFont *ufont = gClient->GetFont(fFontString.Data());
  TGGC   *uGC;           
  GCValues_t g_context_default;
  g_context_default.fMask = kGCForeground | kGCBackground | kGCFillStyle | kGCFont | kGCGraphicsExposures;
  gClient->GetColorByName("#000000",g_context_default.fForeground);
  gClient->GetColorByName("#c6c2c6",g_context_default.fBackground);
  g_context_default.fFillStyle = kFillSolid;
  g_context_default.fFont = ufont->GetFontHandle();
  g_context_default.fGraphicsExposures = kFALSE;
  uGC = gClient->GetGC(&g_context_default, kTRUE);
  
  TString ind_lbl = "";
  Float_t Lbl1Start = 0;
  Float_t LblW     = 0;
  Float_t IndW     = 0;
  Float_t hgap      = 0;
  
  Float_t cur_pos = 0;

  switch(slow_id){
  case LMD: // add mixture indicator    
    fLmdMixLbl = new TGLabel(fGrpFrm[slow_id],"C(4) H(10) %:");
    fGrpFrm[slow_id]->AddFrame(fLmdMixLbl, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    SetFontType(fFontType);
    SetFontSize(10.);  
    //     fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
    //     fFontString+=fFontISO;
    fLmdMixLbl->SetTextFont(fFontString.Data(),kTRUE);
    Gui::MoveResizeSafe(278,35, 73,14.6,fLmdMixLbl);    
    
    fLmdMixture = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
    fLmdMixture->SetMaxLength(255);
    fLmdMixture->SetAlignment(kTextLeft);
    fLmdMixture->SetText("LMD mix");
    fGrpFrm[slow_id]->AddFrame(fLmdMixture, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe(351,35, 73,14.6,fLmdMixture);
    break;
  case STB: // add mixture indicator
    fStbMixLbl = new TGLabel(fGrpFrm[slow_id],"Argon %:");
    fGrpFrm[slow_id]->AddFrame(fStbMixLbl, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    SetFontType(fFontType);
    SetFontSize(10.);  
    //     fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
    //     fFontString+=fFontISO;
    fStbMixLbl->SetTextFont(fFontString.Data(),kTRUE);
    Gui::MoveResizeSafe(278,35, 73,14.6,fStbMixLbl);
    
    fStbMixture = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
    fStbMixture->SetMaxLength(255);
    fStbMixture->SetAlignment(kTextLeft);
    fStbMixture->SetText("STB mix");
    fGrpFrm[slow_id]->AddFrame(fStbMixture, new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
    Gui::MoveResizeSafe(351,35, 73,14.6,fStbMixture);
    break;
  case GAS: // add security switch indicators
    SetFontType(fFontType);
    SetFontSize(10.);  
    //     fFontString+=(Int_t)(Gui::GetTGadj(1) * 10.);
    //     fFontString+=fFontISO;
    
    Lbl1Start = 280;
    LblW = 40;
    IndW = 35;
    hgap = 7;

    cur_pos = Lbl1Start;
    for(Int_t i=0;i<K_N_SECUR_SWITCHES;i++){
      ind_lbl = "c_";ind_lbl += i;
      fGasSecurLbl[i] = new TGLabel(fGrpFrm[slow_id],ind_lbl.Data());
      fGrpFrm[slow_id]->AddFrame(fGasSecurLbl[i], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
      fGasSecurLbl[i]->SetTextFont(fFontString.Data(),kTRUE);
      Gui::MoveResizeSafe((cur_pos+hgap),35, LblW,14.6,fGasSecurLbl[i]);
      cur_pos = cur_pos + hgap + LblW;
      
      fGasSecurInd[i] = new TGTextEntry(fGrpFrm[slow_id], new TGTextBuffer(15),-1,uGC->GetGC(),ufont->GetFontStruct(),kSunkenFrame | kDoubleBorder | kOwnBackground);
      fGasSecurInd[i]->SetMaxLength(255);
      fGasSecurInd[i]->SetAlignment(kTextLeft);
      fGasSecurInd[i]->SetText("...");
      fGrpFrm[slow_id]->AddFrame(fGasSecurInd[i], new TGLayoutHints(kLHintsLeft | kLHintsTop,5,5,5,5));
      Gui::MoveResizeSafe( cur_pos,35, IndW,14.6,fGasSecurInd[i]);
      cur_pos = cur_pos + hgap + IndW;
    }
    break;
  default: return;
  }

}

//_______________________
void TFndSCCgui::MapGUI(){

  fMainFrame->MapSubwindows();

  Gui::MoveResizeSafe( 2,10,900,675,fMainFrame);

  fMainFrame->MapWindow();
  fMainFrame->DontCallClose();

  // Wait until is really mapped
  while(!fMainFrame->IsMapped() || !fMainFrame->IsMapSubwindows()){
    if(K_DEBUG_LEV > 2) Printf("TFndSCCgui::MapGUI ===> still not mapped");
    usleep(5000);
  }

  fTimer = new TTimer();
  fTimer->Connect("Timeout()","TFndSCCgui",this,"ChangePicture()");
  fTimer->Start( 2000, kFALSE);   // kTRUE:single-shot ; kFALSE:repetitive          
  fTimer->TurnOn();
  //fTimer->TurnOff();

  //  fMainFrame->RequestFocus();
  gClient->ProcessEventsFor(fMainFrame); // don't use this method within button methods

  if(K_DEBUG_LEV > 0) Printf("GUI succesfully mapped.");
}

//_______________________
void TFndSCCgui::MakeConnections(Bool_t ConnectDisconnect){
  
  if(ConnectDisconnect){
    //    fPictBut->Connect("Clicked()","TFndSCCgui",this,"MethodTest()");
    //
    enum SlowDetectors_e {TOFI = 0, TOFO, LMD, STB, GAS, SIL, MAG};  // SlowDetectors_e = -1 is used for the "Global Header"
    
    fButSCCRunReceiver[TOFI]->Connect("Clicked()","TFndSCCgui",this,"StartStopTofi()");
    fButSCCRunReceiver[TOFO]->Connect("Clicked()","TFndSCCgui",this,"StartStopTofo()");
    fButSCCRunReceiver[LMD]->Connect("Clicked()","TFndSCCgui",this,"StartStopLMD()");
    fButSCCRunReceiver[STB]->Connect("Clicked()","TFndSCCgui",this,"StartStopSTB()");
    fButSCCRunReceiver[GAS]->Connect("Clicked()","TFndSCCgui",this,"StartStopGAS()");
    fButSCCRunReceiver[SIL]->Connect("Clicked()","TFndSCCgui",this,"StartStopSIL()");
    fButSCCRunReceiver[MAG]->Connect("Clicked()","TFndSCCgui",this,"StartStopMAG()");
    fButSCCRunReceiver[K_N_SLOWS]->Connect("Clicked()","TFndSCCgui",this,"StartStopLowVolt()"); // Low voltage after all detectors
    //
    
    fButStartAllRcv->Connect("Clicked()","TFndSCCgui",this,"StartAllReceivers()");
    fButStopAllRcv ->Connect("Clicked()","TFndSCCgui",this,"StopAllReceivers()");
    // ---  
    fButPrintInfo[TOFI]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoTofi()");
    fButPrintInfo[TOFO]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoTofo()");
    fButPrintInfo[LMD]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoLMD()");
    fButPrintInfo[STB]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoSTB()");
    fButPrintInfo[GAS]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoGAS()");
    fButPrintInfo[SIL]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoSIL()");
    fButPrintInfo[MAG]->Connect("Clicked()","TFndSCCgui",this,"PrintInfoMAG()");    
    //
    fButPrintAllInfo->Connect("Clicked()","TFndSCCgui",this,"PrintAllInfoFromGUI()");

    //
    fQuitBut->Connect("Clicked()","TFndSCCgui",this,"CloseWindow()");
  }
  else{
    //    fPictBut->Disconnect("Clicked()","TFndSCCgui",this,"MethodTest()");
    //
    fButSCCRunReceiver[0]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopTofi()");
    fButSCCRunReceiver[1]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopTofo()");
    fButSCCRunReceiver[2]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopLMD()");
    fButSCCRunReceiver[3]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopSTB()");
    fButSCCRunReceiver[4]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopGAS()");
    fButSCCRunReceiver[5]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopSIL()");
    fButSCCRunReceiver[6]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopMAG()");
    fButSCCRunReceiver[7]->Disconnect("Clicked()","TFndSCCgui",this,"StartStopLowVolt()");
    //
    fButStartAllRcv->Disconnect("Clicked()","TFndSCCgui",this,"StartAllReceivers()");
    fButStopAllRcv ->Disconnect("Clicked()","TFndSCCgui",this,"StopAllReceivers()");
    // ---  
    fButPrintInfo[0]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoTofi()");
    fButPrintInfo[1]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoTofo()");
    fButPrintInfo[2]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoLMD()");
    fButPrintInfo[3]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoSTB()");
    fButPrintInfo[4]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoGAS()");
    fButPrintInfo[5]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoSIL()");
    fButPrintInfo[6]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoMAG()");
    fButPrintInfo[7]->Disconnect("Clicked()","TFndSCCgui",this,"PrintInfoLowVolt()");
    //  
    fButPrintAllInfo->Disconnect("Clicked()","TFndSCCgui",this,"PrintAllInfoFromGUI()");
    //    
    fQuitBut->Disconnect("Clicked()","TFndSCCgui",this,"CloseWindow()");    
  }

  SayToUser("Slow Control Center ready",1);

}


//_______________________
void TFndSCCgui::EnableConnections(Bool_t enabled){
  
  fPictBut->SetEnabled(enabled);
  //  gClient->ProcessEventsFor(fPictBut);
  
  fQuitBut->SetEnabled(enabled);
  //  gClient->ProcessEventsFor(fQuitBut);
  
  for(Int_t i=0;i<K_N_SLOWS+1;i++){
    fButSCCRunReceiver[i]->SetEnabled(enabled);
    //    gClient->ProcessEventsFor(fButSCCRunReceiver[i]);
  }

}

//_______________________
void TFndSCCgui::StartStopSlowReceiver(Int_t slow_det){
  // Check if the selected thread is running,
  // then set the text of the button and
  // perform the required operation
  
  Int_t is_running = IsReceiveThreadRunning(slow_det);
  TString StrSet = "";
  
  switch (is_running){
  case -1:   
    ResetMessages(slow_det,"start command received",SCC_MSG_RESET_ALL);
    StartReceiveThread(slow_det);
    ModifyTextEntry(fTxtSockMsg[slow_det],"Started",TColor::RGB2Pixel(0x99,0x99,0x99));
    StrSet="STOP "; StrSet+=fSlowDetNames[slow_det];
    fButSCCRunReceiver[slow_det]->SetText(StrSet.Data());
    fStatusReceiveRun[slow_det]->SetText("...running...");
    gClient->NeedRedraw(fButSCCRunReceiver[slow_det]);  // last change
    gClient->NeedRedraw(fStatusReceiveRun[slow_det]);  // last change
    //     gClient->ProcessEventsFor(fButSCCRunReceiver[slow_det]);
    //     gClient->ProcessEventsFor(fStatusReceiveRun[slow_det]);
    return;
  case TThread::kRunningState:
    ResetMessages(slow_det,"stop command received",SCC_MSG_RESET_NORM);
    StopReceiveThread(slow_det);
    ModifyTextEntry(fTxtSockMsg[slow_det],"Stopped",TColor::RGB2Pixel(0x99,0x99,0x99));
    StrSet="START "; StrSet+=fSlowDetNames[slow_det];
    fButSCCRunReceiver[slow_det]->SetText(StrSet.Data());
    fStatusReceiveRun[slow_det]->SetText("...stopped...");
    gClient->NeedRedraw(fButSCCRunReceiver[slow_det]);  // last change
    gClient->NeedRedraw(fStatusReceiveRun[slow_det]);  // last change
    //     gClient->ProcessEventsFor(fButSCCRunReceiver[slow_det]);
    //     gClient->ProcessEventsFor(fStatusReceiveRun[slow_det]);
    return;
  default:    
    StartReceiveThread(slow_det);
    ModifyTextEntry(fTxtSockMsg[slow_det],"IDLE",TColor::RGB2Pixel(0x99,0x99,0x99));
    StrSet="STOP "; StrSet+=fSlowDetNames[slow_det];
    fButSCCRunReceiver[slow_det]->SetText(StrSet.Data());
    fStatusReceiveRun[slow_det]->SetText("...running...");
    gClient->NeedRedraw(fButSCCRunReceiver[slow_det]);  // last change
    gClient->NeedRedraw(fStatusReceiveRun[slow_det]);  // last change
//     gClient->ProcessEventsFor(fButSCCRunReceiver[slow_det]);
//     gClient->ProcessEventsFor(fStatusReceiveRun[slow_det]);
    return;
  } 
}

//_______________________
void TFndSCCgui::SetFontType(TString ftype){

  TString fontstring = ftype;
  fontstring+=(Int_t)(Gui::GetTGadj(1) * (Double_t)(fFontSize));
  fontstring+=fFontISO;
  
  if(!gClient->GetFontPool()->GetFont(fontstring.Data(),0)){
    Warning("SetFontType","selected font is not available: \"%s\"",ftype.Data());
    return;
  }
  fFontType = ftype;
  fFontString = fontstring;
}

//_______________________
void TFndSCCgui::SetFontSize(Float_t fsize){
  // round to the smaller one if not accepted

  Int_t check_size = (Int_t) (Gui::GetTGadj(1) * fsize );
  
  TString fontstring;
  
  Int_t accepted = kFALSE;
  while(!accepted){
    if(check_size <=0){
      Error("SetFontSize","Problems while setting font size: using \"8\".");
      fFontSize = 8;
      fFontString = fFontType;
      fFontString+=fFontSize;
      fFontString+=fFontISO;
      return;
    }
    fontstring = fFontType;
    fontstring+=check_size;
    fontstring+=fFontISO;
    
    accepted = (Int_t)gClient->GetFontPool()->GetFont(fontstring.Data(),0);
    if(K_DEBUG_LEV > 0) Printf("accepted = \"%x\"",accepted);
    if(!accepted){
      Warning("SetFontType","selected font size (\"%d\") not available: trying \"%d\"",check_size,check_size-1);
      check_size--;
    }
  }
  
  fFontSize = check_size; 
  fFontString = fontstring;
}

//_______________________
void TFndSCCgui::ChangePicture(){

  if(!fPictBut){
    Warning("ChangePicture","Can not change picture: Picture-Button not built yet...");
  }
  if(K_DEBUG_LEV > 0) Info("ChangePicture","Changing picture %d",fCurPicture);

  if(fCurPicture < (SCC_PICTURES - 1)) fCurPicture++;
  else fCurPicture = 0;
  fPictBut->SetPicture(fPictureList[fCurPicture]);
  gClient->NeedRedraw(fPictBut);

}

//______________________
void TFndSCCgui::RedrawTextEntry(TGTextEntry *txt_entry){
  
  txt_entry->Deselect();
  gClient->NeedRedraw(txt_entry);
}


//______________________
void TFndSCCgui::ModifyTextEntry(TGTextEntry *txt_entry,const Char_t *text,Pixel_t bck_col,Pixel_t frg_col){

  txt_entry->Clear();
  //  txt_entry->SetCursorPosition(txt_entry->GetCursorPosition());
  txt_entry->SetText(text);
  txt_entry->SetBackgroundColor(bck_col);
  txt_entry->SetForegroundColor(frg_col);

  RedrawTextEntry(txt_entry);
  
  //   txt_entry->Deselect();
  //   gClient->NeedRedraw(txt_entry);
  //  gClient->ProcessEventsFor(txt_entry); 
}

//_________________________
void TFndSCCgui::SetCanReceiveFlag(Int_t can_receive){
  // possible values are:
  //             TFndSCCgui::k_CanReceive
  //             TFndSCCgui::k_WaitReceive
  //             TFndSCCgui::k_DontReceive

  if(can_receive != k_CanReceive && can_receive != k_WaitReceive && can_receive != k_DontReceive){
    Printf("TFndSCCMan::SetCanReceiveFlag BUG: %d value not accepted!",can_receive);
    return;
  }
  fCanReceive = can_receive;
}

//______________________
void TFndSCCgui::ReceivedEvent(Int_t slow_det,Int_t part){  
  // Event reception can be controlled by setting the "fCanReceive" data-member
  // (seet the "SetCanReceiveFlag(Int_t can_emit)" method)

  Int_t sock_idx = SlowId2SockId(slow_det, part);
  //   if(slow_det == SIL) Printf("=============> TFndSCCgui SIL event received",sock_idx);
  
  if(fCanReceive == k_DontReceive){
    if(K_DEBUG_LEV > 0) Printf("TFndSCCgui::ReceivedEvent ===> Can not receive events");    
    return;
  }
  while(fCanReceive == k_WaitReceive) {
    usleep(100000);
    if(K_DEBUG_LEV > 0) Printf("TFndSCCgui::ReceivedEvent ===> Waiting for GUI to be idle");
  }

  if(K_DEBUG_LEV > 0)  Printf("MySCCTest ReceivedEvent method: slow_det = %d",slow_det);
  ModifyTextEntry(fTxtSockMsg[slow_det],"RECEIVING",TColor::RGB2Pixel(0xff,0xff,0x00),TColor::RGB2Pixel(0x00,0x00,0xee));
  usleep(250000);
  ModifyTextEntry(fTxtSockMsg[slow_det],"WAITING");
  // ---
  TString DateString = "";
  TString TimeString = "";
  TDatime curtime;
  curtime.Set();
  DateString=curtime.AsString();
  DateString.Resize(DateString.Sizeof()-14);
  //
  TimeString=curtime.AsSQLString();
  TimeString.Remove(0, 11);  
  //

  ModifyTextEntry(fTxtDateMsg[slow_det],DateString.Data());
  ModifyTextEntry(fTxtTimeMsg[slow_det],TimeString.Data());
  // ---
  TString message = GetMessagePart(slow_det);
  //
  if(message.IsNull() && slow_det != SIL){
    ModifyTextEntry(fTxtMsg[slow_det],"NO MESSAGE RECEIVED.");
    return;
  }
  if(slow_det == SIL && !IsDataReady(slow_det) ) message+=" (complete data not available)";
  //

  ModifyTextEntry(fTxtMsg[slow_det],message.Data());
  TString sizestr = ""; sizestr+= fSingleRawData[slow_det][HdrDet_evlen];
  ModifyTextEntry(fTxtEvtSize[slow_det],sizestr.Data());

  // --- Change background color depending on the error message
  TString CmpStr[3] = {0};
  CmpStr[0] = "ok";
  CmpStr[1] = "warning";
  CmpStr[2] = "error";

  TString grep_str[4];
  grep_str[0] = "New pedestals run required";
  grep_str[1] = "warning  Dig IO: Watchdog switched off";
  grep_str[2] = "Error AIR%>20%";
  grep_str[3] = " (complete data not available)"; // still not used

  Int_t i = 0;
  for(i=0;i<3;i++){
    if(!strncasecmp(CmpStr[i],message.Data(),CmpStr[i].Sizeof()-1)) break;
  }

  Float_t stb_argon = 0; // used by STB
  Float_t stb_ethan = 0; // used by STB
  Float_t ar_perc = 0;  // used by STB


  TString err_chk = "";
  TRegexp r = TRegexp("\".*\""); //. select errors between \"\" (included)
  Bool_t upd_err = kTRUE;

  Bool_t upd_solved = kFALSE;

  switch(i){
  case 0: // ok
    fLastError[slow_det] = "";
    fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xff,0xff,0xff));
    fTxtMsg[slow_det]->SetForegroundColor(TColor::RGB2Pixel(0x01,0x01,0x01));
    if( fLastErrorSolved[slow_det] == kFALSE){
      fLastErrorSolved[slow_det] = kTRUE;
      upd_solved = kTRUE;
    }
    break;
  case 1: // warning
    fLastError[slow_det] = "";
    fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xff,0xff,0x99));
    fTxtMsg[slow_det]->SetForegroundColor(TColor::RGB2Pixel(0x00,0x00,0x88));
    if( fLastErrorSolved[slow_det] == kFALSE){
      fLastErrorSolved[slow_det] = kTRUE;
      upd_solved = kTRUE;
    }
    break;
  case 2: // error
    fLastErrorSolved[slow_det] = kFALSE;
    if(!fLastError[slow_det].IsNull()){
      err_chk = fLastError[slow_det](r);
      if(!err_chk.IsNull() && err_chk.CompareTo(message.Data()) ){
        //Printf(" =============> %s ---> %d %s",fLastError[slow_det].Data(),slow_det,err_chk.Data());
        //Printf("            ===> SAME ERROR MESSAGE DETECTED <===");
        upd_err = kFALSE;
      }
    }
    
    if(upd_err){
      fLastError[slow_det] = curtime.AsString();
      fLastError[slow_det]+=": \""; fLastError[slow_det]+=message.Data(); fLastError[slow_det]+="\".";
      if(slow_det != (Int_t) GAS ) ScheduledOperation();
    }
    fStatusReceiveMsg[slow_det]->SetText(fLastError[slow_det].Data());
    //
    fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xff,0x00,0x33));
    fTxtMsg[slow_det]->SetForegroundColor(TColor::RGB2Pixel(0x01,0x01,0x01));
    

    // --- Support for Vocal messages
    if(slow_det != (Int_t) GAS ) SayToUser(fVocalErrorMessage[slow_det],1);
    //    SayToUser("Error");
    break;
  default:Printf("TFndSCCgui::ReceivedEvent ===> Selection: %d not available",i);
  }

  if(upd_solved) ScheduledOperation();

  // Custom colors for exceptions 
  if( message.Contains(grep_str[0].Data()) ) fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xff,0x77,0x24));   // SIL
  if( !message.CompareTo(grep_str[1].Data()) ) fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xe0,0xff,0xff)); // SIL
  if( !message.CompareTo(grep_str[2].Data()) ) fTxtMsg[slow_det]->SetBackgroundColor(TColor::RGB2Pixel(0xe0,0xff,0xff)); // GAS

  fTxtMsg[slow_det]->Deselect();
  gClient->NeedRedraw(fTxtMsg[slow_det]);
  
  // --- Adds on
  TString Num2Txt_tmp = ""; // string buffer for the current misc info
  switch(slow_det){
  case LMD: // add mixture indicator    
    Num2Txt_tmp = ""; Num2Txt_tmp.Form("%.2f",
                                       ( (Float_t)GetMiscInfo(slow_det,0)) / 100
                                       );

    fLmdMixture->SetText(Num2Txt_tmp.Data());
    gClient->NeedRedraw(fLmdMixture);
    break;
  case STB: // add mixture indicator
    stb_argon = GetMiscInfo(slow_det,3);
    stb_ethan = GetMiscInfo(slow_det,2);
    ar_perc = 100 *(Float_t)( stb_argon / (stb_argon + stb_ethan) );
    //    Num2Txt_tmp = ""; Num2Txt_tmp+= ar_perc;
    Num2Txt_tmp = ""; Num2Txt_tmp.Form("%.2f",ar_perc);

    fStbMixture->SetText(Num2Txt_tmp.Data());
    gClient->NeedRedraw(fStbMixture);
    break;
  case GAS: // add security switch indicators
    for(Int_t i=0;i<K_N_SECUR_SWITCHES;i++){
      Num2Txt_tmp = ""; Num2Txt_tmp+= GetMiscInfo(slow_det,i);
      fGasSecurInd[i]->SetText(Num2Txt_tmp.Data());
      gClient->NeedRedraw(fGasSecurInd[i]);
    }
    break;
  default: return;
  }


  if(K_DEBUG_LEV > 0) Printf("Selection: %d (%s)",i,CmpStr[i].Data());
  Relax(0);

}

//______________________
void TFndSCCgui::SocketError(Int_t slow_det){
  
  if(K_DEBUG_LEV > 1) Printf("MySCCTest SocketError method: slow_det = %d",slow_det);
  ModifyTextEntry(fTxtSockMsg[slow_det],"SOCKET ERROR",TColor::RGB2Pixel(0xff,0x33,0x00),TColor::RGB2Pixel(0xff,0xff,0x00));

}

//_______________________
void TFndSCCgui::DisableTxtEntry(TGTextEntry *txt_entry){
  // Called by DTOR in order to avoid segmentation faults
  // (cursor may be active in some text entries)

  txt_entry->Clear();
  txt_entry->SetEnabled(kFALSE);
  gClient->ProcessEventsFor(txt_entry); 
  usleep(25000);
}

//_______________________
void TFndSCCgui::CloseWindow(){
  // Called when window is closed via the window manager.
  

  if(fTimer) fTimer->TurnOff();
  delete fTimer;
  fTimer = 0;

  SetCanReceiveFlag(k_DontReceive);
  gClient->ProcessEventsFor(fMainFrame);
  gSystem->Sleep(300);
  gClient->ProcessEventsFor(fMainFrame);

  // --- (Adds on)
  DisableTxtEntry(fLmdMixture);
  DisableTxtEntry(fStbMixture);
  for(Int_t i=0;i<K_N_SECUR_SWITCHES;i++) DisableTxtEntry(fGasSecurInd[i]);

  for(Int_t i=0;i<K_N_SLOWS;i++){ // important to avoid segmentation faults
    DisableTxtEntry(fTxtSockMsg[i]);
    //
    DisableTxtEntry(fTxtDateMsg[i]);
    DisableTxtEntry(fTxtTimeMsg[i]);
    DisableTxtEntry(fTxtMsg[i]);
    //
    DisableTxtEntry(fTxtEvtSize[i]);
  }

  gClient->ProcessEventsFor(fMainFrame);
  fMainFrame->Cleanup();
  fMainFrame->SendCloseMessage();
  gClient->ProcessEventsFor(fMainFrame);

  if(K_DEBUG_LEV > 1) Printf("TFndSCCgui::CloseWindow ---> Now stopping all threads");
  StopAllThreads();
  if(K_DEBUG_LEV > 1) Printf("TFndSCCgui::CloseWindow ---> ...done.");

  if(K_DEBUG_LEV > 1) Printf("Main Window Closed");
  Printf("...Good bye");
  SayToUser("Bye bye",1);
  gApplication->Terminate(0);
  return;
}

//_______________________
void TFndSCCgui::ResetMessages(Int_t slow_det, TString default_msg,Scc_Msg_Reset_e reset_mode){
  
  TString DateString = "";
  TString TimeString = "";
  TDatime curtime;
  curtime.Set();
  DateString=curtime.AsString();
  DateString.Resize(DateString.Sizeof()-14);
  //
  TimeString=curtime.AsSQLString();
  TimeString.Remove(0, 11);  
  //
  
  ModifyTextEntry(fTxtSockMsg[slow_det],default_msg);
  fStatusReceiveRun[slow_det]->SetText("...idle...");
  ModifyTextEntry(fTxtDateMsg[slow_det],DateString.Data());
  ModifyTextEntry(fTxtTimeMsg[slow_det],TimeString.Data());
  ModifyTextEntry(fTxtMsg[slow_det],default_msg);
 
  if(reset_mode == SCC_MSG_RESET_ALL) fStatusReceiveMsg[slow_det]->SetText("");
}

//_______________________
void TFndSCCgui::ResetMessages(TString default_msg,Scc_Msg_Reset_e reset_mode){
  
  for(Int_t slow_det = (Int_t)TOFI;slow_det <= (Int_t)MAG; slow_det++){
    ResetMessages(slow_det,default_msg,reset_mode);
  }
  
}

// SEND management
//_______________________
// void TFndSCCgui::PerformingScheduledOperation() { 
//   // Automatically called by receiver threads
  


//   fStatusSCC2DAQ->SetText("Building data");
//   fStatusSCC2DAQ->SetBackgroundColor(TColor::RGB2Pixel(0xff,0xff,0x99));
//   gClient->NeedRedraw(fStatusSCC2DAQ);
//   //  gClient->ProcessEventsFor(fStatusSCC2DAQ);

//   gSystem->Sleep(700);
  
// }

//_______________________
void TFndSCCgui::ScheduledOperationPerformed(E_SCC_MAN_GuiComm_t oper,Bool_t UpdateTime){
  // Automatically called by receiver threads

  // ---
  TString DateString = "";
  TString TimeString = "";
  TDatime curtime;
  curtime.Set();
  DateString=curtime.AsString();
  DateString.Resize(DateString.Sizeof()-14);
  DateString.Remove(0,4);
  //
  TimeString=curtime.AsSQLString();
  TimeString.Remove(0, 11);  
  // ---
  TString BytesString = "0";
  BytesString.Form("%u",fGlobalEvent[HdrTot_EvLen]);
 
  // --- status bar information 

  switch(oper){
  case E_SCC_MAN_GuiComm_Building:
    break;
    //
  case E_SCC_MAN_GuiComm_Stored:
    fStatusSCC2DAQ->SetText("");
    fStatusSCC2DAQ->SetBackgroundColor(TColor::RGB2Pixel(0xff,0xa0,0x4f));
    gClient->NeedRedraw(fStatusSCC2DAQ);
    usleep(300000);

    fStatusSCC2DAQ->SetText("Data stored");
    fStatusSCC2DAQ->SetBackgroundColor(TColor::RGB2Pixel(0xff,0xa5,0x4f));
    gClient->NeedRedraw(fStatusSCC2DAQ);

    //   TThread::Sleep(300,0);
    usleep(300000);
    break;
    //
  case E_SCC_MAN_GuiComm_Sent:
    fStatusSCC2DAQ->SetText("Data sent");
    fStatusSCC2DAQ->SetBackgroundColor(TColor::RGB2Pixel(0xff,0x77,0x24));
    gClient->NeedRedraw(fStatusSCC2DAQ);
    
    //    TThread::Sleep(300,0);
    usleep(300000);
    break;
  
  case E_SCC_MAN_GuiComm_Idle:
    fStatusSCC2DAQ->SetText("idle");
    fStatusSCC2DAQ->SetBackgroundColor(TColor::RGB2Pixel(0xaa,0xff,0x99));
    gClient->NeedRedraw(fStatusSCC2DAQ);
     break;
  default:
    Error("ScheduledOperationPerformed","operation \"%d\" not defined",oper);
    return;
  }

  Relax(0);

  if(UpdateTime){
    // --- text entries
    for(Int_t i=SCC_SUMMARY_NUM-1;i>0;i--){
      ModifyTextEntry(fTxtSCC_LastDate[i], fTxtSCC_LastDate[i-1] ->GetText() );
      ModifyTextEntry(fTxtSCC_LastTime[i], fTxtSCC_LastTime[i-1] ->GetText() );
      ModifyTextEntry(fTxtSCC_LastBytes[i],fTxtSCC_LastBytes[i-1] ->GetText() );
    } 
    
    ModifyTextEntry(fTxtSCC_LastDate[0],DateString.Data());
    ModifyTextEntry(fTxtSCC_LastTime[0],TimeString.Data());
    ModifyTextEntry(fTxtSCC_LastBytes[0],BytesString.Data());
  }
  else { // no change: just a GUI update
    for(Int_t i=SCC_SUMMARY_NUM-1;i>0;i--){
      RedrawTextEntry(fTxtSCC_LastDate[i]);
      RedrawTextEntry(fTxtSCC_LastTime[i]);
      RedrawTextEntry(fTxtSCC_LastBytes[i]);
    } 
  }

  return;
}

---