HistoDisplay.cxx

Go to the documentation of this file.

//
// HistoDisplay.C
// Tetsuo Arisawa, 1999 0715
// 
//
// modified by Hans Wenzel to make it work within 
// CDF environment 
// modified by Frank Hartmann
// to allow socket connection to DisplayServer
// modified by  Koji Ikado 
// to display member pictures
//
// Version 1.5 1999 11/18 Tetsuo.Arisawa 
//  TCanvas in addition to TH1F* can be read and drawn. 
// Version 1.51 2000 2/17 T.A
//  TH1F are drawn maintaining original options as being sent.
//  GXW are replaced by ViratualX for the new ROOT version (by Hans).
//  GetDirPath are modified to match new YMON histo names.
//  Canvas Window Resize is tuned by 0.844.( Do not know why.)
// Version 1.52 2000 3/  T.A
//  Any histograms which inherits from TH1, (not TH1F any more)
//  can be handled. For example TProfile are included.
//  (Now objects which inherit from TH1 or TCanvas are displayed.)
//  Canvas Window Resize is 1, not 0.844 any more.
// Version 1.53 2000 3/21 Koji Ikado
//  "Choose File" button & "Clear" button are added.
// Version 1.55 2000 3/24 T.A
//  Added a button to zero histograms.
//  Currently the no of entries are cleared but not other staticsics
//  as mean or rms. Waiting new version of ROOT in CDF. (v2.23.*)
//  Also the codes of drawing are improved.
// Version 1.56 2000 3/25 T.A
//  Added a button to draw a bin-content histogram of a selected histogram. 
//  Requested by LBNL, ANL (Young-Kee Kim, Larry Noodleman, Greg Veramendi). 
//  Control buttons work much better with abling and disabling.
// Version 1.561 2000 4/01 T.A
//  Some TCanvas were not be drawn such as from YMon.cc.
// (ROOT v2.22.06. KCC_3_3. ). Now fixed.
// Version 1.57 2000 4/19 Koji Ikado
//  Functions of help windows from menu bar are modified.
//  Some "WARNING" message windows are added.
// Version 1.58 2000 4/19 T.A
//  Removing automatical resizing and clearing of canvas settings.
//  Allowing to set additional delay time (msec) for  automatical update.
// Version 1.581 2000 4/28 T.A
//  Histogram control buttons (zero, unzero, content) are separated.
// Version 1.582 2000 5/12 T.A & K.I
//  Layout is changed. Debugged for displaying canvas. 
//  Status bar is added(K.I).
// Version 1.583 2000 6/01 T.A
//  Debugged status bar implimentation errors and modified.
//  Errors at closing file with the stop or exit button are fixed.
//  Quit clone of TH1. Delete TList. BinContentHisto modified.
// Version 1.584 2000 6/05 H.S
//  modified socket connection part to work with the new server
// Version 1.59 2000 6/02 T.A
//  Changed so that everything on a canvas is updated automatically.
//  But the only one input source is allowed now.
//  Statistics of subtracted hists are modified
//  for newer version than ROOT v2.23.12.
// Version 1.60 2000 6/8 T.A
//  Changed UpdateHistoList.
// Version 1.61 2000 6/9 T.A
// Version 1.62 2000 6/16 T.A
//  CObject, CHistogram class is added.
// Version 1.63 2000 8/03 T.A
//  Debugged. But if you open hsimple.map after SVXMon.root
//  segmentation fault occurs. If inverse the order, no error.
// Version 1.64 2000 8/25 T.A
//  Debugged. Canvas Update works fine. Draw option is taken from input.
//  Tries several times if it failed to receive an object from a socket.
//  Button to clear currently active pad is added.
// Version 1.641 2000 8/28 T.A
//  Minor change for removing unnecessary Clear().
// Version 1.642 2000 9/1 T.A
//  With updated CHistogram and CObject. Better memory management.
// Version 1.643 2000 9/5 T.A
//  Recursive pad clear is added for memory leak till the ROOT
//  is updated. 
// Version 1.644 2000 9/6 T.A
//  Fixed to draw after reconnection. Current pad is stored.
// Version 1.645 2000 9/9 T.A
//  Recursive pad clear is debugged. Current pad update is modified.
// Version 1.65 2000 9/9 T.A, Wolfgang and Hartmut,  
//  As suggested by Philip Canal, modified
//  error handling of socket connection,
//  update method of histogram maintaining changes by users on canvas.   
// Version 1.651 2000 9/15 T.A
//  Pad update restoring changing by users on canvas.
//  More attributes of pad or canvas are copied from the original 
//  input.
// Version 1.652 2000 9/21 T.A
//  Debugged so that histo in pad from static file can be drawn normally.
//  DrawHisto is divided for TList and TObject draw.
//  Double click on List Tree draws an object. 
//  ContentHisto is drawn for histo in selected pad.
// Version 1.653 2000 9/24 T.A
//  Testing to avoid segmentation fault that occurs 
//  when canvas is clicked while painting. (Igor pointed out.)
// Version 1.66 2000 9/29 T.A
//  TConsumerInfo is read from input and ListTree is made based on it.
//  Layout changes of main frame after its' resize look better now.
//  ( Fixed according to suggestion by Igor. )
// Version 1.661 2000 10/02 T.A
//  TConsumerInfo can be read from text file "ConsumerInfo.txt"
//  so that users can control what to be read from the inputs.
//  Buttons Start and Open are not disabled.
//  After the input connection closed, "Open" and "Start" able to update histos.
//  More precautions for cases where gPad !=0 with no opened canvases.
// Version 1.7 2000 10/06
//  Slide Show canvas is implemented.
//  CDF Consumer Display Canvas names and titles are changed with numbers.
// Version 1.71 2000 10/06
//  Debugging so that others than TH1 or TPad can be updated.
//  Socket becomes the default, not TFile for input.
// Version 1.72 2000 10/08
//  ListTree Item shows tips or a title of the object when mouse is on it.
//  ( For above ROOT v2.25/03 )
// Version 1.8 2000 10/13
//  Timer is added.
// Version 1.81 2000 10/13
//  Print function is being added. 
// Version 1.82 2000 10/27
//  Canvas name and title (which is dispayed on the top of the GUI canvas)
//  are dynamically changed according to the objects on the display.
// Version 1.83 2000 10/28
//  GUI Canvas is resized when a consumer canvas is displayed
//  duplicating its size. ( deactivated 2000/11/3. )
//  Quit to draw additional pad to draw consumer objects on it.
// Version 1.831 2000 11/3
//  Histogram axis labels are redrawn by update
//  because axis labels may be changed.
//  ( Some consumer put run no and no of events on the x axis label.)
// Version 1.832 2000/12/08
//  For ROOT 2.26.00 and for EGCS
// Version 1.84 2001/01/19
//  Popup a current canvas for slide show.
//  Cleaned up code for slide update.
// Version 1.85 2001/01/31
//  Slide show on one window.
// Version 1.852 2001/02/09
//  Slide show with timer update.
//  Slide shows resume on a canvas where the slide show was shown,
//  not on a current active canvas.
//  Actions of Pause and Update buttons are rearranged.
//  Cleared the use of varible Running:
//  Running = kTRUE means some timer is running.
//  By inserting Running = kFALSE, you can interrupped all timers.
//  Change default and min frequencies to 5sec and 800msec. (Wolfgang requests)
//  Included ServerProtocol.hh.
// Version 1.853 2001/02/11
//  Changed the Update Timer.
//  A pad where update timer started is continued to be updated
//  even after current active pad are changed.
// Version 1.854 2001/02/20
//  Debugged error which occured when you start slide show without a canvas
//  window. 
// Version 1.855 2001/02/22
//  Debugged that drawing option of objects in consumer canvases are
//  reproduced when they are displayed. Especially overlaid histos
//  are shown properly.
// Version 1.86 2001/03/08
//  ListTree updates. Redraw ListTree with new TConsumerInfo.
// Version 1.87 2001/03/12
//  Removing buttons. start, exit.
// Version 1.88 2001/03/26
//  Objects are not fetched from inputobj ( e.g. socket )
//  when open button is clicked
//  because it consumes long time.
//  Reading object is done each time when you tried to 
//  draw a List Tree item one by one.
//  Refresh is added to the List Tree menu item.
// Version 1.9 2001/03/28
//  PopUp warning/error slide show starts when new TConsumerInfo
//  that contains warning or error folder.
//  Debugged so that you can reconnect to the same socket
//  by pushing "open" button.
// Version 1.91 2001/04/06
//  Debugged so that canvases are drawn without bad X11 window allocation.
//---------------------------------------------------------------------
// the following lines are a work around for a "known" bug in the IRIX6_2
// unistd.h header file
#include <sys/types.h>
#if defined( OSF1 )
#include <unistd.h>
#else
#include <sys/unistd.h>
#endif
//
// IRIXX 6.2 bug fix 
//
#if defined( IRIX6_2 )
#if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE_EXTENDED==1)
     static pid_t vfork (void);
#define __vfork vfork
#endif   
#endif
// end of work around 
//---------------------------------------------------------------------
extern "C" {
#include <unistd.h>
}

#ifdef ROOT_2_22
#include "TGXW.h"
#define gVirtualX gGXW
#else
#include "TVirtualX.h"
#endif

#include <TROOT.h> //gROOT 
#include <TStyle.h> //gStyle
#include <TApplication.h>
#include <TGClient.h>

#include <TString.h>
#include <TRegexp.h>

#include <TGMenu.h>

//#include <TGToolBar.h> //TGHorizontal3DLine
#ifndef ROOT_2_24
#include <TG3DLine.h> //TGHorizontal3DLine //2000/12/08 v2.26
#else
#include <TGSplitter.h> //TGHorizontal3DLine //2000/12/04 v2.25.03
#endif

#include <TRootHelpDialog.h> 
#include <HelpText.h> //gHelpAbout, gHelpCanvas
#include <TGTextView.h>

#include <TGLabel.h>
#include <TGTextEntry.h> //GContext_t
#include <TGLayout.h> //TGLayoutHints
#include <TGButton.h> //TGPictureButton, TGCheckButton

#include <TFile.h>
class TMapRec;
// needed by KCC 4.0 to correct problem in root v2_24_04c: 
// (Thanks Chris.)
class TGStatusBarPart; 
#include <TMapFile.h> //TMapFile, TMapRec

#include <TList.h>

#include <TCollection.h> // TIter
#include <TKey.h>
#include <TObject.h>
#include <TH1.h>
#include <TClass.h> // TH1F;;Class()

#include <TGListTree.h>

#include <TGWindow.h>
#include <TGCanvas.h>
#include <TCanvas.h>
#include <TTimer.h>
#include <TSystem.h> // TProcessEventTimer
#include <TVirtualPad.h> //gPad

#include <TGFileDialog.h> //TGFileInfo
#include <TGMsgBox.h>

#include <TGFrame.h>
#include <TGStatusBar.h>


#include <string.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <cstring>

#include <TUrl.h>

#include <TFrame.h>

#include <TTimer.h>
#include <TGTextEditDialogs.h> // TGPrintDialog
//#include <Consumer/TGTextEditDialogs.hh> // TGPrintDialog


#include <fstream>
#include <ctype.h>

//#include "Consumer/HistoDisplay.hh"
#include "HistoDisplay.h"
//#include "ConsumerFramework/HistoDisplay.hh"
#include "HistoDisplay.h"
//#include "Consumer/HistoDisplayHelpText.hh" //gHelpHistoDisplay
#include "HistoDisplayHelpText.h" //gHelpHistoDisplay
//#include "Consumer/HistoDisplayPhoto.hh"
#include "HistoDisplayPhoto.h"
//#include "Consumer/ConsumerList.hh"
#include "ConsumerList.h"

#include <TSocket.h>
#include <TMessage.h>
#include <strstream>
//#include "Consumer/TConsumerInfo.hh"
#include "TConsumerInfo.h"

//#include "Consumer/CObject.hh"
#include "CObject.h"
//#include "Consumer/CHistogram.hh"
#include "CHistogram.h"

//using std::string;
#include "ServerProtocol.h"

using std::cout;
using std::endl;
using std::ends;

using std::cerr;
using std::ostrstream;
using std::max;

enum HistoDisplayMessageTypes {
  kM_MENU_FILE_NEWGUI,
  kM_MENU_FILE_NEWCANVAS,
  kM_MENU_FILE_NEWSLIDE,
  kM_MENU_FILE_CLOSE,
  kM_MENU_FILE_EXIT,
  kM_MENU_LISTTREE_SORTTREE,
  kM_MENU_LISTTREE_SORTFOLDER,
  kM_MENU_LISTTREE_DELETE,
  kM_MENU_LISTTREE_CLEAR,
  kM_MENU_LISTTREE_REFRESH,
  /*
  kM_MENU_CONNECT_MON1,
  kM_MENU_CONNECT_MON2,
  kM_MENU_CONNECT_MON3,
  kM_MENU_CONNECT_MON4,
  kM_MENU_CONNECT_MON5,
  */
  kM_MENU_CONNECT_STATUS,
  kM_MENU_HELP_GUI,
  kM_MENU_HELP_ROOT,
  kM_MENU_HELP_CANVAS,
  kM_PICTBUTTON,
  kM_RABUTTON_MFILE,
  kM_RABUTTON_RFILE,
  kM_RABUTTON_SOCKET,
  kM_BUTTON_FILENAME,
  kM_BUTTON_CHOOSEFILE,
  kM_BUTTON_CLEARFILENAME,
  //kM_BUTTON_START,
  kM_BUTTON_PAUSE,
  kM_BUTTON_CLEAR,
  kM_BUTTON_PRINT,
  kM_BUTTON_RESTART,
  kM_BUTTON_ZERO,
  kM_BUTTON_UNZERO,
  kM_BUTTON_CONTENT,
  kM_BUTTON_STOP,
  kM_BUTTON_CANVAS,
  //kM_BUTTON_EXIT,
  kM_CHBUTTON_AUTOUPDATE,
  kM_CHBUTTON_SLIDEUPDATE,
  kM_TEXTENTRY_FILENAME,
  kM_TEXTENTRY_MONITORNAME,
  kM_TEXTENTRY_FREQUENCY
};


/*
enum EInputTypes {
  kTMapFile,
  kTFile,
  kTSocket
};
*/


// slide show starts when following names are included in 
// TGListTreeItem name.
const char *kSlideShowFolder = "slide";

const char *kWarningFolder = "warning";
const char *kErrorFolder = "error";
const char *kWarningErrorCanvasName = "WarningErrorCanvas";
const char *kWarningErrorCanvasTitle = "Warning/Error Canvas";


ClassImp(HistoDisplay)
  //ClassImp(HistoDisplayUpdateTimer)



HistoDisplay::HistoDisplay( const TGWindow *p, UInt_t w, UInt_t h,
                            const char *socketserver, Int_t port)
: TGMainFrame(p, w, h)
, consumerlist(new ConsumerList("http://www-b0.fnal.gov:8000/consumer/consumer_status.html"))
{
  //
  // hjw
  // first check if the enevironment is set correctly:
  //
  char *c_ptr;
  c_ptr = getenv("CONSUMER_ICONS");
    if(c_ptr==NULL){
      cout<<"Unix logical CONSUMER_ICONS is not set, will not be able to load all icons"<<endl;
    }

    gStyle->SetPalette(1); //By Greg.

  gClient->GetColorByName("LightYellow",LightYellow);
  gClient->GetColorByName("Red",Red);
  gClient->GetColorByName("Green",Green);






  fsocketserver=socketserver;
  fport=port;


  MakeMenuBar();

  fMainFrame =
    new TGCompositeFrame(this, 200, 400, kVerticalFrame); 

  fMainFrameLayout =
    //new TGLayoutHints( kLHintsCenterX | kLHintsCenterY, 1, 1, 1, 1); 
    new TGLayoutHints( kLHintsCenterX | kLHintsCenterY |
                       kLHintsExpandX | kLHintsExpandY, 1, 1, 1, 1); 

  char fTitle[] = "MINOS Online Monitoring Display ";
  MakeTitleFrame(fTitle);

  MakeInputFrame();

  MakeTGListTreeFrame();

  MakeStatusBar();

  AddFrame(fMainFrame,fMainFrameLayout); 

  SetWindowName(" MINOS Online Monitoring Main Frame");
  Resize(GetDefaultSize());
  Layout();

  MapSubwindows();
  MapWindow();


  fSelectedItem = 0; // to prevent segmentation fault
  //InputObj = 0;

  fHistoList = new TList();
  fDisplayedList = new TList();
  //fDisplayedList = new CList();


  SlideShowUpdate = kFALSE;
  fSlideCanvasList = new TList();

  CanvasName = "MINOSDisplayCanvas"; 
  CanvasTitle = "MINOS Online Monitoring Display Canvas ";
  CanvasNumber = 0;


  //fUpdateTimer = new TTimer( this, 100, kTRUE );
  fUpdateTimer = new HistoDisplayUpdateTimer( this, 100, kTRUE );
  fSlideTimer = new HistoDisplaySlideTimer( this, 2000, kTRUE );

  Running = kFALSE;

  fPrinter = 0;
  fPrinterCommand = 0;


}


void HistoDisplay::MakeMenuBar()
{
  // File Menu --
  fFileMenu = new TGPopupMenu( fClient->GetRoot() );
  fNewCascadeMenu = new TGPopupMenu( fClient->GetRoot() );
  fNewCascadeMenu->AddEntry( "&GUI", kM_MENU_FILE_NEWGUI );
  fNewCascadeMenu->AddEntry( "&Canvas", kM_MENU_FILE_NEWCANVAS );
  //fNewCascadeMenu->AddEntry( "&Slide Show Canvas", kM_MENU_FILE_NEWSLIDE );
  fNewCascadeMenu->AddEntry( "&Auto-Update Canvas", kM_MENU_FILE_NEWSLIDE );
  fFileMenu->AddPopup( "&New", fNewCascadeMenu );
  fFileMenu->AddSeparator();
  fFileMenu->AddEntry( "&Close", kM_MENU_FILE_CLOSE );
  fFileMenu->AddEntry( "&Exit", kM_MENU_FILE_EXIT );
  //--

  // List Tree --
  fListTreeMenu = new TGPopupMenu( fClient->GetRoot() );
  fSortCascadeMenu = new TGPopupMenu( fClient->GetRoot() );
  fSortCascadeMenu->AddEntry( "&Tree", kM_MENU_LISTTREE_SORTTREE );
  fSortCascadeMenu->AddEntry( "In &Folder", kM_MENU_LISTTREE_SORTFOLDER );
  fListTreeMenu->AddPopup( "&Sort", fSortCascadeMenu );
  fListTreeMenu->AddSeparator();
  fListTreeMenu->AddEntry( "&Delete", kM_MENU_LISTTREE_DELETE );
  fListTreeMenu->AddEntry( "&Clear", kM_MENU_LISTTREE_CLEAR );
  fListTreeMenu->AddEntry( "&Refresh", kM_MENU_LISTTREE_REFRESH );
  //--

  // Connection Menu --
  fConnectMenu = new TGPopupMenu( fClient->GetRoot() );
  fConnectMenu->AddLabel( "CDF Monitors");
  fConnectMenu->AddSeparator();
  /*
  fConnectMenu->AddEntry( "&YMON", kM_MENU_CONNECT_MON1 );
  fConnectMenu->AddEntry( "&TRIGMON", kM_MENU_CONNECT_MON2 );
  fConnectMenu->AddEntry( "&LUMMON", kM_MENU_CONNECT_MON3 );
  fConnectMenu->AddEntry( "&PHYSMON", kM_MENU_CONNECT_MON4 );
  fConnectMenu->AddEntry( "&SPY", kM_MENU_CONNECT_MON5 );
  */
  fConnectMenu->AddSeparator();
  fConnectMenu->AddEntry( "&Status", kM_MENU_CONNECT_STATUS );
  //--

  // Help Menu --
  fHelpMenu = new TGPopupMenu( fClient->GetRoot() );
  fHelpMenu->AddEntry( "&About This GUI", kM_MENU_HELP_GUI );
  fHelpMenu->AddSeparator();
  fHelpMenu->AddEntry( "&About ROOT", kM_MENU_HELP_ROOT );
  fHelpMenu->AddEntry( "&About Canvas", kM_MENU_HELP_CANVAS );
  //--

  // Associate Menu Commands --
  fFileMenu->Associate(this);
  fNewCascadeMenu->Associate(this);
  fListTreeMenu->Associate(this);
  fSortCascadeMenu->Associate(this);
  fConnectMenu->Associate(this);
  fHelpMenu->Associate(this);
  //--

  // Create Menu Bar --
  fMenuBar = new TGMenuBar( this, 1, 1, kHorizontalFrame );
  fMenuBarLayout = 
    new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandX,
                       0, 0, 1, 1);
  fMenuBarItemLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft, 0, 4, 0, 0 );
  fMenuBarHelpLayout =
    new TGLayoutHints( kLHintsTop | kLHintsRight );

  fMenuBar->AddPopup( "&File", fFileMenu, fMenuBarItemLayout );
  fMenuBar->AddPopup( "&List Tree", fListTreeMenu, fMenuBarItemLayout );
  fMenuBar->AddPopup( "&Connection", fConnectMenu, fMenuBarItemLayout );
  fMenuBar->AddPopup( "&Help", fHelpMenu, fMenuBarHelpLayout );

  AddFrame( fMenuBar, fMenuBarLayout );
  //--

  // Separator --
  fMenuBarSeparator = new TGHorizontal3DLine( this );
  fMenuBarSeparatorLayout =
    new TGLayoutHints( kLHintsTop | kLHintsExpandX );
  AddFrame( fMenuBarSeparator, fMenuBarSeparatorLayout );
  //--
}


void HistoDisplay::CloseMenuBar()
{
  delete fNewCascadeMenu;
  delete fFileMenu;
  delete fSortCascadeMenu;
  delete fListTreeMenu;
  delete fConnectMenu;
  delete fHelpMenu;
  delete fMenuBarItemLayout;
  delete fMenuBarHelpLayout;
  delete fMenuBar;
  delete fMenuBarLayout;

  delete fMenuBarSeparator;
  delete fMenuBarSeparatorLayout;
  delete consumerlist;
}



void HistoDisplay::MakeTitleFrame(const char *fTitle)
{
   // Title Frame with logo picture --

   fTitleFrame = new TGCompositeFrame(fMainFrame,200,40,kHorizontalFrame);
   fTitleFrameLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX,
                                         0, 0, 0, 0);
   FontStruct_t labelfont;
   labelfont = gClient->GetFontByName(
              "-*-times-bold-r-*-*-24-*-*-*-*-*-*-*");
   GCValues_t   gval;
   gval.fMask = kGCForeground | kGCFont;
   gval.fFont = gVirtualX->GetFontHandle(labelfont);
   gClient->GetColorByName("red", gval.fForeground);
   fTextGC = gVirtualX->CreateGC(gClient->GetRoot()->GetId(), &gval);

   fTitleLabel       = new TGLabel(fTitleFrame, fTitle , fTextGC, labelfont);
   fTitleLabelLayout = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 40, 10, 20, 20);
   fTitleFrame->AddFrame(fTitleLabel, fTitleLabelLayout);

   fPicBut = 
     new TGPictureButton( fTitleFrame,
                          gClient-> GetPicture("${CONSUMER_ICONS}/minos.xpm"),
                          kM_PICTBUTTON);
   fPictLayout = new TGLayoutHints(kLHintsTop | kLHintsRight
                                   //,0,0,0,0);
                                   ,0,4,4,0);
   fPicBut->Associate(this);
   fTitleFrame->AddFrame(fPicBut, fPictLayout);

   fMainFrame->
     AddFrame(fTitleFrame,fTitleFrameLayout);
   //--
}


void HistoDisplay::CloseTitleFrame()
{
  gVirtualX->DeleteGC(fTextGC);
  delete fTitleLabel;
  delete fTitleLabelLayout;
  delete fPicBut;
  delete fPictLayout;
  delete fTitleFrame;
  delete fTitleFrameLayout;
}



void HistoDisplay::MakeInputFrame()
{
  // Input stream Frame --

  fFileNameFrame =
    //new TGGroupFrame(fMainFrame, "Input Stream", kVerticalFrame);
    new TGGroupFrame(fMainFrame, "Add Input Stream", kVerticalFrame);
  fFileNameFrameLayout =
    //new TGLayoutHints( kLHintsTop | kLHintsLeft, 2, 2, 2, 2);
    new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandX
                       , 4, 4, 2, 2);

  // Radio Buttons --
  fRaButMFile =
    new TGRadioButton(fFileNameFrame,
                       "Memory Map File", kM_RABUTTON_MFILE);
  fRaButRFile =
    new TGRadioButton(fFileNameFrame, 
                       "Other ROOT File", kM_RABUTTON_RFILE);
  fRaButSocket =
    new TGRadioButton(fFileNameFrame,
                       "Socket Connection", kM_RABUTTON_SOCKET);
  fRaButLayout =
    new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,2,2);

  fRaButMFile->Associate(this);
  fRaButRFile->Associate(this);
  fRaButSocket->Associate(this);

  fFileNameFrame->AddFrame(fRaButMFile, fRaButLayout);
  fFileNameFrame->AddFrame(fRaButRFile, fRaButLayout);
  fFileNameFrame->AddFrame(fRaButSocket, fRaButLayout);

  fRaButMFile->SetState(kButtonUp);
  //fRaButRFile->SetState(kButtonDown);
  fRaButRFile->SetState(kButtonUp);
  //fRaButSocket->SetState(kButtonUp);
  fRaButSocket->SetState(kButtonDown);

  /*
  RaButMFileOn = kFALSE;
  RaButRFileOn = kTRUE;
  RaButSocketOn = kFALSE;

  MFileOpen = kFALSE;
  RFileOpen = kFALSE;
  sockOpen = kFALSE;
  */
  //InputOpen = kFALSE;
  //--


  // File Name --
  fFileNameLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft, 3,3,2,2);

  // Label --
  fFileNameLabel = 
    new TGLabel( fFileNameFrame, "Name of File / Socket Server:Port" );
  fFileNameFrame->
    AddFrame( fFileNameLabel, fFileNameLayout );

  //--

  // File Name Text Buffer --
  fFileOpenFrame =
    new TGCompositeFrame(fFileNameFrame, 60, 20, kHorizontalFrame);
  fFileOpenFrameLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft, 2,2,2,2);

  fFileNameTextEntry =
    new TGTextEntry( fFileOpenFrame, 
                     fFileNameBuffer = new TGTextBuffer(320),
                     kM_TEXTENTRY_FILENAME );
  char sstext[80];
 

  sprintf(sstext,"%s:%d",fsocketserver,fport);
 

  fFileNameBuffer->AddText(0,sstext);
  fFileNameTextEntry->
    Resize(340,fFileNameTextEntry->GetDefaultHeight());
  fFileOpenFrame->
    AddFrame( fFileNameTextEntry, fFileNameLayout );

  fReadFileButton =
    new TGTextButton(fFileOpenFrame,"Open", kM_BUTTON_FILENAME);
  fReadFileButton->Associate(this);

  fReadFileButton->SetToolTipText("Open local/remote file or socket.");

  //gClient->GetColorByName("LightYellow",LightYellow);
  fReadFileButton->ChangeBackground(Red);
  //  cout << "Button changed to red\n";
  fFileOpenFrame->
    AddFrame( fReadFileButton, fFileNameLayout );

  fFileNameFrame->
    AddFrame( fFileOpenFrame, fFileOpenFrameLayout );
  //--


  // Choose File, Clear buttons. --
  fFileNameButtonFrame =
    new TGCompositeFrame(fFileNameFrame, 60, 70, kHorizontalFrame);

  fFileNameButtonFrameLayout =
    //new TGLayoutHints( kLHintsTop | kLHintsLeft, 2,2,2,2);
    new TGLayoutHints( kLHintsTop | kLHintsLeft, 2,2,2,0);

  fFileNameButtonLayout =
    new TGLayoutHints( kLHintsLeft, 3,3,2,2);


  fChooseFileButton =
    new TGTextButton(fFileNameButtonFrame,"Choose File",
                     kM_BUTTON_CHOOSEFILE);
  fChooseFileButton->SetToolTipText("Choose Local file");

  fChooseFileButton->Associate(this);

  fFileNameButtonFrame->
    AddFrame( fChooseFileButton,
              //new TGLayoutHints(kLHintsTop | kLHintsCenterX, 3,5,2,2));
              new TGLayoutHints(kLHintsTop | kLHintsCenterX, 3,5,2,0));

  fChooseFileButton->ChangeBackground(LightYellow);


  fClearFileNameButton =
    new TGTextButton(fFileNameButtonFrame,"     Clear    ",
                     kM_BUTTON_CLEARFILENAME);

  fClearFileNameButton->SetToolTipText("Clear Input Source Name");

  fClearFileNameButton->Associate(this);

  fFileNameButtonFrame->
    AddFrame( fClearFileNameButton, 
              //new TGLayoutHints(kLHintsTop | kLHintsRight, 3,5,2,2));
              new TGLayoutHints(kLHintsTop | kLHintsRight, 3,5,2,0));

  fClearFileNameButton->ChangeBackground(LightYellow);


  fFileNameFrame->
    AddFrame( fFileNameButtonFrame, fFileNameButtonFrameLayout );
  //--



  fMainFrame->
    AddFrame( fFileNameFrame, fFileNameFrameLayout  );
  //--
}


void HistoDisplay::CloseInputFrame()
{
  delete fRaButMFile;
  delete fRaButRFile;
  delete fRaButSocket;
  delete fRaButLayout;

  delete fFileNameLabel; 
  delete fFileNameTextEntry;
  delete fReadFileButton;
  delete fFileOpenFrame;
  delete fFileOpenFrameLayout;

  delete   fChooseFileButton;
  delete   fClearFileNameButton;
  delete   fFileNameButtonFrame;
  delete   fFileNameButtonLayout;
  delete   fFileNameButtonFrameLayout;

  delete fFileNameLayout;
  delete fFileNameFrame;
  delete fFileNameFrameLayout;
}



void HistoDisplay::MakeTGListTreeFrame()
{
  fListTreeMainFrame =
    new TGCompositeFrame(fMainFrame,200,300,kVerticalFrame);
  fListTreeMainFrameLayout =
    //new TGLayoutHints( kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);
    new TGLayoutHints( kLHintsTop | kLHintsLeft |
                       kLHintsExpandX | kLHintsExpandY, 5, 5, 5, 5);


  // MonitorName --
  fMonitorNameLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft, 2,2,2,2);
  //new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandX,
  //           2, 200, 2, 2);

  fMonitorNameLabel =
    new TGLabel( fListTreeMainFrame,
                 // " Location in List Tree " );
         " Consumer Name in \"ConsumerInfo.txt\" ( Optional User Control )" );
  fListTreeMainFrame->
    AddFrame( fMonitorNameLabel, fMonitorNameLayout );

  fMonitorNameTextEntry = 
    new TGTextEntry( fListTreeMainFrame,
                     fMonitorNameBuffer = new TGTextBuffer(256),
                     kM_TEXTENTRY_MONITORNAME );
  fMonitorNameTextEntry->
    Resize(260, fMonitorNameTextEntry->GetDefaultHeight());

  fListTreeMainFrame->
    AddFrame( fMonitorNameTextEntry, fMonitorNameLayout );
  //--



  // Make List Tree Frame --

  fHistoListFrame =
    new TGCompositeFrame(fListTreeMainFrame, 220, 300, kHorizontalFrame);
  fHistoListFrameLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft |
                       kLHintsExpandX | kLHintsExpandY,
    //new TGLayoutHints( kLHintsTop | kLHintsCenterX,
                       1, 1, 1, 1); 


  // Make List Tree --
  fTGCanvas =
    new TGCanvas(fHistoListFrame, 210, 300, kSunkenFrame | kDoubleBorder);
  fTGCanvasLayout =
    //new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandY);
    new TGLayoutHints( kLHintsTop | kLHintsLeft |
                       kLHintsExpandX | kLHintsExpandY );
  // , 2, 2, 2, 2); 

  fHistoListTree = new TGListTree(fTGCanvas->GetViewPort()
                                  , 210, 300, kHorizontalFrame);
  fHistoListTree->Associate(this);
  fTGCanvas->SetContainer(fHistoListTree);

  //tmp 2000/12/08
  fHistoListTree->SetAutoTips();


  fHistoListFrame->AddFrame(fTGCanvas,fTGCanvasLayout);
  //--


  // Button Frame of List Tree --
  fListButtonFrame =
    new TGCompositeFrame(fHistoListFrame, 100, 300,
                         kVerticalFrame );
  fListButtonFrameLayout = 
    //    new TGLayoutHints(kLHintsRight | kLHintsCenterY, 10, 10, 10, 10);
    //new TGLayoutHints( kLHintsCenterY, 2, 2, 5, 5);
    new TGLayoutHints( kLHintsRight | kLHintsCenterY |
                       kLHintsExpandX , 2, 2, 5, 5);



  // AutoUpdate Check Button --
  fChButtonAutoUpdate = 
    new TGCheckButton(fListButtonFrame, "Update Automatically",
              kM_CHBUTTON_AUTOUPDATE);
  //fChButtonAutoUpdateLayout =
  //new TGLayoutHints( kLHintsTop | kLHintsCenterX,5,5,15,25);
  fChButtonAutoUpdateLayout =
    new TGLayoutHints( kLHintsTop | kLHintsLeft,5,2,2,2);
  fChButtonAutoUpdate->Associate(this);
  fListButtonFrame->
    AddFrame( fChButtonAutoUpdate, fChButtonAutoUpdateLayout );
  fChButtonAutoUpdate->SetState(kButtonDown);
  AutoUpdate = kTRUE;
  //--


  // Slide Show Check Button --
  fChButtonSlideUpdate = 
    //new TGCheckButton(fListButtonFrame, "Update Slide Show Canvases",
    new TGCheckButton(fListButtonFrame, "Update Multi Canvases",
              kM_CHBUTTON_SLIDEUPDATE);
  fChButtonSlideUpdate->Associate(this);
  fListButtonFrame->
    AddFrame( fChButtonSlideUpdate, fChButtonAutoUpdateLayout );
  fChButtonSlideUpdate->SetState(kButtonUp);
  SlideShowUpdate = kFALSE;
  //--


  // Update Frequency --
  fFrequencyFrame = 
    new TGCompositeFrame(fListButtonFrame, 100, 50,
                         kHorizontalFrame );
  fFrequencyFrameLayout = 
    //    new TGLayoutHints(kLHintsRight | kLHintsCenterY, 10, 10, 10, 10);
    new TGLayoutHints( kLHintsTop | kLHintsLeft );

  fFrequencyLabel =
    //new TGLabel( fListButtonFrame, "Update Delay (msec)" );
    new TGLabel( fFrequencyFrame, "Update Delay (msec)" );
  //fListButtonFrame->
  fFrequencyFrame->
    AddFrame( fFrequencyLabel, fChButtonAutoUpdateLayout);



  fFrequencyTextEntry =
    //new TGTextEntry( fListButtonFrame,
    new TGTextEntry( fFrequencyFrame,
                     fFrequencyTextBuffer = new TGTextBuffer(40),
                     kM_TEXTENTRY_FREQUENCY );
  //fFrequencyTextBuffer->AddText(0,  "0");
  fFrequencyTextBuffer->AddText(0,  "3000");

  fFrequencyTextEntry->
    Resize( 50, fFrequencyTextEntry->GetDefaultHeight() );

  //fListButtonFrame->
  fFrequencyFrame->
    AddFrame( fFrequencyTextEntry, fChButtonAutoUpdateLayout);

  fListButtonFrame->
    AddFrame(fFrequencyFrame, fFrequencyFrameLayout);

  //--


  // Control Buttons --

  fControlButtonFrame =
    new TGCompositeFrame( fListButtonFrame, 200, 300,
                          kHorizontalFrame );
  fControlButtonFrameLayout =
    new TGLayoutHints( kLHintsCenterX | kLHintsCenterY, 5,5,5,5);



  // List Tree Control Buttons --
  fButtonFrame =
    new TGCompositeFrame(fControlButtonFrame, 90, 300,
                         kVerticalFrame | kFixedWidth );
  fButtonFrameLayout = 
    new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 10, 10, 10, 10);

  fButtonLayout =
    new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX,
                      //5, 5, 5, 5);
                      5, 5, 2, 2);
  /*
  fStartHistoButton =
    new TGTextButton(fButtonFrame, "&Start", kM_BUTTON_START);
  fStartHistoButton->Associate(this);
  fStartHistoButton->SetToolTipText("Start Monitoring");
  */

  fRestartHistoButton =
    new TGTextButton(fButtonFrame, "&Update", kM_BUTTON_RESTART);
  fRestartHistoButton->Associate(this);
  fRestartHistoButton->SetToolTipText("Update Current Pad");

  fPauseHistoButton = 
    new TGTextButton(fButtonFrame, "&Pause", kM_BUTTON_PAUSE); 
  fPauseHistoButton->Associate(this);
  fPauseHistoButton->SetToolTipText("Pause Updating Current Pad");

  fClearHistoButton = 
    new TGTextButton(fButtonFrame, "&Clear", kM_BUTTON_CLEAR); 
  fClearHistoButton->Associate(this);
  fClearHistoButton->SetToolTipText("Clear Current Pad");

  fPrintHistoButton = 
    new TGTextButton(fButtonFrame, "&Print", kM_BUTTON_PRINT); 
  fPrintHistoButton->Associate(this);
  //fPrintHistoButton->SetToolTipText("Print Current Canvas");
  fPrintHistoButton->SetToolTipText("Print Current Pad");

  fStopHistoButton = 
    new TGTextButton(fButtonFrame, "&Reset", kM_BUTTON_STOP);
  fStopHistoButton->Associate(this);
  fStopHistoButton->SetToolTipText("Reset All");

  fNewCanvasButton = 
    new TGTextButton(fButtonFrame, "&New Canvas", kM_BUTTON_CANVAS);
  fNewCanvasButton->Associate(this);
  fNewCanvasButton->SetToolTipText("Draw new canvas");

  /*
  fExitButton =
    new TGTextButton(fButtonFrame, "&Exit", kM_BUTTON_EXIT); 
  fExitButton->Associate(this);
  fExitButton->SetToolTipText("Exit from this GUI");
  */

  //fButtonFrame->AddFrame(fStartHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fRestartHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fPauseHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fClearHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fPrintHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fStopHistoButton, fButtonLayout);
  fButtonFrame->AddFrame(fNewCanvasButton, fButtonLayout);
  //fButtonFrame->AddFrame(fExitButton, fButtonLayout);

  //tmp
  //fStartHistoButton->SetState(kButtonDisabled);
  fPauseHistoButton->SetState(kButtonDisabled);
  //fClearHistoButton->SetState(kButtonDisabled);
  //fPrintHistoButton->SetState(kButtonDisabled);
  //fRestartHistoButton->SetState(kButtonDisabled);
  //fStopHistoButton->SetState(kButtonDisabled);

  //Pausing = kFALSE;

  //gClient->GetColorByName("LightYellow",LightYellow);

  //fStartHistoButton->ChangeBackground(LightYellow);
  fPauseHistoButton->ChangeBackground(LightYellow);
  fClearHistoButton->ChangeBackground(LightYellow);
  fPrintHistoButton->ChangeBackground(LightYellow);
  fRestartHistoButton->ChangeBackground(LightYellow);
  fStopHistoButton->ChangeBackground(LightYellow);
  fNewCanvasButton->ChangeBackground(LightYellow);
  //fExitButton->ChangeBackground(LightYellow);


  fControlButtonFrame->
    AddFrame(fButtonFrame, fButtonFrameLayout);
  //--


  // Histogram Control Buttons --
  fHistoButtonGFrame
    = new TGGroupFrame(fControlButtonFrame, "Histogram",
                       kVerticalFrame );

  fHistoButtonGFrameLayout = 
    //    new TGLayoutHints(kLHintsCenterX | kLHintsCenterY, 2, 2, 2, 2);
    new TGLayoutHints(kLHintsRight | kLHintsCenterY, 10, 10, 10, 10);


  fHistoButtonFrame =
    new TGCompositeFrame(fHistoButtonGFrame, 50, 30,
                         kVerticalFrame | kFixedWidth );


  fHistoButtonFrameLayout = 
    //new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsExpandX,
    new TGLayoutHints(kLHintsRight | kLHintsCenterY); 
  //                 , 1, 1, 1, 1);

  fHistoButtonLayout =
    new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX,
                      1, 1, 5, 5);

  fZeroHistoButton = 
    new TGTextButton(fHistoButtonFrame, "&Zero", kM_BUTTON_ZERO);
  fZeroHistoButton->Associate(this);
  fZeroHistoButton->SetToolTipText("Reset selected Histograms");

  fUnZeroHistoButton = 
    new TGTextButton(fHistoButtonFrame, "&Restore", kM_BUTTON_UNZERO);
  fUnZeroHistoButton->Associate(this);
  fUnZeroHistoButton
    ->SetToolTipText("Back before reseting selected Histograms");


  fContentHistoButton = 
    new TGTextButton(fHistoButtonFrame, "&Content", kM_BUTTON_CONTENT);
  fContentHistoButton->Associate(this);
  fContentHistoButton
    ->SetToolTipText("Draw Bin-Content Histo of a Selected Item");


  fHistoButtonFrame->AddFrame(fZeroHistoButton, fHistoButtonLayout);
  fHistoButtonFrame->AddFrame(fUnZeroHistoButton, fHistoButtonLayout);
  fHistoButtonFrame->AddFrame(fContentHistoButton, fHistoButtonLayout);

  //fZeroHistoButton->SetState(kButtonDisabled);
  //fUnZeroHistoButton->SetState(kButtonDisabled);
  //fContentHistoButton->SetState(kButtonDisabled);

  fZeroHistoButton->ChangeBackground(LightYellow);
  fUnZeroHistoButton->ChangeBackground(LightYellow);
  fContentHistoButton->ChangeBackground(LightYellow);


  fHistoButtonGFrame->
    AddFrame(fHistoButtonFrame, fHistoButtonFrameLayout);

  fControlButtonFrame->
    AddFrame(fHistoButtonGFrame, fHistoButtonGFrameLayout);

  //--


  fListButtonFrame->
    AddFrame(fControlButtonFrame, fControlButtonFrameLayout);


  fHistoListFrame->
    AddFrame(fListButtonFrame, fListButtonFrameLayout);


  fListTreeMainFrame->
    AddFrame(fHistoListFrame,fHistoListFrameLayout);

  //--

  fMainFrame->
    AddFrame(fListTreeMainFrame,fListTreeMainFrameLayout);

  //--

}



void HistoDisplay::CloseTGListTreeFrame()
{
  delete fMonitorNameLayout;
  delete fMonitorNameLabel;
  delete fMonitorNameBuffer;
  delete fMonitorNameTextEntry;

  delete fHistoListTree;
  delete fTGCanvas;
  delete fTGCanvasLayout;

  delete fChButtonAutoUpdate;
  delete fChButtonSlideUpdate;
  delete fChButtonAutoUpdateLayout;


  delete fFrequencyLabel;
  delete fFrequencyTextBuffer;
  delete fFrequencyTextEntry;
  delete fFrequencyFrame;
  delete fFrequencyFrameLayout;

  //delete fStartHistoButton;
  delete fPauseHistoButton;
  delete fRestartHistoButton;
  delete fClearHistoButton;
  delete fPrintHistoButton;
  delete fStopHistoButton;
  //delete fExitButton;

  delete fButtonLayout;

  delete fButtonFrame;
  delete fButtonFrameLayout;



  delete fZeroHistoButton;
  delete fUnZeroHistoButton;
  delete fContentHistoButton;

  delete fHistoButtonLayout;

  delete fHistoButtonFrame;
  delete fHistoButtonFrameLayout;
  delete fHistoButtonGFrame;
  delete fHistoButtonGFrameLayout;


  delete fControlButtonFrame;
  delete fControlButtonFrameLayout;


  delete fListButtonFrame;
  delete fListButtonFrameLayout;

  delete fHistoListFrame;
  delete fHistoListFrameLayout;

  delete fListTreeMainFrame;
  delete fListTreeMainFrameLayout;
}

void HistoDisplay::MakeStatusBar()
{
  Int_t parts[] = {20, 80};
  fStatusBar = new TGStatusBar(fMainFrame, 50, 10, kHorizontalFrame);
  fStatusBar->SetParts(parts, 2);
  fMainFrame->AddFrame(fStatusBar, new TGLayoutHints(kLHintsBottom| kLHintsExpandX));
}

void HistoDisplay::CloseStatusBar()
{
  delete fStatusBar;
}





//TObject *HistoDisplay::OpenFile( const char *filename )
TObject *HistoDisplay::OpenFile( const char *filename,
                                 EInputTypes inputtype,
                                 Option_t *option )
{
  //cout << " In OpenFile " << endl;

  TObject *InputObj = 0;

  if ( inputtype == kTMapFile ) {
    TObject *obj =gROOT->GetListOfMappedFiles()->FindObject(filename) ;
    TMapFile *MFile = 0;
    if ( obj ) {
      MFile = (TMapFile*)obj;
    }
    else {
      //TMapFile::SetMapAddress(0x40c0000);
      MFile = TMapFile::Create(filename, option);
    }

    if ( MFile &&
         MFile->IsFolder() &&
         (MFile->IsA() == TMapFile::Class())  ) {
      //MFile->ls();
      //InputOpen = kTRUE;
      InputObj = MFile;
    }
    else {
      cout << " Error Opening " << filename << endl;
      if ( MFile ) MFile->Close();
      //InputOpen = kFALSE;
    }
  } //if ( inputtype == kTMapFile )

  else if ( inputtype == kTFile ) {
    TObject *obj = gROOT->GetListOfFiles()->FindObject(filename);
    TFile *RFile = 0;
    if ( obj ) {
      RFile = (TFile*)obj;
    }
    else {
      RFile = TFile::Open(filename, option);
    }
    if ( RFile &&
         RFile->IsOpen()  &&
         RFile->IsFolder() &&
         !(RFile->IsZombie()) &&
         (RFile->IsA() == TFile::Class()) &&
         (RFile->IsA() != TMapFile::Class())  ) {
      //RFile->ls();
      //InputOpen = kTRUE;
      InputObj = RFile;
    }
    else {
      cout << " Error Opening " << filename << endl;
      if ( RFile ) RFile->Close();
      //InputOpen = kFALSE;
    }
  } //else if ( inputtype == kTFile ) 


  else if ( inputtype == kTSocket ) {

    TSocket *sock = 0;
    //TObject *obj =gROOT->GetListOfSockets()->FindObject(filename);
    //if ( obj ) sock = (TSocket*)obj;
    //else {

    sock = (TSocket*)gROOT->GetListOfSockets()->FindObject(filename);
    //while ( sock && !sock->IsValid() ) {
    while ( sock ) {
      sock->Close();
      sock = (TSocket*)gROOT->GetListOfSockets()->FindObject(filename);
    }//while ( sock && !sock->IsValid() ) 

    if ( !sock ) {
      TUrl url(filename);
      sock = new TSocket(url.GetHost(),url.GetPort());
      //cout << " Socket Server Name = " << url.GetHost() << endl;
      //cout << " port = " << url.GetPort() << endl;
    } //if ( !sock ) 

    sock->SetName( filename );

    if ( sock && sock->IsValid() ) {
      cout << " Socket Server = " << filename << endl;
      //InputOpen = kTRUE;
      InputObj = sock;
    }
    else {
      cout << " Error Opening " << filename << endl;
      if ( sock ) sock->Close();
      //InputOpen = kFALSE;
    }
  } //else if ( inputtype == kTSocket ) {


  return InputObj;

}



TObject *HistoDisplay::CloseFile( const char *filename,
                                  EInputTypes inputtype )
{
  //cout << " In CloseFile " << endl;

  TObject *obj = 0;

  if ( inputtype == kTMapFile ) {

    while( ( obj = gROOT->GetListOfMappedFiles()->FindObject(filename) ) )
      ( (TMapFile*)obj )->Close();

  } //if ( inputtype == kTMapFile )
  else if ( inputtype == kTFile ) {

    while( ( obj = gROOT->GetListOfFiles()->FindObject(filename) ) )
      ( (TFile*)obj )->Close();

  } //else if ( inputtype == kTFile )
  else if ( inputtype == kTSocket ) {

    while( ( obj =gROOT->GetListOfSockets()->FindObject(filename) ) )
      ( (TSocket*)obj )->Close();

  } //else if ( inputtype == kTSocket ) 
 
  return obj;

}

TObject *HistoDisplay::CloseFile( TObject *obj )
{
  //cout << " In CloseFile ( obj )" << endl;

  if ( obj ) { 

    if ( obj->InheritsFrom( TMapFile::Class() ) ) 
      ( (TMapFile*)obj )->Close();

    else if ( obj->InheritsFrom( TMapFile::Class() ) ) 
      ( (TFile*)obj )->Close();

    else if ( obj->InheritsFrom( TSocket::Class() ) ) 
      ( (TSocket*)obj )->Close();
 
  } //if ( obj ) 

  return obj;

}


void HistoDisplay::CloseConnection() 
{

  //if (MFileOpen) {
  if ( gROOT->GetListOfMappedFiles() ) {
    //delete MFile;
    //gROOT->GetListOfMappedFiles()->Delete();
    // To avoid Error in <TMapFile::Close>: 
    //  shadow map == 0, should never happen!
    TIter next( gROOT->GetListOfMappedFiles() );
    TMapFile* mfile = 0; 
    while ( ( mfile = (TMapFile*)next() ) ) {
      mfile->Close();
      //gROOT->GetListOfMappedFiles()->Remove(mfile);
      // is called by close
    }
    //MFile = 0;
    //MFileOpen = kFALSE;
  }

  //if (RFileOpen) {
  if ( gROOT->GetListOfFiles() ) {
    //delete RFile;
    //gROOT->GetListOfFiles()->Delete();
    TIter next( gROOT->GetListOfFiles() );
    TFile* file = 0; 
    while ( ( file = (TFile*)next() ) ) {
      file->Close();
      //gROOT->GetListOfFiles()->Remove(file);
      // is called by close
    }
    //RFile = 0;
    //RFileOpen = kFALSE;
  }

  //if (sockOpen) {

  if ( gROOT->GetListOfSockets() ) {
    //gROOT->GetListOfSockets()->Delete();
    gROOT->GetListOfSockets()->ls();
    TIter next( gROOT->GetListOfSockets() );
    TSocket* socktmp = 0;
    while ( ( socktmp = (TSocket*)next() ) ) {
      //socktmp->Send("END CONNECTION");
      socktmp->Send( DspEndConnection.c_str() );
      socktmp->Close();
      //gROOT->GetListOfFiles()->Remove(socktmp);
      // is called by close
    }
    //sockOpen = kFALSE;
  }

  //InputOpen = kFALSE;

}



/*
//void HistoDisplay::HistoDisplayMain( TObject *inputobj )
//void HistoDisplay::HistoDisplayMain()
void HistoDisplay::HistoDisplayMain( Int_t autoOpen )
{
  //cout << " In HistoDisplayMain" << endl;

  TObject *inputobj = InputObj;

  TPad *padsav = 0;

  if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) )
    padsav = (TPad*) gPad;

  TConsumerInfo *info = 0;

  info = MakeConsumerInfo( MonitorName.Data(), "ConsumerInfo.txt" );

  //if ( info ) {
  if ( info && autoOpen ) {

    const char *filename = 0;
    EInputTypes inputtype;
    const char *inputname = ( info->getInputName() ).Data();

    if ( strstr( inputname, "TMapFile:" ) ) {
      filename = inputname + strlen( "TMapFile:" );
      inputtype = kTMapFile;
    } //if ( strstr( info->getInputName(), "TMapFile:" ) ) 
    else if ( strstr( inputname, "TFile:" ) ) {
      filename = inputname + strlen( "TFile:" );
      inputtype = kTFile;
    } //else if ( strstr( info->getInputName(), "TFile:" ) ) 
    else if ( strstr( inputname, "TSocket:" ) ) {
      filename = inputname + strlen( "TSocket:" );
      inputtype = kTSocket;
    } //if ( strstr( info->getInputName(), "TSocket:" ) ) 
    else
      cout << " No Consumer " << inputname 
           << " in ConsumerInfo.txt." << endl;

    if ( filename ) {
      inputobj = OpenFile( filename, inputtype, "READE" );
      InputObj = inputobj;
    }

  } //if( info && autoOpen )





  //DelTreeItemsOfInput( inputobj );
  AddTreeItemsOfInput( inputobj );
  RefreshTreeItem( fHistoListTree->GetFirstItem() );
  fClient->NeedRedraw( fHistoListTree );

  if ( padsav ) padsav->cd();


}
*/


TConsumerInfo* HistoDisplay::MakeConsumerInfo( TObject *inputobj ) 
{
  //cout << " In Make ConsumerInfo( inputobj ) " << endl;

  if ( !inputobj ) return 0;

  TConsumerInfo *info = 0;
  TObject *obj = 0;

  /*
  if ( inputobj->InheritsFrom( TMapFile::Class() ) ) {
    TMapFile *file = (TMapFile*) inputobj;
    obj =  file->Get("ConsumerInfo");
  } //if ( inputobj->InheritsFrom( TMapFile::Class() )

  else if ( inputobj->InheritsFrom( TFile::Class() ) ) {
    TFile *file = (TFile*) inputobj;
    obj =  file->Get("ConsumerInfo");
  } //if ( inputobj->InheritsFrom( TFile::Class() ) 

  else if ( inputobj->InheritsFrom( TSocket::Class() ) ) {
    TSocket *sock = (TSocket*) inputobj;
    if ( sock->IsValid() ) {
      //request TConsumerInfo
      TMessage *mess;
      sock->Send("ConsumerInfo");
      sock->Recv(mess);
      if ( mess ) {
        if ( mess->What() == kMESS_OBJECT) {
          obj = mess->ReadObject(mess->GetClass());
        } //if ( mess->What() == kMESS_OBJECT)
        delete mess;
      } //if ( mess )
    } //if ( sock->IsValid() )
  } //else if ( inputobj->InheritsFrom( TSocket::Class() ) )

  if ( obj && obj->InheritsFrom( TConsumerInfo::Class() ) ) {
    info = (TConsumerInfo*)obj;
    //info->print();
  } //if ( obj && obj->InheritsFrom( TConsumerInfo::Class() ) )
  */


  obj = GetNewObj( "ConsumerInfo", inputobj );

  if ( obj && obj->InheritsFrom( TConsumerInfo::Class() ) ) {
    info = (TConsumerInfo*)obj;
    //info->print();
  } //if ( obj && obj->InheritsFrom( TConsumerInfo::Class() ) )



  return info;
}



TConsumerInfo* HistoDisplay::
MakeConsumerInfo( const char *TheConsumerName, const char *filename ) 
{
  //cout << " In Make ConsumerInfo( file ) " << endl;
  //cout << TheConsumerName << " " << filename << endl;

  //if ( !TheConsumerName || !filename ) return 0;
  if ( ( strlen( TheConsumerName ) == 0 ) || !filename ) return 0;

  TConsumerInfo *info = 0;

  const int maxsize = 256;
  ifstream infile( filename );

  if ( infile ) {

    do {
      char str[ maxsize ];
      infile.getline( str, maxsize - 1 );

      // ConsumerInfo --
      if ( char *pos = const_cast<char*>(strstr( str, "ConsumerInfo ")) ) {

        char *ConsumerName = 0;
        ConsumerName =  getword( pos + strlen( "ConsumerInfo " ) ); 

        if ( !strcmp( ConsumerName, TheConsumerName ) ) {

          //tmp
          //cout << " ConsumerName = " << ConsumerName << endl;

          info = new TConsumerInfo( "ConsumerInfo" );

          do {
            char str1[ maxsize ];
            infile.getline( str1, maxsize - 1 );
            // run: --
            if ( strstr( str1, "run:" ) ) {
              char *runstr = 0;
              runstr = getword( str1 + strlen( "run:" ) );

              int runnumber = 0;
              if ( runstr ) {
                runnumber = atoi( runstr );
                delete [] runstr;
              } //if ( runstr )

              //cout << " runnumber = " << runnumber << endl;
              info->setRunNumber( runnumber );

              if ( char *pos = const_cast<char*>(strstr( str1, "number of events:" )) ) {
                char *nevstr = 0;

                nevstr = getword( pos + strlen( "number of events:" ) );

                int eventnumber = 0;
                if ( nevstr ) {
                  eventnumber = atoi( nevstr );
                  delete [] nevstr;
                } //if ( nevstr )

                //cout << " eventnumber = " << eventnumber << endl;
                info->setNevents( eventnumber );


              } //if ( char *pos = strstr( str1, "number of events:" ) ) 

            }// if ( strstr( str1, "run:" ) )

            //--
            // TMapFile, TFile, TSocket -- 
            char *inputname = 0;

            if ( strstr( str1, "TMapFile:" ) ) {

              inputname = getword( str1 + strlen( "TMapFile:" ) ); 
              info->setInputName( TString( "TMapFile:" ) +
                                  TString( inputname ) );

            }// if ( strstr( str1, "TMapFile:" ) )
            else if  ( strstr( str1, "TFile:" ) ) {

              inputname = getword( str1 + strlen( "TFile:" ) ); 
              info->setInputName( TString( "TFile:" ) +
                                  TString( inputname ) );

            }// else if ( strstr( str1, "TFile:" ) )
            else if  ( strstr( str1, "TSocket:" ) ) {

              inputname = getword( str1 + strlen( "TSocket:" ) ); 
              info->setInputName( TString( "TSocket:" ) +
                                  TString( inputname ) );

            } //else if  ( strstr( str1, "TSocket:" ) ) 

            if ( inputname ) {

              //cout << " InputName = " << inputname << endl;
              //info->setInputName( TString( inputname ) );


              delete [] inputname;
            } //if ( inputname )

            //--
            // objects: --
            if ( strstr( str1, "objects:" ) ) {

              do {
                char str2[ maxsize ];
                infile.getline( str2, maxsize - 1 );

                if ( str2 && ( strlen( str2 ) > 0 ) 
                     && !strstr( str2, "ConsumerInfo" ) ) {

                  char *path = 0;
                  char *name = 0;

                  char *pathname = getword( str2 );

                  //if ( pathname && ( *pathname != commentchar ) ) {
                  if ( pathname ) {

                    char *begin = str2 + strlen( pathname ) + 1;

                    char *pos = 0;
                    while ( ( pos = const_cast<char*>(strchr( pathname, '\"' ) )) && 
                            ( strchr( pos + 1, '\"' ) ) ) {
                      char *tmp = 0;
                      tmp = const_cast<char*>(strdelete( pathname, "\"" ));
                      delete [] pathname;
                      pathname = strdelete( tmp, "\"" );
                      delete [] tmp;
                    } // while ( strchr( pathname, '\"') )


                    if ( char *pos = const_cast<char*>( strrchr( pathname, '/')) ) {
                      pos++;

                      name = new char[ strlen( pos ) + 1 ];
                      strcpy( name, pos );

                      char tmpchr = *pos;
                      *pos = '\0';

                      path = new char[ strlen( pathname ) + 1 ];
                      strcpy( path, pathname );

                      *pos = tmpchr;
        
                    } //if ( path = strrchr( pathname, '/') )
                    else {
                      path = new char;
                      *path = '\0'; // was: path="" < mem leak

                      name = new char[ strlen( pathname ) + 1 ];
                      strcpy( name, pathname );

                    } //else //if ( path = strrchr( pathname, '/') )


                    int status = 999;
                    char *statusstr = getword( begin );
                    if ( statusstr ) {
                      delete [] statusstr;
                      status = atoi( statusstr );
                    } //if ( statusstr )

                    /*
                    cout << " path = " << path 
                         << " name = " << name 
                         << " status = " << status << endl;
                    */
                    info->addObject( TString( name ), TString( path ), status );

                    if ( pathname ) {
                      delete [] pathname;
                      pathname = 0;
                    }
                    if ( path ) {
                      delete [] path;
                      path = 0;
                    }
                    if ( name ) {
                      delete [] name;
                      name = 0;
                    }


                  } //if ( pathname && ( *pathname != commentchar ) )
                } // if ( str2 && ( strlen( str2 ) > 0 ) )
                else break;

              } while( !infile.eof() ); //str2


              break;

            } //if ( strstr( str1, "objects:" ) )

            //--


          } while ( !infile.eof() ); //str1


          if ( ConsumerName ) delete [] ConsumerName;
          break;

        }//if ( !strcmp( ConsumerName, TheConsumerName ) )

      } //if ( strstr( str, "ConsumerInfo") ) 


    } while ( !infile.eof() ); //str

    infile.close();

    if ( !info ) cout << " No info of " << TheConsumerName 
                      << " in " << filename << endl;

  } //if ( infile )
  else
    cout << " Failed to open file " << filename << endl;

  return info;

}




char *getword( char *str , const char commentchar )
{
  //cout << " In getword " << endl;

  char *word = 0;

  if ( str && ( strlen( str ) > 0 ) ) {
    char *begin = str;
    while( isspace( *begin ) && ( *begin != '\0' ) ) begin++;

    //if ( *begin != '\0' ) {
    if ( ( *begin != '\0' ) &&
         ( *begin != commentchar ) ) {

      char *end = begin;

      //while( !isspace( *end ) ) end++;

      while( !isspace( *end ) ) {
        char *tmp = 0;
        if ( ( *end == '\"' ) && 
             ( tmp = const_cast<char*>(strchr( end + 1 , '\"' )) )  ) end = tmp;
        else end++;
      }

      char tmpchr = *end;
      *end = '\0';
 
      word = new char[ strlen( begin ) + 1 ];
      strcpy( word , begin );

      *end = tmpchr;

    } //if ( *begin != '\0' )

  } // if ( str && ( strlen( str ) > 0 ) )

  return word;

}


char *strdelete( char *str, const char *del )
{
  //cout << " In strdelete " << endl;

  char *newword = 0;

  char *pos = 0;
  if ( ( pos = const_cast<char*>(strstr( str, del )) ) ) {
    newword = new char[ strlen( str ) - strlen( del ) + 1 ];
    if ( newword ) {
      char tmp = *pos;
      *pos = '\0';

      strcpy( newword, str );

      *pos = tmp;

      strcat( newword, pos + strlen( del ) );

    }//if ( newword )
  } //if ( pos = strstr( str, del ) )

  return newword;

}



char* strstrn( const char *s, const char *k ) 
{
  const char *pk = k;
  const char *ps = 0;

  while ( *s != '\0' ) {
    if ( tolower( *s ) == tolower( *pk ) ) {
      if ( pk == k ) ps = s;
      pk++;
      if ( *pk == '\0' ) break;
    } //if ( tolower( *ps ) == tolower( *pk ) )
    else {
      pk = k;
      ps = 0;
    } //else //if ( tolower( *ps ) == tolower( *pk ) )
    s++;
  } //while ( *s != '\0' ) 

  return  (char*) ps;

}





void HistoDisplay::MakeHistoList( TObject *inputobj )
{
  //cout << " In MakeHistoList " << endl;

  if ( ! inputobj ) return ;

  if ( fHistoList && !( fHistoList->IsEmpty( )) ) fHistoList->Clear();

  if ( inputobj->IsA() == TMapFile::Class() ) {
    MakeHistoListM( (TMapFile*) inputobj );
  }
  else if ( inputobj->IsA() == TFile::Class() ) {
    MakeHistoListR( (TFile*) inputobj );
  }
  else if ( inputobj->IsA() == TSocket::Class() ) {
    MakeHistoListS( (TSocket*) inputobj );
  }

}

void HistoDisplay::MakeHistoListM( TMapFile *MFile )
{
  if ( ! MFile ) return ;

  TMapRec *mr = MFile->GetFirst();
  while( MFile->OrgAddress(mr) ) {
    TString name = mr->GetName();
    TObject * obj = 0;
    obj = (TObject*)MFile->Get(name.Data(),obj);
    if ( obj && obj->InheritsFrom(TH1::Class()) ||
         //obj->InheritsFrom(TPad::Class()) ) {
         obj->InheritsFrom(TCanvas::Class()) ) {
      fHistoList->Add(obj);
    }
    mr = mr->GetNext();
  }
}

void HistoDisplay::MakeHistoListR( TFile *RFile )
{
  if ( ! RFile ) return ;

  TIter next(RFile->GetListOfKeys());
  TKey *key;
  TObject *obj=0;
  while ( ( key = (TKey*)next() )  ) {
    obj = (TObject*)RFile->Get(key->GetName());
    if ( obj &&  obj->InheritsFrom(TH1::Class()) ||
         //obj->InheritsFrom(TPad::Class()) ) {
         obj->InheritsFrom(TCanvas::Class()) ) {
      fHistoList->Add(obj);
    }
  }
}

void HistoDisplay::MakeHistoListS( TSocket *sock )// added FH changed HS
{
  if ( ! sock ) return ;

  if ( sock->IsValid() ) {
      //request TConsumerInfo
      TMessage *mess;
      TConsumerInfo *info;
      sock->Send("ConsumerInfo");
      sock->Recv(mess);
      if ( mess ) {
      if ( mess->What() == kMESS_OBJECT)
        {
          info = (TConsumerInfo*)mess->ReadObject(mess->GetClass());
          if (!info) {
              cerr << "Null info from ReadObject!!!\n";
              return;
          }
          //info->print();
          info->updateList(fHistoList,sock);
          delete info;
        }
      delete mess;
      }
  }

}




void HistoDisplay::AddToDisplayedList( const TObject *inputobj )
{
  // cout << " In AddToDisplayedList " << endl;

  if ( !inputobj ) return ;


  if ( fHistoList && !fHistoList->IsEmpty() ) {

    TIter nextList(fHistoList);
    TObject *obj = 0;
    while ( ( obj = nextList() ) ) {

      //unused:     CObject *coj = UpdateHistoList( obj->GetName(), inputobj );

    }//while ( (obj = nextList()) )

  }//if ( fHistoList && !fHistoList->IsEmpty() )

  //tmp
  //fDisplayedList->ls();

}




void HistoDisplay::AddToTree( TObject *inputobj )
{
  if ( fHistoList && !fHistoList->IsEmpty() ) {

    TIter nextHisto(fHistoList);
    TObject *obj = 0;

    while ( (obj = nextHisto()) ) {
      TString PathName;
      //TString DirPath;

      PathName = GetDirPath( TString(obj->GetName()) ) 
        //PathName = "/" + TString( inputobj->GetName() ) 
        + "/" + TString(obj->GetName());
 
      //MakeTGListTree( PathName, inputobj );
      MakeTGListTree( PathName, inputobj, obj->GetTitle() );
    } //while ( (obj = nextHisto()) )

    fClient->NeedRedraw(fHistoListTree);

  } //if ( fHistoList && !fHistoList->IsEmpty() )

}



void HistoDisplay::MakeTGListTree( const TString &PathName, 
                                   //TObject *inputobj )
                                   TObject *inputobj,
                                   const char* tip )
{
  //cout << " In MakeTGListTree " << endl;


  while ( PathName.Contains("//") ) {
    TRegexp re("//+");
    PathName(re) = "/";
  }

  //cout << " PathName = " << PathName.Data() << endl;

  const int treemax = 10;

  int index[treemax];

  int PathLength = PathName.Length();

  int ii;
  int ind;
  for ( ii=0, ind = PathName.Index("/",1,0,TString::kExact) ;
        0 <= ind && ind <= PathLength ; ++ii ) {
    index[ii] = ind;
    ind = PathName.Index("/",1,ind+1,TString::kExact);
  }

  int nindex = ii;
  index[nindex] = PathLength;

  TString DirName;
  TString HistoName;

  TString CurPathName;
  TString CurParentName;
  TString CurItemName;


  TGListTreeItem *itemOrg= 0;
  itemOrg = fHistoListTree->FindItemByPathname( PathName.Data() );

  //if ( !fHistoListTree
  //->FindItemByPathname( PathName.Data() ) ) {

  if ( !itemOrg ) {

    if ( 1 < nindex ) {

      DirName = PathName( 0, index[nindex-1] );
      HistoName = PathName( index[nindex-1]+1, index[nindex] );


      if ( !fHistoListTree
          ->FindItemByPathname( DirName.Data() ) ) {

        for ( int i=0 ; i < nindex-1 ; ++i ) {
          CurPathName = DirName(0,index[i+1]);

          if ( !fHistoListTree
              ->FindItemByPathname( CurPathName.Data() ) ) {

            if ( i==0 ) { 
              CurItemName = DirName(index[i]+1,index[i+1]-index[i]-1);
              TGListTreeItem *item = 0;
              /*              
              fHistoListTree
                ->AddItem( 0, CurItemName.Data() )
                ->SetUserData(inputobj);
              */
              item = fHistoListTree
                ->AddItem( 0, CurItemName.Data() );
              if ( item ) {
                item->SetUserData(inputobj);
                //if ( tip ) fHistoListTree->SetToolTipItem( item, tip );
              } // if ( item )
            } //if ( i==0 )
            else {
              CurParentName = DirName( 0, index[i]);
              CurItemName = DirName(index[i]+1,index[i+1]-index[i]-1);
              /*
              fHistoListTree
                ->AddItem( fHistoListTree
                           ->FindItemByPathname( CurParentName.Data() ),
                           CurItemName.Data() )
                ->SetUserData(inputobj);
              */
              TGListTreeItem *item = 0;
              item = fHistoListTree
                ->AddItem( fHistoListTree
                           ->FindItemByPathname( CurParentName.Data() ),
                           CurItemName.Data() );
              if ( item ) {
                item->SetUserData(inputobj);
                //if ( tip ) fHistoListTree->SetToolTipItem( item, tip );
              } // if ( item )

            } // else //if ( i==0 )
          } // if ( !fHistoListTree...
        } //for ( int i=0 ; i < nindex-1 ; ++i )
      }//if ( !fHistoListTree...

      /*
      fHistoListTree
        ->AddItem( fHistoListTree->FindItemByPathname(DirName.Data()),
                   HistoName.Data() )
        ->SetUserData(inputobj);
      */
      TGListTreeItem *item = 0;
      item = fHistoListTree
        ->AddItem( fHistoListTree->FindItemByPathname(DirName.Data()),
                   HistoName.Data() );
      if ( item ) {
        item->SetUserData(inputobj);
        if ( tip ) fHistoListTree->SetToolTipItem( item, tip );
      } // if ( item )

    } //if ( 1 < nindex ) 
    else {

      HistoName = PathName( index[nindex-1]+1, index[nindex] );
      /*
      fHistoListTree
        ->AddItem( 0, HistoName.Data() )
        ->SetUserData(inputobj);
      */
      TGListTreeItem *item = 0;
      item = fHistoListTree
        ->AddItem( 0, HistoName.Data() );
      if ( item ) {
        item->SetUserData(inputobj);
        if ( tip ) fHistoListTree->SetToolTipItem( item, tip );
      } // if ( item )


    } //else // if ( 1 < nindex )

  } //  if ( !itemOrg ) 
  else {
    TObject *inputobjOrg = (TObject*) ( itemOrg->GetUserData() );
    if ( !inputobj->IsEqual( inputobjOrg ) ) {
      itemOrg->SetUserData(inputobj);
      if ( tip ) fHistoListTree->SetToolTipItem( itemOrg, tip );
    } //if ( !inputobj->IsEqual( inputobjOrg ) ) 

  } //else // if ( !itemOrg )
}



void HistoDisplay::SortTGListTree()
{

  if ( fHistoListTree->GetFirstItem() ) {

  TGListTreeItem *item;
  TGListTreeItem **list;
  int ichild = 0;
  int iparent = 0;

  const int itemmax = 200;
  list = new TGListTreeItem* [itemmax];
  list[ichild] = fHistoListTree->GetFirstItem();

  do
  {
    if ( fHistoListTree->SortChildren( list[iparent] ) ) {
      if ( (item = list[iparent]->GetFirstChild()) ) {
        list[++ichild] = item;
        while ( ( item =  list[ichild]->GetNextSibling() )
                && ichild < itemmax ) list[++ichild] = item;
      }
    }
    iparent++;

  } while ( iparent <= ichild && ichild < itemmax );
  
  delete [] list;

  } //if ( fHistoListTree->GetFirstItem() )

  fClient->NeedRedraw(fHistoListTree);

}


void HistoDisplay::RemoveTGListTree()
{
  TGListTreeItem *item;
  if ( fHistoListTree ) {
    while ( (item = fHistoListTree->GetFirstItem()) ) {
      fHistoListTree->DeleteItem( item );
    } //while ( (item = fHistoListTree->GetFirstItem()) )
    fClient->NeedRedraw(fHistoListTree);
    fSelectedItem = 0;
  }//if ( fHistoListTree ) 
}


void HistoDisplay::
DelTreeItemsOfInput( TObject *inputobj )
{
  //cout << " In DelTreeItemsOfInput " << endl;
  TGListTreeItem *item = fHistoListTree->GetFirstItem();

  while( item ) {
    fHistoListTree->RecursiveDeleteItem( item, inputobj );
    item = item->GetNextSibling();
  }//while( item )

}

/*
void HistoDisplay::AddTreeItemsOfInput( TObject *inputobj ) 
{
//cout << " In AddTreeItemsOfInput " << endl;

  if ( !inputobj ) {
    cout << " No input is specified. " << endl;
    return;
  } //if ( !inputobj )


  TPad *padsav = 0;

  if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) )
    padsav = (TPad*) gPad;



  TConsumerInfo *info = MakeConsumerInfo( inputobj );

  if ( info ) {
    TIterConsumerInfo nextObjName( info );

    TString objName;
    Int_t count = 0;
    Int_t countAdded = 0;

    while ( ( objName = nextObjName() ) ) {
      //if ( objName.IsNull() || count > 1000 ) break;
      if ( objName.IsNull() ) break;

      //tmp
      //cout << " objName = " << objName << endl;

      CObject *cobj = UpdateHistoList( objName.Data(), inputobj );
      if ( cobj ) {
        TString pathname = 
          "/" + info->getPath( objName.Data() ) + "/" + objName;
        //MakeTGListTree( pathname, inputobj );
        MakeTGListTree( pathname, inputobj, cobj->GetTitle() );
        countAdded++;
      } //if ( cobj )
      
      count++;
    } //while ( objName = nextObjName() )

    if ( countAdded ) {
      fClient->NeedRedraw( fHistoListTree );
      //fDisplayedList->ls();
    } //if ( cout2 )
    else
      cout << " No object"
           << " is found in the input: " 
           << inputobj->GetName()
           << endl;

    delete info;

  } //if( info )
  else {

    //if ( !inputobj ) return;

    MakeHistoList(inputobj);
    AddToTree(inputobj);
    AddToDisplayedList(inputobj);

  } //else //if( info )

  if ( padsav ) padsav->cd();


}
*/


void HistoDisplay::AddTreeItemsOfInput( TObject *inputobj ) 
{
  //cout << " In AddTreeItemsOfInput " << endl;

  if ( !inputobj ) {
    cout << " No input is specified. " << endl;
    return;
  } //if ( !inputobj )


  TPad *padsav = 0;
  if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) )
    padsav = (TPad*) gPad;


  TConsumerInfo *info = MakeConsumerInfo( inputobj );

  if ( info ) {
    TIterConsumerInfo nextObjName( info );

    TString objName;
    Int_t countAdded = 0;

    while ( ( objName = nextObjName() ) ) {
      if ( objName.IsNull() ) break;

      TString pathname = 
        "/" + info->getPath( objName.Data() ) + "/" + objName;

      MakeTGListTree( pathname, inputobj );
      countAdded++;

    } //while ( objName = nextObjName() )

    if ( countAdded ) {
      //fClient->NeedRedraw( fHistoListTree );
      //fDisplayedList->ls();
    } //if ( cout2 )
    else
      cout << " No object"
           << " is found in the input: " 
           << inputobj->GetName()
           << endl;

    delete info;

  } //if( info )
  else {

    //if ( !inputobj ) return;

    MakeHistoList(inputobj);
    AddToTree(inputobj);
    AddToDisplayedList(inputobj);

  } //else //if( info )

  if ( padsav ) padsav->cd();

}



void HistoDisplay::RefreshTreeItem( TGListTreeItem *item ) 
{
  //cout << " In RefreshTreeItem " << endl;


  while ( item ) {

    //tmp
    //cout << " item = " << item->GetText() <<endl;

    TGListTreeItem *sibling = item->GetNextSibling();

    TGListTreeItem *parent = item->GetParent();

    TGListTreeItem *firstchild = item->GetFirstChild();

    if ( firstchild ) {

      RefreshTreeItem( firstchild );

    } //if ( firstchild ) 
    else {

      TObject *inputobj =
        (TObject*)item->GetUserData();

      if ( inputobj ) {

        TPad *padsav = 0;
        if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) )
          padsav = (TPad*) gPad;
      
        CObject *cobj = UpdateHistoList( item->GetText(), inputobj );
        if ( !cobj ) 
          fHistoListTree->DeleteItem( item );
        else
          fHistoListTree->SetToolTipItem( item, cobj->GetTitle() );

        if ( padsav ) padsav->cd();

      } //if ( inputobj )

    } //else //if ( firstchild )

    item = sibling;

    if ( !item &&
         parent && !( parent->GetFirstChild() ) )
      fHistoListTree->DeleteItem( parent );

  }  //while ( item ) 

  //fClient->NeedRedraw( fHistoListTree );

}




void HistoDisplay::
SearchWarningErrorFolder( TGListTreeItem *item, TObject *socket )
{
  //cout << " In SearchWarningErrorFolder " << endl;

  while ( item ) {

    /*
      if ( ( strstr( item->GetText(), "warning" ) ||
             strstr( item->GetText(), "Warning" ) ||
             strstr( item->GetText(), "WARNING" ) ||
             strstr( item->GetText(), "error" ) ||
             strstr( item->GetText(), "Error" ) ||
             strstr( item->GetText(), "ERROR" )  ) &&
           ( socket->IsEqual( (TObject*) item->GetUserData() )  )  ) {
    */

    if ( ( ( strstrn( item->GetText(), kWarningFolder ) ) ||
           ( strstrn( item->GetText(), kErrorFolder ) ) ) &&
         //( socket->IsEqual( (TObject*) item->GetUserData() ) ) ) {
         ( !strcmp( socket->GetName(), 
                    ( (TObject*)item->GetUserData())->GetName() ) ) ) {

        //tmp
      //cout << "item->GetText()" << item->GetText() << endl;


        fHistoListTree->OpenItem( item );

        /*
        PopUpSlides( item,
                     "WarningErrorCanvas",
                     "Warning/Error Canvas" );
        */


        PopUpSlides( item,
                     kWarningErrorCanvasName,
                     kWarningErrorCanvasTitle );

      } //if ( strstr( item->GetText(), "warning" ) ||


    TGListTreeItem *sibling = item->GetNextSibling();
    TGListTreeItem *firstchild = item->GetFirstChild();

    if ( firstchild ) {

      SearchWarningErrorFolder( firstchild, socket );

    } //if ( firstchild ) 

    item = sibling;

  }  //while ( item ) 



}


void HistoDisplay::PopUpSlides( TGListTreeItem *item,
const char *canvasname, const char *canvastitle ) 
{
  //cout << " In PopUpWarningSlides " << endl;

  TVirtualPad *padsav = 0;
  if ( gPad ) padsav = gPad;

  TCanvas *canvas = 0;

  canvas =
    (TCanvas*) 
    ( gROOT->GetListOfCanvases()->FindObject( canvasname ) );
            
  if ( !canvas ) {
    canvas = 
      new TCanvas( canvasname, canvastitle, 400, 400 );
  } //if ( !canvas )

  if ( canvas ) {

    TCanvasImp *canvasimp = canvas->GetCanvasImp();
    if ( canvasimp ) canvasimp->Show();

    canvas->Clear();
    canvas->cd();

    //if ( fSlideTimer )
    if ( fSlideTimer && !fSlideTimer->HasTimedOut() )
      fSlideTimer->TurnOff();

    StartSlides( item );

  } // if ( canvas ) 

  if ( padsav ) padsav->cd();


}









CObject* HistoDisplay::GetCObjFromListItem( TGListTreeItem *item ) 
{
  //cout << " In GetCObjFromListItem " << endl;

  if ( !item ) return 0;

  CObject *cobj = 0;

  //TVirtualPad *padsav = 0;
  //if ( gPad && !gROOT->GetListOfCanvases()->IsEmpty() ) padsav = gPad;


  TObject *obj = fDisplayedList->FindObject( item->GetText() );

  if ( !obj ) {
    if ( !item->GetFirstChild() ) {
      TObject *inputobj = (TObject*)item->GetUserData();
      if ( inputobj ) 
        cobj =  UpdateHistoList( item->GetText(), inputobj );

        if ( !cobj ) 
          //fHistoListTree->DeleteItem( item );
          cout <<  item->GetText() << " is not found." << endl;
        else
          fHistoListTree->SetToolTipItem( item, cobj->GetTitle() );

    } //if ( !item->GetFirstChild() )
  } //if ( !obj ) 
  else 
    if ( obj->InheritsFrom( CObject::Class() ) ) {
      cobj = ( CObject* )obj;
      const TObject *inputobj = (TObject*)item->GetUserData();

      if ( cobj->GetInputSource() != inputobj ) {
        //tmp
        //cout << " inputobj is changed " << endl;
        cobj->SetInputSource( inputobj );

      } //if ( cobj->GetInputSource() != inputobj ) 
        
    } //if ( obj->InheritsFrom( CObject::Class() ) )



  //if ( padsav ) padsav->cd();


  return cobj;

}














void HistoDisplay::DrawHisto( TObject *obj )
{
  //cout << " In DrawHisto obj " << endl;

  /*
  // For older version of ROOT, this is needed.
  static int icount = 0;
  if ( !(icount++) || gROOT->GetListOfCanvases()->IsEmpty() ) gPad = 0;
  */

  if ( gROOT->GetListOfCanvases()->IsEmpty() ) gPad = 0;

  if ( obj ) {

    //obj->ls();

    TCanvas *CurrentCanvas = 0;

    if ( !gPad ) {
      CanvasNumber++;
      char *num= new char[3];
      sprintf( num, "%d", CanvasNumber );
      CurrentCanvas =
        new TCanvas( CanvasName + TString( num ),
                     CanvasTitle + TString( num ) , 500, 500 );
      delete[] num;
      CurrentCanvas->cd();
    }



    TPad *gPadSav = (TPad*)gPad;
    CurrentCanvas = gPadSav->GetCanvas();


    if ( obj->InheritsFrom( CHistogram::Class() ) ) {

      CHistogram *chisto = (CHistogram*) obj;
      TH1 *histo = chisto->SubtractedHisto();
      //TH1 *histo =  chisto->GetHistoDrawn();

      if ( histo ) {

        TObject *hobj = chisto->GetTObject();

        Option_t *option = 0;
        if ( hobj ) option = hobj->GetOption();

        //gPadSav->Clear();
        RecursivePadClear( gPadSav );
        gPadSav->cd();



        TString padname;
        TString padtitle;

        if ( gPadSav == CurrentCanvas ) {

          //tmp
          /*
          CurrentCanvas->SetWindowSize( 500, 500 );
          CurrentCanvas->Resize();
          */

          if ( strcmp( CurrentCanvas->GetName(),
                       kWarningErrorCanvasName ) ) {

          padname = "Canvas_of_" +  TString( histo->GetName() ) ;
          if ( fSlideCanvasList->FindObject( CurrentCanvas ) )
            //padtitle = "<Slide Canvas>" + TString( histo->GetTitle() );
            padtitle = "<Auto Update>" + TString( histo->GetTitle() );
          else
            padtitle = TString( histo->GetTitle() );
          CurrentCanvas->SetName( padname.Data() );
          CurrentCanvas->SetTitle( padtitle.Data() );

          } // if ( strcmp( CurrentCanvas->GetName(),


          //gPadSav->cd();
          //DrawTH1( histo, option, gPadSav );
          DrawTH1( histo, option, CurrentCanvas );
        } //if ( gPadSav == gPadSav->GetCanvas() )
        else { 

          padname = "Pad_of_" + TString( histo->GetName() );
          padtitle = TString( histo->GetTitle() );

          gPadSav->SetName( padname.Data() );
          gPadSav->SetTitle( padtitle.Data() );
          //gPadSav->cd();
          DrawTH1( histo, option, gPadSav );

          ChangeCanvasNameTitle( CurrentCanvas );

        } // else //if ( gPadSav == gPadSav->GetCanvas() )


      } //if ( histo )

    } //if ( obj->InheritsFrom( CHistogram::Class() ) ) 

    else if ( obj->InheritsFrom( CObject::Class() ) ) {
      CObject *cobj = (CObject*)obj;
      TObject *tobj = cobj->GetTObject();

      if ( tobj->InheritsFrom( TPad::Class() ) ) {

        TPad *c2 = (TPad*)tobj;

        //tmp
        //cout << " gPadSav->GetName() = " << gPadSav->GetName() << endl;

        gPadSav->cd(); // necessary to prevent bad x window allocation.

        if ( c2 ) {


          if ( gPadSav == CurrentCanvas ) {
            //gPadSav->Clear();
            //RecursivePadClear( gPadSav );
            gPadSav->cd();

          //tmp
          /*
            if ( c2->InheritsFrom( TCanvas::Class() ) )
              DuplicateCanvasSize( CurrentCanvas, (TCanvas*)c2 );
          */

          if ( strcmp( CurrentCanvas->GetName(),
                       kWarningErrorCanvasName ) ) {

            CurrentCanvas->SetName( c2->GetName() );
            TString padtitle;
            if ( fSlideCanvasList->FindObject( CurrentCanvas ) )
              //padtitle = "<Slide Canvas>" + TString( c2->GetTitle() );
              padtitle = "<Auto Update>" + TString( c2->GetTitle() );
            else
              padtitle = TString( c2->GetTitle() );
            CurrentCanvas->SetTitle( padtitle );

          } // if ( strcmp( CurrentCanvas->GetName(),


            DrawTPad( c2, gPadSav );

          } //if ( gPadSav == gPadSav->GetCanvas() )
          else {
            gPadSav->SetName( c2->GetName() );
            gPadSav->SetTitle( c2->GetTitle() );
            DrawTPad( c2, gPadSav );
            ChangeCanvasNameTitle( CurrentCanvas );

          } //else //if ( gPadSav == gPadSav->GetCanvas() ) 

        } //if (c2)

      } //if ( tobj->InheritsFrom( TPad::Class() ) )

    } //else if ( obj->InheritsFrom( CObject::Class() ) ) 


    //ChangeCanvasNameTitle( CurrentCanvas );

    gPadSav->cd();
    /*
    gPadSav->Modified();
    gPadSav->Update();
    */
    CurrentCanvas->Modified();
    CurrentCanvas->Update();


    //cout << "Drawing done" << endl << endl;
      
  } //if (obj)


}



void HistoDisplay::DrawHisto( TList *fSelectedList )
{
  //cout << " In DrawHisto list " << endl;

  // For older version of ROOT, this is needed.
  //static int icount = 0;
  if ( gROOT->GetListOfCanvases()->IsEmpty() ) gPad = 0;

    if ( fSelectedList && !fSelectedList->IsEmpty() ) {
      int nPad = fSelectedList->GetSize();
      int nPadX = (int) sqrt( (float)nPad );
      int nPadY = nPadX;

      if ( nPadX*nPadY < nPad ) {
        nPadX++;
        if ( nPadX * nPadY < nPad ) nPadY++;
      } //if ( nPadX*nPadY < nPad ) 


      // pad size ww,wh--
      int ww, wh;
      ww = wh = 300;

      TCanvas *CurrentCanvas = 0;

      if ( !gPad ){
        CanvasNumber++;
        char *num = new char[3];
        sprintf( num, "%d", CanvasNumber);
        CurrentCanvas =
          new TCanvas( CanvasName + TString( num ),
                       CanvasTitle + TString( num) , ww * nPadX, wh * nPadY );
        delete num;
        CurrentCanvas->cd();
      }//if (!gPad)
      else {
        CurrentCanvas = (TCanvas*)gPad->GetCanvas();

        //CurrentCanvas->Clear();
        RecursivePadClear( CurrentCanvas );
        CurrentCanvas->cd();

        //tmp
        /*
        CurrentCanvas->SetWindowSize( ww * nPadX, wh * nPadY );
        CurrentCanvas->Resize();
        */

      }//if (!gPad) else


      CurrentCanvas->Divide( nPadX, nPadY );


      int iPad = 0;

      TIter nextList(fSelectedList);

      TObject *obj = 0;
      while ( ( obj = nextList() ) ) {
        iPad++;

        if ( obj->InheritsFrom( CHistogram::Class() ) ) {

          CurrentCanvas->cd(iPad);

          CHistogram *chisto = (CHistogram*)obj;

          TH1 *histo = chisto->SubtractedHisto();
          //TH1 *histo = chisto->GetHistoDrawn();

          if ( histo ) {
 
            Option_t *option;
            option = chisto->GetTObject()->GetOption();

            TPad *gpad = (TPad*)gPad;

            TString padname = "Pad_of_" +  TString( histo->GetName() ) ;
            TString padtitle = TString( histo->GetTitle() ) ;

            gpad->SetName( padname.Data() );
            gpad->SetTitle( padtitle.Data() );

            DrawTH1(histo, option, gpad);

            gpad->Modified();
            gpad->Update();

          } //if( histo )

        } //if ( obj->InheritsFrom( CHistogram::Class() ) )
            
        else if ( obj->InheritsFrom( CObject::Class() ) ) {

          CObject *cobj = (CObject*)obj;
          TObject *tobj = cobj->GetTObject();

          if ( tobj && tobj->InheritsFrom( TPad::Class() ) ) {

            CurrentCanvas->cd(iPad);

            TPad *gpad = (TPad*)gPad;
            TPad *c2 = (TPad*)tobj;

            if (c2) {
              gpad->SetName( c2->GetName() );
              gpad->SetTitle( c2->GetTitle() );

              DrawTPad(c2, gpad);
              //gpad->Modified();
              gpad->Update();

            } //if (c2)

          } //if ( tobj && tobj->InheritsFrom( TPad::Class() ) )

        } //else if ( obj->InheritsFrom( CObject::Class() ) )

      } // while ( obj = nextList() )


      ChangeCanvasNameTitle( CurrentCanvas );


      CurrentCanvas->cd();
      CurrentCanvas->Modified();
      CurrentCanvas->Update();

      //cout << "Drawing done" << endl << endl;

    } // if ( fSelectedList && !fSelectedList->IsEmpty() )
      

}





void HistoDisplay::ChangeCanvasNameTitle( TCanvas *canvas )
{
  //cout << " In ChangeCanvasNameTitle " << endl;

  if ( !canvas ) return;

  TList *list = canvas->GetListOfPrimitives();

  Int_t count = 0;
  TObject *obj = 0;


  TString canvasname = "";
  TString canvastitle = "";

  /*
  const char *name = 0;
  name = canvas->GetName();
  if ( name && fDisplayedList->FindObject( name ) ) {
    count++;
    canvasname = name;
    canvastitle = canvas->GetTitle();
  } //if ( name && fDisplayedList->FindObject( obj ) ) 
  */


  TIter next( list );

  while ( ( obj = next() ) ) {

    const char *name = 0;
    name = obj->GetName();

    if ( strstr( name, "Pad_of_" ) )
      name = &( name[ strlen( "Pad_of_" ) ] );

    //cout << " name " <<  name << endl;

    if ( name && fDisplayedList->FindObject( name ) ) {
      count++;
      if ( count == 1 ) {
          canvasname = TString( name );
          canvastitle = TString( obj->GetTitle() );
      } // if ( count == 1 )
      else if ( count == 2 ) {
        canvasname = canvasname + "__" + TString( name );
        canvastitle = canvastitle + ", " + TString( obj->GetTitle() );
      } //else if ( count == 2 )
      else if ( count == 3 ) {
        canvasname = canvasname + "__etc";
        canvastitle = canvastitle + ", etc.";
      } //else if ( count == 3 )
    } //if ( name && fDisplayedList->FindObject( obj ) ) 

  } //while ( obj = next() )

  if ( count ) {
    if ( fSlideCanvasList->FindObject( canvas->GetName() ) )
      //canvastitle =  "<Slide Canvas>" + canvastitle; 
      canvastitle =  "<Auto Update>" + canvastitle; 

    canvas->SetName( canvasname.Data() );
    canvas->SetTitle( canvastitle.Data() );
  } //if ( count )

}



void HistoDisplay::DuplicateCanvasSize( TCanvas *guicanvas,
                                        TCanvas *consumercanvas )
{
  //cout << " In DuplicateCanvasSize " << endl;

  if ( !guicanvas || !consumercanvas ) return;
  Int_t ww, wh;

  ww = consumercanvas->GetWindowWidth();
  wh = consumercanvas->GetWindowHeight();

  if ( !ww || !wh ) {
    ww = consumercanvas->GetWw() + 4;
    wh = consumercanvas->GetWh() + 28;
  } //if ( !ww || !wh )

  if ( ww && wh ) {
    guicanvas->SetWindowSize( ww, wh );
    guicanvas->Resize();
  } //if ( ww && wh )

}







void HistoDisplay::DrawTH1(TH1 *histo, Option_t *option
                           , TVirtualPad *BackPad )
{
  //cout << " In DrawTH1" << endl;

  if ( !histo || !BackPad ) return;
  //BackPad->Clear(); // Done by TH1::Draw()
  //RecursivePadClear( BackPad );

  BackPad->cd();

  //histo->Draw(option);

  histo->Draw();
  histo->SetDrawOption( option );

  //cout << " End of DrawTH1 " << endl;

}





void HistoDisplay::DrawTPad( TPad *DrawnPad, TVirtualPad *BackPad )
{
  //  cout << " In DrawTPad  " << endl;

  if ( !DrawnPad || !BackPad ) return;

  //copy pad attributes
  BackPad->Range( DrawnPad->GetX1(), DrawnPad->GetY1(),
                  DrawnPad->GetX2(), DrawnPad->GetY2() );
  BackPad->SetTickx( DrawnPad->GetTickx() );
  BackPad->SetTicky( DrawnPad->GetTicky() );
  BackPad->SetGridx( DrawnPad->GetGridx() );
  BackPad->SetGridy( DrawnPad->GetGridy() );
  BackPad->SetLogx( DrawnPad->GetLogx() );
  BackPad->SetLogy( DrawnPad->GetLogy() );
  BackPad->SetLogz( DrawnPad->GetLogz() );
  BackPad->SetBorderSize( DrawnPad->GetBorderSize() );
  BackPad->SetBorderMode( DrawnPad->GetBorderMode() );
  DrawnPad->TAttLine::Copy( (TAttLine&)*BackPad );
  DrawnPad->TAttFill::Copy( (TAttFill&)*BackPad );
  DrawnPad->TAttPad::Copy( (TAttPad&)*BackPad );


  TList *list = DrawnPad->GetListOfPrimitives();
  TIter next( list );
  TObject *objInPad;

  //  BackPad->Clear();
     RecursivePadClear( BackPad );


  //  BackPad->cd();


  while( ( objInPad = next() ) ) {
    BackPad->cd(); // this is absolutely necessary in compiled mode.
    // and just before Draw(). Learned hard way.
    // Seemed not true for newer ROOT version.

    //    objInPad->Print();
    gROOT->SetSelectedPad( BackPad ); 
    // not BackPad->cd() but this for primitiveList->Add

    // objInPad->DrawClone(); // Best choise to draw all in DrawnPad.
    // But does not draw them on additional pad made here.
    // Not allowed to change pad size. 

    //  objInPad->Clone()->Draw();

        BackPad->GetListOfPrimitives()
      //->Add( objInPad->Clone(), objInPad->GetDrawOption() );
        ->Add( objInPad->Clone(), next.GetOption() );

  } // while( objInPad = next() )

  BackPad->Modified();
  delete objInPad;

}


void HistoDisplay::RecursivePadClear( TVirtualPad *pad, Option_t *option )
{
  //cout << " In RecursivePadClear " << endl;
  if ( !pad ) return;
  //cout << pad->GetName() << endl;


  TList *primitivelist = pad->GetListOfPrimitives();
  TFrame *frame = pad->GetFrame();

  TIter next( primitivelist );

  TObject *obj;
  while ( ( obj = next() ) ) {

      if ( !( obj->TestBit( kCanDelete ) ) &&
           !( frame && frame->IsEqual( obj ) ) ) obj->SetBit( kCanDelete );

      if ( obj->InheritsFrom( TPad::Class() )  ) {
        TPad *padInside = (TPad*) obj;
        RecursivePadClear( padInside, option );
      } // if ( obj->InheritsFrom( TPad::Class() )  )

  } //while ( obj = next() )

  pad->Clear( option );

}




void HistoDisplay::UpdateTimerOn()
{
  //cout << " In UpdateTimerOn " << endl;

  TVirtualPad *currentPad;

  if ( !gPad || ( gROOT->GetListOfCanvases()->IsEmpty() ) )
    return;
  else
    currentPad = gPad;


  Int_t sleeptime  = 0;

  if ( AutoUpdate ) {

    sleeptime =  atoi( fFrequencyTextBuffer->GetString() );

    if ( fUpdateTimer ) {
      fUpdateTimer->SetTime( max( sleeptime, 800 ) );
      //cout << " Timer Time = " << fUpdateTimer->GetTime() << endl;

      fUpdateTimer->SetCurrentPad( currentPad );

      Running = kTRUE;
//      fReadFileButton->ChangeBackground(Green);
      fUpdateTimer->TurnOn();

      //return;
    } //if ( fUpdateTimer )

  } //if ( AutoUpdate )


  //cout << "Update done" << endl << endl;

}



Bool_t HistoDisplayUpdateTimer::Notify()
{
  //cout << " In HistoDisplayUpdateTimer::Notify " << endl; 
  if ( this &&
       ( !fHistoDisplay->AutoUpdate ||
         !fHistoDisplay->Running ) ) {

    fHistoDisplay->Running = kFALSE;

    TurnOff();   // same as Remove();

    fHistoDisplay->fPauseHistoButton->SetState( kButtonDisabled );
    fHistoDisplay->fRestartHistoButton->SetState( kButtonUp );

    fHistoDisplay->fHistoListTree
      ->HighlightItem( fHistoDisplay->fSelectedItem );
    fHistoDisplay->fClient->NeedRedraw( fHistoDisplay->fHistoListTree );

    //cout << "Update done" << endl << endl;
    cout << "Update stopped" << endl << endl;
    return kTRUE;
  } //if ( this &&

  //fHistoDisplay->UpdateCanvas();
  fHistoDisplay->UpdateCanvas( fCurrentPad );
  Reset();
  return kFALSE;

}




//void HistoDisplay::UpdateCanvas() {
void HistoDisplay::UpdateCanvas( TVirtualPad *currentpad ) {

  //  cout << " In UpdateCanvas " << endl;

  if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) ) {

    TCanvas *canvas = 0;
    static TObjLink *link = 0;

    TPad *gPadSav = (TPad*) gPad;

    if ( AutoUpdate &&
        SlideShowUpdate &&
        fSlideCanvasList &&
        !( fSlideCanvasList->IsEmpty() ) ) {

      if ( !link ) link = fSlideCanvasList->FirstLink();

      if ( link ) {

        TObject *ocanv = 0;
        if ( ( ocanv = link->GetObject() ) &&
             ( gROOT->GetListOfCanvases()->FindObject( ocanv ) ) &&
             ( ocanv->InheritsFrom( TCanvas::Class() ) ) ) {
          canvas = (TCanvas*) ocanv;

          //canvas->cd();
          UpdatePad( canvas );

          link = link->Next();
        } //if ( ( ocanv = link->GetObject() ) &&
        else {
          TObjLink *linktmp = link;
          link = link->Next();
          fSlideCanvasList->Remove( linktmp );
          return;
        } // else //if ( ( ocanv = link->GetObject() ) &&

      } //if ( link ) 


    } //if ( AutoUpdate &&
    else {

      link = 0;
      //canvas = gPad->GetCanvas();

      if ( !currentpad ||
           !gROOT->GetListOfCanvases()->FindObject( currentpad ) )
        currentpad = gPadSav;

      UpdatePad( currentpad );

      //      canvas = currentpad->GetCanvas();  DP

    } //else //if ( AutoUpdate && 

    /*
    if ( canvas ) {
      TCanvasImp *canvasimp = canvas->GetCanvasImp();
      if ( canvasimp ) canvasimp->Show();
    } // if ( canvas ) 
    */

    //TPad *gpad = (TPad*) gPad;
    //UpdatePad( gpad );


    delete canvas;
    delete link;
    //    cout << gROOT->GetListOfCanvases()->GetSize();
  

     gPadSav->cd();
     // delete gPadSav;
  } //if( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) ) 


}




//void HistoDisplay::StartSlides( const TGListTreeItem *selectedItem )
void HistoDisplay::StartSlides( TGListTreeItem */*selectedItem*/ )
{
  // cout << " In StartSlides " << endl;
  /*
  if ( selectedItem &&
       selectedItem->GetFirstChild() &&
       selectedItem->GetFirstChild()->GetNextSibling() &&
       selectedItem->IsOpen() ) {

    //Running = kTRUE;

    fPauseHistoButton->SetState( kButtonUp );
    fRestartHistoButton->SetState( kButtonDisabled );
  */
    /*
    //if ( fUpdateTimer && !fUpdateTimer->HasTimedOut() )
    if ( fUpdateTimer )
      fUpdateTimer->TurnOff();
    */
  /*
    //SlideTimerOn();
    SlideTimerOn( selectedItem );

  } //if ( selectedItem &&
  */

}


//void HistoDisplay::SlideTimerOn()
//void HistoDisplay::SlideTimerOn( cosnt TGListTreeItem *item )
void HistoDisplay::SlideTimerOn( TGListTreeItem */*item*/ )
{
  //  cout << " In SlideTimerOn " << endl;

  //if ( !gPad || ( gROOT->GetListOfCanvases()->IsEmpty() ) ) return;

  /*
  Int_t sleeptime  = 0;

  sleeptime =  atoi( fFrequencyTextBuffer->GetString() );

  if ( fSlideTimer ) {

    fSlideTimer->SetTime( max( sleeptime, 2000 ) );
    //cout << " Timer Time = " << fSlideTimer->GetTime() << endl;

    //fSlideTimer->SetCurrentItem( fSelectedItem ); 
    fSlideTimer->SetCurrentItem( item ); 

    TVirtualPad *pad = 0;
    //if ( gPad && !gROOT->GetListOfCanvases()->IsEmpty() ) pad = gPad;
    if ( gROOT->GetListOfCanvases()->IsEmpty() ) gPad = 0;
    pad = gPad;
    fSlideTimer->SetCurrentPad( pad );


    if ( fUpdateTimer
         && ( fUpdateTimer->GetCurrentPad() == gPad )
         && !fUpdateTimer->HasTimedOut() )
      //if ( fUpdateTimer )
      fUpdateTimer->TurnOff();



    Running = kTRUE;
    fReadFileButton->ChangeBackground(Green);
    //  cout << "Button changed to green\n"; 
    gClient->NeedRedraw(fReadFileButton);
   fSlideTimer->TurnOn();

  } // if ( fSlideTimer ) {

  */
}



Bool_t HistoDisplaySlideTimer::Notify()
{
  //cout << " In Notify (Slide Timer ) " << endl;

  if ( this &&
       !fHistoDisplay->Running  ) {

    fHistoDisplay->Running = kFALSE;


  
    TurnOff();   // same as Remove();

    fHistoDisplay->fPauseHistoButton->SetState( kButtonDisabled );
    fHistoDisplay->fRestartHistoButton->SetState( kButtonUp );

    fHistoDisplay->fHistoListTree
      ->HighlightItem( fHistoDisplay->fSelectedItem );
    fHistoDisplay->fClient->NeedRedraw( fHistoDisplay->fHistoListTree );

    //cout << "Update done" << endl << endl;
    cout << "Slide show stopped" << endl << endl;
 

  } //if ( this &&

  //fHistoDisplay->CycleSlides( fCurrentItem );
  fHistoDisplay->CycleSlides( fCurrentItem, fCurrentPad );
  fHistoDisplay->fReadFileButton->ChangeBackground(fHistoDisplay->Green);
  // cout << "Button changed to green\n";
   gClient->NeedRedraw(fHistoDisplay->fReadFileButton);
  Reset();
  return kFALSE;

}




//void HistoDisplay::CycleSlides( const TGListTreeItem *currentitem )
void HistoDisplay::CycleSlides( const TGListTreeItem */*currentitem*/,
                                TVirtualPad */*currentpad*/ )
{
  //  cout << " In CycleSlides " << endl;

  /*
  static TGListTreeItem *item = 0;

  TVirtualPad *padsav = 0;

  if ( !currentitem ) {
    Running = kFALSE;
    //    fReadFileButton->ChangeBackground(Red);
    return;
  } //if ( !currentitem ) 

  if ( !item || ( item && ( item->GetParent() != currentitem ) ) ) 
    item = currentitem->GetFirstChild();

  if ( item ) {

    //if ( !gROOT->GetListOfCanvases()->IsEmpty() && gPad )
    if ( gROOT->GetListOfCanvases()->IsEmpty() ) gPad = 0;
    padsav =  gPad;

    //TObject *obj = fDisplayedList->FindObject( item->GetText() );
    TObject *obj = GetCObjFromListItem( item );

    if( obj ) {
      if ( obj->InheritsFrom( CObject::Class() ) ) {

        const TObject *inputobj = 
          ( (CObject*)obj )->GetInputSource();
        TObject *cobj = 
          UpdateHistoList( item->GetText(), inputobj );

        fHistoListTree->HighlightItem( item );
        fClient->NeedRedraw( fHistoListTree );

        if ( currentpad &&
             gROOT->GetListOfCanvases()->FindObject( currentpad ) )
          currentpad->cd();
        else if ( padsav ) {
          padsav->cd();
          fSlideTimer->SetCurrentPad( padsav );
        }

        DrawHisto( cobj );

        if ( padsav ) padsav->cd();

      } //if ( obj->InheritsFrom( CObject::Class() ) )
    }//if( obj )



    item = item->GetNextSibling();

    if ( !item ) 
      if ( AutoUpdate ) item = fSelectedItem->GetFirstChild();
      else
        Running = kFALSE;
    //    fReadFileButton->ChangeBackground(Red);

  } // if ( item )
  else {
    Running = kFALSE;
    // fReadFileButton->ChangeBackground(Red);
  } //else //if ( item )

  */
}






void HistoDisplay::UpdatePad( TVirtualPad *pad )
{
  //cout << " In UpdatePad " << endl;

  if ( !pad ) return;

  DrawUpdatedPad( pad );
  pad->cd();
  pad->Modified();
  pad->Update();

}



void HistoDisplay::DrawUpdatedPad( TVirtualPad *currentPad )
{
  //  cout << " In DrawUpdatedPad " << endl;

  if ( ! currentPad ) return;

  //if ( currentPad != currentPad->GetCanvas() ) {

    const char *name = currentPad->GetName();

    TObject *objP = fDisplayedList->FindObject( name );
 
    if ( objP && objP->InheritsFrom( CObject::Class() ) ) {

      const TObject *inputObj = ( (CObject*)objP )->GetInputSource();
      CObject *objNew = UpdateHistoList( name, inputObj );

      if ( objNew ) {
        TObject *tobj =  objNew->GetTObject();
        
        if ( tobj->InheritsFrom( TPad::Class() ) ) {
           DrawTPad( (TPad*)tobj, currentPad );
          //      ReplacePad( (TPad*)tobj, currentPad );
           //     cout << "In here - replace pad\n";
          //      delete name;
         
                  return;
        } //if ( tobj->InheritsFrom( TPad::Class() ) )
       
      } //if ( objNew )

    } //if ( objP && objP->InheritsFrom( CObject::Class() ) )

    //} //if ( currentPad != currentPad->GetCanvas() )


  //TFrame *frame = currentPad->GetFrame();

  TObjOptLink *lnk = (TObjOptLink*)currentPad
    ->GetListOfPrimitives()
    ->FirstLink();

  while( lnk ) {

    TObject *obj = lnk->GetObject();

    if ( obj->InheritsFrom(TPad::Class()) ) {

      DrawUpdatedPad( (TPad*)obj );
        
    } //if ( obj->InheritsFrom(TPad::Class()) )

    else {

      if ( obj->InheritsFrom(TH1::Class()) ) {

        TObject *obj2 = fDisplayedList->FindObject(obj->GetName());
        
        if ( obj2 && obj2->InheritsFrom(CObject::Class()) ) {

          const TObject *inputObj = ((CObject*)obj2)->GetInputSource();

          CObject *objNew = UpdateHistoList(obj2->GetName(), inputObj);

          //objNew->ls();

          if (objNew && objNew->InheritsFrom(CHistogram::Class()) ) {

            //gROOT->SetSelectedPad( currentPad );

            TH1 *histo = (TH1*) (((CHistogram*)objNew)->SubtractedHisto());
            //TH1 *histo =  ( (CHistogram*)objNew )->GetHistoDrawn();

            if ( histo ) {

              //tmp
              if ( ! currentPad->GetPadPaint() ) {

                TH1 *histoOld = (TH1*)obj;
                histoOld->Reset();
                histoOld->Add(histo);

                TAxis *xaxis = histo->GetXaxis();
                if ( xaxis ) {
                  char *title = new char[ strlen( xaxis->GetTitle() ) + 1 ];
                  strcpy( title, xaxis->GetTitle() ); 
                  histoOld->SetXTitle( title );
                  delete [] title;
                } //if ( xaxis )
                TAxis *yaxis = histo->GetYaxis();
                if ( yaxis ) {
                  char *title = new char[ strlen( yaxis->GetTitle() ) + 1 ];
                  strcpy( title, yaxis->GetTitle() ); 
                  histoOld->SetYTitle( title );
                  delete [] title;
                } //if ( yaxis )
                TAxis *zaxis = histo->GetZaxis();
                if ( zaxis ) {
                  char *title = new char[ strlen( zaxis->GetTitle() ) + 1 ];
                  strcpy( title, zaxis->GetTitle() ); 
                  histoOld->SetZTitle( title );
                  delete [] title;
                } //if ( zaxis ) 

                delete histo;

                currentPad->Modified();

              } //if ( ! currentPad->GetPadPaint() )
              else
                cout << " Pad is being paianted. Not updated. " << endl;

            } //if ( histo ) 

          } //if (objNew && objNew->InheritsFrom(CHistogram::Class()) )

        } //if ( obj2 && obj2->InheritsFrom(CObject::Class()) )

      } //if ( obj->InheritsFrom(TH1::Class()) )

      /*
      else if ( !( frame->IsEqual( obj ) ) ) {

      } //else if ( !( frame->IsEqual( obj ) ) )
      */

    } //else //if ( obj->InheritsFrom(TPad::Class()) )

   lnk = (TObjOptLink*) ( lnk->Next() );

  } //  while( lnk ) 

  // delete name;

  //  cout << " End of DrawUpdatedPad " << endl;
}



void HistoDisplay::ReplacePad( TVirtualPad *newpad, TVirtualPad *oldpad )
{
  // cout << " In ReplacePad " << endl;

  if ( !newpad || !oldpad ) return;

  TFrame *frame = newpad->GetFrame();

  TList *oldPrimitiveList = oldpad->GetListOfPrimitives();
  TList *newPrimitiveList = newpad->GetListOfPrimitives(); 

  TIter next( newPrimitiveList );

  TObject *obj;
  while( ( obj = next() ) ) {

      TObject *objOld = 
        oldPrimitiveList->FindObject( obj->GetName() );
      TObject *cobj =
        fDisplayedList->FindObject( obj->GetName() );

      if ( obj->InheritsFrom( TPad::Class() ) &&
           objOld &&
           objOld->InheritsFrom( TPad::Class() ) )

        ReplacePad( (TPad*)obj, (TPad*)objOld );

      else if ( obj->InheritsFrom( TH1::Class() ) 
                && objOld
                && objOld->InheritsFrom( TH1::Class() ) ) {

        TH1 *histo;
        TH1 *histoOld = (TH1*)objOld;

        if ( cobj && cobj->InheritsFrom( CHistogram::Class() ) ) {
          CHistogram *chisto = (CHistogram*)cobj;
          //chisto->SetTObject( obj );
          histo = chisto->SubtractedHisto();
        } //if ( cobj && cobj->InheritsFrom( CHistogram::Class() ) )
        else {
          histo = (TH1*)( obj->Clone() );
        } //else //if ( cobj && cobj->InheritsFrom( CHistogram::Class() ) )

        if ( histo && histoOld
             && ! obj->IsEqual( objOld )  ) {
          //tmp
          if ( ! oldpad->GetPadPaint() ) {

            histoOld->Reset();
            histoOld->Add( histo );

            TAxis *xaxis = histo->GetXaxis();
            if ( xaxis ) {
              char *title = new char[ strlen( xaxis->GetTitle() ) + 1 ];
              strcpy( title, xaxis->GetTitle() ); 
              histoOld->SetXTitle( title );
              delete [] title;
            } //if ( xaxis )
            TAxis *yaxis = histo->GetYaxis();
            if ( yaxis ) {
              char *title = new char[ strlen( yaxis->GetTitle() ) + 1 ];
              strcpy( title, yaxis->GetTitle() ); 
              histoOld->SetYTitle( title );
              delete [] title;
            } //if ( yaxis )
            TAxis *zaxis = histo->GetZaxis();
            if ( zaxis ) {
              char *title = new char[ strlen( zaxis->GetTitle() ) + 1 ];
              strcpy( title, zaxis->GetTitle() ); 
              histoOld->SetZTitle( title );
              delete [] title;
            } //if ( zaxis ) 

            delete histo;
            oldpad->Modified();

          } //if ( ! oldpad->GetPadPaint() )
          else
            cout << " Pad is being painted. Not updated. " << endl;

        } //if ( histo && histoOld )

      }  //else if ( obj->InheritsFrom( TH1::Class() ) && 

      //tmp
      // Should be comment out the following to avoid double TFrames.
      else {

        if ( !( frame->IsEqual( obj ) ) ) {

          //tmp
          if ( objOld ) {
               //&& !obj->IsEqual(objOld) ) {
            TObject *objtmp = oldPrimitiveList->Remove( objOld );
            if ( objtmp ) delete objOld;
          } //if ( objOld ) 

          oldpad->cd();
          obj->Clone()->Draw();
          oldpad->Modified();

        } //if ( !( frame->IsEqual( obj ) ) )

      } //else //if ( obj->InheritsFrom( TPad::Class() ) &&

  } //while ( obj = next() )


}
 






void HistoDisplay::ClearCurrentPad() {

  //cout << " In ClearCurrentPad " << endl; 

  //TPad *padsav = (TPad*) gPad;
  TPad *pad = (TPad*)gROOT->GetSelectedPad();

  if ( !pad ) return;

  //pad->Clear();
  RecursivePadClear( pad );
  pad->cd();

  
  /*
    if ( pad != pad->GetCanvas() ) {
    pad->SetName("VOID");
    }
  */
  pad->SetName("VOID");

  pad->SetTitle("Cleared");

  pad->Modified();
  pad->Update();
  //padsav->cd();

  //cout << "Cleared " << endl;

}






CObject* HistoDisplay::
UpdateHistoList(const char* objName, const TObject *inputobj )
{
  //cout << " In UpdateHistoList " << endl;
  //cout << " updating " << objName << endl;

  /*
  if ( !inputobj ) {
    cout << " Input Object is not set. " << endl; 
    return 0;
  }
  */

  //const char *path = gROOT->GetPath(); 
  TVirtualPad *padsav = 0;
  if ( gPad && !gROOT->GetListOfCanvases()->IsEmpty() ) padsav = gPad;



  TObject *obj = GetNewObj( objName, inputobj );
  CObject *cobj = 0; 

  if ( obj ) {

    TObject *objold = fDisplayedList->FindObject( objName );

    /*
    TObjLink *lnk = fDisplayedList->FirstLink();
    while (lnk) {
      TObject *objtmp = lnk->GetObject();
      if (objtmp && 
          objtmp->GetName() && !strcmp(objName, objtmp->GetName())) {

        if ( objtmp->InheritsFrom( CObject::Class() ) ) {
          CObject *cobjtmp = (CObject*)objtmp;
          TObject *inputtmp = cobjtmp->GetInputSource();
          if ( ( inputtmp && inputtmp->GetName() ) &&
               ( inputobj && inputobj->GetName() ) &&
               ( !strcmp( inputtmp->GetName(),
                          inputobj->GetName() ) ) ) {
            //objold = objtmp;
            cobj = cobjtmp;
            cobj->SetTObject( obj );
            if ( cobj->GetInputSource() != inputobj )
              cobj->SetInputSource( inputobj );
              
          } //if ( ( inputtmp && inputtmp->GetName() ) &&


        }//if ( objtmp->InheritsFrom( CObject::Class() ) ) 


      } //if ( objtmp && objtmp->GetName() && ... )

      lnk = lnk->Next();
    } //while (lnk) 

    */


    if ( objold && objold->InheritsFrom( CObject::Class() ) ) {

      cobj = (CObject*) objold;

      if ( cobj ) {
        cobj->SetTObject( obj );
        //if ( cobj->GetInputSource() != inputobj )
        if ( inputobj != cobj->GetInputSource()  ) {
          cobj->SetInputSource( inputobj );
          //tmp
          //cout << " InputObj is updated. " << endl;
        } // if ( inputobj != cobj->GetInputSource()  )  
      } // if ( cobj )

    } //if ( objold && objold->InheritsFrom( CObject::Class() ) )

    else {

      //if ( !cobj ) {

      if ( obj->InheritsFrom(TH1::Class()) ) {

        CHistogram *cobjnew =
          new CHistogram( (TH1*)obj, inputobj, 0, 0 );

                        fDisplayedList->Add( cobjnew );

        cobj = cobjnew;

      } //if ( obj->InheritsFrom(TH1::Class()) )
      else {

        CObject *cobjnew =
          new CObject( obj, inputobj );

                        fDisplayedList->Add( cobjnew );

        cobj = cobjnew;

      } // else //if ( obj->InheritsFrom(TH1::Class()) )

      //} // if ( !cobj ) 


    } //else //if ( objold && objold->InheritsFrom( CObject::Class() ) )

        if ( obj->InheritsFrom( TPad::Class() ) )
        AddPadHistosToHistoList( (TPad*)obj );

  } //if ( obj )

  else {

    //tmp
    /*
    if ( objold && objold->InheritsFrom( CObject::Class() ) ) 
      cobj = (CObject*) objold;
    */
    //tmp
    //cout << " obj is not got from the input stream. " << endl;

  } //else //if(obj)

  //tmp
  if ( !cobj ) cout << " Not updated. " << endl;


  //gROOT->Cd( path );
  if ( padsav ) padsav->cd(); 


  return cobj;

}



void HistoDisplay::AddPadHistosToHistoList( TPad *pad )
{
  //cout << " In AddPadHistosToHistoList " << endl; 

  if ( !pad ) return;

  TObjLink *link = pad->GetListOfPrimitives()->FirstLink();

  while ( link ) {

    TObject *obj = link->GetObject();

    if ( obj ) {

      if ( obj->InheritsFrom( TPad::Class() ) ) 
        AddPadHistosToHistoList( (TPad*)obj ); 

      else if ( obj->InheritsFrom( TH1::Class() ) ) {

        TObject *objold = fDisplayedList->FindObject( obj->GetName() );

        if ( objold && objold->InheritsFrom( CObject::Class())  ) {

          CObject *cobj = (CObject*)objold;
          //cobj->SetTObject( obj );
          cobj->SetTObject( obj->Clone() );

        } //if ( objold && objold->InheritsFrom( CObject::Class()) )
        else {

          CHistogram *cobjnew =
            //new CHistogram( (TH1*)obj, 0, 0, 0 );
            new CHistogram( (TH1*)obj->Clone(), 0, 0, 0 );

                  fDisplayedList->Add( cobjnew );

        } //else //if ( objold && objold->InheritsFrom( CObject::Class()) ) )

      } //else if ( obj->InheritsFrom( TH1::Class() ) )

    } //if ( obj ) 

    link = link->Next();

  } //while ( link )

  //cout << " End of AddPadHistosToHistoList " << endl; 

}



TObject* HistoDisplay::
GetNewObj(const char* objName, const TObject* inputobj)
{
  //cout << " In GetNewObj" << endl;

  TObject *obj = 0;

  if (inputobj) {

    if ( inputobj->IsA() == TMapFile::Class() )   {
      TMapFile *mfile = (TMapFile*)inputobj;
      if (mfile) obj = (TObject*)mfile->Get( objName );
    }
    else if ( inputobj->IsA() == TFile::Class() )   {
      TFile *rfile = (TFile*)inputobj;
      if (rfile) obj = (TObject*)rfile->Get( objName );
    }
    else if ( inputobj->IsA() == TSocket::Class() )   {
      TSocket *socket = (TSocket*)inputobj;

      if ( socket && socket->IsValid() ) {

        Int_t count = 0;
        Int_t maxcount = 8; 

        while ( !obj && count < maxcount ) {

          socket->Send( objName );
          TMessage *message = NULL;

          Int_t resRecv;
          resRecv = socket->Recv(message);
          //cout << "resRecv: " << resRecv << endl;
          if (resRecv == -1) {
            cerr << " HistoDisplay: ERROR:"
                 << " Socket->Receive failed. resRecv = " << resRecv << ".\n" 
                 << "    ==> Closing the socket connection." << ".\n"
                 << "    ==> Please open again. "
                 << endl;
            socket->Close();
            Running = kFALSE;
            fReadFileButton->ChangeBackground(Red);  
            //  cout << "Button changed to red\n";
            gClient->NeedRedraw(fReadFileButton);
            count = maxcount;      // Stop the request loop
          } //if (resRecv == -1)
          else {
            if (message) {
              if (message->What() == kMESS_OBJECT) {
                obj = (TObject*)message->ReadObject(message->GetClass());
                // The following was added: //2001/01/16 Wolfgang Wagner
                if (obj) {
                  if (TString(obj->GetName()) != TString(objName))
                    cerr << "ERROR: Got object: " << obj->GetName()
                          << " but requested " << objName << "." << endl;
                }
              }
              else {
                if (message->What() == kMESS_STRING) {          
                  int messLength = message->BufferSize() + 10; 
                  char* keyString = new char[messLength];
                  message->ReadString(keyString,messLength);                  
                  string serverString(keyString);
                  delete keyString;
                  keyString = 0;
                  // We got a message string from Display Server 
                  // indicating a special request.
                  // Now we need to decode the string.
                  // The key strings are defined in ServerProtocol.hh
                  //
                  bool localDebug = false;
                  if (localDebug) {
                    cout << "HistoDisplay: got string: " << serverString
                         << "." << endl;
                  } 
                  if (serverString == DspEndConnection) {
                    cout << "HistoDisplay: The Display Server ended the "
                         << "connection." << endl;
                    count = maxcount;
                    socket->Close();
                    Running = kFALSE;
                    fReadFileButton->ChangeBackground(Red); 
                    // cout << "Button changed to red\n";            
                    gClient->NeedRedraw(fReadFileButton);
                    fChButtonSlideUpdate->SetState(kButtonUp);
                    SlideShowUpdate = kFALSE;
                  }
                  if (serverString == DspObjectNotFound) {
                    cerr << "HistoDisplay: The requested object '"
                         << objName << "' is not available from the "
                         << endl;
                    cerr << "Display Server." << endl;
                    count = maxcount;                      
                  }
                  if (serverString == DspRequestNewInfo) {
                    if (localDebug) {
                      cout << "HistoDisplay: The Display Server suggests "
                           << "to request the TConsumerInfo." << endl;
                    }  
                    //TConsumerInfo* locInfo = MakeConsumerInfo(socket); 
                    //DelTreeItemsOfInput( socket );
                    AddTreeItemsOfInput( socket );
                    RefreshTreeItem( fHistoListTree->GetFirstItem() );
                    SearchWarningErrorFolder
                      ( fHistoListTree->GetFirstItem(), socket );
                    fClient->NeedRedraw( fHistoListTree );
                  }
                } 
              }
            }
          } //else //if (resRecv == -1)

          delete message;
          count++;
        } //while ( !obj && count < maxcount )

        if ( ! obj ) {
          cout << " Failed to get " << objName << endl;
        fReadFileButton->ChangeBackground(Red);
        gClient->NeedRedraw(fReadFileButton);
        fChButtonSlideUpdate->SetState(kButtonUp);
        SlideShowUpdate = kFALSE;
        //      cout << "Button changed to red\n";
        } //if ( ! obj )
        else {
          if ( count > 1 ) cout << " The object " << objName 
                                << " is sent from the socket by " << count
                                << " tries." << endl;
        } //else of if ( ! obj )

      } //if ( socket && socket->IsValid() )
      else {
        cout << "no connection to socket..."
             << socket->GetName() << endl;
        Running = kFALSE;
        fReadFileButton->ChangeBackground(Red);
        gClient->NeedRedraw(fReadFileButton);
        fChButtonSlideUpdate->SetState(kButtonUp);
        SlideShowUpdate = kFALSE;
        //   cout << "Button changed to red\n";
      } //else //if ( socket && socket->IsValid() )

    } // TMapFile,TFile, TSocket 
    else {

      cout << " No inputobj " << endl;

    } //else // TMapFile,TFile, TSocket

  } // if(inputobj)

  //tmp
  //if ( !obj ) cout << " No object found " << endl;

  return obj;

}







void HistoDisplay::AddSubtractHisto( TVirtualPad *currentPad , int option)
{
  // Zero or Restore all histos on the currentPad.
  // int option = 0    ; unzero
  //            = else ;   zero 

  // cout << " In AddSubtractHisto" << endl;

  if (!currentPad) return;

  TList *primitiveList = currentPad->GetListOfPrimitives();
  TIter next(primitiveList);
  TObject *obj = 0;

  while ( ( obj = next() ) ) {
    if ( obj->InheritsFrom(TPad::Class()) ) {

      AddSubtractHisto( (TPad*)obj , option);

    } //if ( obj->InheritsFrom(TPad::Class()) )
    else {

      if ( obj->InheritsFrom(TH1::Class()) ) {

        TObject *obj2 = 
          fDisplayedList->FindObject(obj->GetName());

        if( obj2 && obj2->InheritsFrom(CHistogram::Class()) ) {

          CHistogram *chisto = (CHistogram*)obj2;
          TH1 *histo = (TH1*) chisto->GetTObject();

          if (option) {
            if (histo) chisto->SetSubtractHisto( histo );
          } //if (option)
          else {
            chisto->SetSubtractHisto(0);
          } //else //if (option)


        }//if( obj2 && obj2->InheritsFrom(CHistogram::Class()) )


      } //if ( obj->InheritsFrom(TH1::Class()) )


    } //else//if ( obj->InheritsFrom(TPad::Class()) )


  } //while ( obj = next() )

}



TH1* HistoDisplay::HistoInPad( TVirtualPad *pad, Int_t &counthisto ) 
{
  //cout << " In HistoInPad " << endl;

  if ( !pad ) return 0;

  TList *primitiveList = pad->GetListOfPrimitives();
  TIter next( primitiveList );

  TH1 *histo = 0;

  TObject *obj;
  while ( ( obj = next() ) && ( counthisto <= 1 ) ) {

    if ( obj->InheritsFrom( TH1::Class() ) ) {
      counthisto++ ;
      if ( counthisto == 1 ) histo = (TH1*)obj;
    } //if ( obj->InheritsFrom( TH1::Class() ) )

    if ( obj->InheritsFrom( TPad::Class() ) )
      histo = HistoInPad( (TPad*)obj , counthisto );

  } //while ( ( obj = next() ) && ( counthisto <= 1 ) )

  if ( counthisto >= 2 ) return 0;

  return histo;

}




void HistoDisplay::DrawContentHisto(TH1* histo)
{
  //cout << " In DrawContentHisto" << endl;
  if ( !histo ) return;

  DrawOnTheCanvas( "ContentHistoCanvas", "Bin-Content Histogram Canvas",
                   300, 300,
                   ContentHisto(histo) ) ;
}



TH1F* HistoDisplay::ContentHisto( TH1* histo )
{
  //cout << " In ContentHisto" << endl;
  if (!histo) return 0;

  float min, max;
  min = histo->GetMinimum();
  max = histo->GetMaximum();

  if ( min == max ) return 0;

  int nbin;
  nbin = 50;
  float binsize;
  binsize = (max - min)/nbin;

  TH1F* contenthisto = 
    new TH1F("BinContenHisto", histo->GetTitle(), nbin,
            min - 2*binsize, max + 2*binsize );
  // oldone is removed by canvas->Clear() in DrawOntheCanvas.

  contenthisto->SetXTitle("Hits in a bin");
  contenthisto->SetYTitle("Number of bins");

  Int_t nbinsx = histo->GetNbinsX();
  Int_t nbinsy = histo->GetNbinsY();
  Int_t nbinsz = histo->GetNbinsZ();


   Int_t bin, binx, biny, binz;
   double content;
   for (binz=0;binz<=nbinsz+1;binz++) {
     for (biny=0;biny<=nbinsy+1;biny++) {
       for (binx=0;binx<=nbinsx+1;binx++) {
            bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz);
            content = histo->GetBinContent(bin);
            if (content) contenthisto->Fill(content);
       }
     }
   }

   return contenthisto;
}


void HistoDisplay::DrawOnTheCanvas(
 const char* canvasname, const char* canvastitle, int padx, int pady, 
 TObject *obj )
{
  //cout << " In DrawOnTheCanvas" << endl;
  if (!obj) return;

  TPad *padsav  = (TPad*)gPad;

  TCanvas *canvas;

  canvas = 
    (TCanvas*) ( gROOT->GetListOfCanvases()->FindObject( canvasname ) );

  if (!canvas) {
    canvas = new TCanvas( canvasname, canvastitle, padx, pady);
  }
  else {
    //canvas->SetWindowSize( padx, pady);
    canvas->cd();
    canvas->Clear();
  } //if (!canvas)

  obj->Draw();

  canvas->Modified();
  canvas->Update();

  padsav->cd();

}



void HistoDisplay::PrintCanvas( TPad *canvas )
{
  //cout << " In PrintCanvas " << endl;
  // From TGTextEdit.cxx
    Int_t ret;
    static char *gPrinter = 0;
    static char *gPrintCommand = 0;

    if (!gPrinter) {
      //gPrinter = StrDup(""); // use gEnv
      //gPrintCommand = StrDup("lpr");
      gPrinter = StrDup("157-ept7-hp"); // use gEnv
      gPrintCommand = StrDup("xprint -h -P");
    } //if (!gPrinter)

    //unused    TGPrintDialog *printdialog =
    //      new TGPrintDialog( fClient->GetRoot(), this, 400, 150,
    //          &gPrinter, &gPrintCommand, &ret );

    if ( ret ) {
      if ( canvas ) {

        const char *canvasname = canvas->GetName();

        char *msg = 0;
        if ( strlen( gPrinter ) ) {
          /*
          msg = new char[ strlen( gPrintCommand ) + 3 + strlen( gPrinter ) 
                        + 1 + strlen( canvasname ) + 4 + 1 ];
          sprintf( msg, "%s -P%s %s.ps\n", gPrintCommand,
                   gPrinter, canvasname );
          */
          msg = new char[ strlen( gPrintCommand ) + 1 + strlen( gPrinter ) 
                        + 1 + strlen( canvasname ) + 6 + 1 ];
          sprintf( msg, "%s %s \"%s.ps\"\n", gPrintCommand,
                   gPrinter, canvasname );

        } //if ( gPrinter )
        else {
          msg = new char[ strlen( gPrintCommand )
                        + 1 + strlen( canvasname ) + 6 + 1 ];
          sprintf( msg, "%s \"%s.ps\"\n", gPrintCommand, canvasname );  
        } //else //if ( gPrinter ) 


        canvas->Print( 0, "ps" );

        cout << msg << endl;
        gSystem->Exec( msg );

        if ( msg ) delete [] msg;

      } //if ( canvas )
    } //if (ret)

    // do not need delete printdialog
    // because done by closing the windown.
}


void HistoDisplay::CloseWindow()
{
  gApplication->Terminate(0);

}

void HistoDisplay::ResetObjects()
{
  //cout << " In ResetObjects " << endl;

  RemoveTGListTree();

  if ( fDisplayedList ) fDisplayedList->Delete();

  CloseConnection();
}


HistoDisplay::~HistoDisplay()
{

  ResetObjects();

  delete fHistoList;
  delete fDisplayedList;
  delete fSlideCanvasList;

  delete fUpdateTimer;
  delete fSlideTimer;

  CloseMenuBar();
  CloseTitleFrame();
  CloseTGListTreeFrame();
  CloseInputFrame();
  CloseStatusBar();

  delete fMainFrame;
  delete fMainFrameLayout;
}


void HistoDisplay::MenuConnectStatus()
{

        TGTransientFrame *fTransientFrame;
        fTransientFrame =
          new TGTransientFrame(gClient->GetRoot(), this, 500, 200);
        TGLayoutHints *fLayout;
        fLayout =
          new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0);

        TGTextView *fTextView;
        fTextView =
          new TGTextView( fTransientFrame, 600, 200);
                          //,kSunkenFrame | kDoubleBorder );

        TString StatusTxt = "\n";
        consumerlist->readWebPage();
        ostrstream ostr;
        consumerlist->print(ostr);
        ostr << ends;
        StatusTxt.Append(ostr.str());


        if ( fTextView->LoadBuffer( StatusTxt.Data() ) ) {
          fTextView->MapWindow();
        }
        else {
          cout << " Failed to load Socket status text info."  << endl;
        }

        fTransientFrame->AddFrame(fTextView,fLayout);
        fTransientFrame->SetWindowName("Connection Status");
        fTransientFrame->MapSubwindows();
        fTransientFrame->MapWindow();

}


//Help menu contents modified by Koji (2000/04/19)

void HistoDisplay::MenuHelp(const char *s, const char *helpText)
{
  //cout << " In MenuHelp " << endl;

  TRootHelpDialog  *fHelpDialog;
  fHelpDialog =
    new TRootHelpDialog( this, s, 500, 400);
  {
    fHelpDialog->SetText(helpText);
    fHelpDialog->Popup();
  }
}

void HistoDisplay::MessageBox(const char *msg)
{
  //cout << " In MessageBox " << endl;

        int retval;

        EMsgBoxIcon icontype = kMBIconExclamation;
        //Int_t buttons = kMBOk;
        int buttons = kMBOk;

        new TGMsgBox(fClient->GetRoot(), this, "WARNING", msg, 
                     icontype, buttons, &retval);
}


// Choose File Name buttons. --

const char* HistoDisplay::FileDialogWindow()
{ 

  //const char *filetypes[] = { "All files",     "*",
  //                  "ROOT files",    "*.root",
  //                  "MAP files",     "*.map",
  //                  0,               0 };


  static TGFileInfo fi;
  //fi.fFileTypes = (char **)filetypes;


  //EInputTypes inputtype;

  if ( fRaButMFile->GetState() == kButtonDown ) {
    //inputtype = kTMapFile;
    const char* filetypes[] = { "MAP files",     "*.map",
                    "All files",     "*",
                    "ROOT files",    "*.root",
                    0,               0 };
    fi.fFileTypes = (const char **)filetypes;
  }
  else if ( fRaButRFile->GetState() == kButtonDown ) {
    //inputtype = kTFile;
    const char* filetypes[] = {"ROOT files",    "*.root",
                   "All files",     "*",
                   "MAP files",     "*.map",
                   0,               0 };
    fi.fFileTypes = (const char **)filetypes;
  }
  else if ( fRaButSocket->GetState() == kButtonDown ) {
    //inputtype = kTSocket;
    const char* filetypes[] = { "All files",     "*",
                    "ROOT files",    "*.root",
                    "MAP files",     "*.map",
                    0,               0 };
    fi.fFileTypes = (const char **)filetypes;
  }



  new TGFileDialog(gClient->GetRoot(), gClient->GetRoot(), kFDOpen, &fi);

  return fi.fFilename;
}

void HistoDisplay::FileNameClear()
{
  //cout << " In File Name Clear " << endl;
  fFileNameBuffer->Clear();
  fFileNameTextEntry->SetState(kTRUE);
}

//--



Bool_t HistoDisplay::ProcessMessage(Long_t msg, Long_t parm1, Long_t /*parm2*/)
{

  //cout << " In ProcessMessage " << endl;

  //static TObject *inputobj = 0;
  //TObject *inputobj2 =0;
  TPad *gpad = 0;

  switch ( GET_MSG(msg) ) {
  case kC_COMMAND:
    switch ( GET_SUBMSG(msg) ) {
    case kCM_MENU:
      switch ( parm1 ) {
      case kM_MENU_FILE_NEWGUI:
        new HistoDisplay(gClient->GetRoot(), 200, 400, fsocketserver, fport);
        break;
      case kM_MENU_FILE_NEWCANVAS:
        //gROOT->GetMakeDefCanvas()();
        {
          CanvasNumber++;
          char *num = new char[3];
          sprintf( num, "%d", CanvasNumber);
          TCanvas *CurrentCanvas =
            new TCanvas( CanvasName + TString( num ),
                         CanvasTitle + TString( num) , 500, 500 );
          delete num;
          CurrentCanvas->cd();
        }
        break;
      case kM_MENU_FILE_NEWSLIDE:
        {
          static int i = 0;
          i++;
          //TString name = "MINOSSlideShowCanvas";
          //TString title = "MINOS Slide Show Canvas ";
          TString name = "AutoUpdateCanvas";
          TString title = "Auto Update Canvas ";
          char *num = 0;
          num = new char[ 3 ];
          sprintf( num, "%d", i );
          name = name + TString( num );
          title = title + TString( num );
          delete num;
          //tmp
          //cout << name << " " << title << endl; 
          TCanvas *slideCanvas = new TCanvas( name, title, 500, 500 );
          slideCanvas->cd();
          if ( fSlideCanvasList ) {
            if ( !( fSlideCanvasList->IsEmpty() ) )  {
              TObjLink *link = fSlideCanvasList->FirstLink();
              while ( link ) {
                TObject *obj = 0;
                obj = link->GetObject();
                link = link->Next();
                if ( !obj ||
                     !( gROOT->GetListOfCanvases()->FindObject( obj ) ) )
                  fSlideCanvasList->Remove( obj );
              } //while ( link )
            } //if ( !( fSlideCanvasList->IsEmpty() )
            fSlideCanvasList->Add( slideCanvas );
          } //if ( fSlideCanvasList )
        } //{
        break;
      case kM_MENU_FILE_CLOSE:
        // Do not know how to close one window.
        DestroyWindow(); // in TGWindow
        //cout << " Sorry. Not yet. " << endl;
        break;
      case kM_MENU_FILE_EXIT:
        Running = kFALSE;
        fReadFileButton->ChangeBackground(Red);
        //  cout << "Button changed to red\n";
        fChButtonSlideUpdate->SetState(kButtonUp);
        SlideShowUpdate = kFALSE;         
        gClient->NeedRedraw(fReadFileButton);

        ResetObjects();

        CloseWindow();
        break;
      case kM_MENU_LISTTREE_SORTTREE:
        SortTGListTree();
        break;
      case kM_MENU_LISTTREE_SORTFOLDER:
        if ( fSelectedItem ) {
          fHistoListTree->SortChildren(fSelectedItem);
          fClient->NeedRedraw(fHistoListTree);
        }
        break;
      case kM_MENU_LISTTREE_DELETE:
        if ( fSelectedItem ) {
          CObject *cobj = 
            (CObject*) fDisplayedList
            ->FindObject(fSelectedItem->GetText()); 

          if ( fDisplayedList->Remove( cobj ) ) delete cobj;

          fHistoListTree->DeleteItem(fSelectedItem);
          fClient->NeedRedraw(fHistoListTree);
        }
        fSelectedItem = 0;
        break;
      case kM_MENU_LISTTREE_CLEAR:

        if ( fDisplayedList ) fDisplayedList->Clear();
        RemoveTGListTree();
        break;
      case kM_MENU_LISTTREE_REFRESH:

        if ( fSelectedItem )
          RefreshTreeItem( fSelectedItem );
        else
          RefreshTreeItem( fHistoListTree->GetFirstItem() );

        break;
        /*
      case kM_MENU_CONNECT_MON1:
        cout << " Sorry. Not yet implemented. " << endl;
        break;
      case kM_MENU_CONNECT_MON2:
        cout << " Sorry. Not yet implemented. " << endl;
        break;
      case kM_MENU_CONNECT_MON3:
        cout << " Sorry. Not yet implemented. " << endl;
        break;
      case kM_MENU_CONNECT_MON4:
        cout << " Sorry. Not yet implemented. " << endl;
        break;
      case kM_MENU_CONNECT_MON5:
        cout << " Sorry. Not yet implemented. " << endl;
        break;
        */

      case kM_MENU_CONNECT_STATUS:
        MenuConnectStatus();
        break;

      case kM_MENU_HELP_GUI:
        MenuHelp("Help on this GUI...", gHelpHistoDisplay);
        break;

      case kM_MENU_HELP_ROOT:
        MenuHelp("Help on ROOT...", gHelpAbout);
        break;

      case kM_MENU_HELP_CANVAS:
        MenuHelp("Help on Canvas...", gHelpCanvas);
        break;
      } // switch( parm1 )
      break; //kCM_MENU


    case kCM_BUTTON:
      switch ( parm1 ) {

      case kM_PICTBUTTON:
        //PopupWindow();
        new PhotoWindow(fClient->GetRoot(), this, 400, 500);
        break;


      case kM_BUTTON_FILENAME:
        {

          // dp : reset first

          fReadFileButton->SetState(kButtonUp);
          fReadFileButton->ChangeBackground(Red);
          fChButtonSlideUpdate->SetState(kButtonUp);
          SlideShowUpdate = kFALSE;
          // cout << "Button changed to red\n";   
            gClient->NeedRedraw(fReadFileButton);
          Running = kFALSE;

          fSelectedItem = 0;

          ResetObjects();

          // Delete and Remove files, socket, and lists, ListTrees --
          if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) ) {
            TCanvas *CurrentCanvas = 0;
            CurrentCanvas = gPad->GetCanvas();
            if ( CurrentCanvas ) {
              //CurrentCanvas->Clear();
              RecursivePadClear( CurrentCanvas );
              CurrentCanvas->cd();
              CurrentCanvas->Modified();
              CurrentCanvas->Update();
            } //if ( CurrentCanvas )
          } //if ( gPad && !( gROOT->GetCanvasList()->IsEmpty() ) )





          FileName = TString( fFileNameBuffer->GetString() );

          EInputTypes inputtype;

          if ( fRaButMFile->GetState() == kButtonDown )
            inputtype = kTMapFile;
          else if ( fRaButRFile->GetState() == kButtonDown )
            inputtype = kTFile;
          else if ( fRaButSocket->GetState() == kButtonDown )
            inputtype = kTSocket;

          //InputObj = OpenFile( FileName.Data(), inputtype, "READ" );
          TObject *InputObj = OpenFile( FileName.Data(), inputtype, "READ" );


          //if ( InputOpen ) {
          if ( InputObj ) {

            AddTreeItemsOfInput( InputObj );
            //RefreshTreeItem( fHistoListTree->GetFirstItem() );
            fClient->NeedRedraw( fHistoListTree );
            fReadFileButton->ChangeBackground(Green);
            // cout << "Button changed to green\n";
            // cout << "Opened file\n";
            gClient->NeedRedraw(fReadFileButton);
            //    fMainFrame->Update();

            char* str = new char[ 9 + FileName.Length() ];
            strcpy(str, " Opened ");
            fStatusBar
              ->SetText( strcat(str, FileName.Data()), 1);
            delete [] str;
          } //if ( InputObj ) 
          else {

            //if ( inputtype == kTMapFile && !InputOpen ) {
            if ( inputtype == kTMapFile ) {
              const char *sg = "Failed to open memory map file.";
              MessageBox(sg);
            }
            //else if ( inputtype == kTFile && !InputOpen ) {
            else if ( inputtype == kTFile ) {
              const char *sg = "Failed to open ROOT file.";
              MessageBox(sg);
            }
            //else if ( inputtype == kTSocket && !InputOpen ) {
            else if ( inputtype == kTSocket ) {
              const char *sg = "Failed to open the socket connection.";
              MessageBox(sg);
            }

            char* str = new char[16+FileName.Length()];
            str = strcpy(str," Error Opening ");
            fStatusBar
              ->SetText( strcat(str, FileName.Data()), 1);
            delete [] str;
          }
        }

        break;


      case kM_BUTTON_CHOOSEFILE:
        if( (fRaButMFile->GetState() == kButtonDown) ||
            (fRaButRFile->GetState() == kButtonDown) ) {

          const char *file = FileDialogWindow(); 
          if ( file ){ 

            fFileNameBuffer->Clear();

            // Older version of  ROOT.
            /*
            char s[80] = "";
            strcat(s, gSystem->WorkingDirectory()); 
            strcat(s, "/"); 
            strcat(s, file); 

            fFileNameBuffer->AddText(0, s);
            */

            fFileNameBuffer->AddText(0, file);

            gClient->NeedRedraw(fFileNameTextEntry);

            //T.A
            delete [] file;
          }

        }

        break;
            
      case kM_BUTTON_CLEARFILENAME:

        FileNameClear();

        break;

        /*
      case kM_BUTTON_START:

        MonitorName = TString( fMonitorNameBuffer->GetString() );

        HistoDisplayMain();
        //inputobj2 = inputobj;
        //HistoDisplayMain( inputobj2 );

        //tmp
        //fReadFileButton->SetState(kButtonUp);

        //tmp
        //fStartHistoButton->SetState(kButtonDisabled);
        fStopHistoButton->SetState(kButtonUp);

        fClearHistoButton->SetState(kButtonUp);

        fPrintHistoButton->SetState(kButtonUp);

        fZeroHistoButton->SetState(kButtonUp);
        fUnZeroHistoButton->SetState(kButtonUp);
        fContentHistoButton->SetState(kButtonUp);


        break;
        */

      case kM_BUTTON_PAUSE:

        if ( Running ) {
          fPauseHistoButton->SetState( kButtonDisabled );
          fRestartHistoButton->SetState( kButtonUp );
          Running = kFALSE;
        } //if ( Running )



        break;
      case kM_BUTTON_CLEAR:

        ClearCurrentPad();
        break;

      case kM_BUTTON_PRINT:

        if ( gPad || !( gROOT->GetListOfCanvases()->IsEmpty() ) ) {
          //PrintCanvas( gPad->GetCanvas() );
          PrintCanvas( (TPad*)gPad );
        }//if ( gPad || !( gROOT->GetListOfCanvases()->IsEmpty() ) ) 
          
        break;

      case kM_BUTTON_RESTART:

        if ( fSelectedItem ) {
          /*
          if ( strstr( fSelectedItem->GetText(), "slide" ) ||
               strstr( fSelectedItem->GetText(), "Slide" ) ||
               strstr( fSelectedItem->GetText(), "SLIDE" ) ) {
          */
          if ( strstrn( fSelectedItem->GetText(), kSlideShowFolder ) ) {

            StartSlides( fSelectedItem );

          } //if ( strstr( fSelectedItem->GetText() ) ||

          else {

            if ( AutoUpdate ) {
              fPauseHistoButton->SetState( kButtonUp );
              fRestartHistoButton->SetState( kButtonDisabled );
              UpdateTimerOn();
            } // if ( AutoUpdate ) {
            else {
              UpdateCanvas();
            } //else //if ( AutoUpdate ) {

          } //else // if ( strstr( fSelectedItem->GetText(), "slide" ) ||

        } //if( fSelectedItem )  

        break;
      case kM_BUTTON_ZERO:

        gpad = (TPad*)gPad;
        AddSubtractHisto(gpad, 1);

        UpdateCanvas();



        break;
      case kM_BUTTON_UNZERO:

        gpad = (TPad*)gPad;
        AddSubtractHisto(gpad, 0);
        UpdateCanvas();

        break;
      case kM_BUTTON_CONTENT:
        /*
        if ( fSelectedItem ) {
          TObject *obj = 
            fDisplayedList->FindObject( fSelectedItem->GetText() );
          if ( obj && obj->InheritsFrom(CHistogram::Class()) ) {
            TH1 *histo =
              (TH1*) ( ((CHistogram*)obj)->SubtractedHisto() );
            //TH1 *histo =  ( (CHistogram*)obj )->GetHistoDrawn();

            DrawContentHisto( histo );
            delete histo;
          }
        }
        */

        gpad = (TPad*)gPad;
        if ( gpad ) {

          Int_t counthisto = 0;
          TH1 *histo = HistoInPad( gpad , counthisto );
          if ( counthisto == 1 ) DrawContentHisto( histo ); 
          else if ( counthisto >= 2 )
            cout << " Select one histo on canvas. " << endl;

        } //if ( gpad )


        break;

      case kM_BUTTON_CANVAS:
        {
          static int i = 0;
          i++;
          //TString name = "MINOSSlideShowCanvas";
          //TString title = "MINOS Slide Show Canvas ";
          TString name = "AutoUpdateCanvas";
          TString title = "Auto Update Canvas ";
          char *num = 0;
          num = new char[ 3 ];
          sprintf( num, "%d", i );
          name = name + TString( num );
          title = title + TString( num );
          delete num;
          //tmp
          //cout << name << " " << title << endl; 
          TCanvas *slideCanvas = new TCanvas( name, title, 500, 500 );
          slideCanvas->cd();
          if ( fSlideCanvasList ) {
            if ( !( fSlideCanvasList->IsEmpty() ) )  {
              TObjLink *link = fSlideCanvasList->FirstLink();
              while ( link ) {
                TObject *obj = 0;
                obj = link->GetObject();
                link = link->Next();
                if ( !obj ||
                     !( gROOT->GetListOfCanvases()->FindObject( obj ) ) )
                  fSlideCanvasList->Remove( obj );
              } //while ( link )
            } //if ( !( fSlideCanvasList->IsEmpty() )
            fSlideCanvasList->Add( slideCanvas );
          } //if ( fSlideCanvasList )
        } //{
        break;

      case kM_BUTTON_STOP:

        cout << "Pressed RESET\n";
        /*
        fPauseHistoButton->SetState(kButtonDisabled);
        fRestartHistoButton->SetState(kButtonDisabled);
        fZeroHistoButton->SetState(kButtonDisabled);
        fUnZeroHistoButton->SetState(kButtonDisabled);
        fContentHistoButton->SetState(kButtonDisabled);
        fStopHistoButton->SetState(kButtonDisabled);
        */

        if (fUpdateTimer) {fUpdateTimer->TurnOff();}
        if (fSlideTimer) {fSlideTimer->TurnOff();}

        if ( Running ) {
          fPauseHistoButton->SetState( kButtonDisabled );
          fRestartHistoButton->SetState( kButtonUp );
          Running = kFALSE;
        }

;

        fReadFileButton->SetState(kButtonUp);
          fReadFileButton->ChangeBackground(Red);
          // cout << "Button changed to red\n";  
            gClient->NeedRedraw(fReadFileButton);
            fChButtonSlideUpdate->SetState(kButtonUp);
            SlideShowUpdate = kFALSE;
        Running = kFALSE;

        fSelectedItem = 0;

        ResetObjects();

        fHistoListTree->Clear(); //dp

        // Delete and Remove files, socket, and lists, ListTrees --
        if ( gPad && !( gROOT->GetListOfCanvases()->IsEmpty() ) ) {
          TCanvas *CurrentCanvas = 0;
          CurrentCanvas = gPad->GetCanvas();
          if ( CurrentCanvas ) {
            //CurrentCanvas->Clear();
            RecursivePadClear( CurrentCanvas );
            CurrentCanvas->cd();
            CurrentCanvas->Modified();
            CurrentCanvas->Update();
          } //if ( CurrentCanvas )
        } //if ( gPad && !( gROOT->GetCanvasList()->IsEmpty() ) )


        //--

        break;
        /*
      case kM_BUTTON_EXIT:
        Running = kFALSE;

        ResetObjects();

        CloseWindow();
        break;
        */

      } //switch parm1
      break; //kCM_BUTTON

    case kCM_CHECKBUTTON:
      switch ( parm1 ) {
      case kM_CHBUTTON_AUTOUPDATE:
        if ( fChButtonAutoUpdate->GetState() == kButtonDown ) {
          AutoUpdate = kTRUE;

          fChButtonSlideUpdate->SetState(kButtonUp);
        }
        else {
          AutoUpdate = kFALSE;
          fPauseHistoButton->SetState(kButtonDisabled);
          fRestartHistoButton->SetState(kButtonUp);
          Running = kFALSE;

          fChButtonSlideUpdate->SetState(kButtonUp);
          fChButtonSlideUpdate->SetState(kButtonDisabled);
          SlideShowUpdate = kFALSE;
        }
        break;

      case kM_CHBUTTON_SLIDEUPDATE:
        if ( fChButtonSlideUpdate->GetState() == kButtonDown ) 
          SlideShowUpdate = kTRUE;
        else 
          SlideShowUpdate = kFALSE;

        break;
      } // switch parm1 of Check Button

      break; //kCM_CHECKBUTTON

    case kCM_RADIOBUTTON:
      switch ( parm1 ) {
      case kM_RABUTTON_MFILE:
        fRaButMFile->SetState(kButtonDown);
        fRaButRFile->SetState(kButtonUp);
        fRaButSocket->SetState(kButtonUp);
        break; // kM_RABUTTON_MFILE
      case kM_RABUTTON_RFILE:
        fRaButMFile->SetState(kButtonUp);
        fRaButRFile->SetState(kButtonDown);
        fRaButSocket->SetState(kButtonUp);
        break; // kM_RABUTTON_RFILE
      case kM_RABUTTON_SOCKET:
        fRaButMFile->SetState(kButtonUp);
        fRaButRFile->SetState(kButtonUp);
        fRaButSocket->SetState(kButtonDown);
        break; // kM_RABUTTON_SOCKET
      } // switch parm1 of Radio Button

      break; //kCM_RADIOBUTTON


    } //switch submsg of kC_COMMAND
    break; // kC_COMMAND

  case kC_LISTTREE:
    switch ( GET_SUBMSG(msg) ) {

    case kCT_ITEMCLICK:
      if ( parm1 == kButton1 || parm1 == kButton2 ) {
        TGListTreeItem *item;
        if ( (item = fHistoListTree->GetSelected()) !=0 &&
            item != fSelectedItem) {
          fClient->NeedRedraw(fHistoListTree);
          fSelectedItem = item;
        }
      } //if parm1 of kCT_ITEMCLICK

      else if ( parm1 == kButton3 ) {
        TGListTreeItem *item;
        if ( (item = fHistoListTree->GetSelected()) !=0 ) {
          fClient->NeedRedraw(fHistoListTree);
          fSelectedItem = item;


          if ( fSelectedItem ) {

            /*
            if ( strstr( fSelectedItem->GetText(), "slide" ) ||
                 strstr( fSelectedItem->GetText(), "Slide" ) ||
                 strstr( fSelectedItem->GetText(), "SLIDE" ) ) {
            */
            if ( strstrn( fSelectedItem->GetText(), kSlideShowFolder ) ) {

              //dp            StartSlides( fSelectedItem );

            } //if ( strstr( fSelectedItem->GetText() ) ||


            else {

              if ( fSlideTimer && 
                   ( fSlideTimer->GetCurrentPad() == gPad ) &&
                   !fSlideTimer->HasTimedOut() )
                //if ( fSlideTimer )
                fSlideTimer->TurnOff();


              if ( fSelectedItem->GetFirstChild() &&
                   fSelectedItem->GetFirstChild()->GetNextSibling() &&
                   fSelectedItem->IsOpen() ) {

                TList *selectedList = new TList();

                TGListTreeItem *item2;
                item2 = fSelectedItem->GetFirstChild();

                while ( item2 ) {
                  //TObject *obj2 = 0;
                  //obj2 = fDisplayedList->FindObject( item2->GetText() );

                  TObject *obj2 = GetCObjFromListItem( item2 );

                  if( obj2 ) {
                    selectedList->Add( obj2 );
                    //obj2->ls();
                  }//if( obj2 )
                  item2 = item2->GetNextSibling();
                }// while( item2 )

                DrawHisto( selectedList );
                delete selectedList;

              } //if ( selectedItem->GetFirstChild() &&
              else {

                //TObject *obj =
                //fDisplayedList->FindObject( fSelectedItem->GetText() );

                TObject *obj = GetCObjFromListItem( item );

                DrawHisto( obj );

              } //else //if ( selectedItem->GetFirstChild() &&


              if ( AutoUpdate ) {
                fPauseHistoButton->SetState( kButtonUp );
                fRestartHistoButton->SetState( kButtonDisabled );
              
                UpdateTimerOn();

              } //if (AutoUpdate)
              else {

                //if ( !Running ) {
                  fPauseHistoButton->SetState( kButtonDisabled );
                  fRestartHistoButton->SetState( kButtonUp );
                  //} //if ( !Running ) {

              } //else //if (AutoUpdate)



            } //else //if ( strstr( fSelectedItem->GetText() ) ||

          } //if ( fSelectedItem )


        } //if ( (item = fHistoListTree->GetSelected()) !=0 )
      } // else if parm1 == kButton3 of kCT_ITEMCLICK
      break; // kCT_ITEMCLICK


    case kCT_ITEMDBLCLICK:
      //if ( parm1 == kButton1 ) {
      if ( parm1 ) {
        TGListTreeItem *item;
        if ( (item = fHistoListTree->GetSelected()) !=0 ) {
          fClient->NeedRedraw(fHistoListTree);
          fSelectedItem = item;

          if ( fSelectedItem ) {

            //TObject *obj =
            //fDisplayedList->FindObject( fSelectedItem->GetText() );

            TObject *obj = GetCObjFromListItem( item );

            if ( !obj ) {
 
              /*
              if ( ( strstr( fSelectedItem->GetText(), "slide" ) ||
                     strstr( fSelectedItem->GetText(), "Slide" ) ||
                     strstr( fSelectedItem->GetText(), "SLIDE" ) ) ) {
              */
              if ( strstrn( fSelectedItem->GetText(), kSlideShowFolder ) ) {

                //dp            StartSlides( fSelectedItem );

              } // if ( ( strstr( fSelectedItem->GetText(), "slide" ) ||

            } //if ( !obj )  

            else {

              if ( fSlideTimer &&
                   ( fSlideTimer->GetCurrentPad() == gPad ) &&
                   !fSlideTimer->HasTimedOut() )
                //if ( fSlideTimer )
                fSlideTimer->TurnOff();

              DrawHisto( obj );

              if ( AutoUpdate ) {
                fPauseHistoButton->SetState( kButtonUp );
                fRestartHistoButton->SetState( kButtonDisabled );

                UpdateTimerOn();

              } //if ( AutoUpdate )
              else {

                //if ( !Running ) {
                  fPauseHistoButton->SetState( kButtonDisabled );
                  fRestartHistoButton->SetState( kButtonUp );
                  //} //if ( !Running ) {

              } //else //if (AutoUpdate)


            } //else //if ( !obj )


          } //if ( fSelectedItem )


        } //if ( (item = fHistoListTree->GetSelected()) !=0 )
      } //if ( parm1 == kButton1 ) of kCT_ITEMDBLCLICK
      break; // kCT_ITEMDBLCLICK

    } // switch submsg of kC_LISTTREE
    break; //case kC_LISTTREE

  case kC_TEXTENTRY:
    switch (GET_SUBMSG(msg)) {

    case kTE_ENTER:

      switch ( parm1 ) {

      case kM_TEXTENTRY_FILENAME:

        {
          FileName = TString( fFileNameBuffer->GetString() );

          EInputTypes inputtype;

          if ( fRaButMFile->GetState() == kButtonDown )
            inputtype = kTMapFile;
          else if ( fRaButRFile->GetState() == kButtonDown )
            inputtype = kTFile;
          else if ( fRaButSocket->GetState() == kButtonDown )
            inputtype = kTSocket;

          //InputObj = OpenFile( FileName.Data(), inputtype, "READ" );
          TObject *InputObj = OpenFile( FileName.Data(), inputtype, "READ" );


          //if ( InputOpen ) {
          if ( InputObj ) {

            AddTreeItemsOfInput( InputObj );
            //RefreshTreeItem( fHistoListTree->GetFirstItem() );
            fClient->NeedRedraw( fHistoListTree );


            char* str = new char[ 9 + FileName.Length() ];
            strcpy(str, " Opened ");
            fStatusBar
              ->SetText( strcat(str, FileName.Data()), 1);
            delete [] str;
          } //if ( InputObj ) 
          else {

            //if ( inputtype == kTMapFile && !InputOpen ) {
            if ( inputtype == kTMapFile ) {
              const char *sg = "Failed to open memory map file.";
              MessageBox(sg);
            }
            //else if ( inputtype == kTFile && !InputOpen ) {
            else if ( inputtype == kTFile ) {
              const char *sg = "Failed to open ROOT file.";
              MessageBox(sg);
            }
            //else if ( inputtype == kTSocket && !InputOpen ) {
            else if ( inputtype == kTSocket ) {
              const char *sg = "Failed to open the socket connection.";
              MessageBox(sg);
            }

            char* str = new char[16+FileName.Length()];
            strcpy(str," Error Opening ");
            fStatusBar
              ->SetText( strcat(str, FileName.Data()), 1);
            delete [] str;

          } // else //if ( InputObj )

        }
        break;//  kM_TEXTENTRY_FILENAME
    
      }//switch ( parm1 )

      break; //case kTE_ENTER:

    default:
      break;

    }//switch (GET_SUBMSG(msg)) 

    break; //case kC_TEXTENTRY:

  default:
    break;

  } //switch ( GET_MSG(msg) )

  return kTRUE;

}



//void HistoDisplay::GetDirPath( const TString &Item)
//char* HistoDisplay::GetDirPath( const TString &Item)
TString HistoDisplay::GetDirPath( const TString &/*Item*/)
{
  //cout << " GetDirPath " << endl;

  TString DirPath;

  DirPath = "/" + MonitorName ;
  //DirPath = "/";

  /*
  char *dirpath = new char[DirPath.Length()];

  cout << " DirPath in DirName" << DirPath.Data() << endl;
  strcpy(dirpath, DirPath.Data());
  cout << " dirpath in DirName" << dirpath << endl;
  return dirpath;
  */

  return DirPath;

}


//******************** Modified by Koji (1999/12/2) ************************

PhotoWindow::PhotoWindow(const TGWindow *p, const TGWindow *main, UInt_t w,
                         UInt_t h, UInt_t options)
  :TGTransientFrame(p, main, w, h, options)
{
    gClient->GetColorByName("Cyan",Cyan);
    ChangeBackground(Cyan);

 fTitleFrame = new TGCompositeFrame(this,800,100);
 FontStruct_t labelfont0, labelfont1;
 labelfont0 = gClient->GetFontByName("-adobe-helvetica-medium-r-*-*-18-*-*-*-*-*-iso8859-1");
   GCValues_t   gval0, gval1, gval2;
   gval0.fMask = kGCForeground | kGCFont;
   gval0.fFont = gVirtualX->GetFontHandle(labelfont0);
   gClient->GetColorByName("red", gval0.fForeground);
   fTextGC0 = gVirtualX->CreateGC(gClient->GetRoot()->GetId(), &gval0);
   fTitleLabel = new TGLabel(fTitleFrame, "MINOS Online Monitoring System", fTextGC0, labelfont0);
   fTitleLabel->ChangeBackground(Cyan);
   fTitleFrame->AddFrame(fTitleLabel, new TGLayoutHints(kLHintsTop | kLHintsCenterX));

   // fPicBut0 = new TGPictureButton(this, gClient->GetPicture("${CONSUMER_ICONS}/photo.xpm"), 1);

fPicBut0 = new TGPictureButton(this, gClient->GetPicture("${CONSUMER_ICONS}/photo_old.xpm"), 1);

 fPicBut1 = new TGPictureButton(this, gClient->GetPicture("${CONSUMER_ICONS}/ta.xpm"), 2);

 fButton = new TGTextButton(this, "OK", 3);
 fButton->Associate(this);
 // fButton->SetCommand(".q" );
 gClient->GetColorByName("LightYellow",LightYellow);
 fButton->ChangeBackground(LightYellow);


   labelfont1 = gClient->GetFontByName("-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-iso8859-1");
   gval1.fMask = kGCForeground | kGCFont;
   gval1.fFont = gVirtualX->GetFontHandle(labelfont1);
   gClient->GetColorByName("blue", gval1.fForeground);
   fTextGC1 = gVirtualX->CreateGC(gClient->GetRoot()->GetId(), &gval1);

   gval2.fMask = kGCForeground | kGCFont;
   gval2.fFont = gVirtualX->GetFontHandle(labelfont1);
   gClient->GetColorByName("magenta", gval2.fForeground);
   fTextGC2 = gVirtualX->CreateGC(gClient->GetRoot()->GetId(), &gval2);

 fTextFrame0 = new TGCompositeFrame(this,100,50);
 fTextFrame1 = new TGCompositeFrame(this,100,50);
 fTextFrame2 = new TGCompositeFrame(this,100,50);

 fTextLabel0 = new TGLabel(fTextFrame0, "H. Wenzel", fTextGC1, labelfont1);
 fTextLabel1 = new TGLabel(fTextFrame0, "IEKP Karlsruhe", fTextGC2, labelfont1);
 fTextLabel2 = new TGLabel(fTextFrame1, "K. Maeshima                   K. Ikado        ", fTextGC1, labelfont1);
 fTextLabel3 = new TGLabel(fTextFrame1, "     Fermilab                 Waseda Univ.     ", fTextGC2, labelfont1);
 //fTextLabel4 = new TGLabel(fTextFrame2, "F. Hartmann                T. Arisawa                 G. Veramendi", fTextGC1, labelfont1);
 fTextLabel4 = new TGLabel(fTextFrame2, "H.Stadie,W.Wagner         T. Arisawa                 G. Veramendi", fTextGC1, labelfont1);
 fTextLabel41 = new TGLabel(fTextFrame2, " F.Hartmann", fTextGC1, labelfont1);
 fTextLabel5 = new TGLabel(fTextFrame2, "IEKP Karlsruhe              Waseda Univ.                   LBNL        ", fTextGC2, labelfont1);

 fTextLabel0->ChangeBackground(Cyan);
 fTextLabel1->ChangeBackground(Cyan);
 fTextLabel2->ChangeBackground(Cyan);
 fTextLabel3->ChangeBackground(Cyan);
 fTextLabel4->ChangeBackground(Cyan);
 fTextLabel41->ChangeBackground(Cyan);
 fTextLabel5->ChangeBackground(Cyan);

 fTextFrame0->AddFrame(fTextLabel0,new TGLayoutHints(kLHintsCenterX) );
 fTextFrame0->AddFrame(fTextLabel1,new TGLayoutHints(kLHintsCenterX) );
 fTextFrame1->AddFrame(fTextLabel2,new TGLayoutHints(kLHintsCenterX));
 fTextFrame1->AddFrame(fTextLabel3,new TGLayoutHints(kLHintsCenterX));
 fTextFrame2->AddFrame(fTextLabel4,new TGLayoutHints(kLHintsCenterX));
 fTextFrame2->AddFrame(fTextLabel41,new TGLayoutHints(kLHintsLeft));
 fTextFrame2->AddFrame(fTextLabel5,new TGLayoutHints(kLHintsCenterX));

 fTitleFrame->ChangeBackground(Cyan);
 fTextFrame0->ChangeBackground(Cyan);
 fTextFrame1->ChangeBackground(Cyan);
 fTextFrame2->ChangeBackground(Cyan);

    AddFrame(fTitleFrame, new TGLayoutHints(kLHintsTop | kLHintsExpandX,10,10,10,10));
    AddFrame(fPicBut0, new TGLayoutHints(kLHintsTop | kLHintsCenterX,10,10,0));
    AddFrame(fTextFrame0, new TGLayoutHints(kLHintsTop | kLHintsCenterX));
    AddFrame(fTextFrame1, new TGLayoutHints(kLHintsTop | kLHintsCenterX));
    AddFrame(fPicBut1, new TGLayoutHints(kLHintsTop | kLHintsCenterX,0,0,10));
    AddFrame(fTextFrame2, new TGLayoutHints(kLHintsTop | kLHintsCenterX));
    AddFrame(fButton, new TGLayoutHints(kLHintsBottom | kLHintsCenterX));

    MapSubwindows();
    Layout();
    SetWindowName("MINOS Online Monitoring System");
    MapWindow();

}
 
PhotoWindow::~PhotoWindow()
{
  delete fButton;  delete fPicBut0; delete fPicBut1;
  delete fTitleLabel;  delete fTextLabel0;  delete fTextLabel1;
  delete fTextLabel2;  delete fTextLabel4;  delete fTextLabel5;
  delete fTextLabel41;
  delete fTitleFrame;  delete fTextFrame0;  delete fTextFrame1;
  delete fTextFrame2;
}

void PhotoWindow::ClosePhotoWindow()
{
  delete this;
}

Bool_t PhotoWindow::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{
  switch ( GET_MSG(msg) ) {
  case kC_COMMAND:
    switch ( GET_SUBMSG(msg) ) {
    case kCM_BUTTON:
      switch ( parm1 ) {
      case 3:
        {
          ClosePhotoWindow();
        }
        break; //case 3:
      default:
        break;
      } //switch ( parm1 ) 
      break; //case kCM_BUTTON:
    default:
      break;
    } // switch ( GET_SUBMSG(msg) ) 
    break; //case kC_COMMAND:
  default:
    break;
  } //switch ( GET_MSG(msg) )
  return kTRUE;
}

//***********************************************************************

---