[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),
  fSliderSteps   (-1),
  fEntry  (0),
  fSlider (0)
{}

void RGValuator::Build()
{
  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* lh;
  if(fAlignRight)
    lh = new TGLayoutHints(kLHintsRight | kLHintsBottom, 0,0,0,0);
  else
    lh = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,0,0,0);
  
  if (fLabelWidth > 0) {
    // printf("fLabelWidth > 0 \n");
    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);  
  }

  // 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);   
  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, 1,1,0,0));
   
    fSlider->Associate(this);
    fSlider->Connect("PositionChanged(Int_t)",
		     "Reve::RGValuator", this, "SliderCallback()");
  }
}

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

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){
    fSlider->SetRange(min, max);
    fSliderSteps = max - min;
  }
}

void RGValuator::EntryCallback()
{
  fValue = fEntry->GetNumber();
  if(fSlider) {
    Int_t pos;
    if (fSliderSteps != -1) {
      pos = Int_t( fSliderSteps*(fValue - fMin)/(fMax - fMin));
    } else {
      pos = Int_t(fValue - fMin);
    }
    pos += Int_t(fMin);
    fSlider->SetPosition(pos);
    // printf( "RGValuator::EntryCallback() slider pos %d n", pos);
  }
  ValueSet(fValue);
}

void RGValuator::SliderCallback()
{
  Double_t val;
  if(fSliderSteps != -1)
    val = fMin + fSlider->GetPosition()*Double_t((fMax-fMin))/fSliderSteps;
  else 
    val = Double_t(fSlider->GetPosition());
  
  fValue = val;
  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(Int_t((val-fMin)*fSliderSteps/(fMax-fMin)));
    // printf("RGValuator::ValueSet slider pos %d\n",fSlider->GetPosition() );
  }
  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()
{
  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, 0,2,0,0);
  else
    lh = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,2,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);  
  }

  // 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));
  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));
  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);
    fSlider->Connect("PositionChanged()",
		     "Reve::RGDoubleValuator", this, "SliderCallback()");
  }
}

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()");
}
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),
	48	fSliderSteps (-1),
	49	fEntry (0),
	50	fSlider (0)
	51	{}
	52
	53	void RGValuator::Build()
	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
71	TGLayoutHints* lh;
72	if(fAlignRight)
73	lh = new TGLayoutHints(kLHintsRight \| kLHintsBottom, 0,0,0,0);
74	else
75	lh = new TGLayoutHints(kLHintsLeft \| kLHintsBottom, 0,0,0,0);
76
77	if (fLabelWidth > 0) {
78	// printf("fLabelWidth > 0 \n");
79	TGCompositeFrame *lf = new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight, kFixedSize);
80	fLabel = new TGLabel(lf, GetName());
81	lf->AddFrame(fLabel, lh);
82	// add label frame to top horizontal frame
83	TGLayoutHints* lfh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
84	hf1->AddFrame(lf, lfh);
85	} else {
86	fLabel = new TGLabel(hf1, GetName());
87	hf1->AddFrame(fLabel, lh);
88	}
89
90	// entry
78cd2dc1	91	TGLayoutHints* elh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
5987168b	92	fEntry = new TGNumberEntry(hf1, 0, fNELength);
	93	fEntry->SetHeight(fNEHeight);
	94	fEntry->GetNumberEntry()->SetToolTipText("Enter Slider Value");
	95	hf1->AddFrame(fEntry, elh);
	96
	97	fEntry->Associate(this);
	98	fEntry->Connect("ValueSet(Long_t)",
	99	"Reve::RGValuator", this, "EntryCallback()");
	100
	101
	102	// slider
	103	if(fShowSlider) {
	104	fSlider = new TGHSlider(hfs, GetWidth(), kSlider1 \| kScaleBoth);
	105	hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsLeft, 1,1,0,0));
	106
	107	fSlider->Associate(this);
	108	fSlider->Connect("PositionChanged(Int_t)",
	109	"Reve::RGValuator", this, "SliderCallback()");
	110	}
	111	}
	112
	113	void RGValuator::SetLimits(Float_t min, Float_t max, Int_t ndiv,
	114	TGNumberFormat::EStyle nef)
	115	{
	116	fMin = Float_t(min);
	117	fMax = Float_t(max);
	118	fSliderSteps = ndiv;
	119	fEntry->SetFormat(nef);
	120	fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	121	}
	122
	123	void RGValuator::SetLimits(Int_t min, Int_t max)
	124	{
	125	fMin = Float_t(min);
	126	fMax = Float_t(max);
	127	fEntry->SetFormat(TGNumberFormat::kNESInteger);
	128	fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	129
	130	if(fSlider){
	131	fSlider->SetRange(min, max);
	132	fSliderSteps = max - min;
	133	}
	134	}
	135
	136	void RGValuator::EntryCallback()
	137	{
	138	fValue = fEntry->GetNumber();
	139	if(fSlider) {
	140	Int_t pos;
	141	if (fSliderSteps != -1) {
	142	pos = Int_t( fSliderSteps*(fValue - fMin)/(fMax - fMin));
	143	} else {
	144	pos = Int_t(fValue - fMin);
	145	}
	146	pos += Int_t(fMin);
	147	fSlider->SetPosition(pos);
	148	// printf( "RGValuator::EntryCallback() slider pos %d n", pos);
	149	}
	150	ValueSet(fValue);
	151	}
	152
	153	void RGValuator::SliderCallback()
	154	{
	155	Double_t val;
156	if(fSliderSteps != -1)
157	val = fMin + fSlider->GetPosition()*Double_t((fMax-fMin))/fSliderSteps;
158	else
159	val = Double_t(fSlider->GetPosition());
160
161	fValue = val;
162	fEntry->SetNumber(fValue);
163	ValueSet(fValue);
164	}
165
166
167	void RGValuator::ValueSet(Double_t val)
168	{
169	Emit("ValueSet(Double_t)", val);
170	}
171
172	void RGValuator::SetValue(Float_t val, Bool_t emit)
173	{
174	fValue = val;
175	fEntry->SetNumber(fValue);
176
177	if(fSlider){
178	fSlider->SetPosition(Int_t((val-fMin)*fSliderSteps/(fMax-fMin)));
179	// printf("RGValuator::ValueSet slider pos %d\n",fSlider->GetPosition() );
180	}
181	if(emit)
182	ValueSet(val);
183	}
184
185	void RGValuator::SetToolTip(const Text_t* tip)
186	{
187	fEntry->GetNumberEntry()->SetToolTipText(tip);
188	}
189
78cd2dc1	190	void RGValuator::SetEnabled(Bool_t state)
	191	{
	192	fEntry->GetNumberEntry()->SetEnabled(state);
	193	fEntry->GetButtonUp()->SetEnabled(state);
	194	fEntry->GetButtonDown()->SetEnabled(state);
	195	if(fSlider) {
	196	if(state) fSlider->MapWindow();
	197	else fSlider->UnmapWindow();
	198	}
	199	}
	200
5987168b	201	/**************************************************************************/
	202	// RGDoubleValuator
	203	/**************************************************************************/
	204
	205	ClassImp(RGDoubleValuator)
	206
	207	RGDoubleValuator::RGDoubleValuator(const TGWindow p, const char title,
	208	UInt_t w, UInt_t h) :
	209	RGValuatorBase(p, title, w, h),
	210
	211	fMinEntry(0),
	212	fMaxEntry(0),
	213	fSlider(0)
	214	{}
	215
	216	void RGDoubleValuator::Build()
	217	{
	218	TGCompositeFrame hf1, hfs;
	219	if(fShowSlider) {
	220	SetLayoutManager(new TGVerticalLayout(this));
	221	hf1 = new TGHorizontalFrame(this);
	222	hf1->SetLayoutManager(new TGHorizontalLayout(hf1));
	223	AddFrame(hf1, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	224	hfs = new TGHorizontalFrame(this);
	225	hfs->SetLayoutManager(new TGHorizontalLayout(hfs));
	226	AddFrame(hfs, new TGLayoutHints(kLHintsTop, 0,0,0,0));
	227	} else {
	228	hf1 = this;
	229	hfs = this;
	230	SetLayoutManager(new TGHorizontalLayout(this));
	231	}
	232
	233	// label
	234	TGLayoutHints* lh;
	235	if(fAlignRight)
	236	lh = new TGLayoutHints(kLHintsRight \| kLHintsBottom, 0,2,0,0);
	237	else
	238	lh = new TGLayoutHints(kLHintsLeft \| kLHintsBottom, 0,2,0,0);
	239
	240	if(fLabelWidth > 0) {
	241	TGCompositeFrame *lf = new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight, kFixedSize);
	242	fLabel = new TGLabel(lf, GetName());
	243	lf->AddFrame(fLabel, lh);
	244	// add label frame to top horizontal frame
	245	TGLayoutHints* lfh = new TGLayoutHints(kLHintsLeft, 0,0,0,0);
	246	hf1->AddFrame(lf, lfh);
	247	} else {
	248	fLabel = new TGLabel(hf1, GetName());
	249	hf1->AddFrame(fLabel);
	250	}
	251
	252	// entries
	253	fMinEntry = new TGNumberEntry(this, 0, fNELength);
	254	fMinEntry->SetHeight(fNEHeight);
	255	fMinEntry->GetNumberEntry()->SetToolTipText("Enter Slider Min Value");
78cd2dc1	256	hf1->AddFrame(fMinEntry, new TGLayoutHints(kLHintsLeft, 0,0,0,0));
5987168b	257	fMinEntry->Connect("ValueSet(Long_t)",
	258	"Reve::RGDoubleValuator", this, "MinEntryCallback()");
	259	fMinEntry->Associate(this);
	260
	261	fMaxEntry = new TGNumberEntry(this, 0, fNELength);
	262	fMaxEntry->SetHeight(fNEHeight);
	263	fMaxEntry->GetNumberEntry()->SetToolTipText("Enter Slider Max Value");
	264	hf1->AddFrame(fMaxEntry, new TGLayoutHints(kLHintsLeft, 2,0,0,0));
	265	fMaxEntry->Connect("ValueSet(Long_t)",
	266	"Reve::RGDoubleValuator", this, "MaxEntryCallback()");
	267	fMaxEntry->Associate(this);
	268
	269	// slider
	270	if(fShowSlider) {
	271	fSlider = new TGDoubleHSlider(hfs, GetWidth(), kDoubleScaleBoth);
	272	hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsTop\|kLHintsLeft, 0,0,1,0));
	273	fSlider->Associate(this);
	274	fSlider->Connect("PositionChanged()",
	275	"Reve::RGDoubleValuator", this, "SliderCallback()");
	276	}
	277	}
	278
	279	void RGDoubleValuator::SetLimits(Float_t min, Float_t max,
	280	TGNumberFormat::EStyle nef)
	281	{
	282	// printf("RGDoubleValuator::SetLimits(Float_t min, Float_t max, Int_ \n");
	283	fMinEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	284	fMinEntry->SetFormat(nef);
	285	fMaxEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
	286	fMaxEntry->SetFormat(nef);
	287
	288	if(fSlider) fSlider->SetRange(min, max);
	289	}
	290
	291	void RGDoubleValuator::MinEntryCallback()
	292	{
	293	if(GetMin() > GetMax())
	294	fMaxEntry->SetNumber(GetMin());
	295	if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
	296	ValueSet();
	297	}
	298
	299	void RGDoubleValuator::MaxEntryCallback()
	300	{
	301	if(GetMax() < GetMin())
	302	fMinEntry->SetNumber(GetMax());
	303	if(fSlider) fSlider->SetPosition(GetMin(), GetMax());
	304	ValueSet();
	305	}
	306
	307	void RGDoubleValuator::SliderCallback()
	308	{
	309	Float_t minp, maxp;
	310	fSlider->GetPosition(minp, maxp);
	311	//printf("RGDoubleValuator::SliderCallback %f %f\n", minp, maxp);
	312	fMinEntry->SetNumber(minp);
	313	fMaxEntry->SetNumber(maxp);
	314	ValueSet();
	315	}
	316
	317	void RGDoubleValuator::SetValues(Float_t min, Float_t max, Bool_t emit)
	318	{
	319	fMinEntry->SetNumber(min);
	320	fMaxEntry->SetNumber(max);
321
322	if(fSlider) fSlider->SetPosition(min, max);
323	if(emit) ValueSet();
324	}
325
326	void RGDoubleValuator::ValueSet()
327	{
328	Emit("ValueSet()");
329	}