EVD.cxx

Go to the documentation of this file.

#include "EVD.h"
#include "GfxProxy.h"
#include "GfxCfg.h"
#include "ViewState.h"
#include "EVDObject.h"

#include "TLatex.h"
#include <TBox.h>
#include <TStyle.h>
#include <Midad/Base/PageProxy.h>
#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/DigitText.h>
#include <Midad/Base/ZoomPad.h>
#include <Midad/Base/ColorAxis.h>
#include <Midad/Base/RangeAxis.h>
#include <Midad/Base/Mint.h>
#include <Midad/Base/GfxButton.h>

#include <Midad/Util/RangeControl.h>
#include <Midad/Util/CompositeRange.h>
#include "DataUtil/GetRunSnarlEvent.h"
#include <MinosObjectMap/MomNavigator.h>
#include <Record/SimSnarlRecord.h>
#include <Record/SimSnarlHeader.h>
#include <RawData/RawDaqSnarlHeader.h>
#include <TParticle.h>
#include <TClonesArray.h>
#include "Conventions/StripEnd.h"

#include <REROOT_Classes/REROOT_NeuVtx.h>
#include <REROOT_Classes/REROOT_NeuKin.h>
#include <Validity/VldContext.h>
#include <Validity/VldTimeStamp.h>

#include <Midad/Gui/GuiBox.h>
#include <Midad/Gui/GuiCanvas.h>
#include <Midad/Gui/GuiSlider.h>
#include <Midad/Gui/GuiButton.h>
#include <Midad/Gui/GuiTab.h>
#include <Midad/Gui/GuiMainWindow.h>
#include <Midad/Gui/GuiTextView.h>
#include <Midad/Gui/GuiTree.h>
#include <Midad/Gui/GuiScrolled.h>
#include "TG3DLine.h"
#include "TGTextEntry.h"
#include "TGButton.h"

#include <RecoBase/CandSliceListHandle.h>
#include <CandDigit/CandDigitHandle.h>
#include <CandDigit/CandDigitListHandle.h>
#include <CandTrackSR/CandTrackSRHandle.h>
#include <CandFitTrackSR/CandFitTrackSRHandle.h>
#include <RecoBase/CandTrackListHandle.h>
#include <RecoBase/CandFitTrackHandle.h>
#include <RecoBase/CandTrackHandle.h>
#include <RecoBase/CandShowerHandle.h>
#include <RecoBase/CandShowerListHandle.h>
#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandStripListHandle.h>
#include <RecoBase/CandEventListHandle.h>
#include <RecoBase/CandEventHandle.h>

#include <CalDetPID/CandCalDetPIDHandle.h>

#include <JobControl/JobC.h>
#include <Conventions/Munits.h>
#include <Midad/Base/SteelOutline.h>
#include <TCanvas.h>
#include "DisplayOptions.h"
#include <DataUtil/TruthHelper.h>
#include <TH1F.h>

#include <UgliGeometry/UgliGeomHandle.h>
#include <UgliGeometry/UgliStripHandle.h>
#include <DataUtil/GetCandidate.h>

#include <Plex/PlexSEIdAltL.h>
#include <Plex/PlexSEIdAltLItem.h>
#include <Plex/PlexStripEndId.h>
#include <DataUtil/CDL2STL.h>
#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>

ClassImp(EVD)

using namespace SigC;
using namespace DisplaySetup;

static PageProxy<EVD> gsEVDProxy("MINOS Event Display");

EVD::EVD()
  : fPageDisplay(0)
    , fMint(0)
    , fRecoText(0)
    , fMCText(0)
    , fMCTree(0)
    , fDigitText(0)
    , fMCtextbox(0)
    , fRecotextbox(0) 
    , fMCTreetextbox(0) 
    , fDigittextbox(0)
    , fMCTreescroll(0)
    , fTextBox(0)  
    , fMCbut(0)
    , fRecobut(0)
    , fMCTreebut(0)
    , fDigitbut(0)
    , fZoomHistory(0)
    , fCompositeRange(0)
    , fSlice(-1)
    , fNumSlices(-1)
    , fEvent(-1)
    , fNumEvents(-1)
    , fSnarl(-1)
    , fGhostColor(kGhostColor)
    , fClear(false)
    , fDrawAll(true)
    , fDrawGhosts(false)
    , fLastButtonType(0)
    , fTimeZoom(false)
{
    fZoomHistory = manage(new UndoHistory);
    fCompositeRange = manage(new CompositeRange<double>);
}

EVD::~EVD()
{
}

TObject* EVD::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{

 

  this->CanvasPage::Init(mint,pd,box);
  fMint = mint;
  fPageDisplay = pd;

  fChargeRange= new RangeDouble(0.0,1.0);
  
  /* 
     The 3 views displayed are UZ [0], VZ [1], and XY [2].  The ViewState
     holds the state variables that determine whether non-demuxed digits are
     displayed, whether color represents time or charge, etc.  Refer to
     ViewState.h for the complete state list.
  */
  fViewState[0] = manage(new ViewState);
  fViewState[1] = manage(new ViewState);
  fViewState[2] = manage(new ViewState); 

  BuildMenus();
  BuildButtons();
  
  /* 
     Build ranges.  There are 5 spatial controls, for the one for the z axis 
     in the U and V vs Z views, and one each for U, V, X, and Y.  There is
     also a time range, which controls the range of times displayed, 
     and which is controled by the slider control at the bottom of the window  
  */

  RangeDouble*  spatial_range[5];
  for (int i=0; i<6; ++i) 
    {
      spatial_range[i] = manage(new RangeDouble(0,1));
      fSpatialControl[i] = new RangeControl<double>(fZoomHistory,
                                                    spatial_range[i]);
    }
  fRClist.push_back(fPageDisplay->GetTimeSlider().GetSignals().released.connect
                      (slot_class(*this,&EVD::UpdateTime)));
 
  TCanvas& canvas = this->GetCanvas();
  canvas.SetFillColor(38);

  Int_t colNum=9;
  Int_t palette[9]={10,6,9,4,7,8,3,5,2};
  gStyle->SetPalette(colNum,palette);
  
  /* 
     Build U/V vs Z views.  We must define a pad for each, and set the 
     location of the rangeaxis and color_range controls.  The color ranges
     have an associated button, which determines whether color represents
     pulse height or time.  The color ranges are active, meaning that the 
     display will response to selection of  a range on the color palette.
  */
  
  fPad[0] = new ZoomPad("U View", "U View", kZviewXmin,kUZviewYmin, 
                        kZviewXmax,kZviewYmax);
  fPad[1] = new ZoomPad("V View", "V View", kZviewXmin,kZviewYmin,
                        kZviewXmax,kVZviewYmax);
  
  fRangeAxis[0] = new RangeAxis(kZviewXRUV,kUZviewYmin, 
                                kZviewXRUV,kZviewYmax);
  fRangeAxis[1] = new RangeAxis(kZviewXRUV,kZviewYmin, 
                                kZviewXRUV,kVZviewYmax);
  fRangeAxis[2] = new RangeAxis(kZviewXmin,kZviewYRZ,
                                kZviewXmax,kZviewYRZ);
  
  for (int i = 0; i < 3; ++i) 
    {
      fRangeAxis[i]->UseRange(spatial_range[i]);
      fRangeAxis[i]->SetLabelSize(0.4*fRangeAxis[i]->GetLabelSize());
    }
  
  fRangeAxis[0]->SetTitle("U");
  fRangeAxis[1]->SetTitle("V");
  fRangeAxis[0]->SetTitleSize(0.02);
  fRangeAxis[1]->SetTitleSize(0.02);
  fRangeAxis[0]->SetTitleOffset(0.5);
  fRangeAxis[1]->SetTitleOffset(0.5);
  
  RangeDouble* color_range[2];
  for (int i = 0; i<2; ++i) 
    {
      color_range[i] = manage(new RangeDouble(0,1));
      fColorControl[i] = new RangeControl<double>(fZoomHistory,
                                                  color_range[i]);//leak
      
      fPad[i]->UseCurRangeX(spatial_range[2]);
      
      /*
        Connects selection event to SelectionZoom method.  Selecting
        a region  in either the UZ or VZ views will result in zooming
        in on that region.  The zoom all button is used to zoom back
        out.
      */

      fPad[i]->selection.connect(bind(slot_class(*this,&EVD::SelectionZoom),fPad[i]));
    }
  
  
  fPad[0]->UseCurRangeY(spatial_range[0]);
  fPad[1]->UseCurRangeY(spatial_range[1]);
  
  fColorAxis[0] = new ColorAxis(50,0.05, color_range[0], 
                                kZviewColorFrameXmax-0.1,kZviewColorFrameYmin, 
                                kZviewColorFrameXmax-0.1,kZviewColorFrameYmax,
                                505,"+L");
  fColorAxis[1] = new ColorAxis(50,0.05, color_range[1], 
                                kZviewColorFrameXmax,kZviewColorFrameYmin, 
                                kZviewColorFrameXmax,kZviewColorFrameYmax,
                                505,"+L");
  
  fColorButton[0] = manage(new GfxButton("UZ Time",
                                         kZviewColorFrameXmax-0.15,
                                         kZviewColorFrameYmax+0.01,
                                         kZviewColorFrameXmax-0.1,
                                         kZviewColorFrameYmax+0.04));
  fColorButton[1] = manage(new GfxButton("VZ Time",
                                         kZviewColorFrameXmax-0.05,
                                         kZviewColorFrameYmax+0.01,
                                         kZviewColorFrameXmax,
                                         kZviewColorFrameYmax+0.04));
  
    for(int i = 0; i<2; ++i) 
      {
      fColorAxis[i]->SetLabelSize(0.25*fColorAxis[i]->GetLabelSize());
      fColorButton[i]->SetTextSize(0.5);
      fColorAxis[i]->SetScale(Munits::ns);
      RangeDouble& sel = fColorAxis[i]->GetSelectionRange();

      /* connect selecton of range on color axis to the RangeControl::Apply
         method.  This method determines whether a charge or time sub-range
         is being requested, and triggers a screen redraw with the appropriate
         subrange.
      */
      
      sel.modified.connect(bind(slot(*(fColorControl[i]),
                                     &RangeControl<double>::Apply),&sel));
      sel.modified.connect(slot_class(*this,&EVD::UpdateCanvas));

      /*
        Clicking on a color button toggles between charge and time color
        semantics
      */
      
      fColorButton[i]->clicked.connect(slot(*fViewState[i],
                                            &ViewState::ToggleColorSemantic));       }


    fViewState[0]->color_semantic.connect(bind(slot_class(*this,&EVD::ColorSemanticHandler),0));    
    //    fViewState[0]->show_multiplex.connect(slot_class(*this,&EVD::Update));
    //     fViewState[0]->spatial_metric.connect(slot_class(*this,&EVD::Update));

    fViewState[1]->color_semantic.connect(bind(slot_class(*this,&EVD::ColorSemanticHandler),1));
    fViewState[1]->show_multiplex.connect(slot_class(*this,&EVD::Update));
    //    fViewState[1]->spatial_metric.connect(slot_class(*this,&EVD::Update));


    for (int i=0; i<3; ++i) 
      {
        RangeDouble& s = fRangeAxis[i]->GetSelectionRange();
        s.modified.connect(bind(slot(*(fSpatialControl[i]),
                                     &RangeControl<double>::Apply),&s));       
        fRClist.push_back(spatial_range[i]->modified.connect(slot_class(*this,&EVD::UpdateCanvas)));
      }
    

    /* now build XY view, in fashion similar to above */    

    fPad[2] = new ZoomPad("XY View", "XY View", 
                          kXYviewXmin,kXYviewYmin,
                          kXYviewXmax,kXYviewYmax);
    
    fRangeAxis[3] = new RangeAxis(kXYviewXR,kXYviewYmin,
                                  kXYviewXR,kXYviewYmax);
    fRangeAxis[4] = new RangeAxis(kXYviewXmin,kXYviewYR, 
                                  kXYviewXmax,kXYviewYR);

    for (int i = 3; i < 5; ++i) 
      {
        fRangeAxis[i]->UseRange(spatial_range[i]);
        fRangeAxis[i]->SetLabelSize(0.3*fRangeAxis[i]->GetLabelSize());
        
      }

    fRangeAxis[3]->SetTitle("Y");
    fRangeAxis[4]->SetTitle("X");
    fRangeAxis[3]->SetTitleSize(0.02);
    fRangeAxis[4]->SetTitleSize(0.02);
    fRangeAxis[3]->SetTitleOffset(0.5);
    fRangeAxis[4]->SetTitleOffset(0.5);
    
    fPad[2]->UseCurRangeX(spatial_range[3]);
    fPad[2]->selection.connect(bind(slot_class(*this,&EVD::SelectionZoom),fPad[2]));
    fPad[2]->UseCurRangeY(spatial_range[4]);
    fViewState[2]->color_semantic.connect(bind(slot_class(*this,&EVD::ColorSemanticHandler),1));
 
    
    for (int i=3; i<5; ++i) 
      {
        RangeDouble& s = fRangeAxis[i]->GetSelectionRange();
        s.modified.connect(bind(slot(*(fSpatialControl[i]),
                                     &RangeControl<double>::Apply), &s));
        
        fRClist.push_back(spatial_range[i]->modified.connect
                          (slot_class(*this,&EVD::UpdateCanvas)));
      }

    
    /* the text pad shows a summary of reconstruction,  and MC if appropriate */
    TextPad = new TPad("Summary","Summary",0.42,0.01,0.97,0.24);
    TextPad->SetFillColor(17);
    
    /* draw pads on the canvas, tweaking the drawing options for visual
       impact
    */

    canvas.cd();
    fPad[0]->SetBorderSize(1);
    fPad[1]->SetBorderSize(1);
    fPad[2]->SetBorderSize(1);

    fPad[0]->SetBorderMode(1);
    fPad[1]->SetBorderMode(1);
    fPad[2]->SetBorderMode(1);

    fColorButton[0]->SetFillColor(2);
    fColorButton[1]->SetFillColor(2);

    fPad[0]->SetFillColor(1);
    fPad[1]->SetFillColor(1);
    fPad[2]->SetFillColor(1);
  
    fPad[0]->Draw();
    fPad[1]->Draw();
    fPad[2]->Draw();
    TextPad->Draw();

    //create the user histograms

    fUserHist = new UserHist(fMint);

    // update the reconstruction/MC summary pad.
    
    TextPad->cd();
    UpdateSummary();
    
    canvas.cd();
    InitChargeHists(canvas);
    fRangeAxis[0]->Draw();
    fRangeAxis[1]->Draw();
    fRangeAxis[2]->Draw();
    fRangeAxis[3]->Draw();
    fRangeAxis[4]->Draw();

    fColorAxis[0]->Draw();
    fColorAxis[1]->Draw();
    fColorAxis[0]->PaintPalette();
    fColorButton[0]->Draw();
    fColorButton[1]->Draw();

    /* 
       Activate all Gfx objects. By default, the digitlist, tracklist, and
       showerlist are displayed. One can select or deselect object 
       visibility in the 'Objects' menu
    */

    const char* default_gfx[] = {
      "DigitList",
      "StripList",
      "TrackList",
      "ShowerList",
      "MCVecList",
      0
    };
    
    for (int ind=0; default_gfx[ind]; ++ind) this->AddGfx(default_gfx[ind]);
    
    BuildGfxMenu();
    Clear();
    Update();

    return new EVDObject(this); // small leak   
}

static void toggle_mux(GuiMenu* menu,
                       GuiMenu::GuiMenuList::iterator mit,
                       ViewState* view_state)

  /* called by options menu entry.  Toggles between display modes in which
     all digits are shown, and only the best strip end alternative is shown.
  */
{
    
    bool show_mux = view_state->ShowMultiplex();
    menu->CheckEntry(mit,show_mux);
}


void EVD::BuildMenus(void)
{
    GuiMenuBar& mb = fPageDisplay->GetMenuBar();

    mb.RemoveMenu("Zoom");
    mb.RemoveMenu("Pages");
    
    GuiMenu* options_menu = manage(new GuiMenu);
    mb.AddMenu(*options_menu,"Options");

    GuiMenu::GuiMenuList::iterator mit;

    // Whether to show multiplexing or not
    const char* mux_labels =      "Show AllMultiplex Digits";
    mit = options_menu->Add(mux_labels);
    for (int ind = 0; ind < 3; ++ind) {
        ViewState* vs = fViewState[ind];
        options_menu->CheckEntry(mit,vs->ShowMultiplex());
       (*mit)->Connect(slot(*vs,&ViewState::ToggleMultiplex));
        vs->show_multiplex.connect(bind(bind(bind(slot(toggle_mux),vs),mit),options_menu));
    }

    // Real or discrete coords.
    mit = options_menu->Add("Use Strip/Plane Coord.s");
    (*mit)->Connect(bind(slot_class(*this,&EVD::ToggleRealCoords),options_menu,mit));
    fViewState[2]->SetSpatialMetric(ViewState::metric_is_continuous);

  // Zoom to time window in slice or event view.
    mit = options_menu->Add("Zoom to Slice/Event Time Window");
    (*mit)->Connect(bind(slot_class(*this,&EVD::ToggleTimeZoom),options_menu,mit));
    fTimeZoom=false;

    mit = options_menu->Add("Display Settings");
    fDisplayOptions = new DisplayOptions(*fPageDisplay, *this);
    (*mit)->Connect(bind(slot_class(*fDisplayOptions,&DisplayOptions::OpenDialog),options_menu,mit));


    options_menu->Add(0);
 
}


void EVD::BuildGfxMenu()
{

  GuiMenuBar& mb = fPageDisplay->GetMenuBar();

  list<const char*> gfx_names = GfxProxyBase::GetRegisteredNames();
  list<const char*>::iterator it, done = gfx_names.end();
  
  GuiMenu* pm = manage(new GuiMenu);
  mb.AddMenu(*pm,"Objects");
  
  NamedFactory& nf = NamedFactory::Instance("Gfx");
  for (it = gfx_names.begin(); it != done; ++it) {
    const char* name = *it;
    GfxProxyBase* gpb = dynamic_cast<GfxProxyBase*>(nf.GetProxy(name));
    if (!gpb) {
      cerr << "Failed to get GfxProxy for " << name << endl;
      continue;
    }
    GuiMenu * gfx_menu = gpb->MakeMenu(this);
    if (! gfx_menu) continue;
    gfx_menu = manage(gfx_menu);
    pm->Add(name, *gfx_menu);
    
  }  
}

void EVD::BuildButtons()
{

  GuiBox * gb = fPageDisplay->GetButtonBox();
 
  TGHorizontal3DLine * BigSep = new  TGHorizontal3DLine(gb,1,100); 
  TGHorizontal3DLine * Sep = new  TGHorizontal3DLine(gb,1,20);

  // add next/prev slice buttons

  fNextSlicebut = fPageDisplay->AddButton("Next Slice ");
  fNextSlicebut->clicked.connect(slot_class(*this,&EVD::NextSlice));

  fNextSlicebut = fPageDisplay->AddButton("Prev Slice ");
  fNextSlicebut->clicked.connect(slot_class(*this,&EVD::PrevSlice));


  // lots of work to add a space at the top of the button box

  TGFrameElement *nw = new TGFrameElement;
  nw->fFrame  = BigSep;
  TGLayoutHints * hint = new TGLayoutHints(kLHintsTop);  
  nw->fLayout = hint;
  nw->fState  = 1;
  gb->GetList()->AddFirst(nw);

  // this adds a space after the next/prev buttons

  gb->AddFrame(Sep);
 // add next/prev event buttons

  fNextEventbut = fPageDisplay->AddButton("Next Event ");
  fNextEventbut->clicked.connect(slot_class(*this,&EVD::NextEvent));

  fNextEventbut = fPageDisplay->AddButton("Prev Event ");
  fNextEventbut->clicked.connect(slot_class(*this,&EVD::PrevEvent));
 gb->AddFrame(Sep);

  // these are the user defined buttons

 
  fRecobut = fPageDisplay->AddButton("Reco Data");
  fRecobut->clicked.connect(slot_class(*this,&EVD::Recotext));
  
  fMCbut = fPageDisplay->AddButton("NeuKin");
  fMCbut->clicked.connect(slot_class(*this,&EVD::MCtext));
  
  fMCTreebut = fPageDisplay->AddButton("StdHep Tree");
  fMCTreebut->clicked.connect(slot_class(*this,&EVD::MCTreetext));
  
  fDigitbut = fPageDisplay->AddButton("Digit Data");
  fDigitbut->clicked.connect(slot_class(*this,&EVD::Digittext));
 
  gb->AddFrame(Sep);

  GuiTextButton * zoombut = fPageDisplay->AddButton("Zoom All");
  zoombut->clicked.connect(slot_class(*fPageDisplay,&PageDisplay::FullZoom));
  
  GuiTextButton * zoomredobut = fPageDisplay->AddButton("Zoom Redo");
  zoomredobut->clicked.connect(slot_class(*fPageDisplay,&PageDisplay::Rezoom));

  GuiTextButton * zoomundobut=  fPageDisplay->AddButton("Zoom Undo");
  zoomundobut->clicked.connect(slot_class(*fPageDisplay,&PageDisplay::Unzoom)); 
  gb->AddFrame(Sep); 
  GuiTextButton * printbut=  fPageDisplay->AddButton("Print");
  printbut->clicked.connect(slot_class(*this,&EVD::PrintCanvas));
}

void EVD::ToggleRealCoords(GuiMenu* menu, GuiMenu::GuiMenuList::iterator mit)
{
  // toggles between real XYZ coords and strip/plane.

    bool is_strip = ! menu->IsEntryChecked(mit);
    menu->CheckEntry(mit,is_strip);

    for (int ind = 0; ind < 2; ++ind) {
        fViewState[ind]->SetSpatialMetric(is_strip ? 
                                          ViewState::metric_is_discreet : 
                                          ViewState::metric_is_continuous);
    }    
    fViewState[2]->SetSpatialMetric( ViewState::metric_is_continuous);

    fPad[0]->Clear();
    fPad[1]->Clear();
    fPad[2]->Clear();
    fClear=true;
    this->FullZoom();
    this->Update();

}

void EVD::ToggleTimeZoom(GuiMenu* menu, GuiMenu::GuiMenuList::iterator mit)
{
  // toggles whether you zoom to time window in slice/event view.

    fTimeZoom = ! menu->IsEntryChecked(mit);
    menu->CheckEntry(mit,fTimeZoom);
    this->Update();

}

void EVD::AddGfx(const char* gfx_name)
{

  /* 
     Adds a graphics object  to each of the the three views.  Currently,
     the XY view does not support the display of CandDigits or CandStrips,
     only tracks, showers, and MC vectors.
  */

    GfxProxyBase* gpb = dynamic_cast<GfxProxyBase*>
        (NamedFactory::Instance("Gfx").GetProxy(gfx_name));
    if (!gpb) {
        cerr << "Failed to get " << gfx_name << " proxy\n";
        return;
    }

    GraphicsView::GraphicsView_t view[3];
    PlaneView::PlaneView_t pview[3];
  
    view[0]=GraphicsView::kUZ;
    view[1]=GraphicsView::kVZ;
    view[2]=GraphicsView::kXY;
    pview[0]=PlaneView::kU;
    pview[1]=PlaneView::kV;
    pview[2]=PlaneView::kV;
  
    TVirtualPad* old_pad = gPad;
    for (int ind = 0; ind < 3; ++ind) 
      {
        if(view[ind]==GraphicsView::kUZ || view[ind]==GraphicsView::kVZ ||
           gfx_name=="DigitList" || 
           gfx_name=="TrackList" || 
           gfx_name=="ShowerList" || 
           gfx_name=="MCVecList" )
          {
            fPad[ind]->cd();
            GfxBase* gfx_base = gpb->Create();
            if (!gfx_base) {
              cerr << "Failed to create " << gfx_name << endl;
              break;
            }    
            gfx_base->text_info.connect(slot_class(*fPageDisplay,
                                                   &PageDisplay::StatusBar));
            gfx_base->SetGraphicsView(view[ind]);
            gfx_base->SetPlaneView(pview[ind]);
            gfx_base->SetViewState(fViewState[ind]);
            gfx_base->SetPad(fPad[ind]);
            //      gfx_base->GetCfg().modified_signal.connect(slot_class(*this,&EVD::UpdateCanvas));
            gfx_base->Init(*fPageDisplay,*this);
            
            fGfxList[gfx_base] = GfxInfo(view[ind]);
          }
      }
    gPad = old_pad;
    this->Update();
}

void EVD::InitView(GraphicsView::GraphicsView_t view)
{
 
  Int_t ind=2;
  if(view==GraphicsView::kUZ )ind=0;
  if(view==GraphicsView::kVZ )ind=1;
  if(view==GraphicsView::kUV )ind=2;
  if(view==GraphicsView::kXY )ind=2;
  fPad[ind]->cd();

  const char* hard_coded_default_gfx[] = {
    "DigitList",
    "StripList",
    "TrackList",
    "ShowerList",
    "MCVecList",
    0
  };

  for (int ind=0; hard_coded_default_gfx[ind]; ++ind) 
    {
      const char* gfx_name = hard_coded_default_gfx[ind];
      this->AddGfx(gfx_name);
    }
}


void EVD::Clear()
{
    fZoomHistory->Clear();
    BlockRanges(true);
    fClear=true;
    FullZoom();
    BlockRanges(false);
}

void EVD::FullZoom()
{
  if (!fMint) return;
  if (fMint->GetDetector() == Detector::kUnknown) return;
  BlockRanges(true);
  UgliGeomHandle ugh = fMint->GetUgliGeomHandle();
  if (! ugh.IsValid()) 
    {
      cerr << "EVD::FullZoom: no valid geometry\n";
      return;
    }
  
  if (fViewState[0]->GetSpatialMetric() == ViewState::metric_is_discreet) 
    {
      vector<UgliScintPlnHandle> usphv = ugh.GetScintPlnHandleVector();
      vector<UgliScintPlnHandle>::reverse_iterator rit, rdone = usphv.rend();
      
      for (rit = usphv.rbegin(); rit != rdone; ++rit) 
        {
          if (! rit->GetPlexPlaneId().IsVetoShield()) break;
        }
      if (rit == rdone)
        {
          cerr << "EVD::FullZoom: WTF, can't get last plane!\n";
          return;
        }
      
      double first_plane,last_plane;
      if(GetDisplayOptions()->AutoScaleExtents()){
        first_plane = usphv[0].GetPlaneNumber()-10; 
        last_plane = rit->GetPlaneNumber()+10;
      }
      else{
        first_plane=GetDisplayOptions()->ZMin()/0.06;
        last_plane=GetDisplayOptions()->ZMax()/0.06;  
      }
      int n_strips = usphv[0].NumberOfStrips();
      
      fPad[0]->Range(first_plane,-10,last_plane,n_strips+10);
      fPad[1]->Range(first_plane,-10,last_plane,n_strips+10);
      
      float xmin, xmax, ymin,ymax;      
      ugh.GetTransverseExtent(PlaneView::kU,xmin,xmax);
      ugh.GetTransverseExtent(PlaneView::kV,ymin,ymax);
     
      if(fMint->GetDetector() == Detector::kFar){      
        fPad[2]->Range(xmin-2,ymin-2,xmax+2,ymax+2);
      }
      else if (fMint->GetDetector() == Detector::kNear){
        fPad[2]->Range(xmin-.442,ymin-1.0,xmax+1.5578,ymax+1.0);
      }
      else{
        fPad[2]->Range(xmin-1.0,ymin-1,xmax+1.0,ymax+1);
      }
    }
  else 
    {
      float umin, umax, zmin, zmax, vmin,vmax;
      float xmin, xmax, ymin, ymax;
      
      
      ugh.GetTransverseExtent(PlaneView::kU,umin,umax);
      ugh.GetTransverseExtent(PlaneView::kV,vmin,vmax);
      if(GetDisplayOptions()->AutoScaleExtents()){
        ugh.GetZExtent(zmin,zmax);
      }
      else{
        zmin=GetDisplayOptions()->ZMin();
        zmax=GetDisplayOptions()->ZMax();
        if((zmax-zmin)<0.25) zmax=zmin+0.25;
      }
      if(fMint->GetDetector() == Detector::kFar){
         zmax+=1;
         zmin-=1;
         umin-=0.5;
         vmin-=0.5;
         umax+=0.5;
         vmax+=0.5;
         xmin=umin;
         xmax=umax;
         ymin=umin;
         ymax=umax;
       }
       else if (fMint->GetDetector() == Detector::kNear){
         zmax+=0.2;
         zmin-=0.2;
         umin-=0.2;
         vmin-=0.2;
         umax+=0.2;
         vmax+=0.2;
         Float_t xoffset=0.5578;
         xmin=umin+xoffset;
         xmax=umax+xoffset;
         ymin=umin;
         ymax=umax;
       }
       else{
         zmin-=0.2;
         umin-=0.2;
         vmin-=0.2;
         umax+=0.2;
         vmax+=0.2;
         xmin=umin;
         xmax=umax;
         ymin=umin;
         ymax=umax;
       }   
       fPad[0]->Range(zmin,umin,zmax,umax);     
       fPad[1]->Range(zmin,vmin,zmax,vmax);
       fPad[2]->Range(xmin,ymin,xmax,ymax);

    }
  if(!fClear)Update();
  BlockRanges(false);
}

void EVD::BlockRanges(bool tf)
{
  for (unsigned int ind = 0; ind < fRClist.size(); ++ind) 
    fRClist[ind].block(tf);
}

void EVD::NextSlice(){
  fLastButtonType=1;
  if(!fMint)return;
  fEvent=-1;
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) {
    return;
  }
  fNumSlices=GetNumSlices();
  if(fNumSlices>=0){
    fSlice++;
    if(fSlice>=fNumSlices){
      fMint->Next(); 
      fSlice=0;
      fCandSlice=ReadCandSlice();
      return;
    }
    fCandSlice=ReadCandSlice();
    Update();
  }
  else{
    fMint->Next(); 
    return;
  }
}

void EVD::PrevSlice(){
  fLastButtonType=1;
  if(!fMint)return;
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) {
    return ;
  }
  fEvent=-1;
  fNumSlices= GetNumSlices();
  if(fNumSlices>=0){
    fSlice--;
    if(fSlice<0){
      fMint->Prev(); 
      fSlice=0;
      fCandSlice=ReadCandSlice();
      return;
    }
    fCandSlice=ReadCandSlice();
    Update();
  }
  else{
    fMint->Prev(); 
    return;
  }

}

void EVD::NextEvent(){
  fLastButtonType=2;
  if(!fMint)return;
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) {
    return;
  }
  fNumEvents=GetNumEvents();
 
  if(fNumEvents>0){
    fEvent++;
    if(fEvent>=fNumEvents){
      fMint->Next();
      fSlice=0;
      fCandEvent=ReadCandEvent();
      return;
    }
    fCandEvent=ReadCandEvent();  
    Update();
  }
  else{
    fMint->Next(); 
    return;
  }
}

void EVD::PrevEvent(){
  fLastButtonType=2;
  if(!fMint)return;
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) {
    return ;
  }
  fNumEvents=GetNumEvents();
  if(fNumEvents>=0){
    fEvent--;
    if(fEvent<=0){
      fMint->Prev();
      fEvent=0;
      fCandEvent=ReadCandEvent();
      return;
    }
    fCandEvent=ReadCandEvent();
    Update();
  }
  else{
    fMint->Prev(); 
    return;
  }
}

Int_t EVD::GetNumSlices(){

  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) {
    return -1;
  }
  CandRecord* crec = dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (!crec) {
    return -1;
  }
  CandSliceListHandle * slicelist = dynamic_cast<CandSliceListHandle*>(crec->FindCandHandle("CandSliceListHandle"));

  if(!slicelist)return -1;
  return slicelist->GetNDaughters();
}

Int_t EVD::GetNumEvents(){
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) return -1;
  CandRecord* crec = dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (!crec) return -1;
  CandEventListHandle * eventlist = dynamic_cast<CandEventListHandle*>(crec->FindCandHandle("CandEventListHandle"));
  if(!eventlist)return -1;
  return eventlist->GetNDaughters();
}

CandEventHandle *  EVD::ReadCandEvent(){
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom) return 0;
  CandRecord* crec = dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (!crec)  return 0;
  CandEventListHandle * eventlist = dynamic_cast<CandEventListHandle*>(crec->FindCandHandle("CandEventListHandle"));
  if( !eventlist)return 0;
  CandEventHandleItr eventItr(eventlist->GetDaughterIterator());
  Int_t nEvent=0;  
  while (CandEventHandle *event = eventItr() ) {
    if(nEvent==fEvent){
      return event;
    }
    nEvent++;
  }
  return 0;
}

CandSliceHandle *  EVD::ReadCandSlice(){
  const MomNavigator * mom = fMint->GetJint().GetMom();
  if (!mom)  return 0;
  CandRecord* crec = dynamic_cast<CandRecord*>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (!crec) return 0;
  CandSliceListHandle * slicelist = dynamic_cast<CandSliceListHandle*>(crec->FindCandHandle("CandSliceListHandle"));
  if( !slicelist)return 0;
  CandSliceHandleItr sliceItr(slicelist->GetDaughterIterator());
  Int_t nSlice=0;  
  while (CandSliceHandle *slice = sliceItr() ) {
    if(nSlice==fSlice)return slice;
    nSlice++;
  }
  return 0;
}


void EVD::Update()
{
  if (!fMint) return;

  fPad[0]->SetEditable(true);
  fPad[0]->Clear();
  fPad[1]->SetEditable(true);
  fPad[1]->Clear();
  fPad[2]->SetEditable(true);
  fPad[2]->Clear();
  
  int run=0, snarl=0, event=0;
  DataUtil::GetRunSnarlEvent(&(fMint->GetJobC().Mom), run, snarl, event);
  if(fLastButtonType==1){
    fCandSlice=ReadCandSlice();
    fCandEvent=0;
  }
  else if (fLastButtonType==2){
    fCandEvent=ReadCandEvent();
    fCandSlice=0;
  }
  else{
    fCandEvent=0;
    fCandSlice=0;
  }
  fNumSlices=GetNumSlices();
  fNumEvents=GetNumEvents();

  // on new snarl, reset slice counter and CandSlice - this will cause 
  // full color display of entire snarl.

  if(snarl!=fSnarl){
    if(fNumSlices>1){
      fSlice=-1;
      fCandSlice=0;
      fEvent=-1;
      fCandEvent=0;     
    }
    else{
      fSlice=0;
      fEvent=0;
      fCandSlice=ReadCandSlice();
      fCandEvent=ReadCandEvent();
    }
    fSnarl=snarl;
    RangeDouble& r = fMint->GetTimeRange();
    fUserHist->GetAltTimeHist()->SetTotTimeRange(r); 
  }

  // for far detector, suppress display of pre-trigger time interval
  if(fTimeZoom  && (fCandSlice || fCandEvent)){
    ZoomTimetoSlice();
  }
  else if(fMint->GetDetector() == Detector::kFar){
    if((fMint->GetTimeRange().Max()-fMint->GetTimeRange().Min())*1e9>1500){
      fMint->GetTimeRange().Set(fMint->GetTimeRange().Max()-1500e-9,fMint->GetTimeRange().Max());
    }
  }
  
  SetChargeRange();
  ColorSemanticHandler(0);
  ColorSemanticHandler(1);
  
  UpdateView(GraphicsView::kUZ);
  UpdateView(GraphicsView::kVZ);
  UpdateView(GraphicsView::kXY);

  fUserHist->Refresh(GetDisplayOptions()->UserHist());

  UpdateSummary();
  
  if(fRecoText) fRecoText->Update(fMint);
  if(fMCText) fMCText->Update(fMint);   
  if(fMCTree) fMCTree->Update(fMint); 
   
  UpdateCanvas(); 
}

void EVD::ZoomTimetoSlice(){
  Double_t minTime= fMint->GetTimeRange().Min();
  Double_t maxTime= fMint->GetTimeRange().Max();

  Double_t newminTime=1e9;
  Double_t newmaxTime=-1e9;
  if(fCandSlice){
    TIter stripItr(fCandSlice->GetDaughterIterator());  
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())) {
      if(strip->GetTime()<newminTime) newminTime=strip->GetTime();

      if(strip->GetTime()>newmaxTime) newmaxTime=strip->GetTime();
    }
    newminTime -=50e-9;
    newmaxTime +=20e-9;
    
    if(newminTime<newmaxTime && (newminTime!=minTime || newmaxTime!=maxTime)){
      fMint->GetTimeRange().Set(newminTime,newmaxTime);
    }
  }
  else if(fCandEvent){
    TIter stripItr(fCandEvent->GetDaughterIterator());  
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())) {
      if(strip->GetTime()<newminTime) newminTime=strip->GetTime();
      if(strip->GetTime()>newmaxTime) newmaxTime=strip->GetTime();
    }
    newminTime -=50e-9;
    newmaxTime +=20e-9;
    
    if(newminTime<newmaxTime&& (newminTime!=minTime || newmaxTime!=maxTime)){
      fMint->GetTimeRange().Set(newminTime,newmaxTime);
    }
  }  
}


void EVD::UpdateTime()
{
  if (!fMint) return;
  fPad[0]->SetEditable(true);
  fPad[1]->SetEditable(true);
  fPad[2]->SetEditable(true);

  int run=0, snarl=0, event=0;
  DataUtil::GetRunSnarlEvent(&(fMint->GetJobC().Mom), run, snarl, event);
  if(snarl!=fSnarl){
    return;
   }

  if(fViewState[0]->GetColorSemantic()==ViewState::color_is_time){
    ColorSemanticHandler(0);
  }
  if(fViewState[1]->GetColorSemantic()==ViewState::color_is_time){
    ColorSemanticHandler(1);
  }

  if(fLastButtonType!=2)fCandEvent=0;
  
  UpdateView(GraphicsView::kUZ);
  UpdateView(GraphicsView::kVZ);
  UpdateView(GraphicsView::kXY);
   
  UpdateCanvas(); 

  fCandSlice=ReadCandSlice();
  fCandEvent=ReadCandEvent();
}

void EVD::UpdateCanvas()
{

  /* 
     Sets all pads as modified, and redraws the charge histograms and Gfx
     objects. Called as a result of hiding or unhiding 
     a Gfx object, from UpdateTime when the time window is modified, and 
     from Update on a new event. 
  */
  fClear=false;
  fPad[0]->SetEditable(true);
  fPad[1]->SetEditable(true);
  fPad[2]->SetEditable(true);  

  fPad[0]->Modified();
  fPad[1]->Modified();
  fPad[2]->Modified();

  chargepad[0]->Modified();
  chargepad[1]->Modified();
  chargepad[2]->Modified();
 
  UpdateChargeHists(GraphicsView::kUZ);
  UpdateChargeHists(GraphicsView::kVZ);
  
  UpdateGfxObjects(GraphicsView::kUZ);
  UpdateGfxObjects(GraphicsView::kVZ);
  UpdateGfxObjects(GraphicsView::kXY);
 
  GetCanvas().Modified();
  GetCanvas().Update();

  fPad[0]->SetEditable(false);
  fPad[1]->SetEditable(false);
  fPad[2]->SetEditable(false);

}

int EVD::ViewIndex(GraphicsView::GraphicsView_t view)
{
  if(view==GraphicsView::kUZ)return 0;
  if(view==GraphicsView::kVZ)return 1;
  if(view==GraphicsView::kUV)return 2;
  if(view==GraphicsView::kXY)return 2;
  return 2;
}

void EVD::UpdateGfxObjects(GraphicsView::GraphicsView_t view)
{
  Int_t ind=ViewIndex(view);
  fPad[ind]->cd(); 
  GfxList::iterator it, done = fGfxList.end();
  if(fSlice>=0 && fNumSlices>1){
    fDrawAll=false;
    fDrawGhosts=true;
    for (it = fGfxList.begin(); it != done; ++it) {
      if (it->second.graphicsview_type == view) {
        it->first->Configure(*fMint);
        it->first->Draw();
      }
    }
    fDrawGhosts=false;
    for (it = fGfxList.begin(); it != done; ++it) {
      if (it->second.graphicsview_type == view) {
        //      it->first->Configure(*fMint);
        it->first->Draw();
      }
    }
  }
  else{
    fDrawAll=true;
    for (it = fGfxList.begin(); it != done; ++it) {
      if (it->second.graphicsview_type == view) {
        it->first->Configure(*fMint);
        it->first->Draw();
      }
    }
  }
}

void UpdateColorButtonTitle(){
}

void EVD::UpdateView(GraphicsView::GraphicsView_t view)
{

  Int_t ind=ViewIndex(view);

  fPad[ind]->cd();

  if (!fMint) return;
  if(fViewState[ind]->GetColorSemantic()==ViewState::color_is_charge){
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kNone){
      fColorButton[0]->SetTitle("UZ ADC");      
      fColorButton[1]->SetTitle("VZ ADC");
    }
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kPE){
      fColorButton[0]->SetTitle("UZ PE");      
      fColorButton[1]->SetTitle("VZ PE");
    }
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigLin){
      fColorButton[0]->SetTitle("UZ SigLin");      
      fColorButton[1]->SetTitle("VZ SigLin");
    }
    else if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigCorr){
      fColorButton[0]->SetTitle("UZ SigCor");      
      fColorButton[1]->SetTitle("VZ SigCor");
    }
  } 
 
  if (fMint->GetDetector() == Detector::kUnknown) return;
  UgliGeomHandle ugh = fMint->GetUgliGeomHandle();
  if (! ugh.IsValid()) {
    cerr << "EVD::UpdateView: no valid geometry\n";
    return;
  }
    
  if (fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_discreet) 
    {
      vector<UgliScintPlnHandle> usphv = ugh.GetScintPlnHandleVector();
      vector<UgliScintPlnHandle>::reverse_iterator rit, rdone = usphv.rend();
      
      for (rit = usphv.rbegin(); rit != rdone; ++rit) {

        if (! rit->GetPlexPlaneId().IsVetoShield()) break;
      }
      if (rit == rdone) 
        {
          cerr << "EVD::FullZoom: WTF, can't get last plane!\n";
          return;
        }
      
      int first_plane = usphv[0].GetPlaneNumber();
      int last_plane = rit->GetPlaneNumber();
      int mid_plane=248;
      if(fMint->GetDetector() == Detector::kNear)mid_plane=121;
      else if(fMint->GetDetector() == Detector::kCalDet)mid_plane=0;

      
      if(view==GraphicsView::kUZ || view==GraphicsView::kVZ)
        {
          int n_strips = usphv[0].NumberOfStrips();
          
          Double_t xDet[7]={first_plane,last_plane,last_plane,
                            first_plane,first_plane,mid_plane,mid_plane};
          Double_t yDet[7]={0,0,n_strips,n_strips,0,0,n_strips};
          
          Det[ind] = new TPolyLine(7,xDet,yDet);        
          Det[ind]->SetLineColor(10);
          Det[ind]->SetLineWidth(2);
          Det[ind]->SetFillStyle(0);
          Det[ind]->Draw(); 
        }
    }
  else 
    {
      float tmin, tmax, zmin, zmax;
      ugh.GetZExtent(zmin,zmax);
      
      if(ind==0){
        ugh.GetTransverseExtent(PlaneView::kU,tmin,tmax);
      }
      else{
        ugh.GetTransverseExtent(PlaneView::kV,tmin,tmax);
      }
      
      
      if(view==GraphicsView::kUZ || view==GraphicsView::kVZ){     
        if(fMint->GetDetector() == Detector::kFar)
          {
            
            Float_t spacing=5.94*Munits::cm;
            Float_t SM1zEnd=spacing*248;
            Float_t SM2zStart=SM1zEnd+125.*Munits::cm;
            
            Double_t xSM1[5]={zmin,SM1zEnd,SM1zEnd,zmin,zmin};
            Double_t ySM1[5]={tmin,tmin,tmax,tmax,tmin};
            
            SM1[ind] = new TPolyLine(5,xSM1,ySM1);
            SM1[ind]->SetLineColor(10);
            SM1[ind]->SetLineWidth(2);
            SM1[ind]->SetFillStyle(0);
            SM1[ind]->Draw();
            
            Double_t xSM2[5]={SM2zStart,zmax,zmax,SM2zStart,SM2zStart};
            Double_t ySM2[5]={tmin,tmin,tmax,tmax,tmin};
            
            SM2[ind] = new TPolyLine(5,xSM2,ySM2);      
            
            SM2[ind]->SetLineColor(10);
            SM2[ind]->SetLineWidth(2);
            SM2[ind]->SetFillStyle(0);
            SM2[ind]->Draw();
          }
        else
          {
            Double_t xDet[5]={zmin,zmax,zmax,zmin,zmin};
            Double_t yDet[5]={tmin,tmin,tmax,tmax,tmin};
            
            Det[ind] = new TPolyLine(5,xDet,yDet);
            Det[ind]->SetLineColor(10);
            Det[ind]->SetLineWidth(2);
            Det[ind]->SetFillStyle(0);
            Det[ind]->Draw();
          }
      }
      else{
        Outline = new SteelOutline((fMint->GetDetector()));
        Outline->Draw();
        
        if(fMint->GetDetector()==Detector::kFar  && GetDisplayOptions()->DrawVS())DrawVS();
      }
    }
}
    

void EVD::SelectionZoom(ZoomPad* zp)
{
  fCompositeRange->push_back(fPad[0]->GetCurRange().x);
  fCompositeRange->push_back(fPad[0]->GetCurRange().y);
  fCompositeRange->push_back(fPad[1]->GetCurRange().x);
  fCompositeRange->push_back(fPad[1]->GetCurRange().y);
  fZoomHistory->Store(*fCompositeRange);

  BlockRanges(true);
  zp->ApplySelectionToZoom();
  UpdateCanvas();
  BlockRanges(false);
}

void EVD::Unzoom()
{
  BlockRanges(true);
  fZoomHistory->Undo();
  this->UpdateCanvas();
  BlockRanges(false);
}
void EVD::Rezoom()
{
  BlockRanges(true);
  fZoomHistory->Redo();
  this->UpdateCanvas();
  BlockRanges(false);

}
RangeControl<double> EVD::GetColorRangeControl(PlaneView::PlaneView_t view)
{
  int iview = 0;
  if (view == PlaneView::kV) iview = 1;
  return *fColorControl[iview];
}
void EVD::ColorSemanticHandler(int which)
{

  if (which < 0 || which > 2) return;
  
  GfxButton* but = fColorButton[which];
  
  RangeDouble& cr = fColorAxis[which]->GetRange();
  
  switch (fViewState[which]->GetColorSemantic()) {
  case ViewState::color_is_charge:
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kNone){
      if(which==0){
        but->SetTitle("UZ ADC"); 
      }
      else{     
        but->SetTitle("VZ ADC");
      }
    }
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kPE){
      if(which==0){
        but->SetTitle("UZ PE"); 
      }
      else{     
        but->SetTitle("VZ PE");
      }
    }
    if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigLin){
      if(which==0){
        but->SetTitle("UZ SigLin"); 
      }
      else{     
        but->SetTitle("VZ SigLin");
      }
    }
    else if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigCorr){
      if(which==0){
        but->SetTitle("UZ SigCor"); 
      }
      else{     
        but->SetTitle("VZ SigCor");
      }
    }

    fColorAxis[which]->SetScale(1.0);
    if(!GetDisplayOptions()->AutoScaleCharge()){
      BlockRanges(true);
      cr.SetMax(GetDisplayOptions()->ChargeMax());
      cr.SetMin(GetDisplayOptions()->ChargeMin());
      BlockRanges(false);
      }
      else{
        if(fChargeRange)cr.SetFrom(*fChargeRange);
      } 
    break;
  case ViewState::color_is_time:
    but->SetTitle("time");
    fColorAxis[which]->SetScale(Munits::ns);
    cr.SetFrom(fMint->GetTimeRange());   
    break;
  default:
    break;
  }
  fPad[which]->Modified();
  this->GetCanvas().Modified();
  but->Modified();
}

ViewState* EVD::GetViewState(PlaneView::PlaneView_t view)
{
  int iview = 0;
  if (view == PlaneView::kV) iview = 1;
  return fViewState[iview];
}

void EVD::redo() {
  this->UpdateCanvas();
}


void EVD::InitChargeHists(TCanvas& canvas)
{

  /* build histograms display PE vs position along sides of views.
     all PEs are placed in the ChargeHists, while only charge associated
     with reconstructed showers and tracks will be place in the
     RecoChargeHists. Charge vs Z or plane is held in chargehist[0], vs U
     is in [1], and vs V is in [2]
  */

  chargepad[0] = new TPad( "Charge v Z", "Charge v Z", 
                           kZviewXmin,kZviewYmax, 
                           kZviewXmax,kZviewYmax+0.04); 
  chargepad[0]->SetFillColor(23);  

  chargepad[2] = new TPad( "Charge v strip", "Charge v strip", 
                           kZviewXmax,kZviewYmin,
                           kZviewXmax+0.04,kVZviewYmax);
  chargepad[2]->SetFillColor(23);  

  chargepad[1] = new TPad( "Charge u strip", "Charge u strip", 
                           kZviewXmax,kUZviewYmin,
                           kZviewXmax+0.04,kZviewYmax);
  chargepad[1]->SetFillColor(23);  

  fChargeHist[0]= new TH1F("chargevZ","",100,0.,1.); 
  fChargeHist[1]= new TH1F("chargevU","",100,0.,1.); 
  fChargeHist[2]= new TH1F("chargevV","",100,0.,1.);
  
  fRecoChargeHist[0] = new THStack("RecochargevZ","RecochargevZ");
  fRecoChargeHist[1] = new THStack("RecochargevU","RecochargevU");
  fRecoChargeHist[2] = new THStack("RecochargevV","RecochargevV");

  fShwRecoChargeHist[0]= new TH1F("ShwRecochargevZ","",100,0.,1.); 
  fShwRecoChargeHist[1]= new TH1F("ShwRecochargevU","",100,0.,1.); 
  fShwRecoChargeHist[2]= new TH1F("ShwRecochargevV","",100,0.,1.);

  fTrkRecoChargeHist[0]= new TH1F("TrkRecochargevZ","",100,0.,1.); 
  fTrkRecoChargeHist[1]= new TH1F("TrkRecochargevU","",100,0.,1.); 
  fTrkRecoChargeHist[2]= new TH1F("TrkRecochargevV","",100,0.,1.);

  int i;
  for(i=0;i<3;i++)
    {  
      chargepad[i]->SetGridx(0);
      chargepad[i]->SetGridy(0);
      chargepad[i]->SetLeftMargin(0);
      chargepad[i]->SetRightMargin(0);
      chargepad[i]->SetTopMargin(0);
      chargepad[i]->SetBottomMargin(0);
      chargepad[i]->SetBorderSize(0);
      chargepad[i]->SetBorderMode(1);
      chargepad[i]->SetTicks(0,0);
      chargepad[i]->SetFillStyle(1001);
      chargepad[i]->SetLineWidth(1);
      chargepad[i]->SetFrameFillColor(0);
      canvas.cd();
      chargepad[i]->Draw();  
      chargepad[i]->cd();
      fChargeHist[i]->SetTickLength(0,"Y"); 
      fChargeHist[i]->SetStats(kFALSE);   
      fChargeHist[i]->SetLineColor(1);
      fChargeHist[i]->SetLineWidth(1);
     
      fShwRecoChargeHist[i]->SetTickLength(0,"Y");
      fShwRecoChargeHist[i]->SetStats(kFALSE);      
      fShwRecoChargeHist[i]->SetFillColor(2);
      fShwRecoChargeHist[i]->SetLineColor(1);
      fShwRecoChargeHist[i]->SetLineWidth(1);
      fTrkRecoChargeHist[i]->SetTickLength(0,"Y");
      fTrkRecoChargeHist[i]->SetStats(kFALSE);      
      fTrkRecoChargeHist[i]->SetFillColor(9);
      fTrkRecoChargeHist[i]->SetLineColor(1);
      fTrkRecoChargeHist[i]->SetLineWidth(1);
      fRecoChargeHist[i]->Add(fTrkRecoChargeHist[i]);
      fRecoChargeHist[i]->Add(fShwRecoChargeHist[i]);

      if(i==0) 
        {
          fChargeHist[i]->Draw("bar hist");
          fRecoChargeHist[i]->Draw("bar hist same");

        }
      else
        {
          fChargeHist[i]->Draw("hbar hist");
          fRecoChargeHist[i]->Draw("hbar hist same");
        }

 }
  canvas.cd();
}


void EVD::UpdateChargeHists(GraphicsView::GraphicsView_t view)  
{
  /* Fill histograms displaying PE vs position along sides of views.
     all PEs are placed in the ChargeHists, while only charge associated
     with reconstructed showers and tracks will be place in the
     RecoChargeHists. Charge vs Z or plane is held in chargehist[0], vs U
     is in [1], and vs V is in [2]
  */
  
 // set index based on graphics view

  Int_t ind=2;
  if(view==GraphicsView::kUZ)ind=0;
  if(view==GraphicsView::kVZ)ind=1;
  if(view==GraphicsView::kUV)ind=2;
  if(view==GraphicsView::kXY)ind=2;
  fPad[ind]->cd();    
  if (!fMint)return;

  // set bins in charge histograms based on view scales

  Detector::Detector_t det = fMint->GetDetector();
  float zmin = fRangeAxis[2]->GetRange().Min();
  float zmax = fRangeAxis[2]->GetRange().Max();
  float umin = fRangeAxis[0]->GetRange().Min();
  float umax = fRangeAxis[0]->GetRange().Max();
  float vmin = fRangeAxis[1]->GetRange().Min();
  float vmax = fRangeAxis[1]->GetRange().Max();
  int nbinsz = (int)(zmax-zmin+1);
  int nbinsu = (int)(umax-umin+1);
  int nbinsv = (int)(vmax-vmin+1);
  
  if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous)
    {
      nbinsz=(int)((zmax-zmin)/0.06);
      nbinsu=(int)((umax-umin)/0.06);
      nbinsv=(int)((vmax-vmin)/0.06);
    }
  
  if(view==GraphicsView::kUZ)
    {
      fChargeHist[0]->Reset("ICE");
      fChargeHist[1]->Reset("ICE");
      fShwRecoChargeHist[0]->Reset("ICE");
      fShwRecoChargeHist[1]->Reset("ICE");
      fTrkRecoChargeHist[0]->Reset("ICE");
      fTrkRecoChargeHist[1]->Reset("ICE");

      fChargeHist[0]->SetBins(nbinsz,zmin,zmax);
      fChargeHist[1]->SetBins(nbinsu,umin,umax);
      fShwRecoChargeHist[0]->SetBins(nbinsz,zmin,zmax);
      fShwRecoChargeHist[1]->SetBins(nbinsu,umin,umax);
      fTrkRecoChargeHist[0]->SetBins(nbinsz,zmin,zmax);
      fTrkRecoChargeHist[1]->SetBins(nbinsu,umin,umax);

    }
  else if(view==GraphicsView::kVZ)
    {
      fChargeHist[2]->Reset("ICE");
      fChargeHist[2]->SetBins(nbinsv,vmin,vmax);        
      fShwRecoChargeHist[2]->Reset("ICE");
      fShwRecoChargeHist[2]->SetBins(nbinsv,vmin,vmax); 
      fTrkRecoChargeHist[2]->Reset("ICE");
      fTrkRecoChargeHist[2]->SetBins(nbinsv,vmin,vmax); 
    }


  CandRecord* candrec = dynamic_cast<CandRecord*>
    (fMint->GetJobC().Mom.GetFragment("CandRecord", "PrimaryCandidateRecord"));    if (!candrec) return ;
  
  if(fCandSlice){
    TIter stripItr(fCandSlice->GetDaughterIterator());  
    while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())) {
      PlaneView::PlaneView_t pv = strip->GetPlaneView();
      double q = strip->GetCharge(CalDigitType::kPE);
      if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous){
        if (view==GraphicsView::kUZ && 
            (pv == PlaneView::kU || 
             (det == Detector::kCalib && pv == PlaneView::kX))) 
          {
            fChargeHist[0]->Fill( strip->GetZPos(),q);
            fChargeHist[1]->Fill( strip->GetTPos(),q);
          }
        else if (view==GraphicsView::kVZ && 
                 (pv == PlaneView::kV || 
                  (det == Detector::kCalib && pv ==PlaneView::kY)))
          {
            fChargeHist[0]->Fill( strip->GetZPos(),q);
            fChargeHist[2]->Fill( strip->GetTPos(),q);
          } 
      }
      else{
        if (view==GraphicsView::kUZ && 
            (pv == PlaneView::kU || 
             (det == Detector::kCalib && pv == PlaneView::kX))) 
          {
            fChargeHist[0]->Fill( strip->GetPlane(),q);
            fChargeHist[1]->Fill( strip->GetStrip(),q);
          }
        else if (view==GraphicsView::kVZ && 
                 (pv == PlaneView::kV || 
                  (det == Detector::kCalib && pv ==PlaneView::kY)))
          {
            fChargeHist[0]->Fill( strip->GetPlane(),q);
            fChargeHist[2]->Fill( strip->GetStrip(),q);
          } 
      }
    }
  }
  else if( fCandEvent){
    TIter stripItr(fCandEvent->GetDaughterIterator());
   while (CandStripHandle *strip = dynamic_cast<CandStripHandle*>
           (stripItr())) {
      PlaneView::PlaneView_t pv = strip->GetPlaneView();
      double q = strip->GetCharge(CalDigitType::kPE);
      if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous){
        if (view==GraphicsView::kUZ && 
            (pv == PlaneView::kU || 
             (det == Detector::kCalib && pv == PlaneView::kX))) 
          {
            fChargeHist[0]->Fill( strip->GetZPos(),q);
            fChargeHist[1]->Fill( strip->GetTPos(),q);
          }
        else if (view==GraphicsView::kVZ && 
                 (pv == PlaneView::kV || 
                  (det == Detector::kCalib && pv ==PlaneView::kY)))
          {
            fChargeHist[0]->Fill( strip->GetZPos(),q);
            fChargeHist[2]->Fill( strip->GetTPos(),q);
          } 
      }
      else{
        if (view==GraphicsView::kUZ && 
            (pv == PlaneView::kU || 
             (det == Detector::kCalib && pv == PlaneView::kX))) 
          {
            fChargeHist[0]->Fill( strip->GetPlane(),q);
            fChargeHist[1]->Fill( strip->GetStrip(),q);
          }
        else if (view==GraphicsView::kVZ && 
                 (pv == PlaneView::kV || 
                  (det == Detector::kCalib && pv ==PlaneView::kY)))
          {
            fChargeHist[0]->Fill( strip->GetPlane(),q);
            fChargeHist[2]->Fill( strip->GetStrip(),q);
          } 
      }
    }  
  }    
  else{
    const CandDigitListHandle* cslh = fMint->GetDigits();
    if (!cslh) return;
    vector<const CandDigitHandle*> dv = 
      DataUtil::CDL2STLvector<CandDigitHandle>(*cslh);
    int siz = dv.size();
    //  if (! siz) return; 
    for (int ncd = 0; ncd < siz; ++ncd) {
      const CandDigitHandle* cdh = dv[ncd];
      const PlexSEIdAltL& altl = cdh->GetPlexSEIdAltL();
      double q = altl.GetBestItem().GetPE(); 
      PlaneView::PlaneView_t pv = altl.GetPlaneView();
      
      if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous)
        {
          UgliGeomHandle ugh(*cdh->GetVldContext());
          UgliStripHandle ush;
          if(altl.GetSize()>0){
            ush = ugh.GetStripHandle(altl.GetBestItem().GetSEId());
            if (ush.IsValid()){
              if (view==GraphicsView::kUZ && 
                  (pv == PlaneView::kU || 
                   (det == Detector::kCalib && pv == PlaneView::kX))) 
                {
                  
                  fChargeHist[0]->Fill( ush.GlobalPos(0).Z(),q);
                  fChargeHist[1]->Fill( ush.GetTPos(),q);
                }
              else if (view==GraphicsView::kVZ && 
                       (pv == PlaneView::kV || 
                        (det == Detector::kCalib && pv ==PlaneView::kY)))
                {
                  
                  fChargeHist[0]->Fill( ush.GlobalPos(0).Z(),q);
                  fChargeHist[2]->Fill( ush.GetTPos(),q);
                } 
            }
          }
        }
      else
        {
          if(altl.GetSize()>0){
            PlexStripEndId seid;
            seid = altl.GetBestItem().GetSEId();
            if (view==GraphicsView::kUZ && 
                (pv == PlaneView::kU || 
                 (det == Detector::kCalib && pv ==PlaneView::kX))) 
              {
                fChargeHist[0]->Fill( seid.GetPlane(),q);
                fChargeHist[1]->Fill( seid.GetStrip(),q);
              }
            else if (view==GraphicsView::kVZ && 
                     (pv == PlaneView::kV || 
                      (det == Detector::kCalib && pv ==PlaneView::kY)))
              {
                
                fChargeHist[0]->Fill( seid.GetPlane(),q);
                fChargeHist[2]->Fill( seid.GetStrip(),q);
              }
          }
        }    
    }
  }

  // loop over candtracks, filling histograms with strip PEs

    const CandTrackListHandle* tracklisthandle=fMint->GetTracks(); 
  //  const CandTrackListHandle* tracklisthandle = dynamic_cast<CandTrackListHandle*>(candrec->FindCandHandle("CandTrackCamListHandle","CandTrackSRList"));
  if (tracklisthandle) 
    {
      TIter trackItr(tracklisthandle->GetDaughterIterator());
      while (CandTrackHandle *track = dynamic_cast<CandTrackHandle*>
             (trackItr())) 
        {
        
          CandTrackHandle * usetrack =track;
          Bool_t usethis=false;
          if(!fCandSlice && !fCandEvent){
            usethis=true;
          }
          else if(fCandSlice){
            CandSliceHandle slc1 =  *(track->GetCandSlice());
            CandSliceHandle slc2= *(fCandSlice);
            if(slc1==slc2 || slc1.IsCloneOf(slc2))usethis=true;
          }
          else if (fCandEvent){
            for( Int_t itrack=0;itrack<=fCandEvent->GetLastTrack();itrack++){
              const CandFitTrackHandle * evtrack = dynamic_cast<const CandFitTrackHandle*>(fCandEvent->GetTrack(itrack));
              CandTrackHandle * findtrack=evtrack->GetFinderTrack();
              if(findtrack){
                if (*findtrack==*track){
                  usethis=true;
                  break;
                }
              }
              if(track->InheritsFrom("CandFitTrackHandle") && dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack()){
                if(*evtrack == *(dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack())){
                  usetrack = dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack();           
                  usethis=true;
                  break;
                }
              }
            }
          }
          if(usethis){ 
            TIter titr(usetrack->GetDaughterIterator());
            while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) 
              {
                double q = csh->GetCharge(CalDigitType::kPE); 
                PlaneView::PlaneView_t pv = csh->GetPlaneView();    
                if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous)
                  {
                    
                    if (view==GraphicsView::kUZ && 
                        (pv == PlaneView::kU || 
                         (det == Detector::kCalib && pv == PlaneView::kX))) 
                      { 
                        fTrkRecoChargeHist[0]->Fill( csh->GetZPos(),q);
                        fTrkRecoChargeHist[1]->Fill( csh->GetTPos(),q);
                      }
                    else if (view==GraphicsView::kVZ && 
                             (pv == PlaneView::kV || 
                              (det == Detector::kCalib && pv ==PlaneView::kY)))
                      {               
                        fTrkRecoChargeHist[0]->Fill( csh->GetZPos(),q);
                        fTrkRecoChargeHist[2]->Fill( csh->GetTPos(),q);
                      } 
                  }
                else
                  {
                    if (view==GraphicsView::kUZ && 
                        (pv == PlaneView::kU || 
                         (det == Detector::kCalib && pv ==PlaneView::kX))) 
                      {
                        fTrkRecoChargeHist[0]->Fill( csh->GetPlane(),q);
                        fTrkRecoChargeHist[1]->Fill( csh->GetStrip(),q);
                      }
                    else if (view==GraphicsView::kVZ && 
                             (pv == PlaneView::kV || 
                              (det == Detector::kCalib && pv ==PlaneView::kY)))
                      {
                        fTrkRecoChargeHist[0]->Fill( csh->GetPlane(),q);
                        fTrkRecoChargeHist[2]->Fill( csh->GetStrip(),q);
                      }
                  }        
              }
          }
        }
    }

  // loop over candshowers, filling histograms with strip PEs
  

  const CandShowerListHandle* showerlisthandle = fMint->GetShowers();
  if (showerlisthandle) 
    {
      TIter showerItr(showerlisthandle->GetDaughterIterator());
      while (CandShowerHandle *shower = dynamic_cast<CandShowerHandle*>
             (showerItr())) 
        {
          Bool_t usethis=false;
          if(!fCandSlice && !fCandEvent){
            usethis=true;
          }
          else if(fCandSlice){     
            CandSliceHandle slc1 =  *(shower->GetCandSlice());
            CandSliceHandle slc2 = *(fCandSlice);
            //      cout << fCandSlice << " " << shower->GetCandSlice() << " " << fCandSlice->GetUidInt() << " " << shower->GetCandSlice()->GetUidInt() << endl;
            if(slc1==slc2 || slc1.IsCloneOf(slc2))usethis=true;
          }
          else if (fCandEvent){
            for( Int_t ishower=0;ishower<=fCandEvent->GetLastShower();ishower++){
              const CandShowerHandle *evshower = dynamic_cast<const CandShowerHandle *>(fCandEvent->GetShower(ishower));
              if (*evshower==*shower){
                usethis=true;
                break;
              }
            }
          }
          if(usethis){
            TIter titr(shower->GetDaughterIterator());
            while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) 
              {
                double q = csh->GetCharge(CalDigitType::kPE);
                PlaneView::PlaneView_t pv = csh->GetPlaneView();    
                if(fViewState[ind]->GetSpatialMetric() == ViewState::metric_is_continuous)
                  {
                    
                    if (view==GraphicsView::kUZ && 
                        (pv == PlaneView::kU || 
                         (det == Detector::kCalib && pv == PlaneView::kX))) 
                      {
                        fShwRecoChargeHist[0]->Fill( csh->GetZPos(),q);
                        fShwRecoChargeHist[1]->Fill( csh->GetTPos(),q);
                      }
                    else if (view==GraphicsView::kVZ && 
                             (pv == PlaneView::kV || 
                              (det == Detector::kCalib && pv ==PlaneView::kY)))
                      {
                        fShwRecoChargeHist[0]->Fill( csh->GetZPos(),q);
                        fShwRecoChargeHist[2]->Fill( csh->GetTPos(),q);
                      } 
                  }
                else
                  {
                    if (view==GraphicsView::kUZ && 
                        (pv == PlaneView::kU || 
                         (det == Detector::kCalib && pv ==PlaneView::kX))) 
                      { 
                        fShwRecoChargeHist[0]->Fill( csh->GetPlane(),q);
                        fShwRecoChargeHist[1]->Fill( csh->GetStrip(),q);
                      }
                    else if (view==GraphicsView::kVZ && 
                             (pv == PlaneView::kV || 
                              (det == Detector::kCalib && pv ==PlaneView::kY)))
                      {
                        fShwRecoChargeHist[0]->Fill( csh->GetPlane(),q);
                        fShwRecoChargeHist[2]->Fill( csh->GetStrip(),q);
                      }
                  }        
              } 
          }
        }
    }
  // redraw histograms 
  if(view==GraphicsView::kUZ)
    {      
      chargepad[1]->cd();
      fChargeHist[1]->Draw("hbar hist");
      fRecoChargeHist[1]->RecursiveRemove(fTrkRecoChargeHist[1]);
      fRecoChargeHist[1]->RecursiveRemove(fShwRecoChargeHist[1]); 
      fRecoChargeHist[1]->Add(fTrkRecoChargeHist[1]);
      fRecoChargeHist[1]->Add(fShwRecoChargeHist[1]); 
      fRecoChargeHist[1]->Draw("hbar hist same");  
 
     }
  else if(view==GraphicsView::kVZ)
    {
      chargepad[0]->cd();
      fChargeHist[0]->Draw("bar hist");
      fRecoChargeHist[0]->RecursiveRemove(fTrkRecoChargeHist[0]);
      fRecoChargeHist[0]->RecursiveRemove(fShwRecoChargeHist[0]); 
      fRecoChargeHist[0]->Add(fTrkRecoChargeHist[0]);
      fRecoChargeHist[0]->Add(fShwRecoChargeHist[0]); 
      fRecoChargeHist[0]->Draw("bar hist same");

      chargepad[2]->cd();
      fChargeHist[2]->Draw("hbar hist");
      fRecoChargeHist[2]->RecursiveRemove(fTrkRecoChargeHist[2]);
      fRecoChargeHist[2]->RecursiveRemove(fShwRecoChargeHist[2]); 

      fRecoChargeHist[2]->Add(fTrkRecoChargeHist[2]);
      fRecoChargeHist[2]->Add(fShwRecoChargeHist[2]); 
      fRecoChargeHist[2]->Draw("hbar hist same");     
    }
}

template<class TYPE> void killer(TYPE* obj) {delete obj; }

void EVD::MCtext()
 
{
  // write out NeuKine to a text box.
  // if the textbox is not currently visible, build it, and set to full width   
  if(!fTextBox){
    fTextBox = manage(new GuiBox(*fPageDisplay,kHorizontalFrame));
    fTextBox->SetHeight(200);
    fPageDisplay->SetWidth(fPageDisplay->GetWidth());
    fTextBox->SetWidth(fPageDisplay->GetWidth());
    fTextBox->SetLayoutHints(kLHintsTop || kLHintsLeft || kLHintsExpandX);
    fPageDisplay->Add(*fTextBox);
  } 

  // If the NeuKine data is already being viewed, we want to kill it.
  // Otherwise, create a new text view for this.

  if(fMCtextbox){
    fMCtextbox->Resize(1,1);
    fTextBox->Remove(*fMCtextbox);
    fMCtextbox=0;
    fMCbut->SetDown(false);
    fMCText=0;
  }
  else{ 
    fMCtextbox = manage(new GuiTextView(*fTextBox,1,1)); 
    fTextBox->Add(*fMCtextbox);
    fMCbut->SetDown(true);
    fMCText = manage(new MCText(fMCtextbox));
    fTextBox->SetHeight(200);
    fTextBox->SetWidth(fPageDisplay->GetWidth());
    fMCtextbox ->AddLine(" MC Kinematics ");
    fMCText->Update(fMint);
  }

  // If none of the text views are open at this point (we've just killed
  // the last), then remove the text box from the bottom of the display. 

  if(!fMCtextbox && !fRecotextbox && !fMCTreescroll && !fDigittextbox){
   fTextBox->Resize(1,1);
   fPageDisplay->Remove(*fTextBox);
   fPageDisplay->SetWidth(fPageDisplay->GetWidth());
   fTextBox=0;
  }

  //  refresh the main window.
  
  GuiMainWindow* mw = fPageDisplay->GetTab()->GetMainWindow();
  assert(mw);
  mw->ShowAll();
  mw->ConnectClose();
}

void EVD::MCTreetext()
 
{

  // write out StdHep tree to a text box.

  // if the textbox is not currently visible, build it, and set to full width   

  if(!fTextBox)
    {
      fTextBox = manage(new GuiBox(*fPageDisplay,kHorizontalFrame));
      fTextBox->SetHeight(200);
      fTextBox->SetWidth(fPageDisplay->GetWidth());
      fTextBox->SetLayoutHints(kLHintsTop || kLHintsLeft || kLHintsExpandX);
      fPageDisplay->Add(*fTextBox);
    } 

  // If the StdHep is already being viewed, we want to kill it.
  // Otherwise, create a new text view and scroll tree for this.

  if(fMCTreescroll)
    {
      fMCTreescroll->Resize(1,1);
      fTextBox->Remove(*fMCTreescroll);
      fMCTreescroll=0;
      fMCTreebut->SetDown(false);
      fMCTree=0;
    }
  else
    { 
      fMCTreescroll = manage(new GuiScrolled(*fTextBox)); 
      fTextBox->Add(*fMCTreescroll);  
      GuiTree* gt = manage(new GuiTree(*fMCTreescroll->GetViewPort()));
      fMCTreescroll->Add(*gt);
      gt->SetCanvas(fMCTreescroll);
      fMCTree = manage(new MCTree(gt));
      fMCTreebut->SetDown(true);
      fTextBox->SetHeight(200);
      fTextBox->SetWidth(fPageDisplay->GetWidth());
      fMCTree->Update(fMint);
    }

  // If none of the text views are open at this point (we've just killed
  // the last), then remove the text box from the bottom of the display. 

  if(!fMCTreescroll && !fRecotextbox && !fMCtextbox && !fDigittextbox)
    {
      fTextBox->Resize(1,1);
      fPageDisplay->Remove(*fTextBox);
      fTextBox=0;
    }
  GuiMainWindow* mw = fPageDisplay->GetTab()->GetMainWindow();
  assert(mw);
  mw->ShowAll();
  mw->ConnectClose();
}

void EVD::Digittext()
 
{
  if(!fTextBox)
    {
    fTextBox = manage(new GuiBox(*fPageDisplay,kHorizontalFrame));
    fTextBox->SetHeight(200);
    fTextBox->SetWidth(fPageDisplay->GetWidth());
    fTextBox->SetLayoutHints(kLHintsTop || kLHintsLeft || kLHintsExpandX);
    fPageDisplay->Add(*fTextBox);
    } 
  if(fDigittextbox)
    {
      fDigittextbox->Resize(1,1);
      fTextBox->Remove(*fDigittextbox);
      fDigittextbox=0;
      fDigitbut->SetDown(false);
      fDigitText=0;
    }
  else
    { 
      fDigittextbox = manage(new GuiTextView(*fTextBox,1,1)); 
      fTextBox->Add(*fDigittextbox);
      fDigitbut->SetDown(true);
      fDigitText = new DigitText(fDigittextbox); 
      fTextBox->SetHeight(200);
      fTextBox->SetWidth(fPageDisplay->GetWidth());
      fDigittextbox ->AddLine("Digitization Detail ");
    }
  if(!fMCtextbox && !fRecotextbox && !fMCTreescroll && !fDigittextbox)
    {
      fTextBox->Resize(1,1);
      fPageDisplay->Remove(*fTextBox);
      fTextBox=0;
    }

  GuiMainWindow* mw = fPageDisplay->GetTab()->GetMainWindow();
  assert(mw);
  mw->ShowAll();
  mw->ConnectClose();
}

void EVD::Recotext()
{    
 // write out Reco dump to a text box.

  // if the textbox is not currently visible, build it, and set to full width 

  if(!fTextBox)
    {
      fTextBox = manage(new GuiBox(*fPageDisplay,kHorizontalFrame));
      fTextBox->SetHeight(200);
      fTextBox->SetWidth(fPageDisplay->GetWidth());
      fTextBox->SetLayoutHints(kLHintsTop || kLHintsLeft || kLHintsExpandX);
      fPageDisplay->Add(*fTextBox);
    } 

  // If the Reco dump is already being viewed, we want to kill it.
  // Otherwise, create a new text view for it.

  if(fRecotextbox)
    {
      fRecotextbox->Resize(1,1);
      fTextBox->Remove(*fRecotextbox);
      fRecotextbox=0;
      fRecobut->SetDown(false);
      fRecoText=0;                  
    }
  else
    { 
      fRecotextbox = manage(new GuiTextView(*fTextBox,1,1)); 
      FontStruct_t myfont = gClient->GetFontByName("-adobe-helvetica-medium-r-*-*-14-*-*-*-*-*-iso8859-1");
      fRecotextbox->SetFont(myfont);
      
      fTextBox->Add(*fRecotextbox);
      fRecobut->SetDown(true);
      fRecoText = new RecoText(fRecotextbox);
      fRecoText->Update(fMint);
    }

  // If none of the text views are open at this point (we've just killed
  // the last), then remove the text box from the bottom of the display. 


  if(!fMCtextbox && !fRecotextbox && ! fMCTreescroll && !fDigittextbox)
    {
      fTextBox->Resize(1,1);
      fPageDisplay->Remove(*fTextBox);
      fTextBox=0;
    }
  GuiMainWindow* mw = fPageDisplay->GetTab()->GetMainWindow();
  assert(mw);
  mw->ShowAll();
  mw->ConnectClose();
}


void EVD::UpdateSummary()
{

  /* Here we write to the summary pad a short summary of the reconstruction
     results.  If there is a SimSnarlRecord available, we assume that this
     is MC data, and write out some NeuKine summary stuff. 
  */


  if(!fMint) return;
  
 float textsize=0.08;
  TextPad->cd();
  TextPad->Clear();

  CandRecord* candrec = dynamic_cast<CandRecord*>
    (fMint->GetJobC().Mom.GetFragment("CandRecord", "PrimaryCandidateRecord")); 

  if (candrec==0) {
    return ;
  }

  
  Int_t bestNeu=-1;
  Bool_t simulation = false;
  SimSnarlRecord *ssr = 
    dynamic_cast<SimSnarlRecord*>(fMint->GetJobC().Mom.GetFragment("SimSnarlRecord"));
  if (ssr) simulation=true; 

  // highlight text box color if in spill
  RawDaqSnarlHeader *rdsh=   
    dynamic_cast<RawDaqSnarlHeader*>(fMint->GetJobC().Mom.GetFragment("RawDaqSnarlHeader"));
  if (rdsh){
    // check header for spill flag
    if((rdsh->GetTrigSrc()==0x20000 && fMint->GetDetector() == Detector::kFar) ||(rdsh->GetTrigSrc()==0x10000 && fMint->GetDetector() == Detector::kNear)){
      TextPad->SetFillColor(2);
    }     
    else{
      TextPad->SetFillColor(17);
    }
  }
  
  TruthHelper truthHelp(&(fMint->GetJobC().Mom));
  int nLine=1;
  int run=0, snarl=0, event=0;
  DataUtil::GetRunSnarlEvent(&(fMint->GetJobC().Mom), run, snarl, event);
  
  int nTracks=0;
  int nShowers=0;
  int nEvents=0;

  CandTrackHandle * primtrack=0; 
  CandShowerHandle * primshw=0;
  CandShowerListHandle* showerlisthandle=0;
  CandTrackListHandle* tracklisthandle=0;
  /*
  if(fLastButtonType==2){
    fEvent++;
    fCandEvent=ReadCandEvent();
    fEvent--;
  }
  */
  Bool_t usefinder=false;
  if(fCandEvent){
    CandEventListHandle* eventlisthandle =
      dynamic_cast<CandEventListHandle*>
      (candrec->FindCandHandle("CandEventListHandle"));
    if (eventlisthandle) {
      TIter eventItr(eventlisthandle->GetDaughterIterator());
      while (CandEventHandle *event = dynamic_cast<CandEventHandle*>
             (eventItr())) {
        nEvents++;
        if(fCandEvent==event){ 
          primtrack=event->GetPrimaryTrack();
          if(primtrack){
            if(primtrack->GetNDaughters()==0 && 
               primtrack->InheritsFrom("CandFitTrackHandle") &&  
               dynamic_cast<CandFitTrackHandle*>(primtrack)->GetFinderTrack()){
              primtrack = dynamic_cast<CandFitTrackHandle*>(primtrack)->GetFinderTrack();
              usefinder=true;
            }
          }
          primshw=event->GetPrimaryShower();
          nTracks=event->GetLastTrack()+1;
          nShowers=event->GetLastShower()+1;
        }
      }
    } 
  }
  else{
    tracklisthandle = fMint->GetTracks();
    if (tracklisthandle){   
      Float_t maxscore=-1e6;
      TIter trackItr(tracklisthandle->GetDaughterIterator());
      while (CandTrackHandle *track = dynamic_cast<CandTrackHandle*>
             (trackItr())){
        if(track){
          CandSliceHandle slc1 =  *(track->GetCandSlice());
          CandSliceHandle slc2;
          if(fCandSlice)slc2=*(fCandSlice);
          if(slc1==slc2 || !fCandSlice || slc1.IsCloneOf(slc2)){
            if(track->GetNDaughters()==0 && 
               track->InheritsFrom("CandFitTrackHandle") &&  
               dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack()){
              track = dynamic_cast<CandFitTrackHandle*>(track)->GetFinderTrack();
              usefinder=true;
            }       
            nTracks++;
            if(TMath::Abs(track->GetScore())>=maxscore){
              maxscore=track->GetScore();
              primtrack=track;
            }
          }
        }
      }
    }
    showerlisthandle = fMint->GetShowers();
    if (showerlisthandle) {
      TIter showerItr(showerlisthandle->GetDaughterIterator());
      while (CandShowerHandle *shower = dynamic_cast<CandShowerHandle*>
             (showerItr())){
        if(shower){
          CandSliceHandle slc1 =  *(shower->GetCandSlice());
          CandSliceHandle slc2;
          if(fCandSlice)slc2=*(fCandSlice);
          if(slc1==slc2 || !fCandSlice || slc1.IsCloneOf(slc2)){
            nShowers++;
          }
        }
      }
    }
  }
 

 

  char * cline = new char[80];

  if(fNumSlices>0){
    if(fSlice>=0 || fEvent>=0){
      if(fCandEvent){
        sprintf(cline,"Run: %d    Snarl:  %d    Slice:  %d of %d   Event: %d of %d",run,snarl,fSlice+1,fNumSlices,fEvent+1,fNumEvents);
      }
      else{
        sprintf(cline,"Run: %d    Snarl:  %d    Slice:  %d of %d   All %d Events",run,snarl,fSlice+1,fNumSlices,fNumEvents);
      }
    }
    else{
      sprintf(cline,"Run: %d        Snarl:  %d        All  %d Slices",run,snarl,fNumSlices);
    }
  }
  else{
    sprintf(cline,"Run: %d        Snarl:  %d        No Slice Found",run,snarl);
  }
  Int_t ntline=0;
  cline[79]=0;
  tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
  nLine+=2;
  tline[ntline]->SetTextFont(62);
  tline[ntline]->SetTextSize(textsize);
  tline[ntline]->Draw();
  ntline++;

  sprintf(cline,"Reconstruction Summary");
  cline[79]=0;
  tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
  nLine++;
  tline[ntline]->SetTextFont(52);
  tline[ntline]->SetTextSize(textsize);
  tline[ntline]->Draw();
  ntline++;

  sprintf(cline,"# Tracks:  %d        # Showers: %d",nTracks,nShowers);
  cline[79]=0;
  tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
  nLine+=2;
  tline[ntline]->SetTextFont(42);
  tline[ntline]->SetTextSize(textsize);
  tline[ntline]->Draw();
  ntline++;
  if(fNumSlices>0 && fSlice<0 && fEvent<0) return;   // looking at all slices in overlay

  if(primtrack){
    CandFitTrackHandle *fittrack = 0;
    CandFitTrackSRHandle *fittracksr = 0;
    float P = primtrack->GetMomentum();
    if (primtrack->InheritsFrom("CandFitTrackHandle")) {
      fittrack = dynamic_cast<CandFitTrackHandle*>(primtrack);
    }
    if (primtrack->InheritsFrom("CandFitTrackSRHandle")) {
      fittracksr = dynamic_cast<CandFitTrackSRHandle*>(primtrack);
    }
    float length=primtrack->GetdS();
    float vtxX = (primtrack->GetVtxU()-primtrack->GetVtxV())/TMath::Sqrt(2.);
    float vtxY = (primtrack->GetVtxU()+primtrack->GetVtxV())/TMath::Sqrt(2.);
    float vtxZ = primtrack->GetVtxZ();
    float cosTheta = -(primtrack->GetDirCosU()+primtrack->GetDirCosV())/TMath::Sqrt(2.);
    
    float Pfit=0;
    float chi2=0;
    Int_t pass=0;
    if(fittrack){
      Pfit= fittrack->GetMomentumCurve()*fittrack->GetEMCharge();
      chi2= fittrack->GetChi2();
      P = fittrack->GetMomentumRange();
      pass=fittrack->GetPass();
    }
    Float_t purity = 0.0;
    Float_t completeSlice=0.0;
    Float_t completeAll=0.0;
   
    if(simulation){
      CandTrackHandle trk = *primtrack;
      Int_t bestTrack = truthHelp.GetBestTrackIdMatch(trk);
      bestNeu = truthHelp.GetNeuId(bestTrack);
      purity = truthHelp.TrackPurity(trk,bestTrack);
      completeAll = truthHelp.TrackCompleteness(trk);   
      CandSliceHandle slc;
      if(fCandEvent){
        slc = * fCandEvent->GetCandSlice();
      }
      else if(fCandSlice){
        slc = * fCandSlice;
      }
      else if(fNumSlices==1){
        slc = * trk.GetCandSlice();
      }
      if(fCandSlice || fCandEvent || fNumSlices==1){  
        completeSlice = truthHelp.TrackCompleteness(trk,slc);
        
      }
    }
    if(!usefinder){
      sprintf(cline,
              "Primary Track>  Len:%5.1f Range E:%5.1f GeV Fit P:%5.1f GeV",
              length,
              P,
              Pfit
              );
    }
    else{
      sprintf(cline,
              "(Finder) Primary Track>  Len:%5.1f Range E:%5.1f GeV",
              length,
              P
              );
    }
 
    cline[79]=0;
    tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
    nLine++;
    tline[ntline]->SetTextFont(42);
    tline[ntline]->SetTextSize(textsize);
    tline[ntline]->Draw();
    ntline++;
    if(simulation){
      sprintf(cline,
              " Purity:%5.2f Compl.(Slice):%5.2f Compl.(All):%5.2f Pass:%1d",
            purity,completeSlice,completeAll,pass);
    }
    else{
      sprintf(cline,
            "   Vertex: (%3.1f,%3.1f,%3.1f) cos#theta: %3.2f Pass: %1d",
            vtxX, vtxY, vtxZ, cosTheta, pass);
    }
    cline[79] = 0;
    tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
    nLine++;
    tline[ntline]->SetTextFont(42);
    tline[ntline]->SetTextSize(textsize);
    tline[ntline]->Draw();
    ntline++;
  }
  float PEs=0;
  float Gev=0;
  Float_t purity=0;
  Float_t completeSlice=0.0;
  Float_t completeAll=0.0;
  if(primshw){
    PEs = primshw->GetCharge(CalStripType::kPE);
    Gev = primshw->GetEnergy();
    if(simulation){
      CandShowerHandle shw= *primshw;
      Int_t neuId=  truthHelp.GetBestShowerNeuMatch(shw);
      if(bestNeu==-1) bestNeu=neuId;
      purity =  truthHelp.ShowerPurity(shw, neuId);
      completeAll = truthHelp.ShowerCompleteness(shw); 
      CandSliceHandle slc;
      if(fCandEvent){
        slc = * fCandEvent->GetCandSlice();
      }
      else if(fCandSlice){
        slc = * fCandSlice;
      }
      if(fCandSlice || fCandEvent){
        completeSlice = truthHelp.ShowerCompleteness(shw,slc);

      }
    }
  }
  else if( showerlisthandle){
    
    TIter showerItr(showerlisthandle->GetDaughterIterator());
    nShowers=showerlisthandle->GetNDaughters();
    while (CandShowerHandle *shower = dynamic_cast<CandShowerHandle*>
           (showerItr())){
      if(shower){
        CandSliceHandle slc1 =  *(shower->GetCandSlice());
        CandSliceHandle slc2;
        if(fCandSlice)slc2= *(fCandSlice);
        if(slc1==slc2 || !fCandSlice || slc1.IsCloneOf(slc2)){
          if(shower->GetEnergy()>Gev){
            PEs = shower->GetCharge(CalStripType::kPE);
            Gev = shower->GetEnergy();
            if(simulation){
              CandShowerHandle shw= *shower;
              Int_t neuId=  truthHelp.GetBestShowerNeuMatch(shw);
              if(bestNeu==-1) bestNeu=neuId;
              purity =  truthHelp.ShowerPurity(shw, neuId);
              completeAll = truthHelp.ShowerCompleteness(shw);
              CandSliceHandle slc;
              if(fCandEvent){
                slc = * fCandEvent->GetCandSlice();
              }
              else if(fCandSlice){
                slc = * fCandSlice;
              }
              else if (fNumSlices==1){
                slc = * shw.GetCandSlice();
              }
              if(fCandSlice || fCandEvent || fNumSlices==1){          
                completeSlice = truthHelp.ShowerCompleteness(shw,slc);
              }
            }
          }  
        }
      }
    }
  }  
  sprintf(cline,"Primary Shower> PEs:%6.1f  Energy:%6.2f GeV",
          PEs,
          Gev
          );   
  cline[79]=0;
  tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
  nLine++;
  tline[ntline]->SetTextFont(42);
  tline[ntline]->SetTextSize(textsize);
  tline[ntline]->Draw();
  ntline++;
  if(simulation){
    sprintf(cline,
            "   Purity:%5.2f   Complete(Slice):%5.2f   Complete(All):%5.2f",
            purity,completeSlice,completeAll);
    cline[79]=0;
    tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
    nLine++;
    tline[ntline]->SetTextFont(42);
    tline[ntline]->SetTextSize(textsize);
    tline[ntline]->Draw();
    ntline++;
  }
  
  nLine++;
  const MomNavigator* mom = fMint->GetJint().GetMom();
  if(mom)
    {
      if (simulation) 
        {
          sprintf(cline,"Monte Carlo Event. Generator Summary");
          tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
          nLine++;
          tline[ntline]->SetTextFont(52);
          tline[ntline]->SetTextSize(textsize);
          tline[ntline]->Draw();
          ntline++;
         
          const REROOT_NeuKin* kin = 
            dynamic_cast<const REROOT_NeuKin*>
            (ssr->FindComponent("REROOT_NeuKin"));
          (ssr->FindComponent("TClonesArray","StdHep"));
       
          if(fCandEvent) bestNeu=truthHelp.GetBestEventNeuMatch(*fCandEvent);
          if(bestNeu!=-1){
            sprintf(cline,"Pnu=%6.2f  Eshwr=%6.2f  Pmu=%6.2f Pmu2=%6.2f  Pmu2Eele=%6.2f",   
                    truthHelp.GetP4Neu(bestNeu)[3],
                    truthHelp.GetP4Shw(bestNeu)[3],
                    truthHelp.GetP4Mu1(bestNeu)[3],
                    truthHelp.GetP4Mu2(bestNeu)[3],
                    truthHelp.GetP4El1(bestNeu)[3]);
          }
          else if(kin){
            sprintf(cline,"Pnu=%6.2f  Eshwr=%6.2f  Pmu=%6.2f  Eele=%6.2f",   
                    kin->P4Neu()[3],
                    kin->P4Shw()[3],
                    kin->P4Mu1()[3],
                    kin->P4El1()[3]);
          }
          cline[79]=0;      
          tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
          nLine+=2;
          tline[ntline]->SetTextFont(42);
          tline[ntline]->SetTextSize(textsize);
          tline[ntline]->Draw();
          ntline++;
        }
    }
  
  CandCalDetPIDHandle * PIDh = DataUtil::GetCandidate<CandCalDetPIDHandle>
    (&(fMint->GetJobC().Mom),"CandCalDetPIDHandle");
  if(PIDh){
    sprintf(cline,"CalDet Particle ID Summary");
    tline[ntline] = new TText(textsize,1-nLine*textsize,cline);
    nLine++;
    tline[ntline]->SetTextFont(52);
    tline[ntline]->SetTextSize(textsize);
    tline[ntline]->Draw();
    ntline++;
    const char * c1 = PIDh->AsString().c_str();
    tline[ntline] = new TText(textsize,1-nLine*textsize,c1);
    nLine++;
    tline[ntline]->SetTextFont(42);
    tline[ntline]->SetTextSize(textsize);
    tline[ntline]->Draw();
    ntline++;
  }
  
    
}


void EVD::PrintCanvas(){

  if(!fMint) return;
  int run=0, snarl=0, event=0;
  DataUtil::GetRunSnarlEvent(&(fMint->GetJobC().Mom), run, snarl, event);
  char * cline = new char[80];
  sprintf(cline,"Run%dSnarl%d.ps",run,snarl);
  TCanvas& canvas = this->GetCanvas();
  canvas.Print(cline);

}

void EVD::SetChargeRange(){
  
  if(!fMint) return;
  if(GetDisplayOptions()->AutoScaleCharge()){
    
    Detector::Detector_t det = fMint->GetDetector();
    if (det == Detector::kUnknown) return;
    
    const CandDigitListHandle* cslh = fMint->GetDigits();
    if (!cslh) return;
    
    vector<const CandDigitHandle*> dv = 
      DataUtil::CDL2STLvector<CandDigitHandle>(*cslh);
    int siz = dv.size();
    if (! siz) return;
    
    double tmin=0, tmax=0, qmin=0,qmax=0;
    bool first = true;
    
    for (int ind = 0; ind < siz; ++ind) {
      const CandDigitHandle* csh = dv[ind];
      const PlexSEIdAltL& altl = csh->GetPlexSEIdAltL();
      PlaneView::PlaneView_t pv = altl.GetPlaneView();
      if (det != Detector::kCalib && 
          pv != PlaneView::kU && pv != PlaneView::kV) continue;
      
      altl.SetFirst();
      while (altl.IsValid()) {
        double q =csh->GetCharge();
        if(GetDisplayOptions()->ChargeType()==CalDigitType::kPE)
          q=altl.GetCurrentItem().GetPE();
        else if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigLin)
          q=altl.GetCurrentItem().GetSigLin();
        else if(GetDisplayOptions()->ChargeType()==CalDigitType::kSigCorr)
          q=altl.GetCurrentItem().GetSigCorr();
        
        if (first) {
          qmin = qmax = q;
          first=false;
          continue;
        }
        if (q < qmin) qmin = q;
        if (q > qmax) qmax = q;
        altl.Next();
      }
    }
    // give some buffer at either end...
    qmax +=  0.02*(qmax - qmin);
    qmin += -0.02*(qmax - qmin);
    
    
    if (!first) {
      
      double eps = 1.0e-10;
      if (tmin == tmax) { tmin -= eps; tmax += eps; }
      if (qmin == qmax) { qmin -= eps; qmax += eps; }
      
      fChargeRange->Set(qmin,qmax);
    }
  }
}



void EVD::DrawVS(){

  if (!fMint) return;
  if (fMint->GetDetector() != Detector::kFar) return;
  UgliGeomHandle ugh = fMint->GetUgliGeomHandle();
  if (! ugh.IsValid()) return;
  
  vector<UgliScintPlnHandle> usphv = ugh.GetScintPlnHandleVector();
  vector<UgliScintPlnHandle>::reverse_iterator rit, rdone = usphv.rend();
  VS = new TList;
  VS->SetOwner();
  float cx,cy; 
  StripEnd::StripEnd_t two_sided[] = { StripEnd::kEast,
                                       StripEnd::kWest };
  StripEnd::StripEnd_t *side_list = two_sided;
   
  for (rit = usphv.rbegin(); rit != rdone; ++rit) {
    if (! rit->GetPlexPlaneId().IsVetoShield()) break;
    int nstrips = rit->NumberOfStrips();
    for (int istrip=0; istrip < nstrips; istrip++) {
      PlexStripEndId oneend(rit->GetPlexPlaneId(),istrip,side_list[0]);
      UgliStripHandle ush = ugh.GetStripHandle(oneend);
      TVector3 stripxyz0(ush.GlobalPos(-ush.GetHalfLength()));
      TVector3 stripxyz1(ush.GlobalPos(ush.GetHalfLength()));
      cx = 0.5*(stripxyz0[0]+stripxyz1[0]);
      cy = 0.5*(stripxyz0[1]+stripxyz1[1]);     
      Double_t dy[5] = {-ush.GetHalfThickness(),
                        -ush.GetHalfThickness(),
                        +ush.GetHalfThickness(),
                        +ush.GetHalfThickness(),
                        -ush.GetHalfThickness()};
      Double_t dx[5] = {-ush.GetHalfWidth(),
                        +ush.GetHalfWidth(),
                        +ush.GetHalfWidth(),
                        -ush.GetHalfWidth(),
                        -ush.GetHalfWidth()};
      if(rit->GetPlaneView()==PlaneView::kVSWallOnEdge){
        for (int id=0;id<6;id++){
          double tmp=dy[id];
          dy[id]=dx[id];
          dx[id]=tmp;
        }
      }
      Double_t rot=0.9;
      if(rit->GetPlaneView()==PlaneView::kVSTopEastSlant){
        double newdx;
        double newdy;
        for (int id=0;id<6;id++){
          newdx=dx[id]*cos(-rot)+dy[id]*sin(-rot);
          newdy=-dx[id]*sin(-rot)+dy[id]*cos(-rot);
          dx[id]=newdx;
          dy[id]=newdy;
        }
      }
      if(rit->GetPlaneView()==PlaneView::kVSTopWestSlant){
        double newdx;
        double newdy;
        for (int id=0;id<6;id++){
          newdx=dx[id]*cos(rot)+dy[id]*sin(rot);
          newdy=-dx[id]*sin(rot)+dy[id]*cos(rot);
          dx[id]=newdx;
          dy[id]=newdy;
        }

      }
      Double_t xbox[5]={cx+dx[0],cx+dx[1],cx+dx[2],cx+dx[3],cx+dx[4]};
      Double_t ybox[5]={cy+dy[0],cy+dy[1],cy+dy[2],cy+dy[3],cy+dy[4]};
      TPolyLine * VSstrip = new TPolyLine(5,xbox,ybox);
      VS->Add(VSstrip);
    }
  }
  VS->Draw();
}

---