BesClient.cxx

Go to the documentation of this file.

//
// BesClient.cxx
//
 
#include "BesClient.h"
#include "BesAboutHelp.h"
#include "BesMdcPalette.h"
#include "BesVisLib/BesCursor.h"
#include "BesVisLib/BesVisDisplay.h"
#include <fstream>
#include <iostream>
#include <sstream>
 
#include <TASImage.h>
#include <TApplication.h>
#include <TBranch.h>
#include <TCanvas.h>
#include <TColor.h>
#include <TFile.h>
#include <TG3DLine.h>
#include <TGButton.h>
#include <TGButtonGroup.h>
#include <TGCanvas.h>
#include <TGFileDialog.h>
#include <TGLabel.h>
#include <TGLayout.h>
#include <TGListTree.h>
#include <TGMenu.h>
#include <TGMsgBox.h>
#include <TGNumberEntry.h>
#include <TGProgressBar.h>
#include <TGSlider.h>
#include <TGSplitter.h>
#include <TGStatusBar.h>
#include <TGTab.h>
#include <TGTextBuffer.h>
#include <TGTextEntry.h>
#include <TGeoManager.h>
#include <TGeometry.h>
#include <TInterpreter.h>
#include <TList.h>
#include <TRootEmbeddedCanvas.h>
#include <TSystem.h>
#include <TTimer.h>
#include <TTree.h>
#include <TView.h>
#include <TViewerX3D.h>
// tianhl, TViewerOpneGL has been removed; waiting for new Class
// #include <TViewerOpenGL.h>
#include <TGLViewer.h>
#include <TVirtualViewer3D.h>
// #include <TGLEditor.h>
#include <TRootDialog.h>
#include <TRootHelpDialog.h>
#include <TVirtualGL.h>
#include <TVirtualGeoPainter.h>
 
#include "BesVisLib/DstConvert.h" //Long Peixun's update: Convert Dst to Rec
#include "RootEventData/TDigiEvent.h"
#include "RootEventData/TDisTrack.h"
#include "RootEventData/TRecEvTime.h"
#include "RootEventData/TRecTrackEvent.h"
using namespace std;
 
// #ifndef __CINT__
ClassImp( BesClient )
    // #endif
 
    // Long Peixun's update: Remove help text in program
    /* const char gHelpBesVis[] = "\
                               PRESS \n\
                               \tg\t--- save graph\n\
                               \tn\t--- next event\n\
                               \tp\t--- previous event\n\n\
                               \tw\t--- move up\n\
                               \ta\t--- move left\n\
                               \ts\t--- move down\n\
                               \td\t--- move right\n\n\
                               \tq\t--- zoom out\n\
                               \te\t--- zoom in\n\n" //hehe, too long string literal :)))
                               "\n\
                               Add more..."; */
 
    const char* OpenGeoTypes[] = { "ROOT files", "*.root", "GDML files", "*.gdml", 0, 0 };
 
// Long Peixun's update: adjust the order of file types
const char* SaveGeoTypes[] = { "ROOT files", "*.root", "REC files", "*.rec", 0, 0 };
 
// Long Peixun's update: adjust the order of file types
const char* OpenEventTypes[] = { "rec files", "*.rec", "raw files", "*.rtraw", "dst files",
                                 "*.dst", // Long Peixun's update: Allow dst files
                                 "ROOT files", "*.root",
                                 // #ifdef CF__ZSMSM
                                 //"Generic Adamo files", "*.cz",    //Long Peixun's update:
                                 // remove unsupported file
                                 // #endif
                                 0, 0 };
 
const char* SavePicTypes[] = { "GIF",  "*.gif",  "JPG", "*.jpg", "PS",  "*.ps",
                               "EPS",  "*.eps",  "XPM", "*.xpm", "PNG", "*.png",
                               "TIFF", "*.tiff", 0,     0 };
 
const char* SavePicPS[] = { "PS", "*.ps", 0, 0 };
 
// Long Peixun's update: for BesVis style file
const char* StyleTypes[] = { "Text file", "*.txt", 0, 0 };
 
extern char* optarg;
extern int   optint, opterr;
 
struct sembuf acquire = { 0, -1, SEM_UNDO };
struct sembuf release = { 0, 1, SEM_UNDO };
 
//__________________________________________________________________
// BesClient
// Bes event display client
//
//
BesClient::BesClient( const TGWindow* p, const char* title, UInt_t width, UInt_t height,
                      Option_t* option, Int_t argc, char** argv )
    : TGMainFrame( p, width, height ) {
 
  //
  // BesClient default contructor
  if ( gDebug ) cout << "BesClient ctor called" << endl;
 
  //// acquire semaphore, decrease resource supply
  // acquire.sem_num = 0;
  // acquire.sem_op = -1;
  // acquire.sem_flg = SEM_UNDO;
 
  //// release semaphore, increase resource supply
  // release.sem_num = 0;
  // release.sem_op = 1;
  // release.sem_flg = SEM_UNDO;
  // recdis = NULL;
  recTrack1 = NULL;
  mdchit    = NULL;
  // kalTrack = NULL;
  tofTrack  = NULL;
  muctrk    = NULL;
  emcshower = NULL;
  //  fRecEvent_1 =0;
 
  fDstEvent  = NULL; // Long Peixun's update: Initialize dst tracks
  fEvent     = NULL; // Long Peixun's update: Initialize fEvent to NULL
  fEventTree = NULL;
  fAutoGeom  = false;         // Long Peixun's update: Initialize fAutoGeom
  fCurGeom   = TString( "" ); // Long Peixun's update: Initialize fCurGeom
  isRecEvent = true;          // Long Peixun's update: Initialize isRecEvent
 
  // init parameters
  this->InitParameter();
 
  // init local variables
  this->InitLocal();
 
  // Create toplevel widget
  this->CreateWidget( title, fWindowWidth, fWindowHeight );
 
  // connections to messaging queues
  this->InitConnections();
 
  this->SetBackgroundPixmap( GetPic( "background.gif" ) );
 
  f_bossMode = false;
  int         optchar;
  static char optstring[] = "e:g:B:";
  opterr                  = 0;
  fEventFile              = NULL;
 
  // detail information about getopt can be get by man order in shell
  while ( ( optchar = getopt( argc, argv, optstring ) ) != -1 )
  {
    switch ( optchar )
    {
    case 'g':
      f_geoFile = optarg;
      cout << "Load Geometry file with arguments" << endl;
      cout << "Geometry: " << f_geoFile << endl; // Long Peixun's update: GeoFile -> Geometry
      break;
    case 'e':
      f_evtFile = optarg;
      cout << "Load Event file with argments" << endl;
      cout << "Evtfile: " << f_evtFile << endl;
      break;
    case 'B':
      f_bossMode = true;
      f_pid      = atoi( optarg );
      cout << "Run in the Boss Framework: " << f_bossMode << endl;
      cout << "parent pid: " << f_pid << endl;
      break;
    case '?': cout << "Found an option that was not in optstring!" << endl;
    }
  }
  // Long Peixun's update: It is not necessary to use -e to specify event file
  if ( optind < argc )
  {
    if ( f_evtFile.Length() == 0 )
    {
      f_evtFile = argv[optind];
      cout << "Load Event file with argments" << endl;
      cout << "Evtfile: " << f_evtFile << endl;
    }
  }
  // cout << "Left off at: " << argv[optind] << endl;
 
  // Long Peixun's update: There is no need to popup Load Geometry dialog box when launch
  // BesVis this->LoadGeoFile();
 
  if ( f_bossMode == false )
  {
    // Long Peixun's update: Open geometry file by using -g
    if ( f_geoFile.Length() != 0 )
    {
      if ( FileExists( f_geoFile ) ) OpenGeoFile( f_geoFile );
      else
      {
        if ( f_geoFile.Contains( "/" ) )
        {
          HandleError( "Geometry file doesn't exist!" );
          f_geoFile = TString( "" );
        }
        else
        { // f_geoFile only contains file name
          // Allow abbreviation of geometry file
          if ( !f_geoFile.EndsWith( ".root" ) && !f_geoFile.EndsWith( ".gdml" ) )
            f_geoFile = TString( "geom_" ) + f_geoFile + TString( ".root" );
 
          f_geoFile = fBesVisPath + TString( "/geom/" ) + f_geoFile;
          // try to find geometry file in {$BesVisPath}/geom/
          if ( FileExists( f_geoFile ) ) OpenGeoFile( f_geoFile );
          else
          {
            HandleError( "Geometry file doesn't exist!" );
            f_geoFile = TString( "" );
          }
        }
      }
    }
    if ( f_evtFile.Length() != 0 )
    {
      // Long Peixun's update: Open event file by using -e
      if ( FileExists( f_evtFile ) )
      {
        if ( f_geoFile.Length() == 0 ) OpenEventFile( f_evtFile, true );
        else OpenEventFile( f_evtFile, false );
      }
      else
      {
        HandleError( "Event file doesn't exist!" );
        f_evtFile = TString( "" );
      }
 
      //  this->GetEvent(0);
      // Long Peixun's update: Set status after open event file
      UpdateCurrentPad();
      UpdateBesInputFields();
    }
  }
  else if ( f_bossMode == true )
  {
    fAutoDisplayEvent = kTRUE;
    f_runStatus       = RUN_SMOOTH;
    cout << "Load event file: " << f_evtFile << endl;
    fCurrentEvent = 0;
    this->GetRecEvent();
  }
 
  this->UpdateStatus();
}
 
//___________________________________________________________________
 
BesClient::~BesClient() {
  //
  // BesClient standard destructor
  if ( gDebug ) { cout << "BesClient dtor called" << endl; }
 
  fWidgets->Delete();
  delete fWidgets;
}
 
//__________________________________________________________________
 
void BesClient::CreateWidget( const char* title, UInt_t width, UInt_t height ) {
  //
  // Create display
 
  // CreateHorizontalRuler();
 
  // Create menu bar
  CreateMenuBar();
  // fLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 10, 100, 2, 2);
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 0, 1, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fMenuBar, fLayout );
 
  // CreateHorizontalRuler();
 
  // Create upButton bar
  CreateUpButtonBar();
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 10, 0, 0, 1 );
  fWidgets->Add( fLayout );
  this->AddFrame( fUpButtonBarFrame, fLayout );
 
  // CreateHorizontalRuler();
 
  // Create title bar
  CreateTitleBar();
  fLayout = new TGLayoutHints( kLHintsCenterX | kLHintsExpandX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fTitleFrame, fLayout );
 
  // CreateHorizontalRuler();
 
  // Create main frame
  CreateMainFrame();
  fLayout = new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fMainFrame, fLayout );
 
  // Create display mode bar
  CreateDisplayModeBar();
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fDisplayModeBarFrame, fLayout );
 
  // Create toolbar
  CreateToolBar();
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 3, 0, 1, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fToolBarFrame, fLayout );
 
  // Create status bar
  CreateStatusBar();
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( fStatusBar, fLayout );
 
  // Toplevel widget layout
  TString ttitle( title );
  ttitle.Append( "@" );
  ttitle.Append( gSystem->HostName() );
  SetWindowName( ttitle );
  SetIconName( title );
  SetIconPixmap( ( fBesVisPath + TString( "/icons/LogoBesVisMini.gif" ) ).Data() );
  SetClassHints( "BesVis", "Bes Event Visualisation" );
 
  SetWMPosition( 10, 10 ); // position of the window
  SetMWMHints( kMWMDecorAll, kMWMFuncAll, kMWMInputModeless );
  MapSubwindows();
  Resize( GetDefaultSize() );
  Resize( width, height );
  MapWindow();
}
 
void BesClient::CreateHorizontalRuler() {
  //
  // Add horizontal ruler
  // cout << " horizontal ruler" << endl;
  fLayout = new TGLayoutHints( kLHintsExpandX, 2, 2, 0, 0 );
  fWidgets->Add( fLayout );
  this->AddFrame( new TGHorizontal3DLine( this ), fLayout );
}
 
//__________________________________________________________________
 
void BesClient::CreateMenuBar() {
  //
  // Create the menu bar and popup menus
 
  // Layouts
  fMenuBarFirstItemLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 30, 0, 1, 2 );
  fMenuBarItemLayout      = new TGLayoutHints( kLHintsTop | kLHintsLeft, 20, 0, 1, 2 );
  fMenuBarLastItemLayout  = new TGLayoutHints( kLHintsTop | kLHintsRight, 20, 20, 1, 2 );
 
  // const TGPicture *label2 = gClient->GetPicture("popMenuLabel2.gif");
  const TGPicture* viewGeometryIcon = gClient->GetPicture( "viewGeometry.gif" );
  // const TGPicture *normalPopupEntryIcon = gClient->GetPicture("normalPopupEntry1.gif");
 
  //
  // File menu
  // =========
  fMenuFile = new TGPopupMenu( gClient->GetRoot() );
  // fMenuFile->SetBackgroundPixmap(GetPic("2.gif"));
  fMenuFile->AddEntry( "Load &Geometry File...", kM_File_LoadGeo );
  fMenuFile->AddEntry( "&Save Geometry as...", kM_File_SaveGeoAs );
  fMenuFile->AddEntry( "Load &Event File...", kM_File_OpenEvent );
  fMenuFile->AddEntry( "Save &Picture as...", kM_File_SavePicAs );
  fMenuFile->AddSeparator();
  fMenuFile->AddEntry( "&Quit BesVis", kM_File_Exit );
 
  //
  // Edit menu
  // =========
  fMenuEdit = new TGPopupMenu( gClient->GetRoot() );
  // fMenuEdit->SetBackgroundPixmap(GetPic("popMenuBorder.gif"));
  fMenuEdit->AddEntry( "&Editor", kM_Edit_Editor );
 
  //
  // View-Option Header menu
  // =======================
  fMenuViewOptionHeader = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionHeader->AddEntry( "Show Header",
                                   kM_Header_Global ); // Long Peixun's update: kM_Header_On ->
                                                       // kM_Header_Global
 
  //
  // View-Option Mdc menu
  // ====================
  fMenuViewOptionMdc = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionMdc->AddEntry( "Global", kM_Mdc_Global );
  fMenuViewOptionMdc->AddEntry( "Tubes", kM_Mdc_Tubes );
  fMenuViewOptionMdc->AddEntry( "Wires", kM_Mdc_Wires );
  //
  // View-Option Tof menu
  // ====================
  fMenuViewOptionTof = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionTof->AddEntry( "Global", kM_Tof_Global );
  fMenuViewOptionTof->AddEntry( "East", kM_Tof_East );
  fMenuViewOptionTof->AddEntry( "Barrel", kM_Tof_Barrel );
  fMenuViewOptionTof->AddEntry( "West", kM_Tof_West );
  //
  // View-Option Emc menu
  // ====================
  fMenuViewOptionEmc = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionEmc->AddEntry( "Global", kM_Emc_Global );
  fMenuViewOptionEmc->AddEntry( "East", kM_Emc_East );
  fMenuViewOptionEmc->AddEntry( "Barrel", kM_Emc_Barrel );
  fMenuViewOptionEmc->AddEntry( "West", kM_Emc_West );
  fMenuViewOptionEmc->AddEntry( "Side", kM_Emc_Side );
  //
  // View-Option Muc menu
  // ====================
  fMenuViewOptionMuc = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionMuc->AddEntry( "Global", kM_Muc_Global );
  fMenuViewOptionMuc->AddEntry( "East", kM_Muc_East );
  fMenuViewOptionMuc->AddEntry( "Barrel", kM_Muc_Barrel );
  fMenuViewOptionMuc->AddEntry( "West", kM_Muc_West );
  fMenuViewOptionMuc->AddEntry( "Strips", kM_Muc_Strips );
  //
  // View-Option Full3D menu
  // ====================
  fMenuViewOptionFull3D = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionFull3D->AddEntry( "Mdc", kM_Full3D_Mdc );
  fMenuViewOptionFull3D->AddEntry( "Tof", kM_Full3D_Tof );
  fMenuViewOptionFull3D->AddEntry( "Emc", kM_Full3D_Emc );
  fMenuViewOptionFull3D->AddEntry( "Muc", kM_Full3D_Muc );
  //
  // View-Option Others menu
  // ====================
  fMenuViewOptionOthers = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionOthers->AddEntry( "BeamPipe", kM_BeamPipe );
  fMenuViewOptionOthers->AddEntry( "ZRPlaneOnXY", kM_ZRPlaneOnXY );
  fMenuViewOptionOthers->AddEntry( "Axis", kM_Axis );
 
  //
  // View-Option Mdc Hits menu
  // ====================
  fMenuViewOptionMdcHits = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionMdcHits->AddEntry( "Hits", kM_MdcHits_Hits );
  //
  // View-Option Tof Hits menu
  // =========================
  fMenuViewOptionTofHits = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionTofHits->AddEntry( "Global Hits", kM_TofHits_Global );
  fMenuViewOptionTofHits->AddEntry( "East   Hits", kM_TofHits_East );
  fMenuViewOptionTofHits->AddEntry( "Barrel Hits", kM_TofHits_Barrel );
  fMenuViewOptionTofHits->AddEntry( "West   Hits", kM_TofHits_West );
  //
  // View-Option Emc Hits menu
  // =========================
  fMenuViewOptionEmcHits = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionEmcHits->AddEntry( "Global Hits", kM_EmcHits_Global );
  fMenuViewOptionEmcHits->AddEntry( "East   Hits", kM_EmcHits_East );
  fMenuViewOptionEmcHits->AddEntry( "Barrel Hits", kM_EmcHits_Barrel );
  fMenuViewOptionEmcHits->AddEntry( "West   Hits", kM_EmcHits_West );
  fMenuViewOptionEmcHits->AddEntry( "Side   Hits", kM_EmcHits_Side );
  //
  // View-Option Muc Hits menu
  // =========================
  fMenuViewOptionMucHits = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionMucHits->AddEntry( "Global Hits", kM_MucHits_Global );
  fMenuViewOptionMucHits->AddEntry( "East   Hits", kM_MucHits_East );
  fMenuViewOptionMucHits->AddEntry( "Barrel Hits", kM_MucHits_Barrel );
  fMenuViewOptionMucHits->AddEntry( "West   Hits", kM_MucHits_West );
  //
  // View-Option Tracks menu
  // =========================
  fMenuViewOptionTracks = new TGPopupMenu( gClient->GetRoot() );
  fMenuViewOptionTracks->AddEntry( "Global ", kM_Tracks_Global );
  fMenuViewOptionTracks->AddEntry( "Mdc ", kM_Tracks_Mdc );
  fMenuViewOptionTracks->AddEntry( "Tof ", kM_Tracks_Tof );
  fMenuViewOptionTracks->AddEntry( "Emc ", kM_Tracks_Emc );
  fMenuViewOptionTracks->AddEntry( "Muc ", kM_Tracks_Muc );
  fMenuViewOptionTracks->AddEntry( "Ext ", kM_Tracks_Ext );
 
  //
  // View menu
  // =========
  fMenuView = new TGPopupMenu( gClient->GetRoot() );
  // fMenuView->SetBackgroundPixmap(GetPic("2.gif"));
  fMenuView->AddLabel( "General" );
  fMenuView->AddSeparator();
  fMenuView->AddPopup( "Header", fMenuViewOptionHeader );
  fMenuView->AddSeparator();
  fMenuView->AddLabel( "Detector", viewGeometryIcon );
  fMenuView->AddSeparator();
  fMenuView->AddPopup( "Mdc", fMenuViewOptionMdc );
  fMenuView->AddPopup( "Tof", fMenuViewOptionTof );
  fMenuView->AddPopup( "Emc", fMenuViewOptionEmc );
  fMenuView->AddPopup( "Muc", fMenuViewOptionMuc );
  // fMenuView->AddPopup("Full3D",fMenuViewOptionFull3D);  //Long Peixun's update: No longer
  // use Full3D
  fMenuView->AddPopup( "Others", fMenuViewOptionOthers );
  fMenuView->AddSeparator();
  // fMenuView->AddLabel("DST");
  fMenuView->AddLabel( "REC" );
  fMenuView->AddSeparator();
  fMenuView->AddPopup( "Mdc Hits", fMenuViewOptionMdcHits );
  fMenuView->AddPopup( "Tof Hits", fMenuViewOptionTofHits );
  fMenuView->AddPopup( "Emc Hits", fMenuViewOptionEmcHits );
  fMenuView->AddPopup( "Muc Hits", fMenuViewOptionMucHits );
  fMenuView->AddPopup( "Tracks", fMenuViewOptionTracks );
  fMenuView->AddSeparator();
  fMenuView->AddLabel( "Special Views" );
  fMenuView->AddSeparator();
  // fMenuView->AddEntry("View with X3D", kM_View_X3D, 0, normalPopupEntryIcon);
  fMenuView->AddEntry( "View with X3D", kM_View_X3D );
  fMenuView->AddEntry( "View with OpenGL", kM_View_OpenGL );
 
  //
  // Help menu
  // =========
  fMenuHelp = new TGPopupMenu( gClient->GetRoot() );
  // fMenuHelp->SetBackgroundPixmap(GetPic("popMenuBorder.gif"));
  fMenuHelp->AddEntry( "Help &Content", kM_Help_Content );
  fMenuHelp->AddSeparator();
  fMenuHelp->AddEntry( "About", kM_Help_About );
 
  // Create the menubar and add popup menus
  fMenuBar = new BesGMenuBar( this, 1, 1, kHorizontalFrame );
  fMenuBar->SetBackgroundPixmap( GetPic( "MenuBarBckgnd.gif" ) );
 
  fMenuBar->AddPopup( "&File", fMenuFile, fMenuBarFirstItemLayout );
  // fMenuBar->AddPopup("&Edit", fMenuEdit, fMenuBarItemLayout); // dont show edit
  fMenuBar->AddPopup( "&View", fMenuView, fMenuBarItemLayout );
  fMenuBar->AddPopup( "&Help", fMenuHelp, fMenuBarLastItemLayout );
 
  fMenuBar->GetMenuTitle( 0 )->SetPicture( GetPic( "MenuFile.gif" ) );
  fMenuBar->GetMenuTitle( 0 )->SetPictureHL( GetPic( "MenuFileHL.gif" ) );
  fMenuBar->GetMenuTitle( 1 )->SetPicture( GetPic( "MenuView.gif" ) );
  fMenuBar->GetMenuTitle( 1 )->SetPictureHL( GetPic( "MenuViewHL.gif" ) );
  fMenuBar->GetMenuTitle( 2 )->SetPicture( GetPic( "MenuHelp.gif" ) );
  fMenuBar->GetMenuTitle( 2 )->SetPictureHL( GetPic( "MenuHelpHL.gif" ) );
 
  //
  // Connect menu buttons to actions. Menu button messages are
  // handled by the main frame (i.e. "this") HandleMenu() method., kHorizontalFrame);
  fMenuFile->Connect( "Activated(Int_t)", "BesClient", this, "HandleMenu(Int_t)" );
  fMenuEdit->Connect( "Activated(Int_t)", "BesClient", this, "HandleMenu(Int_t)" );
  fMenuHelp->Connect( "Activated(Int_t)", "BesClient", this, "HandleMenu(Int_t)" );
  fMenuView->Connect( "Activated(Int_t)", "BesClient", this, "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionHeader->Connect( "Activated(Int_t)", "BesClient", this,
                                  "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionMdc->Connect( "Activated(Int_t)", "BesClient", this,
                               "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionTof->Connect( "Activated(Int_t)", "BesClient", this,
                               "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionEmc->Connect( "Activated(Int_t)", "BesClient", this,
                               "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionMuc->Connect( "Activated(Int_t)", "BesClient", this,
                               "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionFull3D->Connect( "Activated(Int_t)", "BesClient", this,
                                  "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionOthers->Connect( "Activated(Int_t)", "BesClient", this,
                                  "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionMdcHits->Connect( "Activated(Int_t)", "BesClient", this,
                                   "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionTofHits->Connect( "Activated(Int_t)", "BesClient", this,
                                   "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionEmcHits->Connect( "Activated(Int_t)", "BesClient", this,
                                   "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionMucHits->Connect( "Activated(Int_t)", "BesClient", this,
                                   "HandleViewOptionMenu(Int_t)" );
  fMenuViewOptionTracks->Connect( "Activated(Int_t)", "BesClient", this,
                                  "HandleViewOptionMenu(Int_t)" );
 
  /*
    TASImage *asImage = new TASImage("013.gif");
    Pixmap_t pic1 = asImage->GetPixmap();
    //asImage->Draw();
    Pixmap_t pic1 = gVirtualX->ReadGIF(0, 0, "013.gif");
    fMenuBar->SetBackgroundPixmap(pic1);
  */
 
  // fMenuBar->SetBackgroundPixmap(GetPic("background.gif"));
 
  /*
  TList *fMenuTitleList = fMenuBar->GetList();
  cout << "Menu title size " << fMenuTitleList->GetSize() << endl;
  for (Int_t iTitle = 0; iTitle < fMenuTitleList->GetSize(); iTitle++) {
    cout << ((TGMenuTitle*)fMenuTitleList->At(iTitle))->GetName() << endl;
   TGFrameElement *el = (TGFrameElement *)fMenuTitleList->At(iTitle);
   TGMenuTitle    *t = (TGMenuTitle *)el->fFrame;
   t->SetBackgroundPixmap(GetPic("test.gif"));
   cout << t->GetName() << endl;
   t->SetBackgroundColor(kBlack);
   if (iTitle == 0) {
     //t->SetHeight(10);
     t->SetForegroundColor(kWhite);
   }
   }
  */
}
 
//__________________________________________________________________
 
void BesClient::CreateUpButtonBar() {
  //
  fUpButtonBarFrame = new TGCompositeFrame( this, 300, 25, kHorizontalFrame );
  fUpButtonBarFrame->SetBackgroundPixmap( GetPic( "UpButtonBarBckgnd.gif" ) );
 
  fUpButtonBarFirstItemLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 15, 0, 1, 2 );
  fUpButtonBarItemLayout      = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 0, 1, 2 );
  fUpButtonBarLastItemLayout  = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 13, 1, 2 );
 
  Int_t width = 23, height = 22;
  Int_t h, charw, w; // of number entry
  Int_t nUpSplitter = 0;
 
  // Up Button Splitter
  for ( Int_t i = 0; i < kNUpSplitter; i++ )
  {
    fUpButtonSplitter[i] = new BesGPictureButton(
        fUpButtonBarFrame, gClient->GetPicture( "UpButtonSplitter.gif" ) );
    fUpButtonSplitter[i]->SetHeight( 20 );
    fUpButtonSplitter[i]->SetWidth( 5 );
    fUpButtonSplitter[i]->SetState( kButtonDisabled );
  }
 
  // Load Geo File
  fLoadGeoFileButton =
      new BesGPictureButton( fUpButtonBarFrame, gClient->GetPicture( "ButtonLoadGeoFile.gif" ),
                             kM_Button_LoadGeoFile );
  fLoadGeoFileButton->SetPictureHL( gClient->GetPicture( "ButtonLoadGeoFileHL.gif" ) );
  fLoadGeoFileButton->SetToolTipText( "Load Geometry File" );
  fLoadGeoFileButton->SetHeight( height );
  fLoadGeoFileButton->SetWidth( width );
  fLoadGeoFileButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fLoadGeoFileButton, fUpButtonBarFirstItemLayout );
 
  // Open Event File
  fOpenEventFileButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonOpenEventFile.gif" ),
      kM_Button_OpenEventFile );
  fOpenEventFileButton->SetPictureHL( gClient->GetPicture( "ButtonOpenEventFileHL.gif" ) );
  fOpenEventFileButton->SetToolTipText( "Open Event File" );
  fOpenEventFileButton->SetHeight( height );
  fOpenEventFileButton->SetWidth( width );
  fOpenEventFileButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fOpenEventFileButton, fUpButtonBarItemLayout );
 
  // Save Pic As
  fSavePicAsButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonSavePicAs.gif" ), kM_Button_SavePicAs );
  fSavePicAsButton->SetPictureHL( gClient->GetPicture( "ButtonSavePicAsHL.gif" ) );
  fSavePicAsButton->SetToolTipText( "Save Picture as" );
  fSavePicAsButton->SetHeight( height );
  fSavePicAsButton->SetWidth( width );
  fSavePicAsButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fSavePicAsButton, fUpButtonBarItemLayout );
 
  // Save Pic As PS
  fSavePicAsPSButton =
      new BesGPictureButton( fUpButtonBarFrame, gClient->GetPicture( "ButtonSavePicAsPS.gif" ),
                             kM_Button_SavePicAsPS );
  fSavePicAsPSButton->SetPictureHL( gClient->GetPicture( "ButtonSavePicAsPSHL.gif" ) );
  fSavePicAsPSButton->SetToolTipText( "Save Picture as besvis.ps" );
  fSavePicAsPSButton->SetHeight( height );
  fSavePicAsPSButton->SetWidth( width );
  fSavePicAsPSButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fSavePicAsPSButton, fUpButtonBarItemLayout );
 
  // Up Button Splitter
  fUpButtonBarFrame->AddFrame( fUpButtonSplitter[nUpSplitter], fUpButtonBarItemLayout );
  nUpSplitter++;
 
  // Refresh
  fRefreshButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonRefresh.gif" ), kM_Button_Refresh );
  fRefreshButton->SetPictureHL( gClient->GetPicture( "ButtonRefreshHL.gif" ) );
  fRefreshButton->SetToolTipText( "Refresh" );
  fRefreshButton->SetHeight( height );
  fRefreshButton->SetWidth( width );
  fRefreshButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fRefreshButton, fUpButtonBarItemLayout );
 
  // Reset Current
  fResetCurrentButton = new BesGPictureButton( fUpButtonBarFrame,
                                               gClient->GetPicture( "ButtonResetCurrent.gif" ),
                                               kM_Button_ResetCurrent );
  fResetCurrentButton->SetPictureHL( gClient->GetPicture( "ButtonResetCurrentHL.gif" ) );
  fResetCurrentButton->SetToolTipText( "Reset Current Pad" );
  fResetCurrentButton->SetHeight( height );
  fResetCurrentButton->SetWidth( width );
  fResetCurrentButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fResetCurrentButton, fUpButtonBarItemLayout );
 
  // Reset All
  fResetAllButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonResetAll.gif" ), kM_Button_ResetAll );
  fResetAllButton->SetPictureHL( gClient->GetPicture( "ButtonResetAllHL.gif" ) );
  fResetAllButton->SetToolTipText( "Reset All Pads" );
  fResetAllButton->SetHeight( height );
  fResetAllButton->SetWidth( width );
  fResetAllButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fResetAllButton, fUpButtonBarItemLayout );
 
  // Up Button Splitter
  fUpButtonBarFrame->AddFrame( fUpButtonSplitter[nUpSplitter], fUpButtonBarItemLayout );
  nUpSplitter++;
 
  // Zoom Out
  fZoomOutButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonZoomOut.gif" ), kM_Button_ZoomOut );
  fZoomOutButton->SetPictureHL( gClient->GetPicture( "ButtonZoomOutHL.gif" ) );
  fZoomOutButton->SetToolTipText( "Zoom Out" );
  fZoomOutButton->SetHeight( height );
  fZoomOutButton->SetWidth( width );
  fZoomOutButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fZoomOutButton, fUpButtonBarItemLayout );
 
  // Zoom Ratio number
  fZoomRatioNumber =
      new TGNumberEntryField( fUpButtonBarFrame, kM_Button_ZoomRatioNumber, 100.0,
                              (TGNumberFormat::EStyle)1, (TGNumberFormat::EAttribute)0 );
  fZoomRatioNumber->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  h     = Int_t( fZoomRatioNumber->GetDefaultHeight() / 1.2 ); // default height 22
  charw = fZoomRatioNumber->GetCharWidth( "0123456" );
  w = charw * TMath::Abs( 5 ) / 10 + 8 + 2 * h / 3 + 2; // 5 is digit width, default width 46
  // cout << h << " " << w << endl;
  fZoomRatioNumber->Resize( w, h );
 
  fLayout = new TGLayoutHints( kLHintsCenterX | kLHintsCenterY );
  fWidgets->Add( fLayout );
  fUpButtonBarFrame->AddFrame( fZoomRatioNumber, fLayout );
 
  // "%"
  fZoomRatioPercentButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonZoomRatioPercent.gif" ) );
  fZoomRatioPercentButton->SetHeight( 20 );
  fZoomRatioPercentButton->SetWidth( 10 );
  fZoomRatioPercentButton->SetState( kButtonDisabled );
  fUpButtonBarFrame->AddFrame( fZoomRatioPercentButton, fUpButtonBarItemLayout );
 
  // Zoom In
  fZoomInButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonZoomIn.gif" ), kM_Button_ZoomIn );
  fZoomInButton->SetPictureHL( gClient->GetPicture( "ButtonZoomInHL.gif" ) );
  fZoomInButton->SetToolTipText( "Zoom In" );
  fZoomInButton->SetHeight( height );
  fZoomInButton->SetWidth( width );
  fZoomInButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fZoomInButton, fUpButtonBarItemLayout );
 
  // Cursor Pick
  fCursorButton[0] = new BesGPictureButton( fUpButtonBarFrame,
                                            gClient->GetPicture( "ButtonCursorPickST.gif" ),
                                            kM_Button_CursorPick );
  fCursorButton[0]->SetState( true ); // with "Button***ST" should set state on
  fCursorButton[0]->SetPictureHL( gClient->GetPicture( "ButtonCursorPickHL.gif" ) );
  fCursorButton[0]->SetToolTipText( "Select Tool" );
  // fCursorButton[0]->SetState(kButtonEngaged);
 
  // Cursor Hand
  fCursorButton[1] = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonCursorHand.gif" ), kM_Button_CursorHand );
  fCursorButton[1]->SetPictureHL( gClient->GetPicture( "ButtonCursorHandHL.gif" ) );
  fCursorButton[1]->SetToolTipText( "Hand Tool" );
 
  for ( int i = 0; i < kNCursorState; i++ )
  {
    fCursorButton[i]->SetHeight( height );
    fCursorButton[i]->SetWidth( width );
    fCursorButton[i]->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
    fUpButtonBarFrame->AddFrame( fCursorButton[i], fUpButtonBarItemLayout );
  }
 
  // Up Button Splitter
  fUpButtonBarFrame->AddFrame( fUpButtonSplitter[nUpSplitter], fUpButtonBarItemLayout );
  nUpSplitter++;
 
  // Switch Display Mode
  fSwitchDisplayModeButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonSwitchDisplayMode.gif" ),
      kM_Button_SwitchDisplayMode );
  fSwitchDisplayModeButton->SetPictureHL(
      gClient->GetPicture( "ButtonSwitchDisplayModeHL.gif" ) );
  fSwitchDisplayModeButton->SetToolTipText( "Switch Display Mode" );
  fSwitchDisplayModeButton->SetHeight( height );
  fSwitchDisplayModeButton->SetWidth( width );
  fSwitchDisplayModeButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fSwitchDisplayModeButton, fUpButtonBarItemLayout );
 
  // Set Home
  fSetHomeButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonSetHome.gif" ), kM_Button_SetHome );
  fSetHomeButton->SetPictureHL( gClient->GetPicture( "ButtonSetHomeHL.gif" ) );
  fSetHomeButton->SetToolTipText( "Set home position" );
  fSetHomeButton->SetHeight( height );
  fSetHomeButton->SetWidth( width );
  fSetHomeButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fSetHomeButton, fUpButtonBarItemLayout );
 
  // Go Home
  fGoHomeButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonGoHome.gif" ), kM_Button_GoHome );
  fGoHomeButton->SetPictureHL( gClient->GetPicture( "ButtonGoHomeHL.gif" ) );
  fGoHomeButton->SetToolTipText( "Go to home position" );
  fGoHomeButton->SetHeight( height );
  fGoHomeButton->SetWidth( width );
  fGoHomeButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fGoHomeButton, fUpButtonBarItemLayout );
 
  // Save My style
  fSaveMyConfigButton = new BesGPictureButton( fUpButtonBarFrame,
                                               gClient->GetPicture( "ButtonSaveMyConfig.gif" ),
                                               kM_Button_SaveMyConfig );
  fSaveMyConfigButton->SetPictureHL( gClient->GetPicture( "ButtonSaveMyConfigHL.gif" ) );
  fSaveMyConfigButton->SetToolTipText( "Save My Style" );
  fSaveMyConfigButton->SetHeight( height );
  fSaveMyConfigButton->SetWidth( width );
  fSaveMyConfigButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fSaveMyConfigButton, fUpButtonBarItemLayout );
 
  // Load My style
  fLoadMyConfigButton = new BesGPictureButton( fUpButtonBarFrame,
                                               gClient->GetPicture( "ButtonLoadMyConfig.gif" ),
                                               kM_Button_LoadMyConfig );
  fLoadMyConfigButton->SetPictureHL( gClient->GetPicture( "ButtonLoadMyConfigHL.gif" ) );
  fLoadMyConfigButton->SetToolTipText( "Load My Style" );
  fLoadMyConfigButton->SetHeight( height );
  fLoadMyConfigButton->SetWidth( width );
  fLoadMyConfigButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fLoadMyConfigButton, fUpButtonBarItemLayout );
 
  // Display mdc wire color palette
  fPaletteButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonPalette.gif" ), kM_Button_Palette );
  fPaletteButton->SetPictureHL( gClient->GetPicture( "ButtonPaletteHL.gif" ) );
  fPaletteButton->SetToolTipText( "Palette" );
  fPaletteButton->SetHeight( height );
  fPaletteButton->SetWidth( width );
  fPaletteButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fPaletteButton, fUpButtonBarItemLayout );
 
  // Up Button Splitter
  fUpButtonBarFrame->AddFrame( fUpButtonSplitter[nUpSplitter], fUpButtonBarItemLayout );
  nUpSplitter++;
 
  // Help
  fHelpButton = new BesGPictureButton(
      fUpButtonBarFrame, gClient->GetPicture( "ButtonHelp.gif" ), kM_Button_Help );
  fHelpButton->SetPictureHL( gClient->GetPicture( "ButtonHelpHL.gif" ) );
  fHelpButton->SetToolTipText( "Help" );
  fHelpButton->SetHeight( height );
  fHelpButton->SetWidth( width );
  fHelpButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fUpButtonBarFrame->AddFrame( fHelpButton, fUpButtonBarLastItemLayout );
}
 
//__________________________________________________________________
 
void BesClient::CreateDisplayModeBar() {
 
  fDisplayModeBarFrame      = new TGCompositeFrame( this, 300, 16, kHorizontalFrame );
  fDisplayModeBarItemLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 0, 0, 0 );
 
  fDisplayModeButton[0] = new BesGPictureButton( fDisplayModeBarFrame,
                                                 gClient->GetPicture( "DisplayMode2DST.gif" ),
                                                 kM_Button_DisplayMode2D );
  fDisplayModeButton[1] =
      new BesGPictureButton( fDisplayModeBarFrame, gClient->GetPicture( "DisplayModeXY.gif" ),
                             kM_Button_DisplayModeXY );
  fDisplayModeButton[2] =
      new BesGPictureButton( fDisplayModeBarFrame, gClient->GetPicture( "DisplayModeZR.gif" ),
                             kM_Button_DisplayModeZR );
  fDisplayModeButton[3] =
      new BesGPictureButton( fDisplayModeBarFrame, gClient->GetPicture( "DisplayMode3D.gif" ),
                             kM_Button_DisplayMode3D );
  fDisplayModeButton[4] =
      new BesGPictureButton( fDisplayModeBarFrame, gClient->GetPicture( "DisplayModeAll.gif" ),
                             kM_Button_DisplayModeAll );
 
  fDisplayModeButton[0]->SetState( true );
  fDisplayModeButton[1]->SetState( false );
  fDisplayModeButton[2]->SetState( false );
  fDisplayModeButton[3]->SetState( false );
  fDisplayModeButton[4]->SetState( false );
 
  fDisplayModeButton[0]->SetPictureHL( gClient->GetPicture( "DisplayMode2DHL.gif" ) );
  fDisplayModeButton[1]->SetPictureHL( gClient->GetPicture( "DisplayModeXYHL.gif" ) );
  fDisplayModeButton[2]->SetPictureHL( gClient->GetPicture( "DisplayModeZRHL.gif" ) );
  fDisplayModeButton[3]->SetPictureHL( gClient->GetPicture( "DisplayMode3DHL.gif" ) );
  fDisplayModeButton[4]->SetPictureHL( gClient->GetPicture( "DisplayModeAllHL.gif" ) );
 
  fDisplayModeButton[0]->SetToolTipText( "XY+ZR view" );
  fDisplayModeButton[1]->SetToolTipText( "XY view" );
  fDisplayModeButton[2]->SetToolTipText( "ZR view" );
  fDisplayModeButton[3]->SetToolTipText( "3D view" );
  fDisplayModeButton[4]->SetToolTipText( "All view" );
 
  Int_t width = 16, height = 16;
  for ( Int_t i = 0; i < kNDisplayMode; i++ )
  {
    fDisplayModeButton[i]->SetState( kButtonUp );
    fDisplayModeButton[i]->SetHeight( height );
    fDisplayModeButton[i]->SetWidth( width );
    fDisplayModeButton[i]->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
    fDisplayModeBarFrame->AddFrame( fDisplayModeButton[i], fDisplayModeBarItemLayout );
  }
}
 
//__________________________________________________________________
 
void BesClient::CreateToolBar() {
 
  fToolBarFrame = new TGCompositeFrame( this, 300, 25, kHorizontalFrame );
  fToolBarFrame->SetBackgroundPixmap( GetPic( "ToolButtonBarBckgnd.gif" ) );
 
  fToolBarFirstItemLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft, 10, 0, 1, 2 );
  fToolBarItemLayout      = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 0, 1, 2 );
  fToolBarLastItemLayout  = new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 14, 1, 2 );
 
  Int_t width = 23, height = 22;
  Int_t nToolSplitter = 0;
 
  // Tool Button Splitter
  for ( Int_t i = 0; i < kNToolSplitter; i++ )
  {
    fToolButtonSplitter[i] = new BesGPictureButton(
        fToolBarFrame, gClient->GetPicture( "ToolButtonSplitter.gif" ) );
    fToolButtonSplitter[i]->SetHeight( 20 );
    fToolButtonSplitter[i]->SetWidth( 5 );
    fToolButtonSplitter[i]->SetState( kButtonDisabled );
  }
 
  // Switch Pad
  fSwitchPadButton = new BesGPictureButton(
      fToolBarFrame, gClient->GetPicture( "ButtonSwitchPad.gif" ), kM_Button_SwitchPad );
  fSwitchPadButton->SetPictureHL( gClient->GetPicture( "ButtonSwitchPadHL.gif" ) );
  fSwitchPadButton->SetToolTipText( "Switch Among Pads" );
  fSwitchPadButton->SetHeight( height );
  fSwitchPadButton->SetWidth( width );
  fSwitchPadButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fSwitchPadButton, fToolBarFirstItemLayout );
 
  // Tool Button Splitter
  fToolBarFrame->AddFrame( fToolButtonSplitter[nToolSplitter], fToolBarItemLayout );
  nToolSplitter++;
 
  // Show Info
  fShowInfoButton = new BesGPictureButton(
      fToolBarFrame, gClient->GetPicture( "ButtonShowInfoST.gif" ), kM_Button_ShowInfo );
  fShowInfoButton->SetState( true );
  fShowInfoButton->SetPictureHL( gClient->GetPicture( "ButtonShowInfoHL.gif" ) );
  fShowInfoButton->SetToolTipText( "Show Info" );
  fShowInfoButton->SetHeight( height );
  fShowInfoButton->SetWidth( width );
  fShowInfoButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fShowInfoButton, fToolBarItemLayout );
 
  // Show Axis
  fShowAxisButton = new BesGPictureButton(
      fToolBarFrame, gClient->GetPicture( "ButtonShowAxis.gif" ), kM_Button_ShowAxis );
  fShowAxisButton->SetPictureHL( gClient->GetPicture( "ButtonShowAxisHL.gif" ) );
  fShowAxisButton->SetToolTipText( "Show Axis" );
  fShowAxisButton->SetHeight( height );
  fShowAxisButton->SetWidth( width );
  fShowAxisButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fShowAxisButton, fToolBarItemLayout );
 
  // Tool Button Splitter
  fToolBarFrame->AddFrame( fToolButtonSplitter[nToolSplitter], fToolBarItemLayout );
  nToolSplitter++;
 
  // FishEye View
  fFishEyeViewButton = new BesGPictureButton(
      fToolBarFrame, gClient->GetPicture( "ButtonFishEyeView.gif" ), kM_Button_FishEyeView );
  fFishEyeViewButton->SetPictureHL( gClient->GetPicture( "ButtonFishEyeViewHL.gif" ) );
  fFishEyeViewButton->SetToolTipText( "FishEye View" );
  fFishEyeViewButton->SetHeight( height );
  fFishEyeViewButton->SetWidth( width );
  fFishEyeViewButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fFishEyeViewButton, fToolBarItemLayout );
 
  // ParallelView
  fParallelViewButton =
      new BesGPictureButton( fToolBarFrame, gClient->GetPicture( "ButtonParallelViewST.gif" ),
                             kM_Button_ParallelView );
  fParallelViewButton->SetState( true );
  fParallelViewButton->SetPictureHL( gClient->GetPicture( "ButtonParallelViewHL.gif" ) );
  fParallelViewButton->SetToolTipText( "Parallel View" );
  fParallelViewButton->SetHeight( height );
  fParallelViewButton->SetWidth( width );
  fParallelViewButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fParallelViewButton, fToolBarItemLayout );
 
  // Perspective View
  fPerspectiveViewButton =
      new BesGPictureButton( fToolBarFrame, gClient->GetPicture( "ButtonPerspectiveView.gif" ),
                             kM_Button_PerspectiveView );
  fPerspectiveViewButton->SetPictureHL( gClient->GetPicture( "ButtonPerspectiveViewHL.gif" ) );
  fPerspectiveViewButton->SetToolTipText( "Perspective View" );
  fPerspectiveViewButton->SetHeight( height );
  fPerspectiveViewButton->SetWidth( width );
  fPerspectiveViewButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fPerspectiveViewButton, fToolBarItemLayout );
 
  // Tool Button Splitter
  fToolBarFrame->AddFrame( fToolButtonSplitter[nToolSplitter], fToolBarItemLayout );
  nToolSplitter++;
 
  // OpenGL
  fOpenGLButton = new BesGPictureButton(
      fToolBarFrame, gClient->GetPicture( "ButtonOpenGL.gif" ), kM_Button_OpenGL );
  fOpenGLButton->SetPictureHL( gClient->GetPicture( "ButtonOpenGLHL.gif" ) );
  fOpenGLButton->SetToolTipText( "OpenGL View" );
  fOpenGLButton->SetHeight( height );
  fOpenGLButton->SetWidth( width );
  fOpenGLButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fOpenGLButton, fToolBarItemLayout );
 
  // X3D
  fX3DButton = new BesGPictureButton( fToolBarFrame, gClient->GetPicture( "ButtonX3D.gif" ),
                                      kM_Button_X3D );
  fX3DButton->SetPictureHL( gClient->GetPicture( "ButtonX3DHL.gif" ) );
  fX3DButton->SetToolTipText( "X3D View" );
  fX3DButton->SetHeight( height );
  fX3DButton->SetWidth( width );
  fX3DButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
  fToolBarFrame->AddFrame( fX3DButton, fToolBarItemLayout );
 
  // Tool Button Splitter
  fToolBarFrame->AddFrame( fToolButtonSplitter[nToolSplitter], fToolBarLastItemLayout );
  nToolSplitter++;
}
 
//__________________________________________________________________
 
void BesClient::CreateTitleBar() {
  //
  // Create the title bar
 
  // Create frame
  fTitleFrame = new TGHorizontalFrame( this, this->GetWidth(), 10 );
}
 
//__________________________________________________________________
 
void BesClient::CreateStatusBar() {
  //
  // Create status bar
  Int_t nPart   = 3;
  Int_t parts[] = { 40, 50, 10 };
  fStatusBar    = new TGStatusBar( this, this->GetWidth(), 20, kHorizontalFrame );
  fStatusBar->SetParts( parts, nPart );
  fStatusBar->SetBackgroundPixmap( GetPic( "StatusBarBckgnd.gif" ) );
  for ( Int_t iPart = 0; iPart < nPart; iPart++ )
  { fStatusBar->GetBarPart( iPart )->SetBackgroundPixmap( GetPic( "StatusBarBckgnd.gif" ) ); }
 
  // Set text
  // fStatusBar->SetText("Ready", 0);
  HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Using HandleStatusBar()
}
 
//__________________________________________________________________
 
void BesClient::CreateMainFrame() {
  //
  // Create main frame containing a tab list,
  // the canvas and a toolbar
  fMainFrame = new TGHorizontalFrame( this, this->GetWidth(), this->GetHeight() - 26 );
 
  // This vertical frame is needed for splitter
  fV1 = new TGVerticalFrame( fMainFrame, 250, fMainFrame->GetHeight(), kFixedWidth );
 
  // Create display tabs
  CreateCanvas();
 
  // Create control tabs
  CreateTabs();
 
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 0, 2, 0, 0 );
  fWidgets->Add( fLayout );
  fV1->AddFrame( fTabs, fLayout );
 
  // Configure Splitter
  //   fV1->Resize(fTabs->GetWidth(), fV1->GetDefaultHeight());
 
  fMainFrame->AddFrame( fEmbeddedCanvas, fECLayout );
 
  fLayout = new TGLayoutHints( kLHintsRight | kLHintsExpandY );
  fWidgets->Add( fLayout );
  fMainFrame->AddFrame( fV1, fLayout );
 
  TGVSplitter* VSplitter = new TGVSplitter( fMainFrame );
  VSplitter->SetFrame( fV1, kFALSE );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsExpandY );
  fWidgets->Add( fLayout );
  fMainFrame->AddFrame( VSplitter, fLayout );
}
 
//__________________________________________________________________
 
void BesClient::CreateCanvas() {
  //
  // Create the embedded canvas
  // Create embedded canvas
  fECLayout = new TGLayoutHints( kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0 );
  fEmbeddedCanvas = new TRootEmbeddedCanvas(
      0, fMainFrame, fMainFrame->GetWidth() / 4 * 3 - 12, fMainFrame->GetHeight() - 46 );
  Int_t wid = fEmbeddedCanvas->GetCanvasWindowId();
  fCanvas   = new TCanvas( "BesVis", fEmbeddedCanvas->GetWidth(),
                           fEmbeddedCanvas->GetHeight() - 10, wid );
  fEmbeddedCanvas->AdoptCanvas( fCanvas );
  fCanvas->cd();
 
  fDisplay = new BesVisDisplay( "BESIII Event Display" );
  fDisplay->SetCanvas( fCanvas );
  fDisplay->Init();
}
 
//__________________________________________________________________
 
void BesClient::CreateTabs() {
 
  //
  // Create tabs for event list and geometry check button lists
  fTabs = new TGTab( fV1, fV1->GetWidth(), fV1->GetHeight() );
  // cout << "Tab width " << fV1->GetWidth() << " height " << fV1->GetHeight() << endl;
  // fTabs->SetBackgroundPixmap(GetPic("2.gif"));
 
  TGCompositeFrame* tf = 0;
  Int_t             h, charw, w;
 
  //
  // "View" tab
  // ================
  tf = fTabs->AddTab( "View" );
  tf->SetBackgroundPixmap( GetPic( "8.gif" ) );
 
  //
  // frame for auto control
  // ===================
  fAutoFrame = new TGCompositeFrame( tf, tf->GetWidth(), tf->GetHeight(), kVerticalFrame );
  fLayout    = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 15, 15, 15, 10 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fAutoFrame, fLayout );
  fAutoFrame->SetBackgroundPixmap( GetPic( "AutoFrameBckgnd.gif" ) );
 
  // lable "Auto control"
  fAutoTextFrame =
      new TGCompositeFrame( fAutoFrame, fAutoFrame->GetWidth(), 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fAutoFrame->AddFrame( fAutoTextFrame, fLayout );
  fAutoTextFrame->SetBackgroundPixmap( GetPic( "AutoControlBckgnd.gif" ) );
 
  fAutoTextLabel = new TGLabel( fAutoTextFrame, "Auto Control  " );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft | kLHintsExpandX, 2, 73, 4, 0 );
  fWidgets->Add( fLayout );
  fAutoTextFrame->AddFrame( fAutoTextLabel, fLayout );
  fAutoTextLabel->SetBackgroundPixmap( GetPic( "AutoControlBckgnd.gif" ) );
 
  // --- Auto rotate ---
  fFrameAutoRotate = new TGGroupFrame( fAutoFrame, "" );
  fLayout          = new TGLayoutHints( kLHintsExpandX, 0, 0, 0, 0 );
  // fLayout = new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5);
  fWidgets->Add( fLayout );
  fAutoFrame->AddFrame( fFrameAutoRotate, fLayout );
 
  // "Auto"
  fChkBtnAutoRotate = new TGCheckButton( fFrameAutoRotate, "Auto", kM_Button_AutoRotate );
  fLayout           = new TGLayoutHints( kLHintsExpandX, 5, 5, 3, 2 );
  fFrameAutoRotate->AddFrame( fChkBtnAutoRotate, fLayout );
  fChkBtnAutoRotate->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  // rotate speed
  fRotateSpeedFrame = new TGCompositeFrame(
      fFrameAutoRotate, fFrameAutoRotate->GetWidth() - 20, 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 2, 2 );
  fWidgets->Add( fLayout );
  fFrameAutoRotate->AddFrame( fRotateSpeedFrame, fLayout );
 
  // input of rotate speed
  fNumEntryRotateSpeed =
      new TGNumberEntryField( fRotateSpeedFrame, kM_Button_RotateSpeed, this->GetRotateSpeed(),
                              (TGNumberFormat::EStyle)1, (TGNumberFormat::EAttribute)1 );
  h     = fNumEntryRotateSpeed->GetDefaultHeight();
  charw = fNumEntryRotateSpeed->GetCharWidth( "0123456" );
  w     = charw * TMath::Abs( 4 ) / 10 + 8 + 2 * h / 3; // 4 is digit width
  fNumEntryRotateSpeed->Resize( w, h );
 
  // fNumEntryRotateSpeed = new TGNumberEntry(fRotateSpeedFrame,this->GetRotateSpeed(), 5
  // ,kM_Button_RotateSpeed,(TGNumberFormat::EStyle) 1,(TGNumberFormat::EAttribute) 1);
  fNumEntryRotateSpeed->SetHeight( 20 );
  fNumEntryRotateSpeed->SetNumber( this->GetRotateSpeed() );
  fNumEntryRotateSpeed->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  fNumEntryRotateSpeed->Connect( "TabPressed()", "BesClient", this, "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 2, 2 );
  fWidgets->Add( fLayout );
  fRotateSpeedFrame->AddFrame( fNumEntryRotateSpeed, fLayout );
 
  // label " deg/sec "
  fRotateSpeedLabel = new TGLabel( fRotateSpeedFrame, " deg/sec   " );
  fLayout           = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 2, 4, 2, 2 );
  fWidgets->Add( fLayout );
  fRotateSpeedFrame->AddFrame( fRotateSpeedLabel, fLayout );
 
  // rotate FPS
  fRotateFPSFrame = new TGCompositeFrame( fFrameAutoRotate, fFrameAutoRotate->GetWidth() - 20,
                                          30, kHorizontalFrame );
  fLayout         = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 2, 2 );
  fWidgets->Add( fLayout );
  fFrameAutoRotate->AddFrame( fRotateFPSFrame, fLayout );
 
  // input of rotate speed
  fNumEntryRotateFPS =
      new TGNumberEntry( fRotateFPSFrame, this->GetRotateFPS(), 3, kM_Button_RotateFPS,
                         (TGNumberFormat::EStyle)0, (TGNumberFormat::EAttribute)1 );
  fNumEntryRotateFPS->SetHeight( 20 );
  fNumEntryRotateFPS->SetNumber( this->GetRotateFPS() );
  fNumEntryRotateFPS->GetNumberEntry()->Connect( "ReturnPressed()", "BesClient", this,
                                                 "ExecuteReturn()" );
  fNumEntryRotateFPS->GetNumberEntry()->Connect( "TabPressed()", "BesClient", this,
                                                 "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 2, 2 );
  fWidgets->Add( fLayout );
  fRotateFPSFrame->AddFrame( fNumEntryRotateFPS, fLayout );
 
  // label " fps "
  fRotateFPSLabel = new TGLabel( fRotateFPSFrame, "  fps       " );
  fLayout         = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 2, 4, 2, 2 );
  fWidgets->Add( fLayout );
  fRotateFPSFrame->AddFrame( fRotateFPSLabel, fLayout );
 
  //
  // frame for view control
  // ===================
  fViewFrame = new TGCompositeFrame( tf, tf->GetWidth(), tf->GetHeight(), kVerticalFrame );
  fLayout    = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 15, 15, 15, 10 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fViewFrame, fLayout );
  fViewFrame->SetBackgroundPixmap( GetPic( "ViewFrameBckgnd.gif" ) );
 
  // lable "View control"
  fViewTextFrame =
      new TGCompositeFrame( fViewFrame, fViewFrame->GetWidth(), 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewFrame->AddFrame( fViewTextFrame, fLayout );
  fViewTextFrame->SetBackgroundPixmap( GetPic( "ViewControlBckgnd.gif" ) );
 
  fViewTextLabel = new TGLabel( fViewTextFrame, "View Control  " );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft | kLHintsExpandX, 2, 73, 4, 4 );
  fWidgets->Add( fLayout );
  fViewTextFrame->AddFrame( fViewTextLabel, fLayout );
  fViewTextLabel->SetBackgroundPixmap( GetPic( "ViewControlBckgnd.gif" ) );
 
  // rotate step
  fRotateStepFrame =
      new TGCompositeFrame( fViewFrame, fViewFrame->GetWidth() - 20, 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 8, 5 );
  fWidgets->Add( fLayout );
  fViewFrame->AddFrame( fRotateStepFrame, fLayout );
 
  // label " Step: "
  fRotateStepLabel = new TGLabel( fRotateStepFrame, " Step:" );
  fLayout          = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 10, 2, 0, 0 );
  fWidgets->Add( fLayout );
  fRotateStepFrame->AddFrame( fRotateStepLabel, fLayout );
 
  // input of rotate step
  fNumEntryRotateStep =
      new TGNumberEntryField( fRotateStepFrame, kM_Button_RotateStep, this->GetRotateStep(),
                              (TGNumberFormat::EStyle)2, (TGNumberFormat::EAttribute)1 );
  h     = fNumEntryRotateStep->GetDefaultHeight();
  charw = fNumEntryRotateStep->GetCharWidth( "0123456" );
  w     = charw * TMath::Abs( 5 ) / 10 + 8 + 2 * h / 3; // 5 is digit width
  fNumEntryRotateStep->Resize( w, h );
 
  fNumEntryRotateStep->SetHeight( 20 );
  fNumEntryRotateStep->SetNumber( this->GetRotateStep() );
  fNumEntryRotateStep->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  fNumEntryRotateStep->Connect( "TabPressed()", "BesClient", this, "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fRotateStepFrame->AddFrame( fNumEntryRotateStep, fLayout );
 
  // label " deg "
  fRotateStepUnitLabel = new TGLabel( fRotateStepFrame, " deg " );
  fLayout              = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 0, 4, 0, 0 );
  fWidgets->Add( fLayout );
  fRotateStepFrame->AddFrame( fRotateStepUnitLabel, fLayout );
 
  // frame ViewContent
  fViewContentFrame = new TGCompositeFrame( fViewFrame, fViewFrame->GetWidth(),
                                            fViewFrame->GetHeight() - 30, kVerticalFrame );
  fLayout           = new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewFrame->AddFrame( fViewContentFrame, fLayout );
 
  // frame ViewContent Line1
  fViewContent1Frame =
      new TGCompositeFrame( fViewContentFrame, fViewFrame->GetWidth(), 39, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 3, 0 );
  fWidgets->Add( fLayout );
  fViewContent1Frame->SetBackgroundPixmap( GetPic( "ViewContent1Bckgnd.gif" ) );
  fViewContentFrame->AddFrame( fViewContent1Frame, fLayout );
 
  // button ViewCounterClockwise
  fViewCounterClockWiseButton = new BesGPictureButton(
      fViewContent1Frame, gClient->GetPicture( "ViewCounterClockwise.gif" ),
      kM_Button_ViewCounterClockWise );
  fViewCounterClockWiseButton->SetToolTipText( "Rotate Counter Clockwise" );
  fViewCounterClockWiseButton->SetHeight( 37 );
  fViewCounterClockWiseButton->SetWidth( 37 );
  fViewCounterClockWiseButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 5, 22, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent1Frame->AddFrame( fViewCounterClockWiseButton, fLayout );
 
  // button ViewMoveUp
  fViewMoveUpButton = new BesGPictureButton(
      fViewContent1Frame, gClient->GetPicture( "ViewMoveUp.gif" ), kM_Button_ViewMoveUp );
  fViewMoveUpButton->SetToolTipText( "Move Up" );
  fViewMoveUpButton->SetHeight( 20 );
  fViewMoveUpButton->SetWidth( 23 );
  fViewMoveUpButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsBottom | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent1Frame->AddFrame( fViewMoveUpButton, fLayout );
 
  // button ViewClockwise
  fViewClockWiseButton =
      new BesGPictureButton( fViewContent1Frame, gClient->GetPicture( "ViewClockwise.gif" ),
                             kM_Button_ViewClockWise );
  fViewClockWiseButton->SetToolTipText( "Rotate Clockwise" );
  fViewClockWiseButton->SetHeight( 37 );
  fViewClockWiseButton->SetWidth( 37 );
  fViewClockWiseButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 22, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent1Frame->AddFrame( fViewClockWiseButton, fLayout );
 
  // frame ViewContent Line2
  fViewContent2Frame =
      new TGCompositeFrame( fViewContentFrame, fViewFrame->GetWidth(), 23, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent2Frame->SetBackgroundPixmap( GetPic( "ViewContent2Bckgnd.gif" ) );
  fViewContentFrame->AddFrame( fViewContent2Frame, fLayout );
 
  // button ViewMoveLeft
  fViewMoveLeftButton = new BesGPictureButton(
      fViewContent2Frame, gClient->GetPicture( "ViewMoveLeft.gif" ), kM_Button_ViewMoveLeft );
  fViewMoveLeftButton->SetToolTipText( "Move Left" );
  fViewMoveLeftButton->SetHeight( 23 );
  fViewMoveLeftButton->SetWidth( 23 );
  fViewMoveLeftButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsBottom | kLHintsCenterX, 49, 2, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent2Frame->AddFrame( fViewMoveLeftButton, fLayout );
 
  // button ViewMoveMoveCenter
  fViewMoveCenterButton =
      new BesGPictureButton( fViewContent2Frame, gClient->GetPicture( "ViewMoveCenter.gif" ),
                             kM_Button_ViewMoveCenter );
  fViewMoveCenterButton->SetToolTipText( "Move Center" );
  fViewMoveCenterButton->SetHeight( 13 );
  fViewMoveCenterButton->SetWidth( 13 );
  fViewMoveCenterButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsCenterX, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent2Frame->AddFrame( fViewMoveCenterButton, fLayout );
 
  // button ViewMoveRight
  fViewMoveRightButton =
      new BesGPictureButton( fViewContent2Frame, gClient->GetPicture( "ViewMoveRight.gif" ),
                             kM_Button_ViewMoveRight );
  fViewMoveRightButton->SetToolTipText( "Move Right" );
  fViewMoveRightButton->SetHeight( 23 );
  fViewMoveRightButton->SetWidth( 23 );
  fViewMoveRightButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsBottom | kLHintsCenterX, 2, 49, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent2Frame->AddFrame( fViewMoveRightButton, fLayout );
 
  // frame ViewContent Line3
  fViewContent3Frame =
      new TGCompositeFrame( fViewContentFrame, fViewFrame->GetWidth(), 32, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 0, 0, 3 );
  fWidgets->Add( fLayout );
  fViewContent3Frame->SetBackgroundPixmap( GetPic( "ViewContent3Bckgnd.gif" ) );
  fViewContentFrame->AddFrame( fViewContent3Frame, fLayout );
 
  // button ViewMoveDown
  fViewMoveDownButton = new BesGPictureButton(
      fViewContent3Frame, gClient->GetPicture( "ViewMoveDown.gif" ), kM_Button_ViewMoveDown );
  fViewMoveDownButton->SetToolTipText( "Move Down" );
  fViewMoveDownButton->SetHeight( 32 );
  fViewMoveDownButton->SetWidth( 23 );
  fViewMoveDownButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  // fLayout = new TGLayoutHints(kLHintsCenterY | kLHintsCenterX, 69, 69, 0, 0);
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 69, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent3Frame->AddFrame( fViewMoveDownButton, fLayout );
 
  // reset angle button
  fViewResetAngleButton =
      new BesGPictureButton( fViewContent3Frame, gClient->GetPicture( "ViewResetAngle.gif" ),
                             kM_Button_ViewResetAngle );
 
  fViewResetAngleButton->SetToolTipText( "Reset Angles" );
  fViewResetAngleButton->SetHeight( 27 );
  fViewResetAngleButton->SetWidth( 27 );
  fViewResetAngleButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 30, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContent3Frame->AddFrame( fViewResetAngleButton, fLayout );
 
  // frame ViewAngle
  fViewAngleFrame = new TGCompositeFrame( fViewContentFrame, fViewContentFrame->GetWidth(), 50,
                                          kHorizontalFrame );
  fLayout         = new TGLayoutHints( kLHintsLeft | kLHintsTop, 4, 4, 0, 0 );
  fWidgets->Add( fLayout );
  fViewContentFrame->AddFrame( fViewAngleFrame, fLayout );
 
  // frame ViewAngleTheta
  fViewAngleThetaFrame =
      new TGCompositeFrame( fViewAngleFrame, fViewAngleFrame->GetWidth(), 50, kVerticalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 3, 3, 3, 3 );
  fWidgets->Add( fLayout );
  fViewAngleFrame->AddFrame( fViewAngleThetaFrame, fLayout );
 
  // button ViewAngleThetaMinus
  fViewAngleThetaMinusButton =
      new BesGPictureButton( fViewAngleThetaFrame, gClient->GetPicture( "ViewAngleMinus.gif" ),
                             kM_Button_ViewAngleThetaMinus );
  fViewAngleThetaMinusButton->SetToolTipText( "Theta -" );
  fViewAngleThetaMinusButton->SetHeight( 22 );
  fViewAngleThetaMinusButton->SetWidth( 22 );
  fViewAngleThetaMinusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAngleThetaFrame->AddFrame( fViewAngleThetaMinusButton, fLayout );
 
  // slider for ViewAngleTheta
  fViewAngleThetaSlider = new TGVSlider( fViewAngleThetaFrame, 120, kSlider2 | kScaleBoth,
                                         kM_Slider_ViewAngleTheta );
  fViewAngleThetaSlider->Connect( "PositionChanged(Int_t)", "BesClient", this,
                                  "HandleSliders(Int_t)" );
  fViewAngleThetaSlider->SetRange( 0, 180 );
  fViewAngleThetaSlider->SetPosition( 0 );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsCenterX | kLHintsExpandY, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAngleThetaFrame->AddFrame( fViewAngleThetaSlider, fLayout );
 
  // button ViewAngleThetaPlus
  fViewAngleThetaPlusButton =
      new BesGPictureButton( fViewAngleThetaFrame, gClient->GetPicture( "ViewAnglePlus.gif" ),
                             kM_Button_ViewAngleThetaPlus );
  fViewAngleThetaPlusButton->SetToolTipText( "Theta +" );
  fViewAngleThetaPlusButton->SetHeight( 22 );
  fViewAngleThetaPlusButton->SetWidth( 22 );
  fViewAngleThetaPlusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAngleThetaFrame->AddFrame( fViewAngleThetaPlusButton, fLayout );
 
  // number ViewAngleTheta
  // fViewAngleThetaNumber = new TGNumberEntry( fViewAngleThetaFrame, 0, 3,
  // kM_Button_ViewAngleThetaNumber,
  // (TGNumberFormat::EStyle) 6, (TGNumberFormat::EAttribute) 0
  //);
  fViewAngleThetaNumber =
      new TGNumberEntryField( fViewAngleThetaFrame, kM_Button_ViewAngleThetaNumber,
                              fViewAngleThetaSlider->GetPosition(), (TGNumberFormat::EStyle)1,
                              (TGNumberFormat::EAttribute)0 );
  fViewAngleThetaNumber->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  h     = fViewAngleThetaNumber->GetDefaultHeight();
  charw = fViewAngleThetaNumber->GetCharWidth( "0123456" );
  w     = charw * TMath::Abs( 4 ) / 10 + 8 + 2 * h / 3; // 4 is digit width
  fViewAngleThetaNumber->Resize( w, h );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 0 );
  fWidgets->Add( fLayout );
  fViewAngleThetaFrame->AddFrame( fViewAngleThetaNumber, fLayout );
 
  // label theta
  fViewAngleThetaLabel = new TGLabel( fViewAngleThetaFrame, "theta" );
  fLayout              = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 2 );
  fWidgets->Add( fLayout );
  fViewAngleThetaFrame->AddFrame( fViewAngleThetaLabel, fLayout );
 
  // frame ViewAnglePhi
  fViewAnglePhiFrame =
      new TGCompositeFrame( fViewAngleFrame, fViewAngleFrame->GetWidth(), 50, kVerticalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 3, 3, 3, 3 );
  fWidgets->Add( fLayout );
  fViewAngleFrame->AddFrame( fViewAnglePhiFrame, fLayout );
 
  // button ViewAnglePhiMinus
  fViewAnglePhiMinusButton =
      new BesGPictureButton( fViewAnglePhiFrame, gClient->GetPicture( "ViewAngleMinus.gif" ),
                             kM_Button_ViewAnglePhiMinus );
  fViewAnglePhiMinusButton->SetToolTipText( "Phi -" );
  fViewAnglePhiMinusButton->SetHeight( 22 );
  fViewAnglePhiMinusButton->SetWidth( 22 );
  fViewAnglePhiMinusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePhiFrame->AddFrame( fViewAnglePhiMinusButton, fLayout );
 
  // slider for ViewAnglePhi
  fViewAnglePhiSlider =
      new TGVSlider( fViewAnglePhiFrame, 120, kSlider2 | kScaleBoth, kM_Slider_ViewAnglePhi );
  fViewAnglePhiSlider->Connect( "PositionChanged(Int_t)", "BesClient", this,
                                "HandleSliders(Int_t)" );
  fViewAnglePhiSlider->SetRange( 0, 360 );
  fViewAnglePhiSlider->SetPosition( 0 );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsCenterX | kLHintsExpandY, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePhiFrame->AddFrame( fViewAnglePhiSlider, fLayout );
 
  // button ViewAnglePhiPlus
  fViewAnglePhiPlusButton =
      new BesGPictureButton( fViewAnglePhiFrame, gClient->GetPicture( "ViewAnglePlus.gif" ),
                             kM_Button_ViewAnglePhiPlus );
  fViewAnglePhiPlusButton->SetToolTipText( "Phi +" );
  fViewAnglePhiPlusButton->SetHeight( 22 );
  fViewAnglePhiPlusButton->SetWidth( 22 );
  fViewAnglePhiPlusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePhiFrame->AddFrame( fViewAnglePhiPlusButton, fLayout );
 
  // number ViewAnglePhi
  // fViewAnglePhiNumber = new TGNumberEntry( fViewAnglePhiFrame, 0, 3,
  // kM_Button_ViewAnglePhiNumber,
  // (TGNumberFormat::EStyle) 6, (TGNumberFormat::EAttribute) 0
  //);
  fViewAnglePhiNumber = new TGNumberEntryField(
      fViewAnglePhiFrame, kM_Button_ViewAnglePhiNumber, fViewAnglePhiSlider->GetPosition(),
      (TGNumberFormat::EStyle)1, (TGNumberFormat::EAttribute)0 );
  fViewAnglePhiNumber->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  h     = fViewAnglePhiNumber->GetDefaultHeight();
  charw = fViewAnglePhiNumber->GetCharWidth( "0123456" );
  w     = charw * TMath::Abs( 4 ) / 10 + 8 + 2 * h / 3; // 4 is digit width
  fViewAnglePhiNumber->Resize( w, h );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePhiFrame->AddFrame( fViewAnglePhiNumber, fLayout );
 
  // label phi
  fViewAnglePhiLabel = new TGLabel( fViewAnglePhiFrame, "phi" );
  fLayout            = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 2 );
  fWidgets->Add( fLayout );
  fViewAnglePhiFrame->AddFrame( fViewAnglePhiLabel, fLayout );
 
  // frame ViewAnglePsi
  fViewAnglePsiFrame =
      new TGCompositeFrame( fViewAngleFrame, fViewAngleFrame->GetWidth(), 50, kVerticalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop, 3, 3, 3, 3 );
  fWidgets->Add( fLayout );
  fViewAngleFrame->AddFrame( fViewAnglePsiFrame, fLayout );
 
  // button ViewAnglePsiMinus
  fViewAnglePsiMinusButton =
      new BesGPictureButton( fViewAnglePsiFrame, gClient->GetPicture( "ViewAngleMinus.gif" ),
                             kM_Button_ViewAnglePsiMinus );
  fViewAnglePsiMinusButton->SetToolTipText( "Psi -" );
  fViewAnglePsiMinusButton->SetHeight( 22 );
  fViewAnglePsiMinusButton->SetWidth( 22 );
  fViewAnglePsiMinusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePsiFrame->AddFrame( fViewAnglePsiMinusButton, fLayout );
 
  // slider for ViewAnglePsi
  fViewAnglePsiSlider =
      new TGVSlider( fViewAnglePsiFrame, 120, kSlider2 | kScaleBoth, kM_Slider_ViewAnglePsi );
  fViewAnglePsiSlider->Connect( "PositionChanged(Int_t)", "BesClient", this,
                                "HandleSliders(Int_t)" );
  fViewAnglePsiSlider->SetRange( 0, 360 );
  fViewAnglePsiSlider->SetPosition( 270 );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsCenterX | kLHintsExpandY, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePsiFrame->AddFrame( fViewAnglePsiSlider, fLayout );
 
  // button ViewAnglePsiPlus
  fViewAnglePsiPlusButton =
      new BesGPictureButton( fViewAnglePsiFrame, gClient->GetPicture( "ViewAnglePlus.gif" ),
                             kM_Button_ViewAnglePsiPlus );
  fViewAnglePsiPlusButton->SetToolTipText( "Psi +" );
  fViewAnglePsiPlusButton->SetHeight( 22 );
  fViewAnglePsiPlusButton->SetWidth( 22 );
  fViewAnglePsiPlusButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 5, 5, 0, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePsiFrame->AddFrame( fViewAnglePsiPlusButton, fLayout );
 
  // number ViewAnglePsi
  // fViewAnglePsiNumber = new TGNumberEntry( fViewAnglePsiFrame, 0, 3,
  // kM_Button_ViewAnglePsiNumber,
  // (TGNumberFormat::EStyle) 6, (TGNumberFormat::EAttribute) 0
  //);
  fViewAnglePsiNumber = new TGNumberEntryField(
      fViewAnglePsiFrame, kM_Button_ViewAnglePsiNumber, fViewAnglePsiSlider->GetPosition(),
      (TGNumberFormat::EStyle)1, (TGNumberFormat::EAttribute)0 );
  fViewAnglePsiNumber->Connect( "ReturnPressed()", "BesClient", this, "ExecuteReturn()" );
  h     = fViewAnglePsiNumber->GetDefaultHeight();
  charw = fViewAnglePsiNumber->GetCharWidth( "0123456" );
  w     = charw * TMath::Abs( 4 ) / 10 + 8 + 2 * h / 3; // 4 is digit width
  fViewAnglePsiNumber->Resize( w, h );
 
  fLayout = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 0 );
  fWidgets->Add( fLayout );
  fViewAnglePsiFrame->AddFrame( fViewAnglePsiNumber, fLayout );
 
  // label psi
  fViewAnglePsiLabel = new TGLabel( fViewAnglePsiFrame, "psi" );
  fLayout            = new TGLayoutHints( kLHintsTop | kLHintsCenterX, 2, 2, 2, 2 );
  fWidgets->Add( fLayout );
  fViewAnglePsiFrame->AddFrame( fViewAnglePsiLabel, fLayout );
 
  //
  // "Event" tab
  // ================
  tf = fTabs->AddTab( "Event" );
  tf->SetBackgroundPixmap( GetPic( "8.gif" ) );
 
  //
  // frame for event control
  // =====================
  fEventControlFrame =
      new TGCompositeFrame( tf, tf->GetWidth(), tf->GetHeight(), kVerticalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 15, 15, 15, 10 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fEventControlFrame, fLayout );
  fEventControlFrame->SetBackgroundPixmap( GetPic( "EventFrameBckgnd.gif" ) );
 
  // lable "Event control"
  fEventControlTextFrame = new TGCompositeFrame(
      fEventControlFrame, fEventControlFrame->GetWidth(), 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX, 0, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fEventControlTextFrame, fLayout );
  fEventControlTextFrame->SetBackgroundPixmap( GetPic( "EventControlBckgnd.gif" ) );
 
  fEventControlTextLabel = new TGLabel( fEventControlTextFrame, "Event Control " );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft | kLHintsExpandX, 2, 73, 4, 4 );
  fWidgets->Add( fLayout );
  fEventControlTextFrame->AddFrame( fEventControlTextLabel, fLayout );
  fEventControlTextLabel->SetBackgroundPixmap( GetPic( "EventControlBckgnd.gif" ) );
 
  // input of run nr
  fBesRunFrame =
      new TGHorizontalFrame( fEventControlFrame, fEventControlFrame->GetWidth(), 25 );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsExpandX, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fBesRunFrame, fLayout );
  fBesRunFrame->SetBackgroundPixmap( GetPic( "EventFrameBckgnd.gif" ) );
 
  fBesLabelRun = new TGLabel( fBesRunFrame, "Run : " );
  fLayout      = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fBesRunFrame->AddFrame( fBesLabelRun, fLayout );
 
  fNumEntryRunNo = new TGNumberEntry(
      fBesRunFrame, this->GetBesRunNo(), 12, kM_Button_BesRun, (TGNumberFormat::EStyle)0,
      (TGNumberFormat::EAttribute)1 ); // 16 is ditits number in the entry
  fNumEntryRunNo->SetHeight( 20 );
  fNumEntryRunNo->SetNumber( this->GetBesRunNo() );
  fNumEntryRunNo->GetNumberEntry()->Connect( "ReturnPressed()", "BesClient", this,
                                             "ExecuteReturn()" );
  fNumEntryRunNo->GetNumberEntry()->Connect( "TabPressed()", "BesClient", this,
                                             "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fBesRunFrame->AddFrame( fNumEntryRunNo, fLayout );
 
  // input of Event nr
  fBesEventFrame =
      new TGHorizontalFrame( fEventControlFrame, fEventControlFrame->GetWidth(), 25 );
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsExpandX, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fBesEventFrame, fLayout );
 
  fBesLabelEvent = new TGLabel( fBesEventFrame, "Event : " );
  fLayout        = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fBesEventFrame->AddFrame( fBesLabelEvent, fLayout );
 
  fNumEntryEventNo =
      new TGNumberEntry( fBesEventFrame, this->GetBesEventNo(), 12, kM_Button_BesEvent,
                         (TGNumberFormat::EStyle)0, (TGNumberFormat::EAttribute)1 );
  fNumEntryEventNo->SetHeight( 20 );
  fNumEntryEventNo->SetNumber( this->GetBesEventNo() );
  fNumEntryEventNo->GetNumberEntry()->Connect( "ReturnPressed()", "BesClient", this,
                                               "ExecuteReturn()" );
  fNumEntryEventNo->GetNumberEntry()->Connect( "TabPressed()", "BesClient", this,
                                               "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fBesEventFrame->AddFrame( fNumEntryEventNo, fLayout );
 
  //
  // frame for event play
  // ====================
 
  // slider for event play
  fEventPlaySlider =
      new TGHSlider( fEventControlFrame, 40, kSlider1 | kScaleNo, kM_Slider_EventPlay );
  fEventPlaySlider->Connect( "PositionChanged(Int_t)", "BesClient", this,
                             "HandleSliders(Int_t)" );
  fEventPlaySlider->SetRange( 0, 100 );
  fEventPlaySlider->SetPosition( 0 );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsCenterX | kLHintsExpandX, 5, 5, 5, 0 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fEventPlaySlider, fLayout );
 
  // event play buttons
  fEventPlayButtonFrame = new TGCompositeFrame(
      fEventControlFrame, fEventControlFrame->GetWidth(), 30, kHorizontalFrame );
  // fEventNavFrame->SetBackgroundPixmap(GetPic("1.gif"));
  fLayout = new TGLayoutHints( kLHintsCenterX | kLHintsTop, 2, 2, 2, 2 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fEventPlayButtonFrame, fLayout );
 
  // prev button
  fPrevEventButton = new BesGPictureButton( fEventPlayButtonFrame,
                                            gClient->GetPicture( "ButtonEventPrev.gif" ),
                                            kM_Button_PrevEvent );
  fPrevEventButton->SetToolTipText( "Previous Event" );
  fPrevEventButton->SetHeight( 26 );
  fPrevEventButton->SetWidth( 25 );
  fPrevEventButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 8, 0, 0, 4 );
  fWidgets->Add( fLayout );
  fEventPlayButtonFrame->AddFrame( fPrevEventButton, fLayout );
 
  // next button
  fNextEventButton = new BesGPictureButton( fEventPlayButtonFrame,
                                            gClient->GetPicture( "ButtonEventNext.gif" ),
                                            kM_Button_NextEvent );
  fNextEventButton->SetToolTipText( "Next Event" );
  fNextEventButton->SetHeight( 26 );
  fNextEventButton->SetWidth( 26 );
  fNextEventButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsCenterY, 0, 10, 0, 4 );
  fWidgets->Add( fLayout );
  fEventPlayButtonFrame->AddFrame( fNextEventButton, fLayout );
 
  // play button
  fPlayEventButton = new BesGPictureButton( fEventPlayButtonFrame,
                                            gClient->GetPicture( "ButtonEventPlay.gif" ),
                                            kM_Button_PlayEvent );
  fPlayEventButton->SetToolTipText( "Play Event" );
  fPlayEventButton->SetHeight( 35 );
  fPlayEventButton->SetWidth( 34 );
  fPlayEventButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 5, 0, 0, 4 );
  fWidgets->Add( fLayout );
  fEventPlayButtonFrame->AddFrame( fPlayEventButton, fLayout );
 
  // first button
  fFirstEventButton = new BesGPictureButton( fEventPlayButtonFrame,
                                             gClient->GetPicture( "ButtonEventReturn.gif" ),
                                             kM_Button_FirstEvent );
  fFirstEventButton->SetToolTipText( "First Event" );
  fFirstEventButton->SetHeight( 35 );
  fFirstEventButton->SetWidth( 25 );
  fFirstEventButton->Connect( "Clicked()", "BesClient", this, "HandleButtons()" );
 
  fLayout = new TGLayoutHints( kLHintsLeft | kLHintsCenterY, 0, 8, 0, 4 );
  fWidgets->Add( fLayout );
  fEventPlayButtonFrame->AddFrame( fFirstEventButton, fLayout );
 
  // lable "Event Play"
  fEventPlayTextFrame = new TGCompositeFrame(
      fEventControlFrame, fEventControlFrame->GetWidth(), 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsCenterX | kLHintsTop, 2, 2, 2, 2 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fEventPlayTextFrame, fLayout );
 
  fEventPlayTextLabel = new TGLabel( fEventPlayTextFrame, "Prev,Next,Play/Stop,Return" );
  fLayout             = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 5, 4, 2, 5 );
  fWidgets->Add( fLayout );
  fEventPlayTextFrame->AddFrame( fEventPlayTextLabel, fLayout );
 
  // play speed
  fEventPlaySpeedFrame = new TGCompositeFrame(
      fEventControlFrame, fEventControlFrame->GetWidth(), 30, kHorizontalFrame );
  fLayout = new TGLayoutHints( kLHintsCenterX | kLHintsTop, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fEventControlFrame->AddFrame( fEventPlaySpeedFrame, fLayout );
 
  // input of speed
  fNumEntryEventPlaySpeed = new TGNumberEntry(
      fEventPlaySpeedFrame, (Double_t)this->GetEventPlaySpeed() / 1000.0, 4,
      kM_Button_EventPlaySpeed, (TGNumberFormat::EStyle)1, (TGNumberFormat::EAttribute)1 );
  fNumEntryEventPlaySpeed->SetHeight( 20 );
  fNumEntryEventPlaySpeed->SetNumber( this->GetEventPlaySpeed() / 1000.0 );
  fNumEntryEventPlaySpeed->GetNumberEntry()->Connect( "ReturnPressed()", "BesClient", this,
                                                      "ExecuteReturn()" );
  fNumEntryEventPlaySpeed->GetNumberEntry()->Connect( "TabPressed()", "BesClient", this,
                                                      "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fEventPlaySpeedFrame->AddFrame( fNumEntryEventPlaySpeed, fLayout );
 
  // label "Play Speed : "
  fEventPlaySpeedLabel = new TGLabel( fEventPlaySpeedFrame, " sec/event " );
  fLayout              = new TGLayoutHints( kLHintsCenterY | kLHintsRight, 2, 4, 4, 10 );
  fWidgets->Add( fLayout );
  fEventPlaySpeedFrame->AddFrame( fEventPlaySpeedLabel, fLayout );
 
  /*
  //
  // frame for file list
  // ===================
  fEventListFrame = new TGCompositeFrame(tf, tf->GetWidth(), tf->GetHeight(), kVerticalFrame);
  fLayout = new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsBottom | kLHintsExpandX |
  kLHintsExpandY , 15, 15, 10, 200); fWidgets->Add(fLayout);
  //tf->AddFrame(fEventListFrame, fLayout);
  fEventListFrame->SetBackgroundPixmap(GetPic("12.gif"));
 
  // lable "File list"
  fEventListTextFrame = new TGCompositeFrame(fEventListFrame, fEventListFrame->GetWidth(), 30,
  kHorizontalFrame); fLayout = new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsExpandX, 0,
  0, 0, 0); fWidgets->Add(fLayout); fEventListFrame->AddFrame(fEventListTextFrame, fLayout);
  fEventListTextFrame->SetBackgroundPixmap(GetPic("11.gif"));
 
  fEventListTextLabel = new TGLabel(fEventListTextFrame,"Event file list  ");
  fLayout = new TGLayoutHints(kLHintsCenterY | kLHintsLeft | kLHintsExpandX , 2, 73, 4, 4);
  fWidgets->Add(fLayout);
  fEventListTextFrame->AddFrame(fEventListTextLabel, fLayout);
  fEventListTextLabel->SetBackgroundPixmap(GetPic("11.gif"));
 
  // frame EventListContent
  fEventListContentFrame = new TGCompositeFrame(fEventListFrame, fEventListFrame->GetWidth(),
  fEventListFrame->GetHeight()-30, kVerticalFrame); fLayout = new TGLayoutHints(kLHintsExpandX
  | kLHintsExpandY , 10, 10, 10, 10); fWidgets->Add(fLayout);
  fEventListFrame->AddFrame(fEventListContentFrame, fLayout);
 
  fEventListView = new TGCanvas(fEventListContentFrame, 2, 2, kSunkenFrame | kDoubleBorder);
 
  fEventListTree = new TGListTree(fEventListView->GetViewPort(), 2, 2, kHorizontalFrame);
 
  fEventListView->SetContainer(fEventListTree);
  fEventListTree->SetCanvas(fEventListView);
  fLayout = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0);
  fWidgets->Add(fLayout);
  fEventListContentFrame->AddFrame(fEventListView, fLayout);
 
  // Connect event list tree
  fEventListTree->Connect("Clicked(TGListTreeItem*, Int_t)",
              "BesClient", this,
          "HandleEventList(TGListTreeItem*, Int_t)");
 
  // init active tree item
  fItem = 0;
  fRunItem = 0;
  */
 
  // "Show DST Info" tab
  // ================
  tf = fTabs->AddTab( "REC" );
  // tf = fTabs->AddTab("DST");
  tf->SetBackgroundPixmap( GetPic( "8.gif" ) );
 
  // Header
  fFrameHeader = new TGGroupFrame( tf, "Header" );
  fLayout      = new TGLayoutHints( kLHintsExpandX, 15, 15, 15,
                                    5 ); // Long Peixun's update: Reduce spacing, bottom 15 -> 5
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameHeader, fLayout );
  fChkBtnHeaderGlobal = new TGCheckButton( fFrameHeader, "Header", kM_Header_Global );
  fFrameHeader->AddFrame( fChkBtnHeaderGlobal );
  fChkBtnHeaderGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Hits
  fFrameHits = new TGGroupFrame( tf, "Hits" );
  fLayout    = new TGLayoutHints( kLHintsExpandX, 15, 15, 15,
                                  5 ); // Long Peixun's update: Reduce spacing, bottom 15 -> 5
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameHits, fLayout );
 
  //------------------------------------------
 
  fChkBtnMdcHitsGlobal = new TGCheckButton( fFrameHits, "Mdc hits", kM_MdcHits_Global );
  fFrameHits->AddFrame( fChkBtnMdcHitsGlobal );
 
  fChkBtnTofHitsGlobal = new TGCheckButton( fFrameHits, "Tof  hits", kM_TofHits_Global );
  fFrameHits->AddFrame( fChkBtnTofHitsGlobal );
 
  fChkBtnTofHitsEast = new TGCheckButton( fFrameHits, " East ", kM_TofHits_East );
  fLayout            = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fFrameHits->AddFrame( fChkBtnTofHitsEast, fLayout );
 
  fChkBtnTofHitsBarrel = new TGCheckButton( fFrameHits, " Barrel ", kM_TofHits_Barrel );
  fFrameHits->AddFrame( fChkBtnTofHitsBarrel, fLayout );
 
  fChkBtnTofHitsWest = new TGCheckButton( fFrameHits, " West ", kM_TofHits_West );
  fFrameHits->AddFrame( fChkBtnTofHitsWest, fLayout );
 
  fChkBtnEmcHitsGlobal = new TGCheckButton( fFrameHits, "Emc hits", kM_EmcHits_Global );
  fFrameHits->AddFrame( fChkBtnEmcHitsGlobal );
 
  fChkBtnEmcHitsEast = new TGCheckButton( fFrameHits, " East ", kM_EmcHits_East );
  fLayout            = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fFrameHits->AddFrame( fChkBtnEmcHitsEast, fLayout );
 
  fChkBtnEmcHitsBarrel = new TGCheckButton( fFrameHits, " Barrel ", kM_EmcHits_Barrel );
  fFrameHits->AddFrame( fChkBtnEmcHitsBarrel, fLayout );
 
  fChkBtnEmcHitsWest = new TGCheckButton( fFrameHits, " West ", kM_EmcHits_West );
  fFrameHits->AddFrame( fChkBtnEmcHitsWest, fLayout );
 
  fChkBtnEmcHitsSide = new TGCheckButton( fFrameHits, " Side ", kM_EmcHits_Side );
  fFrameHits->AddFrame( fChkBtnEmcHitsSide, fLayout );
 
  fChkBtnMucHitsGlobal = new TGCheckButton( fFrameHits, "Muc hits", kM_MucHits_Global );
  fFrameHits->AddFrame( fChkBtnMucHitsGlobal );
 
  fChkBtnMucHitsEast = new TGCheckButton( fFrameHits, " East ", kM_MucHits_East );
  fLayout            = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fFrameHits->AddFrame( fChkBtnMucHitsEast, fLayout );
 
  fChkBtnMucHitsBarrel = new TGCheckButton( fFrameHits, " Barrel ", kM_MucHits_Barrel );
  fFrameHits->AddFrame( fChkBtnMucHitsBarrel, fLayout );
 
  fChkBtnMucHitsWest = new TGCheckButton( fFrameHits, " West ", kM_MucHits_West );
  fFrameHits->AddFrame( fChkBtnMucHitsWest, fLayout );
 
  fChkBtnMdcHitsGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTofHitsGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTofHitsEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTofHitsBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTofHitsWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnEmcHitsGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnEmcHitsEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnEmcHitsBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnEmcHitsWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnEmcHitsSide->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnMucHitsGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnMucHitsEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnMucHitsBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnMucHitsWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Tracks
  fFrameTracks = new TGGroupFrame( tf, "Tracks" );
  fLayout      = new TGLayoutHints( kLHintsExpandX, 15, 15, 15,
                                    5 ); // Long Peixun's update: Reduce spacing, bottom 15 -> 5
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameTracks, fLayout );
 
  fChkBtnTracksGlobal = new TGCheckButton( fFrameTracks, "Tracks", kM_Tracks_Global );
  fFrameTracks->AddFrame( fChkBtnTracksGlobal );
 
  fChkBtnTracksMdc = new TGCheckButton( fFrameTracks, " Mdc ", kM_Tracks_Mdc );
  fLayout          = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fWidgets->Add( fLayout );
  fFrameTracks->AddFrame( fChkBtnTracksMdc, fLayout );
 
  fChkBtnTracksTof = new TGCheckButton( fFrameTracks, " Tof ", kM_Tracks_Tof );
  fFrameTracks->AddFrame( fChkBtnTracksTof, fLayout );
 
  fChkBtnTracksEmc = new TGCheckButton( fFrameTracks, " Emc ", kM_Tracks_Emc );
  fFrameTracks->AddFrame( fChkBtnTracksEmc, fLayout );
 
  fChkBtnTracksMuc = new TGCheckButton( fFrameTracks, " Muc ", kM_Tracks_Muc );
  fFrameTracks->AddFrame( fChkBtnTracksMuc, fLayout );
 
  fChkBtnTracksExt = new TGCheckButton( fFrameTracks, " Ext ", kM_Tracks_Ext );
  fFrameTracks->AddFrame( fChkBtnTracksExt, fLayout );
 
  fChkBtnTracksGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTracksMdc->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTracksTof->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTracksEmc->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTracksMuc->Connect( "Clicked()", "BesClient", this, "SetState()" );
  fChkBtnTracksExt->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  //
  // "Show Detector" tab
  // ===================
  tf = fTabs->AddTab( "Detector" );
  tf->SetBackgroundPixmap( GetPic( "8.gif" ) );
  // tf->SetBackgroundPixmap(GetPic("3.gif"));
 
  fFrameSubDetector = new TGGroupFrame( tf, "Sub-Detector" );
 
  // SubDetector
  fLayout = new TGLayoutHints( kLHintsExpandX, 15, 15, 15, 15 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameSubDetector, fLayout );
 
  // Mdc
  fChkBtnMdcGlobal = new TGCheckButton( fFrameSubDetector, "Mdc", kM_Mdc_Global );
  fLayout          = new TGLayoutHints( kLHintsExpandX, 0, 0, 10, 0 );
  fFrameSubDetector->AddFrame( fChkBtnMdcGlobal, fLayout );
  fChkBtnMdcGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMdcTubes = new TGCheckButton( fFrameSubDetector, "Tubes", kM_Mdc_Tubes );
  fLayout         = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fFrameSubDetector->AddFrame( fChkBtnMdcTubes, fLayout );
  fChkBtnMdcTubes->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMdcWires = new TGCheckButton( fFrameSubDetector, "Wires", kM_Mdc_Wires );
  fFrameSubDetector->AddFrame( fChkBtnMdcWires, fLayout );
  fChkBtnMdcWires->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Tof
  fChkBtnTofGlobal = new TGCheckButton( fFrameSubDetector, "Tof", kM_Tof_Global );
  fLayout          = new TGLayoutHints( kLHintsExpandX, 0, 0, 10, 0 );
  fFrameSubDetector->AddFrame( fChkBtnTofGlobal, fLayout );
  fChkBtnTofGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnTofEast = new TGCheckButton( fFrameSubDetector, "East EC", kM_Tof_East );
  fLayout        = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fFrameSubDetector->AddFrame( fChkBtnTofEast, fLayout );
  fChkBtnTofEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnTofBarrel = new TGCheckButton( fFrameSubDetector, "Barrel", kM_Tof_Barrel );
  fFrameSubDetector->AddFrame( fChkBtnTofBarrel, fLayout );
  fChkBtnTofBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnTofWest = new TGCheckButton( fFrameSubDetector, "West EC", kM_Tof_West );
  fFrameSubDetector->AddFrame( fChkBtnTofWest, fLayout );
  fChkBtnTofWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Emc
  fChkBtnEmcGlobal = new TGCheckButton( fFrameSubDetector, "Emc", kM_Emc_Global );
  fLayout          = new TGLayoutHints( kLHintsExpandX, 0, 0, 10, 0 );
  fFrameSubDetector->AddFrame( fChkBtnEmcGlobal, fLayout );
  fChkBtnEmcGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnEmcEast = new TGCheckButton( fFrameSubDetector, "East EC", kM_Emc_East );
  fLayout        = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fFrameSubDetector->AddFrame( fChkBtnEmcEast, fLayout );
  fChkBtnEmcEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnEmcBarrel = new TGCheckButton( fFrameSubDetector, "Barrel", kM_Emc_Barrel );
  fFrameSubDetector->AddFrame( fChkBtnEmcBarrel, fLayout );
  fChkBtnEmcBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnEmcWest = new TGCheckButton( fFrameSubDetector, "West EC", kM_Emc_West );
  fFrameSubDetector->AddFrame( fChkBtnEmcWest, fLayout );
  fChkBtnEmcWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnEmcSide = new TGCheckButton( fFrameSubDetector, "Side ", kM_Emc_Side );
  fFrameSubDetector->AddFrame( fChkBtnEmcSide, fLayout );
  fChkBtnEmcSide->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Muc
  fChkBtnMucGlobal = new TGCheckButton( fFrameSubDetector, "Muc", kM_Muc_Global );
  fLayout          = new TGLayoutHints( kLHintsExpandX, 0, 0, 10, 0 );
  fFrameSubDetector->AddFrame( fChkBtnMucGlobal, fLayout );
  fChkBtnMucGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMucEast = new TGCheckButton( fFrameSubDetector, "East EC", kM_Muc_East );
  fLayout        = new TGLayoutHints( kLHintsLeft, 20, 0, 0, 0 );
  fFrameSubDetector->AddFrame( fChkBtnMucEast, fLayout );
  fChkBtnMucEast->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMucBarrel = new TGCheckButton( fFrameSubDetector, "Barrel", kM_Muc_Barrel );
  fFrameSubDetector->AddFrame( fChkBtnMucBarrel, fLayout );
  fChkBtnMucBarrel->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMucWest = new TGCheckButton( fFrameSubDetector, "West EC", kM_Muc_West );
  fFrameSubDetector->AddFrame( fChkBtnMucWest, fLayout );
  fChkBtnMucWest->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMucStrips = new TGCheckButton( fFrameSubDetector, "Strips", kM_Muc_Strips );
  fFrameSubDetector->AddFrame( fChkBtnMucStrips, fLayout );
  fChkBtnMucStrips->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Other parts
  fFrameOthers = new TGGroupFrame( tf, "Others" );
  fLayout      = new TGLayoutHints( kLHintsExpandX, 15, 15, 15, 15 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameOthers, fLayout );
 
  fChkBtnBeamPipe = new TGCheckButton( fFrameOthers, "Beam Pipe", kM_BeamPipe );
  fFrameOthers->AddFrame( fChkBtnBeamPipe );
  fChkBtnBeamPipe->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnZRPlaneOnXY = new TGCheckButton( fFrameOthers, "ZR plane on XY", kM_ZRPlaneOnXY );
  fFrameOthers->AddFrame( fChkBtnZRPlaneOnXY );
  fChkBtnZRPlaneOnXY->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnAxis = new TGCheckButton( fFrameOthers, "Axis", kM_Axis );
  fFrameOthers->AddFrame( fChkBtnAxis );
  fChkBtnAxis->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  //
  // "Others" tab
  // ================
  tf = fTabs->AddTab( "Others" );
  tf->SetBackgroundPixmap( GetPic( "8.gif" ) );
 
  // Mdc TQMatch
  fFrameMdcMatch = new TGGroupFrame( tf, "Mdc Status" );
  fLayout        = new TGLayoutHints( kLHintsExpandX, 15, 15, 15, 15 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameMdcMatch, fLayout );
 
  fChkBtnMdcTMatchGlobal = new TGCheckButton( fFrameMdcMatch, "T Fire", kM_Mdc_TMatch_Global );
  fChkBtnMdcTMatchGlobal->SetState( kButtonDown );
  // fChkBtnMdcTMatchGlobal->SetOn();
  fFrameMdcMatch->AddFrame( fChkBtnMdcTMatchGlobal );
  fChkBtnMdcTMatchGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMdcQMatchGlobal = new TGCheckButton( fFrameMdcMatch, "Q Fire", kM_Mdc_QMatch_Global );
  fChkBtnMdcQMatchGlobal->SetState( kButtonDown );
  // fChkBtnMdcQMatchGlobal->SetOn();
  fFrameMdcMatch->AddFrame( fChkBtnMdcQMatchGlobal );
  fChkBtnMdcQMatchGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnMdcQOverflowGlobal =
      new TGCheckButton( fFrameMdcMatch, "Q Not Overflow", kM_Mdc_QNotOverflow_Global );
  fChkBtnMdcQOverflowGlobal->SetState( kButtonUp );
  // fChkBtnMdcQOverflowGlobal->SetOn();
  fFrameMdcMatch->AddFrame( fChkBtnMdcQOverflowGlobal );
  fChkBtnMdcQOverflowGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Colorful Mdc Wire
  fChkBtnMdcColorfulWireGlobal =
      new TGCheckButton( fFrameMdcMatch, "Colorful Wire", kM_Mdc_ColorfulWire_Global );
  fChkBtnMdcColorfulWireGlobal->SetState( kButtonUp );
  fFrameMdcMatch->AddFrame( fChkBtnMdcColorfulWireGlobal );
  fChkBtnMdcColorfulWireGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Mdc time substract event start time
  fChkBtnMdcTimeSubEvTimeGlobal =
      new TGCheckButton( fFrameMdcMatch, "Sub EvTime", kM_Mdc_MdcTimeSubEvTime_Global );
  fChkBtnMdcTimeSubEvTimeGlobal->SetState( kButtonUp );
  fFrameMdcMatch->AddFrame( fChkBtnMdcTimeSubEvTimeGlobal );
  fChkBtnMdcTimeSubEvTimeGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Tof TQMatch
  fFrameTofMatch = new TGGroupFrame( tf, "Tof TQ Match" );
  fLayout        = new TGLayoutHints( kLHintsExpandX, 15, 15, 15, 15 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameTofMatch, fLayout );
 
  fChkBtnTofTMatchGlobal =
      new TGCheckButton( fFrameTofMatch, "T Match", kM_Tof_TMatch_Global );
  fChkBtnTofTMatchGlobal->SetState( kButtonDown );
  // fChkBtnTofTMatchGlobal->SetOn();
  fFrameTofMatch->AddFrame( fChkBtnTofTMatchGlobal );
  fChkBtnTofTMatchGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  fChkBtnTofQMatchGlobal =
      new TGCheckButton( fFrameTofMatch, "Q Match", kM_Tof_QMatch_Global );
  fChkBtnTofQMatchGlobal->SetState( kButtonDown );
  // fChkBtnTofQMatchGlobal->SetOn();
  fFrameTofMatch->AddFrame( fChkBtnTofQMatchGlobal );
  fChkBtnTofQMatchGlobal->Connect( "Clicked()", "BesClient", this, "SetState()" );
 
  // Magnetic field
  fFrameMagnetic = new TGGroupFrame( tf, "Magnetic Field(Tesla)" );
  fLayout        = new TGLayoutHints( kLHintsExpandX, 15, 15, 15, 15 );
  fWidgets->Add( fLayout );
  tf->AddFrame( fFrameMagnetic, fLayout );
 
  // input of Magnetic field
  fNumEntryMagnetic =
      new TGNumberEntry( fFrameMagnetic, 1.0, 4, kM_Button_Magnetic,
                         TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEAAnyNumber );
  fNumEntryMagnetic->SetHeight( 20 );
  fNumEntryMagnetic->SetNumber( 1.0 );
  fNumEntryMagnetic->GetNumberEntry()->Connect( "ReturnPressed()", "BesClient", this,
                                                "ExecuteReturn()" );
  fNumEntryMagnetic->GetNumberEntry()->Connect( "TabPressed()", "BesClient", this,
                                                "ChangeFocus()" );
  fLayout = new TGLayoutHints( kLHintsCenterY | kLHintsLeft, 4, 4, 4, 4 );
  fWidgets->Add( fLayout );
  fFrameMagnetic->AddFrame( fNumEntryMagnetic, fLayout );
 
  for ( Int_t iTab = 0; iTab < fTabs->GetNumberOfTabs(); iTab++ )
  { fTabs->GetTabTab( iTab )->SetBackgroundPixmap( GetPic( "8.gif" ) ); }
}
 
void BesClient::SetMdcQNotOverflow( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetMdcROOTGeo()->SetQNotOverflow( input ); }
}
 
void BesClient::SetMdcTFire( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetMdcROOTGeo()->SetTFire( input ); }
}
 
void BesClient::SetMdcQFire( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetMdcROOTGeo()->SetQFire( input ); }
}
 
void BesClient::SetMdcColorfulWire( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetMdcROOTGeo()->SetColorfulWire( input ); }
}
 
void BesClient::SetMdcTimeSubEvTime( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetMdcROOTGeo()->SetMdcTimeSubEvTime( input ); }
}
 
void BesClient::SetTofTMatch( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetTofROOTGeo()->SetTMatch( input ); }
}
 
void BesClient::SetTofQMatch( Bool_t input ) {
  if ( gBesGeometry ) { gBesGeometry->GetTofROOTGeo()->SetQMatch( input ); }
}
//_____________________________________________________
 
void BesClient::InitLocal() {
  //
  // init local variables
  if ( gDebug ) cout << "BesClient::InitLocal called!" << endl;
 
  // init widget list
  fWidgets = new TList();
  fLayout  = 0;
 
  gGeometry  = 0;
  gBesCursor = new BesCursor();
  gBesCursor->SetType( kBesPick );
  gBesCursor->SetShowInfo( true );
 
  fAutoDisplayEventTimer = new TTimer( fEventPlaySpeed );
  Connect( fAutoDisplayEventTimer, "Timeout()", "BesClient", this,
           "AutoDisplayEventCommand()" );
 
  fAutoRotateTimer = new TTimer( (Int_t)1000 / fRotateFPS );
  Connect( fAutoRotateTimer, "Timeout()", "BesClient", this, "AutoRotateCommand()" );
 
  /*TColor *milk        = */
  new TColor( 9001, 1.0, 1.0, 225 / 255.0 );
  /*TColor *pink        = */
  new TColor( 9002, 227 / 255.0, 186 / 255.0, 227 / 255.0 );
  /*TColor *lightYellow = */
  new TColor( 9003, 232 / 255.0, 234 / 255.0, 117 / 255.0 );
  /*TColor *orange      = */
  new TColor( 9004, 254 / 255.0, 216 / 255.0, 31 / 255.0 );
  /*TColor *lightBlue   = */
  new TColor( 9005, 175 / 255.0, 192 / 255.0, 227 / 255.0 );
  /*TColor *lightGreen  = */
  new TColor( 9006, 192 / 255.0, 227 / 255.0, 226 / 255.0 );
  /*TColor *lightBrown  = */
  new TColor( 9007, 225 / 255.0, 199 / 255.0, 162 / 255.0 );
}
 
//_____________________________________________________
 
void BesClient::InitParameter() {
  //
  // init local variables
  if ( gDebug ) cout << "BesClient::InitParameter called!" << endl;
 
  // init command line parameter
  fWindowWidth  = 1000;
  fWindowHeight = 710;
 
  fBesVisPath = TString( getenv( "BESVISLIBROOT" ) );
 
  fEventPlaySpeed   = 1000; // 1000 ms/event
  fAutoDisplayEvent = kFALSE;
 
  for ( Int_t i = 0; i < 3; i++ )
  {
    fHomeX[i] = 0.0;
    fHomeY[i] = 0.0;
  }
 
  fMoveFactor  = 0.1;  // factor of move
  fRotateStep  = 1.0;  // 0.1 deg/frame
  fRotateSpeed = 10.0; // 1.0 deg/sec
  fRotateFPS   = 10;   // 10 frame/sec
 
  fAutoRotate          = kFALSE;
  fAutoRotateClockWise = 0;
  fAutoRotateTheta     = 0;
  fAutoRotatePhi       = 0;
  fAutoRotatePsi       = 0;
 
  fBesRunNo   = 0;
  fBesEventNo = 0;
 
  fViewer3DMode = 0;
 
  // Long Peixun's update: Load help.txt to f_HelpText
  TString  docfile = fBesVisPath + "/docs/help.txt";
  ifstream ifile( docfile.Data() );
  if ( ifile )
  {
    stringstream ss;
    int          ch = 0;
    while ( ( ch = ifile.get() ) != EOF ) { ss << static_cast<char>( ch ); }
    f_HelpText = ss.str();
  }
  ifile.close();
 
  // Long Peixun's update: Load geom_sel.txt
  docfile = fBesVisPath + "/docs/geom_sel.txt";
  InitGeoSelector( docfile.Data() );
}
 
//_____________________________________________________
// Long Peixun's update: Initialize geometry selector
void BesClient::InitGeoSelector( const char* geomsel_file ) {
  ifstream ifile( geomsel_file );
  if ( ifile )
  {
    stringstream ss;
    string       line, fname;
    int          startno;
    int          ich = 0;
    while ( ( ich = ifile.get() ) != EOF )
    {
      char ch = static_cast<char>( ich );
      if ( ch == '\n' || ch == '\r' )
      {
        line = ss.str();
        if ( line.length() == 0 || line.find( '#' ) != string::npos )
        {
          ss.clear();
          ss.str( "" );
        }
        else
        {
          fname.clear();
          ss >> fname;
          startno = 0;
          ss >> startno;
          fSelector.addGeomFile( fname.c_str(), startno );
          ss.clear();
          ss.str( "" );
        }
      }
      else ss << ch;
    }
  }
  ifile.close();
}
 
//_____________________________________________________
 
void BesClient::InitConnections() {
  //
  // init connections to internal messaging queues
  if ( gDebug ) cout << "BesClient::InitConnections called!" << endl;
 
  // Connect canvas to mouse actions
  Connect( (TCanvas*)fEmbeddedCanvas->GetCanvas(),
           "ProcessedEvent(Int_t, Int_t, Int_t, TObject*)", "BesClient", this,
           "ExecuteEvent(Int_t, Int_t, Int_t, TObject*)" );
 
  // Connect close button
  Connect( "CloseWindow()", "BesClient", this, "CloseWindow()" );
}
 
//__________________________________________________________________
 
void BesClient::HandleMenu( Int_t id ) {
  //
  // Handle menu items.
 
  switch ( id )
  {
 
    // File
  case kM_File_LoadGeo: LoadGeoFile(); break;
  case kM_File_SaveGeoAs: SaveGeoAs(); break;
  case kM_File_OpenEvent: OpenEventFile(); break;
  case kM_File_SavePicAs: SavePicAs(); break;
  case kM_File_Close:
    gInterpreter->DeleteGlobal( this );
    delete this;
    break;
  case kM_File_Exit:
    CloseWindow(); // terminate theApp no need to use SendCloseMessage()
    break;
 
    // Edit
  case kM_Edit_Editor:
    fEmbeddedCanvas->GetCanvas()->EditorBar();
    break;
 
    // Help
  case kM_Help_Content: Help(); break;
 
  case kM_Help_About:
    new BesAboutHelp( gClient->GetRoot(), this );
    break;
 
    // Default
  default: cerr << "Menu item" << id << "selected" << endl; break;
  }
}
 
//_____________________________________________________
 
void BesClient::HandleViewOptionMenu( Int_t id ) {
  //
  // Handle view option menu items.
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( !view )
  {
    cout << "BesClient::HandleViewOptionMenu(), BesView does not exist in this pad" << endl;
    return;
  }
 
  // Int_t i = 0, px = 0, py = 0;
  // TVirtualGeoPainter *painter = 0;
 
  switch ( id )
  {
  // Long Peixun's update: kM_Header_On -> kM_Header_Global
  case kM_Header_Global:
    if ( fMenuViewOptionHeader->IsEntryChecked( kM_Header_Global ) )
    {
      fMenuViewOptionHeader->UnCheckEntry( kM_Header_Global );
      fDisplay->SetVisHeader( 0 );
    }
    else
    {
      fMenuViewOptionHeader->CheckEntry( kM_Header_Global );
      fDisplay->SetVisHeader( 1 );
    }
    break;
 
  case kM_Mdc_Global:
    if ( fMenuViewOptionMdc->IsEntryChecked( kM_Mdc_Global ) )
    {
      fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Global );
      view->SetVisMdcGlobal( 0 );
    }
    else
    {
      fMenuViewOptionMdc->CheckEntry( kM_Mdc_Global );
      view->SetVisMdcGlobal( 1 );
    }
    break;
 
  case kM_Mdc_Tubes:
    if ( fMenuViewOptionMdc->IsEntryChecked( kM_Mdc_Tubes ) )
    {
      fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Tubes );
      view->SetVisMdcTubes( 0 );
    }
    else
    {
      fMenuViewOptionMdc->CheckEntry( kM_Mdc_Tubes );
      view->SetVisMdcTubes( 1 );
    }
    break;
 
  case kM_Mdc_Wires:
    if ( fMenuViewOptionMdc->IsEntryChecked( kM_Mdc_Wires ) )
    {
      fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Wires );
      view->SetVisMdcWires( 0 );
    }
    else
    {
      fMenuViewOptionMdc->CheckEntry( kM_Mdc_Wires );
      view->SetVisMdcWires( 1 );
    }
    break;
 
  case kM_Tof_Global:
    if ( fMenuViewOptionTof->IsEntryChecked( kM_Tof_Global ) )
    {
      fMenuViewOptionTof->UnCheckEntry( kM_Tof_Global );
      view->SetVisTofGlobal( 0 );
    }
    else
    {
      fMenuViewOptionTof->CheckEntry( kM_Tof_Global );
      view->SetVisTofGlobal( 1 );
    }
    break;
 
  case kM_Tof_East:
    if ( fMenuViewOptionTof->IsEntryChecked( kM_Tof_East ) )
    {
      fMenuViewOptionTof->UnCheckEntry( kM_Tof_East );
      view->SetVisTofEast( 0 );
    }
    else
    {
      fMenuViewOptionTof->CheckEntry( kM_Tof_East );
      view->SetVisTofEast( 1 );
    }
    break;
 
  case kM_Tof_Barrel:
    if ( fMenuViewOptionTof->IsEntryChecked( kM_Tof_Barrel ) )
    {
      fMenuViewOptionTof->UnCheckEntry( kM_Tof_Barrel );
      view->SetVisTofBarrel( 0 );
    }
    else
    {
      fMenuViewOptionTof->CheckEntry( kM_Tof_Barrel );
      view->SetVisTofBarrel( 1 );
    }
    break;
 
  case kM_Tof_West:
    if ( fMenuViewOptionTof->IsEntryChecked( kM_Tof_West ) )
    {
      fMenuViewOptionTof->UnCheckEntry( kM_Tof_West );
      view->SetVisTofWest( 0 );
    }
    else
    {
      fMenuViewOptionTof->CheckEntry( kM_Tof_West );
      view->SetVisTofWest( 1 );
    }
    break;
 
  case kM_Emc_Global:
    if ( fMenuViewOptionEmc->IsEntryChecked( kM_Emc_Global ) )
    {
      fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Global );
      view->SetVisEmcGlobal( 0 );
    }
    else
    {
      fMenuViewOptionEmc->CheckEntry( kM_Emc_Global );
      view->SetVisEmcGlobal( 1 );
    }
    break;
 
  case kM_Emc_East:
    if ( fMenuViewOptionEmc->IsEntryChecked( kM_Emc_East ) )
    {
      fMenuViewOptionEmc->UnCheckEntry( kM_Emc_East );
      view->SetVisEmcEast( 0 );
    }
    else
    {
      fMenuViewOptionEmc->CheckEntry( kM_Emc_East );
      view->SetVisEmcEast( 1 );
    }
    break;
 
  case kM_Emc_Barrel:
    if ( fMenuViewOptionEmc->IsEntryChecked( kM_Emc_Barrel ) )
    {
      fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Barrel );
      view->SetVisEmcBarrel( 0 );
    }
    else
    {
      fMenuViewOptionEmc->CheckEntry( kM_Emc_Barrel );
      view->SetVisEmcBarrel( 1 );
    }
    break;
 
  case kM_Emc_West:
    if ( fMenuViewOptionEmc->IsEntryChecked( kM_Emc_West ) )
    {
      fMenuViewOptionEmc->UnCheckEntry( kM_Emc_West );
      view->SetVisEmcWest( 0 );
    }
    else
    {
      fMenuViewOptionEmc->CheckEntry( kM_Emc_West );
      view->SetVisEmcWest( 1 );
    }
    break;
 
  case kM_Emc_Side:
    if ( fMenuViewOptionEmc->IsEntryChecked( kM_Emc_Side ) )
    {
      fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Side );
      view->SetVisEmcSide( 0 );
    }
    else
    {
      fMenuViewOptionEmc->CheckEntry( kM_Emc_Side );
      view->SetVisEmcSide( 1 );
    }
    break;
 
  case kM_Muc_Global:
    if ( fMenuViewOptionMuc->IsEntryChecked( kM_Muc_Global ) )
    {
      fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Global );
      view->SetVisMucGlobal( 0 );
    }
    else
    {
      fMenuViewOptionMuc->CheckEntry( kM_Muc_Global );
      view->SetVisMucGlobal( 1 );
    }
    break;
 
  case kM_Muc_East:
    if ( fMenuViewOptionMuc->IsEntryChecked( kM_Muc_East ) )
    {
      fMenuViewOptionMuc->UnCheckEntry( kM_Muc_East );
      view->SetVisMucEast( 0 );
    }
    else
    {
      fMenuViewOptionMuc->CheckEntry( kM_Muc_East );
      view->SetVisMucEast( 1 );
    }
    break;
 
  case kM_Muc_Barrel:
    if ( fMenuViewOptionMuc->IsEntryChecked( kM_Muc_Barrel ) )
    {
      fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Barrel );
      view->SetVisMucBarrel( 0 );
    }
    else
    {
      fMenuViewOptionMuc->CheckEntry( kM_Muc_Barrel );
      view->SetVisMucBarrel( 1 );
    }
    break;
 
  case kM_Muc_West:
    if ( fMenuViewOptionMuc->IsEntryChecked( kM_Muc_West ) )
    {
      fMenuViewOptionMuc->UnCheckEntry( kM_Muc_West );
      view->SetVisMucWest( 0 );
    }
    else
    {
      fMenuViewOptionMuc->CheckEntry( kM_Muc_West );
      view->SetVisMucWest( 1 );
    }
    break;
 
  case kM_Muc_Strips:
    if ( fMenuViewOptionMuc->IsEntryChecked( kM_Muc_Strips ) )
    {
      fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Strips );
      view->SetVisMucStrips( 0 );
    }
    else
    {
      fMenuViewOptionMuc->CheckEntry( kM_Muc_Strips );
      view->SetVisMucStrips( 1 );
    }
    break;
 
  case kM_Full3D_Mdc:
    if ( fMenuViewOptionFull3D->IsEntryChecked( kM_Full3D_Mdc ) )
    {
      fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Mdc );
      view->SetVisFull3DMdc( 0 );
    }
    else
    {
      fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Mdc );
      view->SetVisFull3DMdc( 1 );
    }
 
    if ( gBesGeometry )
    {
      gBesGeometry->GetMdcROOTGeo()->SetDetector();
      gBesGeometry->GetMdcROOTGeo()->SetVisMdcDetector();
    }
    break;
 
  case kM_Full3D_Tof:
    if ( fMenuViewOptionFull3D->IsEntryChecked( kM_Full3D_Tof ) )
    {
      fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Tof );
      view->SetVisFull3DTof( 0 );
    }
    else
    {
      fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Tof );
      view->SetVisFull3DTof( 1 );
    }
 
    if ( gBesGeometry )
    {
      gBesGeometry->GetTofROOTGeo()->SetDetector();
      gBesGeometry->GetTofROOTGeo()->SetVisTofDetector();
    }
    break;
 
  case kM_Full3D_Emc:
    if ( fMenuViewOptionFull3D->IsEntryChecked( kM_Full3D_Emc ) )
    {
      fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Emc );
      view->SetVisFull3DEmc( 0 );
    }
    else
    {
      fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Emc );
      view->SetVisFull3DEmc( 1 );
    }
 
    if ( gBesGeometry )
    {
      gBesGeometry->GetEmcROOTGeo()->SetDetector();
      gBesGeometry->GetEmcROOTGeo()->SetVisEmcDetector();
    }
    break;
 
  case kM_Full3D_Muc:
    if ( fMenuViewOptionFull3D->IsEntryChecked( kM_Full3D_Muc ) )
    {
      fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Muc );
      view->SetVisFull3DMuc( 0 );
    }
    else
    {
      fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Muc );
      view->SetVisFull3DMuc( 1 );
    }
 
    if ( gBesGeometry )
    {
      gBesGeometry->GetMucROOTGeo()->SetDetector();
      gBesGeometry->GetMucROOTGeo()->SetVisMucDetector();
    }
    break;
 
  case kM_BeamPipe:
    if ( fMenuViewOptionOthers->IsEntryChecked( kM_BeamPipe ) )
    {
      fMenuViewOptionOthers->UnCheckEntry( kM_BeamPipe );
      view->SetVisBeamPipe( 0 );
    }
    else
    {
      fMenuViewOptionOthers->CheckEntry( kM_BeamPipe );
      view->SetVisBeamPipe( 1 );
    }
    break;
 
  case kM_ZRPlaneOnXY:
    if ( fMenuViewOptionOthers->IsEntryChecked( kM_ZRPlaneOnXY ) )
    {
      fMenuViewOptionOthers->UnCheckEntry( kM_ZRPlaneOnXY );
      view->SetVisZRPlaneOnXY( 0 );
    }
    else
    {
      fMenuViewOptionOthers->CheckEntry( kM_ZRPlaneOnXY );
      view->SetVisZRPlaneOnXY( 1 );
    }
    break;
 
  case kM_Axis:
    if ( fMenuViewOptionOthers->IsEntryChecked( kM_Axis ) )
    {
      fMenuViewOptionOthers->UnCheckEntry( kM_Axis );
      view->SetVisAxis( 0 );
    }
    else
    {
      fMenuViewOptionOthers->CheckEntry( kM_Axis );
      view->SetVisAxis( 1 );
    }
    break;
 
  case kM_MdcHits_Hits:
    if ( fMenuViewOptionMdcHits->IsEntryChecked( kM_MdcHits_Hits ) )
    {
      fMenuViewOptionMdcHits->UnCheckEntry( kM_MdcHits_Hits );
      view->SetVisMdcHits( 0 );
    }
    else
    {
      fMenuViewOptionMdcHits->CheckEntry( kM_MdcHits_Hits );
      view->SetVisMdcHits( 1 );
    }
    break;
 
  case kM_TofHits_Global:
    if ( fMenuViewOptionTofHits->IsEntryChecked( kM_TofHits_Global ) )
    {
      fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_Global );
      view->SetVisTofHitsGlobal( 0 );
    }
    else
    {
      fMenuViewOptionTofHits->CheckEntry( kM_TofHits_Global );
      view->SetVisTofHitsGlobal( 1 );
    }
    break;
 
  case kM_TofHits_East:
    if ( fMenuViewOptionTofHits->IsEntryChecked( kM_TofHits_East ) )
    {
      fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_East );
      view->SetVisTofHitsEast( 0 );
    }
    else
    {
      fMenuViewOptionTofHits->CheckEntry( kM_TofHits_East );
      view->SetVisTofHitsEast( 1 );
    }
    break;
 
  case kM_TofHits_Barrel:
    if ( fMenuViewOptionTofHits->IsEntryChecked( kM_TofHits_Barrel ) )
    {
      fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_Barrel );
      view->SetVisTofHitsBarrel( 0 );
    }
    else
    {
      fMenuViewOptionTofHits->CheckEntry( kM_TofHits_Barrel );
      view->SetVisTofHitsBarrel( 1 );
    }
    break;
 
  case kM_TofHits_West:
    if ( fMenuViewOptionTofHits->IsEntryChecked( kM_TofHits_West ) )
    {
      fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_West );
      view->SetVisTofHitsWest( 0 );
    }
    else
    {
      fMenuViewOptionTofHits->CheckEntry( kM_TofHits_West );
      view->SetVisTofHitsWest( 1 );
    }
    break;
 
  case kM_EmcHits_Global:
    if ( fMenuViewOptionEmcHits->IsEntryChecked( kM_EmcHits_Global ) )
    {
      fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Global );
      view->SetVisEmcHitsGlobal( 0 );
    }
    else
    {
      fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Global );
      view->SetVisEmcHitsGlobal( 1 );
    }
    break;
 
  case kM_EmcHits_East:
    if ( fMenuViewOptionEmcHits->IsEntryChecked( kM_EmcHits_East ) )
    {
      fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_East );
      view->SetVisEmcHitsEast( 0 );
    }
    else
    {
      fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_East );
      view->SetVisEmcHitsEast( 1 );
    }
    break;
 
  case kM_EmcHits_Barrel:
    if ( fMenuViewOptionEmcHits->IsEntryChecked( kM_EmcHits_Barrel ) )
    {
      fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Barrel );
      view->SetVisEmcHitsBarrel( 0 );
    }
    else
    {
      fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Barrel );
      view->SetVisEmcHitsBarrel( 1 );
    }
    break;
 
  case kM_EmcHits_West:
    if ( fMenuViewOptionEmcHits->IsEntryChecked( kM_EmcHits_West ) )
    {
      fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_West );
      view->SetVisEmcHitsWest( 0 );
    }
    else
    {
      fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_West );
      view->SetVisEmcHitsWest( 1 );
    }
    break;
 
  case kM_EmcHits_Side:
    if ( fMenuViewOptionEmcHits->IsEntryChecked( kM_EmcHits_Side ) )
    {
      fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Side );
      view->SetVisEmcHitsSide( 0 );
    }
    else
    {
      fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Side );
      view->SetVisEmcHitsSide( 1 );
    }
    break;
 
  case kM_MucHits_Global:
    if ( fMenuViewOptionMucHits->IsEntryChecked( kM_MucHits_Global ) )
    {
      fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_Global );
      view->SetVisMucHitsGlobal( 0 );
    }
    else
    {
      fMenuViewOptionMucHits->CheckEntry( kM_MucHits_Global );
      view->SetVisMucHitsGlobal( 1 );
    }
    break;
 
  case kM_MucHits_East:
    if ( fMenuViewOptionMucHits->IsEntryChecked( kM_MucHits_East ) )
    {
      fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_East );
      view->SetVisMucHitsEast( 0 );
    }
    else
    {
      fMenuViewOptionMucHits->CheckEntry( kM_MucHits_East );
      view->SetVisMucHitsEast( 1 );
    }
    break;
 
  case kM_MucHits_Barrel:
    if ( fMenuViewOptionMucHits->IsEntryChecked( kM_MucHits_Barrel ) )
    {
      fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_Barrel );
      view->SetVisMucHitsBarrel( 0 );
    }
    else
    {
      fMenuViewOptionMucHits->CheckEntry( kM_MucHits_Barrel );
      view->SetVisMucHitsBarrel( 1 );
    }
    break;
 
  case kM_MucHits_West:
    if ( fMenuViewOptionMucHits->IsEntryChecked( kM_MucHits_West ) )
    {
      fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_West );
      view->SetVisMucHitsWest( 0 );
    }
    else
    {
      fMenuViewOptionMucHits->CheckEntry( kM_MucHits_West );
      view->SetVisMucHitsWest( 1 );
    }
    break;
 
  case kM_Tracks_Global:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Global ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Global );
      view->SetVisTracksGlobal( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Global );
      view->SetVisTracksGlobal( 1 );
    }
    break;
 
  case kM_Tracks_Mdc:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Mdc ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Mdc );
      view->SetVisTracksMdc( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Mdc );
      view->SetVisTracksMdc( 1 );
    }
    break;
 
  case kM_Tracks_Tof:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Tof ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Tof );
      view->SetVisTracksTof( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Tof );
      view->SetVisTracksTof( 1 );
    }
    break;
 
  case kM_Tracks_Emc:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Emc ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Emc );
      view->SetVisTracksEmc( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Emc );
      view->SetVisTracksEmc( 1 );
    }
    break;
 
  case kM_Tracks_Muc:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Muc ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Muc );
      view->SetVisTracksMuc( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Muc );
      view->SetVisTracksMuc( 1 );
    }
    break;
 
  case kM_Tracks_Ext:
    if ( fMenuViewOptionTracks->IsEntryChecked( kM_Tracks_Ext ) )
    {
      fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Ext );
      view->SetVisTracksExt( 0 );
    }
    else
    {
      fMenuViewOptionTracks->CheckEntry( kM_Tracks_Ext );
      view->SetVisTracksExt( 1 );
    }
    break;
 
  case kM_View_X3D: X3D(); break;
 
  case kM_View_OpenGL:
    OpenGL();
    break;
 
    // Default
  default: cerr << "MenuViewOption item" << id << "selected" << endl; break;
  }
 
  view->UpdateView( 0 );
  UpdateStatus();
 
  ( (TCanvas*)fEmbeddedCanvas->GetCanvas() )->Modified();
  ( (TCanvas*)fEmbeddedCanvas->GetCanvas() )->Update();
}
 
//__________________________________________________________________
 
void BesClient::HandleError( const char* msg ) {
  //
  // Error handling
  new TGMsgBox( gClient->GetRoot(), this, "Error", msg, gClient->GetPicture( "mb_stop_s.xpm" ),
                kMBOk ); // Long Peixun's update: kMBDismiss -> kMBOk
}
 
//__________________________________________________________________
 
void BesClient::HandleInfoBar( const char* msg ) {
  //
  // Info handling
  fStatusBar->SetText( msg, 1 );
}
 
//__________________________________________________________________
 
void BesClient::HandleStatusBar( const char* msg ) {
  //
  // Client status handling
  fStatusBar->SetText( msg, 0 );
}
 
//__________________________________________________________________
 
void BesClient::Show() {
  //
  // Show display
  MapWindow();
  MapRaised();
}
 
//__________________________________________________________________
 
void BesClient::LoadGeoFile() {
  //
  // Load BesVis geometry file
 
  // Long Peixun's update: Always popup open geometry dialog box
  //  if ( f_geoFile.Length() != 0){
  //      cout << "Load geoFile f_geoFile: " << f_geoFile << endl;
  //      this->OpenGeoFile(f_geoFile);
  //  }
  //  else {
  //  Open file browser
  static TString GeoDir = fBesVisPath + TString( "/geom/" ); // "."
  TGFileInfo     fi;
  fi.fFileTypes = OpenGeoTypes;
  fi.fIniDir    = StrDup( GeoDir );
  char msg[256];
  sprintf( msg, "Loading Geometry File" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDOpen, &fi );
  if ( &fi == 0 ) return;
  GeoDir = fi.fIniDir;
  this->OpenGeoFile( fi.fFilename ); // fi.fFilename: full path of geofile
  fAutoGeom = false; // Long Peixun's update: Current geometry was selected manually
  // }
}
 
//__________________________________________________________________
 
void BesClient::OpenGeoFile( TString fname ) {
  //
  // Open BesVis geometry file
  // HandleStatusBar("Open Geometry File");
  if ( fname.Length() == 0 ) return;
  char msg[256];
  if ( gDebug ) cout << fname << " fname Length " << fname.Length() << endl;
 
  // Long Peixun's update: consider whether fname contains path or not
  TString fpath, fpurename;
  if ( fname.Contains( "/" ) )
  {                                          // fname contains both path and file name
    Ssiz_t posLastSlash = fname.Last( '/' ); // /scratch/youzy/BesVis/geom.root
    //                                                               |
    fpath     = fname;
    fpath     = fpath.Remove( posLastSlash + 1, fname.Length() - posLastSlash - 1 );
    fpurename = fname; // Long Peixun's update: Get pure name of file
    fpurename = fpurename.Remove( 0, posLastSlash + 1 );
    if ( fpath.Length() == 0 ) return; //  Cancel Button pressed.
  }
  else
  { // fname contains only file name
    fpath     = TString( "" );
    fpurename = fname;
  }
 
  // Long Peixun's update: Judge whether this geometry file is default geometry file;
  TString geompath = fBesVisPath + TString( "/geom/" );
  if ( fname.BeginsWith( geompath ) )
  {
    if ( fSelector.hasGeomFile( fpurename.Data() ) )
    {
      fCurGeom = fpurename;
      cout << "Open a default geometry " << fpurename.Data() << endl;
    }
    else
    {
      fCurGeom = TString( "" );
      cout << "Open a user-defined geometry " << fpurename.Data() << endl;
    }
  }
  else
  {
    fCurGeom = TString( "" );
    cout << "Open a user-defined geometry " << fpurename.Data() << endl;
  }
 
  // Long Peixun's update: Rebuilding geometry is normal operation
  //  if (fDisplay->GetBesGeometry()) {
  //      Int_t ret;
  //      const char *txt;
  //      txt = Form("Geometry has already been build, Yes to rebuild it? \n (Each rebuild
  //      increase memory ~80MB)"); new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
  //                   "Geometry Exist", txt, kMBIconExclamation,
  //                   kMBYes | kMBNo, &ret);
  //      if (ret == kMBNo) return;
  //  }
 
  if ( fname.EndsWith( ".gdml" ) )
  { // Long Peixun update: Contains->EndsWith
    // Long Peixun's update: Decide whether load MRPC and CGEM by the name of selected file
    bool mrpc = false, cgem = false;
    fpurename.ToUpper();
    if ( fpurename.Contains( "MRPC" ) ) mrpc = true;
    // if (fpurename.Contains("CGEM")) cgem = true;
 
    fDisplay->InitGeometryFromGDML( fpath, mrpc, cgem );
    fDisplay->Draw();
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    return;
  }
 
  if ( fname.EndsWith( ".root" ) )
  { // Long Peixun update: Contains->EndsWith
    fGeoFile = TFile::Open( fname, "read" );
 
    TGeoVolume* volBes = (TGeoVolume*)( fGeoFile->Get( "volBes" ) );
 
    if ( volBes )
    {
      fDisplay->InitGeometryFromROOT( volBes );
      fDisplay->Draw();
      HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
      return;
    }
    else
    {
      this->HandleError( "This File is not a valid BesVis geometry file : \n TopVolume "
                         "\"volBes\" not found!" );
      sprintf( msg, "This File is not a valid BesVis geometry file" );
      HandleStatusBar( msg );
      return;
    }
  }
}
 
//_____________________________________________________
 
void BesClient::SaveGeoAs() {
  //
  // save object of Top Volume "volBes" to a ROOT file
  // Open file browser
 
  if ( !fDisplay )
  {
    this->HandleError( "fDisplay not found !" );
    return;
  }
 
  if ( !fDisplay->GetBesGeometry() )
  {
    this->HandleError( "Bes Geometry not found, Load from ROOT or GDML files first !" );
    return;
  }
 
  TGeoVolume* volBes = fDisplay->GetBesGeometry()->GetVolBes();
  if ( volBes )
  {
    // get name to save volBes to
    static TString EventDir( "." );
    TGFileInfo     fi;
    fi.fFileTypes = SaveGeoTypes;
    fi.fIniDir    = StrDup( EventDir );
    char msg[256];
    sprintf( msg, "Saving Geometry ----> BUSY!" );
    HandleStatusBar( msg );
    new TGFileDialog( fClient->GetRoot(), this, kFDSave, &fi );
 
    // Long Peixun's update: Consider cancel button
    if ( fi.fFilename )
    {
      // Long Peixun's update: Add extension at the end of filename.
      TString     filename = fi.fFilename;
      const char* ptype    = SaveGeoTypes[fi.fFileTypeIdx + 1] + 1;
      if ( !filename.EndsWith( ptype ) ) filename += ptype;
      TFile* f = new TFile( filename.Data(), "RECREATE" );
      volBes->Write();
      f->Close();
    }
  }
  else
  {
    this->HandleError( "TGeoVolume \"volBes\" not found !" );
    return;
  }
 
  HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                            // GetCurrentPadString()
}
 
//__________________________________________________________________
// Long Peixun's update: Modify OpenEventFile to adapt to geometry selection
void BesClient::OpenEventFile() {
  //
  // Load BesVis event file
  bool auto_sel_geom = true;
  if ( gBesGeometry )
  {
    Int_t clkbtn = 0;
    new TGMsgBox( gClient->GetRoot(), this, "BesVis",
                  "Detector geometry has existed. Do you want to use current geometry?",
                  gClient->GetPicture( "mb_question_s.xpm" ), kMBYes | kMBNo | kMBCancel,
                  &clkbtn );
    if ( clkbtn & kMBYes )
    {
      auto_sel_geom = false;
      fAutoGeom     = false;
    }
    else if ( clkbtn & kMBNo ) auto_sel_geom = true;
    else return;
  }
 
  // Open file browser
  static TString EventDir( "." );
  TGFileInfo     fi;
  fi.fFileTypes = OpenEventTypes;
  fi.fIniDir    = StrDup( EventDir );
  char msg[256];
  sprintf( msg, "Loading Event File" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDOpen, &fi );
  EventDir = fi.fIniDir;
  this->OpenEventFile( fi.fFilename, auto_sel_geom );
}
 
//__________________________________________________________________
// Long Peixun's update: Add a parameter to determine whether choose a detector geometry
// automatically when open an event file.
void BesClient::OpenEventFile( TString fname, bool auto_sel_geom ) {
  //
  // Open BesVis event file
 
  std::cout << "OpenEventFile: " << fname << std::endl;
  HandleStatusBar( "Open Event File" );
  char msg[256];
  // f_evtFile_1 = fname;      //Long Peixun's update: remove useless variable
 
  // Long Peixun's update: Contains -> EndsWith; Add .dst
  if ( fname.EndsWith( ".root" ) || fname.EndsWith( ".rtraw" ) || fname.EndsWith( ".rec" ) ||
       fname.EndsWith( ".dst" ) )
  {
    // Long Peixun's update: Delete old file and events
    if ( fEventFile ) fEventFile->Close();
    delete fEventFile;
    fEventFile = 0;
    delete fEvent;
    fEvent     = 0;
    gEvent     = fEvent;
    fEventTree = 0;
 
    fEventFile = TFile::Open( fname, "read" );
 
    if ( fEventFile )
    {
      // Long Peixun's update: Check whether this event is REC event
      if ( fname.EndsWith( ".rec" ) ) isRecEvent = true;
      else isRecEvent = false;
 
      fEvent     = new BesEvent();
      gEvent     = fEvent;
      fEventTree = (TTree*)fEventFile->Get( "Event" );
 
      // Long Peixun's update: Load events only if open file successfully
      if ( fEventTree )
      {
        Long64_t nEvents = fEventTree->GetEntries();
        fBesEventNo      = 0;
 
        // Long Peixun's update: fix EventSlider range error
        if ( nEvents > 0 )
        {
          if ( f_bossMode == false )
          {
            fDigiEvent = 0;
            fEvtHeader = 0;
            // fTrigEvent = 0;
            fRecEvent_1 = 0;
            fDstEvent   = 0; // Long Peixun's update: for dst file
            fEventTree->SetBranchAddress( "TDigiEvent", &fDigiEvent );
            fEventTree->SetBranchAddress( "TRecEvent", &fRecEvent_1 );
            fEventTree->SetBranchAddress( "TEvtHeader", &fEvtHeader );
            fEventTree->SetBranchAddress( "TDstEvent",
                                          &fDstEvent ); // Long Peixun's update: for dst file
            // fEventTree->SetBranchAddress("TTrigEvent" ,  &fTrigEvent);
          }
          GetEvent( fBesEventNo, true, auto_sel_geom );
          fEventPlaySlider->SetRange( 0, nEvents - 1 );
          fEventPlaySlider->SetPosition( 0 );
        }
        else
        {
          fEventPlaySlider->SetRange( 0, 0 );
          fEventPlaySlider->SetPosition( 0 );
        }
      }
      else
      {
        this->HandleError( "This File is not a valid BesVis ROOT Event File : \n Event Tree "
                           "\"Event\" not found!" );
        sprintf( msg, "This File contains no Event Tree \"Event\"" );
        HandleStatusBar( msg );
        return;
      }
    }
    else
    {
      this->HandleError( "This File is not a valid BesVis ROOT Event File!" );
      sprintf( msg, "This File is not valid" );
      HandleStatusBar( msg );
      return;
    }
 
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                              // GetCurrentPadString()
  }
}
 
//_____________________________________________________
 
void BesClient::SavePicAs() {
  //
  // save picture of canvas in file
  // Open file browser
 
  // get name to save events to
  static TString EventDir( "." );
  TGFileInfo     fi;
  fi.fFileTypes = SavePicTypes;
  fi.fIniDir    = StrDup( EventDir );
  char msg[256];
  sprintf( msg, "Saving Picture ----> BUSY!" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDSave, &fi );
 
  if ( fi.fFilename )
  {
    TString filename = fi.fFilename;
 
    // Long Peixun's update: Add extension at the end of filename.
    const char* ptype = SavePicTypes[fi.fFileTypeIdx + 1] + 1;
    if ( !filename.EndsWith( ptype ) ) filename += ptype;
 
    if ( filename.EndsWith( "gif" ) || filename.EndsWith( "GIF" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "gif" ); }
    else if ( filename.EndsWith( "jpg" ) || filename.EndsWith( "JPG" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "jpg" ); }
    else if ( filename.EndsWith( "eps" ) || filename.EndsWith( "EPS" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "eps" ); }
    else if ( filename.EndsWith( "ps" ) || filename.EndsWith( "PS" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "ps" ); }
    else if ( filename.EndsWith( "xpm" ) || filename.EndsWith( "XPM" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "xmp" ); }
    else if ( filename.EndsWith( "png" ) || filename.EndsWith( "PNG" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "png" ); }
    else if ( filename.EndsWith( "tiff" ) || filename.EndsWith( "TIFF" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "tiff" ); }
    else if ( filename.EndsWith( "cxx" ) || filename.EndsWith( "CXX" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "cxx" ); }
    else if ( filename.EndsWith( "xml" ) || filename.EndsWith( "XML" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "xml" ); }
    else if ( filename.EndsWith( "root" ) || filename.EndsWith( "ROOT" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "root" ); }
    // Long Peixun's update: Remove hint of filename being empty
  }
  HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                            // GetCurrentPadString()
}
 
//_____________________________________________________
 
void BesClient::SavePicAsPS() {
  //
  // save picture of canvas in file
  // Open file browser
 
  // get name to save events to
  static TString PSEventDir( "." );
  TGFileInfo     fi;
  fi.fFileTypes = SavePicPS;
  fi.fIniDir    = StrDup( PSEventDir );
  char msg[256];
  sprintf( msg, "Saving Picture as PS ----> BUSY!" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDSave, &fi );
 
  if ( fi.fFilename )
  {
    TString filename = fi.fFilename;
    if ( filename.EndsWith( "ps" ) || filename.EndsWith( "PS" ) )
    { fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "ps" ); }
    else
    {
      filename += ".ps";
      fEmbeddedCanvas->GetCanvas()->Print( filename.Data(), "ps" );
    }
  }
  HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                            // GetCurrentPadString()
}
 
//_____________________________________________________
 
void BesClient::SetHome() {
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( view )
  {
    Double_t x1, y1, x2, y2;
    gPad->GetRange( x1, y1, x2, y2 );
    // cout << "x1 " << x1 << " x2 " << x2 << " y1 " << y1 << " y2 " << y2 << endl;
    Int_t iPad = 0;
    if ( view->GetViewType() == kXYView ) iPad = 0;
    else if ( view->GetViewType() == kZRView ) iPad = 1;
    else if ( view->GetViewType() == k3DView ) iPad = 2;
    fHomeX[iPad] = 0.5 * ( x1 + x2 );
    fHomeY[iPad] = 0.5 * ( y1 + y2 );
  }
}
 
//_____________________________________________________
 
void BesClient::GoHome() {
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( view )
  {
    Double_t x1, y1, x2, y2, dx, dy;
    gPad->GetRange( x1, y1, x2, y2 );
    dx = x2 - x1;
    dy = y2 - y1;
 
    Int_t iPad = 0;
    if ( view->GetViewType() == kXYView ) iPad = 0;
    else if ( view->GetViewType() == kZRView ) iPad = 1;
    else if ( view->GetViewType() == k3DView ) iPad = 2;
 
    gPad->Range( fHomeX[iPad] - 0.5 * dx, fHomeY[iPad] - 0.5 * dy, fHomeX[iPad] + 0.5 * dx,
                 fHomeY[iPad] + 0.5 * dy );
  }
}
 
//_____________________________________________________
 
void BesClient::SaveMyConfig() {
  //
  // save current style to ~/.besvisMyConfig.txt
 
  // Int_t ret;
  // const char *txt;
  // txt = Form("Save current style to ~/.besvisMyConfig.txt, Yes to save it? ");
  // new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
  //              "Save My Style", txt, kMBIconExclamation,
  //              kMBYes | kMBNo, &ret);
  // if (ret == kMBNo)  return;
  if ( !fDisplay ) return;
 
  // Long Peixun's update: Popup a save dialog
  static TString EventDir( "." );
  TGFileInfo     fi;
  fi.fFileTypes = StyleTypes;
  fi.fIniDir    = StrDup( EventDir );
  char msg[256];
  sprintf( msg, "Saving Style ----> BUSY!" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDSave, &fi );
 
  if ( fi.fFilename )
  {
    // Long Peixun's update: Handle save file process
    TString     filename = fi.fFilename;
    const char* ptype    = StyleTypes[fi.fFileTypeIdx + 1] + 1;
    if ( !filename.EndsWith( ptype ) ) filename += ptype;
    ofstream fileMyConfig( filename.Data(), ios_base::out );
 
    // Long Peixun's update: Add flag of BesVis at the head of file
    fileMyConfig << "BesVisStyle";
 
    BesView* viewXY = dynamic_cast<BesView*>( fDisplay->GetPadXY()->GetView() );
    if ( viewXY )
    {
      BesStatus* status = viewXY->GetStatusXY();
      fileMyConfig << *status;
      // cout << "viewXY " << *status << endl;
    }
 
    BesView* viewZR = dynamic_cast<BesView*>( fDisplay->GetPadZR()->GetView() );
    if ( viewZR )
    {
      BesStatus* status = viewZR->GetStatusZR();
      fileMyConfig << *status;
      // cout << "viewZR " << *status << endl;
    }
 
    BesView* view3D = dynamic_cast<BesView*>( fDisplay->GetPad3D()->GetView() );
    if ( view3D )
    {
      BesStatus* status = view3D->GetStatus3D();
      fileMyConfig << *status;
      // cout << "view3D " << *status << endl;
    }
 
    // Long Peixun's update: Add normal CGEM unfolded view config
    BesStatus statuscgem;
    statuscgem.Default( kCgemUFView0 );
    fileMyConfig << statuscgem;
    statuscgem.Default( kCgemUFView1 );
    fileMyConfig << statuscgem;
    statuscgem.Default( kCgemUFView2 );
    fileMyConfig << statuscgem;
 
    fileMyConfig.close(); // Long Peixun's update: Close file stream
    cout << "Save my style finished." << endl;
  }
  HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                            // GetCurrentPadString()
}
 
//_____________________________________________________
 
void BesClient::LoadMyConfig() {
  //
  // load my style from ~/.besvisMyConfig.txt
 
  // string homePath = getenv("HOME");
  // string fileName = homePath + string("/.besvisMyConfig.txt");
  // cout << "fileName " << fileName << endl;
  if ( !fDisplay ) return;
 
  // Long Peixun's update: Popup open file dialog
  static TString EventDir( "." );
  TGFileInfo     fi;
  fi.fFileTypes = StyleTypes;
  fi.fIniDir    = StrDup( EventDir );
  char msg[256];
  sprintf( msg, "Loading Style File" );
  HandleStatusBar( msg );
  new TGFileDialog( fClient->GetRoot(), this, kFDOpen, &fi );
  EventDir = fi.fIniDir;
 
  if ( fi.fFilename )
  {
    ifstream fileMyConfig( fi.fFilename );
 
    // Long Peixun's update: Check header of file
    string header;
    fileMyConfig >> header;
    if ( header != "BesVisStyle" ) { HandleError( "This file is not a BesVis style file!" ); }
    else
    {
      BesView* viewXY = dynamic_cast<BesView*>( fDisplay->GetPadXY()->GetView() );
      if ( viewXY )
      {
        BesStatus status;
        fileMyConfig >> status;
        viewXY->GetStatusCurrent()->Transfer( &status, true );
      }
 
      BesView* viewZR = dynamic_cast<BesView*>( fDisplay->GetPadZR()->GetView() );
      if ( viewZR )
      {
        BesStatus status;
        fileMyConfig >> status;
        viewZR->GetStatusCurrent()->Transfer( &status, true );
      }
 
      BesView* view3D = dynamic_cast<BesView*>( fDisplay->GetPad3D()->GetView() );
      if ( view3D )
      {
        BesStatus status;
        fileMyConfig >> status;
        view3D->GetStatusCurrent()->Transfer( &status, true );
      }
    }
 
    // Long Peixun's update: Close file stream
    fileMyConfig.close();
    UpdateStatus();
    UpdateAllView();
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: "Ready" ->
                                              // GetCurrentPadString()
  }
}
 
//_____________________________________________________
 
void BesClient::LoadMdcPalette() {
  cout << "BesClient Loading PaletteAxis ... " << endl;
 
  new BesMdcPalette( gClient->GetRoot(), this );
 
  // TRootHelpDialog* hd1 = new TRootHelpDialog(this, "Mdc Wire Palette",200, 600);
  // hd1->ChangeSubframesBackground(GetPic("MdcPalette.gif"));
  // hd1->Popup();
}
 
//_____________________________________________________
 
void BesClient::Help() {
 
  // char str[32];
  // sprintf(str, "BesVis Help %s...", gROOT->GetVersion());
  // TRootHelpDialog * hd = new TRootHelpDialog(this, str, 600, 400);
 
  TRootHelpDialog* hd = new TRootHelpDialog( this, "Help on BesVis...", 600, 400 );
  hd->SetText( f_HelpText.c_str() );
  hd->Popup();
}
 
//_____________________________________________________
 
void BesClient::SetAllDisplayModeButtonUnHL() {
 
  fDisplayModeButton[0]->SetPicture( gClient->GetPicture( "DisplayMode2D.gif" ) );
  fDisplayModeButton[1]->SetPicture( gClient->GetPicture( "DisplayModeXY.gif" ) );
  fDisplayModeButton[2]->SetPicture( gClient->GetPicture( "DisplayModeZR.gif" ) );
  fDisplayModeButton[3]->SetPicture( gClient->GetPicture( "DisplayMode3D.gif" ) );
  fDisplayModeButton[4]->SetPicture( gClient->GetPicture( "DisplayModeAll.gif" ) );
 
  for ( Int_t i = 0; i < kNDisplayMode; i++ )
    fDisplayModeButton[i]->SetState( false ); // Long Peixun's update: Ajust display mode
}
 
//_____________________________________________________
 
void BesClient::X3D() {
 
  /*
  painter = gGeoManager->GetGeomPainter();
  //if (!painter) return;
  painter->SetRaytracing(true);
  //if (!gPad) return;
  gPad->Modified();
  gPad->Update();
  */
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( !view ) return;
 
  if ( view && view->GetViewType() & k3DView )
  {
    // gPad->GetViewer3D();      //Long Peixun's update: This line is unnecessary
    //  use TPad::Getviewer3D() instead of depreciated function x3d()
    //  changed by tianhl at Mon Aug 20 2007
    fViewer3DMode = 1;
    // Long Peixun's update: Add parameter "x3d"; dynamic_cast
    TViewerX3D* x3d = dynamic_cast<TViewerX3D*>( gPad->GetViewer3D( "x3d" ) );
    if ( !x3d ) cout << " x3d does not exist " << endl;
    else x3d->ExecCommand( 0, 0, 'r' );
  }
  else
  {
    // Long Peixun's update: Switching to 3D View instead of showing error message
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[3]->SetState( true );
    fDisplayModeButton[3]->SetPicture( gClient->GetPicture( "DisplayMode3DST.gif" ) );
    fDisplay->SwitchDisplayMode( 3 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    X3D();
  }
}
 
//_____________________________________________________
 
void BesClient::OpenGL() {
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( !view ) return;
 
  // Long Peixun's update: Remove annotation
  if ( view->GetViewType() & k3DView )
  {
    // use TPad::GetViewer3D() instead of depreciated function TPad::x3d
    // changed by tianhl at Mon Aug 20 2007
    fViewer3DMode = 2;
    // Long Peixun's update: TVirtualViewer3D -> TGLViewer; Don't reset when update;
    // dynamic_cast
    TGLViewer* ogl = dynamic_cast<TGLViewer*>( gPad->GetViewer3D( "ogl" ) );
    if ( ogl )
    {
      ogl->SetResetCamerasOnUpdate( false );
      ogl->SetClearColor( kWhite );
    }
    else cout << " ogl does not exist " << endl;
    UpdateCurrentPad();
  }
  else
  {
    // Long Peixun's update: Switching to 3D View instead of showing error message
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[3]->SetState( true );
    fDisplayModeButton[3]->SetPicture( gClient->GetPicture( "DisplayMode3DST.gif" ) );
    fDisplay->SwitchDisplayMode( 3 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    OpenGL();
  }
}
 
//__________________________________________________________________
 
void BesClient::CloseWindow() {
  //
  // Got close message for this MainFrame. Calls parent CloseWindow())
  // (which destroys the window) and terminate the application.
  // The close message is generated by the window manager when its close
  // window menu item is selected.
  TGMainFrame::CloseWindow();
  gApplication->Terminate( 0 ); // 0 = OK
}
 
//_____________________________________________________
// Long Peixun's update: Get run number and choose a detector geometry automatically when in
// need.
Bool_t BesClient::GetEvent( Long64_t i, bool openfile, bool sel_geom ) {
  if ( fEventTree )
  {
 
    Long64_t nEvents = fEventTree->GetEntries();
    if ( i >= 0 && i < nEvents )
    {
 
      fDigiEvent = 0;
      fEvtHeader = 0;
      fRecEvTime = 0;
      // fTrigEvent = 0;
      TDisTrack* fRecEvent = new TDisTrack();
      if ( f_bossMode == true )
      {
        TBranch* digiEvent = fEventTree->GetBranch( "TDigiEvent" );
        TBranch* evtHeader = fEventTree->GetBranch( "TEvtHeader" );
        // TBranch *trigEvent = fEventTree->GetBranch("TTrigEvent");
        TBranch* disTrack = fEventTree->GetBranch( "TDisTrack" );
        digiEvent->SetAddress( &fDigiEvent );
        // trigEvent->SetAddress(&fTrigEvent);
        disTrack->SetAddress( &fRecEvent );
        disTrack->GetEntry( i );
        digiEvent->GetEntry( i );
        evtHeader->GetEntry( i );
        // trigEvent->GetEntry(i);
      }
 
      if ( f_bossMode == false )
      {
        // Long Peixun add these to debug opening event
        cout << "[LPX] Get Event Entry test begin" << endl;
        fEventTree->GetEntry( i ); // There are some errors here when open event file again
        cout << "[LPX] Successfully get Event Entry" << endl;
 
        // Long Peixun's update: Judge the change of run number
        /* Long64_t newrunno = fEvtHeader->getRunId();
        cout << "[LPX] fAutoGeom == ";
        if (fAutoGeom) cout << "true" << endl;
        else cout << "false" << endl;
        if (fAutoGeom && fBesRunNo != newrunno && !sel_geom)
        {
            cout << "[LPX] fBesRunNo has changed!" << endl;
            const char* ogfile = fSelector.getGeomFileNameFromRunNo(fBesRunNo);
            const char* ngfile = fSelector.getGeomFileNameFromRunNo(newrunno);
            if (strcmp(ogfile, ngfile) != 0 && ngfile[0] != '\0')
            {
                Int_t clkbtn = 0;
                new TGMsgBox(gClient->GetRoot(), this, "BesVis",
                    "The run number has changed. Do you want to let BesVis change the detector
        geometry into a suitable one?", gClient->GetPicture("mb_question_s.xpm"), kMBYes |
        kMBNo, &clkbtn); if (clkbtn & kMBYes)
                {
                    cout << "Select geometry file: " << ngfile << endl;
                    TString geomfile = fBesVisPath + TString("/geom/");
                    geomfile += ngfile;
                    OpenGeoFile(geomfile);
                }
            }
        } */
 
        // Long Peixun's update: Set fBesRunNo
        fBesRunNo = fEvtHeader->getRunId();
        cout << "Run Number: " << fBesRunNo << endl;
 
        // Long Peixun's update: if flag sel_geom is true, select a suitable detector geometry
        if ( openfile )
        {
          const char* ret = fSelector.getGeomFileNameFromRunNo( fBesRunNo );
          if ( sel_geom )
          {
            if ( ret[0] == '\0' )
            {
              HandleError(
                  "There is no suitable delector geometry! Please select a geometry file." );
              LoadGeoFile();
            }
            else
            {
              cout << "Select geometry file: " << ret << endl;
              TString geomfile = fBesVisPath + TString( "/geom/" );
              geomfile += ret;
              OpenGeoFile( geomfile );
              fAutoGeom = true;
            }
          }
          else
          {
            if ( fCurGeom.Length() > 0 )
            {
              TString ts_ret = TString( ret );
              if ( ts_ret != fCurGeom )
              {
                new TGMsgBox( fClient->GetRoot(), GetMainFrame(), "BesVis",
                              "Maybe you have selected an unsuitable geometry!",
                              kMBIconExclamation, kMBDismiss );
              }
            }
            fAutoGeom = false;
          }
        }
 
        // yzhang get event start time
        if ( fRecEvent_1 )
        {
          if ( fRecEvent_1->getEvTimeCol()->GetEntries() == 1 )
          { fRecEvTime = (TRecEvTime*)fRecEvent_1->getEvTimeCol()->At( 0 ); }
          else
          {
            cout << "WARNING:EsTimeCol size!=1, size="
                 << fRecEvent_1->getEvTimeCol()->GetEntries() << endl;
          }
        }
        // zhangy
 
        int no = 0;
 
        // recTrack1 = new TRecMdcTrack[20];
        // if contains reconstruction information
        if ( fRecEvent_1 )
        {
          // Mdc tracks
          // Long Peixun's update: Remove "if"; Move "delete [] recTrack1" here
          no = 0;
          delete[] recTrack1;
          if ( fRecEvent_1->getRecMdcTrackCol() )
            no = ( fRecEvent_1->getRecMdcTrackCol() )->GetEntries();
          // if (no>20) no=20;
          recTrack1 =
              new TRecMdcTrack[no]; // Long Peixun's update: Remove limit of Mdc tracks number
          for ( int i = 0; i < no; i++ )
          {
            const TRecMdcTrack* recTrack = fRecEvent_1->getRecMdcTrack( i );
            recTrack1[i].setTRecMdcTrack( recTrack ); // Long Peixun's update: "(pointer+i)->"
                                                      // -> "pointer[i].", more clear
            fRecEvent->addRecMdcTrack( recTrack1 + i );
          }
 
          ////yzhang
          // if (kalTrack){
          //     delete [] kalTrack;
          //     kalTrack = NULL;
          // }
          // kalTrack = new TRecMdcKalTrack[20];
          // no=0;
          // if (fRecEvent_1->getRecMdcKalTrackCol()){
          //     no=(fRecEvent_1->getRecMdcKalTrackCol())->GetEntries();
          // }
          // if (no>20) no=20;
          // for (int i=0;i<no;i++){
          //     TRecMdcKalTrack* kalTrack1 = const_cast<TRecMdcKalTrack*>
          //     (fRecEvent_1->getRecMdcKalTrack(i));
          //     //(kalTrack+i)->setTRecMdcKalTrack(kalTrack1);
          //     fRecEvent->addRecMdcKalTrack(kalTrack1);
          // }
          ////zhangy
 
          // Tof tracks
          // Long Peixun's update: Remove "if"
          delete[] tofTrack;
          no = 0;
          // tofTrack = new TRecTofTrack[200];
          if ( fRecEvent_1->getTofTrackCol() )
            no = ( fRecEvent_1->getTofTrackCol() )->GetEntries();
          // if (no>200) no =200;
          tofTrack =
              new TRecTofTrack[no]; // Long Peixun's update: Remove limit of Tof tracks number
          for ( int i = 0; i < no; i++ )
          {
            const TRecTofTrack* tofTrack1 = fRecEvent_1->getTofTrack( i );
            tofTrack[i].setTRecTofTrack( tofTrack1 ); // Long Peixun's update: "(pointer+i)->"
                                                      // -> "pointer[i].", more clear
            fRecEvent->addTofTrack( tofTrack + i );
          }
 
          // Mdc hits
          // Long Peixun's update: Remove "if"
          delete[] mdchit;
          // mdchit = new TRecMdcHit[1000];
          no = 0;
          if ( fRecEvent_1->getRecMdcHitCol() )
            no = ( fRecEvent_1->getRecMdcHitCol() )->GetEntries();
          // if (no>1000) no =1000;
          mdchit = new TRecMdcHit[no]; // Long Peixun's update: Remove limit of Mdc hits number
          for ( int i = 0; i < no; i++ )
          {
            const TRecMdcHit* mdchit1 = fRecEvent_1->getRecMdcHit( i );
            mdchit[i].setTRecMdcHit( mdchit1 ); // Long Peixun's update: "(pointer+i)->" ->
                                                // "pointer[i].", more clear
            fRecEvent->addRecMdcHit( mdchit + i );
          }
 
          // Muc Hits
          // Long Peixun's update: Remove "if"
          delete[] muctrk;
          // muctrk = new TRecMucTrack[20];
          no = 0;
          if ( fRecEvent_1->getMucTrackCol() )
            no = ( fRecEvent_1->getMucTrackCol() )->GetEntries();
          // if (no>20) no=20;
          muctrk =
              new TRecMucTrack[no]; // Long Peixun's update: Remove limit of Muc tracks number
          for ( int i = 0; i < no; i++ )
          {
            const TRecMucTrack* mucTrack1 = fRecEvent_1->getMucTrack( i );
            muctrk[i].setTRecMucTrack( mucTrack1 ); // Long Peixun's update: "(pointer+i)->" ->
                                                    // "pointer[i].", more clear
            fRecEvent->addMucTrack( muctrk + i );
          }
 
          // Emc shower
          // Long Peixun's update: Remove "if"
          delete[] emcshower;
          // emcshower = new TRecEmcShower[20];
          no = 0;
          if ( fRecEvent_1->getEmcShowerCol() )
            no = ( fRecEvent_1->getEmcShowerCol() )->GetEntries();
          // if (no>20) no=20;
          emcshower =
              new TRecEmcShower[no]; // Long Peixun's update: Remove limit of Emc shower number
          for ( int i = 0; i < no; i++ )
          {
            const TRecEmcShower* rec_emc = fRecEvent_1->getEmcShower( i );
            emcshower[i].setTRecEmcShower( rec_emc ); // Long Peixun's update: "(pointer+i)->"
                                                      // -> "pointer[i].", more clear
            fRecEvent->addEmcShower( emcshower + i );
          }
        }
        // Long Peixun's update: For dst file, convert dst tracks to rec tracks
        else if ( fDstEvent )
        {
          cout << "BesClient Construct DST tracks" << endl;
          // Mdc dst tracks
          no = 0;
          delete[] recTrack1;
          if ( fDstEvent->getMdcTrackCol() )
            no = ( fDstEvent->getMdcTrackCol() )->GetEntries();
          recTrack1 = new TRecMdcTrack[no];
          for ( int i = 0; i < no; i++ )
          {
            cvtMdcDst2MdcRec( recTrack1 + i, fDstEvent->getMdcTrack(
                                                 i ) ); // Convert dst tracks to rec tracks
            fRecEvent->addRecMdcTrack( recTrack1 + i );
          }
 
          // Tof dst tracks
          no = 0;
          delete[] tofTrack;
          if ( fDstEvent->getTofTrackCol() )
            no = ( fDstEvent->getTofTrackCol() )->GetEntries();
          tofTrack = new TRecTofTrack[no];
          for ( int i = 0; i < no; i++ )
          {
            cvtTofDst2TofRec( tofTrack + i, fDstEvent->getTofTrack(
                                                i ) ); // Convert dst tracks to rec tracks
            fRecEvent->addTofTrack( tofTrack + i );
          }
 
          // Emc dst tracks
          no = 0;
          delete[] emcshower;
          if ( fDstEvent->getEmcTrackCol() )
            no = ( fDstEvent->getEmcTrackCol() )->GetEntries();
          emcshower = new TRecEmcShower[no];
          for ( int i = 0; i < no; i++ )
          {
            cvtEmcDst2EmcRec( emcshower + i, fDstEvent->getEmcTrack(
                                                 i ) ); // Convert dst tracks to rec tracks
            fRecEvent->addEmcShower( emcshower + i );
          }
 
          // Muc dst tracks
          no = 0;
          delete[] muctrk;
          if ( fDstEvent->getMucTrackCol() )
            no = ( fDstEvent->getMucTrackCol() )->GetEntries();
          muctrk = new TRecMucTrack[no];
          for ( int i = 0; i < no; i++ )
          {
            cvtMucDst2MucRec( muctrk + i, fDstEvent->getMucTrack( i ) ); // Convert dst tracks
                                                                         // to rec tracks
            fRecEvent->addMucTrack( muctrk + i );
          }
        }
      }
 
      // Long Peixun's update: Reset detector 3D color
      fDisplay->GetBesGeometry()->SetPhysicalDefaultVis();
      // fEvent->SetEvent(fDigiEvent, fRecEvent, fEvtHeader, fTrigEvent);
      // Long Peixun's update: Add "isRecEvent"
      fEvent->SetEvent( fDigiEvent, fRecEvent, fEvtHeader, fRecEvTime, isRecEvent );
 
      // delete fRecEvent;
      UpdateAllView();
      UpdateStatus();
      return true;
    }
    else
    {
      fAutoDisplayEvent = kFALSE;
      if ( fAutoDisplayEventTimer )
      {
        fAutoDisplayEventTimer->TurnOff();
        fPlayEventButton->SetPicture( gClient->GetPicture( "ButtonEventPlay.gif" ) );
      }
 
      ostringstream s;
      s << "Request event entry " << i << " does not exist ! \n valid (" << 0 << "~"
        << nEvents - 1 << ")";
      this->HandleError( s.str().c_str() );
      return false;
    }
  }
  else
  {
    fAutoDisplayEvent = kFALSE;
    if ( fAutoDisplayEventTimer ) fAutoDisplayEventTimer->TurnOff();
    this->HandleError( "Event Tree does not exist !" );
    return false;
  }
}
 
Bool_t BesClient::GetRecEvent() {
  int  semid, shmid, n, runNo;
  int* shmptr;
  int  sem_value_F, sem_value_O;
 
  // set autodisplay on
  if ( fAutoDisplayEvent )
  {
    if ( fAutoDisplayEventTimer ) fAutoDisplayEventTimer->TurnOn();
    fPlayEventButton->SetPicture( gClient->GetPicture( "ButtonEventStop.gif" ) );
  }
 
  // access semaphore
  if ( ( semid = semget( f_pid, 2, 0 ) ) == -1 )
  {
    perror( "concumer -- access -- semget" );
    exit( 0 );
  }
  else
  {
    acquire.sem_num = OUTPUT_STORE;
    //*******************************
    // Debug information
    //*******************************
    // std::cout << "acquire.sem_num: " << OUTPUT_STORE << std::endl;
    // std::cout << "acquire.sem_num: " << acquire.sem_num << std::endl;
    // std::cout << "acquire.sem_op:  " << acquire.sem_op << std::endl;
    //
    // std::cout << "Current Event No. : " << fCurrentEvent << std::endl;
    // std::cout << "besvis has gotten semid: " << semid << std::endl;
    // std::cout << "before change OUTPUT_STORE" << std::endl;
 
    // if ((sem_value_F = semctl(semid, FREE_SPACE, GETVAL, 0)) == -1){
    //   perror("Can not get FREE_SPACE");
    // }
    ////if (sem_value_F == 1) return true;
    // std::cout << "Semaphore FREE_SPACE has value of(refer 0) " <<  sem_value_F << std::endl;
 
    // std::cout << "OUTPUT_STORE will decrease from 1 to 0" << std::endl;
    //*******************************
    //  operate semaphore:OUTPUT_STORE
    //*******************************
    if ( ( sem_value_O = semctl( semid, OUTPUT_STORE, GETVAL, 0 ) ) == -1 )
    { perror( "Can not get OUTPUT_STORE" ); }
    // std::cout << "Semaphore OUTPUT_STORE has value of(refer 1) " << sem_value_O <<
    // std::endl;
    if ( sem_value_O == 0 ) return true;
    if ( f_runStatus == RUN_ERROR )
    {
      release.sem_num = FREE_SPACE;
      if ( semop( semid, &release, 1 ) == -1 )
      {
        perror( "consumer -- increase -- freeSpace" );
        exit( 0 );
      }
      std::cout << "read data error " << std::endl;
      f_runStatus = RUN_SMOOTH;
      return true;
    }
    f_runStatus = RUN_ERROR;
 
    if ( semop( semid, &acquire, 1 ) == -1 )
    {
      perror( "consumer -- decrease -- storage" );
      exit( 0 );
    }
 
    //*******************************
    // Debug information
    //*******************************
    // std::cout << "Current Event No. : " << fCurrentEvent << std::endl;
    // std::cout << "besvis has gotten semid: " << semid << std::endl;
    // std::cout << "besvis will read data" << std::endl;
    // std::cout << "OUTPUT_STORE must decrease from 1 to 0" << std::endl;
 
    // if ((sem_value_F = semctl(semid, FREE_SPACE, GETVAL, 0)) == -1){
    //   perror("Can not get FREE_SPACE");
    // }
    // std::cout << "Semaphore FREE_SPACE has value of(refer 0) " <<  sem_value_F << std::endl;
    //
    // if ((sem_value_O = semctl(semid, OUTPUT_STORE, GETVAL, 0)) == -1){
    //   perror("Can not get OUTPUT_STORE");
    // }
    // std::cout << "Semaphore OUTPUT_STORE has value of(refer 0) " << sem_value_O <<
    // std::endl;
    //*******************************
    if ( fCurrentEvent >= 1 )
    {
      if ( fDigiEvent )
      {
        // fDigiEvent->Clear();
        delete fDigiEvent;
        fDigiEvent = 0;
      }
      if ( fEvtHeader )
      {
        fEvtHeader->Clear();
        delete fEvtHeader;
        fEvtHeader = 0;
      }
      // if (fTrigEvent){
      //     //fTrigEvent->Clear();
      //     delete fTrigEvent;
      //     fTrigEvent=0;
      // }
      if ( fEvent )
      {
        delete fEvent;
        fEvent = NULL;
      }
    }
 
    //*******************************
    // read from share file
    //*******************************
    OpenEventFile( f_evtFile );
    if ( fEventFile == NULL ) { return true; }
    if ( fEventTree ) delete fEventTree;
    fEventFile->Close();
    delete fEventFile;
    //*******************************
 
    release.sem_num = FREE_SPACE;
    //*******************************
    // Debug information
    //*******************************
    // std::cout << "release.sem_num: " << FREE_SPACE << std::endl;
    // std::cout << "release.sem_num: " << release.sem_num << std::endl;
    // std::cout << "release.sem_op:  " << release.sem_op << std::endl;
    //
    // std::cout << "Current Event No. : " << fCurrentEvent << std::endl;
    // std::cout << "besvis has gotten semid: " << semid << std::endl;
    // std::cout << "besvis has read data" << std::endl;
    // std::cout << "before change FREE_SPACE" << std::endl;
 
    // if ((sem_value_F = semctl(semid, FREE_SPACE, GETVAL, 0)) == -1){
    //   perror("Can not get FREE_SPACE");
    // }
    // std::cout << "Semaphore FREE_SPACE has value of(refer 0) " <<  sem_value_F << std::endl;
    //
    // if ((sem_value_O = semctl(semid, OUTPUT_STORE, GETVAL, 0)) == -1){
    //   perror("Can not get OUTPUT_STORE");
    // }
    // std::cout << "Semaphore OUTPUT_STORE has value of(refer 0) " << sem_value_O <<
    // std::endl;
    //
    // std::cout << "FREE_SPACE will increase from 0 to 1" << std::endl;
    //*******************************
    //  operate semaphore:FREE_SPACE
    //*******************************
    if ( semop( semid, &release, 1 ) == -1 )
    {
      perror( "consumer -- increase -- freeSpace" );
      exit( 0 );
    }
    std::cout << "Current Event No. : " << fCurrentEvent++ << std::endl;
    //*******************************
    // Debug information
    //*******************************
    // std::cout << "besvis has gotten semid: " << semid << std::endl;
    // std::cout << "besvis has read data" << std::endl;
    // std::cout << "FREE_SPACE must increase from 0 to 1" << std::endl;
 
    // if ((sem_value_F = semctl(semid, FREE_SPACE, GETVAL, 0)) == -1){
    //   perror("Can not get FREE_SPACE");
    // }
    // std::cout << "Semaphore FREE_SPACE has value of(refer 1) " <<  sem_value_F << std::endl;
    //
    // if ((sem_value_O = semctl(semid, OUTPUT_STORE, GETVAL, 0)) == -1){
    //   perror("Can not get OUTPUT_STORE");
    // }
    // std::cout << "Semaphore OUTPUT_STORE has value of(refer 0) " << sem_value_O <<
    // std::endl;
    //*******************************
  }
  f_runStatus = RUN_SMOOTH;
  return true;
}
//_____________________________________________________
 
Bool_t BesClient::NextEvent() {
  // Long Peixun's update: Check range before shift
  if ( !fEventTree ) return false;
  if ( fBesEventNo + 1 >= fEventTree->GetEntries() ) return false;
 
  Bool_t status;
  fBesEventNo++;
  if ( f_bossMode == false ) { status = GetEvent( fBesEventNo ); }
  else if ( f_bossMode == true )
  {
    std::cout << "In Boss Mode, execute NextEvent()" << std::endl;
    status = GetRecEvent();
  }
  if ( !status ) fBesEventNo--;
  return status;
}
 
//_____________________________________________________
 
Bool_t BesClient::PrevEvent() {
  // Long Peixun's update: Check range before shift
  if ( !fEventTree ) return false;
  if ( fBesEventNo <= 0 ) return false;
 
  Bool_t status = false;
  fBesEventNo--;
 
  if ( f_bossMode )
  {
    // add error box
    this->HandleError( "Boss Mode can not get previous event!" );
  }
  else { status = GetEvent( fBesEventNo ); }
  if ( !status ) fBesEventNo++;
  return status;
}
 
//_____________________________________________________
 
Bool_t BesClient::FirstEvent() {
  Bool_t status = false;
 
  if ( f_bossMode )
  {
    // add error box
    this->HandleError( "Boss Mode can not get first event!" );
  }
  else
  {
    fBesEventNo = 0;
    status      = GetEvent( fBesEventNo );
  }
  return status;
}
 
//_____________________________________________________
// Long Peixun's update: Get last event
Bool_t BesClient::LastEvent() {
  Bool_t status = false;
 
  if ( f_bossMode )
  {
    // add error box
    this->HandleError( "Boss Mode can not get last event!" );
  }
  else
  {
    fBesEventNo = fEventTree->GetEntries() - 1;
    status      = GetEvent( fBesEventNo );
  }
  return status;
}
 
//_____________________________________________________
 
void BesClient::AutoDisplayEvent() {
  // if (fEventTree) {
  fAutoDisplayEvent = !fAutoDisplayEvent;
  std::cout << "(AutoDisplayEvent)fAutoDisplayEvent: " << fAutoDisplayEvent << std::endl;
  if ( fAutoDisplayEventTimer )
  {
    if ( fAutoDisplayEvent )
    {
      fPlayEventButton->SetPicture( gClient->GetPicture( "ButtonEventStop.gif" ) );
      fAutoDisplayEventTimer->TurnOn();
    }
    else
    {
      fPlayEventButton->SetPicture( gClient->GetPicture( "ButtonEventPlay.gif" ) );
      fAutoDisplayEventTimer->TurnOff();
    }
  }
  //}
 
  /*
     fAutoDisplayEvent = kTRUE;
     if (gDebug) cout << "Into AutoDisplayEvent(), fAutoDisplayEvent = " << fAutoDisplayEvent
     << " fEventPlaySpeed " << fEventPlaySpeed << endl;
 
     if (fAutoDisplayEventTimer) fAutoDisplayEventTimer->TurnOn();
     */
}
 
//_____________________________________________________
 
void BesClient::AutoDisplayEventCommand() {
  NextEvent();
  UpdateBesInputFields();
}
 
//_____________________________________________________
 
void BesClient::AutoRotate() {
  fAutoRotate = !fAutoRotate;
 
  if ( !fAutoRotate )
  {
    fAutoRotateClockWise = 0;
    fAutoRotateTheta     = 0;
    fAutoRotatePhi       = 0;
    fAutoRotatePsi       = 0;
  }
 
  if ( fAutoRotateTimer )
  {
    if ( fAutoRotate ) fAutoRotateTimer->TurnOn();
    else fAutoRotateTimer->TurnOff();
  }
}
 
//_____________________________________________________
 
void BesClient::AutoRotateCommand() {
  if ( fAutoRotateClockWise != 0 ) { RotateClockWise( fAutoRotateClockWise ); }
 
  if ( fAutoRotateTheta != 0 ) { RotateTheta( fAutoRotateTheta ); }
 
  if ( fAutoRotatePhi != 0 ) { RotatePhi( fAutoRotatePhi ); }
 
  if ( fAutoRotatePsi != 0 ) { RotatePsi( fAutoRotatePsi ); }
 
  /*
     Int_t iret;
     if (fDisplay->GetPadXY()->GetView()) {
     fDisplay->GetPadXY()->GetView()->SetView(fDisplay->GetPadXY()->GetView()->GetLongitude()+fRotateStep,
     fDisplay->GetPadXY()->GetView()->GetLatitude(),
     fDisplay->GetPadXY()->GetView()->GetPsi(), iret);
     fDisplay->GetPadXY()->Modified();
     fDisplay->GetPadXY()->Update();
     }
     if (fDisplay->GetPadZR()->GetView()) {
     fDisplay->GetPadZR()->GetView()->SetView(fDisplay->GetPadZR()->GetView()->GetLongitude()+fRotateStep,
     fDisplay->GetPadZR()->GetView()->GetLatitude(),
     fDisplay->GetPadZR()->GetView()->GetPsi(), iret);
     fDisplay->GetPadZR()->Modified();
     fDisplay->GetPadZR()->Update();
     }
     */
 
  UpdateCurrentPad();
  UpdateBesInputFields();
}
 
//_____________________________________________________
 
void BesClient::RotateClockWise( int clockwise ) // -1 = counterclockwise
{
  Double_t phi = 0.0;
  Int_t    iret;
  if ( fDisplay->GetPadXY()->GetView() )
  {
    phi = fDisplay->GetPadXY()->GetView()->GetLongitude();
    phi += clockwise * fRotateStep;
    fDisplay->GetPadXY()->GetView()->SetView(
        phi, fDisplay->GetPadXY()->GetView()->GetLatitude(),
        fDisplay->GetPadXY()->GetView()->GetPsi(), iret );
    fDisplay->GetPadXY()->Modified();
    fDisplay->GetPadXY()->Update();
  }
  if ( fDisplay->GetPadZR()->GetView() )
  {
    // phi = fDisplay->GetPadZR()->GetView()->GetLongitude();
    // phi += clockwise * fRotateStep;
    phi += 180.0;
    fDisplay->GetPadZR()->GetView()->SetView(
        phi, fDisplay->GetPadZR()->GetView()->GetLatitude(),
        fDisplay->GetPadZR()->GetView()->GetPsi(), iret );
    fDisplay->GetPadZR()->Modified();
    fDisplay->GetPadZR()->Update();
  }
}
 
//_____________________________________________________
 
void BesClient::RotateTheta( int pn ) // 1 plus, -1 minus
{
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
 
  if ( view )
  {
    Double_t theta = view->GetLatitude() + pn * fRotateStep;
    Int_t    iret;
    SetRange( theta, 0.0, 180.0 );
    view->SetView( view->GetLongitude(), theta, view->GetPsi(), iret );
    // gPad->Modified();
    // gPad->Update();
  }
}
 
//_____________________________________________________
 
void BesClient::RotatePhi( int pn ) // 1 plus, -1 minus
{
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
 
  if ( view )
  {
    Double_t phi = view->GetLongitude() + pn * fRotateStep;
    Int_t    iret;
    SetRange( phi, 0.0, 360.0 );
    view->SetView( phi, view->GetLatitude(), view->GetPsi(), iret );
    // gPad->Modified();
    // gPad->Update();
  }
}
 
//_____________________________________________________
 
void BesClient::RotatePsi( int pn ) // 1 plus, -1 minus
{
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
 
  if ( view )
  {
    Double_t psi = view->GetPsi() + pn * fRotateStep;
    Int_t    iret;
    SetRange( psi, 0.0, 360.0 );
    view->SetView( view->GetLongitude(), view->GetLatitude(), psi, iret );
    // gPad->Modified();
    // gPad->Update();
  }
}
 
//__________________________________________________________________
 
void BesClient::HandleEventList( TGListTreeItem* entry, Int_t btn ) {
  //
  // Event list handling for buttons
 
  if ( entry->GetFirstChild() != 0 )
  {
    // Run folder
    if ( entry->IsOpen() ) { fEventListTree->CloseItem( entry ); }
    else { fEventListTree->OpenItem( entry ); }
  }
  else
  {
    fEventListTree->HighlightItem( entry );
    gClient->NeedRedraw( fEventListTree );
 
    // Event item
    fItem    = entry;
    fRunItem = entry->GetParent();
    TString msg1( "Displaying Run " );
    HandleStatusBar( msg1.Data() );
 
    SetState(); // includes canvas update
 
    TString msg2( "Run " );
    HandleStatusBar( msg2.Data() );
  }
 
  // Redraw canvas
  TCanvas* canvas = (TCanvas*)fEmbeddedCanvas->GetCanvas();
  canvas->Modified();
  canvas->Update();
}
 
//__________________________________________________________________
 
void BesClient::ExecuteEvent( Int_t event, Int_t px, Int_t py, TObject* sel ) {
  //
  // Actions in reponse to mouse button events
 
  // Get view from current pad
  if ( !gBesGeometry )
  {
    // cout << "there is not BesGeometry" << endl;  // added by tianhl to debug event
    return;
  }
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  TString  viewInfo;
  if ( view ) viewInfo = TString( view->GetObjectInfo( px, py ) );
 
  switch ( event )
  {
  case kKeyPress:
    // px = char code of pressed key
    // py = counter
    if ( py <= 0 ) py = 1; // Reset counter
 
    // Long Peixun's update: Modify the easy key
    switch ( Char_t( px ) )
    {
    case '.': // Long Peixun modify: Next event: nN -> .>
    case '>': NextEvent(); break;
    case ',': // Long Peixun modify: Prev event: pP -> ,<
    case '<': PrevEvent(); break;
    case 'm': // Long Peixun add: First event: mM
    case 'M': FirstEvent(); break;
    case '/': // Long Peixun add: Last event: /?
    case '?': LastEvent(); break;
    case 'g': // Save picture as
    case 'G': SavePicAs(); break;
    }
 
    if ( !view )
      break; // Long Peixun's update: check view pointer before execute keys which need view
 
    // Long Peixun's update: Modify the easy key
    switch ( Char_t( px ) )
    {
    case '-': // Long Peixun modify: Zoom out: -_qQ
    case '_':
    case 'q':
    case 'Q':
      view->ZoomOut();
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case '+': // Long Peixun modify: Zoom in: +=eE
    case '=':
    case 'e':
    case 'E':
      view->ZoomIn();
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case 'a': // Long Peixun modify: Move left: aD
    case 'D':
      view->Move( -10, 0 );
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case 'd': // Long Peixun modify: Move right: dA
    case 'A':
      view->Move( 10, 0 );
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case 'w': // Long Peixun modify: Move up: wS
    case 'S':
      view->Move( 0, -10 );
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case 's': // Long Peixun modify: Move down: sW
    case 'W':
      view->Move( 0, 10 );
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    case 'o': // Long Peixun add: Move center: oO
    case 'O':
      view->Center();
      fEmbeddedCanvas->GetCanvas()->Update();
      break;
    }
    break;
 
  default:
    if ( sel != 0 )
    {
      // if ( !gPad->InheritsFrom("BesCanvas") ) {
      if ( gPad->GetName() != TString( "PadHeader" ) )
      {
        TString info( sel->GetTitle() );
        info.Append( ": " );
        info.Append( sel->GetObjectInfo( px, py ) );
        // info.Append(viewInfo);
        HandleInfoBar( info.Data() );
      }
    }
    break;
  }
 
  UpdateBesInputFields();
}
 
//__________________________________________________________________
 
void BesClient::SetState( Int_t id ) {
  //
  // set geometry state and update Canvas
  if ( id == -1 )
  {
    TGButton* btn = (TGButton*)gTQSender;
    id            = btn->WidgetId();
  }
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( view )
  {
    switch ( id )
    {
 
    case kM_Header_Global:
      // Long Peixun's update: Add Header control code
      fDisplay->SetVisHeader( fChkBtnHeaderGlobal->GetState() );
      break;
 
    case kM_Mdc_Global:
      view->SetVisMdcGlobal( fChkBtnMdcGlobal->GetState() );
      // gBesGeometry->GetMdcROOTGeo()->SetDetectorOn();
      // cout << "Mdc Global vis " << endl;
      break;
 
    case kM_Mdc_Tubes:
      view->SetVisMdcTubes( fChkBtnMdcTubes->GetState() );
      // HandleViewOptionMenu(kM_Mdc_Tubes);
      break;
 
    case kM_Mdc_Wires:
      view->SetVisMdcWires( fChkBtnMdcWires->GetState() );
      // HandleViewOptionMenu(kM_Mdc_Wires);
      break;
 
    case kM_Tof_Global:
      view->SetVisTofGlobal( fChkBtnTofGlobal->GetState() );
      // cout << "Tof Global vis " << endl;
      break;
 
    case kM_Tof_East: view->SetVisTofEast( fChkBtnTofEast->GetState() ); break;
 
    case kM_Tof_Barrel: view->SetVisTofBarrel( fChkBtnTofBarrel->GetState() ); break;
 
    case kM_Tof_West: view->SetVisTofWest( fChkBtnTofWest->GetState() ); break;
 
    case kM_Emc_Global:
      view->SetVisEmcGlobal( fChkBtnEmcGlobal->GetState() );
      // cout << "Emc Global vis " << endl;
      break;
 
    case kM_Emc_East: view->SetVisEmcEast( fChkBtnEmcEast->GetState() ); break;
 
    case kM_Emc_Barrel: view->SetVisEmcBarrel( fChkBtnEmcBarrel->GetState() ); break;
 
    case kM_Emc_West: view->SetVisEmcWest( fChkBtnEmcWest->GetState() ); break;
 
    case kM_Emc_Side: view->SetVisEmcSide( fChkBtnEmcSide->GetState() ); break;
 
    case kM_Muc_Global:
      view->SetVisMucGlobal( fChkBtnMucGlobal->GetState() );
      // cout << "Muc Global vis " << endl;
      break;
 
    case kM_Muc_East: view->SetVisMucEast( fChkBtnMucEast->GetState() ); break;
 
    case kM_Muc_Barrel: view->SetVisMucBarrel( fChkBtnMucBarrel->GetState() ); break;
 
    case kM_Muc_West: view->SetVisMucWest( fChkBtnMucWest->GetState() ); break;
 
    case kM_Muc_Strips: view->SetVisMucStrips( fChkBtnMucStrips->GetState() ); break;
 
    case kM_BeamPipe: view->SetVisBeamPipe( fChkBtnBeamPipe->GetState() ); break;
 
    case kM_ZRPlaneOnXY: view->SetVisZRPlaneOnXY( fChkBtnZRPlaneOnXY->GetState() ); break;
 
    case kM_Axis: view->SetVisAxis( fChkBtnAxis->GetState() ); break;
 
    case kM_MdcHits_Global:
      view->SetVisMdcHitsGlobal( fChkBtnMdcHitsGlobal->GetState() );
      break;
 
    case kM_TofHits_Global:
      view->SetVisTofHitsGlobal( fChkBtnTofHitsGlobal->GetState() );
      break;
 
    case kM_TofHits_East: view->SetVisTofHitsEast( fChkBtnTofHitsEast->GetState() ); break;
 
    case kM_TofHits_Barrel:
      view->SetVisTofHitsBarrel( fChkBtnTofHitsBarrel->GetState() );
      break;
 
    case kM_TofHits_West: view->SetVisTofHitsWest( fChkBtnTofHitsWest->GetState() ); break;
 
    case kM_EmcHits_Global:
      view->SetVisEmcHitsGlobal( fChkBtnEmcHitsGlobal->GetState() );
      break;
 
    case kM_EmcHits_East: view->SetVisEmcHitsEast( fChkBtnEmcHitsEast->GetState() ); break;
 
    case kM_EmcHits_Barrel:
      view->SetVisEmcHitsBarrel( fChkBtnEmcHitsBarrel->GetState() );
      break;
 
    case kM_EmcHits_West: view->SetVisEmcHitsWest( fChkBtnEmcHitsWest->GetState() ); break;
 
    case kM_EmcHits_Side: view->SetVisEmcHitsSide( fChkBtnEmcHitsSide->GetState() ); break;
 
    case kM_MucHits_Global:
      view->SetVisMucHitsGlobal( fChkBtnMucHitsGlobal->GetState() );
      break;
 
    case kM_MucHits_East: view->SetVisMucHitsEast( fChkBtnMucHitsEast->GetState() ); break;
 
    case kM_MucHits_Barrel:
      view->SetVisMucHitsBarrel( fChkBtnMucHitsBarrel->GetState() );
      break;
 
    case kM_MucHits_West: view->SetVisMucHitsWest( fChkBtnMucHitsWest->GetState() ); break;
 
    case kM_Tracks_Global: view->SetVisTracksGlobal( fChkBtnTracksGlobal->GetState() ); break;
 
    case kM_Tracks_Mdc: view->SetVisTracksMdc( fChkBtnTracksMdc->GetState() ); break;
 
    case kM_Tracks_Tof: view->SetVisTracksTof( fChkBtnTracksTof->GetState() ); break;
 
    case kM_Tracks_Emc: view->SetVisTracksEmc( fChkBtnTracksEmc->GetState() ); break;
 
    case kM_Tracks_Muc: view->SetVisTracksMuc( fChkBtnTracksMuc->GetState() ); break;
 
    case kM_Tracks_Ext: view->SetVisTracksExt( fChkBtnTracksExt->GetState() ); break;
 
    case kM_Mdc_TMatch_Global: this->SetMdcTFire( fChkBtnMdcTMatchGlobal->GetState() ); break;
 
    case kM_Mdc_QMatch_Global:
      this->SetMdcQFire( fChkBtnMdcQMatchGlobal->GetState() );
      break;
 
      // case   kM_Mdc_TOverflow_Global:
      //   this->SetMdcTOverflow(fChkBtnMdcTOverflowGlobal->GetState());
      //   break;
 
    case kM_Mdc_QNotOverflow_Global:
      this->SetMdcQNotOverflow( fChkBtnMdcQOverflowGlobal->GetState() );
      break;
 
    case kM_Mdc_ColorfulWire_Global:
      this->SetMdcColorfulWire( fChkBtnMdcColorfulWireGlobal->GetState() );
      break;
 
    case kM_Mdc_MdcTimeSubEvTime_Global:
      this->SetMdcTimeSubEvTime( fChkBtnMdcTimeSubEvTimeGlobal->GetState() );
      break;
 
    case kM_Tof_TMatch_Global: this->SetTofTMatch( fChkBtnTofTMatchGlobal->GetState() ); break;
 
    case kM_Tof_QMatch_Global: this->SetTofQMatch( fChkBtnTofQMatchGlobal->GetState() ); break;
    }
 
    view->UpdateView( 0 );
 
    ( (TCanvas*)fEmbeddedCanvas->GetCanvas() )->Modified();
    ( (TCanvas*)fEmbeddedCanvas->GetCanvas() )->Update();
  }
 
  UpdateStatus();
}
 
//_____________________________________________________
 
void BesClient::UpdateStatus() {
  //
  // get status from active BesView instance
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
 
  if ( view )
  {
    fZoomRatioNumber->SetNumber( view->GetStatusCurrent()->fZoom * 100.0 ); // yzhang
    view->SetZoomRatio( view->GetStatusCurrent()->fZoom );                  // yzhang
 
    // fish eye tick in zview menu
    view->SetFishEye( view->GetFishEyeStatus() );
 
    // Mdc global
    fChkBtnMdcGlobal->SetOn( view->GetVisMdcGlobal() );
 
    // Mdc Tubes
    fChkBtnMdcTubes->SetOn( view->GetVisMdcTubes() );
 
    // Mdc Wires
    fChkBtnMdcWires->SetOn( view->GetVisMdcWires() );
 
    // Tof global
    fChkBtnTofGlobal->SetOn( view->GetVisTofGlobal() );
 
    // Tof east
    fChkBtnTofEast->SetOn( view->GetVisTofEast() );
 
    // Tof barrel
    fChkBtnTofBarrel->SetOn( view->GetVisTofBarrel() );
 
    // Tof west
    fChkBtnTofWest->SetOn( view->GetVisTofWest() );
 
    // Emc global
    fChkBtnEmcGlobal->SetOn( view->GetVisEmcGlobal() );
 
    // Emc east
    fChkBtnEmcEast->SetOn( view->GetVisEmcEast() );
 
    // Emc barrel
    fChkBtnEmcBarrel->SetOn( view->GetVisEmcBarrel() );
 
    // Emc west
    fChkBtnEmcWest->SetOn( view->GetVisEmcWest() );
 
    // Emc side
    fChkBtnEmcSide->SetOn( view->GetVisEmcSide() );
 
    // Muc global
    fChkBtnMucGlobal->SetOn( view->GetVisMucGlobal() );
 
    // Muc east
    fChkBtnMucEast->SetOn( view->GetVisMucEast() );
 
    // Muc barrel
    fChkBtnMucBarrel->SetOn( view->GetVisMucBarrel() );
 
    // Muc west
    fChkBtnMucWest->SetOn( view->GetVisMucWest() );
 
    // Muc strips
    fChkBtnMucStrips->SetOn( view->GetVisMucStrips() );
 
    // BeamPipe
    fChkBtnBeamPipe->SetOn( view->GetVisBeamPipe() );
 
    // ZRPlaneOnXY
    fChkBtnZRPlaneOnXY->SetOn( view->GetVisZRPlaneOnXY() );
 
    // Axis
    fChkBtnAxis->SetOn( view->GetVisAxis() );
 
    // Long Peixun's update: for Header
    fChkBtnHeaderGlobal->SetOn( fDisplay->GetVisHeader() );
 
    // Mdc Hits global
    fChkBtnMdcHitsGlobal->SetOn( view->GetVisMdcHitsGlobal() );
 
    // Tof Hits global
    fChkBtnTofHitsGlobal->SetOn( view->GetVisTofHitsGlobal() );
 
    // Tof Hits east
    fChkBtnTofHitsEast->SetOn( view->GetVisTofHitsEast() );
 
    // Tof Hits barrel
    fChkBtnTofHitsBarrel->SetOn( view->GetVisTofHitsBarrel() );
 
    // Tof Hits west
    fChkBtnTofHitsWest->SetOn( view->GetVisTofHitsWest() );
 
    // Emc Hits global
    fChkBtnEmcHitsGlobal->SetOn( view->GetVisEmcHitsGlobal() );
 
    // Emc Hits east
    fChkBtnEmcHitsEast->SetOn( view->GetVisEmcHitsEast() );
 
    // Emc Hits barrel
    fChkBtnEmcHitsBarrel->SetOn( view->GetVisEmcHitsBarrel() );
 
    // Emc Hits west
    fChkBtnEmcHitsWest->SetOn( view->GetVisEmcHitsWest() );
 
    // Emc Hits side
    fChkBtnEmcHitsSide->SetOn( view->GetVisEmcHitsSide() );
 
    // Muc Hits global
    fChkBtnMucHitsGlobal->SetOn( view->GetVisMucHitsGlobal() );
 
    // Muc Hits east
    fChkBtnMucHitsEast->SetOn( view->GetVisMucHitsEast() );
 
    // Muc Hits barrel
    fChkBtnMucHitsBarrel->SetOn( view->GetVisMucHitsBarrel() );
 
    // Muc Hits west
    fChkBtnMucHitsWest->SetOn( view->GetVisMucHitsWest() );
 
    // Tracks global
    fChkBtnTracksGlobal->SetOn( view->GetVisTracksGlobal() );
 
    // Tracks mdc
    fChkBtnTracksMdc->SetOn( view->GetVisTracksMdc() );
 
    // Tracks tof
    fChkBtnTracksTof->SetOn( view->GetVisTracksTof() );
 
    // Tracks emc
    fChkBtnTracksEmc->SetOn( view->GetVisTracksEmc() );
 
    // Tracks muc
    fChkBtnTracksMuc->SetOn( view->GetVisTracksMuc() );
 
    // Tracks ext
    fChkBtnTracksExt->SetOn( view->GetVisTracksExt() );
 
    // Long Peixun's update: Header
    if ( fDisplay->GetVisHeader() ) fMenuViewOptionHeader->CheckEntry( kM_Header_Global );
    else fMenuViewOptionHeader->UnCheckEntry( kM_Header_Global );
 
    // Mdc Global
    if ( view->GetVisMdcGlobal() ) fMenuViewOptionMdc->CheckEntry( kM_Mdc_Global );
    else fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Global );
 
    // Mdc Tubes
    if ( view->GetVisMdcTubes() ) fMenuViewOptionMdc->CheckEntry( kM_Mdc_Tubes );
    else fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Tubes );
 
    // Mdc Wires
    if ( view->GetVisMdcWires() ) fMenuViewOptionMdc->CheckEntry( kM_Mdc_Wires );
    else fMenuViewOptionMdc->UnCheckEntry( kM_Mdc_Wires );
 
    // Tof Global
    if ( view->GetVisTofGlobal() ) fMenuViewOptionTof->CheckEntry( kM_Tof_Global );
    else fMenuViewOptionTof->UnCheckEntry( kM_Tof_Global );
 
    // Tof East
    if ( view->GetVisTofEast() ) fMenuViewOptionTof->CheckEntry( kM_Tof_East );
    else fMenuViewOptionTof->UnCheckEntry( kM_Tof_East );
 
    // Tof Barrel
    if ( view->GetVisTofBarrel() ) fMenuViewOptionTof->CheckEntry( kM_Tof_Barrel );
    else fMenuViewOptionTof->UnCheckEntry( kM_Tof_Barrel );
 
    // Tof West
    if ( view->GetVisTofWest() ) fMenuViewOptionTof->CheckEntry( kM_Tof_West );
    else fMenuViewOptionTof->UnCheckEntry( kM_Tof_West );
 
    // Emc Global
    if ( view->GetVisEmcGlobal() ) fMenuViewOptionEmc->CheckEntry( kM_Emc_Global );
    else fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Global );
 
    // Emc East
    if ( view->GetVisEmcEast() ) fMenuViewOptionEmc->CheckEntry( kM_Emc_East );
    else fMenuViewOptionEmc->UnCheckEntry( kM_Emc_East );
 
    // Emc Barrel
    if ( view->GetVisEmcBarrel() ) fMenuViewOptionEmc->CheckEntry( kM_Emc_Barrel );
    else fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Barrel );
 
    // Emc West
    if ( view->GetVisEmcWest() ) fMenuViewOptionEmc->CheckEntry( kM_Emc_West );
    else fMenuViewOptionEmc->UnCheckEntry( kM_Emc_West );
 
    // Emc Side
    if ( view->GetVisEmcSide() ) fMenuViewOptionEmc->CheckEntry( kM_Emc_Side );
    else fMenuViewOptionEmc->UnCheckEntry( kM_Emc_Side );
 
    // Muc Global
    if ( view->GetVisMucGlobal() ) fMenuViewOptionMuc->CheckEntry( kM_Muc_Global );
    else fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Global );
 
    // Muc East
    if ( view->GetVisMucEast() ) fMenuViewOptionMuc->CheckEntry( kM_Muc_East );
    else fMenuViewOptionMuc->UnCheckEntry( kM_Muc_East );
 
    // Muc Barrel
    if ( view->GetVisMucBarrel() ) fMenuViewOptionMuc->CheckEntry( kM_Muc_Barrel );
    else fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Barrel );
 
    // Muc West
    if ( view->GetVisMucWest() ) fMenuViewOptionMuc->CheckEntry( kM_Muc_West );
    else fMenuViewOptionMuc->UnCheckEntry( kM_Muc_West );
 
    // Muc Strips
    if ( view->GetVisMucStrips() ) fMenuViewOptionMuc->CheckEntry( kM_Muc_Strips );
    else fMenuViewOptionMuc->UnCheckEntry( kM_Muc_Strips );
 
    // Full3D Mdc
    if ( view->GetVisFull3DMdc() ) fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Mdc );
    else fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Mdc );
 
    // Full3D Tof
    if ( view->GetVisFull3DTof() ) fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Tof );
    else fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Tof );
 
    // Full3D Emc
    if ( view->GetVisFull3DEmc() ) fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Emc );
    else fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Emc );
 
    // Full3D Muc
    if ( view->GetVisFull3DMuc() ) fMenuViewOptionFull3D->CheckEntry( kM_Full3D_Muc );
    else fMenuViewOptionFull3D->UnCheckEntry( kM_Full3D_Muc );
 
    // BeamPipe
    if ( view->GetVisBeamPipe() ) fMenuViewOptionOthers->CheckEntry( kM_BeamPipe );
    else fMenuViewOptionOthers->UnCheckEntry( kM_BeamPipe );
 
    // ZRPlaneOnXY
    if ( view->GetVisZRPlaneOnXY() ) fMenuViewOptionOthers->CheckEntry( kM_ZRPlaneOnXY );
    else fMenuViewOptionOthers->UnCheckEntry( kM_ZRPlaneOnXY );
 
    // Axis
    if ( view->GetVisAxis() )
    {
      fMenuViewOptionOthers->CheckEntry( kM_Axis );
      fShowAxisButton->SetPicture( gClient->GetPicture( "ButtonShowAxisST.gif" ) );
      fShowAxisButton->SetState( true );
    }
    else
    {
      fMenuViewOptionOthers->UnCheckEntry( kM_Axis );
      fShowAxisButton->SetPicture( gClient->GetPicture( "ButtonShowAxis.gif" ) );
      fShowAxisButton->SetState( false );
    }
 
    // Mdc Hits
    if ( view->GetVisMdcHits() ) fMenuViewOptionMdcHits->CheckEntry( kM_MdcHits_Hits );
    else fMenuViewOptionMdcHits->UnCheckEntry( kM_MdcHits_Hits );
 
    // Tof hits Global
    if ( view->GetVisTofHitsGlobal() ) fMenuViewOptionTofHits->CheckEntry( kM_TofHits_Global );
    else fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_Global );
 
    // Tof hits East
    if ( view->GetVisTofHitsEast() ) fMenuViewOptionTofHits->CheckEntry( kM_TofHits_East );
    else fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_East );
 
    // Tof hits Barrel
    if ( view->GetVisTofHitsBarrel() ) fMenuViewOptionTofHits->CheckEntry( kM_TofHits_Barrel );
    else fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_Barrel );
 
    // Tof hits West
    if ( view->GetVisTofHitsWest() ) fMenuViewOptionTofHits->CheckEntry( kM_TofHits_West );
    else fMenuViewOptionTofHits->UnCheckEntry( kM_TofHits_West );
 
    // Emc hits Global
    if ( view->GetVisEmcHitsGlobal() ) fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Global );
    else fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Global );
 
    // Emc hits East
    if ( view->GetVisEmcHitsEast() ) fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_East );
    else fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_East );
 
    // Emc hits Barrel
    if ( view->GetVisEmcHitsBarrel() ) fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Barrel );
    else fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Barrel );
 
    // Emc hits West
    if ( view->GetVisEmcHitsWest() ) fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_West );
    else fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_West );
 
    // Emc hits Side
    if ( view->GetVisEmcHitsSide() ) fMenuViewOptionEmcHits->CheckEntry( kM_EmcHits_Side );
    else fMenuViewOptionEmcHits->UnCheckEntry( kM_EmcHits_Side );
 
    // Muc hits Global
    if ( view->GetVisMucHitsGlobal() ) fMenuViewOptionMucHits->CheckEntry( kM_MucHits_Global );
    else fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_Global );
 
    // Muc hits East
    if ( view->GetVisMucHitsEast() ) fMenuViewOptionMucHits->CheckEntry( kM_MucHits_East );
    else fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_East );
 
    // Muc hits Barrel
    if ( view->GetVisMucHitsBarrel() ) fMenuViewOptionMucHits->CheckEntry( kM_MucHits_Barrel );
    else fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_Barrel );
 
    // Muc hits West
    if ( view->GetVisMucHitsWest() ) fMenuViewOptionMucHits->CheckEntry( kM_MucHits_West );
    else fMenuViewOptionMucHits->UnCheckEntry( kM_MucHits_West );
 
    // Tracks Global
    if ( view->GetVisTracksGlobal() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Global );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Global );
 
    // Tracks Mdc
    if ( view->GetVisTracksMdc() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Mdc );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Mdc );
 
    // Tracks Tof
    if ( view->GetVisTracksTof() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Tof );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Tof );
 
    // Tracks Emc
    if ( view->GetVisTracksEmc() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Emc );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Emc );
 
    // Tracks Muc
    if ( view->GetVisTracksMuc() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Muc );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Muc );
 
    // Tracks Ext
    if ( view->GetVisTracksExt() ) fMenuViewOptionTracks->CheckEntry( kM_Tracks_Ext );
    else fMenuViewOptionTracks->UnCheckEntry( kM_Tracks_Ext );
 
    // Fish Eye View
    if ( view->GetFishEye() )
    { fFishEyeViewButton->SetPicture( gClient->GetPicture( "ButtonFishEyeViewST.gif" ) ); }
    else { fFishEyeViewButton->SetPicture( gClient->GetPicture( "ButtonFishEyeView.gif" ) ); }
 
    // Parallel or Perspective View
    if ( view->IsPerspective() )
    {
      fParallelViewButton->SetPicture( gClient->GetPicture( "ButtonParallelView.gif" ) );
      fPerspectiveViewButton->SetPicture(
          gClient->GetPicture( "ButtonPerspectiveViewST.gif" ) );
    }
    else
    {
      fParallelViewButton->SetPicture( gClient->GetPicture( "ButtonParallelViewST.gif" ) );
      fPerspectiveViewButton->SetPicture( gClient->GetPicture( "ButtonPerspectiveView.gif" ) );
    }
  }
  UpdateBesInputFields();
}
 
//__________________________________________________________________
 
void BesClient::HandleButtons( Int_t id ) {
  //
  // Handle different buttons
  if ( id == -1 )
  {
    TGButton* btn = (TGButton*)gTQSender;
    id            = btn->WidgetId();
  }
 
  // TCanvas *canvas = (TCanvas*)fEmbeddedCanvas->GetCanvas();
  TString query       = "";
  Int_t   displayMode = 0;
 
  Double_t xmin = 0.0, ymin = 0.0, xmax = 0.0, ymax = 0.0;
  if ( gPad )
  {
    xmin = gPad->GetX1();
    ymin = gPad->GetY1();
    xmax = gPad->GetX2();
    ymax = gPad->GetY2();
  }
 
  BesView* view = 0;
  if ( gPad ) view = dynamic_cast<BesView*>( gPad->GetView() );
  Int_t iret;
  // Double_t theta, phi, psi;
 
  switch ( id )
  {
 
  case kM_Button_LoadGeoFile: // Load geometry file
    LoadGeoFile();
    fLoadGeoFileButton->SetPicture( gClient->GetPicture( "ButtonLoadGeoFile.gif" ) );
    break;
 
  case kM_Button_OpenEventFile: // Load event file
    OpenEventFile();
    fOpenEventFileButton->SetPicture( gClient->GetPicture( "ButtonOpenEventFile.gif" ) );
    break;
 
  case kM_Button_SavePicAs: // Save picture as
    SavePicAs();
    fSavePicAsButton->SetPicture( gClient->GetPicture( "ButtonSavePicAs.gif" ) );
    break;
 
  case kM_Button_SavePicAsPS: // Save picture as *.ps
    fSavePicAsPSButton->SetPicture( gClient->GetPicture( "ButtonSavePicAsPSHL.gif" ) );
    // SavePicAsPS();
    fEmbeddedCanvas->GetCanvas()->Print( "besvis.ps", "ps" );
    fSavePicAsPSButton->SetPicture( gClient->GetPicture( "ButtonSavePicAsPS.gif" ) );
    break;
 
  case kM_Button_Refresh: // Refresh all pads
                          // fDisplay->SwitchDisplayMode(fDisplay->GetDisplayMode());
    if ( view ) fDisplay->Refresh();          // Long Peixun's update: Refresh all view
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    // if (view) view->UpdateView(0);
    break;
 
  case kM_Button_ResetCurrent: // reset active pad to default
    if ( view ) view->Reset();
    break;
 
  case kM_Button_ResetAll: // Reset all pads to Default
    if ( view ) fDisplay->Reset();
    break;
 
  case kM_Button_CursorPick: // Cursor Pick
    gBesCursor->SetType( kBesPick );
    fCursorButton[0]->SetPicture( gClient->GetPicture( "ButtonCursorPickST.gif" ) );
    fCursorButton[0]->SetState( true );
    fCursorButton[1]->SetPicture( gClient->GetPicture( "ButtonCursorHand.gif" ) );
    fCursorButton[1]->SetState( false );
    // fCursorButton[0]->SetState(kButtonEngaged);
    // fCursorButton[1]->SetState(kButtonUp);
    break;
 
  case kM_Button_CursorHand: // Cursor Hand
    gBesCursor->SetType( kBesHand );
    fCursorButton[0]->SetPicture( gClient->GetPicture( "ButtonCursorPick.gif" ) );
    fCursorButton[0]->SetState( false );
    fCursorButton[1]->SetPicture( gClient->GetPicture( "ButtonCursorHandST.gif" ) );
    fCursorButton[1]->SetState( true );
    break;
 
  case kM_Button_ZoomOut: // Zoom out
    if ( view ) view->ZoomOut();
    break;
 
  case kM_Button_ZoomIn: // Zoom in
    if ( view ) view->ZoomIn();
    break;
 
  case kM_Button_SetHome: // Set Home position
    SetHome();
    break;
 
  case kM_Button_GoHome: // Go Home position
    GoHome();
    break;
 
  case kM_Button_SaveMyConfig:
    SaveMyConfig();
    fSaveMyConfigButton->SetPicture( gClient->GetPicture( "ButtonSaveMyConfig.gif" ) );
    break;
 
  case kM_Button_LoadMyConfig:
    LoadMyConfig();
    fLoadMyConfigButton->SetPicture( gClient->GetPicture( "ButtonLoadMyConfig.gif" ) );
    break;
 
  case kM_Button_Palette:
    LoadMdcPalette();
    fPaletteButton->SetPicture( gClient->GetPicture( "ButtonPalette.gif" ) );
    break;
 
  case kM_Button_Help: Help(); break;
 
  case kM_Button_ShowInfo: // Show Info
    gBesCursor->SetShowInfo( !gBesCursor->GetShowInfo() );
    if ( gBesCursor->GetShowInfo() )
    {
      fShowInfoButton->SetState( true );
      fShowInfoButton->SetPicture( gClient->GetPicture( "ButtonShowInfoST.gif" ) );
    }
    else
    {
      fShowInfoButton->SetState( false );
      fShowInfoButton->SetPicture( gClient->GetPicture( "ButtonShowInfo.gif" ) );
    }
    break;
 
  case kM_Button_ShowAxis: // Show Axis
    if ( view )
    {
      view->SetVisAxis( !view->GetVisAxis() );
      if ( view->GetVisAxis() )
      {
        fShowAxisButton->SetPicture( gClient->GetPicture( "ButtonShowAxisST.gif" ) );
        fShowAxisButton->SetState( true );
      }
      else
      {
        fShowAxisButton->SetPicture( gClient->GetPicture( "ButtonShowAxis.gif" ) );
        fShowAxisButton->SetState( false );
      }
      view->UpdateView( 0 );
    }
    break;
 
  case kM_Button_FishEyeView: // FishEye View
    if ( view )
    {
      view->SetFishEye( !view->GetFishEye() );
      if ( view->GetFishEye() )
      {
        fFishEyeViewButton->SetPicture( gClient->GetPicture( "ButtonFishEyeViewST.gif" ) );
        fFishEyeViewButton->SetState( true );
      }
      else
      {
        fFishEyeViewButton->SetPicture( gClient->GetPicture( "ButtonFishEyeView.gif" ) );
        fFishEyeViewButton->SetState( false );
      }
    }
    break;
 
  case kM_Button_ParallelView: // Parallel View
    if ( view && view->IsPerspective() )
    {
      fParallelViewButton->SetPicture( gClient->GetPicture( "ButtonParallelViewST.gif" ) );
      fParallelViewButton->SetState( true );
      fPerspectiveViewButton->SetPicture( gClient->GetPicture( "ButtonPerspectiveView.gif" ) );
      fPerspectiveViewButton->SetState( false );
      // view->SetParralel();
      view->SetParallel();
      // use SetParallel() instead of depreciated function SetParralel()
      // changed by tianhl at Mon Aug 20 2007
      view->UpdateView( 0 );
    }
    break;
 
  case kM_Button_PerspectiveView: // Perspective View
    if ( view && !view->IsPerspective() )
    {
      fParallelViewButton->SetPicture( gClient->GetPicture( "ButtonParallelView.gif" ) );
      fParallelViewButton->SetState( false );
      fPerspectiveViewButton->SetPicture(
          gClient->GetPicture( "ButtonPerspectiveViewST.gif" ) );
      fPerspectiveViewButton->SetState( true );
      view->SetPerspective();
      view->UpdateView( 0 );
    }
    break;
 
  case kM_Button_X3D: // X3D
    X3D();
    fX3DButton->SetPicture( gClient->GetPicture( "ButtonX3D.gif" ) );
    break;
 
  case kM_Button_OpenGL: // OpenGL
    OpenGL();
    fOpenGLButton->SetPicture( gClient->GetPicture( "ButtonOpenGL.gif" ) );
    break;
 
  case kM_Button_NextEvent: NextEvent(); break;
 
  case kM_Button_PrevEvent: PrevEvent(); break;
 
  case kM_Button_PlayEvent: AutoDisplayEvent(); break;
 
  case kM_Button_FirstEvent: FirstEvent(); break;
 
  case kM_Button_ViewResetAngle:
    if ( view )
    { // Long Peixun's update: Consider view == NULL
      if ( view->GetViewType() == k3DView ) view->Front();
      if ( view->GetViewType() == kXYView ) view->SetView( 0, 0, 270, iret );
      if ( view->GetViewType() == kZRView ) view->SetView( 180, 90, 90, iret );
    }
    break;
 
  case kM_Button_ViewCounterClockWise:
    RotateClockWise( -1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotateClockWise != -1 )
      {
        fAutoRotateClockWise = -1;
        fAutoRotatePhi       = 0;
      }
      else fAutoRotateClockWise = 0;
    }
    break;
 
  case kM_Button_ViewClockWise:
    RotateClockWise( 1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotateClockWise != 1 )
      {
        fAutoRotateClockWise = 1;
        fAutoRotatePhi       = 0;
      }
      else fAutoRotateClockWise = 0;
    }
    break;
 
  case kM_Button_ViewMoveUp:
    // Long Peixun's update: Consider view == NULL
    if ( view ) view->Move( 0, -10 ); // Long Peixun's update: Fix up and down direction
    // if (gPad) gPad->Range(xmin, ymin+fMoveFactor*(ymax-ymin), xmax,
    // ymax+fMoveFactor*(ymax-ymin));
    break;
 
  case kM_Button_ViewMoveDown:
    // Long Peixun's update: Consider view == NULL
    if ( view ) view->Move( 0, 10 ); // Long Peixun's update: Fix up and down direction
    break;
 
  case kM_Button_ViewMoveLeft:
    // Long Peixun's update: Consider view == NULL
    if ( view ) view->Move( -10, 0 );
    break;
 
  case kM_Button_ViewMoveRight:
    // Long Peixun's update: Consider view == NULL
    if ( view ) view->Move( 10, 0 );
    break;
 
  case kM_Button_ViewMoveCenter:
    // Long Peixun's update: Consider view == NULL
    if ( view ) view->Center();
    break;
 
  case kM_Button_ViewAngleThetaPlus:
    RotateTheta( 1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotateTheta != 1 ) fAutoRotateTheta = 1;
      else fAutoRotateTheta = 0;
    }
    break;
 
  case kM_Button_ViewAngleThetaMinus:
    RotateTheta( -1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotateTheta != -1 ) fAutoRotateTheta = -1;
      else fAutoRotateTheta = 0;
    }
    break;
 
  case kM_Button_ViewAnglePhiPlus:
    RotatePhi( 1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotatePhi != 1 )
      {
        fAutoRotatePhi       = 1;
        fAutoRotateClockWise = 0;
      }
      else fAutoRotatePhi = 0;
    }
    break;
 
  case kM_Button_ViewAnglePhiMinus:
    RotatePhi( -1 );
    if ( fAutoRotate )
    {
      if ( fAutoRotatePhi != -1 )
      {
        fAutoRotatePhi       = -1;
        fAutoRotateClockWise = 0;
      }
      else fAutoRotatePhi = 0;
    }
    break;
 
  case kM_Button_ViewAnglePsiPlus:
    if ( view->GetViewType() == k3DView )
    {
      RotatePsi( 1 );
      if ( fAutoRotate )
      {
        if ( fAutoRotatePsi != 1 ) fAutoRotatePsi = 1;
        else fAutoRotatePsi = 0;
      }
    }
    break;
 
  case kM_Button_ViewAnglePsiMinus:
    if ( view->GetViewType() == k3DView )
    {
      RotatePsi( -1 );
      if ( fAutoRotate )
      {
        if ( fAutoRotatePsi != -1 ) fAutoRotatePsi = -1;
        else fAutoRotatePsi = 0;
      }
    }
    break;
 
  case kM_Button_AutoRotate: AutoRotate(); break;
 
  case kM_Button_DisplayMode2D:
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[0]->SetState( true );
    fDisplayModeButton[0]->SetPicture( gClient->GetPicture( "DisplayMode2DST.gif" ) );
    fDisplay->SwitchDisplayMode( 0 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
 
  case kM_Button_DisplayModeXY:
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[1]->SetState( true );
    fDisplayModeButton[1]->SetPicture( gClient->GetPicture( "DisplayModeXYST.gif" ) );
    fDisplay->SwitchDisplayMode( 1 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
 
  case kM_Button_DisplayModeZR:
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[2]->SetState( true );
    fDisplayModeButton[2]->SetPicture( gClient->GetPicture( "DisplayModeZRST.gif" ) );
    fDisplay->SwitchDisplayMode( 2 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
 
  case kM_Button_DisplayMode3D:
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[3]->SetState( true );
    fDisplayModeButton[3]->SetPicture( gClient->GetPicture( "DisplayMode3DST.gif" ) );
    fDisplay->SwitchDisplayMode( 3 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
 
  case kM_Button_DisplayModeAll:
    SetAllDisplayModeButtonUnHL();
    fDisplayModeButton[4]->SetState( true );
    fDisplayModeButton[4]->SetPicture( gClient->GetPicture( "DisplayModeAllST.gif" ) );
    fDisplay->SwitchDisplayMode( 4 );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
 
  case kM_Button_SwitchDisplayMode:
    displayMode = fDisplay->GetDisplayMode();
    displayMode++;
    if ( displayMode >= kNDisplayMode )
      displayMode = 0; // Long Peixun's update: Adjust display mode
    fDisplay->SwitchDisplayMode( displayMode );
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
 
    SetAllDisplayModeButtonUnHL();
    switch ( displayMode )
    {
    case 0:
      fDisplayModeButton[displayMode]->SetPicture(
          gClient->GetPicture( "DisplayMode2DST.gif" ) );
      break;
    case 1:
      fDisplayModeButton[displayMode]->SetPicture(
          gClient->GetPicture( "DisplayModeXYST.gif" ) );
      break;
    case 2:
      fDisplayModeButton[displayMode]->SetPicture(
          gClient->GetPicture( "DisplayModeZRST.gif" ) );
      break;
    case 3:
      fDisplayModeButton[displayMode]->SetPicture(
          gClient->GetPicture( "DisplayMode3DST.gif" ) );
      break;
    case 4:
      fDisplayModeButton[displayMode]->SetPicture(
          gClient->GetPicture( "DisplayModeAllST.gif" ) );
      break;
    default: break;
    }
    break;
 
  case kM_Button_SwitchPad:
    fDisplay->SwitchPad();
    HandleStatusBar( GetCurrentPadString() ); // Long Peixun's update: Update status bar
    break;
  }
 
  UpdateStatus();
  UpdateCurrentPad();
  UpdateBesInputFields();
}
 
//__________________________________________________________________
 
void BesClient::HandleSliders( Int_t slider ) {
  //
  // Handle slider events
  if ( gDebug ) cout << "BesClient::DoSlider called!" << endl;
 
  TGButton* btn = (TGButton*)gTQSender;
  Int_t     id  = btn->WidgetId();
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  Int_t    iret;
 
  switch ( id )
  {
 
  case kM_Slider_EventPlay:
    fEventPlaySlider->SetPosition( slider );
    if ( fEventTree )
    {
      fBesEventNo = slider;
      this->GetEvent( fBesEventNo );
    }
    break;
 
  case kM_Slider_ViewAngleTheta:
    if ( view ) { view->SetView( view->GetLongitude(), slider, view->GetPsi(), iret ); }
    break;
 
  case kM_Slider_ViewAnglePhi:
    if ( view ) { view->SetView( slider, view->GetLatitude(), view->GetPsi(), iret ); }
    break;
 
  case kM_Slider_ViewAnglePsi:
    if ( view && view->GetViewType() == k3DView )
    { view->SetView( view->GetLongitude(), view->GetLatitude(), slider, iret ); }
    break;
  }
 
  UpdateCurrentPad();
  UpdateBesInputFields();
}
 
//_________________________________________________________________
 
void BesClient::UpdateAllView() {
  TCanvas* canvas = (TCanvas*)fEmbeddedCanvas->GetCanvas();
  TPad*    curPad = (TPad*)gPad; // canvas->GetSelectedPad();
 
  fDisplay->GetPadXY()->cd();
  BesView* view = dynamic_cast<BesView*>( fDisplay->GetPadXY()->GetView() );
  if ( view )
  {
    view->UpdateView( 0 );
    cout << "update xy view" << endl;
  }
  else cout << "no xy view" << endl;
 
  fDisplay->GetPadZR()->cd();
  view = dynamic_cast<BesView*>( fDisplay->GetPadZR()->GetView() );
  if ( view )
  {
    view->UpdateView( 0 );
    cout << "update zr view" << endl;
  }
  else cout << "no zr view" << endl;
 
  fDisplay->GetPad3D()->cd();
  view = dynamic_cast<BesView*>( fDisplay->GetPad3D()->GetView() );
  if ( view )
  {
    view->UpdateView( 0 );
    cout << "update 3d view" << endl;
  }
  else cout << "no 3d view" << endl;
 
  // Header show be drawn last, as it will update all pads and makes tracks in pad drawn first
  fDisplay->DrawHeader();
  fDisplay->Refresh(); // Long Peixun's update: Refresh all views
 
  curPad->cd();
 
  UpdateBesInputFields();
 
  // Redraw canvas
  canvas->Modified();
  canvas->Update();
}
 
//_________________________________________________________________
 
void BesClient::UpdateCurrentPad() {
  if ( gPad )
  {
    gPad->Modified();
    gPad->Update();
  }
 
  // BesView *view = dynamic_cast<BesView*>(gPad->GetView());
 
  // TViewerX3D *x3d = 0;
  // x3d = (TViewerX3D*)gPad->GetViewer3D();
  // if (fViewer3DMode == 1 && view && x3d) {
  //     x3d->ExecCommand(Int_t(2*view->GetLatitude()), Int_t(2*view->GetLongitude()), 0);
  //     //rotate
  // }
 
  ////TViewerOpenGL *ogl = 0;
  ////ogl = (TViewerOpenGL*)gPad->GetViewer3D();
  //// update from 4.04 to 5.14
  // TVirtualViewer3D *ogl = 0;
  // ogl = (TVirtualViewer3D*)gPad->GetViewer3D("ogl");
  // if (fViewer3DMode == 2 && view && ogl) {
  //     gVirtualGL->ClearGLColor(0.0,0.0,0.0,0.0);   // set GL background color
  //     gVirtualGL->SetGLLineWidth(5);
 
  //    Double_t deltaTheta = view->GetLatitude()  - fViewThetaPreStep;
  //    Double_t deltaPhi   = view->GetLongitude() - fViewPhiPreStep;
  //    if (deltaTheta >  90.0)  deltaTheta -= 180.0;
  //    if (deltaTheta < -90.0)  deltaTheta += 180.0;
  //    if (deltaPhi   >  180.0) deltaPhi   -= 360.0;
  //    if (deltaPhi   < -180.0) deltaPhi   += 360.0;
 
  //    // update from 4.04 to 5.14, TViewerOpenGL has been removed,
  //    // TVirtualViewer3D has none those memthods
  //    //UInt_t width = ogl->GetWidth();
  //    //UInt_t height = ogl->GetHeight();
  //    //UInt_t xPos = width/2, yPos = height/2;
 
  //    //Event_t *event1 = new Event_t;
  //    //event1->fType = kButtonPress;
  //    //event1->fX = xPos; //(Int_t)view->GetLatitude();
  //    //event1->fY = yPos; //(Int_t)view->GetLongitude();
  //    //event1->fCode = kButton1;
  //    //ogl->HandleContainerButton(event1);
 
  //    //Event_t *event2 = new Event_t;
  //    //event2->fType = kMotionNotify;
  //    //event2->fX = (Int_t)(xPos + deltaTheta);
  //    //event2->fY = (Int_t)(yPos + deltaPhi);
  //    //ogl->HandleContainerMotion(event2);
 
  //    //Event_t *event3 = new Event_t;
  //    //event3->fType = kButtonRelease;
  //    //event3->fX = (Int_t)(xPos + deltaTheta); //(view->GetLatitude()  + deltaPhi);
  //    //event3->fY = (Int_t)(yPos + deltaPhi); //(view->GetLongitude() + deltaTheta);
  //    //event3->fCode = kButton1;
  //    //ogl->HandleContainerButton(event3);
 
  //    //fViewThetaPreStep = view->GetLatitude();
  //    //fViewPhiPreStep   = view->GetLongitude();
 
  //    //delete event1;
  //    //delete event2;
  //    //delete event3;
  //}
}
 
//_________________________________________________________________
 
void BesClient::UpdateBesInputFields() {
  fNumEntryRunNo->SetNumber( GetBesRunNo() );
  fNumEntryEventNo->SetIntNumber( GetBesEventNo() );
  fNumEntryEventPlaySpeed->SetNumber( Double_t( GetEventPlaySpeed() ) / 1000.0 );
  fEventPlaySlider->SetPosition( GetBesEventNo() );
 
  fNumEntryRotateStep->SetNumber( GetRotateStep() );
  fNumEntryRotateSpeed->SetNumber( GetRotateSpeed() );
  fNumEntryRotateFPS->SetIntNumber( GetRotateFPS() );
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  if ( view )
  {
    fZoomRatioNumber->SetNumber( view->GetZoomRatio() * 100.0 );
 
    Double_t theta = view->GetLatitude();
    Double_t phi   = view->GetLongitude();
    Double_t psi   = view->GetPsi();
    SetRange( theta, 0.0, 180.0 );
    SetRange( phi, 0.0, 360.0 );
    SetRange( psi, 0.0, 360.0 );
    fViewAngleThetaNumber->SetNumber( theta );
    fViewAnglePhiNumber->SetNumber( phi );
    fViewAnglePsiNumber->SetNumber( psi );
  }
  fViewAngleThetaSlider->SetPosition( (Int_t)fViewAngleThetaNumber->GetNumber() );
  fViewAnglePhiSlider->SetPosition( (Int_t)fViewAnglePhiNumber->GetNumber() );
  fViewAnglePsiSlider->SetPosition( (Int_t)fViewAnglePsiNumber->GetNumber() );
 
  fChkBtnAutoRotate->SetOn( fAutoRotate );
}
 
//_____________________________________________________
 
void BesClient::ChangeFocus() {
  //
  // change focus on pressed tab
  if ( gDebug ) cout << "BesClient::ChangeFocus called!" << endl;
 
  if ( gTQSender == fNumEntryRunNo->GetNumberEntry() )
  {
    fNumEntryEventNo->GetNumberEntry()->SelectAll();
    fNumEntryEventNo->GetNumberEntry()->SetFocus();
  }
  else if ( gTQSender == fNumEntryEventPlaySpeed->GetNumberEntry() )
  {
    fNumEntryEventPlaySpeed->GetNumberEntry()->SelectAll();
    fNumEntryEventPlaySpeed->GetNumberEntry()->SetFocus();
  }
  else if ( gTQSender == fNumEntryMagnetic->GetNumberEntry() )
  {
    fNumEntryMagnetic->GetNumberEntry()->SelectAll();
    fNumEntryMagnetic->GetNumberEntry()->SetFocus();
  }
}
 
//_____________________________________________________
 
void BesClient::ExecuteReturn() {
  //
  // execute if return was pressed
  if ( gDebug ) cout << "BesClient::ExecuteReturn called!" << endl;
 
  BesView* view = dynamic_cast<BesView*>( gPad->GetView() );
  // Double_t theta, phi, psi;
  Int_t iret;
 
  if ( gTQSender == fZoomRatioNumber )
  {
    if ( view ) view->SetZoomRatio( fZoomRatioNumber->GetNumber() / 100.0 );
  }
 
  if ( gTQSender == fNumEntryEventNo->GetNumberEntry() )
  {
    // fBesEventNo = fNumEntryEventNo->GetIntNumber();
    // this->GetEvent(fBesEventNo);
 
    // Long Peixun's update: If event doesn't exist, don't change fBesEventNo
    Long64_t tempno = fBesEventNo;
    fBesEventNo     = fNumEntryEventNo->GetIntNumber();
    if ( !this->GetEvent( fBesEventNo ) ) fBesEventNo = tempno;
  }
 
  else if ( gTQSender == fNumEntryEventPlaySpeed->GetNumberEntry() )
  {
    fEventPlaySpeed = Int_t( fNumEntryEventPlaySpeed->GetNumber() * 1000 );
    fAutoDisplayEventTimer->SetTime( fEventPlaySpeed );
  }
 
  else if ( gTQSender == fNumEntryRotateSpeed )
  {
    fRotateSpeed = fNumEntryRotateSpeed->GetNumber();
    this->SetRotateStep();
    cout << "fRotateSpeed " << fRotateSpeed << " fRotateStep " << fRotateStep << endl;
    // fAutoRotateTimer->SetTime((Int_t)1000/this->GetRotateFPS());
  }
 
  else if ( gTQSender == fNumEntryRotateFPS->GetNumberEntry() )
  {
    fRotateFPS = fNumEntryRotateFPS->GetIntNumber();
    this->SetRotateSpeed();
    fAutoRotateTimer->SetTime( (Int_t)1000 / fRotateFPS );
    cout << "fRotateFPS " << fRotateFPS << " fRotateStep " << fRotateStep << endl;
  }
 
  else if ( gTQSender == fNumEntryMagnetic->GetNumberEntry() )
  {
    if ( gEvent )
    {
      gEvent->SetMagnetic( fNumEntryMagnetic->GetNumber() );
      GetEvent( fBesEventNo ); // Long Peixun's update: Update display when change the magnetic
                               // field
    }
  }
 
  else if ( gTQSender == fNumEntryRotateStep )
  {
    fRotateStep  = fNumEntryRotateStep->GetNumber();
    fRotateSpeed = fRotateStep * fRotateFPS;
    cout << "fRotateSpeed " << fRotateSpeed << " fRotateStep " << fRotateStep << endl;
  }
 
  else if ( gTQSender == fViewAngleThetaNumber )
  {
    if ( view )
    {
      view->SetView( view->GetLongitude(), fViewAngleThetaNumber->GetNumber(), view->GetPsi(),
                     iret );
    }
  }
 
  else if ( gTQSender == fViewAnglePhiNumber )
  {
    if ( view )
    {
      view->SetView( fViewAnglePhiNumber->GetNumber(), view->GetLatitude(), view->GetPsi(),
                     iret );
    }
  }
 
  else if ( gTQSender == fViewAnglePsiNumber )
  {
    if ( view && view->GetViewType() == k3DView )
    {
      view->SetView( view->GetLongitude(), view->GetLatitude(),
                     fViewAnglePsiNumber->GetNumber(), iret );
    }
  }
 
  fEmbeddedCanvas->RequestFocus(); // RequestFocus to let Hot Key "QWEASD.." work in
                                   // ExecuteEvent, or it doesnt work after input
  UpdateCurrentPad();
  UpdateBesInputFields();
}
 
Pixmap_t BesClient::GetPic( const char* file ) {
  TString filePath = fBesVisPath;
  filePath += "/icons/";
  filePath += file;
 
  TASImage asImage( filePath );
  Pixmap_t pic = asImage.GetPixmap();
  // asImage->Draw();
  return pic;
}
 
Bool_t BesClient::FileExists( TString fname ) {
  // gSystem return 0 if exist, 1 for not exist
  return ( !gSystem->AccessPathName( fname, kFileExists ) );
}
 
// makes min <= input < max
void BesClient::SetRange( Double_t& input, Double_t min, Double_t max ) {
  Double_t range = max - min;
  if ( input < min )
  {
    do {
      input += range;
    } while ( input < min );
  }
 
  if ( input >= max )
  {
    do {
      input -= range;
    } while ( input >= max );
  }
}
 
// Long Peixun's update: Return current pad hint string
const char* BesClient::GetCurrentPadString() {
  if ( (TPad*)gPad == fDisplay->GetPadXY() ) return "XY view";
  else if ( (TPad*)gPad == fDisplay->GetPadZR() ) return "ZR view";
  else if ( (TPad*)gPad == fDisplay->GetPad3D() ) return "3D view";
  else return "Ready";
}