Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TFunctionParametersDialog.cxx
Go to the documentation of this file.
1// @(#)root/ged:$Id$
2// Author: Ilka Antcheva 08/05/06
3
4/*************************************************************************
5 * Copyright (C) 1995-2006, 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/** \class TFunctionParametersDialog
13 \ingroup ged
14
15This class is used for function parameter settings.
16
17*/
18
19#include "TFunctionParametersDialog.h"
20#include "TTimer.h"
21#include "TList.h"
22#include "TF1.h"
23#include "TGButton.h"
24#include "TGFrame.h"
25#include "TGLabel.h"
26#include "TGLayout.h"
27#include "TGTextEntry.h"
28#include "TGMsgBox.h"
29#include "TGNumberEntry.h"
30#include "TGTripleSlider.h"
31#include "TVirtualPad.h"
32
33
34enum EParametersDialogWid {
35 kNAME,
36 kFIX = 10,
37 kVAL = 20,
38 kMIN = 30,
39 kMAX = 40,
40 kSLD = 50,
41 kUPDATE = 8888,
42 kRESET,
43 kAPPLY,
44 kOK,
45 kCANCEL
46};
47
48ClassImp(TFunctionParametersDialog);
49
50////////////////////////////////////////////////////////////////////////////////
51/// Create the parameters' dialog of currently selected function 'func'.
52
53TFunctionParametersDialog::TFunctionParametersDialog(const TGWindow *p,
54 const TGWindow *main,
55 TF1 *func,
56 TVirtualPad *pad,
57 Double_t rx, Double_t ry) :
58 TGTransientFrame(p, main, 10, 10, kVerticalFrame)
59{
60 fFunc = func;
61 fFpad = pad;
62 fRXmin = rx;
63 fRXmax = ry;
64 fFunc->GetRange(fRangexmin, fRangexmax);
65 fNP = fFunc->GetNpar();
66 fHasChanges = kFALSE;
67 fPmin = new Double_t[fNP];
68 fPmax = new Double_t[fNP];
69 fPval = new Double_t[fNP];
70 fPerr = new Double_t[fNP];
71
72 for (Int_t i = 0; i < fNP; i++) {
73 fFunc->GetParLimits(i, fPmin[i], fPmax[i]);
74 fPval[i] = fFunc->GetParameter(i);
75 fPerr[i] = fFunc->GetParError(i);
76 }
77 fParNam = new TGTextEntry*[fNP];
78 fParFix = new TGCheckButton*[fNP];
79 fParVal = new TGNumberEntry*[fNP];
80 fParMin = new TGNumberEntryField*[fNP];
81 fParMax = new TGNumberEntryField*[fNP];
82 fParSld = new TGTripleHSlider*[fNP];
83
84 memset(fParNam, 0, sizeof(TGTextEntry*)*fNP);
85 memset(fParFix, 0, sizeof(TGCheckButton*)*fNP);
86 memset(fParVal, 0, sizeof(TGNumberEntry*)*fNP);
87 memset(fParMin, 0, sizeof(TGNumberEntryField*)*fNP);
88 memset(fParMax, 0, sizeof(TGNumberEntryField*)*fNP);
89 memset(fParMax, 0, sizeof(TGTripleHSlider*)*fNP);
90
91 TGCompositeFrame *f1 = new TGCompositeFrame(this, 80, 20, kHorizontalFrame);
92 AddFrame(f1, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
93
94 // column 'Name'
95 fContNam = new TGCompositeFrame(f1, 80, 20, kVerticalFrame | kFixedWidth);
96 fContNam->AddFrame(new TGLabel(fContNam,"Name"),
97 new TGLayoutHints(kLHintsTop, 5, 0, 0, 0));
98 for (Int_t i = 0; i < fNP; i++ ) {
99 fParNam[i] = new TGTextEntry(fContNam, new TGTextBuffer(80), kNAME+i);
100 fParNam[i]->SetText(Form("%s", fFunc->GetParName(i)));
101 fParNam[i]->SetEnabled(kFALSE);
102 fContNam->AddFrame(fParNam[i],
103 new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 5));
104 }
105 f1->AddFrame(fContNam, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
106
107 // column 'Fix'
108 fContFix = new TGCompositeFrame(f1, 20, 20, kVerticalFrame | kFixedWidth);
109 fContFix->AddFrame(new TGLabel(fContFix,"Fix"),
110 new TGLayoutHints(kLHintsTop, 2, 0, 0, 0));
111 for (Int_t i = 0; i < fNP; i++ ) {
112 fParFix[i] = new TGCheckButton(fContFix, "", kFIX*fNP+i);
113 fParFix[i]->SetToolTipText(Form("Set %s to fixed", fFunc->GetParName(i)));
114 fContFix->AddFrame(fParFix[i], new TGLayoutHints(kLHintsLeft | kLHintsCenterY,
115 5, 5, 10, 7));
116 if ((fPmin[i] == fPmax[i]) && (fPmin[i] || fPmax[i]))
117 fParFix[i]->SetState(kButtonDown);
118 else
119 fParFix[i]->SetState(kButtonUp);
120 fParFix[i]->Connect("Toggled(Bool_t)", "TFunctionParametersDialog", this, "DoFix(Bool_t)");
121 }
122 f1->AddFrame(fContFix, new TGLayoutHints(kLHintsLeft, 5, 5, 5, 5));
123
124 // column 'Value'
125 fContVal = new TGCompositeFrame(f1, 80, 20, kVerticalFrame | kFixedWidth);
126 fContVal->AddFrame(new TGLabel(fContVal,"Value"),
127 new TGLayoutHints(kLHintsTop, 5, 0, 0, 0));
128 for (Int_t i = 0; i < fNP; i++ ) {
129 fParVal[i] = new TGNumberEntry(fContVal, 1.2E-12, 15, kVAL*fNP+i,
130 TGNumberFormat::kNESReal);
131 fParVal[i]->SetNumber(fPval[i]);
132 fParVal[i]->SetFormat(TGNumberFormat::kNESReal, TGNumberFormat::kNEAAnyNumber); //tbs
133 fContVal->AddFrame(fParVal[i], new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 5));
134 (fParVal[i]->GetNumberEntry())->SetToolTipText(Form("%s", fFunc->GetParName(i)));
135 (fParVal[i]->GetNumberEntry())->Connect("ReturnPressed()", "TFunctionParametersDialog",
136 this, "DoParValue()");
137 fParVal[i]->Connect("ValueSet(Long_t)", "TFunctionParametersDialog", this, "DoParValue()");
138 }
139 f1->AddFrame(fContVal, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
140
141 // column 'Min'
142 fContMin = new TGCompositeFrame(f1, 80, 20, kVerticalFrame | kFixedWidth);
143 fContMin->AddFrame(new TGLabel(fContMin,"Min"),
144 new TGLayoutHints(kLHintsTop, 5, 0, 0, 0));
145 for (Int_t i = 0; i < fNP; i++ ) {
146 fParMin[i] = new TGNumberEntryField(fContMin, kMIN*fNP+i, 0.0,
147 TGNumberFormat::kNESReal,
148 TGNumberFormat::kNEAAnyNumber);
149 ((TGTextEntry*)fParMin[i])->SetToolTipText(Form("Lower limit of %s",
150 fFunc->GetParName(i)));
151 fContMin->AddFrame(fParMin[i], new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 5));
152 if (fPmin[i])
153 fParMin[i]->SetNumber(fPmin[i]);
154 else if (fPerr[i])
155 fParMin[i]->SetNumber(fPval[i]-3*fPerr[i]);
156 else if (fPval[i])
157 fParMin[i]->SetNumber(fPval[i]-0.1*fPval[i]);
158 else
159 fParMin[i]->SetNumber(1.0);
160 fParMin[i]->Connect("ReturnPressed()", "TFunctionParametersDialog", this, "DoParMinLimit()");
161 }
162 f1->AddFrame(fContMin, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
163
164 // column 'Set Range'
165 fContSld = new TGCompositeFrame(f1, 120, 20, kVerticalFrame | kFixedWidth);
166 fContSld->AddFrame(new TGLabel(fContSld,"Set Range"),
167 new TGLayoutHints(kLHintsTop, 5, 0, 0, 0));
168 for (Int_t i = 0; i < fNP; i++ ) {
169 fParSld[i] = new TGTripleHSlider(fContSld, 100, kDoubleScaleBoth, kSLD*fNP+i,
170 kHorizontalFrame, GetDefaultFrameBackground(),
171 kFALSE, kFALSE, kFALSE, kFALSE);
172 fContSld->AddFrame(fParSld[i], new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
173 fParSld[i]->SetConstrained(kTRUE);
174 }
175 f1->AddFrame(fContSld, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
176
177 // column 'Max'
178 fContMax = new TGCompositeFrame(f1, 80, 20, kVerticalFrame);
179 fContMax->AddFrame(new TGLabel(fContMax,"Max"),
180 new TGLayoutHints(kLHintsTop, 5, 0, 0, 0));
181 for (Int_t i = 0; i < fNP; i++ ) {
182 fParMax[i] = new TGNumberEntryField(fContMax, kMAX*fNP+i, 0.0,
183 TGNumberFormat::kNESReal,
184 TGNumberFormat::kNEAAnyNumber);
185 ((TGTextEntry*)fParMax[i])->SetToolTipText(Form("Upper limit of %s",
186 fFunc->GetParName(i)));
187 fContMax->AddFrame(fParMax[i], new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 5));
188 if (fPmax[i])
189 fParMax[i]->SetNumber(fPmax[i]);
190 else if (fPerr[i])
191 fParMax[i]->SetNumber(fPval[i]+3*fPerr[i]);
192 else if (fPval[i])
193 fParMax[i]->SetNumber(fPval[i]+0.1*fPval[i]);
194 else
195 fParMax[i]->SetNumber(1.0);
196 if (fParMax[i]->GetNumber() < fParMin[i]->GetNumber()){
197 Double_t temp;
198 temp = fParMax[i]->GetNumber();
199 fParMax[i]->SetNumber(fParMin[i]->GetNumber());
200 fParMin[i]->SetNumber(temp);
201 }
202 fParMax[i]->Connect("ReturnPressed()", "TFunctionParametersDialog", this, "DoParMaxLimit()");
203 }
204 f1->AddFrame(fContMax, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
205
206
207 fUpdate = new TGCheckButton(this, "&Immediate preview", kUPDATE);
208 fUpdate->SetToolTipText("Immediate function redrawing");
209 AddFrame(fUpdate, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 5, 5, 5));
210 fUpdate->Connect("Toggled(Bool_t)", "TFunctionParametersDialog", this, "HandleButtons(Bool_t)");
211
212 TGCompositeFrame *f2 = new TGCompositeFrame(this, 270, 20, kHorizontalFrame | kFixedWidth);
213 AddFrame(f2, new TGLayoutHints(kLHintsRight, 20, 20, 5, 1));
214
215 fReset = new TGTextButton(f2, "&Reset", kRESET);
216 f2->AddFrame(fReset, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,5,5,5,5));
217 fReset->SetToolTipText("Reset the parameter settings");
218 fReset->SetState(kButtonDisabled);
219 fReset->Connect("Clicked()", "TFunctionParametersDialog", this, "DoReset()");
220
221 fApply = new TGTextButton(f2, "&Apply", kAPPLY);
222 f2->AddFrame(fApply, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,5,5,5,5));
223 fApply->SetState(kButtonDisabled);
224 fApply->Connect("Clicked()", "TFunctionParametersDialog", this, "DoApply()");
225 fApply->SetToolTipText("Apply parameter settings and redraw the function");
226
227 fOK = new TGTextButton(f2, "&OK", kOK);
228 f2->AddFrame(fOK, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,5,5,5,5));
229 fOK->SetToolTipText("Apply parameter settings, redraw function and close this dialog");
230 fOK->Connect("Clicked()", "TFunctionParametersDialog", this, "DoOK()");
231
232 fCancel = new TGTextButton(f2, "&Cancel", kCANCEL);
233 f2->AddFrame(fCancel, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,5,5,5,5));
234 fCancel->SetToolTipText("Close this dialog with no parameter changes");
235 fCancel->Connect("Clicked()", "TFunctionParametersDialog", this, "DoCancel()");
236
237 MapSubwindows();
238 Resize(GetDefaultSize());
239 CenterOnParent(kFALSE, kBottomLeft);
240 SetWindowName(Form("Set Parameters of %s", fFunc->GetTitle()));
241 MapWindow();
242
243 for (Int_t i = 0; i < fNP; i++ ) {
244 if (fParFix[i]->GetState() == kButtonDown) {
245 fParVal[i]->SetState(kFALSE);
246 fParMin[i]->SetEnabled(kFALSE);
247 fParMax[i]->SetEnabled(kFALSE);
248 fParSld[i]->UnmapWindow();
249 } else {
250 fParSld[i]->SetRange(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
251 fParSld[i]->SetPosition(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
252 fParSld[i]->SetPointerPosition(fPval[i]);
253 fParSld[i]->Connect("PointerPositionChanged()", "TFunctionParametersDialog",
254 this, "DoSlider()");
255 fParSld[i]->Connect("PositionChanged()", "TFunctionParametersDialog",
256 this, "DoSlider()");
257 }
258 }
259
260 gClient->WaitFor(this);
261}
262
263////////////////////////////////////////////////////////////////////////////////
264/// Destructor.
265
266TFunctionParametersDialog::~TFunctionParametersDialog()
267{
268 TGFrameElement *el;
269 TIter next(GetList());
270
271 while ((el = (TGFrameElement *)next())) {
272 if (!strcmp(el->fFrame->ClassName(), "TGCompositeFrame")) {
273 TGFrameElement *el1;
274 TIter next1(((TGCompositeFrame *)el->fFrame)->GetList());
275 while ((el1 = (TGFrameElement *)next1())) {
276 if (!strcmp(el1->fFrame->ClassName(), "TGCompositeFrame"))
277 ((TGCompositeFrame *)el1->fFrame)->Cleanup();
278 }
279 ((TGCompositeFrame *)el->fFrame)->Cleanup();
280 }
281 }
282 Cleanup();
283 delete [] fPval;
284 delete [] fPmin;
285 delete [] fPmax;
286 delete [] fPerr;
287}
288
289////////////////////////////////////////////////////////////////////////////////
290/// Close parameters' dialog.
291
292void TFunctionParametersDialog::CloseWindow()
293{
294 if (fHasChanges) {
295 Int_t ret;
296 const char *txt;
297 txt = "Do you want to apply last parameters' setting?";
298 new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
299 "Parameters Have Been Changed", txt, kMBIconExclamation,
300 kMBYes | kMBNo | kMBCancel, &ret);
301 if (ret == kMBYes) {
302 DoOK();
303 return;
304 } else if (ret == kMBNo) {
305 DoReset();
306 } else return;
307 }
308 DeleteWindow();
309}
310
311////////////////////////////////////////////////////////////////////////////////
312/// Slot related to the Cancel button.
313
314void TFunctionParametersDialog::DoCancel()
315{
316 if (fHasChanges)
317 DoReset();
318 TTimer::SingleShot(50, "TFunctionParametersDialog", this, "CloseWindow()");
319}
320
321////////////////////////////////////////////////////////////////////////////////
322/// Slot related to the Fix check button.
323
324void TFunctionParametersDialog::DoFix(Bool_t on)
325{
326 fReset->SetState(kButtonUp);
327 TGButton *bt = (TGButton *) gTQSender;
328 Int_t id = bt->WidgetId();
329 fHasChanges = kTRUE;
330 for (Int_t i = 0; i < fNP; i++ ) {
331 if (id == kFIX*fNP+i) {
332 if (on) {
333 if (fParVal[i]->GetNumber() != 0) {
334 fParMin[i]->SetNumber(fParVal[i]->GetNumber());
335 fParMin[i]->SetEnabled(kFALSE);
336 fParMax[i]->SetNumber(fParVal[i]->GetNumber());
337 fParMax[i]->SetEnabled(kFALSE);
338 } else {
339 fParMin[i]->SetNumber(1.);
340 fParMin[i]->SetEnabled(kFALSE);
341 fParMax[i]->SetNumber(1.);
342 fParMax[i]->SetEnabled(kFALSE);
343 }
344 fParVal[i]->SetState(kFALSE);
345 fParSld[i]->Disconnect("PointerPositionChanged()");
346 fParSld[i]->Disconnect("PositionChanged()");
347 fParSld[i]->UnmapWindow();
348 fFunc->FixParameter(i, fParVal[i]->GetNumber());
349 } else if (!fParMin[i]->IsEnabled()) {
350 if (fPmin[i] != fPmax[i]) {
351 if (fPmin[i])
352 fParMin[i]->SetNumber(fPmin[i]);
353 else if (fPerr[i])
354 fParMin[i]->SetNumber(fPval[i]-3*fPerr[i]);
355 else if (fPval[i])
356 fParMin[i]->SetNumber(fPval[i]-0.1*fPval[i]);
357 else
358 fParMin[i]->SetNumber(1.0);
359 if (fPmax[i])
360 fParMax[i]->SetNumber(fPmax[i]);
361 else if (fPerr[i])
362 fParMax[i]->SetNumber(fPval[i]+3*fPerr[i]);
363 else if (fPval[i])
364 fParMax[i]->SetNumber(fPval[i]+0.1*fPval[i]);
365 else
366 fParMax[i]->SetNumber(1.0);
367 } else if (fPval[i]) {
368 fParMin[i]->SetNumber(fPval[i]-0.1*fPval[i]);
369 fParMax[i]->SetNumber(fPval[i]+0.1*fPval[i]);
370 } else {
371 fParMin[i]->SetNumber(1.0);
372 fParMax[i]->SetNumber(1.0);
373 }
374 if (fParMax[i]->GetNumber() < fParMin[i]->GetNumber()){
375 Double_t temp;
376 temp = fParMax[i]->GetNumber();
377 fParMax[i]->SetNumber(fParMin[i]->GetNumber());
378 fParMin[i]->SetNumber(temp);
379 }
380 fParMax[i]->SetEnabled(kTRUE);
381 fParMin[i]->SetEnabled(kTRUE);
382 fParSld[i]->MapWindow();
383 fParVal[i]->SetState(kTRUE);
384 fParSld[i]->SetRange(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
385 fParSld[i]->SetPosition(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
386 fParSld[i]->SetPointerPosition(fPval[i]);
387 fParSld[i]->Connect("PointerPositionChanged()", "TFunctionParametersDialog",
388 this, "DoSlider()");
389 fParSld[i]->Connect("PositionChanged()", "TFunctionParametersDialog",
390 this, "DoSlider()");
391 fFunc->SetParLimits(i, fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
392 }
393 }
394 }
395 if (fUpdate->GetState() == kButtonDown)
396 RedrawFunction();
397 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
398 fApply->SetState(kButtonUp);
399}
400
401////////////////////////////////////////////////////////////////////////////////
402/// Slot related to the OK button.
403
404void TFunctionParametersDialog::DoOK()
405{
406 if (fHasChanges)
407 RedrawFunction();
408 fFunc->SetRange(fRangexmin, fRangexmax);
409 TTimer::SingleShot(50, "TFunctionParametersDialog", this, "CloseWindow()");
410}
411
412////////////////////////////////////////////////////////////////////////////////
413/// Slot related to the Preview button.
414
415void TFunctionParametersDialog::DoApply()
416{
417 RedrawFunction();
418 fApply->SetState(kButtonDisabled);
419 if (fReset->GetState() == kButtonDisabled)
420 fReset->SetState(kButtonUp);
421}
422
423////////////////////////////////////////////////////////////////////////////////
424/// Slot related to the Reset button.
425
426void TFunctionParametersDialog::DoReset()
427{
428 fHasChanges = kTRUE;
429 Int_t k = fNP;
430 for (Int_t i = 0; i < fNP; i++) {
431 if (fParVal[i]->GetNumber() == fPval[i])
432 k--;
433 else
434 break;
435 }
436
437 if (!k) {
438 if (fReset->GetState() == kButtonUp)
439 fReset->SetState(kButtonDisabled);
440 fHasChanges = kFALSE;
441 return;
442 }
443 for (Int_t i = 0; i < fNP; i++) {
444 fFunc->SetParameter(i, fPval[i]);
445 fFunc->SetParLimits(i, fPmin[i], fPmax[i]);
446 fFunc->SetParError(i, fPerr[i]);
447
448 if (fPmin[i])
449 fParMin[i]->SetNumber(fPmin[i]);
450 else if (fPerr[i])
451 fParMin[i]->SetNumber(fPval[i]-3*fPerr[i]);
452 else if (fPval[i])
453 fParMin[i]->SetNumber(fPval[i]-0.1*fPval[i]);
454 else
455 fParMin[i]->SetNumber(1.0);
456
457 if (fPmax[i])
458 fParMax[i]->SetNumber(fPmax[i]);
459 else if (fPerr[i])
460 fParMax[i]->SetNumber(fPval[i]+3*fPerr[i]);
461 else if (fPval[i])
462 fParMax[i]->SetNumber(fPval[i]+0.1*fPval[i]);
463 else
464 fParMax[i]->SetNumber(1.0);
465 if (fParMax[i]->GetNumber() < fParMin[i]->GetNumber()){
466 Double_t temp;
467 temp = fParMax[i]->GetNumber();
468 fParMax[i]->SetNumber(fParMin[i]->GetNumber());
469 fParMin[i]->SetNumber(temp);
470 }
471 if (fParMin[i]->GetNumber() == fParMax[i]->GetNumber()) {
472 fParVal[i]->SetState(kFALSE);
473 fParMin[i]->SetEnabled(kFALSE);
474 fParMax[i]->SetEnabled(kFALSE);
475 fParSld[i]->Disconnect("PointerPositionChanged()");
476 fParSld[i]->Disconnect("PositionChanged()");
477 fParSld[i]->UnmapWindow();
478 fFunc->FixParameter(i, fParVal[i]->GetNumber());
479 fParFix[i]->SetState(kButtonDown);
480 } else {
481 fParFix[i]->SetState(kButtonUp);
482 if (!fParMax[i]->IsEnabled()) {
483 fParMax[i]->SetEnabled(kTRUE);
484 fParMin[i]->SetEnabled(kTRUE);
485 fParVal[i]->SetState(kTRUE);
486 fParSld[i]->SetRange(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
487 fParSld[i]->SetPosition(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
488 fParSld[i]->SetPointerPosition(fPval[i]);
489 fParSld[i]->MapWindow();
490 fParSld[i]->Connect("PointerPositionChanged()", "TFunctionParametersDialog",
491 this, "DoSlider()");
492 fParSld[i]->Connect("PositionChanged()", "TFunctionParametersDialog",
493 this, "DoSlider()");
494 }
495 }
496 fParVal[i]->SetNumber(fPval[i]);
497
498 fParSld[i]->SetRange(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
499 fParSld[i]->SetPosition(fParMin[i]->GetNumber(), fParMax[i]->GetNumber());
500 fParSld[i]->SetPointerPosition(fPval[i]);
501 }
502
503 if (fUpdate->GetState() == kButtonDown)
504 RedrawFunction();
505 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
506 fApply->SetState(kButtonUp);
507 fHasChanges = kFALSE;
508 fReset->SetState(kButtonDisabled);
509}
510
511////////////////////////////////////////////////////////////////////////////////
512/// Slot related to the parameters' value settings.
513
514void TFunctionParametersDialog::DoSlider()
515{
516 TGTripleHSlider *sl = (TGTripleHSlider *) gTQSender;
517 Int_t id = sl->WidgetId();
518
519 fHasChanges = kTRUE;
520 for (Int_t i = 0; i < fNP; i++ ) {
521 if (id == kSLD*fNP+i) {
522 fFunc->SetParameter(i,fParSld[i]->GetPointerPosition());
523 fFunc->SetParLimits(i,fParSld[i]->GetMinPosition(),
524 fParSld[i]->GetMaxPosition());
525 fParMin[i]->SetNumber(fParSld[i]->GetMinPosition());
526 fParMax[i]->SetNumber(fParSld[i]->GetMaxPosition());
527 fParVal[i]->SetNumber(fParSld[i]->GetPointerPosition());
528 }
529 }
530 if (fUpdate->GetState() == kButtonDown)
531 RedrawFunction();
532 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
533 fApply->SetState(kButtonUp);
534 if (fReset->GetState() == kButtonDisabled)
535 fReset->SetState(kButtonUp);
536}
537
538////////////////////////////////////////////////////////////////////////////////
539/// Slot related to the parameter value settings.
540
541void TFunctionParametersDialog::DoParValue()
542{
543 TGNumberEntry *ne = (TGNumberEntry *) gTQSender;
544 Int_t id = ne->WidgetId();
545
546 for (Int_t i = 0; i < fNP; i++ ) {
547 if (id == kVAL*fNP+i) {
548 fParSld[i]->SetPointerPosition(fParVal[i]->GetNumber());
549 if (fParVal[i]->GetNumber() < fParMin[i]->GetNumber()) {
550 fParMin[i]->SetNumber(fParVal[i]->GetNumber());
551 fClient->NeedRedraw(fParMin[i]);
552 fParSld[i]->SetRange(fParMin[i]->GetNumber(),
553 fParMax[i]->GetNumber());
554 fParSld[i]->SetPosition(fParMin[i]->GetNumber(),
555 fParMax[i]->GetNumber());
556 }
557 if (fParVal[i]->GetNumber() > fParMax[i]->GetNumber()) {
558 fParMax[i]->SetNumber(fParVal[i]->GetNumber());
559 fClient->NeedRedraw(fParMax[i]);
560 fParSld[i]->SetRange(fParMin[i]->GetNumber(),
561 fParMax[i]->GetNumber());
562 fParSld[i]->SetPosition(fParMin[i]->GetNumber(),
563 fParMax[i]->GetNumber());
564 }
565 fClient->NeedRedraw(fParSld[i]);
566 fFunc->SetParameter(i,fParSld[i]->GetPointerPosition());
567 fFunc->SetParLimits(i,fParSld[i]->GetMinPosition(),
568 fParSld[i]->GetMaxPosition());
569 }
570 }
571 fHasChanges = kTRUE;
572 if (fUpdate->GetState() == kButtonDown)
573 RedrawFunction();
574 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
575 fApply->SetState(kButtonUp);
576 if (fReset->GetState() == kButtonDisabled)
577 fReset->SetState(kButtonUp);
578}
579
580////////////////////////////////////////////////////////////////////////////////
581/// Slot related to the minumum parameter limit settings.
582
583void TFunctionParametersDialog::DoParMinLimit()
584{
585 TGNumberEntryField *ne = (TGNumberEntryField *) gTQSender;
586 Int_t id = ne->WidgetId();
587
588 for (Int_t i = 0; i < fNP; i++ ) {
589 if (id == kMIN*fNP+i) {
590 if (fParMin[i]->GetNumber() > fParMax[i]->GetNumber()) {
591 Int_t ret;
592 const char *txt;
593 txt = "The lower parameter bound cannot be bigger then the upper one.";
594 new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
595 "Parameter Limits", txt, kMBIconExclamation,kMBOk,&ret);
596 fParMin[i]->SetNumber(fParVal[i]->GetNumber());
597 return;
598 }
599 fParSld[i]->SetRange(fParMin[i]->GetNumber(),
600 fParMax[i]->GetNumber());
601 fParSld[i]->SetPosition(fParMin[i]->GetNumber(),
602 fParMax[i]->GetNumber());
603 fParSld[i]->SetPointerPosition(fParVal[i]->GetNumber());
604 fClient->NeedRedraw(fParSld[i]);
605 }
606 }
607 fHasChanges = kTRUE;
608 if (fUpdate->GetState() == kButtonDown)
609 RedrawFunction();
610 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
611 fApply->SetState(kButtonUp);
612 if (fReset->GetState() == kButtonDisabled)
613 fReset->SetState(kButtonUp);
614}
615
616////////////////////////////////////////////////////////////////////////////////
617/// Slot related to the maximum parameter limit settings.
618
619void TFunctionParametersDialog::DoParMaxLimit()
620{
621 TGNumberEntryField *ne = (TGNumberEntryField *) gTQSender;
622 Int_t id = ne->WidgetId();
623
624 for (Int_t i = 0; i < fNP; i++ ) {
625 if (id == kMAX*fNP+i) {
626 if (fParMin[i]->GetNumber() > fParMax[i]->GetNumber()) {
627 Int_t ret;
628 const char *txt;
629 txt = "The lower parameter bound cannot be bigger then the upper one.";
630 new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
631 "Parameter Limits", txt, kMBIconExclamation,kMBOk,&ret);
632 fParMax[i]->SetNumber(fParVal[i]->GetNumber());
633 return;
634 }
635 fParSld[i]->SetRange(fParMin[i]->GetNumber(),
636 fParMax[i]->GetNumber());
637 fParSld[i]->SetPosition(fParMin[i]->GetNumber(),
638 fParMax[i]->GetNumber());
639 fParSld[i]->SetPointerPosition(fParVal[i]->GetNumber());
640 fClient->NeedRedraw(fParSld[i]);
641 }
642 }
643 fHasChanges = kTRUE;
644 if (fUpdate->GetState() == kButtonDown)
645 RedrawFunction();
646 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges)
647 fApply->SetState(kButtonUp);
648 if (fReset->GetState() == kButtonDisabled)
649 fReset->SetState(kButtonUp);
650}
651
652////////////////////////////////////////////////////////////////////////////////
653/// Redraw function graphics.
654
655void TFunctionParametersDialog::RedrawFunction()
656{
657 TString opt = fFunc->GetDrawOption();
658 opt.ToUpper();
659 if (!opt.Contains("SAME"))
660 opt += "SAME";
661 fFunc->SetRange(fRXmin, fRXmax);
662 fFunc->Draw(opt);
663 fFpad->Modified();
664 fFpad->Update();
665 fHasChanges = kFALSE;
666}
667
668////////////////////////////////////////////////////////////////////////////////
669/// Handle the button dependent states in this dialog.
670
671void TFunctionParametersDialog::HandleButtons(Bool_t update)
672{
673 if (update && fHasChanges)
674 RedrawFunction();
675 else if ((fApply->GetState() == kButtonDisabled) && fHasChanges) {
676 fApply->SetState(kButtonUp);
677 }
678}
kVerticalFrame
@ kVerticalFrame
Definition GuiTypes.h:381
kFixedWidth
@ kFixedWidth
Definition GuiTypes.h:387
kHorizontalFrame
@ kHorizontalFrame
Definition GuiTypes.h:382
main
int main()
Definition Prototype.cxx:12
update
static void update(gsl_integration_workspace *workspace, double a1, double b1, double area1, double error1, double a2, double b2, double area2, double error2)
Definition RooAdaptiveGaussKronrodIntegrator1D.cxx:652
kFALSE
const Bool_t kFALSE
Definition RtypesCore.h:101
Double_t
double Double_t
Definition RtypesCore.h:59
kTRUE
const Bool_t kTRUE
Definition RtypesCore.h:100
ClassImp
#define ClassImp(name)
Definition Rtypes.h:364
kButtonDown
@ kButtonDown
Definition TGButton.h:54
kButtonDisabled
@ kButtonDisabled
Definition TGButton.h:56
kButtonUp
@ kButtonUp
Definition TGButton.h:53
gClient
#define gClient
Definition TGClient.h:157
kDoubleScaleBoth
@ kDoubleScaleBoth
Definition TGDoubleSlider.h:32
kLHintsRight
@ kLHintsRight
Definition TGLayout.h:26
kLHintsLeft
@ kLHintsLeft
Definition TGLayout.h:24
kLHintsCenterY
@ kLHintsCenterY
Definition TGLayout.h:28
kLHintsTop
@ kLHintsTop
Definition TGLayout.h:27
kLHintsExpandX
@ kLHintsExpandX
Definition TGLayout.h:30
kMBNo
@ kMBNo
Definition TGMsgBox.h:32
kMBYes
@ kMBYes
Definition TGMsgBox.h:31
kMBCancel
@ kMBCancel
Definition TGMsgBox.h:37
kMBOk
@ kMBOk
Definition TGMsgBox.h:33
kMBIconExclamation
@ kMBIconExclamation
Definition TGMsgBox.h:24
gTQSender
R__EXTERN void * gTQSender
Definition TQObject.h:46
Form
char * Form(const char *fmt,...)
TF1
1-Dim function class
Definition TF1.h:213
TF1::SetParError
virtual void SetParError(Int_t ipar, Double_t error)
Set error for parameter number ipar.
Definition TF1.cxx:3493
TF1::GetParLimits
virtual void GetParLimits(Int_t ipar, Double_t &parmin, Double_t &parmax) const
Return limits for parameter ipar.
Definition TF1.cxx:1936
TF1::GetParError
virtual Double_t GetParError(Int_t ipar) const
Return value of parameter number ipar.
Definition TF1.cxx:1926
TF1::SetRange
virtual void SetRange(Double_t xmin, Double_t xmax)
Initialize the upper and lower bounds to draw the function.
Definition TF1.cxx:3539
TF1::GetNpar
virtual Int_t GetNpar() const
Definition TF1.h:481
TF1::GetRange
virtual void GetRange(Double_t *xmin, Double_t *xmax) const
Return range of a generic N-D function.
Definition TF1.cxx:2275
TF1::GetParName
virtual const char * GetParName(Int_t ipar) const
Definition TF1.h:529
TF1::SetParLimits
virtual void SetParLimits(Int_t ipar, Double_t parmin, Double_t parmax)
Set limits for parameter ipar.
Definition TF1.cxx:3518
TF1::Draw
virtual void Draw(Option_t *option="")
Draw this function with its current attributes.
Definition TF1.cxx:1328
TF1::SetParameter
virtual void SetParameter(Int_t param, Double_t value)
Definition TF1.h:634
TF1::FixParameter
virtual void FixParameter(Int_t ipar, Double_t value)
Fix the value of a parameter The specified value will be used in a fit operation.
Definition TF1.cxx:1553
TF1::GetParameter
virtual Double_t GetParameter(Int_t ipar) const
Definition TF1.h:512
TFunctionParametersDialog
This class is used for function parameter settings.
Definition TFunctionParametersDialog.h:29
TFunctionParametersDialog::fContMin
TGCompositeFrame * fContMin
container of min range values
Definition TFunctionParametersDialog.h:47
TFunctionParametersDialog::fPmax
Double_t * fPmax
max limits of patameters range
Definition TFunctionParametersDialog.h:36
TFunctionParametersDialog::fParMin
TGNumberEntryField ** fParMin
min range values
Definition TFunctionParametersDialog.h:52
TFunctionParametersDialog::DoApply
virtual void DoApply()
Slot related to the Preview button.
Definition TFunctionParametersDialog.cxx:415
TFunctionParametersDialog::fContNam
TGCompositeFrame * fContNam
container of parameter names
Definition TFunctionParametersDialog.h:43
TFunctionParametersDialog::fApply
TGTextButton * fApply
Apply button.
Definition TFunctionParametersDialog.h:56
TFunctionParametersDialog::fPerr
Double_t * fPerr
original patameters' errors
Definition TFunctionParametersDialog.h:38
TFunctionParametersDialog::DoReset
virtual void DoReset()
Slot related to the Reset button.
Definition TFunctionParametersDialog.cxx:426
TFunctionParametersDialog::CloseWindow
virtual void CloseWindow()
Close parameters' dialog.
Definition TFunctionParametersDialog.cxx:292
TFunctionParametersDialog::RedrawFunction
virtual void RedrawFunction()
Redraw function graphics.
Definition TFunctionParametersDialog.cxx:655
TFunctionParametersDialog::fParFix
TGCheckButton ** fParFix
fix setting check buttons
Definition TFunctionParametersDialog.h:50
TFunctionParametersDialog::fParMax
TGNumberEntryField ** fParMax
max range values
Definition TFunctionParametersDialog.h:53
TFunctionParametersDialog::fFunc
TF1 * fFunc
function passed to this dialog
Definition TFunctionParametersDialog.h:32
TFunctionParametersDialog::fNP
Int_t fNP
number of function parameters
Definition TFunctionParametersDialog.h:34
TFunctionParametersDialog::~TFunctionParametersDialog
virtual ~TFunctionParametersDialog()
Destructor.
Definition TFunctionParametersDialog.cxx:266
TFunctionParametersDialog::DoFix
virtual void DoFix(Bool_t on)
Slot related to the Fix check button.
Definition TFunctionParametersDialog.cxx:324
TFunctionParametersDialog::fParNam
TGTextEntry ** fParNam
parameter names
Definition TFunctionParametersDialog.h:49
TFunctionParametersDialog::DoParMinLimit
virtual void DoParMinLimit()
Slot related to the minumum parameter limit settings.
Definition TFunctionParametersDialog.cxx:583
TFunctionParametersDialog::fRangexmin
Double_t fRangexmin
min limits of patameters range
Definition TFunctionParametersDialog.h:39
TFunctionParametersDialog::fOK
TGTextButton * fOK
Cancel button.
Definition TFunctionParametersDialog.h:58
TFunctionParametersDialog::TFunctionParametersDialog
TFunctionParametersDialog(const TGWindow *p, const TGWindow *main, TF1 *func, TVirtualPad *pad, Double_t rmin, Double_t rmax)
Create the parameters' dialog of currently selected function 'func'.
Definition TFunctionParametersDialog.cxx:53
TFunctionParametersDialog::DoOK
virtual void DoOK()
Slot related to the OK button.
Definition TFunctionParametersDialog.cxx:404
TFunctionParametersDialog::fRXmax
Double_t fRXmax
original max range
Definition TFunctionParametersDialog.h:42
TFunctionParametersDialog::fContVal
TGCompositeFrame * fContVal
container of parameter values
Definition TFunctionParametersDialog.h:44
TFunctionParametersDialog::fPmin
Double_t * fPmin
min limits of patameters range
Definition TFunctionParametersDialog.h:35
TFunctionParametersDialog::DoParMaxLimit
virtual void DoParMaxLimit()
Slot related to the maximum parameter limit settings.
Definition TFunctionParametersDialog.cxx:619
TFunctionParametersDialog::HandleButtons
virtual void HandleButtons(Bool_t update)
Handle the button dependent states in this dialog.
Definition TFunctionParametersDialog.cxx:671
TFunctionParametersDialog::fParSld
TGTripleHSlider ** fParSld
triple sliders
Definition TFunctionParametersDialog.h:54
TFunctionParametersDialog::fPval
Double_t * fPval
original patameters' values
Definition TFunctionParametersDialog.h:37
TFunctionParametersDialog::fUpdate
TGCheckButton * fUpdate
Immediate update check button.
Definition TFunctionParametersDialog.h:55
TFunctionParametersDialog::fCancel
TGTextButton * fCancel
Cancel button.
Definition TFunctionParametersDialog.h:59
TFunctionParametersDialog::DoSlider
virtual void DoSlider()
Slot related to the parameters' value settings.
Definition TFunctionParametersDialog.cxx:514
TFunctionParametersDialog::fContMax
TGCompositeFrame * fContMax
container of max range values
Definition TFunctionParametersDialog.h:48
TFunctionParametersDialog::fRangexmax
Double_t fRangexmax
max limits of patameters range
Definition TFunctionParametersDialog.h:40
TFunctionParametersDialog::fHasChanges
Bool_t fHasChanges
kTRUE if function was redrawn;
Definition TFunctionParametersDialog.h:60
TFunctionParametersDialog::fContSld
TGCompositeFrame * fContSld
container of sliders
Definition TFunctionParametersDialog.h:46
TFunctionParametersDialog::fParVal
TGNumberEntry ** fParVal
parameter values
Definition TFunctionParametersDialog.h:51
TFunctionParametersDialog::fReset
TGTextButton * fReset
Reset button.
Definition TFunctionParametersDialog.h:57
TFunctionParametersDialog::fFpad
TVirtualPad * fFpad
pad where the function is drawn
Definition TFunctionParametersDialog.h:33
TFunctionParametersDialog::DoCancel
virtual void DoCancel()
Slot related to the Cancel button.
Definition TFunctionParametersDialog.cxx:314
TFunctionParametersDialog::DoParValue
virtual void DoParValue()
Slot related to the parameter value settings.
Definition TFunctionParametersDialog.cxx:541
TFunctionParametersDialog::fContFix
TGCompositeFrame * fContFix
container of fix settings
Definition TFunctionParametersDialog.h:45
TFunctionParametersDialog::fRXmin
Double_t fRXmin
original min range
Definition TFunctionParametersDialog.h:41
TGButton
A button abstract base class.
Definition TGButton.h:68
TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition TGButton.cxx:445
TGButton::GetState
virtual EButtonState GetState() const
Definition TGButton.h:112
TGButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set button state.
Definition TGButton.cxx:235
TGCheckButton
Selects different options.
Definition TGButton.h:264
TGCheckButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set check button state.
Definition TGButton.cxx:1250
TGClient::GetRoot
const TGWindow * GetRoot() const
Returns current root (i.e.
Definition TGClient.cxx:224
TGClient::NeedRedraw
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition TGClient.cxx:372
TGCompositeFrame
The base class for composite widgets (menu bars, list boxes, etc.).
Definition TGFrame.h:287
TGCompositeFrame::GetList
virtual TList * GetList() const
Definition TGFrame.h:310
TGCompositeFrame::GetState
Int_t GetState(TGFrame *f) const
Get state of sub frame.
Definition TGFrame.cxx:1218
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
TGCompositeFrame::Cleanup
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition TGFrame.cxx:967
TGCompositeFrame::GetDefaultSize
virtual TGDimension GetDefaultSize() const
std::cout << fWidth << "x" << fHeight << std::endl;
Definition TGFrame.h:316
TGCompositeFrame::MapSubwindows
virtual void MapSubwindows()
Map all sub windows that are part of the composite frame.
Definition TGFrame.cxx:1164
TGDoubleSlider::GetMaxPosition
virtual Float_t GetMaxPosition() const
Definition TGDoubleSlider.h:103
TGDoubleSlider::SetRange
virtual void SetRange(Float_t min, Float_t max)
Definition TGDoubleSlider.h:80
TGDoubleSlider::SetPosition
virtual void SetPosition(Float_t min, Float_t max)
Definition TGDoubleSlider.h:90
TGFrameElement::fFrame
TGFrame * fFrame
Definition TGLayout.h:112
TGFrame::GetDefaultFrameBackground
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition TGFrame.cxx:683
TGFrame::DeleteWindow
virtual void DeleteWindow()
Delete window.
Definition TGFrame.cxx:276
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition TGFrame.cxx:605
TGFrame::MapWindow
virtual void MapWindow()
map window
Definition TGFrame.h:204
TGFrame::UnmapWindow
virtual void UnmapWindow()
unmap window
Definition TGFrame.h:206
TGLabel
This class handles GUI labels.
Definition TGLabel.h:24
TGLayoutHints
This class describes layout hints used by the layout classes.
Definition TGLayout.h:50
TGMainFrame::SetWindowName
void SetWindowName(const char *name=0)
Set window name. This is typically done via the window manager.
Definition TGFrame.cxx:1788
TGNumberEntryField::SetNumber
virtual void SetNumber(Double_t val, Bool_t emit=kTRUE)
Set the numeric value (floating point representation).
Definition TGNumberEntry.cxx:1115
TGNumberEntryField::GetNumber
virtual Double_t GetNumber() const
Get the numeric value (floating point representation).
Definition TGNumberEntry.cxx:1244
TGNumberEntry
TGNumberEntry is a number entry input widget with up/down buttons.
Definition TGNumberEntry.h:148
TGNumberEntry::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Definition TGNumberEntry.h:260
TGNumberEntry::SetState
virtual void SetState(Bool_t enable=kTRUE)
Set the active state.
Definition TGNumberEntry.cxx:2025
TGNumberEntry::SetFormat
virtual void SetFormat(EStyle style, EAttribute attr=TGNumberFormat::kNEAAnyNumber)
Definition TGNumberEntry.h:216
TGNumberEntry::SetNumber
virtual void SetNumber(Double_t val, Bool_t emit=kTRUE)
Definition TGNumberEntry.h:177
TGNumberFormat::kNEAAnyNumber
@ kNEAAnyNumber
Attributes of number entry field.
Definition TGNumberEntry.h:41
TGNumberFormat::kNESReal
@ kNESReal
Real number.
Definition TGNumberEntry.h:30
TGObject::fClient
TGClient * fClient
Connection to display server.
Definition TGObject.h:27
TGTextBuffer
A text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc.
Definition TGTextBuffer.h:19
TGTextButton
Yield an action as soon as it is clicked.
Definition TGButton.h:142
TGTextEntry
A TGTextEntry is a one line text input widget.
Definition TGTextEntry.h:24
TGTextEntry::SetEnabled
void SetEnabled(Bool_t flag=kTRUE)
Definition TGTextEntry.h:149
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
TGTransientFrame
Defines transient windows that typically are used for dialogs windows.
Definition TGFrame.h:499
TGTransientFrame::CenterOnParent
virtual void CenterOnParent(Bool_t croot=kTRUE, EPlacement pos=kCenter)
Position transient frame centered relative to the parent frame.
Definition TGFrame.cxx:1955
TGTripleHSlider
TripleSlider inherit from DoubleSlider widgets and allow easy selection of a min, max and pointer val...
Definition TGTripleSlider.h:73
TGTripleHSlider::SetPointerPosition
virtual void SetPointerPosition(Double_t pos)
Set pointer position in scaled (real) value.
Definition TGTripleSlider.cxx:643
TGTripleHSlider::SetConstrained
virtual void SetConstrained(Bool_t on=kTRUE)
Set pointer position constrained in the slider range.
Definition TGTripleSlider.cxx:569
TGWidget::WidgetId
Int_t WidgetId() const
Definition TGWidget.h:68
TGWindow
ROOT GUI Window base class.
Definition TGWindow.h:23
TGWindow::GetMainFrame
virtual const TGWindow * GetMainFrame() const
Returns top level main frame.
Definition TGWindow.cxx:152
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition TNamed.h:48
TObject::ClassName
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:200
TObject::GetDrawOption
virtual Option_t * GetDrawOption() const
Get option used by the graphics system to draw this object.
Definition TObject.cxx:413
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
TQObject::Disconnect
Bool_t Disconnect(const char *signal=0, void *receiver=0, const char *slot=0)
Disconnects signal of this object from slot of receiver.
Definition TQObject.cxx:1027
TString
Basic string class.
Definition TString.h:136
TString::ToUpper
void ToUpper()
Change string to upper case.
Definition TString.cxx:1163
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:624
TTimer::SingleShot
static void SingleShot(Int_t milliSec, const char *receiver_class, void *receiver, const char *method)
This static function calls a slot after a given time interval.
Definition TTimer.cxx:256
TVirtualPad
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
TVirtualPad::Modified
virtual void Modified(Bool_t flag=1)=0
TVirtualPad::Update
virtual void Update()=0
f1
TF1 * f1
Definition legend1.C:11