[u/mrichter/AliRoot.git] / EVE / Reve / TrackEditors.cxx

// $Header$

#include "TrackEditors.h"
#include <Reve/Track.h>

#include <Reve/RGValuators.h>

#include <TVirtualPad.h>
#include <TColor.h>

#include <TGLabel.h>
#include <TGButton.h>
#include <TGNumberEntry.h>
#include <TGColorSelect.h>
#include <TGDoubleSlider.h>
#include <TGComboBox.h>

#include <TGMsgBox.h>
#include <TH1F.h>

using namespace Reve;

//______________________________________________________________________
// TrackListEditor
//

ClassImp(TrackListEditor)

TrackListEditor::TrackListEditor(const TGWindow *p,
				 Int_t width, Int_t height,
				 UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options | kVerticalFrame, back),

  fTC (0),

  fMaxR(0),
  fMaxZ(0),
  fMaxOrbits(0),
  fMinAng(0),
  fDelta(0),

  fRnrTracks(0),
  fRnrMarkers(0),

  fPMFrame(0),
  fFitDaughters(0),
  fFitReferences(0),
  fFitDecay(0),
  fRnrDaughters(0),
  fRnrReferences(0),
  fRnrDecay(0),

  fPtRange(0)
{
  MakeTitle("TrackList");
  Int_t labelW = 67;

  // --- Limits

  fMaxR = new RGValuator(this, "Max R:", 110, 0);
  fMaxR->SetLabelWidth(labelW);
  fMaxR->SetNELength(6);
  fMaxR->Build();
  fMaxR->SetLimits(0.1, 1000, 100, TGNumberFormat::kNESRealOne);
  fMaxR->SetToolTip("Maximum radius to which the tracks will be drawn.");
  fMaxR->Connect("ValueSet(Double_t)", "Reve::TrackListEditor", this, "DoMaxR()");
  AddFrame(fMaxR, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));

  fMaxZ = new RGValuator(this, "Max Z:", 110, 0);
  fMaxZ->SetLabelWidth(labelW);
  fMaxZ->SetNELength(6);
  fMaxZ->Build();
  fMaxZ->SetLimits(0.1, 2000, 100, TGNumberFormat::kNESRealOne);
  fMaxZ->SetToolTip("Maximum z-coordinate to which the tracks will be drawn.");
  fMaxZ->Connect("ValueSet(Double_t)", "Reve::TrackListEditor", this, "DoMaxZ()");
  AddFrame(fMaxZ, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel *l = new TGLabel(f, "Max Orbits:");
    f->AddFrame(l, new TGLayoutHints(kLHintsTop | kLHintsCenterY, 0, 2, 1, 1));
    fMaxOrbits = new TGNumberEntry(f, 0., 6, -1, 
				   TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
				   TGNumberFormat::kNELLimitMinMax, 0.1, 100.0);
    fMaxOrbits->GetNumberEntry()->SetToolTipText("Maximal angular path of tracks' orbits (1 ~ 2Pi).");
    f->AddFrame(fMaxOrbits, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fMaxOrbits->Associate(f);
    fMaxOrbits->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxOrbits()");
    AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel *l = new TGLabel(f, "Min Angle:");
    f->AddFrame(l, new TGLayoutHints(kLHintsTop | kLHintsCenterY, 3, 2, 1, 1));
    fMinAng = new TGNumberEntry(f, 0., 6, -1, 
				TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
				TGNumberFormat::kNELLimitMinMax, 1, 180.0);
    fMinAng->GetNumberEntry()->SetToolTipText("Minimal angular step between two helix points.");
    f->AddFrame(fMinAng, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fMinAng->Associate(f);
    fMinAng->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMinAng()");
    AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel *l = new TGLabel(f, "Delta:");
    f->AddFrame(l, new TGLayoutHints(kLHintsTop | kLHintsCenterY, 32, 2, 1, 1));
    fDelta = new TGNumberEntry(f, 0., 6, -1, 
			       TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAPositive,
			       TGNumberFormat::kNELLimitMinMax, 0.001, 100.0);
    fDelta->GetNumberEntry()->SetToolTipText("Maximal error at the mid-point of the line connecting to helix points.");
    f->AddFrame(fDelta, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fDelta->Associate(f);
    fDelta->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoDelta()");
    AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
  }

  // --- Selectors

  fPtRange = new RGDoubleValuator(this,"Pt Range", 200, 0);
  fPtRange->SetNELength(6);
  fPtRange->Build();
  fPtRange->GetSlider()->SetWidth(224);
  fPtRange->SetLimits(0, 10, TGNumberFormat::kNESRealTwo);
  fPtRange->Connect("ValueSet()",
		    "Reve::TrackListEditor", this, "DoPtRange()");
  AddFrame(fPtRange, new TGLayoutHints(kLHintsTop, 1, 1, 4, 1));

  // --- Rendering control
  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    fRnrTracks = new TGCheckButton(f, "Render tracks");
    f->AddFrame(fRnrTracks, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 0));
    fRnrTracks->Connect
      ("Toggled(Bool_t)", "Reve::TrackListEditor", this, "DoRnrTracks()");
    fWidthCombo = new TGLineWidthComboBox(f);
    fWidthCombo->Resize(80, 18);
    f->AddFrame(fWidthCombo, new TGLayoutHints(kLHintsLeft, 8, 1, 0, 0));

    fWidthCombo->Connect
      ("Selected(Int_t)", "Reve::TrackListEditor", this, "DoLineWidth(Int_t)"); 
    AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 3, 0));
  }

  // --- Kinematics fitting
  
  fPMFrame = new  TGHorizontalFrame(this);
  {
    TGGroupFrame* fitPM = new TGGroupFrame(fPMFrame, "PathMarks:", kLHintsTop | kLHintsCenterX);
    fitPM->SetTitlePos(TGGroupFrame::kLeft);
    fPMFrame->AddFrame( fitPM, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));

    TGMatrixLayout *ml = new TGMatrixLayout(fitPM, 0,1,6);
    fitPM->SetLayoutManager(ml);

    fFitDaughters  = new TGCheckButton(fitPM, "Fit Daughters", PathMark::Daughter);
    fFitReferences = new TGCheckButton(fitPM, "Fit Refs",      PathMark::Reference);
    fFitDecay      = new TGCheckButton(fitPM, "Fit Decay",     PathMark::Decay);

    fitPM->AddFrame(fFitDaughters);
    fitPM->AddFrame(fFitReferences);
    fitPM->AddFrame(fFitDecay);

    fFitDecay->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");  
    fFitReferences->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");  
    fFitDaughters->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");
  }
  {
    TGGroupFrame* rnrPM = new TGGroupFrame(fPMFrame, "PathMarks:", kLHintsTop | kLHintsCenterX);
    rnrPM->SetTitlePos(TGGroupFrame::kLeft);
    fPMFrame->AddFrame( rnrPM, new TGLayoutHints(kLHintsTop | kLHintsCenterX | kLHintsExpandX, 3, 3, 3, 3));

    TGMatrixLayout *ml = new TGMatrixLayout(rnrPM, 0,1,6);
    rnrPM->SetLayoutManager(ml);

    fRnrDaughters  = new TGCheckButton(rnrPM, "Rnr Daughters", PathMark::Daughter);
    fRnrReferences = new TGCheckButton(rnrPM, "Rnr Refs",  PathMark::Reference);
    fRnrDecay      = new TGCheckButton(rnrPM, "Rnr Decay", PathMark::Decay);

    rnrPM->AddFrame(fRnrDaughters);
    rnrPM->AddFrame(fRnrReferences);
    rnrPM->AddFrame(fRnrDecay);

    fRnrDecay->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");  
    fRnrReferences->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");  
    fRnrDaughters->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");
  }
  AddFrame(fPMFrame, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
 
  fRnrMarkers = new TGCheckButton(this, "Render markers");
  AddFrame(fRnrMarkers, new TGLayoutHints(kLHintsTop, 3, 1, 2, 0));
  fRnrMarkers->Connect
    ("Toggled(Bool_t)",
     "Reve::TrackListEditor", this, "DoRnrMarkers()");  

}

TrackListEditor::~TrackListEditor()
{}

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

void TrackListEditor::SetModel(TObject* obj)
{
  fTC = dynamic_cast<TrackList*>(obj);

  fMaxR->SetValue(fTC->GetMaxR());
  fMaxZ->SetValue(fTC->GetMaxZ());
  fMaxOrbits->SetNumber(fTC->GetMaxOrbs());
  fMinAng->SetNumber(fTC->GetMinAng());
  fDelta->SetNumber(fTC->GetDelta());

  fWidthCombo->Select(fTC->GetWidth());

  fRnrTracks->SetState(fTC->GetRnrTracks() ? kButtonDown : kButtonUp);
 
  if(fTC->GetEditPathMarks()) 
  {
    HideFrame(fRnrMarkers);
    ShowFrame(fPMFrame);
    fRnrDaughters->SetState(fTC->GetRnrDaughters() ? kButtonDown : kButtonUp);
    fRnrReferences->SetState(fTC->GetRnrReferences() ? kButtonDown : kButtonUp);
    fRnrDecay->SetState(fTC->GetRnrDecay() ? kButtonDown : kButtonUp);

    fFitDaughters->SetState(fTC->GetFitDaughters() ? kButtonDown : kButtonUp);
    fFitReferences->SetState(fTC->GetFitReferences() ? kButtonDown : kButtonUp);
    fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);
  }
  else 
  {
    HideFrame(fPMFrame);
    ShowFrame(fRnrMarkers);
    fRnrMarkers->SetState(fTC->GetRnrMarkers() ? kButtonDown : kButtonUp);
  }
  fPtRange->SetValues(fTC->GetMinPt(), fTC->GetMaxPt());
}

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

void TrackListEditor::DoMaxR()
{
  fTC->SetMaxR(fMaxR->GetValue());
  Update();
}

void TrackListEditor::DoMaxZ()
{
  fTC->SetMaxZ(fMaxZ->GetValue());
  Update();
}

void TrackListEditor::DoMaxOrbits()
{
  fTC->SetMaxOrbs(fMaxOrbits->GetNumber());
  Update();
}

void TrackListEditor::DoMinAng()
{
  fTC->SetMinAng(fMinAng->GetNumber());
  Update();
}

void TrackListEditor::DoDelta()
{
  fTC->SetDelta(fDelta->GetNumber());
  Update();
}

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

void TrackListEditor::DoLineWidth(Int_t width)
{
  fTC->SetWidth(width);
  Update();
}

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

void TrackListEditor::DoRnrTracks()
{
  fTC->SetRnrTracks(fRnrTracks->IsOn());
  Update();
}

void TrackListEditor::DoRnrMarkers()
{
  fTC->SetRnrMarkers(fRnrMarkers->IsOn());
  Update();
}

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

void TrackListEditor::DoFitPM()
{
  TGButton* b = (TGButton *) gTQSender;
  PathMark::Type_e type = PathMark::Type_e(b->WidgetId());
  Bool_t on = b->IsOn();

  switch(type)
  {
    case PathMark::Daughter:
      fTC->SetFitDaughters(on);
      break; 
    case PathMark::Reference:
      fTC->SetFitReferences(on);
      break; 
    case PathMark::Decay:
      fTC->SetFitDecay(on);
      break;
     default:
      break;
  }
  Update();
}

void TrackListEditor::DoRnrPM()
{
  TGButton * b = (TGButton *) gTQSender;
  PathMark::Type_e type = PathMark::Type_e(b->WidgetId());
  Bool_t on = b->IsOn();
  switch(type){
    case  PathMark::Daughter:
      fTC->SetRnrDaughters(on);
      break; 
    case  PathMark::Reference:
      fTC->SetRnrReferences(on);
      break; 
    case  PathMark::Decay:
      fTC->SetRnrDecay(on);
      break;
 
    default:
      break;

  }
  Update();
}
/**************************************************************************/

void TrackListEditor::DoPtRange()
{
 
  fTC->SelectByPt(fPtRange->GetMin(), fPtRange->GetMax());
  Update();
}


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

#include <TCanvas.h>
#include <TGLViewer.h>
#include <Reve/RGTopFrame.h>

//______________________________________________________________________
// TrackCounterEditor
//

ClassImp(TrackCounterEditor)

TrackCounterEditor::TrackCounterEditor(const TGWindow *p, Int_t width, Int_t height,
				       UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options | kVerticalFrame, back),
  fM(0),
  fClickAction (0),
  fInfoLabel   (0),
  fEventId     (0)
{
  MakeTitle("TrackCounter");

  Int_t labelW = 42;

  { // ClickAction
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel* lab = new TGLabel(f, "Click:");
    f->AddFrame(lab, new TGLayoutHints(kLHintsLeft|kLHintsBottom, 1, 10, 1, 2));
    fClickAction = new TGComboBox(f);
    fClickAction->AddEntry("Print", 0);
    fClickAction->AddEntry("Toggle", 1);
    TGListBox* lb = fClickAction->GetListBox();
    lb->Resize(lb->GetWidth(), 2*16);
    fClickAction->Resize(70, 20);
    fClickAction->Connect("Selected(Int_t)", "Reve::TrackCounterEditor", this,
			  "DoClickAction(Int_t)");
    f->AddFrame(fClickAction, new TGLayoutHints(kLHintsLeft, 1, 2, 1, 1));
  
    AddFrame(f);
  }

  { // Status
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel* lab = new TGLabel(f, "Status:");
    f->AddFrame(lab, new TGLayoutHints(kLHintsLeft, 1, 5, 1, 2));

    fInfoLabel = new TGLabel(f);
    f->AddFrame(fInfoLabel, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 9, 1, 2));

    AddFrame(f);
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);

    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "View:");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);

    TGTextButton* b;

    b = new TGTextButton(f, "Orto XY");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoOrtoXY()");

    b = new TGTextButton(f, "Orto ZY");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoOrtoZY()");

    b = new TGTextButton(f, "Persp");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPersp()");

    AddFrame(f);
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);

    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "Event:");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);

    TGTextButton* b;

    b = new TGTextButton(f, "Prev");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPrev()");

    fEventId = new TGNumberEntry(f, 0, 3, -1,TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative,
				 TGNumberFormat::kNELLimitMinMax, 0, 1000);
    f->AddFrame(fEventId, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    fEventId->Connect("ValueSet(Long_t)", "Reve::TrackCounterEditor", this, "DoSetEvent()");

    b = new TGTextButton(f, "Next");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoNext()");

    AddFrame(f);
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);

    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "Report:");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);

    TGTextButton* b;

    b = new TGTextButton(f, "Print");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPrintReport()");

    b = new TGTextButton(f, "File");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoFileReport()");

    AddFrame(f, new TGLayoutHints(kLHintsLeft, 0, 0, 4, 0));
  }
  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);

    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "Histos:");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);

    TGTextButton* b;

    b = new TGTextButton(f, "Show");
    f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
    b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoShowHistos()");

    AddFrame(f, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
  }

}

TrackCounterEditor::~TrackCounterEditor()
{}

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

void TrackCounterEditor::SetModel(TObject* obj)
{
  fM = dynamic_cast<TrackCounter*>(obj);

  fClickAction->Select(fM->fClickAction, kFALSE);
  fInfoLabel->SetText(Form("All: %3d; Primaries: %3d", fM->fAllTracks, fM->fGoodTracks));
  fEventId->SetNumber(fM->GetEventId());
}

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

// glv->SetOrthoCamera(TGLViewer::kCameraOrthoXOY, 2*left, 2*right, 2*top, bottom);

void TrackCounterEditor::DoOrtoXY()
{
  TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
  glv->SetCurrentCamera(TGLViewer::kCameraOrthoXOY) ;
}

void TrackCounterEditor::DoOrtoZY()
{
  TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
  glv->SetCurrentCamera(TGLViewer::kCameraOrthoZOY) ;
}

void TrackCounterEditor::DoPersp()
{
  TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
  glv->SetCurrentCamera(TGLViewer::kCameraPerspXOZ) ;
}

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

void TrackCounterEditor::DoPrev()
{
  Reve::Macro("event_prev.C");
  gReve->EditRenderElement(fM);
}

void TrackCounterEditor::DoNext()
{
  Reve::Macro("event_next.C");
  gReve->EditRenderElement(fM);
}

void TrackCounterEditor::DoSetEvent()
{
  Reve::LoadMacro("event_goto.C");
  gROOT->ProcessLine(Form("event_goto(%d);", (Int_t) fEventId->GetNumber()));
  gReve->EditRenderElement(fM);
}

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

void TrackCounterEditor::DoPrintReport()
{
  fM->OutputEventTracks();
}

void TrackCounterEditor::DoFileReport()
{
  TString file(Form("ev-report-%03d.txt", fM->GetEventId()));
  if (gSystem->AccessPathName(file) == kFALSE)
  {
    Int_t ret;
    new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
		 "File Exist",
		 Form("Event record for event %d already exist.\n Replace?", fM->GetEventId()),
		 kMBIconQuestion, kMBYes | kMBNo, &ret);
    if (ret == kMBNo)
      return;
  }
  FILE* out = fopen(file, "w");
  fM->OutputEventTracks(out);
  fclose(out);
}

void TrackCounterEditor::DoShowHistos()
{
  TH1F* hcnt = new TH1F("cnt", "Primeries per event", 41, -0.5, 40.5);
  TH1F* hchg = new TH1F("chg", "Primary charge",       3, -1.5,  1.5);
  TH1F* hpt  = new TH1F("pt",  "pT distribution",     40,  0.0,  8.0);
  TH1F* heta = new TH1F("eta", "eta distribution",    40, -1.0,  1.0);

  Int_t nn; // fscanf return value

  for (Int_t i=0; i<1000; ++i)
  {
    TString file(Form("ev-report-%03d.txt", i));
    if (gSystem->AccessPathName(file) == kFALSE)
    {
      Int_t   ev, ntr;
      FILE* f = fopen(file, "read");
      nn = fscanf(f, "Event = %d  Ntracks = %d", &ev, &ntr);
      if (nn != 2) { printf("SAFR1 %d\n", nn); fclose(f); return;  }
      hcnt->Fill(ntr);
      for (Int_t t=0; t<ntr; ++t)
      {
	Int_t   id, chg;
	Float_t pt, eta;
	nn = fscanf(f, "%d: chg=%d pt=%f eta=%f", &id, &chg, &pt, &eta);
	if (nn != 4) { printf("SAFR2 %d\n", nn); fclose(f); return;  }
	hchg->Fill(chg);
	hpt ->Fill(pt);
	heta->Fill(eta);
      }
      fclose(f);
    }
  }

  TCanvas* c;
  if (gPad == 0 || gPad->GetCanvas()->IsEditable() == kFALSE) {
    c = new TCanvas("Scanwas", "Scanning Results", 800, 600);
  } else {
    c = gPad->GetCanvas();
    c->Clear();
  }
  c->Divide(2, 2);

  c->cd(1); hcnt->Draw();
  c->cd(2); hchg->Draw();
  c->cd(3); hpt ->Draw();
  c->cd(4); heta->Draw();

  c->Modified();
  c->Update();
}


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

void TrackCounterEditor::DoClickAction(Int_t mode)
{
  fM->SetClickAction(mode);
}
Commit	Line	Data
5a5a1232	1	// $Header$
	2
	3	#include "TrackEditors.h"
	4	#include <Reve/Track.h>
	5
a3912979	6	#include <Reve/RGValuators.h>
a3912979	7
5a5a1232	8	#include <TVirtualPad.h>
	9	#include <TColor.h>
	10
	11	#include <TGLabel.h>
	12	#include <TGButton.h>
	13	#include <TGNumberEntry.h>
	14	#include <TGColorSelect.h>
	15	#include <TGDoubleSlider.h>
c71edfe9	16	#include <TGComboBox.h>
	17
	18	#include <TGMsgBox.h>
	19	#include <TH1F.h>
5a5a1232	20
	21	using namespace Reve;
	22
	23	//______________________________________________________________________
	24	// TrackListEditor
	25	//
	26
	27	ClassImp(TrackListEditor)
	28
22df2a83	29	TrackListEditor::TrackListEditor(const TGWindow *p,
	30	Int_t width, Int_t height,
	31	UInt_t options, Pixel_t back) :
	32	TGedFrame(p, width, height, options \| kVerticalFrame, back),
	33
	34	fTC (0),
	35
	36	fMaxR(0),
	37	fMaxZ(0),
	38	fMaxOrbits(0),
	39	fMinAng(0),
	40	fDelta(0),
	41
	42	fRnrTracks(0),
	43	fRnrMarkers(0),
	44
	45	fPMFrame(0),
	46	fFitDaughters(0),
	47	fFitReferences(0),
	48	fFitDecay(0),
	49	fRnrDaughters(0),
	50	fRnrReferences(0),
	51	fRnrDecay(0),
	52
	53	fPtRange(0)
5a5a1232	54	{
5a5a1232	55	MakeTitle("TrackList");
f1d52824	56	Int_t labelW = 67;
	57
	58	// --- Limits
	59
	60	fMaxR = new RGValuator(this, "Max R:", 110, 0);
	61	fMaxR->SetLabelWidth(labelW);
	62	fMaxR->SetNELength(6);
	63	fMaxR->Build();
	64	fMaxR->SetLimits(0.1, 1000, 100, TGNumberFormat::kNESRealOne);
	65	fMaxR->SetToolTip("Maximum radius to which the tracks will be drawn.");
	66	fMaxR->Connect("ValueSet(Double_t)", "Reve::TrackListEditor", this, "DoMaxR()");
	67	AddFrame(fMaxR, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	68
	69	fMaxZ = new RGValuator(this, "Max Z:", 110, 0);
	70	fMaxZ->SetLabelWidth(labelW);
	71	fMaxZ->SetNELength(6);
	72	fMaxZ->Build();
	73	fMaxZ->SetLimits(0.1, 2000, 100, TGNumberFormat::kNESRealOne);
	74	fMaxZ->SetToolTip("Maximum z-coordinate to which the tracks will be drawn.");
	75	fMaxZ->Connect("ValueSet(Double_t)", "Reve::TrackListEditor", this, "DoMaxZ()");
	76	AddFrame(fMaxZ, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
5a5a1232	77
	78	{
	79	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	80	TGLabel *l = new TGLabel(f, "Max Orbits:");
	81	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 0, 2, 1, 1));
	82	fMaxOrbits = new TGNumberEntry(f, 0., 6, -1,
	83	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	84	TGNumberFormat::kNELLimitMinMax, 0.1, 100.0);
	85	fMaxOrbits->GetNumberEntry()->SetToolTipText("Maximal angular path of tracks' orbits (1 ~ 2Pi).");
	86	f->AddFrame(fMaxOrbits, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	87	fMaxOrbits->Associate(f);
	88	fMaxOrbits->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxOrbits()");
	89	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	90	}
	91
	92	{
	93	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	94	TGLabel *l = new TGLabel(f, "Min Angle:");
	95	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 3, 2, 1, 1));
	96	fMinAng = new TGNumberEntry(f, 0., 6, -1,
	97	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	98	TGNumberFormat::kNELLimitMinMax, 1, 180.0);
	99	fMinAng->GetNumberEntry()->SetToolTipText("Minimal angular step between two helix points.");
	100	f->AddFrame(fMinAng, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	101	fMinAng->Associate(f);
	102	fMinAng->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMinAng()");
	103	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	104	}
	105
	106	{
	107	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	108	TGLabel *l = new TGLabel(f, "Delta:");
	109	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 32, 2, 1, 1));
	110	fDelta = new TGNumberEntry(f, 0., 6, -1,
694e6973	111	TGNumberFormat::kNESRealThree, TGNumberFormat::kNEAPositive,
f1d52824	112	TGNumberFormat::kNELLimitMinMax, 0.001, 100.0);
5a5a1232	113	fDelta->GetNumberEntry()->SetToolTipText("Maximal error at the mid-point of the line connecting to helix points.");
	114	f->AddFrame(fDelta, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	115	fDelta->Associate(f);
	116	fDelta->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoDelta()");
	117	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	118	}
	119
511684d7	120	// --- Selectors
5a5a1232	121
511684d7	122	fPtRange = new RGDoubleValuator(this,"Pt Range", 200, 0);
	123	fPtRange->SetNELength(6);
	124	fPtRange->Build();
	125	fPtRange->GetSlider()->SetWidth(224);
22df2a83	126	fPtRange->SetLimits(0, 10, TGNumberFormat::kNESRealTwo);
511684d7	127	fPtRange->Connect("ValueSet()",
	128	"Reve::TrackListEditor", this, "DoPtRange()");
	129	AddFrame(fPtRange, new TGLayoutHints(kLHintsTop, 1, 1, 4, 1));
	130
	131	// --- Rendering control
2074deef	132	{
	133	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	134	fRnrTracks = new TGCheckButton(f, "Render tracks");
	135	f->AddFrame(fRnrTracks, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 0));
	136	fRnrTracks->Connect
	137	("Toggled(Bool_t)", "Reve::TrackListEditor", this, "DoRnrTracks()");
	138	fWidthCombo = new TGLineWidthComboBox(f);
	139	fWidthCombo->Resize(80, 18);
	140	f->AddFrame(fWidthCombo, new TGLayoutHints(kLHintsLeft, 8, 1, 0, 0));
	141
	142	fWidthCombo->Connect
	143	("Selected(Int_t)", "Reve::TrackListEditor", this, "DoLineWidth(Int_t)");
	144	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 3, 0));
	145	}
5a5a1232	146
511684d7	147	// --- Kinematics fitting
	148
	149	fPMFrame = new TGHorizontalFrame(this);
	150	{
	151	TGGroupFrame* fitPM = new TGGroupFrame(fPMFrame, "PathMarks:", kLHintsTop \| kLHintsCenterX);
	152	fitPM->SetTitlePos(TGGroupFrame::kLeft);
	153	fPMFrame->AddFrame( fitPM, new TGLayoutHints(kLHintsTop \| kLHintsCenterX \| kLHintsExpandX, 3, 3, 3, 3));
	154
	155	TGMatrixLayout *ml = new TGMatrixLayout(fitPM, 0,1,6);
	156	fitPM->SetLayoutManager(ml);
	157
89083271	158	fFitDaughters = new TGCheckButton(fitPM, "Fit Daughters", PathMark::Daughter);
	159	fFitReferences = new TGCheckButton(fitPM, "Fit Refs", PathMark::Reference);
	160	fFitDecay = new TGCheckButton(fitPM, "Fit Decay", PathMark::Decay);
511684d7	161
	162	fitPM->AddFrame(fFitDaughters);
	163	fitPM->AddFrame(fFitReferences);
	164	fitPM->AddFrame(fFitDecay);
	165
	166	fFitDecay->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");
	167	fFitReferences->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");
	168	fFitDaughters->Connect("Clicked()","Reve::TrackListEditor", this, "DoFitPM()");
	169	}
	170	{
	171	TGGroupFrame* rnrPM = new TGGroupFrame(fPMFrame, "PathMarks:", kLHintsTop \| kLHintsCenterX);
	172	rnrPM->SetTitlePos(TGGroupFrame::kLeft);
	173	fPMFrame->AddFrame( rnrPM, new TGLayoutHints(kLHintsTop \| kLHintsCenterX \| kLHintsExpandX, 3, 3, 3, 3));
	174
	175	TGMatrixLayout *ml = new TGMatrixLayout(rnrPM, 0,1,6);
	176	rnrPM->SetLayoutManager(ml);
	177
	178	fRnrDaughters = new TGCheckButton(rnrPM, "Rnr Daughters", PathMark::Daughter);
	179	fRnrReferences = new TGCheckButton(rnrPM, "Rnr Refs", PathMark::Reference);
	180	fRnrDecay = new TGCheckButton(rnrPM, "Rnr Decay", PathMark::Decay);
	181
	182	rnrPM->AddFrame(fRnrDaughters);
	183	rnrPM->AddFrame(fRnrReferences);
	184	rnrPM->AddFrame(fRnrDecay);
	185
	186	fRnrDecay->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");
	187	fRnrReferences->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");
	188	fRnrDaughters->Connect("Clicked()","Reve::TrackListEditor", this, "DoRnrPM()");
	189	}
	190	AddFrame(fPMFrame, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	191
5a5a1232	192	fRnrMarkers = new TGCheckButton(this, "Render markers");
2074deef	193	AddFrame(fRnrMarkers, new TGLayoutHints(kLHintsTop, 3, 1, 2, 0));
5a5a1232	194	fRnrMarkers->Connect
	195	("Toggled(Bool_t)",
	196	"Reve::TrackListEditor", this, "DoRnrMarkers()");
	197
5a5a1232	198	}
	199
	200	TrackListEditor::~TrackListEditor()
	201	{}
	202
	203	/**************************************************************************/
	204
a8600b56	205	void TrackListEditor::SetModel(TObject* obj)
5a5a1232	206	{
a8600b56	207	fTC = dynamic_cast<TrackList*>(obj);
5a5a1232	208
f1d52824	209	fMaxR->SetValue(fTC->GetMaxR());
f1d52824	210	fMaxZ->SetValue(fTC->GetMaxZ());
5a5a1232	211	fMaxOrbits->SetNumber(fTC->GetMaxOrbs());
	212	fMinAng->SetNumber(fTC->GetMinAng());
	213	fDelta->SetNumber(fTC->GetDelta());
	214
2074deef	215	fWidthCombo->Select(fTC->GetWidth());
2074deef	216
5a5a1232	217	fRnrTracks->SetState(fTC->GetRnrTracks() ? kButtonDown : kButtonUp);
511684d7	218
	219	if(fTC->GetEditPathMarks())
	220	{
	221	HideFrame(fRnrMarkers);
	222	ShowFrame(fPMFrame);
	223	fRnrDaughters->SetState(fTC->GetRnrDaughters() ? kButtonDown : kButtonUp);
	224	fRnrReferences->SetState(fTC->GetRnrReferences() ? kButtonDown : kButtonUp);
	225	fRnrDecay->SetState(fTC->GetRnrDecay() ? kButtonDown : kButtonUp);
	226
	227	fFitDaughters->SetState(fTC->GetFitDaughters() ? kButtonDown : kButtonUp);
	228	fFitReferences->SetState(fTC->GetFitReferences() ? kButtonDown : kButtonUp);
	229	fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);
	230	}
	231	else
	232	{
	233	HideFrame(fPMFrame);
	234	ShowFrame(fRnrMarkers);
	235	fRnrMarkers->SetState(fTC->GetRnrMarkers() ? kButtonDown : kButtonUp);
	236	}
22df2a83	237	fPtRange->SetValues(fTC->GetMinPt(), fTC->GetMaxPt());
5a5a1232	238	}
	239
	240	/**************************************************************************/
	241
	242	void TrackListEditor::DoMaxR()
	243	{
f1d52824	244	fTC->SetMaxR(fMaxR->GetValue());
5a5a1232	245	Update();
	246	}
	247
	248	void TrackListEditor::DoMaxZ()
	249	{
f1d52824	250	fTC->SetMaxZ(fMaxZ->GetValue());
5a5a1232	251	Update();
	252	}
	253
	254	void TrackListEditor::DoMaxOrbits()
	255	{
	256	fTC->SetMaxOrbs(fMaxOrbits->GetNumber());
	257	Update();
	258	}
	259
	260	void TrackListEditor::DoMinAng()
	261	{
	262	fTC->SetMinAng(fMinAng->GetNumber());
	263	Update();
	264	}
	265
	266	void TrackListEditor::DoDelta()
	267	{
	268	fTC->SetDelta(fDelta->GetNumber());
	269	Update();
	270	}
	271
	272	/**************************************************************************/
	273
2074deef	274	void TrackListEditor::DoLineWidth(Int_t width)
	275	{
	276	fTC->SetWidth(width);
	277	Update();
	278	}
	279
	280	/**************************************************************************/
	281
5a5a1232	282	void TrackListEditor::DoRnrTracks()
	283	{
	284	fTC->SetRnrTracks(fRnrTracks->IsOn());
	285	Update();
	286	}
	287
	288	void TrackListEditor::DoRnrMarkers()
	289	{
	290	fTC->SetRnrMarkers(fRnrMarkers->IsOn());
	291	Update();
	292	}
	293
	294	/**************************************************************************/
	295
511684d7	296	void TrackListEditor::DoFitPM()
5a5a1232	297	{
511684d7	298	TGButton* b = (TGButton *) gTQSender;
	299	PathMark::Type_e type = PathMark::Type_e(b->WidgetId());
	300	Bool_t on = b->IsOn();
	301
	302	switch(type)
	303	{
	304	case PathMark::Daughter:
	305	fTC->SetFitDaughters(on);
	306	break;
	307	case PathMark::Reference:
	308	fTC->SetFitReferences(on);
	309	break;
	310	case PathMark::Decay:
	311	fTC->SetFitDecay(on);
	312	break;
	313	default:
	314	break;
	315	}
5a5a1232	316	Update();
	317	}
	318
511684d7	319	void TrackListEditor::DoRnrPM()
5a5a1232	320	{
511684d7	321	TGButton * b = (TGButton *) gTQSender;
	322	PathMark::Type_e type = PathMark::Type_e(b->WidgetId());
	323	Bool_t on = b->IsOn();
	324	switch(type){
	325	case PathMark::Daughter:
	326	fTC->SetRnrDaughters(on);
	327	break;
	328	case PathMark::Reference:
	329	fTC->SetRnrReferences(on);
	330	break;
	331	case PathMark::Decay:
	332	fTC->SetRnrDecay(on);
	333	break;
	334
	335	default:
	336	break;
	337
	338	}
5a5a1232	339	Update();
5a5a1232	340	}
5a5a1232	341	/**************************************************************************/
5a5a1232	342
a3912979	343	void TrackListEditor::DoPtRange()
5a5a1232	344	{
511684d7	345
a3912979	346	fTC->SelectByPt(fPtRange->GetMin(), fPtRange->GetMax());
a8600b56	347	Update();
5a5a1232	348	}
6bd69299	349
	350
	351
	352	/**************************************************************************/
	353	/**************************************************************************/
	354	/**************************************************************************/
	355
	356	#include <TCanvas.h>
	357	#include <TGLViewer.h>
	358	#include <Reve/RGTopFrame.h>
	359
	360	//______________________________________________________________________
	361	// TrackCounterEditor
	362	//
	363
	364	ClassImp(TrackCounterEditor)
	365
	366	TrackCounterEditor::TrackCounterEditor(const TGWindow *p, Int_t width, Int_t height,
	367	UInt_t options, Pixel_t back) :
	368	TGedFrame(p, width, height, options \| kVerticalFrame, back),
	369	fM(0),
	370	fClickAction (0),
5ea94a5a	371	fInfoLabel (0),
5ea94a5a	372	fEventId (0)
6bd69299	373	{
	374	MakeTitle("TrackCounter");
	375
	376	Int_t labelW = 42;
	377
	378	{ // ClickAction
	379	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	380	TGLabel* lab = new TGLabel(f, "Click:");
	381	f->AddFrame(lab, new TGLayoutHints(kLHintsLeft\|kLHintsBottom, 1, 10, 1, 2));
	382	fClickAction = new TGComboBox(f);
	383	fClickAction->AddEntry("Print", 0);
	384	fClickAction->AddEntry("Toggle", 1);
	385	TGListBox* lb = fClickAction->GetListBox();
	386	lb->Resize(lb->GetWidth(), 2*16);
	387	fClickAction->Resize(70, 20);
	388	fClickAction->Connect("Selected(Int_t)", "Reve::TrackCounterEditor", this,
	389	"DoClickAction(Int_t)");
	390	f->AddFrame(fClickAction, new TGLayoutHints(kLHintsLeft, 1, 2, 1, 1));
	391
	392	AddFrame(f);
	393	}
	394
	395	{ // Status
	396	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	397	TGLabel* lab = new TGLabel(f, "Status:");
	398	f->AddFrame(lab, new TGLayoutHints(kLHintsLeft, 1, 5, 1, 2));
	399
	400	fInfoLabel = new TGLabel(f);
	401	f->AddFrame(fInfoLabel, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 9, 1, 2));
	402
	403	AddFrame(f);
	404	}
	405
	406	{
	407	TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);
	408
	409	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
c71edfe9	410	TGLabel* l = new TGLabel(g, "View:");
6bd69299	411	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	412	f->AddFrame(g);
	413
	414	TGTextButton* b;
	415
	416	b = new TGTextButton(f, "Orto XY");
	417	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	418	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoOrtoXY()");
	419
	420	b = new TGTextButton(f, "Orto ZY");
	421	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	422	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoOrtoZY()");
	423
	424	b = new TGTextButton(f, "Persp");
	425	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	426	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPersp()");
	427
	428	AddFrame(f);
	429	}
	430
	431	{
	432	TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);
	433
	434	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
c71edfe9	435	TGLabel* l = new TGLabel(g, "Event:");
6bd69299	436	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	437	f->AddFrame(g);
	438
	439	TGTextButton* b;
	440
	441	b = new TGTextButton(f, "Prev");
	442	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	443	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPrev()");
	444
16100de8	445	fEventId = new TGNumberEntry(f, 0, 3, -1,TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative,
5ea94a5a	446	TGNumberFormat::kNELLimitMinMax, 0, 1000);
	447	f->AddFrame(fEventId, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	448	fEventId->Connect("ValueSet(Long_t)", "Reve::TrackCounterEditor", this, "DoSetEvent()");
	449
6bd69299	450	b = new TGTextButton(f, "Next");
	451	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	452	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoNext()");
	453
	454	AddFrame(f);
	455	}
	456
c71edfe9	457	{
	458	TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);
	459
	460	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
	461	TGLabel* l = new TGLabel(g, "Report:");
	462	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	463	f->AddFrame(g);
	464
	465	TGTextButton* b;
	466
	467	b = new TGTextButton(f, "Print");
	468	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	469	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoPrintReport()");
	470
	471	b = new TGTextButton(f, "File");
	472	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	473	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoFileReport()");
	474
	475	AddFrame(f, new TGLayoutHints(kLHintsLeft, 0, 0, 4, 0));
	476	}
	477	{
	478	TGHorizontalFrame* f = new TGHorizontalFrame(this, 210, 20, kFixedWidth);
	479
	480	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
	481	TGLabel* l = new TGLabel(g, "Histos:");
	482	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	483	f->AddFrame(g);
	484
	485	TGTextButton* b;
	486
	487	b = new TGTextButton(f, "Show");
	488	f->AddFrame(b, new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 0, 0));
	489	b->Connect("Clicked()", "Reve::TrackCounterEditor", this, "DoShowHistos()");
	490
	491	AddFrame(f, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
	492	}
	493
6bd69299	494	}
	495
	496	TrackCounterEditor::~TrackCounterEditor()
	497	{}
	498
	499	/**************************************************************************/
	500
	501	void TrackCounterEditor::SetModel(TObject* obj)
	502	{
	503	fM = dynamic_cast<TrackCounter*>(obj);
	504
	505	fClickAction->Select(fM->fClickAction, kFALSE);
	506	fInfoLabel->SetText(Form("All: %3d; Primaries: %3d", fM->fAllTracks, fM->fGoodTracks));
5ea94a5a	507	fEventId->SetNumber(fM->GetEventId());
6bd69299	508	}
	509
	510	/**************************************************************************/
	511
	512	// glv->SetOrthoCamera(TGLViewer::kCameraOrthoXOY, 2left, 2right, 2*top, bottom);
	513
	514	void TrackCounterEditor::DoOrtoXY()
	515	{
	516	TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
	517	glv->SetCurrentCamera(TGLViewer::kCameraOrthoXOY) ;
	518	}
	519
	520	void TrackCounterEditor::DoOrtoZY()
	521	{
	522	TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
	523	glv->SetCurrentCamera(TGLViewer::kCameraOrthoZOY) ;
	524	}
	525
	526	void TrackCounterEditor::DoPersp()
	527	{
	528	TGLViewer* glv = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
	529	glv->SetCurrentCamera(TGLViewer::kCameraPerspXOZ) ;
	530	}
	531
	532	/**************************************************************************/
	533
	534	void TrackCounterEditor::DoPrev()
	535	{
	536	Reve::Macro("event_prev.C");
	537	gReve->EditRenderElement(fM);
6bd69299	538	}
	539
	540	void TrackCounterEditor::DoNext()
	541	{
	542	Reve::Macro("event_next.C");
	543	gReve->EditRenderElement(fM);
c71edfe9	544	}
c71edfe9	545
5ea94a5a	546	void TrackCounterEditor::DoSetEvent()
	547	{
	548	Reve::LoadMacro("event_goto.C");
	549	gROOT->ProcessLine(Form("event_goto(%d);", (Int_t) fEventId->GetNumber()));
	550	gReve->EditRenderElement(fM);
	551	}
	552
c71edfe9	553	/**************************************************************************/
6bd69299	554
c71edfe9	555	void TrackCounterEditor::DoPrintReport()
	556	{
	557	fM->OutputEventTracks();
	558	}
	559
	560	void TrackCounterEditor::DoFileReport()
	561	{
	562	TString file(Form("ev-report-%03d.txt", fM->GetEventId()));
	563	if (gSystem->AccessPathName(file) == kFALSE)
	564	{
	565	Int_t ret;
	566	new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
	567	"File Exist",
	568	Form("Event record for event %d already exist.\n Replace?", fM->GetEventId()),
	569	kMBIconQuestion, kMBYes \| kMBNo, &ret);
	570	if (ret == kMBNo)
	571	return;
	572	}
	573	FILE* out = fopen(file, "w");
	574	fM->OutputEventTracks(out);
	575	fclose(out);
6bd69299	576	}
6bd69299	577
c71edfe9	578	void TrackCounterEditor::DoShowHistos()
	579	{
	580	TH1F* hcnt = new TH1F("cnt", "Primeries per event", 41, -0.5, 40.5);
	581	TH1F* hchg = new TH1F("chg", "Primary charge", 3, -1.5, 1.5);
	582	TH1F* hpt = new TH1F("pt", "pT distribution", 40, 0.0, 8.0);
	583	TH1F* heta = new TH1F("eta", "eta distribution", 40, -1.0, 1.0);
	584
	585	Int_t nn; // fscanf return value
	586
	587	for (Int_t i=0; i<1000; ++i)
	588	{
	589	TString file(Form("ev-report-%03d.txt", i));
	590	if (gSystem->AccessPathName(file) == kFALSE)
	591	{
	592	Int_t ev, ntr;
	593	FILE* f = fopen(file, "read");
	594	nn = fscanf(f, "Event = %d Ntracks = %d", &ev, &ntr);
	595	if (nn != 2) { printf("SAFR1 %d\n", nn); fclose(f); return; }
	596	hcnt->Fill(ntr);
	597	for (Int_t t=0; t<ntr; ++t)
	598	{
	599	Int_t id, chg;
	600	Float_t pt, eta;
	601	nn = fscanf(f, "%d: chg=%d pt=%f eta=%f", &id, &chg, &pt, &eta);
	602	if (nn != 4) { printf("SAFR2 %d\n", nn); fclose(f); return; }
	603	hchg->Fill(chg);
	604	hpt ->Fill(pt);
	605	heta->Fill(eta);
	606	}
	607	fclose(f);
	608	}
	609	}
	610
	611	TCanvas* c;
	612	if (gPad == 0 \|\| gPad->GetCanvas()->IsEditable() == kFALSE) {
	613	c = new TCanvas("Scanwas", "Scanning Results", 800, 600);
	614	} else {
	615	c = gPad->GetCanvas();
	616	c->Clear();
	617	}
	618	c->Divide(2, 2);
	619
	620	c->cd(1); hcnt->Draw();
	621	c->cd(2); hchg->Draw();
	622	c->cd(3); hpt ->Draw();
	623	c->cd(4); heta->Draw();
	624
	625	c->Modified();
	626	c->Update();
	627	}
	628
	629
6bd69299	630	/**************************************************************************/
	631
	632	void TrackCounterEditor::DoClickAction(Int_t mode)
	633	{
	634	fM->SetClickAction(mode);
	635	}