Logo ROOT  
Reference Guide
TGNumberEntry.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Daniel Sigg 03/09/2001
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 
13 /** \class TGNumberEntry
14  \ingroup guiwidgets
15 
16 TGNumberEntry is a number entry input widget with up/down buttons.
17 TGNumberEntryField is a number entry input widget.
18 TGNumberFormat contains enum types to specify the numeric format.
19 
20 The number entry widget is based on TGTextEntry but allows only
21 numerical input. The widget support numerous formats including
22 integers, hex numbers, real numbers, fixed fraction reals and
23 time/date formats. The widget also allows to restrict input values
24 to non-negative or positive numbers and to specify explicit limits.
25 
26 The following styles are supported:
27  - kNESInteger: integer number
28  - kNESRealOne: real number with one digit (no exponent)
29  - kNESRealTwo: real number with two digits (no exponent)
30  - kNESRealThree: real number with three digits (no exponent)
31  - kNESRealFour: real number with four digits (no exponent)
32  - kNESReal: arbitrary real number
33  - kNESDegree: angle in degree:minutes:seconds format
34  - kNESMinSec: time in minutes:seconds format
35  - kNESHourMin: time in hour:minutes format
36  - kNESHourMinSec: time in hour:minutes:seconds format
37  - kNESDayMYear: date in day/month/year format
38  - kNESMDayYear: date in month/day/year format
39  - kNESHex: hex number
40 
41 The following attributes can be specified:
42  - kNEAAnyNumber: any number is allowed
43  - kNEANonNegative: only non-negative numbers are allowed
44  - kNEAPositive: only positive numbers are allowed
45 
46 Explicit limits can be specified individually:
47  - kNELNoLimits: no limits
48  - kNELLimitMin: lower limit only
49  - kNELLimitMax upper limit only
50  - kNELLimitMinMax both lower and upper limits
51 
52 TGNumberEntryField is a plain vanilla entry field, whereas
53 TGNumberEntry adds two small buttons to increase and decrease the
54 numerical value in the field. The number entry widgets also support
55 using the up and down cursor keys to change the numerical values.
56 The step size can be selected with control and shift keys:
57  - -- small step (1 unit/factor of 3)
58  - shift medium step (10 units/factor of 10)
59  - control large step (100 units/factor of 30)
60  - shift-control huge step (1000 units/factor of 100)
61 
62 The steps are either linear or logarithmic. The default behaviour
63 is set when the entry field is created, but it can be changed by
64 pressing the alt key at the same time.
65 
66 Changing the number in the widget will generate the event:
67  - kC_TEXTENTRY, kTE_TEXTCHANGED, widget id, 0.
68 Hitting the enter key will generate:
69  - kC_TEXTENTRY, kTE_ENTER, widget id, 0.
70 Hitting the tab key will generate:
71  - kC_TEXTENTRY, kTE_TAB, widget id, 0.
72 
73 */
74 
75 
76 #include "TGNumberEntry.h"
77 #include "KeySymbols.h"
78 #include "TTimer.h"
79 #include "TSystem.h"
80 #include "TGToolTip.h"
81 #include "TMath.h"
82 #include "TVirtualX.h"
83 #include "strlcpy.h"
84 #include "snprintf.h"
85 
86 #include <cctype>
87 #include <iostream>
88 
89 
94 
95 
96 
97 //////////////////////////////////////////////////////////////////////////
98 // //
99 // Miscellaneous routines for handling numeric values <-> strings //
100 // //
101 //////////////////////////////////////////////////////////////////////////
102 
103 //______________________________________________________________________________
104 enum ERealStyle { // Style of real
105  kRSInt = 0, // Integer
106  kRSFrac = 1, // Fraction only
107  kRSExpo = 2, // Exponent only
108  kRSFracExpo = 3 // Fraction and Exponent
109 };
110 
111 ////////////////////////////////////////////////////////////////////////////////
112 
113 struct RealInfo_t {
114  ERealStyle fStyle{kRSInt}; // Style of real
115  Int_t fFracDigits{0}; // Number of fractional digits
116  Int_t fFracBase{0}; // Base of fractional digits
117  Int_t fIntNum{0}; // Integer number
118  Int_t fFracNum{0}; // Fraction
119  Int_t fExpoNum{0}; // Exponent
120  Int_t fSign{0}; // Sign
121 };
122 
123 ////////////////////////////////////////////////////////////////////////////////
124 
125 const Double_t kEpsilon = 1E-12;
126 
127 ////////////////////////////////////////////////////////////////////////////////
128 
129 const Int_t kDays[13] =
130  { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
131 
132 ////////////////////////////////////////////////////////////////////////////////
133 
135 {
136  if (x > 0) {
137  return (Long_t) (x + 0.5);
138  } else if (x < 0) {
139  return (Long_t) (x - 0.5);
140  } else {
141  return 0;
142  }
143 }
144 
145 ////////////////////////////////////////////////////////////////////////////////
146 
148 {
149  if (x > 0) {
150  return (Long_t) (x + kEpsilon);
151  } else if (x < 0) {
152  return (Long_t) (x - kEpsilon);
153  } else {
154  return 0;
155  }
156 }
157 
158 ////////////////////////////////////////////////////////////////////////////////
159 
160 static Bool_t IsLeapYear(Int_t year)
161 {
162  return ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)));
163 }
164 
165 ////////////////////////////////////////////////////////////////////////////////
166 
169 {
170  if (isdigit(c)) {
171  return kTRUE;
172  }
173  if (isxdigit(c) && (style == TGNumberFormat::kNESHex)) {
174  return kTRUE;
175  }
176  if ((c == '-') && (style == TGNumberFormat::kNESInteger) &&
177  (attr == TGNumberFormat::kNEAAnyNumber)) {
178  return kTRUE;
179  }
180  if ((c == '-') &&
188  (attr == TGNumberFormat::kNEAAnyNumber)) {
189  return kTRUE;
190  }
191  if ((c == '-') && (style == TGNumberFormat::kNESReal)) {
192  return kTRUE;
193  }
194  if (((c == '.') || (c == ',')) &&
206  return kTRUE;
207  }
208  if ((c == ':') &&
215  return kTRUE;
216  }
217  if ((c == '/') &&
220  return kTRUE;
221  }
222  if (((c == 'e') || (c == 'E')) && (style == TGNumberFormat::kNESReal)) {
223  return kTRUE;
224  }
225  return kFALSE;
226 }
227 
228 ////////////////////////////////////////////////////////////////////////////////
229 
230 static char *EliminateGarbage(char *text,
233 {
234  if (text == 0) {
235  return 0;
236  }
237  for (Int_t i = strlen(text) - 1; i >= 0; i--) {
238  if (!IsGoodChar(text[i], style, attr)) {
239  memmove(text + i, text + i + 1, strlen(text) - i);
240  }
241  }
242  return text;
243 }
244 
245 ////////////////////////////////////////////////////////////////////////////////
246 
247 static Long_t IntStr(const char *text)
248 {
249  Long_t l = 0;
250  Int_t sign = 1;
251  for (UInt_t i = 0; i < strlen(text); i++) {
252  if (text[i] == '-') {
253  sign = -1;
254  } else if ((isdigit(text[i])) && (l < kMaxLong)) {
255  l = 10 * l + (text[i] - '0');
256  }
257  }
258  return sign * l;
259 }
260 
261 ////////////////////////////////////////////////////////////////////////////////
262 
263 static char *StrInt(char *text, Long_t i, Int_t digits)
264 {
265  snprintf(text, 250, "%li", TMath::Abs(i));
266  TString s = text;
267  while (digits > s.Length()) {
268  s = "0" + s;
269  }
270  if (i < 0) {
271  s = "-" + s;
272  }
273  strlcpy(text, (const char *) s, 250);
274  return text;
275 }
276 
277 ////////////////////////////////////////////////////////////////////////////////
278 
279 static TString StringInt(Long_t i, Int_t digits)
280 {
281  char text[256];
282  StrInt(text, i, digits);
283  return TString(text);
284 }
285 
286 ////////////////////////////////////////////////////////////////////////////////
287 
288 static char *RealToStr(char *text, const RealInfo_t & ri)
289 {
290  char *p = text;
291  if (text == 0) {
292  return 0;
293  }
294  strlcpy(p, "", 256);
295  if (ri.fSign < 0) {
296  strlcpy(p, "-", 256);
297  p++;
298  }
299  StrInt(p, TMath::Abs(ri.fIntNum), 0);
300  p += strlen(p);
301  if ((ri.fStyle == kRSFrac) || (ri.fStyle == kRSFracExpo)) {
302  strlcpy(p, ".", 256-strlen(p));
303  p++;
305  p += strlen(p);
306  }
307  if ((ri.fStyle == kRSExpo) || (ri.fStyle == kRSFracExpo)) {
308  strlcpy(p, "e", 256-strlen(p));
309  p++;
310  StrInt(p, ri.fExpoNum, 0);
311  p += strlen(p);
312  }
313  return text;
314 }
315 
316 ////////////////////////////////////////////////////////////////////////////////
317 
318 static Double_t StrToReal(const char *text, RealInfo_t & ri)
319 {
320  char *s;
321  char *frac;
322  char *expo;
323  char *minus;
324  char buf[256];
325 
326  if ((text == 0) || (!text[0])) {
327  ri.fStyle = kRSInt;
328  ri.fIntNum = 0;
329  ri.fSign = 1;
330  return 0.0;
331  }
332  strlcpy(buf, text, sizeof(buf));
333  s = buf;
334  frac = strchr(s, '.');
335  if (frac == 0) {
336  frac = strchr(s, ',');
337  }
338  expo = strchr(s, 'e');
339  minus = strchr(s, '-');
340  if (expo == 0) {
341  expo = strchr(s, 'E');
342  }
343  if ((frac != 0) && (expo != 0) && (frac > expo)) {
344  frac = 0;
345  }
346  if ((minus != 0) && ((expo == 0) || (minus < expo))) {
347  ri.fSign = -1;
348  } else {
349  ri.fSign = 1;
350  }
351  if ((frac == 0) && (expo == 0)) {
352  ri.fStyle = kRSInt;
353  } else if (frac == 0) {
354  ri.fStyle = kRSExpo;
355  } else if (expo == 0) {
356  ri.fStyle = kRSFrac;
357  } else {
358  ri.fStyle = kRSFracExpo;
359  }
360  if (frac != 0) {
361  *frac = 0;
362  frac++;
363  }
364  if (expo != 0) {
365  *expo = 0;
366  expo++;
367  }
368  ri.fIntNum = TMath::Abs(IntStr(s));
369  if (expo != 0) {
370  ri.fExpoNum = IntStr(expo);
371  } else {
372  ri.fExpoNum = 0;
373  }
374  if (ri.fExpoNum > 999) {
375  ri.fExpoNum = 999;
376  }
377  if (ri.fExpoNum < -999) {
378  ri.fExpoNum = -999;
379  }
380  ri.fFracDigits = 0;
381  ri.fFracBase = 1;
382  ri.fFracNum = 0;
383  if (frac != 0) {
384  for (UInt_t i = 0; i < strlen(frac); i++) {
385  if (isdigit(frac[i])) {
386  if (ri.fFracNum + 9 < kMaxInt / 10) {
387  ri.fFracNum = 10 * ri.fFracNum + (frac[i] - '0');
388  ri.fFracDigits++;
389  ri.fFracBase *= 10;
390  }
391  }
392  }
393  }
394  if ((ri.fFracDigits == 0) && (ri.fStyle == kRSFrac)) {
395  ri.fStyle = kRSInt;
396  }
397  if ((ri.fFracDigits == 0) && (ri.fStyle == kRSFracExpo)) {
398  ri.fStyle = kRSExpo;
399  }
400  switch (ri.fStyle) {
401  case kRSInt:
402  return ri.fSign * ri.fIntNum;
403  case kRSFrac:
404  return ri.fSign *
405  (ri.fIntNum + (Double_t) ri.fFracNum / ri.fFracBase);
406  case kRSExpo:
407  return ri.fSign * (ri.fIntNum * TMath::Power(10, ri.fExpoNum));
408  case kRSFracExpo:
409  return ri.fSign * (ri.fIntNum +
410  (Double_t) ri.fFracNum / ri.fFracBase) *
411  TMath::Power(10, ri.fExpoNum);
412  }
413  return 0;
414 }
415 
416 ////////////////////////////////////////////////////////////////////////////////
417 
418 static ULong_t HexStrToInt(const char *s)
419 {
420  ULong_t w = 0;
421  for (UInt_t i = 0; i < strlen(s); i++) {
422  if ((s[i] >= '0') && (s[i] <= '9')) {
423  w = 16 * w + (s[i] - '0');
424  } else if ((toupper(s[i]) >= 'A') && (toupper(s[i]) <= 'F')) {
425  w = 16 * w + (toupper(s[i]) - 'A' + 10);
426  }
427  }
428  return w;
429 }
430 
431 ////////////////////////////////////////////////////////////////////////////////
432 
433 static char *IntToHexStr(char *text, ULong_t l)
434 {
435  const char *const digits = "0123456789ABCDEF";
436  char buf[64];
437  char *p = buf + 62;
438  // coverity[secure_coding]
439  strcpy(p, "");
440  while (l > 0) {
441  *(--p) = digits[l % 16];
442  l /= 16;
443  }
444  if (!p[0]) {
445  // coverity[secure_coding]
446  strcpy(text, "0");
447  } else {
448  // coverity[secure_coding]
449  strcpy(text, p);
450  }
451  return text;
452 }
453 
454 ////////////////////////////////////////////////////////////////////////////////
455 
456 static char *MIntToStr(char *text, Long_t l, Int_t digits)
457 {
458  TString s;
459  Int_t base;
460  switch (digits) {
461  case 0:
462  base = 1;
463  break;
464  case 1:
465  base = 10;
466  break;
467  case 2:
468  base = 100;
469  break;
470  case 3:
471  base = 1000;
472  break;
473  default:
474  case 4:
475  base = 10000;
476  break;
477  }
478  s = StringInt(TMath::Abs(l) / base, 0) + "." +
479  StringInt(TMath::Abs(l) % base, digits);
480  if (l < 0) {
481  s = "-" + s;
482  }
483  strlcpy(text, (const char *) s, 256);
484  return text;
485 }
486 
487 ////////////////////////////////////////////////////////////////////////////////
488 
489 static char *DIntToStr(char *text, Long_t l, Bool_t Sec, char Del)
490 {
491  TString s;
492  if (Sec) {
493  s = StringInt(TMath::Abs(l) / 3600, 0) + Del +
494  StringInt((TMath::Abs(l) % 3600) / 60, 2) + Del +
495  StringInt(TMath::Abs(l) % 60, 2);
496  } else {
497  s = StringInt(TMath::Abs(l) / 60, 0) + Del +
498  StringInt(TMath::Abs(l) % 60, 2);
499  }
500  if (l < 0) {
501  s = "-" + s;
502  }
503  strlcpy(text, (const char *) s, 256);
504  return text;
505 }
506 
507 ////////////////////////////////////////////////////////////////////////////////
508 
509 static void GetNumbers(const char *s, Int_t & Sign,
510  Long_t & n1, Int_t maxd1,
511  Long_t & n2, Int_t maxd2,
512  Long_t & n3, Int_t maxd3, const char *Delimiters)
513 {
514  Long_t n;
515  Long_t d = 0;
516  Sign = +1;
517  n1 = 0;
518  n2 = 0;
519  n3 = 0;
520  if (*s == '-') {
521  Sign = -1;
522  s++;
523  }
524  if (!isdigit(*s) && !strchr(Delimiters, *s)) {
525  return;
526  }
527  while ((*s != 0) && ((strchr(Delimiters, *s) == 0) || (maxd2 == 0))) {
528  if (isdigit(*s) && (d < maxd1)) {
529  if (n1 < kMaxLong) {
530  n1 = 10 * n1 + (*s - '0');
531  }
532  d++;
533  }
534  s++;
535  }
536  if (strcspn(s, Delimiters) == strlen(s)) {
537  return;
538  }
539  Int_t dummy = 0;
540  GetNumbers(s + 1, dummy, n2, maxd2, n3, maxd3, n, d, Delimiters);
541 }
542 
543 ////////////////////////////////////////////////////////////////////////////////
544 
546 {
547  while (TMath::Abs(l) >= Max) {
548  l /= 10;
549  }
550  return l;
551 }
552 
553 ////////////////////////////////////////////////////////////////////////////////
554 
555 static void AppendFracZero(char *text, Int_t digits)
556 {
557  char *p;
558  Int_t found = 0;
559  p = strchr(text, '.');
560  if (p == 0) {
561  p = strchr(text, ',');
562  }
563  if (p == 0) {
564  return;
565  }
566  p++;
567  for (UInt_t i = 0; i < strlen(p); i++) {
568  if (isdigit(*p)) {
569  found++;
570  }
571  }
572  while (found < digits) {
573  // coverity[secure_coding]
574  strcpy(p + strlen(p), "0");
575  found++;
576  }
577 }
578 
579 ////////////////////////////////////////////////////////////////////////////////
580 /// Create a number entry with year/month/day information.
581 
582 static Long_t MakeDateNumber(const char * /*text*/, Long_t Day,
583  Long_t Month, Long_t Year)
584 {
585  Day = TMath::Abs(Day);
586  Month = TMath::Abs(Month);
587  Year = TMath::Abs(Year);
588  if (Year < 100) {
589  Year += 2000;
590  }
591  Month = GetSignificant(Month, 100);
592  if (Month > 12)
593  Month = 12;
594  if (Month == 0)
595  Month = 1;
596  Day = GetSignificant(Day, 100);
597  if (Day == 0)
598  Day = 1;
599  if (Day > kDays[Month])
600  Day = kDays[Month];
601  if ((Month == 2) && (Day > 28) && !IsLeapYear(Year))
602  Day = 28;
603  return 10000 * Year + 100 * Month + Day;
604 }
605 
606 ////////////////////////////////////////////////////////////////////////////////
607 /// Translate a string to a number value.
608 
609 static Long_t TranslateToNum(const char *text,
611 {
612  Long_t n1;
613  Long_t n2;
614  Long_t n3;
615  Int_t sign;
616  switch (style) {
618  GetNumbers(text, sign, n1, 12, n2, 0, n3, 0, "");
619  return sign * n1;
621  GetNumbers(text, sign, n1, 12, n2, 1, n3, 0, ".,");
622  return sign * (10 * n1 + GetSignificant(n2, 10));
624  {
625  char buf[256];
626  strlcpy(buf, text, sizeof(buf));
627  AppendFracZero(buf, 2);
628  GetNumbers(buf, sign, n1, 12, n2, 2, n3, 0, ".,");
629  return sign * (100 * n1 + GetSignificant(n2, 100));
630  }
632  {
633  char buf[256];
634  strlcpy(buf, text, sizeof(buf));
635  AppendFracZero(buf, 3);
636  GetNumbers(buf, sign, n1, 12, n2, 3, n3, 0, ".,");
637  return sign * (1000 * n1 + GetSignificant(n2, 1000));
638  }
640  {
641  char buf[256];
642  strlcpy(buf, text, sizeof(buf));
643  AppendFracZero(buf, 4);
644  GetNumbers(buf, sign, n1, 12, n2, 4, n3, 0, ".,");
645  return sign * (10000 * n1 + GetSignificant(n2, 10000));
646  }
648  return (Long_t) StrToReal(text, ri);
650  GetNumbers(text, sign, n1, 12, n2, 2, n3, 2, ".,:");
651  return sign * (3600 * n1 + 60 * GetSignificant(n2, 60) +
652  GetSignificant(n3, 60));
654  GetNumbers(text, sign, n1, 12, n2, 2, n3, 2, ".,:");
655  return 3600 * n1 + 60 * GetSignificant(n2, 60) +
656  GetSignificant(n3, 60);
658  GetNumbers(text, sign, n1, 12, n2, 2, n3, 0, ".,:");
659  return sign * (60 * n1 + GetSignificant(n2, 60));
661  GetNumbers(text, sign, n1, 12, n2, 2, n3, 0, ".,:");
662  return 60 * n1 + GetSignificant(n2, 60);
664  GetNumbers(text, sign, n1, 2, n2, 2, n3, 4, ".,/");
665  return MakeDateNumber(text, n1, n2, n3);
667  GetNumbers(text, sign, n2, 2, n1, 2, n3, 4, ".,/");
668  return MakeDateNumber(text, n1, n2, n3);
670  return HexStrToInt(text);
671  }
672  return 0;
673 }
674 
675 ////////////////////////////////////////////////////////////////////////////////
676 /// Translate a number value to a string.
677 
678 static char *TranslateToStr(char *text, Long_t l,
680 {
681  switch (style) {
683  return StrInt(text, l, 0);
685  return MIntToStr(text, l, 1);
687  return MIntToStr(text, l, 2);
689  return MIntToStr(text, l, 3);
691  return MIntToStr(text, l, 4);
693  return RealToStr(text, ri);
695  return DIntToStr(text, l, kTRUE, '.');
697  return DIntToStr(text, l % (24 * 3600), kTRUE, ':');
699  return DIntToStr(text, l, kFALSE, ':');
701  return DIntToStr(text, l % (24 * 60), kFALSE, ':');
703  {
704  TString date =
705  StringInt(TMath::Abs(l) % 100, 0) + "/" +
706  StringInt((TMath::Abs(l) / 100) % 100, 0) + "/" +
707  StringInt(TMath::Abs(l) / 10000, 0);
708  strlcpy(text, (const char *) date, 256);
709  return text;
710  }
712  {
713  TString date =
714  StringInt((TMath::Abs(l) / 100) % 100, 0) + "/" +
715  StringInt(TMath::Abs(l) % 100, 0) + "/" +
716  StringInt(TMath::Abs(l) / 10000, 0);
717  strlcpy(text, (const char *) date, 256);
718  return text;
719  }
721  return IntToHexStr(text, (ULong_t) l);
722  }
723  return 0;
724 }
725 
726 ////////////////////////////////////////////////////////////////////////////////
727 /// Convert to double format.
728 
730 {
731  switch (ri.fStyle) {
732  // Integer type real
733  case kRSInt:
734  return (Double_t) ri.fSign * ri.fIntNum;
735  // Fraction type real
736  case kRSFrac:
737  return (Double_t) ri.fSign * ((Double_t) TMath::Abs(ri.fIntNum) +
738  (Double_t) ri.fFracNum / ri.fFracBase);
739  // Exponent only
740  case kRSExpo:
741  return (Double_t) ri.fSign * ri.fIntNum *
742  TMath::Power(10, ri.fExpoNum);
743  // Fraction and exponent
744  case kRSFracExpo:
745  return (Double_t) ri.fSign * ((Double_t) TMath::Abs(ri.fIntNum) +
746  (Double_t) ri.fFracNum /
747  ri.fFracBase) * TMath::Power(10,
748  ri.fExpoNum);
749  }
750  return 0;
751 }
752 
753 ////////////////////////////////////////////////////////////////////////////////
754 /// Check min/max limits for the set value.
755 
757  TGNumberFormat::ELimit limits,
758  Double_t min, Double_t max)
759 {
760  if ((limits == TGNumberFormat::kNELNoLimits) ||
762  return;
763  }
764  // check min
765  if ((limits == TGNumberFormat::kNELLimitMin) ||
766  (limits == TGNumberFormat::kNELLimitMinMax)) {
767  Long_t lower;
768  switch (style) {
770  lower = Round(10.0 * min);
771  break;
773  lower = Round(100.0 * min);
774  break;
776  lower = Round(1000.0 * min);
777  break;
779  lower = Round(10000.0 * min);
780  break;
782  lower = (ULong_t) Round(min);
783  break;
784  default:
785  lower = Round(min);
786  break;
787  }
789  if (l < lower)
790  l = lower;
791  } else {
792  if (lower < 0)
793  lower = 0;
794  if ((ULong_t) l < (ULong_t) lower)
795  l = lower;
796  }
797  }
798  // check max
799  if ((limits == TGNumberFormat::kNELLimitMax) ||
800  (limits == TGNumberFormat::kNELLimitMinMax)) {
801  Long_t upper;
802  switch (style) {
804  upper = Round(10.0 * max);
805  break;
807  upper = Round(100.0 * max);
808  break;
810  upper = Round(1000.0 * max);
811  break;
813  upper = Round(10000.0 * max);
814  break;
816  upper = (ULong_t) Round(max);
817  break;
818  default:
819  upper = Round(max);
820  break;
821  }
823  if (l > upper)
824  l = upper;
825  } else {
826  if (upper < 0)
827  upper = 0;
828  if ((ULong_t) l > (ULong_t) upper)
829  l = upper;
830  }
831  }
832 }
833 
834 ////////////////////////////////////////////////////////////////////////////////
835 /// Convert to double format.
836 
837 static void IncreaseReal(RealInfo_t & ri, Double_t mag, Bool_t logstep,
838  TGNumberFormat::ELimit limits =
840  Double_t max = 1)
841 {
842  Double_t x = RealToDouble(ri);
843 
844  // apply step
845  if (logstep) {
846  x *= mag;
847  } else {
848  switch (ri.fStyle) {
849  case kRSInt:
850  x = x + mag;
851  break;
852  case kRSFrac:
853  x = x + mag / ri.fFracBase;
854  break;
855  case kRSExpo:
856  x = x + mag * TMath::Power(10, ri.fExpoNum);
857  break;
858  case kRSFracExpo:
859  x = x + (mag / ri.fFracBase) * TMath::Power(10, ri.fExpoNum);
860  break;
861  }
862  }
863  // check min
864  if ((limits == TGNumberFormat::kNELLimitMin) ||
865  (limits == TGNumberFormat::kNELLimitMinMax)) {
866  if (x < min)
867  x = min;
868  }
869  // check max
870  if ((limits == TGNumberFormat::kNELLimitMax) ||
871  (limits == TGNumberFormat::kNELLimitMinMax)) {
872  if (x > max)
873  x = max;
874  }
875  // check format after log step
876  if ((x != 0) && logstep && (TMath::Abs(mag) > kEpsilon)) {
877  for (int j = 0; j < 10; j++) {
878  // Integer: special case
879  if ((ri.fStyle == kRSInt) && (TMath::Abs(x) < 1) &&
880  (TMath::Abs(x) > kEpsilon)) {
881  ri.fStyle = kRSFrac;
882  ri.fFracDigits = 1;
883  ri.fFracBase = 10;
884  continue;
885  }
886  if ((ri.fStyle == kRSInt) && (TMath::Abs(x) > 10000)) {
887  ri.fStyle = kRSFracExpo;
888  ri.fExpoNum = 4;
889  ri.fFracDigits = 4;
890  ri.fFracBase = 10000;
891  Long_t rest = Round(TMath::Abs(x)) % 10000;
892  for (int k = 0; k < 4; k++) {
893  if (rest % 10 != 0) {
894  break;
895  }
896  ri.fFracDigits--;
897  ri.fFracBase /= 10;
898  rest /= 10;
899  }
900  if (ri.fFracDigits == 0) {
901  ri.fStyle = kRSExpo;
902  }
903  continue;
904  }
905  if (ri.fStyle == kRSInt)
906  break;
907 
908  // calculate first digit
909  Double_t y;
910  if ((ri.fStyle == kRSExpo) || (ri.fStyle == kRSFracExpo)) {
911  y = TMath::Abs(x) * TMath::Power(10, -ri.fExpoNum);
912  } else {
913  y = TMath::Abs(x);
914  }
915  // adjust exponent if num < 1
916  if ((Truncate(y) == 0) && (y > 0.001)) {
917  if ((ri.fStyle == kRSExpo) || (ri.fStyle == kRSFracExpo)) {
918  ri.fExpoNum--;
919  } else {
920  ri.fStyle = kRSFracExpo;
921  ri.fExpoNum = -1;
922  }
923  continue;
924  }
925  // adjust exponent if num > 10
926  if (Truncate(y) >= 10) {
927  if ((ri.fStyle == kRSExpo) || (ri.fStyle == kRSFracExpo)) {
928  ri.fExpoNum++;
929  } else {
930  ri.fStyle = kRSFracExpo;
931  ri.fExpoNum = 1;
932  }
933  continue;
934  }
935  break;
936  }
937  }
938  // convert back to RealInfo_t
939  switch (ri.fStyle) {
940  // Integer type real
941  case kRSInt:
942  {
943  ri.fSign = (x < 0) ? -1 : 1;
944  ri.fIntNum = Round(TMath::Abs(x));
945  break;
946  }
947  // Fraction type real
948  case kRSFrac:
949  {
950  ri.fSign = (x < 0) ? -1 : 1;
951  ri.fIntNum = Truncate(TMath::Abs(x));
952  ri.fFracNum = Round((TMath::Abs(x) - TMath::Abs(ri.fIntNum)) * ri.fFracBase);
953  break;
954  }
955  // Exponent only
956  case kRSExpo:
957  {
958  ri.fSign = (x < 0) ? -1 : 1;
959  ri.fIntNum = Round(TMath::Abs(x) * TMath::Power(10, -ri.fExpoNum));
960  if (ri.fIntNum == 0) {
961  ri.fStyle = kRSInt;
962  }
963  break;
964  }
965  // Fraction and exponent
966  case kRSFracExpo:
967  {
968  ri.fSign = (x < 0) ? -1 : 1;
969  Double_t y = TMath::Abs(x) * TMath::Power(10, -ri.fExpoNum);
970  ri.fIntNum = Truncate(y);
971  ri.fFracNum = Round((y - TMath::Abs(ri.fIntNum)) * ri.fFracBase);
972  if ((ri.fIntNum == 0) && (ri.fFracNum == 0)) {
973  ri.fStyle = kRSFrac;
974  }
975  break;
976  }
977  }
978 
979  // check if the back conversion violated limits
980  if (limits != TGNumberFormat::kNELNoLimits) {
981  x = RealToDouble(ri);
982  // check min
983  if ((limits == TGNumberFormat::kNELLimitMin) ||
984  (limits == TGNumberFormat::kNELLimitMinMax)) {
985  if (x < min) {
986  char text[256];
987  snprintf(text, 255, "%g", min);
988  StrToReal(text, ri);
989  }
990  }
991  // check max
992  if ((limits == TGNumberFormat::kNELLimitMax) ||
993  (limits == TGNumberFormat::kNELLimitMinMax)) {
994  if (x > max) {
995  char text[256];
996  snprintf(text, 255, "%g", max);
997  StrToReal(text, ri);
998  }
999  }
1000  }
1001 }
1002 
1003 ////////////////////////////////////////////////////////////////////////////////
1004 /// Change year/month/day format.
1005 
1007 {
1008  Long_t year;
1009  Long_t month;
1010  Long_t day;
1011 
1012  // get year/month/day format
1013  year = l / 10000;
1014  month = (TMath::Abs(l) / 100) % 100;
1015  if (month > 12)
1016  month = 12;
1017  if (month == 0)
1018  month = 1;
1019  day = TMath::Abs(l) % 100;
1020  if (day > kDays[month])
1021  day = kDays[month];
1022  if ((month == 2) && (day > 28) && !IsLeapYear(year)) {
1023  day = 28;
1024  }
1025  if (day == 0)
1026  day = 0;
1027 
1028  // apply step
1029  if (step == TGNumberFormat::kNSSHuge) {
1030  year += sign * 10;
1031  } else if (step == TGNumberFormat::kNSSLarge) {
1032  year += sign;
1033  } else if (step == TGNumberFormat::kNSSMedium) {
1034  month += sign;
1035  if (month > 12) {
1036  month = 1;
1037  year++;
1038  }
1039  if (month < 1) {
1040  month = 12;
1041  year--;
1042  }
1043  } else if (step == TGNumberFormat::kNSSSmall) {
1044  day += sign;
1045  if ((sign > 0) &&
1046  ((day > kDays[month]) ||
1047  ((month == 2) && (day > 28) && !IsLeapYear(year)))) {
1048  day = 1;
1049  month++;
1050  if (month > 12) {
1051  month = 1;
1052  year++;
1053  }
1054  }
1055  if ((sign < 0) && (day == 0)) {
1056  month--;
1057  if (month < 1) {
1058  month = 12;
1059  year--;
1060  }
1061  day = kDays[month];
1062  }
1063  }
1064  // check again for valid date
1065  if (year < 0)
1066  year = 0;
1067  if (day > kDays[month])
1068  day = kDays[month];
1069  if ((month == 2) && (day > 28) && !IsLeapYear(year)) {
1070  day = 28;
1071  }
1072  l = 10000 * year + 100 * month + day;
1073 }
1074 
1075 
1076 
1077 
1078 ////////////////////////////////////////////////////////////////////////////////
1079 /// Constructs a number entry field.
1080 
1082  Double_t val, GContext_t norm,
1083  FontStruct_t font, UInt_t option,
1084  ULong_t back)
1085  : TGTextEntry(p, new TGTextBuffer(), id, norm, font, option, back),
1086  fNeedsVerification(kFALSE), fNumStyle(kNESReal), fNumAttr(kNEAAnyNumber),
1087  fNumLimits(kNELNoLimits), fNumMin(0.0), fNumMax(1.0)
1088 {
1089  fStepLog = kFALSE;
1091  SetNumber(val);
1093 }
1094 
1095 ////////////////////////////////////////////////////////////////////////////////
1096 /// Constructs a number entry field.
1097 
1099  Int_t id, Double_t val,
1100  EStyle style, EAttribute attr,
1101  ELimit limits, Double_t min,
1102  Double_t max)
1103  : TGTextEntry(parent, "", id), fNeedsVerification(kFALSE), fNumStyle(style),
1104  fNumAttr(attr), fNumLimits(limits), fNumMin(min), fNumMax(max)
1105 {
1106  fStepLog = kFALSE;
1108  SetNumber(val);
1110 }
1111 
1112 ////////////////////////////////////////////////////////////////////////////////
1113 /// Set the numeric value (floating point representation).
1114 
1116 {
1117  switch (fNumStyle) {
1118  case kNESInteger:
1119  SetIntNumber(Round(val));
1120  break;
1121  case kNESRealOne:
1122  SetIntNumber(Round(10.0 * val));
1123  break;
1124  case kNESRealTwo:
1125  SetIntNumber(Round(100.0 * val));
1126  break;
1127  case kNESRealThree:
1128  SetIntNumber(Round(1000.0 * val));
1129  break;
1130  case kNESRealFour:
1131  SetIntNumber(Round(10000.0 * val));
1132 
1133  break;
1134  case kNESReal:
1135  {
1136  char text[256];
1137  snprintf(text, 255, "%g", val);
1138  SetText(text);
1139  break;
1140  }
1141  case kNESDegree:
1142  SetIntNumber(Round(val));
1143  break;
1144  case kNESHourMinSec:
1145  SetIntNumber(Round(val));
1146  break;
1147  case kNESMinSec:
1148  SetIntNumber(Round(val));
1149  break;
1150  case kNESHourMin:
1151  SetIntNumber(Round(val));
1152  break;
1153  case kNESDayMYear:
1154  SetIntNumber(Round(val));
1155  break;
1156  case kNESMDayYear:
1157  SetIntNumber(Round(val));
1158  break;
1159  case kNESHex:
1160  SetIntNumber((UInt_t) (TMath::Abs(val) + 0.5));
1161  break;
1162  }
1163 }
1164 
1165 ////////////////////////////////////////////////////////////////////////////////
1166 /// Set the numeric value (integer representation).
1167 
1169 {
1170  char text[256];
1171  RealInfo_t ri;
1172  if (fNumStyle == kNESReal) {
1173  TranslateToStr(text, val, kNESInteger, ri);
1174  } else {
1175  TranslateToStr(text, val, fNumStyle, ri);
1176  }
1177  SetText(text);
1178 }
1179 
1180 ////////////////////////////////////////////////////////////////////////////////
1181 /// Set the numeric value (time format).
1182 
1184 {
1185  switch (fNumStyle) {
1186  case kNESHourMinSec:
1187  SetIntNumber(3600 * TMath::Abs(hour) + 60 * TMath::Abs(min) +
1188  TMath::Abs(sec));
1189  break;
1190  case kNESMinSec:
1191  {
1192  SetIntNumber(60 * min + sec);
1193  break;
1194  }
1195  case kNESHourMin:
1196  SetIntNumber(60 * TMath::Abs(hour) + TMath::Abs(min));
1197  break;
1198  default:
1199  break;
1200  }
1201 }
1202 
1203 ////////////////////////////////////////////////////////////////////////////////
1204 /// Set the numeric value (date format).
1205 
1207 {
1208  switch (fNumStyle) {
1209  case kNESDayMYear:
1210  case kNESMDayYear:
1211  {
1212  SetIntNumber(10000 * TMath::Abs(year) + 100 * TMath::Abs(month) +
1213  TMath::Abs(day));
1214  }
1215  default:
1216  {
1217  break;
1218  }
1219  }
1220 }
1221 
1222 ////////////////////////////////////////////////////////////////////////////////
1223 /// Set the numeric value (hex format).
1224 
1226 {
1227  SetIntNumber((Long_t) val);
1228 }
1229 
1230 ////////////////////////////////////////////////////////////////////////////////
1231 /// Set the value (text format).
1232 
1233 void TGNumberEntryField::SetText(const char *text, Bool_t emit)
1234 {
1235  char buf[256];
1236  strlcpy(buf, text, sizeof(buf));
1238  TGTextEntry::SetText(buf, emit);
1240 }
1241 
1242 ////////////////////////////////////////////////////////////////////////////////
1243 /// Get the numeric value (floating point representation).
1244 
1246 {
1247  switch (fNumStyle) {
1248  case kNESInteger:
1249  return (Double_t) GetIntNumber();
1250  case kNESRealOne:
1251  return (Double_t) GetIntNumber() / 10.0;
1252  case kNESRealTwo:
1253  return (Double_t) GetIntNumber() / 100.0;
1254  case kNESRealThree:
1255  return (Double_t) GetIntNumber() / 1000.0;
1256  case kNESRealFour:
1257  return (Double_t) GetIntNumber() / 10000.0;
1258  case kNESReal:
1259  {
1260  char text[256];
1261  RealInfo_t ri;
1262  strlcpy(text, GetText(), sizeof(text));
1263  return StrToReal(text, ri);
1264  }
1265  case kNESDegree:
1266  return (Double_t) GetIntNumber();
1267  case kNESHourMinSec:
1268  return (Double_t) GetIntNumber();
1269  case kNESMinSec:
1270  return (Double_t) GetIntNumber();
1271  case kNESHourMin:
1272  return (Double_t) GetIntNumber();
1273  case kNESDayMYear:
1274  return (Double_t) GetIntNumber();
1275  case kNESMDayYear:
1276  return (Double_t) GetIntNumber();
1277  case kNESHex:
1278  return (Double_t) (ULong_t) GetIntNumber();
1279  }
1280  return 0;
1281 }
1282 
1283 ////////////////////////////////////////////////////////////////////////////////
1284 /// Get the numeric value (integer representation).
1285 
1287 {
1288  RealInfo_t ri;
1289  return TranslateToNum(GetText(), fNumStyle, ri);
1290 }
1291 
1292 ////////////////////////////////////////////////////////////////////////////////
1293 /// Get the numeric value (time format).
1294 
1295 void TGNumberEntryField::GetTime(Int_t & hour, Int_t & min, Int_t & sec) const
1296 {
1297  switch (fNumStyle) {
1298  case kNESHourMinSec:
1299  {
1300  Long_t l = GetIntNumber();
1301  hour = TMath::Abs(l) / 3600;
1302  min = (TMath::Abs(l) % 3600) / 60;
1303  sec = TMath::Abs(l) % 60;
1304  break;
1305  }
1306  case kNESMinSec:
1307  {
1308  Long_t l = GetIntNumber();
1309  hour = 0;
1310  min = TMath::Abs(l) / 60;
1311  sec = TMath::Abs(l) % 60;
1312  if (l < 0) {
1313  min *= -1;
1314  sec *= -1;
1315  }
1316  break;
1317  }
1318  case kNESHourMin:
1319  {
1320  Long_t l = GetIntNumber();
1321  hour = TMath::Abs(l) / 60;
1322  min = TMath::Abs(l) % 60;
1323  sec = 0;
1324  break;
1325  }
1326  default:
1327  {
1328  hour = 0;
1329  min = 0;
1330  sec = 0;
1331  break;
1332  }
1333  }
1334 }
1335 
1336 ////////////////////////////////////////////////////////////////////////////////
1337 /// Get the numeric value (date format).
1338 
1339 void TGNumberEntryField::GetDate(Int_t & year, Int_t & month, Int_t & day) const
1340 {
1341  switch (fNumStyle) {
1342  case kNESDayMYear:
1343  case kNESMDayYear:
1344  {
1345  Long_t l = GetIntNumber();
1346  year = l / 10000;
1347  month = (l % 10000) / 100;
1348  day = l % 100;
1349  break;
1350  }
1351  default:
1352  {
1353  year = 0;
1354  month = 0;
1355  day = 0;
1356  break;
1357  }
1358  }
1359 }
1360 
1361 ////////////////////////////////////////////////////////////////////////////////
1362 /// Get the numeric value (hex format).
1363 
1365 {
1366  return (ULong_t) GetIntNumber();
1367 }
1368 
1369 ////////////////////////////////////////////////////////////////////////////////
1370 /// Get the text width in pixels.
1371 
1373 {
1374  return gVirtualX->TextWidth(fFontStruct, text, strlen(text));
1375 }
1376 
1377 ////////////////////////////////////////////////////////////////////////////////
1378 /// Increase the number value.
1379 
1381  Int_t stepsign, Bool_t logstep)
1382 {
1383  Long_t l = 0;
1384  RealInfo_t ri;
1385  Long_t mag = 0;
1386  Double_t rmag = 0.0;
1387  Int_t sign = stepsign;
1388 
1389  // save old text field
1390  TString oldtext = GetText();
1391  // Get number
1392  if (fNumStyle != kNESReal) {
1393  l = GetIntNumber();
1394  } else {
1395  StrToReal(oldtext, ri);
1396  }
1397 
1398  // magnitude of step
1399  if ((fNumStyle == kNESDegree) || (fNumStyle == kNESHourMinSec) ||
1400  (fNumStyle == kNESMinSec) || (fNumStyle == kNESHourMin) ||
1402  (fNumStyle == kNESHex)) {
1403  logstep = kFALSE;
1404  switch (step) {
1405  case kNSSSmall:
1406  mag = 1;
1407  break;
1408  case kNSSMedium:
1409  mag = 10;
1410  break;
1411  case kNSSLarge:
1412  mag = 100;
1413  break;
1414  case kNSSHuge:
1415  mag = 1000;
1416  break;
1417  }
1418  } else {
1419  Int_t msd = TMath::Abs((fNumStyle == kNESReal) ? ri.fIntNum : l);
1420  while (msd >= 10)
1421  msd /= 10;
1422  Bool_t odd = (msd < 3);
1423  if (sign < 0)
1424  odd = !odd;
1425  switch (step) {
1426  case kNSSSmall:
1427  rmag = (!logstep) ? 1. : (odd ? 3. : 10. / 3.);
1428  break;
1429  case kNSSMedium:
1430  rmag = 10.;
1431  break;
1432  case kNSSLarge:
1433  rmag = (!logstep) ? 100. : (odd ? 30. : 100. / 3.);
1434  break;
1435  case kNSSHuge:
1436  rmag = (!logstep) ? 1000. : 100.;
1437  break;
1438  }
1439  if (sign < 0)
1440  rmag = logstep ? 1. / rmag : -rmag;
1441  }
1442 
1443  // sign of step
1444  if (sign == 0) {
1445  logstep = kFALSE;
1446  rmag = 0;
1447  mag = 0;
1448  } else {
1449  sign = (sign > 0) ? 1 : -1;
1450  }
1451  // add/multiply step
1452  switch (fNumStyle) {
1453  case kNESInteger:
1454  case kNESRealOne:
1455  case kNESRealTwo:
1456  case kNESRealThree:
1457  case kNESRealFour:
1458  {
1459  l = logstep ? Round(l * rmag) : Round(l + rmag);
1461  if ((l < 0) && (fNumAttr == kNEANonNegative))
1462  l = 0;
1463  if ((l <= 0) && (fNumAttr == kNEAPositive))
1464  l = 1;
1465  break;
1466  }
1467  case kNESReal:
1468  {
1469  IncreaseReal(ri, rmag, logstep, fNumLimits, fNumMin, fNumMax);
1470  if (((fNumAttr == kNEANonNegative) ||
1471  (fNumAttr == kNEAPositive)) && (ri.fSign < 0)) {
1472  ri.fIntNum = 0;
1473  ri.fFracNum = 0;
1474  ri.fExpoNum = 0;
1475  ri.fSign = 1;
1476  }
1477  break;
1478  }
1479  case kNESDegree:
1480  {
1481  if (mag > 60)
1482  l += sign * 36 * mag;
1483  else if (mag > 6)
1484  l += sign * 6 * mag;
1485  else
1486  l += sign * mag;
1488  if ((l < 0) && (fNumAttr == kNEANonNegative))
1489  l = 0;
1490  if ((l <= 0) && (fNumAttr == kNEAPositive))
1491  l = 1;
1492  break;
1493  }
1494  case kNESHourMinSec:
1495  {
1496  if (mag > 60)
1497  l += sign * 36 * mag;
1498  else if (mag > 6)
1499  l += sign * 6 * mag;
1500  else
1501  l += sign * mag;
1503  if (l < 0)
1504  l = (24 * 3600) - ((-l) % (24 * 3600));
1505  if (l > 0)
1506  l = l % (24 * 3600);
1507  break;
1508  }
1509  case kNESMinSec:
1510  {
1511  if (mag > 6)
1512  l += sign * 6 * mag;
1513  else
1514  l += sign * mag;
1516  if ((l < 0) && (fNumAttr == kNEANonNegative))
1517  l = 0;
1518  if ((l <= 0) && (fNumAttr == kNEAPositive))
1519  l = 1;
1520  break;
1521  }
1522  case kNESHourMin:
1523  {
1524  if (mag > 6)
1525  l += sign * 6 * mag;
1526  else
1527  l += sign * mag;
1529  if (l < 0)
1530  l = (24 * 60) - ((-l) % (24 * 60));
1531  if (l > 0)
1532  l = l % (24 * 60);
1533  break;
1534  }
1535  case kNESDayMYear:
1536  case kNESMDayYear:
1537  {
1538  IncreaseDate(l, step, sign);
1540  break;
1541  }
1542  case kNESHex:
1543  {
1544  ULong_t ll = (ULong_t) l;
1545  if (mag > 500)
1546  ll += sign * 4096 * mag / 1000;
1547  else if (mag > 50)
1548  ll += sign * 256 * mag / 100;
1549  else if (mag > 5)
1550  ll += sign * 16 * mag / 10;
1551  else
1552  ll += sign * mag;
1553  l = (Long_t) ll;
1555  break;
1556  }
1557  }
1558  if (fNumStyle != kNESReal) {
1559  SetIntNumber(l);
1560  } else {
1561  char buf[256];
1562  RealToStr(buf, ri);
1563  SetText(buf);
1564  }
1565 }
1566 
1567 ////////////////////////////////////////////////////////////////////////////////
1568 /// Set the numerical format.
1569 
1571 {
1572  Double_t val = GetNumber();
1573  fNumStyle = style;
1574  fNumAttr = attr;
1575  if ((fNumAttr != kNEAAnyNumber) && (val < 0))
1576  val = 0;
1577  SetNumber(val);
1578  // make sure we have a valid number by increasing it by 0
1580 }
1581 
1582 ////////////////////////////////////////////////////////////////////////////////
1583 /// Set the numerical limits.
1584 
1586  Double_t min, Double_t max)
1587 {
1588  Double_t val = GetNumber();
1589  fNumLimits = limits;
1590  fNumMin = min;
1591  fNumMax = max;
1592  SetNumber(val);
1593  // make sure we have a valid number by increasing it by 0
1595 }
1596 
1597 ////////////////////////////////////////////////////////////////////////////////
1598 /// Set the active state.
1599 
1601 {
1602  if (!state && fNeedsVerification) {
1603  // make sure we have a valid number by increasing it by 0
1605  }
1606  TGTextEntry::SetState(state);
1607 }
1608 
1609 ////////////////////////////////////////////////////////////////////////////////
1610 /// Handle keys.
1611 
1613 {
1614  if (!IsEnabled()) {
1615  return TGTextEntry::HandleKey(event);
1616  }
1617 
1618  Int_t n;
1619  char tmp[10];
1620  UInt_t keysym;
1621  gVirtualX->LookupString(event, tmp, sizeof(tmp), keysym);
1622  n = strlen(tmp);
1623 
1624  // intercept up key
1625  if ((EKeySym) keysym == kKey_Up) {
1626  // Get log step / alt key
1627  Bool_t logstep = fStepLog;
1628  if (event->fState & kKeyMod1Mask)
1629  logstep = !logstep;
1630  // shift-cntrl-up
1631  if ((event->fState & kKeyShiftMask) &&
1632  (event->fState & kKeyControlMask)) {
1633  IncreaseNumber(kNSSHuge, 1, logstep);
1634  }
1635  // cntrl-up
1636  else if (event->fState & kKeyControlMask) {
1637  IncreaseNumber(kNSSLarge, 1, logstep);
1638 
1639  }
1640  // shift-up
1641  else if (event->fState & kKeyShiftMask) {
1642  IncreaseNumber(kNSSMedium, 1, logstep);
1643  }
1644 
1645  // up
1646  else {
1647  IncreaseNumber(kNSSSmall, 1, logstep);
1648  }
1649  return kTRUE;
1650  }
1651  // intercept down key
1652  else if ((EKeySym) keysym == kKey_Down) {
1653  // Get log step / alt key
1654  Bool_t logstep = fStepLog;
1655  if (event->fState & kKeyMod1Mask)
1656  logstep = !logstep;
1657  // shift-cntrl-down
1658  if ((event->fState & kKeyShiftMask) &&
1659  (event->fState & kKeyControlMask)) {
1660  IncreaseNumber(kNSSHuge, -1, logstep);
1661  }
1662  // cntrl-down
1663  else if (event->fState & kKeyControlMask) {
1664  IncreaseNumber(kNSSLarge, -1, logstep);
1665  }
1666  // shift-down
1667  else if (event->fState & kKeyShiftMask) {
1668  IncreaseNumber(kNSSMedium, -1, logstep);
1669  }
1670  // down
1671  else {
1672  IncreaseNumber(kNSSSmall, -1, logstep);
1673  }
1674  return kTRUE;
1675  }
1676  // intercept printable characters
1677  else if (n && (keysym < 127) && (keysym >= 32) &&
1678  ((EKeySym) keysym != kKey_Delete) &&
1679  ((EKeySym) keysym != kKey_Backspace) &&
1680  ((event->fState & kKeyControlMask) == 0)) {
1681  if (IsGoodChar(tmp[0], fNumStyle, fNumAttr)) {
1682  return TGTextEntry::HandleKey(event);
1683  } else {
1684  return kTRUE;
1685  }
1686  }
1687  // otherwise use default behaviour
1688  else {
1689  return TGTextEntry::HandleKey(event);
1690  }
1691 }
1692 
1693 ////////////////////////////////////////////////////////////////////////////////
1694 /// Handle focus change.
1695 
1697 {
1698  if (IsEnabled() && fNeedsVerification &&
1699  (event->fCode == kNotifyNormal) &&
1700  (event->fState != kNotifyPointer) && (event->fType == kFocusOut)) {
1701  // make sure we have a valid number by increasing it by 0
1703  }
1704 
1706 }
1707 
1708 ////////////////////////////////////////////////////////////////////////////////
1709 /// Text has changed message.
1710 
1712 {
1715 }
1716 
1717 ////////////////////////////////////////////////////////////////////////////////
1718 /// Return was pressed.
1719 
1721 {
1722  TString instr, outstr;
1723  instr = TGTextEntry::GetBuffer()->GetString();
1724 
1725  if (fNeedsVerification) {
1726  // make sure we have a valid number by increasing it by 0
1728  }
1729  outstr = TGTextEntry::GetBuffer()->GetString();
1730  if (instr != outstr) {
1731  InvalidInput(instr);
1732  gVirtualX->Bell(0);
1733  }
1735 }
1736 
1737 ////////////////////////////////////////////////////////////////////////////////
1738 /// Layout.
1739 
1741 {
1742  if (GetAlignment() == kTextRight) {
1743  End(kFALSE);
1744  } else {
1745  Home(kFALSE);
1746  }
1747 }
1748 
1749 //////////////////////////////////////////////////////////////////////////
1750 // //
1751 // TGNumberEntryLayout //
1752 // //
1753 // Layout manager for number entry widget //
1754 // //
1755 //////////////////////////////////////////////////////////////////////////
1756 
1757 
1758 ////////////////////////////////////////////////////////////////////////////////
1759 /// Layout the internal GUI elements in use.
1760 
1762 {
1763  if (fBox == 0) {
1764  return;
1765  }
1766  UInt_t w = fBox->GetWidth();
1767  UInt_t h = fBox->GetHeight();
1768  UInt_t upw = 2 * h / 3;
1769  UInt_t uph = h / 2;
1770  Int_t upx = (w > h) ? (Int_t) w - (Int_t) upw : -1000;
1771  Int_t upy = 0;
1772  Int_t downx = (w > h) ? (Int_t) w - (Int_t) upw : -1000;
1773  Int_t downy = h / 2;
1774  UInt_t downw = upw;
1775  UInt_t downh = h - downy;
1776  UInt_t numw = (w > h) ? w - upw : w;
1777  UInt_t numh = h;
1778  if (fBox->GetNumberEntry())
1779  fBox->GetNumberEntry()->MoveResize(0, 0, numw, numh);
1780  if (fBox->GetButtonUp())
1781  fBox->GetButtonUp()->MoveResize(upx, upy, upw, uph);
1782  if (fBox->GetButtonDown())
1783  fBox->GetButtonDown()->MoveResize(downx, downy, downw, downh);
1784 }
1785 
1786 ////////////////////////////////////////////////////////////////////////////////
1787 /// Return the default size of the numeric control box.
1788 
1790 {
1791  return fBox->GetSize();
1792 }
1793 
1794 
1795 
1796 //////////////////////////////////////////////////////////////////////////
1797 // //
1798 // TRepeatTimer //
1799 // //
1800 // Timer for numeric control box buttons. //
1801 // //
1802 //////////////////////////////////////////////////////////////////////////
1803 
1804 class TGRepeatFireButton;
1805 
1806 ////////////////////////////////////////////////////////////////////////////////
1807 
1808 class TRepeatTimer : public TTimer {
1809 private:
1810  TGRepeatFireButton *fButton; // Fire button
1811 
1812 public:
1814  : TTimer(ms, kTRUE), fButton(button) { }
1815  virtual Bool_t Notify();
1816 };
1817 
1818 
1819 
1820 //////////////////////////////////////////////////////////////////////////
1821 // //
1822 // TRepeatFireButton //
1823 // //
1824 // Picture button which fires repeatedly as long as the button is pressed //
1825 // //
1826 //////////////////////////////////////////////////////////////////////////
1827 
1828 ////////////////////////////////////////////////////////////////////////////////
1829 
1831 protected:
1832  TRepeatTimer *fTimer; // the timer
1833  Int_t fIgnoreNextFire; // flag for skipping next
1834  TGNumberFormat::EStepSize fStep; // increment/decrement step
1835  Bool_t fStepLog; // logarithmic step flag
1836  Bool_t fDoLogStep; // flag for using logarithmic step
1837 
1839 
1840 public:
1841  TGRepeatFireButton(const TGWindow *p, const TGPicture *pic,
1842  Int_t id, Bool_t logstep)
1843  : TGPictureButton(p, pic, id), fTimer(0), fIgnoreNextFire(0),
1844  fStep(TGNumberFormat::kNSSSmall), fStepLog(logstep), fDoLogStep(logstep)
1846  virtual ~TGRepeatFireButton() { delete fTimer; }
1847 
1848  virtual Bool_t HandleButton(Event_t *event);
1849  void FireButton();
1850  virtual void SetLogStep(Bool_t on = kTRUE) { fStepLog = on; }
1851 };
1852 
1853 ////////////////////////////////////////////////////////////////////////////////
1854 /// Return kTRUE if one of the parents is in edit mode.
1855 
1857 {
1858  TGWindow *parent = (TGWindow*)GetParent();
1859 
1860  while (parent && (parent != fClient->GetDefaultRoot())) {
1861  if (parent->IsEditable()) {
1862  return kTRUE;
1863  }
1864  parent = (TGWindow*)parent->GetParent();
1865  }
1866  return kFALSE;
1867 }
1868 
1869 ////////////////////////////////////////////////////////////////////////////////
1870 /// Handle messages for number entry widget according to the user input.
1871 
1873 {
1874  const Int_t t0 = 200;
1875  if (fTip)
1876  fTip->Hide();
1877 
1878  // disable button handling while gui building
1879  if (IsEditableParent()) {
1880  return kTRUE;
1881  }
1882 
1883  if (fState == kButtonDisabled)
1884  return kTRUE;
1885 
1886  if (event->fType == kButtonPress) {
1887  // Get log step / alt key
1888  fDoLogStep = fStepLog;
1889  if (event->fState & kKeyMod1Mask)
1891  if ((event->fState & kKeyShiftMask) &&
1892  (event->fState & kKeyControlMask)) {
1894  } else if (event->fState & kKeyControlMask) {
1896  } else if (event->fState & kKeyShiftMask) {
1898  } else {
1900  }
1902  fIgnoreNextFire = 0;
1903  FireButton();
1904  fIgnoreNextFire = 2;
1905 
1906  if (fTimer == 0) {
1907  fTimer = new TRepeatTimer(this, t0);
1908  }
1909  fTimer->Reset();
1911  } else {
1913  if (fTimer != 0) {
1914  fTimer->Remove();
1915  fTimer->SetTime(t0);
1916  }
1917  }
1918 
1919  return kTRUE;
1920 }
1921 
1922 ////////////////////////////////////////////////////////////////////////////////
1923 /// Process messages for fire button.
1924 
1926 {
1927  if (fIgnoreNextFire <= 0) {
1929  fWidgetId, (Long_t) fStep + (fDoLogStep ? 100 : 0));
1930  } else {
1931  fIgnoreNextFire--;
1932  }
1933 }
1934 
1935 ////////////////////////////////////////////////////////////////////////////////
1936 /// Notify when timer times out and reset the timer.
1937 
1939 {
1940  fButton->FireButton();
1941  Reset();
1942  if ((Long64_t)fTime > 20) fTime -= 10;
1943  return kFALSE;
1944 }
1945 
1946 ////////////////////////////////////////////////////////////////////////////////
1947 /// Constructs a numeric entry widget.
1948 
1950  Double_t val, Int_t wdigits, Int_t id,
1951  EStyle style,
1952  EAttribute attr,
1953  ELimit limits, Double_t min, Double_t max)
1954  : TGCompositeFrame(parent, 10 * wdigits, 25), fButtonToNum(kTRUE)
1955 {
1956  fWidgetId = id;
1957  fMsgWindow = parent;
1958  fPicUp = fClient->GetPicture("arrow_up.xpm");
1959  if (!fPicUp)
1960  Error("TGNumberEntry", "arrow_up.xpm not found");
1961  fPicDown = fClient->GetPicture("arrow_down.xpm");
1962  if (!fPicDown)
1963  Error("TGNumberEntry", "arrow_down.xpm not found");
1964 
1965  // create gui elements
1966  fNumericEntry = new TGNumberEntryField(this, id, val, style, attr,
1967  limits, min, max);
1968  fNumericEntry->Connect("ReturnPressed()", "TGNumberEntry", this,
1969  "ValueSet(Long_t=0)");
1970  fNumericEntry->Connect("ReturnPressed()", "TGNumberEntry", this,
1971  "Modified()");
1973  AddFrame(fNumericEntry, 0);
1974  fButtonUp = new TGRepeatFireButton(this, fPicUp, 1,
1976  fButtonUp->Associate(this);
1977  AddFrame(fButtonUp, 0);
1978  fButtonDown = new TGRepeatFireButton(this, fPicDown, 2,
1980  fButtonDown->Associate(this);
1981  AddFrame(fButtonDown, 0);
1982 
1983  // resize
1985  Int_t charw = fNumericEntry->GetCharWidth("0123456789");
1986  Int_t w = charw * TMath::Abs(wdigits) / 10 + 8 + 2 * h / 3;
1988  MapSubwindows();
1989  Resize(w, h);
1991 }
1992 
1993 ////////////////////////////////////////////////////////////////////////////////
1994 /// Destructs a numeric entry widget.
1995 
1997 {
1998  gClient->FreePicture(fPicUp);
1999  gClient->FreePicture(fPicDown);
2000 
2001  Cleanup();
2002 }
2003 
2004 ////////////////////////////////////////////////////////////////////////////////
2005 /// Make w the window that will receive the generated messages.
2006 
2008 {
2011 }
2012 
2013 ////////////////////////////////////////////////////////////////////////////////
2014 /// Set log steps.
2015 
2017 {
2019  ((TGRepeatFireButton *) fButtonUp)->SetLogStep(fNumericEntry->IsLogStep());
2020  ((TGRepeatFireButton *) fButtonDown)->SetLogStep(fNumericEntry->IsLogStep());
2021 }
2022 
2023 ////////////////////////////////////////////////////////////////////////////////
2024 /// Set the active state.
2025 
2027 {
2028  if (enable) {
2032  } else {
2036  }
2037 }
2038 
2039 ////////////////////////////////////////////////////////////////////////////////
2040 /// Send button messages to the number field (true) or parent widget (false).
2041 /// When the message is sent to the parent widget, it is responsible to change
2042 /// the numerical value accordingly. This can be useful to implement cursors
2043 /// which move from data point to data point. For the message being sent
2044 /// see ProcessMessage().
2045 
2047 {
2048  fButtonToNum = state;
2049 }
2050 
2051 ////////////////////////////////////////////////////////////////////////////////
2052 /// Process the up/down button messages. If fButtonToNum is false the
2053 /// following message is sent: kC_COMMAND, kCM_BUTTON, widget id, param
2054 /// param % 100 is the step size
2055 /// param % 10000 / 100 != 0 indicates log step
2056 /// param / 10000 != 0 indicates button down
2057 
2059 {
2060  switch (GET_MSG(msg)) {
2061  case kC_COMMAND:
2062  {
2063  if ((GET_SUBMSG(msg) == kCM_BUTTON) &&
2064  (parm1 >= 1) && (parm1 <= 2)) {
2065  if (fButtonToNum) {
2066  Int_t sign = (parm1 == 1) ? 1 : -1;
2067  EStepSize step = (EStepSize) (parm2 % 100);
2068  Bool_t logstep = (parm2 >= 100);
2069  fNumericEntry->IncreaseNumber(step, sign, logstep);
2070  } else {
2072  10000 * (parm1 - 1) + parm2);
2073  ValueChanged(10000 * (parm1 - 1) + parm2);
2074  }
2075  // Emit a signal needed by pad editor
2076  ValueSet(10000 * (parm1 - 1) + parm2);
2077  Modified();
2078  }
2079  break;
2080  }
2081  }
2082  return kTRUE;
2083 }
2084 
2085 
2086 ////////////////////////////////////////////////////////////////////////////////
2087 /// Return layout manager.
2088 
2090 {
2091  TGNumberEntry *entry = (TGNumberEntry*)this;
2092 
2093  if (entry->fLayoutManager->IsA() != TGNumberEntryLayout::Class()) {
2094  entry->SetLayoutManager(new TGNumberEntryLayout(entry));
2095  }
2096 
2097  return entry->fLayoutManager;
2098 }
2099 
2100 ////////////////////////////////////////////////////////////////////////////////
2101 /// Emit ValueChanged(Long_t) signal. This signal is emitted when
2102 /// fButtonToNum is false. The val has the following meaning:
2103 /// val % 100 is the step size
2104 /// val % 10000 / 100 != 0 indicates log step
2105 /// val / 10000 != 0 indicates button down
2106 
2108 {
2109  Emit("ValueChanged(Long_t)", val);
2110 }
2111 
2112 ////////////////////////////////////////////////////////////////////////////////
2113 /// Emit ValueSet(Long_t) signal. This signal is emitted when the
2114 /// number entry value is changed. The val has the following meaning:
2115 /// val % 100 is the step size
2116 /// val % 10000 / 100 != 0 indicates log step
2117 /// val / 10000 != 0 indicates button down
2118 
2120 {
2121  Emit("ValueSet(Long_t)", val);
2122 }
2123 
2124 ////////////////////////////////////////////////////////////////////////////////
2125 /// Emit Modified() signal. This signal is emitted when the
2126 /// number entry value is changed.
2127 
2129 {
2130  Emit("Modified()");
2131 }
2132 
2133 ////////////////////////////////////////////////////////////////////////////////
2134 /// Save a number entry widget as a C++ statement(s) on output stream out.
2135 
2136 void TGNumberEntry::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
2137 {
2138  char quote = '"';
2139 
2140  // to calculate the digits parameter
2141  Int_t w = fNumericEntry->GetWidth();
2143  Int_t charw = fNumericEntry->GetCharWidth("0123456789");
2144  Int_t digits = (30*w - 240 -20*h)/(3*charw) + 3;
2145 
2146  // for time format
2147  Int_t hour, min, sec;
2148  GetTime(hour, min, sec);
2149 
2150  // for date format
2151  Int_t yy, mm, dd;
2152  GetDate(yy, mm, dd);
2153 
2154  out << " TGNumberEntry *";
2155  out << GetName() << " = new TGNumberEntry(" << fParent->GetName() << ", (Double_t) ";
2156  switch (GetNumStyle()){
2157  case kNESInteger:
2158  out << GetIntNumber() << "," << digits << "," << WidgetId()
2159  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2160  break;
2161  case kNESRealOne:
2162  out << GetNumber() << "," << digits << "," << WidgetId()
2163  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2164  break;
2165  case kNESRealTwo:
2166  out << GetNumber() << "," << digits << "," << WidgetId()
2167  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2168  break;
2169  case kNESRealThree:
2170  out << GetNumber() << "," << digits << "," << WidgetId()
2171  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2172  break;
2173  case kNESRealFour:
2174  out << GetNumber() << "," << digits << "," << WidgetId()
2175  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2176  break;
2177  case kNESReal:
2178  out << GetNumber() << "," << digits << "," << WidgetId()
2179  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2180  break;
2181  case kNESDegree:
2182  out << GetIntNumber() << "," << digits << "," << WidgetId()
2183  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2184  break;
2185  case kNESMinSec:
2186  out << min*60 + sec << "," << digits << "," << WidgetId()
2187  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2188  break;
2189  case kNESHourMin:
2190  out << hour*60 + min << "," << digits << "," << WidgetId()
2191  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2192  break;
2193  case kNESHourMinSec:
2194  out << hour*3600 + min*60 + sec << "," << digits << "," << WidgetId()
2195  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2196  break;
2197  case kNESDayMYear:
2198  out << yy << mm << dd << "," << digits << "," << WidgetId()
2199  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2200  break;
2201  case kNESMDayYear:
2202  out << yy << mm << dd << "," << digits << "," << WidgetId()
2203  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2204  break;
2205  case kNESHex:
2206  { char hex[256];
2207  ULong_t l = GetHexNumber();
2208  IntToHexStr(hex, l);
2209  std::ios::fmtflags f = out.flags(); // store flags
2210  out << "0x" << std::hex << "U," << digits << "," << WidgetId()
2211  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2212  out.flags( f ); // restore flags (reset std::hex)
2213  break;
2214  }
2215  }
2216  if (GetNumMax() ==1) {
2217  if (GetNumMin() == 0) {
2218  if (GetNumLimits() == kNELNoLimits) {
2219  if (GetNumAttr() == kNEAAnyNumber) {
2220  out << ");" << std::endl;
2221  } else {
2222  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr() << ");" << std::endl;
2223  }
2224  } else {
2225  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2226  << ",(TGNumberFormat::ELimit) " << GetNumLimits() << ");" << std::endl;
2227  }
2228  } else {
2229  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2230  << ",(TGNumberFormat::ELimit) " << GetNumLimits()
2231  << "," << GetNumMin() << ");" << std::endl;
2232  }
2233  } else {
2234  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2235  << ",(TGNumberFormat::ELimit) " << GetNumLimits()
2236  << "," << GetNumMin() << "," << GetNumMax() << ");" << std::endl;
2237  }
2238  if (option && strstr(option, "keep_names"))
2239  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
2241  out << " " << GetName() << "->SetState(kFALSE);" << std::endl;
2242 
2243  TGToolTip *tip = GetNumberEntry()->GetToolTip();
2244  if (tip) {
2245  TString tiptext = tip->GetText()->GetString();
2246  tiptext.ReplaceAll("\n", "\\n");
2247  out << " ";
2248  out << GetName() << "->GetNumberEntry()->SetToolTipText(" << quote
2249  << tiptext << quote << ");" << std::endl;
2250  }
2251 }
2252 
2253 ////////////////////////////////////////////////////////////////////////////////
2254 /// Save a number entry widget as a C++ statement(s) on output stream out.
2255 
2256 void TGNumberEntryField::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
2257 {
2258  char quote = '"';
2259 
2260  // for time format
2261  Int_t hour, min, sec;
2262  GetTime(hour, min, sec);
2263 
2264  // for date format
2265  Int_t yy, mm, dd;
2266  GetDate(yy, mm, dd);
2267 
2268  out << " TGNumberEntryField *";
2269  out << GetName() << " = new TGNumberEntryField(" << fParent->GetName()
2270  << ", " << WidgetId() << ", (Double_t) ";
2271  switch (GetNumStyle()){
2272  case kNESInteger:
2273  out << GetIntNumber()
2274  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2275  break;
2276  case kNESRealOne:
2277  out << GetNumber()
2278  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2279  break;
2280  case kNESRealTwo:
2281  out << GetNumber()
2282  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2283  break;
2284  case kNESRealThree:
2285  out << GetNumber()
2286  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2287  break;
2288  case kNESRealFour:
2289  out << GetNumber()
2290  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2291  break;
2292  case kNESReal:
2293  out << GetNumber()
2294  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2295  break;
2296  case kNESDegree:
2297  out << GetIntNumber()
2298  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2299  break;
2300  case kNESMinSec:
2301  out << min*60 + sec
2302  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2303  break;
2304  case kNESHourMin:
2305  out << hour*60 + min
2306  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2307  break;
2308  case kNESHourMinSec:
2309  out << hour*3600 + min*60 + sec
2310  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2311  break;
2312  case kNESDayMYear:
2313  out << yy << mm << dd
2314  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2315  break;
2316  case kNESMDayYear:
2317  out << yy << mm << dd
2318  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2319  break;
2320  case kNESHex:
2321  { char hex[256];
2322  ULong_t l = GetHexNumber();
2323  IntToHexStr(hex, l);
2324  std::ios::fmtflags f = out.flags(); // store flags
2325  out << "0x" << std::hex << "U"
2326  << ",(TGNumberFormat::EStyle) " << GetNumStyle();
2327  out.flags( f ); // restore flags (reset std::hex)
2328  break;
2329  }
2330  }
2331  if (GetNumMax() ==1) {
2332  if (GetNumMin() == 0) {
2333  if (GetNumLimits() == kNELNoLimits) {
2334  if (GetNumAttr() == kNEAAnyNumber) {
2335  out << ");" << std::endl;
2336  } else {
2337  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr() << ");" << std::endl;
2338  }
2339  } else {
2340  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2341  << ",(TGNumberFormat::ELimit) " << GetNumLimits() << ");" << std::endl;
2342  }
2343  } else {
2344  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2345  << ",(TGNumberFormat::ELimit) " << GetNumLimits()
2346  << "," << GetNumMin() << ");" << std::endl;
2347  }
2348  } else {
2349  out << ",(TGNumberFormat::EAttribute) " << GetNumAttr()
2350  << ",(TGNumberFormat::ELimit) " << GetNumLimits()
2351  << "," << GetNumMin() << "," << GetNumMax() << ");" << std::endl;
2352  }
2353  if (option && strstr(option, "keep_names"))
2354  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
2355  if (!IsEnabled())
2356  out << " " << GetName() << "->SetState(kFALSE);" << std::endl;
2357 
2358  out << " " << GetName() << "->Resize("<< GetWidth() << "," << GetName()
2359  << "->GetDefaultHeight());" << std::endl;
2360 
2361  TGToolTip *tip = GetToolTip();
2362  if (tip) {
2363  TString tiptext = tip->GetText()->GetString();
2364  tiptext.ReplaceAll("\n", "\\n");
2365  out << " ";
2366  out << GetName() << "->SetToolTipText(" << quote
2367  << tiptext << quote << ");" << std::endl;
2368  }
2369 }
kKey_Down
@ kKey_Down
Definition: KeySymbols.h:43
TGNumberFormat::ELimit
ELimit
Definition: TGNumberEntry.h:46
c
#define c(i)
Definition: RSha256.hxx:101
l
auto * l
Definition: textangle.C:4
TGNumberFormat::kNELLimitMax
@ kNELLimitMax
Upper limit only.
Definition: TGNumberEntry.h:49
TGNumberFormat::kNESMinSec
@ kNESMinSec
Minute:seconds.
Definition: TGNumberEntry.h:32
TGClient::GetDefaultRoot
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition: TGClient.cxx:236
TGNumberEntryField::SetHexNumber
virtual void SetHexNumber(ULong_t val)
Set the numeric value (hex format).
Definition: TGNumberEntry.cxx:1225
n
const Int_t n
Definition: legend1.C:16
IntStr
static Long_t IntStr(const char *text)
Definition: TGNumberEntry.cxx:247
CheckMinMax
static void CheckMinMax(Long_t &l, TGNumberFormat::EStyle style, TGNumberFormat::ELimit limits, Double_t min, Double_t max)
Check min/max limits for the set value.
Definition: TGNumberEntry.cxx:756
GET_MSG
Int_t GET_MSG(Long_t val)
Definition: WidgetMessageTypes.h:110
StrToReal
static Double_t StrToReal(const char *text, RealInfo_t &ri)
Definition: TGNumberEntry.cxx:318
TGNumberEntry::ProcessMessage
virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
Process the up/down button messages.
Definition: TGNumberEntry.cxx:2058
TGNumberEntry::GetLayoutManager
virtual TGLayoutManager * GetLayoutManager() const
Return layout manager.
Definition: TGNumberEntry.cxx:2089
TGFrame::GetHeight
UInt_t GetHeight() const
Definition: TGFrame.h:225
IncreaseDate
static void IncreaseDate(Long_t &l, TGNumberFormat::EStepSize step, Int_t sign)
Change year/month/day format.
Definition: TGNumberEntry.cxx:1006
TranslateToNum
static Long_t TranslateToNum(const char *text, TGNumberFormat::EStyle style, RealInfo_t &ri)
Translate a string to a number value.
Definition: TGNumberEntry.cxx:609
TGNumberEntryLayout
Definition: TGNumberEntry.h:280
kKey_Delete
@ kKey_Delete
Definition: KeySymbols.h:33
TRepeatTimer::TRepeatTimer
TRepeatTimer(TGRepeatFireButton *button, Long_t ms)
Definition: TGNumberEntry.cxx:1813
TGWindow
ROOT GUI Window base class.
Definition: TGWindow.h:23
TGNumberEntryField::GetDate
virtual void GetDate(Int_t &year, Int_t &month, Int_t &day) const
Get the numeric value (date format).
Definition: TGNumberEntry.cxx:1339
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
TGNumberEntry::fPicUp
const TGPicture * fPicUp
Up arrow.
Definition: TGNumberEntry.h:156
StrInt
static char * StrInt(char *text, Long_t i, Int_t digits)
Definition: TGNumberEntry.cxx:263
TGTextEntry::SetText
virtual void SetText(const char *text, Bool_t emit=kTRUE)
Sets text entry to text, clears the selection and moves the cursor to the end of the line.
Definition: TGTextEntry.cxx:611
kRSInt
@ kRSInt
Definition: TGNumberEntry.cxx:105
TGRepeatFireButton::SetLogStep
virtual void SetLogStep(Bool_t on=kTRUE)
Definition: TGNumberEntry.cxx:1850
TGNumberFormat::kNELLimitMinMax
@ kNELLimitMinMax
Both lower and upper limits.
Definition: TGNumberEntry.h:50
snprintf
#define snprintf
Definition: civetweb.c:1540
TGNumberFormat::kNESDegree
@ kNESDegree
Degree.
Definition: TGNumberEntry.h:31
TGNumberEntry::~TGNumberEntry
virtual ~TGNumberEntry()
Destructs a numeric entry widget.
Definition: TGNumberEntry.cxx:1996
kEpsilon
const Double_t kEpsilon
Definition: TGNumberEntry.cxx:125
TGPicture
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition: TGPicture.h:25
f
#define f(i)
Definition: RSha256.hxx:104
TGNumberEntry::ValueChanged
virtual void ValueChanged(Long_t val)
Emit ValueChanged(Long_t) signal.
Definition: TGNumberEntry.cxx:2107
MIntToStr
static char * MIntToStr(char *text, Long_t l, Int_t digits)
Definition: TGNumberEntry.cxx:456
TGDimension
Definition: TGDimension.h:18
TGNumberEntryLayout::Layout
virtual void Layout()
Layout the internal GUI elements in use.
Definition: TGNumberEntry.cxx:1761
Option_t
const char Option_t
Definition: RtypesCore.h:66
TGNumberFormat::kNSSMedium
@ kNSSMedium
Medium step.
Definition: TGNumberEntry.h:55
RealInfo_t::fFracBase
Int_t fFracBase
Definition: TGNumberEntry.cxx:116
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TGNumberEntryLayout::GetDefaultSize
virtual TGDimension GetDefaultSize() const
Return the default size of the numeric control box.
Definition: TGNumberEntry.cxx:1789
TGRepeatFireButton::TGRepeatFireButton
TGRepeatFireButton(const TGWindow *p, const TGPicture *pic, Int_t id, Bool_t logstep)
Definition: TGNumberEntry.cxx:1841
TGNumberFormat::kNSSHuge
@ kNSSHuge
Huge step.
Definition: TGNumberEntry.h:57
TGNumberFormat::kNSSSmall
@ kNSSSmall
Step for number entry field increase.
Definition: TGNumberEntry.h:54
TGNumberEntryField::IncreaseNumber
virtual void IncreaseNumber(EStepSize step=kNSSSmall, Int_t sign=1, Bool_t logstep=kFALSE)
Increase the number value.
Definition: TGNumberEntry.cxx:1380
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
GetSignificant
static Long_t GetSignificant(Long_t l, Int_t Max)
Definition: TGNumberEntry.cxx:545
Truncate
static Long_t Truncate(Double_t x)
Definition: TGNumberEntry.cxx:147
kButtonDown
@ kButtonDown
Definition: TGButton.h:54
kKey_Up
@ kKey_Up
Definition: KeySymbols.h:41
TGTextEntry::SetAlignment
virtual void SetAlignment(ETextJustification mode=kTextLeft)
Sets the alignment of the text entry.
Definition: TGTextEntry.cxx:566
TGFrame::GetSize
TGDimension GetSize() const
Definition: TGFrame.h:230
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
kNotifyNormal
@ kNotifyNormal
Definition: GuiTypes.h:219
EKeySym
EKeySym
Definition: KeySymbols.h:25
TGNumberEntry::fButtonToNum
Bool_t fButtonToNum
Send button messages to parent rather than number entry field.
Definition: TGNumberEntry.h:166
TGNumberEntry::Modified
virtual void Modified()
Emit Modified() signal.
Definition: TGNumberEntry.cxx:2128
TGTextEntry::SetState
virtual void SetState(Bool_t state)
Set state of widget. If kTRUE=enabled, kFALSE=disabled.
Definition: TGTextEntry.cxx:498
TGNumberFormat::kNESHourMin
@ kNESHourMin
Hour:minutes.
Definition: TGNumberEntry.h:33
IntToHexStr
static char * IntToHexStr(char *text, ULong_t l)
Definition: TGNumberEntry.cxx:433
HexStrToInt
static ULong_t HexStrToInt(const char *s)
Definition: TGNumberEntry.cxx:418
FontStruct_t
Handle_t FontStruct_t
Pointer to font structure.
Definition: GuiTypes.h:39
TGNumberFormat::kNESRealThree
@ kNESRealThree
Fixed fraction real, three digit.
Definition: TGNumberEntry.h:28
TGNumberFormat::kNEAAnyNumber
@ kNEAAnyNumber
Attributes of number entry field.
Definition: TGNumberEntry.h:41
Long64_t
long long Long64_t
Definition: RtypesCore.h:80
TGToolTip::GetText
const TGString * GetText() const
Get the tool tip text.
Definition: TGToolTip.cxx:430
TGNumberEntryField::fNumStyle
EStyle fNumStyle
Number style.
Definition: TGNumberEntry.h:69
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
TGWindow::kEditDisableLayout
@ kEditDisableLayout
window layout cannot be edited
Definition: TGWindow.h:53
TGNumberEntryField::Layout
virtual void Layout()
Layout.
Definition: TGNumberEntry.cxx:1740
TGCompositeFrame::Cleanup
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition: TGFrame.cxx:967
TGFrame::GetDefaultHeight
virtual UInt_t GetDefaultHeight() const
Definition: TGFrame.h:191
TGRepeatFireButton
Definition: TGNumberEntry.cxx:1830
TGNumberFormat::kNEAPositive
@ kNEAPositive
Positive number.
Definition: TGNumberEntry.h:43
kButtonUp
@ kButtonUp
Definition: TGButton.h:53
TRepeatTimer::Notify
virtual Bool_t Notify()
Notify when timer times out and reset the timer.
Definition: TGNumberEntry.cxx:1938
TGWindow::kEditDisable
@ kEditDisable
disable edit of this window
Definition: TGWindow.h:50
RealInfo_t::fFracNum
Int_t fFracNum
Definition: TGNumberEntry.cxx:118
TGTextEntry::fFontStruct
FontStruct_t fFontStruct
text font
Definition: TGTextEntry.h:41
TGRepeatFireButton::IsEditableParent
Bool_t IsEditableParent()
Return kTRUE if one of the parents is in edit mode.
Definition: TGNumberEntry.cxx:1856
TGNumberFormat::kNEANonNegative
@ kNEANonNegative
Non-negative number.
Definition: TGNumberEntry.h:42
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162
TGNumberEntryField::TGNumberEntryField
TGNumberEntryField(const TGWindow *p, Int_t id, Double_t val, GContext_t norm, FontStruct_t font=GetDefaultFontStruct(), UInt_t option=kSunkenFrame|kDoubleBorder, Pixel_t back=GetWhitePixel())
Constructs a number entry field.
Definition: TGNumberEntry.cxx:1081
Int_t
int Int_t
Definition: RtypesCore.h:45
TGNumberEntryField::InvalidInput
virtual void InvalidInput(const char *instr)
Definition: TGNumberEntry.h:139
TGNumberEntryField::GetCharWidth
virtual Int_t GetCharWidth(const char *text="0") const
Get the text width in pixels.
Definition: TGNumberEntry.cxx:1372
TGNumberEntryField::fNumAttr
EAttribute fNumAttr
Number attribute.
Definition: TGNumberEntry.h:70
TGNumberFormat::kNESReal
@ kNESReal
Real number.
Definition: TGNumberEntry.h:30
TGNumberEntryField::SetDate
virtual void SetDate(Int_t year, Int_t month, Int_t day)
Set the numeric value (date format).
Definition: TGNumberEntry.cxx:1206
event
Definition: triangle.c:553
x
Double_t x[n]
Definition: legend1.C:17
TGWindow::kEditDisableHeight
@ kEditDisableHeight
window height cannot be edited
Definition: TGWindow.h:55
TGToolTip
Definition: TGToolTip.h:24
TGRepeatFireButton::fTimer
TRepeatTimer * fTimer
Definition: TGNumberEntry.cxx:1832
kKeyMod1Mask
const Mask_t kKeyMod1Mask
typically the Alt key
Definition: GuiTypes.h:198
TGNumberFormat::kNESRealTwo
@ kNESRealTwo
Fixed fraction real, two digit.
Definition: TGNumberEntry.h:27
TGNumberEntry::TGNumberEntry
TGNumberEntry(const TGNumberEntry &)=delete
TGRepeatFireButton::fIgnoreNextFire
Int_t fIgnoreNextFire
Definition: TGNumberEntry.cxx:1833
TVirtualX.h
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TGNumberEntryField::SetNumber
virtual void SetNumber(Double_t val)
Set the numeric value (floating point representation).
Definition: TGNumberEntry.cxx:1115
TGTextEntry::GetBuffer
TGTextBuffer * GetBuffer() const
Definition: TGTextEntry.h:112
TGNumberEntryField::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save a number entry widget as a C++ statement(s) on output stream out.
Definition: TGNumberEntry.cxx:2256
TGNumberEntry::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Definition: TGNumberEntry.h:260
TTimer.h
kFocusOut
@ kFocusOut
Definition: GuiTypes.h:61
RealToDouble
static Double_t RealToDouble(const RealInfo_t ri)
Convert to double format.
Definition: TGNumberEntry.cxx:729
kNotifyPointer
@ kNotifyPointer
Definition: GuiTypes.h:220
TString
Basic string class.
Definition: TString.h:136
ERealStyle
ERealStyle
Definition: TGNumberEntry.cxx:104
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TGNumberEntryField::fNumMax
Double_t fNumMax
Upper limit.
Definition: TGNumberEntry.h:73
TGNumberFormat::kNESRealFour
@ kNESRealFour
Fixed fraction real, four digit.
Definition: TGNumberEntry.h:29
TGNumberEntryLayout::fBox
TGNumberEntry * fBox
Definition: TGNumberEntry.h:282
text
TText * text
Definition: entrylist_figure1.C:10
TSystem::AddTimer
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition: TSystem.cxx:473
bool
TString::ReplaceAll
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
StringInt
static TString StringInt(Long_t i, Int_t digits)
Definition: TGNumberEntry.cxx:279
TGTextBuffer
A text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc.
Definition: TGTextBuffer.h:19
TGFrame::GetWidth
UInt_t GetWidth() const
Definition: TGFrame.h:224
id
XFontStruct * id
Definition: TGX11.cxx:109
TTimer::fTime
TTime fTime
Definition: TTimer.h:54
TGNumberEntryField::HandleFocusChange
virtual Bool_t HandleFocusChange(Event_t *event)
Handle focus change.
Definition: TGNumberEntry.cxx:1696
TGLayoutManager
Frame layout manager.
Definition: TGLayout.h:135
IncreaseReal
static void IncreaseReal(RealInfo_t &ri, Double_t mag, Bool_t logstep, TGNumberFormat::ELimit limits=TGNumberFormat::kNELNoLimits, Double_t min=0, Double_t max=1)
Convert to double format.
Definition: TGNumberEntry.cxx:837
TGNumberFormat::EStepSize
EStepSize
Definition: TGNumberEntry.h:53
GContext_t
Handle_t GContext_t
Graphics context handle.
Definition: GuiTypes.h:38
gClient
#define gClient
Definition: TGClient.h:157
TGNumberEntryField::IsLogStep
virtual Bool_t IsLogStep() const
Definition: TGNumberEntry.h:129
style
TCanvas * style()
Definition: style.C:1
TGNumberFormat::kNESRealOne
@ kNESRealOne
Fixed fraction real, one digit.
Definition: TGNumberEntry.h:26
TGNumberEntryField::SetText
virtual void SetText(const char *text, Bool_t emit=kTRUE)
Set the value (text format).
Definition: TGNumberEntry.cxx:1233
TTimer
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
kDays
const Int_t kDays[13]
Definition: TGNumberEntry.cxx:129
kRSFrac
@ kRSFrac
Definition: TGNumberEntry.cxx:106
TGRepeatFireButton::FireButton
void FireButton()
Process messages for fire button.
Definition: TGNumberEntry.cxx:1925
TGNumberEntry::fButtonUp
TGButton * fButtonUp
Button for increasing value.
Definition: TGNumberEntry.h:164
TGTextEntry::GetAlignment
ETextJustification GetAlignment() const
Definition: TGTextEntry.h:111
EliminateGarbage
static char * EliminateGarbage(char *text, TGNumberFormat::EStyle style, TGNumberFormat::EAttribute attr)
Definition: TGNumberEntry.cxx:230
TGWindow::kEditDisableGrab
@ kEditDisableGrab
window grab cannot be edited
Definition: TGWindow.h:52
TGNumberEntry::fNumericEntry
TGNumberEntryField * fNumericEntry
Number text entry field.
Definition: TGNumberEntry.h:163
TGNumberEntryField::SetLogStep
virtual void SetLogStep(Bool_t on=kTRUE)
Definition: TGNumberEntry.h:110
TGNumberFormat::kNESMDayYear
@ kNESMDayYear
Month/day/year.
Definition: TGNumberEntry.h:36
TGNumberFormat::kNESDayMYear
@ kNESDayMYear
Day/month/year.
Definition: TGNumberEntry.h:35
TSystem.h
TGNumberEntry::GetHexNumber
virtual ULong_t GetHexNumber() const
Definition: TGNumberEntry.h:209
TGTextEntry::ReturnPressed
virtual void ReturnPressed()
This signal is emitted when the return or enter key is pressed.
Definition: TGTextEntry.cxx:393
h
#define h(i)
Definition: RSha256.hxx:106
TGNumberFormat
Definition: TGNumberEntry.h:22
TGWidget::WidgetId
Int_t WidgetId() const
Definition: TGWidget.h:68
TGWidget::fMsgWindow
const TGWindow * fMsgWindow
window which handles widget events
Definition: TGWidget.h:48
TGTextEntry::GetToolTip
virtual TGToolTip * GetToolTip() const
Definition: TGTextEntry.h:120
TGWindow::GetName
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:336
DIntToStr
static char * DIntToStr(char *text, Long_t l, Bool_t Sec, char Del)
Definition: TGNumberEntry.cxx:489
TGCompositeFrame::MapSubwindows
virtual void MapSubwindows()
Map all sub windows that are part of the composite frame.
Definition: TGFrame.cxx:1164
TGWidget::Associate
virtual void Associate(const TGWindow *w)
Definition: TGWidget.h:72
kMaxLong
const Long_t kMaxLong
Definition: RtypesCore.h:116
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:605
TGNumberEntryField::SetTime
virtual void SetTime(Int_t hour, Int_t min, Int_t sec)
Set the numeric value (time format).
Definition: TGNumberEntry.cxx:1183
TGNumberEntry::fPicDown
const TGPicture * fPicDown
Down arrow.
Definition: TGNumberEntry.h:157
TGTextEntry
A TGTextEntry is a one line text input widget.
Definition: TGTextEntry.h:24
RealInfo_t
Definition: TGNumberEntry.cxx:113
TGFrame::SendMessage
virtual void SendMessage(const TGWindow *w, Long_t msg, Long_t parm1, Long_t parm2)
Send message (i.e.
Definition: TGFrame.cxx:645
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
TMath::Sign
T1 Sign(T1 a, T2 b)
Definition: TMathBase.h:165
TGNumberFormat::kNESHex
@ kNESHex
Hex.
Definition: TGNumberEntry.h:37
TGRepeatFireButton::~TGRepeatFireButton
virtual ~TGRepeatFireButton()
Definition: TGNumberEntry.cxx:1846
kButtonPress
@ kButtonPress
Definition: GuiTypes.h:60
kCM_BUTTON
@ kCM_BUTTON
Definition: WidgetMessageTypes.h:34
TGNumberEntryField::GetNumber
virtual Double_t GetNumber() const
Get the numeric value (floating point representation).
Definition: TGNumberEntry.cxx:1245
Long_t
long Long_t
Definition: RtypesCore.h:54
IsGoodChar
static Bool_t IsGoodChar(char c, TGNumberFormat::EStyle style, TGNumberFormat::EAttribute attr)
Definition: TGNumberEntry.cxx:167
TGButton::fTip
TGToolTip * fTip
tool tip associated with button
Definition: TGButton.h:79
TGWidget::IsEnabled
Bool_t IsEnabled() const
Definition: TGWidget.h:69
TMath::Power
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:735
TTimer::Remove
void Remove()
Definition: TTimer.h:85
TGNumberEntryField::HandleKey
virtual Bool_t HandleKey(Event_t *event)
Handle keys.
Definition: TGNumberEntry.cxx:1612
TGTextEntry::End
void End(Bool_t mark=kFALSE)
Moves the text cursor to the right end of the line.
Definition: TGTextEntry.cxx:1003
TGNumberEntry::GetNumLimits
virtual ELimit GetNumLimits() const
Definition: TGNumberEntry.h:230
TGClient::GetPicture
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition: TGClient.cxx:291
kRSFracExpo
@ kRSFracExpo
Definition: TGNumberEntry.cxx:108
TGNumberEntry::fButtonDown
TGButton * fButtonDown
Button for decreasing value.
Definition: TGNumberEntry.h:165
TGNumberEntryField::SetState
virtual void SetState(Bool_t state)
Set the active state.
Definition: TGNumberEntry.cxx:1600
TGTextEntry::HandleKey
virtual Bool_t HandleKey(Event_t *event)
The key press event handler converts a key press to some line editor action.
Definition: TGTextEntry.cxx:1216
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TRepeatTimer::fButton
TGRepeatFireButton * fButton
Definition: TGNumberEntry.cxx:1810
TGNumberEntry::GetNumAttr
virtual EAttribute GetNumAttr() const
Definition: TGNumberEntry.h:227
y
Double_t y[n]
Definition: legend1.C:17
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:55
TGNumberEntryField::TextChanged
virtual void TextChanged(const char *text=0)
Text has changed message.
Definition: TGNumberEntry.cxx:1711
TTimer::SetTime
void SetTime(Long_t milliSec)
Definition: TTimer.h:90
KeySymbols.h
TGNumberEntryField
Definition: TGNumberEntry.h:65
TGTextEntry::TextChanged
virtual void TextChanged(const char *text=nullptr)
This signal is emitted every time the text has changed.
Definition: TGTextEntry.cxx:423
RealInfo_t::fStyle
ERealStyle fStyle
Definition: TGNumberEntry.cxx:114
RealToStr
static char * RealToStr(char *text, const RealInfo_t &ri)
Definition: TGNumberEntry.cxx:288
TGCompositeFrame::SetLayoutManager
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition: TGFrame.cxx:1000
TGeant4Unit::mm
static constexpr double mm
Definition: TGeant4SystemOfUnits.h:108
RealInfo_t::fExpoNum
Int_t fExpoNum
Definition: TGNumberEntry.cxx:119
TGNumberEntry::GetTime
virtual void GetTime(Int_t &hour, Int_t &min, Int_t &sec) const
Definition: TGNumberEntry.h:203
unsigned int
TGNumberEntry::SetLogStep
virtual void SetLogStep(Bool_t on=kTRUE)
Set log steps.
Definition: TGNumberEntry.cxx:2016
TGButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set button state.
Definition: TGButton.cxx:235
TGTextEntry::HandleFocusChange
virtual Bool_t HandleFocusChange(Event_t *event)
Handle focus change event in text entry widget.
Definition: TGTextEntry.cxx:1454
RealInfo_t::fFracDigits
Int_t fFracDigits
Definition: TGNumberEntry.cxx:115
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
RealInfo_t::fSign
Int_t fSign
Definition: TGNumberEntry.cxx:120
kKeyControlMask
const Mask_t kKeyControlMask
Definition: GuiTypes.h:197
IsLeapYear
static Bool_t IsLeapYear(Int_t year)
Definition: TGNumberEntry.cxx:160
TGNumberEntry::GetButtonUp
TGButton * GetButtonUp() const
Definition: TGNumberEntry.h:263
TGWindow::GetParent
const TGWindow * GetParent() const
Definition: TGWindow.h:76
TGWidget::fWidgetId
Int_t fWidgetId
the widget id (used for event processing)
Definition: TGWidget.h:46
TGNumberEntry::GetDate
virtual void GetDate(Int_t &year, Int_t &month, Int_t &day) const
Definition: TGNumberEntry.h:206
Double_t
double Double_t
Definition: RtypesCore.h:59
TQObject::Connect
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot.
Definition: TQObject.cxx:869
TGRepeatFireButton::fDoLogStep
Bool_t fDoLogStep
Definition: TGNumberEntry.cxx:1836
TGNumberEntryField::GetNumStyle
virtual EStyle GetNumStyle() const
Definition: TGNumberEntry.h:114
TGTextEntry::Home
void Home(Bool_t mark=kFALSE)
Moves the text cursor to the left end of the line.
Definition: TGTextEntry.cxx:983
TGPictureButton
Yield an action as soon as it is clicked.
Definition: TGButton.h:228
MakeDateNumber
static Long_t MakeDateNumber(const char *, Long_t Day, Long_t Month, Long_t Year)
Create a number entry with year/month/day information.
Definition: TGNumberEntry.cxx:582
TGObject::fClient
TGClient * fClient
Connection to display server.
Definition: TGObject.h:27
TGFrame::MoveResize
virtual void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0)
Move and/or resize the frame.
Definition: TGFrame.cxx:629
TGNumberEntryField::GetHexNumber
virtual ULong_t GetHexNumber() const
Get the numeric value (hex format).
Definition: TGNumberEntry.cxx:1364
TGNumberEntryField::GetIntNumber
virtual Long_t GetIntNumber() const
Get the numeric value (integer representation).
Definition: TGNumberEntry.cxx:1286
TranslateToStr
static char * TranslateToStr(char *text, Long_t l, TGNumberFormat::EStyle style, const RealInfo_t &ri)
Translate a number value to a string.
Definition: TGNumberEntry.cxx:678
kC_COMMAND
@ kC_COMMAND
Definition: WidgetMessageTypes.h:31
TGRepeatFireButton::fStepLog
Bool_t fStepLog
Definition: TGNumberEntry.cxx:1835
AppendFracZero
static void AppendFracZero(char *text, Int_t digits)
Definition: TGNumberEntry.cxx:555
TGNumberEntryField::GetNumAttr
virtual EAttribute GetNumAttr() const
Definition: TGNumberEntry.h:117
TGCompositeFrame::fLayoutManager
TGLayoutManager * fLayoutManager
layout manager
Definition: TGFrame.h:291
kRSExpo
@ kRSExpo
Definition: TGNumberEntry.cxx:107
kKey_Backspace
@ kKey_Backspace
Definition: KeySymbols.h:29
TGButton::GetState
virtual EButtonState GetState() const
Definition: TGButton.h:112
TGToolTip.h
TGNumberEntry::GetNumStyle
virtual EStyle GetNumStyle() const
Definition: TGNumberEntry.h:224
TGButton::fState
EButtonState fState
button state
Definition: TGButton.h:75
TGRepeatFireButton::fStep
TGNumberFormat::EStepSize fStep
Definition: TGNumberEntry.cxx:1834
TGNumberEntryField::GetNumMax
virtual Double_t GetNumMax() const
Definition: TGNumberEntry.h:126
TGNumberEntryField::SetFormat
virtual void SetFormat(EStyle style, EAttribute attr=kNEAAnyNumber)
Set the numerical format.
Definition: TGNumberEntry.cxx:1570
Event_t
Event structure.
Definition: GuiTypes.h:174
GET_SUBMSG
Int_t GET_SUBMSG(Long_t val)
Definition: WidgetMessageTypes.h:111
TGNumberEntry::Associate
virtual void Associate(const TGWindow *w)
Make w the window that will receive the generated messages.
Definition: TGNumberEntry.cxx:2007
TGNumberFormat::kNELNoLimits
@ kNELNoLimits
Limit selection of number entry field.
Definition: TGNumberEntry.h:47
TGNumberEntryField::GetNumMin
virtual Double_t GetNumMin() const
Definition: TGNumberEntry.h:123
TGNumberEntry::SetButtonToNum
virtual void SetButtonToNum(Bool_t state)
Send button messages to the number field (true) or parent widget (false).
Definition: TGNumberEntry.cxx:2046
d
#define d(i)
Definition: RSha256.hxx:102
Round
static Long_t Round(Double_t x)
Definition: TGNumberEntry.cxx:134
TGTextEntry::GetText
const char * GetText() const
Definition: TGTextEntry.h:119
TGNumberFormat::kNELLimitMin
@ kNELLimitMin
Lower limit only.
Definition: TGNumberEntry.h:48
kMaxInt
const Int_t kMaxInt
Definition: RtypesCore.h:112
TGString::GetString
const char * GetString() const
Definition: TGString.h:30
TGNumberEntry::GetIntNumber
virtual Long_t GetIntNumber() const
Definition: TGNumberEntry.h:200
TGNumberEntryField::GetNumLimits
virtual ELimit GetNumLimits() const
Definition: TGNumberEntry.h:120
TGNumberEntry.h
TGNumberEntry::GetNumber
virtual Double_t GetNumber() const
Definition: TGNumberEntry.h:197
RealInfo_t::fIntNum
Int_t fIntNum
Definition: TGNumberEntry.cxx:117
TGNumberEntryField::GetTime
virtual void GetTime(Int_t &hour, Int_t &min, Int_t &sec) const
Get the numeric value (time format).
Definition: TGNumberEntry.cxx:1295
TGeant4Unit::ms
static constexpr double ms
Definition: TGeant4SystemOfUnits.h:163
kTextRight
@ kTextRight
Definition: TGWidget.h:24
TGNumberEntryField::fNumLimits
ELimit fNumLimits
Limit attributes.
Definition: TGNumberEntry.h:71
TGNumberEntry
TGNumberEntry is a number entry input widget with up/down buttons.
Definition: TGNumberEntry.h:148
TGNumberEntryField::ReturnPressed
virtual void ReturnPressed()
Return was pressed.
Definition: TGNumberEntry.cxx:1720
TGRepeatFireButton::HandleButton
virtual Bool_t HandleButton(Event_t *event)
Handle messages for number entry widget according to the user input.
Definition: TGNumberEntry.cxx:1872
GetNumbers
static void GetNumbers(const char *s, Int_t &Sign, Long_t &n1, Int_t maxd1, Long_t &n2, Int_t maxd2, Long_t &n3, Int_t maxd3, const char *Delimiters)
Definition: TGNumberEntry.cxx:509
TGNumberEntryField::fStepLog
Bool_t fStepLog
Logarithmic steps for increase?
Definition: TGNumberEntry.h:74
TGWindow::fEditDisabled
UInt_t fEditDisabled
flags used for "guibuilding"
Definition: TGWindow.h:32
TGNumberFormat::kNESHourMinSec
@ kNESHourMinSec
Hour:minute:seconds.
Definition: TGNumberEntry.h:34
TGNumberFormat::EAttribute
EAttribute
Definition: TGNumberEntry.h:40
Class
void Class()
Definition: Class.C:29
TGNumberEntryField::SetLimits
virtual void SetLimits(ELimit limits=kNELNoLimits, Double_t min=0, Double_t max=1)
Set the numerical limits.
Definition: TGNumberEntry.cxx:1585
TGWindow::IsEditable
virtual Bool_t IsEditable() const
Definition: TGWindow.h:104
TRepeatTimer
Definition: TGNumberEntry.cxx:1808
TGCompositeFrame
The base class for composite widgets (menu bars, list boxes, etc.).
Definition: TGFrame.h:287
TTimer::Reset
void Reset()
Reset the timer.
Definition: TTimer.cxx:157
TGToolTip::Hide
void Hide()
Hide tool tip window.
Definition: TGToolTip.cxx:250
TGNumberFormat::kNSSLarge
@ kNSSLarge
Large step.
Definition: TGNumberEntry.h:56
TGNumberEntry::SetState
virtual void SetState(Bool_t enable=kTRUE)
Set the active state.
Definition: TGNumberEntry.cxx:2026
TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1117
TMath::E
constexpr Double_t E()
Base of natural log:
Definition: TMath.h:96
TGNumberEntry::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save a number entry widget as a C++ statement(s) on output stream out.
Definition: TGNumberEntry.cxx:2136
TGNumberFormat::EStyle
EStyle
Definition: TGNumberEntry.h:24
TGNumberEntry::GetNumMax
virtual Double_t GetNumMax() const
Definition: TGNumberEntry.h:236
TGNumberEntry::ValueSet
virtual void ValueSet(Long_t val)
Emit ValueSet(Long_t) signal.
Definition: TGNumberEntry.cxx:2119
MK_MSG
Int_t MK_MSG(EWidgetMessageTypes msg, EWidgetMessageTypes submsg)
Definition: WidgetMessageTypes.h:108
TGNumberEntryField::SetIntNumber
virtual void SetIntNumber(Long_t val)
Set the numeric value (integer representation).
Definition: TGNumberEntry.cxx:1168
TGWindow::fParent
const TGWindow * fParent
Parent window.
Definition: TGWindow.h:28
TGNumberEntryField::fNumMin
Double_t fNumMin
Lower limit.
Definition: TGNumberEntry.h:72
TGNumberEntry::GetButtonDown
TGButton * GetButtonDown() const
Definition: TGNumberEntry.h:266
kKeyShiftMask
const Mask_t kKeyShiftMask
Definition: GuiTypes.h:195
kButtonDisabled
@ kButtonDisabled
Definition: TGButton.h:56
TGNumberFormat::kNESInteger
@ kNESInteger
Style of number entry field.
Definition: TGNumberEntry.h:25
TGNumberEntry::GetNumMin
virtual Double_t GetNumMin() const
Definition: TGNumberEntry.h:233
TGTextBuffer::GetString
const char * GetString() const
Definition: TGTextBuffer.h:34
TQObject::Emit
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
TMath.h
int
TGNumberEntryField::fNeedsVerification
Bool_t fNeedsVerification
Needs verification of input.
Definition: TGNumberEntry.h:68