EventDisplay.cxx

Go to the documentation of this file.

// C++
#include <iostream>
#include <iomanip>
#include <sstream>

// ROOT
#include "TCanvas.h"
#include "TGClient.h"
#include "TGButton.h"
#include "TGFrame.h"
#include "TGTab.h"
#include "TGTableLayout.h"
#include "TRootEmbeddedCanvas.h"

// Local
#include "PhysicsNtuple/Factory.h"

#include "EventDisplay.h"

Anp::EventDisplay *Anp::EventDisplay::fgInstance = 0;

//------------------------------------------------------------------------------------------
// return (create for a first call) factory instance
//------------------------------------------------------------------------------------------
Anp::EventDisplay& Anp::EventDisplay::Instance()
{
   if(!fgInstance)
   {
      fgInstance = new Anp::EventDisplay();
   }

  return *fgInstance;
}

using namespace std;

//----------------------------------------------------------------------------------------
Anp::EventDisplay::EventDisplay()
   :fMain(NULL),
    fTab(NULL),
    fStore(),
    fZoom(false)
{
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::Add(const Record &record)
{
   fStore.Add(record);
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::Add(EventTabPtr tab)
{
   if(!tab.valid())
   {
      cerr << "EventDisplay::Add() - ignoring invalid tab" << endl;
   }

   fTabs.push_back(tab);
   
   if(fTab && fMain)
   {
      InitTab(tab);
   }
}

//----------------------------------------------------------------------------------------
Anp::EventTabPtr Anp::EventDisplay::Add(const string &name)
{
   EventTabPtr tab = Factory<EventTab>::Instance().Create(name);

   if(!tab.valid())
   {
      cerr << "EventDisplay::Init() - failed to create tab:" << name << endl;
      return EventTabPtr(0);
   }      
   
   tab -> SetName(name);

   Add(tab);

   return tab;
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::InitTab(EventTabPtr tab)
{   
   if(!fTab || !fMain)
   {
      return;
   }

   string label = tab -> GetLabel();
   if(label.empty())
   {
      label = tab -> GetName();
      tab -> SetLabel(label);      
   }

   TGCompositeFrame *tf = fTab -> AddTab(label.c_str());

   TGLayoutHints* lh = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY); 
   TRootEmbeddedCanvas *rec = new TRootEmbeddedCanvas(label.c_str(), tf, 700,700);

   tf -> AddFrame(rec, lh);
   
   tab -> Init(rec -> GetCanvas());
   tab -> SetEmbedded(rec);
   
   fTab -> MapSubwindows();
   fTab -> Resize(fTab -> GetDefaultSize());
   fTab -> Layout();
}

//----------------------------------------------------------------------------------------
Anp::EventTabPtr Anp::EventDisplay::GetCurrent()
{
   const int current = fTab -> GetCurrent();
    
   if(current < static_cast<int>(fTabs.size()))
   {
      return fTabs[current];
   }
   else
   {
      cerr << "EventDisplay::GetCurrent() - requested tab does not exists" << endl;
   }

   return EventTabPtr(0);
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::Selected(int tab) 
{
   if(tab < static_cast<int>(fTabs.size()))
   {
      fTabs[tab] -> Expose();
   }
   else
   {
      cerr << "EventDisplay::Selected() - tab index is out of range" << endl;
   }
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::Init()
{
  TGWindow* main = const_cast<TGWindow*> (gClient->GetRoot());
  fMain = new TGMainFrame(main, 1000, 900, kHorizontalFrame);
  fMain -> SetWMSize(900, 700);
  fMain -> SetCleanup(kDeepCleanup);
  fMain -> Connect("CloseWindow()", "Anp::EventDisplay", this, "CloseWindow()");  

   //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   // add tab frame
   //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   fTab = new TGTab(fMain, 900, 900);
   TGLayoutHints *thints = new TGLayoutHints(kLHintsRight | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2);
   fTab -> Connect("Selected(Int_t)", "Anp::EventDisplay", this, "Selected(int)");
   fMain -> AddFrame(fTab, thints);
   cout<<"EventDisplay::Init() before for loop" <<endl;
   for(TabVec::const_iterator cit = fTabs.begin(); cit != fTabs.end(); ++cit) 
   {
      InitTab(*cit);
   }
   cout<<" EventDisplay::Init() Add Buttons"<<endl;
   //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   // add buttons
   //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

   TGVerticalFrame *bframe = new TGVerticalFrame(fMain, 80, 1000);
   bframe -> SetHeight(1000);
   bframe -> SetWidth(80);
   TGLayoutHints *lh = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 2, 2, 2);

   TGTextButton *bnevent = new TGTextButton(bframe, "Next event", 0);
   TGTextButton *bpevent = new TGTextButton(bframe, "Prev event", 0);
   TGTextButton *bnsnarl = new TGTextButton(bframe, "Next snarl", 0);
   TGTextButton *bpsnarl = new TGTextButton(bframe, "Prev snarl", 0);

   TGTextButton *bzoomi = new TGTextButton(bframe, "Zoom In", 0);
   TGTextButton *bzoomo = new TGTextButton(bframe, "Zoom Out", 0);
   TGTextButton *btruth = new TGTextButton(bframe, "Print truth", 0);
   TGTextButton *bdata  = new TGTextButton(bframe, "Print data", 0);
   TGTextButton *bprint = new TGTextButton(bframe, "Print tab", 0);
   TGTextButton *bclose = new TGTextButton(bframe, "Close", 0);

   TGLayoutHints *tloh = new TGLayoutHints(kLHintsTop);

   bnevent -> Connect("Clicked()", "Anp::EventDisplay", this, "NextEvent()");
   bpevent -> Connect("Clicked()", "Anp::EventDisplay", this, "PrevEvent()");
   bnsnarl -> Connect("Clicked()", "Anp::EventDisplay", this, "NextSnarl()");
   bpsnarl -> Connect("Clicked()", "Anp::EventDisplay", this, "PrevSnarl()");

   bzoomi -> Connect("Clicked()", "Anp::EventDisplay", this, "ZoomIn()");
   bzoomo -> Connect("Clicked()", "Anp::EventDisplay", this, "ZoomOut()");
   btruth -> Connect("Clicked()", "Anp::EventDisplay", this, "PrintTruth()");
   bdata  -> Connect("Clicked()", "Anp::EventDisplay", this, "PrintData()");
   bprint -> Connect("Clicked()", "Anp::EventDisplay", this, "PrintTab()");
   bclose -> Connect("Clicked()", "Anp::EventDisplay", this, "CloseWindow()");
 
   bframe -> AddFrame(bnevent, tloh);
   bframe -> AddFrame(bpevent, tloh);
   bframe -> AddFrame(bnsnarl, tloh);
   bframe -> AddFrame(bpsnarl, tloh);
   bframe -> AddFrame(bzoomi, tloh);
   bframe -> AddFrame(bzoomo, tloh);
   bframe -> AddFrame(btruth, tloh);
   bframe -> AddFrame(bprint, tloh);
   bframe -> AddFrame(bclose, tloh);

   fMain -> AddFrame(bframe, lh);

   fMain -> SetWindowName("Event display");

   fMain -> MapSubwindows();
   fMain -> Resize(fMain -> GetDefaultSize());
   fMain -> MapWindow();
   fMain -> Layout();
   fMain -> Print();
   cout<<" Done with Event Display:: Init"<<endl;
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::NextEvent()
{
   fStore.NextEvent();
   NewEvent();
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::PrevEvent()
{
   fStore.PrevEvent();
   NewEvent();
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::NextSnarl()
{
   fStore.NextSnarl();
   NewEvent();
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::PrevSnarl()
{
   fStore.PrevSnarl();
   NewEvent();
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::ZoomIn()
{
   fZoom = true;

   for(TabVec::const_iterator cit = fTabs.begin(); cit != fTabs.end(); ++cit) 
   {
      (*cit) -> ZoomIn();
   }

   Selected(fTab -> GetCurrent());
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::ZoomOut()
{
   fZoom = false;

   for(TabVec::const_iterator cit = fTabs.begin(); cit != fTabs.end(); ++cit) 
   {
      (*cit) -> ZoomOut();
   }

   Selected(fTab -> GetCurrent());
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::NewEvent()
{
   if(!fStore.IsValid())
   {
      cerr << "EventDisplay::NewEvent() - bad RecordStore status..." << endl;
      return;
   }
   
   const Header &header = fStore.CurrSnarl() -> GetHeader();

   cout << "Run = " << setw(6) << header.Run()
        << " snarl = " << setw(6) << header.Snarl()
        << " event = " << setw(2) << fStore.CurrEvent() -> EventIndex() 
        << endl;

   for(TabVec::const_iterator cit = fTabs.begin(); cit != fTabs.end(); ++cit) 
   {
      (*cit) -> Set(*fStore.CurrEvent(), *fStore.CurrSnarl());
      
      if(fZoom)
      {
        (*cit) -> ZoomIn(); 
      }
   }

   Selected(fTab -> GetCurrent());
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::PrintTruth()
{
   if(fStore.IsValid())
   {
      fStore.PrintTruth();
   }
}
//----------------------------------------------------------------------------------
void Anp::EventDisplay::PrintData()
{
  if(fStore.IsValid())
    {
      fStore.PrintData();
    }
}


//----------------------------------------------------------------------------------------
void Anp::EventDisplay::PrintTab()
{
   if(!fTab)
   {
      cout << "PrintTab: no tabs exists" << endl;
      return;
   }

   if(!fStore.IsValid())
   {
      cout << "PrintTab:: bad RecordStore" << endl;
      return;
   }

   RecordStore::SnarlIter snarl = fStore.CurrSnarl();
   if(snarl == fStore.SnarlEnd())
   {
      cout << "PrintTab: no snarls found" << endl;
      return;
   }

   RecordStore::EventIter event = fStore.CurrEvent();
   if(event == fStore.EventEnd())
   {
      cout << "PrintTab: no events found" << endl;
      return;
   }

   EventTabPtr tab = GetCurrent();
   if(!tab.valid())
   {
      cout << "PrintTab: current tab is not valid" << endl;
      return;
   }
   
   TRootEmbeddedCanvas *emcan = tab -> GetEmbedded();
   if(!emcan)
   {
      cout << "PrintTab: invalid pointer to TRootEmbeddedCanvas" << endl;
      return;
   }
      
   TCanvas *canvas = emcan -> GetCanvas();
   if(!canvas)
   {
      cout << "PrintTab: TRootEmbeddedCanvas has invalid TCanvas" << endl;
      return;
   }
   
   const Header &header = snarl -> GetHeader();
   
   stringstream name;
   name << tab -> GetName() << "_run_" << header.Run()
        << "_snarl_" << header.Snarl() << "_event_" << event -> EventIndex() 
        << ".eps";
   
   canvas -> Print(name.str().c_str());
}

//----------------------------------------------------------------------------------------
void Anp::EventDisplay::CloseWindow() 
{
   if(fMain)
   {
      fMain -> CloseWindow();
   }
}

---