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

// $Header$

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

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

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

using namespace Reve;

//______________________________________________________________________
// TrackListEditor
//

ClassImp(TrackListEditor)

TrackListEditor::TrackListEditor(const TGWindow *p, Int_t id, Int_t width, Int_t height,
	     UInt_t options, Pixel_t back) :
  TGedFrame(p, id, width, height, options | kVerticalFrame, back)
{
  fTC = 0;
  MakeTitle("TrackList");

    // --- Limits

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel *l = new TGLabel(f, "Max R:");
    f->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 25, 2, 1, 1));
    fMaxR = new TGNumberEntry(f, 0., 6, -1, 
			      TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
			      TGNumberFormat::kNELLimitMinMax, 0.1, 2000.0);
    fMaxR->GetNumberEntry()->SetToolTipText("Maximum radius to which the tracks will be drawn.");
    f->AddFrame(fMaxR, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fMaxR->Associate(f);
    fMaxR->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxR()");
    AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
  }

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGLabel *l = new TGLabel(f, "Max Z:");
    f->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 24, 2, 1, 1));
    fMaxZ = new TGNumberEntry(f, 0., 6, -1, 
			      TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
			      TGNumberFormat::kNELLimitMinMax, 0.1, 2000.0);
    fMaxZ->GetNumberEntry()->SetToolTipText("Maximum z-coordinate to which the tracks will be drawn.");
    f->AddFrame(fMaxZ, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fMaxZ->Associate(f);
    fMaxZ->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxZ()");
    AddFrame(f, 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::kNESRealOne, 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));
  }

  // --- Rendering control

  fRnrTracks = new TGCheckButton(this, "Render tracks");
  AddFrame(fRnrTracks, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrTracks->Connect
    ("Toggled(Bool_t)",
     "Reve::TrackListEditor", this, "DoRnrTracks()");

  fRnrMarkers = new TGCheckButton(this, "Render markers");
  AddFrame(fRnrMarkers, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrMarkers->Connect
    ("Toggled(Bool_t)",
     "Reve::TrackListEditor", this, "DoRnrMarkers()");  

  // --- Kinematics fitting

  fFitDaughters = new TGCheckButton(this, "Fit daughters");
  AddFrame(fFitDaughters, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fFitDaughters->Connect("Toggled(Bool_t)","Reve::TrackListEditor", this, "DoFitDaughters()");

  fFitDecay = new TGCheckButton(this, "Fit decay");
  AddFrame(fFitDecay, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fFitDecay->Connect("Toggled(Bool_t)","Reve::TrackListEditor", this, "DoFitDecay()");  

  // --- Selectors

  TGDoubleHSlider* hs = new TGDoubleHSlider(this);
  hs->SetRange(0.1, 10);
  hs->SetPosition(0.1, 10);
  hs->Resize(260, 20);
  AddFrame(hs, new TGLayoutHints(kLHintsLeft, 0, 5));
  hs->Connect("PositionChanged()", "Reve::TrackListEditor",
	      this, "DoPtScroll()");


  // Register the editor.
  TClass *cl = TrackList::Class();
  TGedElement *ge = new TGedElement;
  ge->fGedFrame = this;
  ge->fCanvas = 0;
  cl->GetEditorList()->Add(ge);
}

TrackListEditor::~TrackListEditor()
{}

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

void TrackListEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
  fModel = 0;
  fPad   = 0;

  if (!obj || !obj->InheritsFrom(TrackList::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
    SetActive(kFALSE);
    return;
  }

  fModel = obj;
  fPad   = pad;

  fTC = dynamic_cast<TrackList*>(fModel);

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

  fRnrTracks->SetState(fTC->GetRnrTracks() ? kButtonDown : kButtonUp);
  fRnrMarkers->SetState(fTC->GetRnrMarkers() ? kButtonDown : kButtonUp);

  fFitDaughters->SetState(fTC->GetFitDaughters() ? kButtonDown : kButtonUp);
  fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);

  SetActive();
}

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

void TrackListEditor::DoMaxR()
{
  Double_t maxr = fMaxR->GetNumber();
  fTC->SetMaxR(maxr);
  Update();
}

void TrackListEditor::DoMaxZ()
{
  fTC->SetMaxZ(fMaxZ->GetNumber());
  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::DoRnrTracks()
{
  fTC->SetRnrTracks(fRnrTracks->IsOn());
  Update();
}

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

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

void TrackListEditor::DoFitDaughters()
{
  fTC->SetFitDaughters(fFitDaughters->IsOn());
  Update();
}

void TrackListEditor::DoFitDecay()
{
  fTC->SetFitDecay(fFitDecay->IsOn());
  Update();
}

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

void TrackListEditor::DoPtScroll()
{
  TGDoubleHSlider* hs = (TGDoubleHSlider*)gTQSender;

  Double_t min = hs->GetMinPosition(), max = hs->GetMaxPosition();
  printf("Track pt range: min=%f max=%f\n", min, max);
  fTC->SelectByPt(min, max);
}
Commit	Line	Data
	1	// $Header$
	2
	3	#include "TrackEditors.h"
	4	#include <Reve/Track.h>
	5
	6	#include <TVirtualPad.h>
	7	#include <TColor.h>
	8
	9	#include <TGLabel.h>
	10	#include <TGButton.h>
	11	#include <TGNumberEntry.h>
	12	#include <TGColorSelect.h>
	13	#include <TGDoubleSlider.h>
	14
	15	using namespace Reve;
	16
	17	//______________________________________________________________________
	18	// TrackListEditor
	19	//
	20
	21	ClassImp(TrackListEditor)
	22
	23	TrackListEditor::TrackListEditor(const TGWindow *p, Int_t id, Int_t width, Int_t height,
	24	UInt_t options, Pixel_t back) :
	25	TGedFrame(p, id, width, height, options \| kVerticalFrame, back)
	26	{
	27	fTC = 0;
	28	MakeTitle("TrackList");
	29
	30	// --- Limits
	31
	32	{
	33	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	34	TGLabel *l = new TGLabel(f, "Max R:");
	35	f->AddFrame(l, new TGLayoutHints(kLHintsLeft \| kLHintsCenterY, 25, 2, 1, 1));
	36	fMaxR = new TGNumberEntry(f, 0., 6, -1,
	37	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	38	TGNumberFormat::kNELLimitMinMax, 0.1, 2000.0);
	39	fMaxR->GetNumberEntry()->SetToolTipText("Maximum radius to which the tracks will be drawn.");
	40	f->AddFrame(fMaxR, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	41	fMaxR->Associate(f);
	42	fMaxR->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxR()");
	43	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	44	}
	45
	46	{
	47	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	48	TGLabel *l = new TGLabel(f, "Max Z:");
	49	f->AddFrame(l, new TGLayoutHints(kLHintsLeft \| kLHintsCenterY, 24, 2, 1, 1));
	50	fMaxZ = new TGNumberEntry(f, 0., 6, -1,
	51	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	52	TGNumberFormat::kNELLimitMinMax, 0.1, 2000.0);
	53	fMaxZ->GetNumberEntry()->SetToolTipText("Maximum z-coordinate to which the tracks will be drawn.");
	54	f->AddFrame(fMaxZ, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	55	fMaxZ->Associate(f);
	56	fMaxZ->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxZ()");
	57	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	58	}
	59
	60	{
	61	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	62	TGLabel *l = new TGLabel(f, "Max Orbits:");
	63	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 0, 2, 1, 1));
	64	fMaxOrbits = new TGNumberEntry(f, 0., 6, -1,
	65	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	66	TGNumberFormat::kNELLimitMinMax, 0.1, 100.0);
	67	fMaxOrbits->GetNumberEntry()->SetToolTipText("Maximal angular path of tracks' orbits (1 ~ 2Pi).");
	68	f->AddFrame(fMaxOrbits, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	69	fMaxOrbits->Associate(f);
	70	fMaxOrbits->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMaxOrbits()");
	71	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	72	}
	73
	74	{
	75	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	76	TGLabel *l = new TGLabel(f, "Min Angle:");
	77	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 3, 2, 1, 1));
	78	fMinAng = new TGNumberEntry(f, 0., 6, -1,
	79	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	80	TGNumberFormat::kNELLimitMinMax, 1, 180.0);
	81	fMinAng->GetNumberEntry()->SetToolTipText("Minimal angular step between two helix points.");
	82	f->AddFrame(fMinAng, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	83	fMinAng->Associate(f);
	84	fMinAng->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoMinAng()");
	85	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	86	}
	87
	88	{
	89	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	90	TGLabel *l = new TGLabel(f, "Delta:");
	91	f->AddFrame(l, new TGLayoutHints(kLHintsTop \| kLHintsCenterY, 32, 2, 1, 1));
	92	fDelta = new TGNumberEntry(f, 0., 6, -1,
	93	TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAPositive,
	94	TGNumberFormat::kNELLimitMinMax, 0.001, 100.0);
	95	fDelta->GetNumberEntry()->SetToolTipText("Maximal error at the mid-point of the line connecting to helix points.");
	96	f->AddFrame(fDelta, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
	97	fDelta->Associate(f);
	98	fDelta->Connect("ValueSet(Long_t)", "Reve::TrackListEditor", this, "DoDelta()");
	99	AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
	100	}
	101
	102	// --- Rendering control
	103
	104	fRnrTracks = new TGCheckButton(this, "Render tracks");
	105	AddFrame(fRnrTracks, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	106	fRnrTracks->Connect
	107	("Toggled(Bool_t)",
	108	"Reve::TrackListEditor", this, "DoRnrTracks()");
	109
	110	fRnrMarkers = new TGCheckButton(this, "Render markers");
	111	AddFrame(fRnrMarkers, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	112	fRnrMarkers->Connect
	113	("Toggled(Bool_t)",
	114	"Reve::TrackListEditor", this, "DoRnrMarkers()");
	115
	116	// --- Kinematics fitting
	117
	118	fFitDaughters = new TGCheckButton(this, "Fit daughters");
	119	AddFrame(fFitDaughters, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	120	fFitDaughters->Connect("Toggled(Bool_t)","Reve::TrackListEditor", this, "DoFitDaughters()");
	121
	122	fFitDecay = new TGCheckButton(this, "Fit decay");
	123	AddFrame(fFitDecay, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	124	fFitDecay->Connect("Toggled(Bool_t)","Reve::TrackListEditor", this, "DoFitDecay()");
	125
	126	// --- Selectors
	127
	128	TGDoubleHSlider* hs = new TGDoubleHSlider(this);
	129	hs->SetRange(0.1, 10);
	130	hs->SetPosition(0.1, 10);
	131	hs->Resize(260, 20);
	132	AddFrame(hs, new TGLayoutHints(kLHintsLeft, 0, 5));
	133	hs->Connect("PositionChanged()", "Reve::TrackListEditor",
	134	this, "DoPtScroll()");
	135
	136
	137	// Register the editor.
	138	TClass *cl = TrackList::Class();
	139	TGedElement *ge = new TGedElement;
	140	ge->fGedFrame = this;
	141	ge->fCanvas = 0;
	142	cl->GetEditorList()->Add(ge);
	143	}
	144
	145	TrackListEditor::~TrackListEditor()
	146	{}
	147
	148	/**************************************************************************/
	149
	150	void TrackListEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
	151	{
	152	fModel = 0;
	153	fPad = 0;
	154
	155	if (!obj \|\| !obj->InheritsFrom(TrackList::Class()) \|\| obj->InheritsFrom(TVirtualPad::Class())) {
	156	SetActive(kFALSE);
	157	return;
	158	}
	159
	160	fModel = obj;
	161	fPad = pad;
	162
	163	fTC = dynamic_cast<TrackList*>(fModel);
	164
	165	fMaxR->SetNumber(fTC->GetMaxR());
	166	fMaxZ->SetNumber(fTC->GetMaxZ());
	167	fMaxOrbits->SetNumber(fTC->GetMaxOrbs());
	168	fMinAng->SetNumber(fTC->GetMinAng());
	169	fDelta->SetNumber(fTC->GetDelta());
	170
	171	fRnrTracks->SetState(fTC->GetRnrTracks() ? kButtonDown : kButtonUp);
	172	fRnrMarkers->SetState(fTC->GetRnrMarkers() ? kButtonDown : kButtonUp);
	173
	174	fFitDaughters->SetState(fTC->GetFitDaughters() ? kButtonDown : kButtonUp);
	175	fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);
	176
	177	SetActive();
	178	}
	179
	180	/**************************************************************************/
	181
	182	void TrackListEditor::DoMaxR()
	183	{
	184	Double_t maxr = fMaxR->GetNumber();
	185	fTC->SetMaxR(maxr);
	186	Update();
	187	}
	188
	189	void TrackListEditor::DoMaxZ()
	190	{
	191	fTC->SetMaxZ(fMaxZ->GetNumber());
	192	Update();
	193	}
	194
	195	void TrackListEditor::DoMaxOrbits()
	196	{
	197	fTC->SetMaxOrbs(fMaxOrbits->GetNumber());
	198	Update();
	199	}
	200
	201	void TrackListEditor::DoMinAng()
	202	{
	203	fTC->SetMinAng(fMinAng->GetNumber());
	204	Update();
	205	}
	206
	207	void TrackListEditor::DoDelta()
	208	{
	209	fTC->SetDelta(fDelta->GetNumber());
	210	Update();
	211	}
	212
	213	/**************************************************************************/
	214
	215	void TrackListEditor::DoRnrTracks()
	216	{
	217	fTC->SetRnrTracks(fRnrTracks->IsOn());
	218	Update();
	219	}
	220
	221	void TrackListEditor::DoRnrMarkers()
	222	{
	223	fTC->SetRnrMarkers(fRnrMarkers->IsOn());
	224	Update();
	225	}
	226
	227	/**************************************************************************/
	228
	229	void TrackListEditor::DoFitDaughters()
	230	{
	231	fTC->SetFitDaughters(fFitDaughters->IsOn());
	232	Update();
	233	}
	234
	235	void TrackListEditor::DoFitDecay()
	236	{
	237	fTC->SetFitDecay(fFitDecay->IsOn());
	238	Update();
	239	}
	240
	241	/**************************************************************************/
	242
	243	void TrackListEditor::DoPtScroll()
	244	{
	245	TGDoubleHSlider* hs = (TGDoubleHSlider*)gTQSender;
	246
	247	Double_t min = hs->GetMinPosition(), max = hs->GetMaxPosition();
	248	printf("Track pt range: min=%f max=%f\n", min, max);
	249	fTC->SelectByPt(min, max);
	250	}