EVE/Reve/RGValuators.cxx

   1 // $Header$
   2
   3 #include "RGValuators.h"
   4
   5 #include <TMath.h>
   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),
  49   fSliderDivs    (-1),
  50   fEntry  (0),
  51   fSlider (0)
  52 {}
  53
  54 void RGValuator::Build(Bool_t connect)
  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
  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, fName);
  85     labfr->AddFrame(fLabel, labh);
  86     hf1->AddFrame(labfr, labfrh);
  87   }
  88
  89   // number-entry
  90   TGLayoutHints*  elh =  new TGLayoutHints(kLHintsLeft, 0,0,0,0);
  91   fEntry = new TGNumberEntry(hf1, 0, fNELength);
  92   fEntry->SetHeight(fNEHeight);
  93   fEntry->GetNumberEntry()->SetToolTipText("Enter Slider Value");
  94   hf1->AddFrame(fEntry, elh);
  95
  96   fEntry->Associate(this);
  97   if (connect)
  98     fEntry->Connect("ValueSet(Long_t)",
  99                     "Reve::RGValuator", this, "EntryCallback()");
 100
 101   // slider
 102   if(fShowSlider) {
 103     fSlider = new TGHSlider(hfs, GetWidth(), kSlider1 | kScaleBoth);
 104     hfs->AddFrame(fSlider, new TGLayoutHints(kLHintsLeft|kLHintsTop, 1,1,0,0));
 105
 106     fSlider->Associate(this);
 107     if (connect)
 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 npos,
 114                            TGNumberFormat::EStyle nef)
 115 {
 116   fMin = Float_t(min);
 117   fMax = Float_t(max);
 118   fEntry->SetFormat(nef);
 119   fEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, min, max);
 120
 121   if(fSlider) {
 122     fSliderDivs = npos - 1;
 123     fSlider->SetRange(0, fSliderDivs);
 124   }
 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
 134   if(fSlider) {
 135     fSliderDivs = max - min;
 136     fSlider->SetRange(0, fSliderDivs);
 137   }
 138 }
 139
 140 Int_t RGValuator::CalcSliderPos(Float_t v)
 141 {
 142   return (Int_t) TMath::Nint((v - fMin)*fSliderDivs/(fMax - fMin));
 143 }
 144
 145 void RGValuator::EntryCallback()
 146 {
 147   fValue = fEntry->GetNumber();
 148   if(fSlider) {
 149     fSlider->SetPosition(CalcSliderPos(fValue));
 150   }
 151   ValueSet(fValue);
 152 }
 153
 154 void RGValuator::SliderCallback()
 155 {
 156   fValue = fMin + fSlider->GetPosition()*(fMax-fMin)/fSliderDivs;
 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){
 173     fSlider->SetPosition(CalcSliderPos(fValue));
 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
 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
 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
 210 void RGDoubleValuator::Build(Bool_t connect)
 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)
 230     lh = new TGLayoutHints(kLHintsRight | kLHintsBottom, 4,0,0,0);
 231   else
 232     lh = new TGLayoutHints(kLHintsLeft  | kLHintsBottom, 0,4,0,0);
 233
 234   if(fLabelWidth > 0) {
 235     TGCompositeFrame *lf = new TGHorizontalFrame(hf1, fLabelWidth, fNEHeight, kFixedSize);
 236     fLabel = new TGLabel(lf, fName);
 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, fName);
 243     hf1->AddFrame(fLabel, lh);
 244   }
 245
 246   // entries
 247   fMinEntry = new TGNumberEntry(hf1, 0, fNELength);
 248   fMinEntry->SetHeight(fNEHeight);
 249   fMinEntry->GetNumberEntry()->SetToolTipText("Enter Slider Min Value");
 250   hf1->AddFrame(fMinEntry, new TGLayoutHints(kLHintsLeft, 0,0,0,0));
 251   if (connect)
 252     fMinEntry->Connect("ValueSet(Long_t)",
 253                        "Reve::RGDoubleValuator", this, "MinEntryCallback()");
 254   fMinEntry->Associate(this);
 255
 256   fMaxEntry = new TGNumberEntry(hf1, 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));
 260   if (connect)
 261     fMaxEntry->Connect("ValueSet(Long_t)",
 262                        "Reve::RGDoubleValuator", this, "MaxEntryCallback()");
 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);
 270     if (connect)
 271       fSlider->Connect("PositionChanged()",
 272                        "Reve::RGDoubleValuator", this, "SliderCallback()");
 273   }
 274 }
 275
 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
 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 }
 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