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

// $Header$

#ifndef REVE_RGValuators_H
#define REVE_RGValuators_H

#include <TGNumberEntry.h>

class TGLabel;
class TGHSlider;
class TGDoubleHSlider;


namespace Reve {

class RGValuatorBase: public TGCompositeFrame
{
protected:
  UInt_t      fLabelWidth;
  Bool_t      fAlignRight;
  Bool_t      fShowSlider;

  Int_t       fNELength;
  Int_t       fNEHeight;

  TGLabel*    fLabel;

public:
  RGValuatorBase(const TGWindow *p, const char* title, UInt_t w, UInt_t h);
  virtual ~RGValuatorBase() {}

  virtual void Build() = 0;

  void SetLabelWidth(Int_t w)        { fLabelWidth = w; }
  void SetAlignRight(Bool_t a)       { fAlignRight = a; }
  void SetShowSlider(Bool_t s=kTRUE) { fShowSlider = s; }

  void SetNELength(Int_t l)          { fNELength = l; }
  void SetNEGeight(Int_t h)          { fNEHeight = h; }

  ClassDef(RGValuatorBase, 0);
}; // endclass RGValuatorBase

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

class RGValuator: public RGValuatorBase
{
protected:
  Float_t        fValue;
  Float_t        fMin;
  Float_t        fMax;

  Bool_t         fSliderNewLine;
  Int_t          fSliderDivs;
  TGNumberEntry* fEntry;
  TGHSlider*     fSlider;

  Int_t CalcSliderPos(Float_t v);
  
public:
  RGValuator(const TGWindow *p, const char* title, UInt_t w, UInt_t h);
  virtual ~RGValuator() {}

  virtual void Build();
  
  Float_t GetValue() const { return fValue; }
  virtual void SetValue(Float_t v, Bool_t emit=kFALSE);

  void SliderCallback();
  void EntryCallback();
  void ValueSet(Double_t); //*SIGNAL* 

  TGHSlider*     GetSlider() { return fSlider; }
  TGNumberEntry* GetEntry()  { return fEntry; }

  void SetSliderNewLine(Bool_t nl) { fSliderNewLine = nl; }

  void SetLimits(Int_t min, Int_t max);
  void SetLimits(Float_t min, Float_t max, Int_t npos,
		 TGNumberFormat::EStyle nef=TGNumberFormat::kNESRealTwo);

  void SetToolTip(const Text_t* tip);
  void SetEnabled(Bool_t state);

  ClassDef(RGValuator, 0);
}; // endclass RGValuator

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

class RGDoubleValuator: public RGValuatorBase
{
protected:
  TGNumberEntry*    fMinEntry;
  TGNumberEntry*    fMaxEntry;
  TGDoubleHSlider*  fSlider;
  
public:
  RGDoubleValuator(const TGWindow *p, const char* title, UInt_t w, UInt_t h);
  virtual ~RGDoubleValuator() {}

  virtual void Build();
 
  void MinEntryCallback();
  void MaxEntryCallback();
  void SliderCallback();
  void ValueSet(); //*SIGNAL* 

  TGDoubleHSlider* GetSlider()   { return fSlider; }
  TGNumberEntry*   GetMinEntry() { return fMinEntry; }
  TGNumberEntry*   GetMaxEntry() { return fMaxEntry; }

  void SetLimits(Float_t min, Float_t max, TGNumberFormat::EStyle nef=TGNumberFormat::kNESRealTwo);
  void SetValues(Float_t min, Float_t max, Bool_t emit=kFALSE);

  void GetValues(Float_t& min, Float_t& max) const
  { min = fMinEntry->GetNumber(); max = fMaxEntry->GetNumber(); }
  Float_t GetMin() const { return fMinEntry->GetNumber(); }
  Float_t GetMax() const { return fMaxEntry->GetNumber(); }

  ClassDef(RGDoubleValuator, 0);
}; // endclass RGDoubleValuator

}

#endif
Commit	Line	Data
5987168b	1	// $Header$
	2
	3	#ifndef REVE_RGValuators_H
	4	#define REVE_RGValuators_H
	5
	6	#include <TGNumberEntry.h>
	7
	8	class TGLabel;
	9	class TGHSlider;
	10	class TGDoubleHSlider;
	11
	12
	13	namespace Reve {
	14
	15	class RGValuatorBase: public TGCompositeFrame
	16	{
	17	protected:
	18	UInt_t fLabelWidth;
	19	Bool_t fAlignRight;
	20	Bool_t fShowSlider;
	21
	22	Int_t fNELength;
	23	Int_t fNEHeight;
	24
	25	TGLabel* fLabel;
	26
	27	public:
	28	RGValuatorBase(const TGWindow p, const char title, UInt_t w, UInt_t h);
	29	virtual ~RGValuatorBase() {}
	30
	31	virtual void Build() = 0;
	32
	33	void SetLabelWidth(Int_t w) { fLabelWidth = w; }
	34	void SetAlignRight(Bool_t a) { fAlignRight = a; }
	35	void SetShowSlider(Bool_t s=kTRUE) { fShowSlider = s; }
	36
	37	void SetNELength(Int_t l) { fNELength = l; }
	38	void SetNEGeight(Int_t h) { fNEHeight = h; }
	39
	40	ClassDef(RGValuatorBase, 0);
	41	}; // endclass RGValuatorBase
	42
	43	/**************************************************************************/
	44
	45	class RGValuator: public RGValuatorBase
	46	{
	47	protected:
	48	Float_t fValue;
	49	Float_t fMin;
	50	Float_t fMax;
	51
	52	Bool_t fSliderNewLine;
20d5c75e	53	Int_t fSliderDivs;
5987168b	54	TGNumberEntry* fEntry;
5987168b	55	TGHSlider* fSlider;
20d5c75e	56
20d5c75e	57	Int_t CalcSliderPos(Float_t v);
5987168b	58
	59	public:
	60	RGValuator(const TGWindow p, const char title, UInt_t w, UInt_t h);
	61	virtual ~RGValuator() {}
	62
	63	virtual void Build();
	64
	65	Float_t GetValue() const { return fValue; }
	66	virtual void SetValue(Float_t v, Bool_t emit=kFALSE);
	67
	68	void SliderCallback();
	69	void EntryCallback();
	70	void ValueSet(Double_t); //SIGNAL
	71
	72	TGHSlider* GetSlider() { return fSlider; }
	73	TGNumberEntry* GetEntry() { return fEntry; }
	74
	75	void SetSliderNewLine(Bool_t nl) { fSliderNewLine = nl; }
	76
	77	void SetLimits(Int_t min, Int_t max);
20d5c75e	78	void SetLimits(Float_t min, Float_t max, Int_t npos,
5987168b	79	TGNumberFormat::EStyle nef=TGNumberFormat::kNESRealTwo);
	80
	81	void SetToolTip(const Text_t* tip);
78cd2dc1	82	void SetEnabled(Bool_t state);
5987168b	83
	84	ClassDef(RGValuator, 0);
	85	}; // endclass RGValuator
	86
	87	/**************************************************************************/
	88
	89	class RGDoubleValuator: public RGValuatorBase
	90	{
	91	protected:
	92	TGNumberEntry* fMinEntry;
	93	TGNumberEntry* fMaxEntry;
	94	TGDoubleHSlider* fSlider;
	95
	96	public:
	97	RGDoubleValuator(const TGWindow p, const char title, UInt_t w, UInt_t h);
	98	virtual ~RGDoubleValuator() {}
	99
	100	virtual void Build();
	101
	102	void MinEntryCallback();
	103	void MaxEntryCallback();
	104	void SliderCallback();
	105	void ValueSet(); //SIGNAL
	106
	107	TGDoubleHSlider* GetSlider() { return fSlider; }
	108	TGNumberEntry* GetMinEntry() { return fMinEntry; }
	109	TGNumberEntry* GetMaxEntry() { return fMaxEntry; }
	110
	111	void SetLimits(Float_t min, Float_t max, TGNumberFormat::EStyle nef=TGNumberFormat::kNESRealTwo);
	112	void SetValues(Float_t min, Float_t max, Bool_t emit=kFALSE);
	113
	114	void GetValues(Float_t& min, Float_t& max) const
	115	{ min = fMinEntry->GetNumber(); max = fMaxEntry->GetNumber(); }
	116	Float_t GetMin() const { return fMinEntry->GetNumber(); }
	117	Float_t GetMax() const { return fMaxEntry->GetNumber(); }
	118
	119	ClassDef(RGDoubleValuator, 0);
	120	}; // endclass RGDoubleValuator
	121
	122	}
	123
	124	#endif