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