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

// $Header$

#include "RGValuators.h"

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