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

// $Header$

#include "RGValuators.h"

#include <TGLabel.h>
#include <TGSlider.h>
#include <TGDoubleSlider.h>

using namespace Reve;

/**************************************************************************/
// RGValuatorBase
/**************************************************************************/

ClassImp(RGValuatorBase)

RGValuatorBase::RGValuatorBase(const TGWindow *p, const char* name,
			       UInt_t w, UInt_t h) :
  TGCompositeFrame(p, w, h),

  fLabelWidth (0),
  fAlignRight (kFALSE),
  fShowSlider (kTRUE),

  fNELength (5),
  fNEHeight (20),

  fLabel (0)
{
   SetName(name);
}

/**************************************************************************/
// RGValuator
/**************************************************************************/

ClassImp(RGValuator)

RGValuator::RGValuator(const TGWindow *p, const char* title,
		       UInt_t w, UInt_t h) :
  RGValuatorBase(p, title, w, h),

  fValue (0),
  fMin   (0),
  fMax   (0),

  fSliderNewLine (kFALSE),
  fSliderDivs    (-1),
  fEntry  (0),
  fSlider (0)
{}

void RGValuator::Build(Bool_t connect)
{
  TGCompositeFrame *hf1, *hfs;
  if(fShowSlider && fSliderNewLine) {
    SetLayoutManager(new TGVerticalLayout(this));
    hf1 = new TGHorizontalFrame(this);
    hf1->SetLayoutManager(new TGHorizontalLayout(hf1));
    AddFrame(hf1, new TGLayoutHints(kLHintsTop, 0,0,0,0));
    hfs = new TGHorizontalFrame(this);
    hfs->SetLayoutManager(new TGHorizontalLayout(hfs));
    AddFrame(hfs, new TGLayoutHints(kLHintsTop, 0,0,0,0));
  } else {
    hf1 = this;
    hfs = this;
    SetLayoutManager(new TGHorizontalLayout(this));
  }

  // label
  {
    TGLayoutHints *labh, *labfrh;
    if(fAlignRight) {
      labh   = new TGLayoutHints(kLHintsRight | kLHintsBottom, 4,0,0,0);
      labfrh = new TGLayoutHints(kLHintsRight);
    } else {
      labh   = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,4,0,0);
      labfrh = new TGLayoutHints(kLHintsLeft);
    }
    TGCompositeFrame *labfr = 
      new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight,
			    fLabelWidth != 0 ? kFixedSize : kFixedHeight);
    fLabel = new TGLabel(labfr, GetName());
    labfr->AddFrame(fLabel, labh);
    hf1->AddFrame(labfr, labfrh);
  }

  // number-entry
  TGLayoutHints*  elh =  new TGLayoutHints(kLHintsLeft, 0,0,0,0);
  fEntry = new TGNumberEntry(hf1, 0, fNELength);
  fEntry->SetHeight(fNEHeight);
  fEntry->GetNumberEntry()->SetToolTipText("Enter Slider Value");
  hf1->AddFrame(fEntry, elh);

  fEntry->Associate(this);  
  if (connect)
    fEntry->Connect("ValueSet(Long_t)",
		    "Reve::RGValuator", this, "EntryCallback()");
  
  // slider
  if(fShowSlider) {
    fSlider = new TGHSlider(hfs, GetWidth(), kSlider1 | kScaleBoth);
    hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsLeft|kLHintsTop, 1,1,0,0));
   
    fSlider->Associate(this);
    if (connect)
      fSlider->Connect("PositionChanged(Int_t)",
		       "Reve::RGValuator", this, "SliderCallback()");
  }
}

void RGValuator::SetLimits(Float_t min, Float_t max, Int_t npos,
			   TGNumberFormat::EStyle nef) 
{
  fMin = Float_t(min);
  fMax = Float_t(max);
  fEntry->SetFormat(nef);
  fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);

  if(fSlider) {
    fSliderDivs = npos - 1;
    fSlider->SetRange(0, fSliderDivs);
  }
}

void RGValuator::SetLimits(Int_t min, Int_t max) 
{
  fMin = Float_t(min);
  fMax = Float_t(max);
  fEntry->SetFormat(TGNumberFormat::kNESInteger);
  fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);

  if(fSlider) {
    fSliderDivs = max - min;
    fSlider->SetRange(0, fSliderDivs);
  }
}

Int_t RGValuator::CalcSliderPos(Float_t v)
{
  return (Int_t) TMath::Nint((v - fMin)*fSliderDivs/(fMax - fMin));
}

void RGValuator::EntryCallback()
{
  fValue = fEntry->GetNumber();
  if(fSlider) {
    fSlider->SetPosition(CalcSliderPos(fValue));
  }
  ValueSet(fValue);
}

void RGValuator::SliderCallback()
{
  fValue = fMin + fSlider->GetPosition()*(fMax-fMin)/fSliderDivs;
  fEntry->SetNumber(fValue);
  ValueSet(fValue);
}


void RGValuator::ValueSet(Double_t val)
{
  Emit("ValueSet(Double_t)", val);
}

void RGValuator::SetValue(Float_t val, Bool_t emit)
{
  fValue = val;
  fEntry->SetNumber(fValue);

  if(fSlider){
    fSlider->SetPosition(CalcSliderPos(fValue));
  }
  if(emit)
    ValueSet(val);
}

void RGValuator::SetToolTip(const Text_t* tip)
{
  fEntry->GetNumberEntry()->SetToolTipText(tip);
}

void RGValuator::SetEnabled(Bool_t state)
{
  fEntry->GetNumberEntry()->SetEnabled(state);
  fEntry->GetButtonUp()->SetEnabled(state);
  fEntry->GetButtonDown()->SetEnabled(state);
  if(fSlider) {
    if(state) fSlider->MapWindow();
    else      fSlider->UnmapWindow();
  }
}

/**************************************************************************/
// RGDoubleValuator
/**************************************************************************/

ClassImp(RGDoubleValuator)

RGDoubleValuator::RGDoubleValuator(const TGWindow *p, const char* title,
				   UInt_t w, UInt_t h) :
  RGValuatorBase(p, title, w, h),

  fMinEntry(0),
  fMaxEntry(0),
  fSlider(0)
{}

void RGDoubleValuator::Build(Bool_t connect)
{
  TGCompositeFrame *hf1, *hfs;
  if(fShowSlider) {
    SetLayoutManager(new TGVerticalLayout(this));
    hf1 = new TGHorizontalFrame(this);
    hf1->SetLayoutManager(new TGHorizontalLayout(hf1));
    AddFrame(hf1, new TGLayoutHints(kLHintsTop, 0,0,0,0));
    hfs = new TGHorizontalFrame(this);
    hfs->SetLayoutManager(new TGHorizontalLayout(hfs));
    AddFrame(hfs, new TGLayoutHints(kLHintsTop, 0,0,0,0));
  } else {
    hf1 = this;
    hfs = this;
    SetLayoutManager(new TGHorizontalLayout(this));
  }

  // label
  TGLayoutHints* lh;
  if(fAlignRight)
    lh = new TGLayoutHints(kLHintsRight | kLHintsBottom, 4,0,0,0);
  else
    lh = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,4,0,0);
  
  if(fLabelWidth > 0) {
    TGCompositeFrame *lf = new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight, kFixedSize);
    fLabel = new TGLabel(lf, GetName());
    lf->AddFrame(fLabel, lh); 
    // add label frame to top horizontal frame
    TGLayoutHints* lfh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
    hf1->AddFrame(lf, lfh);
  } else {
    fLabel = new TGLabel(hf1, GetName());
    hf1->AddFrame(fLabel, lh);  
  }

  // entries
  fMinEntry = new TGNumberEntry(this, 0, fNELength);
  fMinEntry->SetHeight(fNEHeight);
  fMinEntry->GetNumberEntry()->SetToolTipText("Enter Slider Min Value");
  hf1->AddFrame(fMinEntry, new TGLayoutHints(kLHintsLeft, 0,0,0,0));
  if (connect)
    fMinEntry->Connect("ValueSet(Long_t)",
		       "Reve::RGDoubleValuator", this, "MinEntryCallback()");
  fMinEntry->Associate(this);   
   
  fMaxEntry = new TGNumberEntry(this, 0, fNELength);
  fMaxEntry->SetHeight(fNEHeight);
  fMaxEntry->GetNumberEntry()->SetToolTipText("Enter Slider Max Value");
  hf1->AddFrame(fMaxEntry,  new TGLayoutHints(kLHintsLeft, 2,0,0,0));
  if (connect)
    fMaxEntry->Connect("ValueSet(Long_t)",
		       "Reve::RGDoubleValuator", this, "MaxEntryCallback()");
  fMaxEntry->Associate(this);   
  
  // slider
  if(fShowSlider) {
    fSlider = new TGDoubleHSlider(hfs, GetWidth(), kDoubleScaleBoth);
    hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsTop|kLHintsLeft, 0,0,1,0));
    fSlider->Associate(this);
    if (connect)
      fSlider->Connect("PositionChanged()",
		       "Reve::RGDoubleValuator", this, "SliderCallback()");
  }
}

void RGDoubleValuator::SetLimits(Int_t min, Int_t max) 
{
  fMinEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
  fMinEntry->SetFormat(TGNumberFormat::kNESInteger);
  fMaxEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
  fMaxEntry->SetFormat(TGNumberFormat::kNESInteger);

  if(fSlider) {
    fSlider->SetRange(min, max);
  }
}

void RGDoubleValuator::SetLimits(Float_t min, Float_t max,
				 TGNumberFormat::EStyle nef) 
{
  //  printf("RGDoubleValuator::SetLimits(Float_t min, Float_t max, Int_ \n");
  fMinEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
  fMinEntry->SetFormat(nef);
  fMaxEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
  fMaxEntry->SetFormat(nef);
  
  if(fSlider) fSlider->SetRange(min, max);
}

void RGDoubleValuator::MinEntryCallback()
{
  if(GetMin() > GetMax())
    fMaxEntry->SetNumber(GetMin());
  if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
  ValueSet();
}

void RGDoubleValuator::MaxEntryCallback()
{
  if(GetMax() < GetMin())
    fMinEntry->SetNumber(GetMax());
  if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
  ValueSet();
}

void RGDoubleValuator::SliderCallback()
{
  Float_t minp, maxp;
  fSlider->GetPosition(minp, maxp);
  //printf("RGDoubleValuator::SliderCallback %f %f\n", minp, maxp);
  fMinEntry->SetNumber(minp);
  fMaxEntry->SetNumber(maxp); 
  ValueSet();
}

void RGDoubleValuator::SetValues(Float_t min, Float_t max, Bool_t emit)
{
  fMinEntry->SetNumber(min);
  fMaxEntry->SetNumber(max);

  if(fSlider) fSlider->SetPosition(min, max);
  if(emit)    ValueSet();
}

void RGDoubleValuator::ValueSet()
{
  Emit("ValueSet()");
}


/**************************************************************************/
// RGTriVecValuator
/**************************************************************************/

RGTriVecValuator::RGTriVecValuator(const TGWindow *p, const char* name,
				   UInt_t w, UInt_t h) :
  TGCompositeFrame(p, w, h),

  fLabelWidth (0),
  fNELength   (5),
  fNEHeight   (20)
{
  SetName(name);
}

RGTriVecValuator::~RGTriVecValuator()
{}

void RGTriVecValuator::Build(Bool_t vertical, const char* lab0, const char* lab1, const char* lab2)
{
  if (vertical) SetLayoutManager(new TGVerticalLayout(this));
  else          SetLayoutManager(new TGHorizontalLayout(this));

  const char *labs[3] = { lab0, lab1, lab2 };
  TGLayoutHints* lh;
  for (Int_t i=0; i<3; ++i) {
    fVal[i] = new RGValuator(this, labs[i], 10, 0);
    fVal[i]->SetLabelWidth(fLabelWidth);
    fVal[i]->SetShowSlider(kFALSE);
    fVal[i]->SetNELength(fNELength);
    fVal[i]->SetNEHeight(fNEHeight);
    fVal[i]->Build();
    fVal[i]->Connect
      ("ValueSet(Double_t)", "Reve::RGTriVecValuator", this, "ValueSet()");
    if (vertical) lh = new TGLayoutHints(kLHintsTop,  1, 1, 1, 1);
    else          lh = new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 1, 1);
    AddFrame(fVal[i], lh);
  }
}

void RGTriVecValuator::ValueSet()
{
  Emit("ValueSet()");
}

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

void RGTriVecValuator::SetLimits(Int_t min, Int_t max)
{
  for (Int_t i=0; i<3; ++i)
    fVal[i]->SetLimits(min, max);
}

void RGTriVecValuator::SetLimits(Float_t min, Float_t max,
				 TGNumberFormat::EStyle nef)
{
  for (Int_t i=0; i<3; ++i)
    fVal[i]->SetLimits(min, max, 0, nef);
}
Commit	Line	Data
5987168b	1	// $Header$
	2
	3	#include "RGValuators.h"
	4
	5	#include <TGLabel.h>
	6	#include <TGSlider.h>
	7	#include <TGDoubleSlider.h>
	8
	9	using namespace Reve;
	10
	11	/**************************************************************************/
	12	// RGValuatorBase
	13	/**************************************************************************/
	14
	15	ClassImp(RGValuatorBase)
	16
	17	RGValuatorBase::RGValuatorBase(const TGWindow p, const char name,
	18	UInt_t w, UInt_t h) :
	19	TGCompositeFrame(p, w, h),
	20
	21	fLabelWidth (0),
	22	fAlignRight (kFALSE),
	23	fShowSlider (kTRUE),
	24
	25	fNELength (5),
	26	fNEHeight (20),
	27
	28	fLabel (0)
	29	{
	30	SetName(name);
	31	}
	32
	33	/**************************************************************************/
	34	// RGValuator
	35	/**************************************************************************/
	36
	37	ClassImp(RGValuator)
	38
	39	RGValuator::RGValuator(const TGWindow p, const char title,
	40	UInt_t w, UInt_t h) :
	41	RGValuatorBase(p, title, w, h),
	42
	43	fValue (0),
	44	fMin (0),
	45	fMax (0),
	46
	47	fSliderNewLine (kFALSE),
20d5c75e	48	fSliderDivs (-1),
5987168b	49	fEntry (0),
	50	fSlider (0)
	51	{}
	52
65b5c50a	53	void RGValuator::Build(Bool_t connect)
5987168b	54	{
	55	TGCompositeFrame hf1, hfs;
	56	if(fShowSlider && fSliderNewLine) {
	57	SetLayoutManager(new TGVerticalLayout(this));
	58	hf1 = new TGHorizontalFrame(this);
	59	hf1->SetLayoutManager(new TGHorizontalLayout(hf1));
	60	AddFrame(hf1, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	61	hfs = new TGHorizontalFrame(this);
	62	hfs->SetLayoutManager(new TGHorizontalLayout(hfs));
	63	AddFrame(hfs, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	64	} else {
	65	hf1 = this;
	66	hfs = this;
	67	SetLayoutManager(new TGHorizontalLayout(this));
	68	}
	69
	70	// label
20d5c75e	71	{
	72	TGLayoutHints labh, labfrh;
	73	if(fAlignRight) {
	74	labh = new TGLayoutHints(kLHintsRight \| kLHintsBottom, 4,0,0,0);
	75	labfrh = new TGLayoutHints(kLHintsRight);
	76	} else {
	77	labh = new TGLayoutHints(kLHintsLeft \| kLHintsBottom, 0,4,0,0);
	78	labfrh = new TGLayoutHints(kLHintsLeft);
	79	}
	80	TGCompositeFrame *labfr =
	81	new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight,
	82	fLabelWidth != 0 ? kFixedSize : kFixedHeight);
	83	fLabel = new TGLabel(labfr, GetName());
	84	labfr->AddFrame(fLabel, labh);
	85	hf1->AddFrame(labfr, labfrh);
5987168b	86	}
5987168b	87
65b5c50a	88	// number-entry
78cd2dc1	89	TGLayoutHints* elh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
5987168b	90	fEntry = new TGNumberEntry(hf1, 0, fNELength);
	91	fEntry->SetHeight(fNEHeight);
	92	fEntry->GetNumberEntry()->SetToolTipText("Enter Slider Value");
	93	hf1->AddFrame(fEntry, elh);
	94
65b5c50a	95	fEntry->Associate(this);
	96	if (connect)
	97	fEntry->Connect("ValueSet(Long_t)",
	98	"Reve::RGValuator", this, "EntryCallback()");
5987168b	99
5987168b	100	// slider
	101	if(fShowSlider) {
	102	fSlider = new TGHSlider(hfs, GetWidth(), kSlider1 \| kScaleBoth);
20d5c75e	103	hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsLeft\|kLHintsTop, 1,1,0,0));
5987168b	104
5987168b	105	fSlider->Associate(this);
65b5c50a	106	if (connect)
	107	fSlider->Connect("PositionChanged(Int_t)",
	108	"Reve::RGValuator", this, "SliderCallback()");
5987168b	109	}
	110	}
	111
20d5c75e	112	void RGValuator::SetLimits(Float_t min, Float_t max, Int_t npos,
5987168b	113	TGNumberFormat::EStyle nef)
	114	{
	115	fMin = Float_t(min);
	116	fMax = Float_t(max);
5987168b	117	fEntry->SetFormat(nef);
5987168b	118	fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
20d5c75e	119
	120	if(fSlider) {
	121	fSliderDivs = npos - 1;
	122	fSlider->SetRange(0, fSliderDivs);
	123	}
5987168b	124	}
	125
	126	void RGValuator::SetLimits(Int_t min, Int_t max)
	127	{
	128	fMin = Float_t(min);
	129	fMax = Float_t(max);
	130	fEntry->SetFormat(TGNumberFormat::kNESInteger);
	131	fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	132
20d5c75e	133	if(fSlider) {
	134	fSliderDivs = max - min;
	135	fSlider->SetRange(0, fSliderDivs);
5987168b	136	}
	137	}
	138
20d5c75e	139	Int_t RGValuator::CalcSliderPos(Float_t v)
	140	{
	141	return (Int_t) TMath::Nint((v - fMin)*fSliderDivs/(fMax - fMin));
	142	}
	143
5987168b	144	void RGValuator::EntryCallback()
	145	{
	146	fValue = fEntry->GetNumber();
	147	if(fSlider) {
20d5c75e	148	fSlider->SetPosition(CalcSliderPos(fValue));
5987168b	149	}
	150	ValueSet(fValue);
	151	}
	152
	153	void RGValuator::SliderCallback()
	154	{
20d5c75e	155	fValue = fMin + fSlider->GetPosition()*(fMax-fMin)/fSliderDivs;
5987168b	156	fEntry->SetNumber(fValue);
	157	ValueSet(fValue);
	158	}
	159
	160
	161	void RGValuator::ValueSet(Double_t val)
	162	{
	163	Emit("ValueSet(Double_t)", val);
	164	}
	165
	166	void RGValuator::SetValue(Float_t val, Bool_t emit)
	167	{
	168	fValue = val;
	169	fEntry->SetNumber(fValue);
	170
	171	if(fSlider){
20d5c75e	172	fSlider->SetPosition(CalcSliderPos(fValue));
5987168b	173	}
	174	if(emit)
	175	ValueSet(val);
	176	}
	177
	178	void RGValuator::SetToolTip(const Text_t* tip)
	179	{
	180	fEntry->GetNumberEntry()->SetToolTipText(tip);
	181	}
	182
78cd2dc1	183	void RGValuator::SetEnabled(Bool_t state)
	184	{
	185	fEntry->GetNumberEntry()->SetEnabled(state);
	186	fEntry->GetButtonUp()->SetEnabled(state);
	187	fEntry->GetButtonDown()->SetEnabled(state);
	188	if(fSlider) {
	189	if(state) fSlider->MapWindow();
	190	else fSlider->UnmapWindow();
	191	}
	192	}
	193
5987168b	194	/**************************************************************************/
	195	// RGDoubleValuator
	196	/**************************************************************************/
	197
	198	ClassImp(RGDoubleValuator)
	199
	200	RGDoubleValuator::RGDoubleValuator(const TGWindow p, const char title,
	201	UInt_t w, UInt_t h) :
	202	RGValuatorBase(p, title, w, h),
	203
	204	fMinEntry(0),
	205	fMaxEntry(0),
	206	fSlider(0)
	207	{}
	208
65b5c50a	209	void RGDoubleValuator::Build(Bool_t connect)
5987168b	210	{
	211	TGCompositeFrame hf1, hfs;
	212	if(fShowSlider) {
	213	SetLayoutManager(new TGVerticalLayout(this));
	214	hf1 = new TGHorizontalFrame(this);
	215	hf1->SetLayoutManager(new TGHorizontalLayout(hf1));
	216	AddFrame(hf1, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	217	hfs = new TGHorizontalFrame(this);
	218	hfs->SetLayoutManager(new TGHorizontalLayout(hfs));
	219	AddFrame(hfs, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	220	} else {
	221	hf1 = this;
	222	hfs = this;
	223	SetLayoutManager(new TGHorizontalLayout(this));
	224	}
	225
	226	// label
	227	TGLayoutHints* lh;
	228	if(fAlignRight)
3b7a1af7	229	lh = new TGLayoutHints(kLHintsRight \| kLHintsBottom, 4,0,0,0);
5987168b	230	else
3b7a1af7	231	lh = new TGLayoutHints(kLHintsLeft \| kLHintsBottom, 0,4,0,0);
5987168b	232
	233	if(fLabelWidth > 0) {
	234	TGCompositeFrame *lf = new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight, kFixedSize);
	235	fLabel = new TGLabel(lf, GetName());
	236	lf->AddFrame(fLabel, lh);
	237	// add label frame to top horizontal frame
	238	TGLayoutHints* lfh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
	239	hf1->AddFrame(lf, lfh);
	240	} else {
	241	fLabel = new TGLabel(hf1, GetName());
3b7a1af7	242	hf1->AddFrame(fLabel, lh);
5987168b	243	}
	244
	245	// entries
	246	fMinEntry = new TGNumberEntry(this, 0, fNELength);
	247	fMinEntry->SetHeight(fNEHeight);
	248	fMinEntry->GetNumberEntry()->SetToolTipText("Enter Slider Min Value");
78cd2dc1	249	hf1->AddFrame(fMinEntry, new TGLayoutHints(kLHintsLeft, 0,0,0,0));
65b5c50a	250	if (connect)
	251	fMinEntry->Connect("ValueSet(Long_t)",
	252	"Reve::RGDoubleValuator", this, "MinEntryCallback()");
5987168b	253	fMinEntry->Associate(this);
	254
	255	fMaxEntry = new TGNumberEntry(this, 0, fNELength);
	256	fMaxEntry->SetHeight(fNEHeight);
	257	fMaxEntry->GetNumberEntry()->SetToolTipText("Enter Slider Max Value");
	258	hf1->AddFrame(fMaxEntry, new TGLayoutHints(kLHintsLeft, 2,0,0,0));
65b5c50a	259	if (connect)
	260	fMaxEntry->Connect("ValueSet(Long_t)",
	261	"Reve::RGDoubleValuator", this, "MaxEntryCallback()");
5987168b	262	fMaxEntry->Associate(this);
	263
	264	// slider
	265	if(fShowSlider) {
	266	fSlider = new TGDoubleHSlider(hfs, GetWidth(), kDoubleScaleBoth);
	267	hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsTop\|kLHintsLeft, 0,0,1,0));
	268	fSlider->Associate(this);
65b5c50a	269	if (connect)
	270	fSlider->Connect("PositionChanged()",
	271	"Reve::RGDoubleValuator", this, "SliderCallback()");
5987168b	272	}
	273	}
	274
ae586c74	275	void RGDoubleValuator::SetLimits(Int_t min, Int_t max)
	276	{
	277	fMinEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	278	fMinEntry->SetFormat(TGNumberFormat::kNESInteger);
	279	fMaxEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	280	fMaxEntry->SetFormat(TGNumberFormat::kNESInteger);
	281
	282	if(fSlider) {
	283	fSlider->SetRange(min, max);
	284	}
	285	}
	286
5987168b	287	void RGDoubleValuator::SetLimits(Float_t min, Float_t max,
	288	TGNumberFormat::EStyle nef)
	289	{
	290	// printf("RGDoubleValuator::SetLimits(Float_t min, Float_t max, Int_ \n");
	291	fMinEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	292	fMinEntry->SetFormat(nef);
	293	fMaxEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	294	fMaxEntry->SetFormat(nef);
	295
	296	if(fSlider) fSlider->SetRange(min, max);
	297	}
	298
	299	void RGDoubleValuator::MinEntryCallback()
	300	{
	301	if(GetMin() > GetMax())
	302	fMaxEntry->SetNumber(GetMin());
	303	if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
	304	ValueSet();
	305	}
	306
	307	void RGDoubleValuator::MaxEntryCallback()
	308	{
	309	if(GetMax() < GetMin())
	310	fMinEntry->SetNumber(GetMax());
	311	if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
	312	ValueSet();
	313	}
	314
	315	void RGDoubleValuator::SliderCallback()
	316	{
	317	Float_t minp, maxp;
	318	fSlider->GetPosition(minp, maxp);
	319	//printf("RGDoubleValuator::SliderCallback %f %f\n", minp, maxp);
	320	fMinEntry->SetNumber(minp);
	321	fMaxEntry->SetNumber(maxp);
	322	ValueSet();
	323	}
	324
	325	void RGDoubleValuator::SetValues(Float_t min, Float_t max, Bool_t emit)
	326	{
	327	fMinEntry->SetNumber(min);
	328	fMaxEntry->SetNumber(max);
	329
	330	if(fSlider) fSlider->SetPosition(min, max);
	331	if(emit) ValueSet();
	332	}
	333
	334	void RGDoubleValuator::ValueSet()
	335	{
	336	Emit("ValueSet()");
	337	}
65b5c50a	338
	339
	340	/**************************************************************************/
	341	// RGTriVecValuator
	342	/**************************************************************************/
	343
	344	RGTriVecValuator::RGTriVecValuator(const TGWindow p, const char name,
	345	UInt_t w, UInt_t h) :
	346	TGCompositeFrame(p, w, h),
	347
	348	fLabelWidth (0),
	349	fNELength (5),
	350	fNEHeight (20)
	351	{
	352	SetName(name);
	353	}
	354
	355	RGTriVecValuator::~RGTriVecValuator()
	356	{}
	357
	358	void RGTriVecValuator::Build(Bool_t vertical, const char* lab0, const char* lab1, const char* lab2)
	359	{
	360	if (vertical) SetLayoutManager(new TGVerticalLayout(this));
	361	else SetLayoutManager(new TGHorizontalLayout(this));
	362
	363	const char *labs[3] = { lab0, lab1, lab2 };
	364	TGLayoutHints* lh;
	365	for (Int_t i=0; i<3; ++i) {
	366	fVal[i] = new RGValuator(this, labs[i], 10, 0);
	367	fVal[i]->SetLabelWidth(fLabelWidth);
	368	fVal[i]->SetShowSlider(kFALSE);
	369	fVal[i]->SetNELength(fNELength);
	370	fVal[i]->SetNEHeight(fNEHeight);
	371	fVal[i]->Build();
	372	fVal[i]->Connect
	373	("ValueSet(Double_t)", "Reve::RGTriVecValuator", this, "ValueSet()");
	374	if (vertical) lh = new TGLayoutHints(kLHintsTop, 1, 1, 1, 1);
	375	else lh = new TGLayoutHints(kLHintsLeft\|kLHintsExpandX, 1, 1, 1, 1);
	376	AddFrame(fVal[i], lh);
	377	}
	378	}
	379
	380	void RGTriVecValuator::ValueSet()
	381	{
	382	Emit("ValueSet()");
	383	}
	384
	385	/**************************************************************************/
	386
	387	void RGTriVecValuator::SetLimits(Int_t min, Int_t max)
	388	{
	389	for (Int_t i=0; i<3; ++i)
	390	fVal[i]->SetLimits(min, max);
	391	}
	392
	393	void RGTriVecValuator::SetLimits(Float_t min, Float_t max,
	394	TGNumberFormat::EStyle nef)
	395	{
	396	for (Int_t i=0; i<3; ++i)
	397	fVal[i]->SetLimits(min, max, 0, nef);
	398	}
	399
	400