[u/mrichter/AliRoot.git] / EVE / Alieve / TPCLoaderEditor.cxx

// $Header$

#include "TPCLoaderEditor.h"
#include <Alieve/TPCLoader.h>
#include <Alieve/TPCData.h>
#include <Reve/ReveManager.h>
#include <Reve/RGValuators.h>

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

#include <TGLabel.h>
#include <TGButton.h>
#include <TGTextEntry.h>
#include <TGNumberEntry.h>
#include <TGFileDialog.h>
#include <TGToolTip.h>

using namespace Reve;
using namespace Alieve;

//______________________________________________________________________
// TPCLoaderEditor
//

ClassImp(TPCLoaderEditor)

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

    fM (0),

    fFile     (0),
    fOpenFile (0),

    fEvent    (0),
    fDoubleSR (0),

    fDataLoadThreshold (0),
    fDataLoadPedestal  (0),
    fDataAutoPedestal  (0),

    fUpdateSectors   (0),
    fReloadSectors   (0),
    fCreateSectors3D (0),
    fDeleteSectors3D (0)
{
  MakeTitle("TPCLoader");

  Int_t labelW;

  // File / event interface

  labelW = 42;
  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
    TGLabel* l = new TGLabel(g, "File: ");
    g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
    f->AddFrame(g);
    fFile = new TGTextEntry(f);
    fFile->SetWidth(140);
    f->AddFrame(fFile);
    fFile->Connect("DoubleClicked()",
		   "Alieve::TPCLoaderEditor", this, "FileSelect()");
    fFile->Connect("TextChanged(const char *)",
		   "Alieve::TPCLoaderEditor", this, "FileChanged()");
    fOpenFile = new TGTextButton(f, "Open");
    f->AddFrame(fOpenFile);
    fOpenFile->Connect("Clicked()",
		       "Alieve::TPCLoaderEditor", this, "DoOpen()");
    AddFrame(f);
  }

  fEvent = new RGValuator(this, "Event:", 110, 0);
  fEvent->SetShowSlider(kFALSE);
  fEvent->SetLabelWidth(labelW);
  fEvent->SetNELength(6);
  fEvent->Build();
  fEvent->SetLimits(0, 1000);
  fEvent->SetToolTip("Current event number");
  fEvent->Connect("ValueSet(Double_t)",
		  "Alieve::TPCLoaderEditor", this, "DoEvent()");
  // Reuse Event for DoubleSR button
  fDoubleSR = new TGCheckButton(fEvent, "Double SR");
  fDoubleSR->SetToolTipText("Double sampling rate");
  fEvent->AddFrame(fDoubleSR, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
  fDoubleSR->Connect("Toggled(Bool_t)",
                     "Alieve::TPCLoaderEditor", this, "DoDoubleSR()");
  AddFrame(fEvent);


  // TPCData load settings

  labelW = 90;

  fDataLoadThreshold = new RGValuator(this, "Load threshold:", 110, 0);
  fDataLoadThreshold->SetShowSlider(kFALSE);
  fDataLoadThreshold->SetLabelWidth(labelW);
  fDataLoadThreshold->SetNELength(6);
  fDataLoadThreshold->Build();
  fDataLoadThreshold->SetLimits(0, 1000);
  fDataLoadThreshold->SetToolTip("Minimum signal that will be stored (pedestal subtracted first).");
  fDataLoadThreshold->Connect
    ("ValueSet(Double_t)",
     "Alieve::TPCLoaderEditor", this, "DoDataLoadThreshold()");
  AddFrame(fDataLoadThreshold, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));

  fDataLoadPedestal = new RGValuator(this, "Load pedestal:", 110, 0);
  fDataLoadPedestal->SetShowSlider(kFALSE);
  fDataLoadPedestal->SetLabelWidth(labelW);
  fDataLoadPedestal->SetNELength(6);
  fDataLoadPedestal->Build();
  fDataLoadPedestal->SetLimits(0, 1000);
  fDataLoadPedestal->SetToolTip("Pedestal that will be subtracted during data loading.");
  fDataLoadPedestal->Connect
    ("ValueSet(Double_t)",
     "Alieve::TPCLoaderEditor", this, "DoDataLoadPedestal()");
  // Reuse DataLoadPedestal for DataAutoPedestal check button
  fDataAutoPedestal = new TGCheckButton(fDataLoadPedestal, "Automatic");
  fDataAutoPedestal->SetToolTipText("Determine per-pad pedestal during data loading.");
  fDataAutoPedestal->Connect
    ("Toggled(Bool_t)",
     "Alieve::TPCLoaderEditor", this, "DoDataAutoPedestal()");
  fDataLoadPedestal->AddFrame(fDataAutoPedestal, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
  AddFrame(fDataLoadPedestal);

  // Steering buttons: update/reload sectors; show/hide 3d

  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    fUpdateSectors = new TGTextButton(f, "Update Sectors");
    f->AddFrame(fUpdateSectors, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
    fUpdateSectors->Connect("Clicked()",
			    "Alieve::TPCLoaderEditor", this, "DoUpdateSectors()");
    fReloadSectors = new TGTextButton(f, "Reload Sectors");
    f->AddFrame(fReloadSectors, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
    fReloadSectors->Connect("Clicked()",
			    "Alieve::TPCLoaderEditor", this, "DoReloadSectors()");
    AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
  }
  {
    TGHorizontalFrame* f = new TGHorizontalFrame(this);
    fCreateSectors3D = new TGTextButton(f, "Create 3D");
    f->AddFrame(fCreateSectors3D, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
    fCreateSectors3D->Connect("Clicked()",
			      "Alieve::TPCLoaderEditor", this, "DoCreateSectors3D()");
    fDeleteSectors3D = new TGTextButton(f, "Delete 3D");
    f->AddFrame(fDeleteSectors3D, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
    fDeleteSectors3D->Connect("Clicked()",
			      "Alieve::TPCLoaderEditor", this, "DoDeleteSectors3D()");
    AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
  }
}

TPCLoaderEditor::~TPCLoaderEditor()
{}

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

void TPCLoaderEditor::SetModel(TObject* obj)
{
  fM = dynamic_cast<TPCLoader*>(obj);

  // !!!! order changed, need TGTextEntry::SetText NO BLOODY EMIT.
  fFile->SetToolTipText(gSystem->DirName(fM->fFile));
  fFile->SetText(gSystem->BaseName(fM->fFile));
  fEvent->SetValue(fM->fEvent);
  fEvent->SetEnabled(fM->fEvent >= 0);
  fDoubleSR->SetState(fM->fDoubleSR ? kButtonDown : kButtonUp);

  TPCData* tpcd = fM->GetData();
  Bool_t   tpcp = (tpcd != 0);
  fDataLoadThreshold->SetEnabled(tpcp);
  fDataLoadPedestal ->SetEnabled(tpcp && ! tpcd->GetAutoPedestal());
  fDataAutoPedestal ->SetEnabled(tpcp);
  if (tpcp) {
    fDataLoadThreshold->SetValue(tpcd->GetLoadThreshold());
    fDataLoadPedestal ->SetValue(tpcd->GetLoadPedestal());
    fDataAutoPedestal ->SetState(tpcd->GetAutoPedestal() ? kButtonDown : kButtonUp);
  }
}

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

namespace {
const char *tpcfiletypes[] = {
   "Root files",  "*.root",
   "All files",   "*.*",
    0,               0
};
}

void TPCLoaderEditor::FileSelect()
{
  TGFileInfo fi;
  fi.fIniDir    = StrDup(gSystem->DirName (fM->fFile));
  fi.fFilename  = StrDup(gSystem->BaseName(fM->fFile));
  fi.fFileTypes = tpcfiletypes;

  new TGFileDialog(fClient->GetRoot(), gReve->GetMainWindow(), kFDOpen, &fi);
  if (!fi.fFilename)
    return;

  fFile->SetToolTipText(gSystem->DirName (fi.fFilename));
  fFile->SetText       (gSystem->BaseName(fi.fFilename));
}

void TPCLoaderEditor::FileChanged()
{
  fM->fFile = Form("%s/%s", fFile->GetToolTip()->GetText()->Data(),
		   fFile->GetText());
}

void TPCLoaderEditor::DoOpen()
{
  fM->OpenFile();
  SetModel(fM);
}

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

void TPCLoaderEditor::DoEvent()
{
  fM->GotoEvent((Int_t) fEvent->GetValue());
  SetModel(fM);
}

void TPCLoaderEditor::DoDoubleSR()
{
  fM->SetDoubleSR(fDoubleSR->IsOn());
  Update();
}

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

void TPCLoaderEditor::DoDataLoadThreshold()
{
  if (fM->GetData() == 0) return;
  fM->GetData()->SetLoadThreshold((Short_t) fDataLoadThreshold->GetValue());
}

void TPCLoaderEditor::DoDataLoadPedestal()
{
  if (fM->GetData() == 0) return;
  fM->GetData()->SetLoadPedestal((Short_t) fDataLoadPedestal->GetValue());
}

void TPCLoaderEditor::DoDataAutoPedestal()
{
  if (fM->GetData() == 0) return;
  fM->GetData()->SetAutoPedestal(fDataAutoPedestal->IsOn());
  fDataLoadPedestal->SetEnabled(!fDataAutoPedestal->IsOn());
}

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

void TPCLoaderEditor::DoUpdateSectors()
{
  fM->UpdateSectors();
}

void TPCLoaderEditor::DoReloadSectors()
{
  fM->ReloadSectors();
}

void TPCLoaderEditor::DoCreateSectors3D()
{
  fM->CreateSectors3D();
}


void TPCLoaderEditor::DoDeleteSectors3D()
{
  fM->DeleteSectors3D();
}
Commit	Line	Data
e9a38ea3	1	// $Header$
	2
	3	#include "TPCLoaderEditor.h"
	4	#include <Alieve/TPCLoader.h>
10b1edfc	5	#include <Alieve/TPCData.h>
32e219c2	6	#include <Reve/ReveManager.h>
e9a38ea3	7	#include <Reve/RGValuators.h>
	8
	9	#include <TSystem.h>
	10	#include <TVirtualPad.h>
	11	#include <TColor.h>
	12
	13	#include <TGLabel.h>
	14	#include <TGButton.h>
	15	#include <TGTextEntry.h>
	16	#include <TGNumberEntry.h>
	17	#include <TGFileDialog.h>
89ec258e	18	#include <TGToolTip.h>
e9a38ea3	19
	20	using namespace Reve;
	21	using namespace Alieve;
	22
	23	//______________________________________________________________________
	24	// TPCLoaderEditor
	25	//
	26
	27	ClassImp(TPCLoaderEditor)
	28
10b1edfc	29	TPCLoaderEditor::TPCLoaderEditor(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),
265ecb21	33
10b1edfc	34	fM (0),
265ecb21	35
10b1edfc	36	fFile (0),
10b1edfc	37	fOpenFile (0),
265ecb21	38
10b1edfc	39	fEvent (0),
10b1edfc	40	fDoubleSR (0),
265ecb21	41
10b1edfc	42	fDataLoadThreshold (0),
	43	fDataLoadPedestal (0),
	44	fDataAutoPedestal (0),
	45
	46	fUpdateSectors (0),
	47	fReloadSectors (0),
	48	fCreateSectors3D (0),
	49	fDeleteSectors3D (0)
e9a38ea3	50	{
e9a38ea3	51	MakeTitle("TPCLoader");
e9a38ea3	52
10b1edfc	53	Int_t labelW;
	54
	55	// File / event interface
	56
	57	labelW = 42;
e9a38ea3	58	{
	59	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	60	TGHorizontalFrame* g = new TGHorizontalFrame(f, labelW, 0, kFixedWidth);
	61	TGLabel* l = new TGLabel(g, "File: ");
	62	g->AddFrame(l, new TGLayoutHints(kLHintsLeft, 0,0,4,0));
	63	f->AddFrame(g);
	64	fFile = new TGTextEntry(f);
	65	fFile->SetWidth(140);
	66	f->AddFrame(fFile);
	67	fFile->Connect("DoubleClicked()",
	68	"Alieve::TPCLoaderEditor", this, "FileSelect()");
	69	fFile->Connect("TextChanged(const char *)",
	70	"Alieve::TPCLoaderEditor", this, "FileChanged()");
	71	fOpenFile = new TGTextButton(f, "Open");
	72	f->AddFrame(fOpenFile);
	73	fOpenFile->Connect("Clicked()",
	74	"Alieve::TPCLoaderEditor", this, "DoOpen()");
	75	AddFrame(f);
	76	}
	77
	78	fEvent = new RGValuator(this, "Event:", 110, 0);
	79	fEvent->SetShowSlider(kFALSE);
	80	fEvent->SetLabelWidth(labelW);
	81	fEvent->SetNELength(6);
	82	fEvent->Build();
	83	fEvent->SetLimits(0, 1000);
	84	fEvent->SetToolTip("Current event number");
	85	fEvent->Connect("ValueSet(Double_t)",
	86	"Alieve::TPCLoaderEditor", this, "DoEvent()");
6e91772d	87	// Reuse Event for DoubleSR button
	88	fDoubleSR = new TGCheckButton(fEvent, "Double SR");
	89	fDoubleSR->SetToolTipText("Double sampling rate");
10b1edfc	90	fEvent->AddFrame(fDoubleSR, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
b6b01ba3	91	fDoubleSR->Connect("Toggled(Bool_t)",
b6b01ba3	92	"Alieve::TPCLoaderEditor", this, "DoDoubleSR()");
e9a38ea3	93	AddFrame(fEvent);
e9a38ea3	94
10b1edfc	95
	96	// TPCData load settings
	97
	98	labelW = 90;
	99
	100	fDataLoadThreshold = new RGValuator(this, "Load threshold:", 110, 0);
	101	fDataLoadThreshold->SetShowSlider(kFALSE);
	102	fDataLoadThreshold->SetLabelWidth(labelW);
	103	fDataLoadThreshold->SetNELength(6);
	104	fDataLoadThreshold->Build();
	105	fDataLoadThreshold->SetLimits(0, 1000);
fe83f7ce	106	fDataLoadThreshold->SetToolTip("Minimum signal that will be stored (pedestal subtracted first).");
10b1edfc	107	fDataLoadThreshold->Connect
	108	("ValueSet(Double_t)",
	109	"Alieve::TPCLoaderEditor", this, "DoDataLoadThreshold()");
	110	AddFrame(fDataLoadThreshold, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
	111
	112	fDataLoadPedestal = new RGValuator(this, "Load pedestal:", 110, 0);
	113	fDataLoadPedestal->SetShowSlider(kFALSE);
	114	fDataLoadPedestal->SetLabelWidth(labelW);
	115	fDataLoadPedestal->SetNELength(6);
	116	fDataLoadPedestal->Build();
	117	fDataLoadPedestal->SetLimits(0, 1000);
	118	fDataLoadPedestal->SetToolTip("Pedestal that will be subtracted during data loading.");
	119	fDataLoadPedestal->Connect
	120	("ValueSet(Double_t)",
	121	"Alieve::TPCLoaderEditor", this, "DoDataLoadPedestal()");
	122	// Reuse DataLoadPedestal for DataAutoPedestal check button
	123	fDataAutoPedestal = new TGCheckButton(fDataLoadPedestal, "Automatic");
	124	fDataAutoPedestal->SetToolTipText("Determine per-pad pedestal during data loading.");
	125	fDataAutoPedestal->Connect
	126	("Toggled(Bool_t)",
	127	"Alieve::TPCLoaderEditor", this, "DoDataAutoPedestal()");
	128	fDataLoadPedestal->AddFrame(fDataAutoPedestal, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
	129	AddFrame(fDataLoadPedestal);
	130
	131	// Steering buttons: update/reload sectors; show/hide 3d
	132
	133	{
	134	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	135	fUpdateSectors = new TGTextButton(f, "Update Sectors");
	136	f->AddFrame(fUpdateSectors, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
	137	fUpdateSectors->Connect("Clicked()",
	138	"Alieve::TPCLoaderEditor", this, "DoUpdateSectors()");
	139	fReloadSectors = new TGTextButton(f, "Reload Sectors");
	140	f->AddFrame(fReloadSectors, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
	141	fReloadSectors->Connect("Clicked()",
	142	"Alieve::TPCLoaderEditor", this, "DoReloadSectors()");
	143	AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
	144	}
e9a38ea3	145	{
	146	TGHorizontalFrame* f = new TGHorizontalFrame(this);
	147	fCreateSectors3D = new TGTextButton(f, "Create 3D");
	148	f->AddFrame(fCreateSectors3D, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
	149	fCreateSectors3D->Connect("Clicked()",
10b1edfc	150	"Alieve::TPCLoaderEditor", this, "DoCreateSectors3D()");
e9a38ea3	151	fDeleteSectors3D = new TGTextButton(f, "Delete 3D");
	152	f->AddFrame(fDeleteSectors3D, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
	153	fDeleteSectors3D->Connect("Clicked()",
10b1edfc	154	"Alieve::TPCLoaderEditor", this, "DoDeleteSectors3D()");
e9a38ea3	155	AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
e9a38ea3	156	}
e9a38ea3	157	}
	158
	159	TPCLoaderEditor::~TPCLoaderEditor()
	160	{}
	161
	162	/**************************************************************************/
	163
a8600b56	164	void TPCLoaderEditor::SetModel(TObject* obj)
e9a38ea3	165	{
a8600b56	166	fM = dynamic_cast<TPCLoader*>(obj);
e9a38ea3	167
89ec258e	168	// !!!! order changed, need TGTextEntry::SetText NO BLOODY EMIT.
	169	fFile->SetToolTipText(gSystem->DirName(fM->fFile));
	170	fFile->SetText(gSystem->BaseName(fM->fFile));
e9a38ea3	171	fEvent->SetValue(fM->fEvent);
e9a38ea3	172	fEvent->SetEnabled(fM->fEvent >= 0);
10b1edfc	173	fDoubleSR->SetState(fM->fDoubleSR ? kButtonDown : kButtonUp);
	174
	175	TPCData* tpcd = fM->GetData();
	176	Bool_t tpcp = (tpcd != 0);
	177	fDataLoadThreshold->SetEnabled(tpcp);
	178	fDataLoadPedestal ->SetEnabled(tpcp && ! tpcd->GetAutoPedestal());
	179	fDataAutoPedestal ->SetEnabled(tpcp);
	180	if (tpcp) {
	181	fDataLoadThreshold->SetValue(tpcd->GetLoadThreshold());
	182	fDataLoadPedestal ->SetValue(tpcd->GetLoadPedestal());
	183	fDataAutoPedestal ->SetState(tpcd->GetAutoPedestal() ? kButtonDown : kButtonUp);
	184	}
e9a38ea3	185	}
	186
	187	/**************************************************************************/
	188	/**************************************************************************/
	189
	190	namespace {
	191	const char *tpcfiletypes[] = {
	192	"Root files", "*.root",
	193	"All files", ".",
	194	0, 0
	195	};
	196	}
	197
	198	void TPCLoaderEditor::FileSelect()
	199	{
	200	TGFileInfo fi;
fda47a05	201	fi.fIniDir = StrDup(gSystem->DirName (fM->fFile));
fda47a05	202	fi.fFilename = StrDup(gSystem->BaseName(fM->fFile));
e9a38ea3	203	fi.fFileTypes = tpcfiletypes;
89ec258e	204
32e219c2	205	new TGFileDialog(fClient->GetRoot(), gReve->GetMainWindow(), kFDOpen, &fi);
89ec258e	206	if (!fi.fFilename)
	207	return;
	208
	209	fFile->SetToolTipText(gSystem->DirName (fi.fFilename));
	210	fFile->SetText (gSystem->BaseName(fi.fFilename));
e9a38ea3	211	}
	212
	213	void TPCLoaderEditor::FileChanged()
	214	{
89ec258e	215	fM->fFile = Form("%s/%s", fFile->GetToolTip()->GetText()->Data(),
89ec258e	216	fFile->GetText());
e9a38ea3	217	}
	218
	219	void TPCLoaderEditor::DoOpen()
	220	{
	221	fM->OpenFile();
a8600b56	222	SetModel(fM);
e9a38ea3	223	}
	224
	225	/**************************************************************************/
	226
	227	void TPCLoaderEditor::DoEvent()
	228	{
	229	fM->GotoEvent((Int_t) fEvent->GetValue());
a8600b56	230	SetModel(fM);
e9a38ea3	231	}
e9a38ea3	232
6e91772d	233	void TPCLoaderEditor::DoDoubleSR()
	234	{
	235	fM->SetDoubleSR(fDoubleSR->IsOn());
	236	Update();
	237	}
	238
e9a38ea3	239	/**************************************************************************/
e9a38ea3	240
10b1edfc	241	void TPCLoaderEditor::DoDataLoadThreshold()
	242	{
	243	if (fM->GetData() == 0) return;
	244	fM->GetData()->SetLoadThreshold((Short_t) fDataLoadThreshold->GetValue());
	245	}
	246
	247	void TPCLoaderEditor::DoDataLoadPedestal()
	248	{
	249	if (fM->GetData() == 0) return;
	250	fM->GetData()->SetLoadPedestal((Short_t) fDataLoadPedestal->GetValue());
	251	}
	252
	253	void TPCLoaderEditor::DoDataAutoPedestal()
	254	{
	255	if (fM->GetData() == 0) return;
	256	fM->GetData()->SetAutoPedestal(fDataAutoPedestal->IsOn());
	257	fDataLoadPedestal->SetEnabled(!fDataAutoPedestal->IsOn());
	258	}
	259
	260	/**************************************************************************/
	261
e9a38ea3	262	void TPCLoaderEditor::DoUpdateSectors()
	263	{
	264	fM->UpdateSectors();
	265	}
	266
10b1edfc	267	void TPCLoaderEditor::DoReloadSectors()
	268	{
	269	fM->ReloadSectors();
	270	}
	271
e9a38ea3	272	void TPCLoaderEditor::DoCreateSectors3D()
	273	{
	274	fM->CreateSectors3D();
	275	}
	276
	277
	278	void TPCLoaderEditor::DoDeleteSectors3D()
	279	{
	280	fM->DeleteSectors3D();
	281	}
	282