Removed the AliHLTPHOSValidCellDataStruct.h from Makefile.am
[u/mrichter/AliRoot.git] / EVE / Reve / RGValuators.cxx
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   fSliderDivs    (-1),
49   fEntry  (0),
50   fSlider (0)
51 {}
52
53 void RGValuator::Build(Bool_t connect)
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   {
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);
86   }
87
88   // number-entry
89   TGLayoutHints*  elh =  new TGLayoutHints(kLHintsLeft, 0,0,0,0);
90   fEntry = new TGNumberEntry(hf1, 0, fNELength);
91   fEntry->SetHeight(fNEHeight);
92   fEntry->GetNumberEntry()->SetToolTipText("Enter Slider Value");
93   hf1->AddFrame(fEntry, elh);
94
95   fEntry->Associate(this);  
96   if (connect)
97     fEntry->Connect("ValueSet(Long_t)",
98                     "Reve::RGValuator", this, "EntryCallback()");
99   
100   // slider
101   if(fShowSlider) {
102     fSlider = new TGHSlider(hfs, GetWidth(), kSlider1 | kScaleBoth);
103     hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsLeft|kLHintsTop, 1,1,0,0));
104    
105     fSlider->Associate(this);
106     if (connect)
107       fSlider->Connect("PositionChanged(Int_t)",
108                        "Reve::RGValuator", this, "SliderCallback()");
109   }
110 }
111
112 void RGValuator::SetLimits(Float_t min, Float_t max, Int_t npos,
113                            TGNumberFormat::EStyle nef) 
114 {
115   fMin = Float_t(min);
116   fMax = Float_t(max);
117   fEntry->SetFormat(nef);
118   fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
119
120   if(fSlider) {
121     fSliderDivs = npos - 1;
122     fSlider->SetRange(0, fSliderDivs);
123   }
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
133   if(fSlider) {
134     fSliderDivs = max - min;
135     fSlider->SetRange(0, fSliderDivs);
136   }
137 }
138
139 Int_t RGValuator::CalcSliderPos(Float_t v)
140 {
141   return (Int_t) TMath::Nint((v - fMin)*fSliderDivs/(fMax - fMin));
142 }
143
144 void RGValuator::EntryCallback()
145 {
146   fValue = fEntry->GetNumber();
147   if(fSlider) {
148     fSlider->SetPosition(CalcSliderPos(fValue));
149   }
150   ValueSet(fValue);
151 }
152
153 void RGValuator::SliderCallback()
154 {
155   fValue = fMin + fSlider->GetPosition()*(fMax-fMin)/fSliderDivs;
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){
172     fSlider->SetPosition(CalcSliderPos(fValue));
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
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
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
209 void RGDoubleValuator::Build(Bool_t connect)
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)
229     lh = new TGLayoutHints(kLHintsRight | kLHintsBottom, 4,0,0,0);
230   else
231     lh = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,4,0,0);
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());
242     hf1->AddFrame(fLabel, lh);  
243   }
244
245   // entries
246   fMinEntry = new TGNumberEntry(this, 0, fNELength);
247   fMinEntry->SetHeight(fNEHeight);
248   fMinEntry->GetNumberEntry()->SetToolTipText("Enter Slider Min Value");
249   hf1->AddFrame(fMinEntry, new TGLayoutHints(kLHintsLeft, 0,0,0,0));
250   if (connect)
251     fMinEntry->Connect("ValueSet(Long_t)",
252                        "Reve::RGDoubleValuator", this, "MinEntryCallback()");
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));
259   if (connect)
260     fMaxEntry->Connect("ValueSet(Long_t)",
261                        "Reve::RGDoubleValuator", this, "MaxEntryCallback()");
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);
269     if (connect)
270       fSlider->Connect("PositionChanged()",
271                        "Reve::RGDoubleValuator", this, "SliderCallback()");
272   }
273 }
274
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
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 }
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