Logo ROOT  
Reference Guide
TCanvas.cxx
Go to the documentation of this file.
1// @(#)root/gpad:$Id$
2// Author: Rene Brun 12/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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#include <cstring>
13#include <cstdlib>
14#include <iostream>
15#include <fstream>
16
17#include "TROOT.h"
18#include "TBuffer.h"
19#include "TCanvas.h"
20#include "TCanvasImp.h"
21#include "TDatime.h"
22#include "TClass.h"
23#include "TStyle.h"
24#include "TBox.h"
25#include "TCanvasImp.h"
26#include "TDialogCanvas.h"
27#include "TGuiFactory.h"
28#include "TEnv.h"
29#include "TError.h"
30#include "TContextMenu.h"
31#include "TControlBar.h"
32#include "TInterpreter.h"
33#include "TApplication.h"
34#include "TColor.h"
35#include "TObjArray.h"
36#include "TVirtualPadEditor.h"
37#include "TVirtualViewer3D.h"
38#include "TPadPainter.h"
39#include "TVirtualGL.h"
40#include "TVirtualPS.h"
41#include "TVirtualX.h"
42#include "TAxis.h"
43#include "TH1.h"
44#include "TGraph.h"
45#include "TMath.h"
46#include "TView.h"
47#include "strlcpy.h"
48#include "snprintf.h"
49
50#include "TVirtualMutex.h"
51
53public:
56
57//*-*x16 macros/layout_canvas
58
60
62
64
65
66/** \class TCanvas
67\ingroup gpad
68
69The Canvas class.
70
71A Canvas is an area mapped to a window directly under the control of the display
72manager. A ROOT session may have several canvases open at any given time.
73
74A Canvas may be subdivided into independent graphical areas: the __Pads__.
75A canvas has a default pad which has the name of the canvas itself.
76An example of a Canvas layout is sketched in the picture below.
77
78\image html gpad_canvas.png
79
80This canvas contains two pads named P1 and P2. Both Canvas, P1 and P2 can be
81moved, grown, shrunk using the normal rules of the Display manager.
82
83Once objects have been drawn in a canvas, they can be edited/moved by pointing
84directly to them. The cursor shape is changed to suggest the type of action that
85one can do on this object. Clicking with the right mouse button on an object
86pops-up a contextmenu with a complete list of actions possible on this object.
87
88A graphical editor may be started from the canvas "View" menu under the menu
89entry "Toolbar".
90
91An interactive HELP is available by clicking on the HELP button at the top right
92of the canvas. It gives a short explanation about the canvas' menus.
93
94A canvas may be automatically divided into pads via `TPad::Divide`.
95
96At creation time, no matter if in interactive or batch mode, the canvas size
97defines the size of the canvas window (including the size of the window
98manager's decoration). To define precisely the graphics area size of a canvas in
99the interactive mode, the following four lines of code should be used:
100~~~ {.cpp}
101 {
102 Double_t w = 600;
103 Double_t h = 600;
104 auto c = new TCanvas("c", "c", w, h);
105 c->SetWindowSize(w + (w - c->GetWw()), h + (h - c->GetWh()));
106 }
107~~~
108and in the batch mode simply do:
109~~~ {.cpp}
110 c->SetCanvasSize(w,h);
111~~~
112
113If the canvas size this exceed the window size, scroll bars will be added to the canvas
114This allows to display very large canvases (even bigger than the screen size). The
115Following example shows how to proceed.
116~~~ {.cpp}
117 {
118 auto c = new TCanvas("c","c");
119 c->SetCanvasSize(1500, 1500);
120 c->SetWindowSize(500, 500);
121 }
122~~~
123*/
124
125////////////////////////////////////////////////////////////////////////////////
126/// Canvas default constructor.
127
128TCanvas::TCanvas(Bool_t build) : TPad(), fDoubleBuffer(0)
129{
130 fPainter = 0;
131 fWindowTopX = 0;
132 fWindowTopY = 0;
133 fWindowWidth = 0;
134 fWindowHeight = 0;
135 fCw = 0;
136 fCh = 0;
137 fXsizeUser = 0;
138 fYsizeUser = 0;
139 fXsizeReal = kDefaultCanvasSize;
140 fYsizeReal = kDefaultCanvasSize;
141 fHighLightColor = gEnv->GetValue("Canvas.HighLightColor", kRed);
142 fEvent = -1;
143 fEventX = -1;
144 fEventY = -1;
145 fSelectedX = 0;
146 fSelectedY = 0;
147 fRetained = kTRUE;
148 fDrawn = kFALSE;
149 fSelected = 0;
150 fClickSelected = 0;
151 fSelectedPad = 0;
152 fClickSelectedPad = 0;
153 fPadSave = 0;
154 fCanvasImp = 0;
155 fContextMenu = 0;
156
157 fUseGL = gStyle->GetCanvasPreferGL();
158
159 if (!build || TClass::IsCallingNew() != TClass::kRealNew) {
160 Constructor();
161 } else {
162 const char *defcanvas = gROOT->GetDefCanvasName();
163 TString cdef;
164
165 auto lc = (TList*)gROOT->GetListOfCanvases();
166 if (lc->FindObject(defcanvas)) {
167 Int_t n = lc->GetSize() + 1;
168 do {
169 cdef.Form("%s_n%d",defcanvas,n++);
170 } while (lc->FindObject(cdef.Data()));
171 } else {
172 cdef = defcanvas;
173 }
174 Constructor(cdef.Data(), cdef.Data(), 1);
175 }
176}
177
178////////////////////////////////////////////////////////////////////////////////
179/// Canvas default constructor
180
182{
183 if (gThreadXAR) {
184 void *arr[2];
185 arr[1] = this;
186 if ((*gThreadXAR)("CANV", 2, arr, 0)) return;
187 }
188
189 fCanvas = 0;
190 fCanvasID = -1;
191 fCanvasImp = 0;
192 fBatch = kTRUE;
194
195 fContextMenu = 0;
196 fSelected = 0;
197 fClickSelected = 0;
198 fSelectedPad = 0;
200 fPadSave = 0;
204}
205
206////////////////////////////////////////////////////////////////////////////////
207/// Create an embedded canvas, i.e. a canvas that is in a TGCanvas widget
208/// which is placed in a TGFrame. This ctor is only called via the
209/// TRootEmbeddedCanvas class.
210///
211/// If "name" starts with "gl" the canvas is ready to receive GL output.
212
213TCanvas::TCanvas(const char *name, Int_t ww, Int_t wh, Int_t winid) : TPad(), fDoubleBuffer(0)
214{
215 fCanvasImp = 0;
216 fPainter = 0;
217 Init();
218
219 fCanvasID = winid;
220 fWindowTopX = 0;
221 fWindowTopY = 0;
222 fWindowWidth = ww;
223 fWindowHeight = wh;
224 fCw = ww + 4;
225 fCh = wh +28;
226 fBatch = kFALSE;
228
229 //This is a very special ctor. A window exists already!
230 //Can create painter now.
232
233 if (fUseGL) {
234 fGLDevice = gGLManager->CreateGLContext(winid);
235 if (fGLDevice == -1)
236 fUseGL = kFALSE;
237 }
238
240 if (!fCanvasImp) return;
241
243 SetName(name);
244 Build();
245}
246
247////////////////////////////////////////////////////////////////////////////////
248/// Create a new canvas with a predefined size form.
249/// If form < 0 the menubar is not shown.
250///
251/// - form = 1 700x500 at 10,10 (set by TStyle::SetCanvasDefH,W,X,Y)
252/// - form = 2 500x500 at 20,20
253/// - form = 3 500x500 at 30,30
254/// - form = 4 500x500 at 40,40
255/// - form = 5 500x500 at 50,50
256///
257/// If "name" starts with "gl" the canvas is ready to receive GL output.
258
259TCanvas::TCanvas(const char *name, const char *title, Int_t form) : TPad(), fDoubleBuffer(0)
260{
261 fPainter = 0;
263
264 Constructor(name, title, form);
265}
266
267////////////////////////////////////////////////////////////////////////////////
268/// Create a new canvas with a predefined size form.
269/// If form < 0 the menubar is not shown.
270///
271/// - form = 1 700x500 at 10,10 (set by TStyle::SetCanvasDefH,W,X,Y)
272/// - form = 2 500x500 at 20,20
273/// - form = 3 500x500 at 30,30
274/// - form = 4 500x500 at 40,40
275/// - form = 5 500x500 at 50,50
276
277void TCanvas::Constructor(const char *name, const char *title, Int_t form)
278{
279 if (gThreadXAR) {
280 void *arr[6];
281 static Int_t ww = 500;
282 static Int_t wh = 500;
283 arr[1] = this; arr[2] = (void*)name; arr[3] = (void*)title; arr[4] =&ww; arr[5] = &wh;
284 if ((*gThreadXAR)("CANV", 6, arr, 0)) return;
285 }
286
287 Init();
288 SetBit(kMenuBar,1);
289 if (form < 0) {
290 form = -form;
291 SetBit(kMenuBar,0);
292 }
293
294 fCanvas = this;
295
296 fCanvasID = -1;
297 TCanvas *old = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(name);
298 if (old && old->IsOnHeap()) {
299 Warning("Constructor","Deleting canvas with same name: %s",name);
300 delete old;
301 }
302 if (gROOT->IsBatch()) { //We are in Batch mode
304 if (form == 1) {
307 } else {
308 fWindowWidth = 500;
309 fWindowHeight = 500;
310 }
314 if (!fCanvasImp) return;
315 fBatch = kTRUE;
316 } else { //normal mode with a screen window
318 if (form < 1 || form > 5) form = 1;
319 if (form == 1) {
320 UInt_t uh = UInt_t(cx*gStyle->GetCanvasDefH());
321 UInt_t uw = UInt_t(cx*gStyle->GetCanvasDefW());
322 Int_t ux = Int_t(cx*gStyle->GetCanvasDefX());
323 Int_t uy = Int_t(cx*gStyle->GetCanvasDefY());
324 fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, ux, uy, uw, uh);
325 }
326 fCw = 500;
327 fCh = 500;
328 if (form == 2) fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, 20, 20, UInt_t(cx*500), UInt_t(cx*500));
329 if (form == 3) fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, 30, 30, UInt_t(cx*500), UInt_t(cx*500));
330 if (form == 4) fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, 40, 40, UInt_t(cx*500), UInt_t(cx*500));
331 if (form == 5) fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, 50, 50, UInt_t(cx*500), UInt_t(cx*500));
332 if (!fCanvasImp) return;
333
334 if (!gROOT->IsBatch() && fCanvasID == -1)
336
338 fBatch = kFALSE;
339 }
340
342
343 SetName(name);
344 SetTitle(title); // requires fCanvasImp set
345 Build();
346
347 // Popup canvas
348 fCanvasImp->Show();
349}
350
351////////////////////////////////////////////////////////////////////////////////
352/// Create a new canvas at a random position.
353///
354/// \param[in] name canvas name
355/// \param[in] title canvas title
356/// \param[in] ww is the canvas size in pixels along X
357/// (if ww < 0 the menubar is not shown)
358/// \param[in] wh is the canvas size in pixels along Y
359///
360/// If "name" starts with "gl" the canvas is ready to receive GL output.
361
362TCanvas::TCanvas(const char *name, const char *title, Int_t ww, Int_t wh) : TPad(), fDoubleBuffer(0)
363{
364 fPainter = 0;
366
367 Constructor(name, title, ww, wh);
368}
369
370////////////////////////////////////////////////////////////////////////////////
371/// Create a new canvas at a random position.
372///
373/// \param[in] name canvas name
374/// \param[in] title canvas title
375/// \param[in] ww is the canvas size in pixels along X
376/// (if ww < 0 the menubar is not shown)
377/// \param[in] wh is the canvas size in pixels along Y
378
379void TCanvas::Constructor(const char *name, const char *title, Int_t ww, Int_t wh)
380{
381 if (gThreadXAR) {
382 void *arr[6];
383 arr[1] = this; arr[2] = (void*)name; arr[3] = (void*)title; arr[4] =&ww; arr[5] = &wh;
384 if ((*gThreadXAR)("CANV", 6, arr, 0)) return;
385 }
386
387 Init();
388 SetBit(kMenuBar,1);
389 if (ww < 0) {
390 ww = -ww;
391 SetBit(kMenuBar,0);
392 }
393 if (wh <= 0) {
394 Error("Constructor", "Invalid canvas height: %d",wh);
395 return;
396 }
397 fCw = ww;
398 fCh = wh;
399 fCanvasID = -1;
400 TCanvas *old = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(name);
401 if (old && old->IsOnHeap()) {
402 Warning("Constructor","Deleting canvas with same name: %s",name);
403 delete old;
404 }
405 if (gROOT->IsBatch()) { //We are in Batch mode
407 fWindowWidth = ww;
408 fWindowHeight = wh;
409 fCw = ww;
410 fCh = wh;
412 if (!fCanvasImp) return;
413 fBatch = kTRUE;
414 } else {
416 fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, UInt_t(cx*ww), UInt_t(cx*wh));
417 if (!fCanvasImp) return;
418
419 if (!gROOT->IsBatch() && fCanvasID == -1)
421
423 fBatch = kFALSE;
424 }
425
427
428 SetName(name);
429 SetTitle(title); // requires fCanvasImp set
430 Build();
431
432 // Popup canvas
433 fCanvasImp->Show();
434}
435
436////////////////////////////////////////////////////////////////////////////////
437/// Create a new canvas.
438///
439/// \param[in] name canvas name
440/// \param[in] title canvas title
441/// \param[in] wtopx,wtopy are the pixel coordinates of the top left corner of
442/// the canvas (if wtopx < 0) the menubar is not shown)
443/// \param[in] ww is the canvas size in pixels along X
444/// \param[in] wh is the canvas size in pixels along Y
445///
446/// If "name" starts with "gl" the canvas is ready to receive GL output.
447
448TCanvas::TCanvas(const char *name, const char *title, Int_t wtopx, Int_t wtopy, Int_t ww, Int_t wh)
449 : TPad(), fDoubleBuffer(0)
450{
451 fPainter = 0;
453
454 Constructor(name, title, wtopx, wtopy, ww, wh);
455}
456
457////////////////////////////////////////////////////////////////////////////////
458/// Create a new canvas.
459///
460/// \param[in] name canvas name
461/// \param[in] title canvas title
462/// \param[in] wtopx,wtopy are the pixel coordinates of the top left corner of
463/// the canvas (if wtopx < 0) the menubar is not shown)
464/// \param[in] ww is the canvas size in pixels along X
465/// \param[in] wh is the canvas size in pixels along Y
466
467void TCanvas::Constructor(const char *name, const char *title, Int_t wtopx,
468 Int_t wtopy, Int_t ww, Int_t wh)
469{
470 if (gThreadXAR) {
471 void *arr[8];
472 arr[1] = this; arr[2] = (void*)name; arr[3] = (void*)title;
473 arr[4] = &wtopx; arr[5] = &wtopy; arr[6] = &ww; arr[7] = &wh;
474 if ((*gThreadXAR)("CANV", 8, arr, 0)) return;
475 }
476
477 Init();
478 SetBit(kMenuBar,1);
479 if (wtopx < 0) {
480 wtopx = -wtopx;
481 SetBit(kMenuBar,0);
482 }
483 fCw = ww;
484 fCh = wh;
485 fCanvasID = -1;
486 TCanvas *old = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(name);
487 if (old && old->IsOnHeap()) {
488 Warning("Constructor","Deleting canvas with same name: %s",name);
489 delete old;
490 }
491 if (gROOT->IsBatch()) { //We are in Batch mode
493 fWindowWidth = ww;
494 fWindowHeight = wh;
495 fCw = ww;
496 fCh = wh;
498 if (!fCanvasImp) return;
499 fBatch = kTRUE;
500 } else { //normal mode with a screen window
502 fCanvasImp = gGuiFactory->CreateCanvasImp(this, name, Int_t(cx*wtopx), Int_t(cx*wtopy), UInt_t(cx*ww), UInt_t(cx*wh));
503 if (!fCanvasImp) return;
504
505 if (!gROOT->IsBatch() && fCanvasID == -1)
507
509 fBatch = kFALSE;
510 }
511
513
514 SetName(name);
515 SetTitle(title); // requires fCanvasImp set
516 Build();
517
518 // Popup canvas
519 fCanvasImp->Show();
520}
521
522////////////////////////////////////////////////////////////////////////////////
523/// Initialize the TCanvas members. Called by all constructors.
524
526{
527 // Make sure the application environment exists. It is need for graphics
528 // (colors are initialized in the TApplication ctor).
529 if (!gApplication)
531
532 // Load and initialize graphics libraries if
533 // TApplication::NeedGraphicsLibs() has been called by a
534 // library static initializer.
535 if (gApplication)
537
538 // Get some default from .rootrc. Used in fCanvasImp->InitWindow().
539 fHighLightColor = gEnv->GetValue("Canvas.HighLightColor", kRed);
540 SetBit(kMoveOpaque, gEnv->GetValue("Canvas.MoveOpaque", 0));
541 SetBit(kResizeOpaque, gEnv->GetValue("Canvas.ResizeOpaque", 0));
542 if (gEnv->GetValue("Canvas.ShowEventStatus", kFALSE)) SetBit(kShowEventStatus);
543 if (gEnv->GetValue("Canvas.ShowToolTips", kFALSE)) SetBit(kShowToolTips);
544 if (gEnv->GetValue("Canvas.ShowToolBar", kFALSE)) SetBit(kShowToolBar);
545 if (gEnv->GetValue("Canvas.ShowEditor", kFALSE)) SetBit(kShowEditor);
546 if (gEnv->GetValue("Canvas.AutoExec", kTRUE)) SetBit(kAutoExec);
547
548 // Fill canvas ROOT data structure
549 fXsizeUser = 0;
550 fYsizeUser = 0;
553
554 fDISPLAY = "$DISPLAY";
557 fSelected = 0;
558 fClickSelected = 0;
559 fSelectedX = 0;
560 fSelectedY = 0;
561 fSelectedPad = 0;
563 fPadSave = 0;
564 fEvent = -1;
565 fEventX = -1;
566 fEventY = -1;
567 fContextMenu = 0;
568 fDrawn = kFALSE;
569}
570
571////////////////////////////////////////////////////////////////////////////////
572/// Build a canvas. Called by all constructors.
573
575{
576 // Get window identifier
577 if (fCanvasID == -1 && fCanvasImp)
579 if (fCanvasID == -1) return;
580
581 if (fCw !=0 && fCh !=0) {
584 }
585
586 // Set Pad parameters
587 gPad = this;
588 fCanvas = this;
589 fMother = (TPad*)gPad;
590
591 if (IsBatch()) {
592 // Make sure that batch interactive canvas sizes are the same
593 fCw -= 4;
594 fCh -= 28;
595 } else if (IsWeb()) {
596 // mark canvas as batch - avoid virtualx in many places
598 } else {
599 //normal mode with a screen window
600 // Set default physical canvas attributes
601 //Should be done via gVirtualX, not via fPainter (at least now). No changes here.
602 gVirtualX->SelectWindow(fCanvasID);
603 gVirtualX->SetFillColor(1); //Set color index for fill area
604 gVirtualX->SetLineColor(1); //Set color index for lines
605 gVirtualX->SetMarkerColor(1); //Set color index for markers
606 gVirtualX->SetTextColor(1); //Set color index for text
607 // Clear workstation
608 gVirtualX->ClearWindow();
609
610 // Set Double Buffer on by default
612
613 // Get effective window parameters (with borders and menubar)
616
617 // Get effective canvas parameters without borders
618 Int_t dum1, dum2;
619 gVirtualX->GetGeometry(fCanvasID, dum1, dum2, fCw, fCh);
620
621 fContextMenu = new TContextMenu("ContextMenu");
622 }
623
624 gROOT->GetListOfCanvases()->Add(this);
625
626 if (!fPrimitives) {
627 fPrimitives = new TList;
629 SetFillStyle(1001);
641 fBorderMode=gStyle->GetCanvasBorderMode(); // do not call SetBorderMode (function redefined in TCanvas)
642 SetPad(0, 0, 1, 1);
643 Range(0, 0, 1, 1); //pad range is set by default to [0,1] in x and y
644
646 if (vpp) vpp->SelectDrawable(fPixmapID);//gVirtualX->SelectPixmap(fPixmapID); //pixmap must be selected
647 PaintBorder(GetFillColor(), kTRUE); //paint background
648 }
649
650 // transient canvases have typically no menubar and should not get
651 // by default the event status bar (if set by default)
652 if (TestBit(kMenuBar) && fCanvasImp) {
654 // ... and toolbar + editor
658 }
659}
660
661////////////////////////////////////////////////////////////////////////////////
662/// Canvas destructor
663
665{
666 Destructor();
667}
668
669////////////////////////////////////////////////////////////////////////////////
670/// Browse.
671
673{
674 Draw();
675 cd();
677}
678
679////////////////////////////////////////////////////////////////////////////////
680/// Actual canvas destructor.
681
683{
684 if (gThreadXAR) {
685 void *arr[2];
686 arr[1] = this;
687 if ((*gThreadXAR)("CDEL", 2, arr, 0)) return;
688 }
689
690 if (!TestBit(kNotDeleted)) return;
691
693 if (!gPad) return;
694
695 Close();
696
697 //If not yet (batch mode?).
699}
700
701////////////////////////////////////////////////////////////////////////////////
702/// Set current canvas & pad. Returns the new current pad,
703/// or 0 in case of failure.
704/// See TPad::cd() for an explanation of the parameter.
705
707{
708 if (fCanvasID == -1) return 0;
709
710 TPad::cd(subpadnumber);
711
712 // in case doublebuffer is off, draw directly onto display window
713 if (!IsBatch()) {
714 if (!fDoubleBuffer)
715 gVirtualX->SelectWindow(fCanvasID);//Ok, does not matter for glpad.
716 }
717 return gPad;
718}
719
720////////////////////////////////////////////////////////////////////////////////
721/// Remove all primitives from the canvas.
722/// If option "D" is specified, direct sub-pads are cleared but not deleted.
723/// This option is not recursive, i.e. pads in direct sub-pads are deleted.
724
726{
727 if (fCanvasID == -1) return;
728
730
731 TString opt = option;
732 opt.ToLower();
733 if (opt.Contains("d")) {
734 // clear subpads, but do not delete pads in case the canvas
735 // has been divided (note: option "D" is propagated so could cause
736 // conflicts for primitives using option "D" for something else)
737 if (fPrimitives) {
738 TIter next(fPrimitives);
739 TObject *obj;
740 while ((obj=next())) {
741 obj->Clear(option);
742 }
743 }
744 } else {
745 //default, clear everything in the canvas. Subpads are deleted
746 TPad::Clear(option); //Remove primitives from pad
747 }
748
749 fSelected = 0;
750 fClickSelected = 0;
751 fSelectedPad = 0;
753}
754
755////////////////////////////////////////////////////////////////////////////////
756/// Emit pad Cleared signal.
757
759{
760 Emit("Cleared(TVirtualPad*)", (Longptr_t)pad);
761}
762
763////////////////////////////////////////////////////////////////////////////////
764/// Emit Closed signal.
765
767{
768 Emit("Closed()");
769}
770
771////////////////////////////////////////////////////////////////////////////////
772/// Close canvas.
773///
774/// Delete window/pads data structure
775
777{
778 TPad *padsave = (TPad*)gPad;
779 TCanvas *cansave = 0;
780 if (padsave) cansave = (TCanvas*)gPad->GetCanvas();
781
782 if (fCanvasID != -1) {
783
784 if ((!gROOT->IsLineProcessing()) && (!gVirtualX->IsCmdThread())) {
785 gInterpreter->Execute(this, IsA(), "Close", option);
786 return;
787 }
788
790
792
793 cd();
795
796 if (!IsBatch()) {
797 gVirtualX->SelectWindow(fCanvasID); //select current canvas
798
800
801 if (fCanvasImp)
802 fCanvasImp->Close();
803 }
804 fCanvasID = -1;
805 fBatch = kTRUE;
806
807 gROOT->GetListOfCanvases()->Remove(this);
808
809 // Close actual window on screen
811 }
812
813 if (cansave == this) {
814 gPad = (TCanvas *) gROOT->GetListOfCanvases()->First();
815 } else {
816 gPad = padsave;
817 }
818
819 Closed();
820}
821
822////////////////////////////////////////////////////////////////////////////////
823/// Copy the canvas pixmap of the pad to the canvas.
824
826{
827 if (!IsBatch()) {
828 CopyPixmap();
830 }
831}
832
833////////////////////////////////////////////////////////////////////////////////
834/// Draw a canvas.
835/// If a canvas with the name is already on the screen, the canvas is repainted.
836/// This function is useful when a canvas object has been saved in a Root file.
837/// One can then do:
838/// ~~~ {.cpp}
839/// Root > Tfile f("file.root");
840/// Root > canvas.Draw();
841/// ~~~
842
844{
845 // Load and initialize graphics libraries if
846 // TApplication::NeedGraphicsLibs() has been called by a
847 // library static initializer.
848 if (gApplication)
850
851 fDrawn = kTRUE;
852
853 TCanvas *old = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(GetName());
854 if (old == this) {
855 Paint();
856 return;
857 }
858 if (old) { gROOT->GetListOfCanvases()->Remove(old); delete old;}
859
860 if (fWindowWidth == 0) {
861 if (fCw !=0) fWindowWidth = fCw+4;
862 else fWindowWidth = 800;
863 }
864 if (fWindowHeight == 0) {
865 if (fCh !=0) fWindowHeight = fCh+28;
866 else fWindowHeight = 600;
867 }
868 if (gROOT->IsBatch()) { //We are in Batch mode
870 if (!fCanvasImp) return;
871 fBatch = kTRUE;
872
873 } else { //normal mode with a screen window
876 if (!fCanvasImp) return;
878 }
879 Build();
880 ResizePad();
882 fCanvasImp->Show();
883 Modified();
884}
885
886////////////////////////////////////////////////////////////////////////////////
887/// Draw a clone of this canvas
888/// A new canvas is created that is a clone of this canvas
889
891{
892 TCanvas *newCanvas = (TCanvas*)Clone();
893 newCanvas->SetName();
894
895 newCanvas->Draw(option);
896 newCanvas->Update();
897 return newCanvas;
898}
899
900////////////////////////////////////////////////////////////////////////////////
901/// Draw a clone of this canvas into the current pad
902/// In an interactive session, select the destination/current pad
903/// with the middle mouse button, then point to the canvas area to select
904/// the canvas context menu item DrawClonePad.
905/// Note that the original canvas may have subpads.
906
908{
909 TPad *padsav = (TPad*)gPad;
910 TPad *selpad = (TPad*)gROOT->GetSelectedPad();
911 TPad *pad = padsav;
912 if (pad == this) pad = selpad;
913 if (padsav == 0 || pad == 0 || pad == this) {
914 TCanvas *newCanvas = (TCanvas*)DrawClone();
916 return newCanvas;
917 }
918 if (fCanvasID == -1) {
921 if (!fCanvasImp) return 0;
924 }
925 this->cd();
926 TObject *obj, *clone;
927 //copy pad attributes
928 pad->Range(fX1,fY1,fX2,fY2);
929 pad->SetTickx(GetTickx());
930 pad->SetTicky(GetTicky());
931 pad->SetGridx(GetGridx());
932 pad->SetGridy(GetGridy());
933 pad->SetLogx(GetLogx());
934 pad->SetLogy(GetLogy());
935 pad->SetLogz(GetLogz());
938 TAttLine::Copy((TAttLine&)*pad);
939 TAttFill::Copy((TAttFill&)*pad);
940 TAttPad::Copy((TAttPad&)*pad);
941
942 //copy primitives
944 while ((obj=next())) {
945 pad->cd();
946 clone = obj->Clone();
947 pad->GetListOfPrimitives()->Add(clone,next.GetOption());
948 }
949 pad->ResizePad();
950 pad->Modified();
951 pad->Update();
952 if (padsav) padsav->cd();
953 return 0;
954}
955
956////////////////////////////////////////////////////////////////////////////////
957/// Report name and title of primitive below the cursor.
958///
959/// This function is called when the option "Event Status"
960/// in the canvas menu "Options" is selected.
961
963{
964 const Int_t kTMAX=256;
965 static char atext[kTMAX];
966
967 if (!TestBit(kShowEventStatus) || !selected) return;
968
969 if (!fCanvasImp) return; //this may happen when closing a TAttCanvas
970
971 TVirtualPad* savepad;
972 savepad = gPad;
974
975 fCanvasImp->SetStatusText(selected->GetTitle(),0);
976 fCanvasImp->SetStatusText(selected->GetName(),1);
977 if (event == kKeyPress)
978 snprintf(atext, kTMAX, "%c", (char) px);
979 else
980 snprintf(atext, kTMAX, "%d,%d", px, py);
981 fCanvasImp->SetStatusText(atext,2);
982
983 // Show date/time if TimeDisplay is selected
984 TAxis *xaxis = NULL;
985 if ( selected->InheritsFrom("TH1") )
986 xaxis = ((TH1*)selected)->GetXaxis();
987 else if ( selected->InheritsFrom("TGraph") )
988 xaxis = ((TGraph*)selected)->GetXaxis();
989 else if ( selected->InheritsFrom("TAxis") )
990 xaxis = (TAxis*)selected;
991 if ( xaxis != NULL && xaxis->GetTimeDisplay()) {
992 TString objinfo = selected->GetObjectInfo(px,py);
993 // check if user has overwritten GetObjectInfo and altered
994 // the default text from TObject::GetObjectInfo "x=.. y=.."
995 if (objinfo.Contains("x=") && objinfo.Contains("y=") ) {
996 UInt_t toff = 0;
997 TString time_format(xaxis->GetTimeFormat());
998 // TimeFormat may contain offset: %F2000-01-01 00:00:00
999 Int_t idF = time_format.Index("%F");
1000 if (idF>=0) {
1001 Int_t lnF = time_format.Length();
1002 // minimal check for correct format
1003 if (lnF - idF == 21) {
1004 time_format = time_format(idF+2, lnF);
1005 TDatime dtoff(time_format);
1006 toff = dtoff.Convert();
1007 }
1008 } else {
1009 toff = (UInt_t)gStyle->GetTimeOffset();
1010 }
1011 TDatime dt((UInt_t)gPad->AbsPixeltoX(px) + toff);
1012 snprintf(atext, kTMAX, "%s, y=%g",
1013 dt.AsSQLString(),gPad->AbsPixeltoY(py));
1014 fCanvasImp->SetStatusText(atext,3);
1015 gPad = savepad;
1016 return;
1017 }
1018 }
1019 // default
1020 fCanvasImp->SetStatusText(selected->GetObjectInfo(px,py),3);
1021
1022 gPad = savepad;
1023}
1024
1025////////////////////////////////////////////////////////////////////////////////
1026/// Get editor bar.
1027
1029{
1031}
1032
1033////////////////////////////////////////////////////////////////////////////////
1034/// Embedded a canvas into a TRootEmbeddedCanvas. This method is only called
1035/// via TRootEmbeddedCanvas::AdoptCanvas.
1036
1038{
1039 // If fCanvasImp already exists, no need to go further.
1040 if(fCanvasImp) return;
1041
1042 fCanvasID = winid;
1043 fWindowTopX = 0;
1044 fWindowTopY = 0;
1045 fWindowWidth = ww;
1046 fWindowHeight = wh;
1047 fCw = ww;
1048 fCh = wh;
1049 fBatch = kFALSE;
1050 fUpdating = kFALSE;
1051
1053 if (!fCanvasImp) return;
1054 Build();
1055 Resize();
1056}
1057
1058////////////////////////////////////////////////////////////////////////////////
1059/// Generate kMouseEnter and kMouseLeave events depending on the previously
1060/// selected object and the currently selected object. Does nothing if the
1061/// selected object does not change.
1062
1063void TCanvas::EnterLeave(TPad *prevSelPad, TObject *prevSelObj)
1064{
1065 if (prevSelObj == fSelected) return;
1066
1067 TPad *padsav = (TPad *)gPad;
1068 Int_t sevent = fEvent;
1069
1070 if (prevSelObj) {
1071 gPad = prevSelPad;
1072 prevSelObj->ExecuteEvent(kMouseLeave, fEventX, fEventY);
1074 RunAutoExec();
1075 ProcessedEvent(kMouseLeave, fEventX, fEventY, prevSelObj); // emit signal
1076 }
1077
1079
1080 if (fSelected) {
1083 RunAutoExec();
1085 }
1086
1087 fEvent = sevent;
1088 gPad = padsav;
1089}
1090
1091////////////////////////////////////////////////////////////////////////////////
1092/// Execute action corresponding to one event.
1093///
1094/// This member function must be implemented to realize the action
1095/// corresponding to the mouse click on the object in the canvas
1096///
1097/// Only handle mouse motion events in TCanvas, all other events are
1098/// ignored for the time being
1099
1101{
1102 if (gROOT->GetEditorMode()) {
1104 return;
1105 }
1106
1107 switch (event) {
1108
1109 case kMouseMotion:
1111 break;
1112 }
1113}
1114
1115////////////////////////////////////////////////////////////////////////////////
1116/// Turn rubberband feedback mode on or off.
1117
1119{
1120 if (set) {
1121 SetDoubleBuffer(0); // turn off double buffer mode
1122 gVirtualX->SetDrawMode(TVirtualX::kInvert); // set the drawing mode to XOR mode
1123 } else {
1124 SetDoubleBuffer(1); // turn on double buffer mode
1125 gVirtualX->SetDrawMode(TVirtualX::kCopy); // set drawing mode back to normal (copy) mode
1126 }
1127}
1128
1129////////////////////////////////////////////////////////////////////////////////
1130/// Flush canvas buffers.
1131
1133{
1134 if ((fCanvasID == -1) || IsWeb()) return;
1135
1136 TPad *padsav = (TPad*)gPad;
1137 cd();
1138 if (!IsBatch()) {
1139 if (!UseGL() || fGLDevice == -1) {
1140 gVirtualX->SelectWindow(fCanvasID);
1141 gPad = padsav; //don't do cd() because than also the pixmap is changed
1142 CopyPixmaps();
1143 gVirtualX->UpdateWindow(1);
1144 } else {
1145 TVirtualPS *tvps = gVirtualPS;
1146 gVirtualPS = 0;
1147 gGLManager->MakeCurrent(fGLDevice);
1149 Paint();
1150 if (padsav && padsav->GetCanvas() == this) {
1151 padsav->cd();
1152 padsav->HighLight(padsav->GetHighLightColor());
1153 //cd();
1154 }
1156 gGLManager->Flush(fGLDevice);
1157 gVirtualPS = tvps;
1158 }
1159 }
1160 if (padsav) padsav->cd();
1161}
1162
1163////////////////////////////////////////////////////////////////////////////////
1164/// Force canvas update
1165
1167{
1169}
1170
1171////////////////////////////////////////////////////////////////////////////////
1172/// Force a copy of current style for all objects in canvas.
1173
1175{
1176 if ((!gROOT->IsLineProcessing()) && (!gVirtualX->IsCmdThread())) {
1177 gInterpreter->Execute(this, IsA(), "UseCurrentStyle", "");
1178 return;
1179 }
1180
1182
1184
1185 if (gStyle->IsReading()) {
1189 } else {
1193 }
1194}
1195
1196////////////////////////////////////////////////////////////////////////////////
1197/// Returns current top x position of window on screen.
1198
1200{
1203
1204 return fWindowTopX;
1205}
1206
1207////////////////////////////////////////////////////////////////////////////////
1208/// Returns current top y position of window on screen.
1209
1211{
1214
1215 return fWindowTopY;
1216}
1217
1218////////////////////////////////////////////////////////////////////////////////
1219/// Handle Input Events.
1220///
1221/// Handle input events, like button up/down in current canvas.
1222
1224{
1225 TPad *pad;
1226 TPad *prevSelPad = (TPad*) fSelectedPad;
1227 TObject *prevSelObj = fSelected;
1228
1229 fPadSave = (TPad*)gPad;
1230 cd(); // make sure this canvas is the current canvas
1231
1232 fEvent = event;
1233 fEventX = px;
1234 fEventY = py;
1235
1236 switch (event) {
1237
1238 case kMouseMotion:
1239 // highlight object tracked over
1240 pad = Pick(px, py, prevSelObj);
1241 if (!pad) return;
1242
1243 EnterLeave(prevSelPad, prevSelObj);
1244
1245 gPad = pad; // don't use cd() we will use the current
1246 // canvas via the GetCanvas member and not via
1247 // gPad->GetCanvas
1248
1249 if (fSelected) {
1250 fSelected->ExecuteEvent(event, px, py);
1251 RunAutoExec();
1252 }
1253
1254 break;
1255
1256 case kMouseEnter:
1257 // mouse enters canvas
1259 break;
1260
1261 case kMouseLeave:
1262 // mouse leaves canvas
1263 {
1264 // force popdown of tooltips
1265 TObject *sobj = fSelected;
1266 TPad *spad = fSelectedPad;
1267 fSelected = 0;
1268 fSelectedPad = 0;
1269 EnterLeave(prevSelPad, prevSelObj);
1270 fSelected = sobj;
1271 fSelectedPad = spad;
1273 }
1274 break;
1275
1276 case kButton1Double:
1277 // triggered on the second button down within 350ms and within
1278 // 3x3 pixels of the first button down, button up finishes action
1279
1280 case kButton1Down:
1281 // find pad in which input occurred
1282 pad = Pick(px, py, prevSelObj);
1283 if (!pad) return;
1284
1285 gPad = pad; // don't use cd() because we won't draw in pad
1286 // we will only use its coordinate system
1287
1288 if (fSelected) {
1289 FeedbackMode(kTRUE); // to draw in rubberband mode
1290 fSelected->ExecuteEvent(event, px, py);
1291
1292 RunAutoExec();
1293 }
1294
1295 break;
1296
1297 case kArrowKeyPress:
1298 case kArrowKeyRelease:
1299 case kButton1Motion:
1300 case kButton1ShiftMotion: //8 == kButton1Motion + shift modifier
1301 if (fSelected) {
1303
1304 fSelected->ExecuteEvent(event, px, py);
1305 gVirtualX->Update();
1307 Bool_t resize = kFALSE;
1309 resize = ((TBox*)fSelected)->IsBeingResized();
1311 resize = ((TVirtualPad*)fSelected)->IsBeingResized();
1312
1313 if ((!resize && TestBit(kMoveOpaque)) || (resize && TestBit(kResizeOpaque))) {
1314 gPad = fPadSave;
1315 Update();
1317 }
1318 }
1319
1320 RunAutoExec();
1321 }
1322
1323 break;
1324
1325 case kButton1Up:
1326
1327 if (fSelected) {
1329
1330 fSelected->ExecuteEvent(event, px, py);
1331
1332 RunAutoExec();
1333
1334 if (fPadSave)
1335 gPad = fPadSave;
1336 else {
1337 gPad = this;
1338 fPadSave = this;
1339 }
1340
1341 Update(); // before calling update make sure gPad is reset
1342 }
1343 break;
1344
1345//*-*----------------------------------------------------------------------
1346
1347 case kButton2Down:
1348 // find pad in which input occurred
1349 pad = Pick(px, py, prevSelObj);
1350 if (!pad) return;
1351
1352 gPad = pad; // don't use cd() because we won't draw in pad
1353 // we will only use its coordinate system
1354
1356
1357 if (fSelected) fSelected->Pop(); // pop object to foreground
1358 pad->cd(); // and make its pad the current pad
1359 if (gDebug)
1360 printf("Current Pad: %s / %s\n", pad->GetName(), pad->GetTitle());
1361
1362 // loop over all canvases to make sure that only one pad is highlighted
1363 {
1364 TIter next(gROOT->GetListOfCanvases());
1365 TCanvas *tc;
1366 while ((tc = (TCanvas *)next()))
1367 tc->Update();
1368 }
1369
1370 //if (pad->GetGLDevice() != -1 && fSelected)
1371 // fSelected->ExecuteEvent(event, px, py);
1372
1373 break; // don't want fPadSave->cd() to be executed at the end
1374
1375 case kButton2Motion:
1376 //was empty!
1377 case kButton2Up:
1378 if (fSelected) {
1380
1381 fSelected->ExecuteEvent(event, px, py);
1382 RunAutoExec();
1383 }
1384 break;
1385
1386 case kButton2Double:
1387 break;
1388
1389//*-*----------------------------------------------------------------------
1390
1391 case kButton3Down:
1392 // popup context menu
1393 pad = Pick(px, py, prevSelObj);
1394 if (!pad) return;
1395
1397
1400 fContextMenu->Popup(px, py, fSelected, this, pad);
1401
1402 break;
1403
1404 case kButton3Motion:
1405 break;
1406
1407 case kButton3Up:
1409 break;
1410
1411 case kButton3Double:
1412 break;
1413
1414 case kKeyPress:
1415 if (!fSelectedPad || !fSelected) return;
1416 gPad = fSelectedPad; // don't use cd() because we won't draw in pad
1417 // we will only use its coordinate system
1418 fSelected->ExecuteEvent(event, px, py);
1419
1420 RunAutoExec();
1421
1422 break;
1423
1424 case kButton1Shift:
1425 // Try to select
1426 pad = Pick(px, py, prevSelObj);
1427
1428 if (!pad) return;
1429
1430 EnterLeave(prevSelPad, prevSelObj);
1431
1432 gPad = pad; // don't use cd() we will use the current
1433 // canvas via the GetCanvas member and not via
1434 // gPad->GetCanvas
1435 if (fSelected) {
1436 fSelected->ExecuteEvent(event, px, py);
1437 RunAutoExec();
1438 }
1439 break;
1440
1441 case kWheelUp:
1442 case kWheelDown:
1443 pad = Pick(px, py, prevSelObj);
1444 if (!pad) return;
1445
1446 gPad = pad;
1447 if (fSelected)
1448 fSelected->ExecuteEvent(event, px, py);
1449 break;
1450
1451 default:
1452 break;
1453 }
1454
1455 if (fPadSave && event != kButton2Down)
1456 fPadSave->cd();
1457
1458 if (event != kMouseLeave) { // signal was already emitted for this event
1459 ProcessedEvent(event, px, py, fSelected); // emit signal
1461 }
1462}
1463
1464////////////////////////////////////////////////////////////////////////////////
1465/// Iconify canvas
1466
1468{
1469 if (fCanvasImp)
1471}
1472
1473////////////////////////////////////////////////////////////////////////////////
1474/// Is folder ?
1475
1477{
1478 return fgIsFolder;
1479}
1480
1481////////////////////////////////////////////////////////////////////////////////
1482/// Is web canvas
1483
1485{
1486 return fCanvasImp ? fCanvasImp->IsWeb() : kFALSE;
1487}
1488
1489////////////////////////////////////////////////////////////////////////////////
1490/// List all pads.
1491
1493{
1495 std::cout <<"Canvas Name=" <<GetName()<<" Title="<<GetTitle()<<" Option="<<option<<std::endl;
1499}
1500
1501////////////////////////////////////////////////////////////////////////////////
1502/// Static function to build a default canvas.
1503
1505{
1506 const char *defcanvas = gROOT->GetDefCanvasName();
1507 TString cdef;
1508
1509 auto lc = (TList*)gROOT->GetListOfCanvases();
1510 if (lc->FindObject(defcanvas)) {
1511 Int_t n = lc->GetSize() + 1;
1512 do {
1513 cdef.Form("%s_n%d", defcanvas, n++);
1514 } while (lc->FindObject(cdef.Data()));
1515 } else
1516 cdef = defcanvas;
1517
1518 TCanvas *c = new TCanvas(cdef.Data(), cdef.Data(), 1);
1519
1520 ::Info("TCanvas::MakeDefCanvas"," created default TCanvas with name %s",cdef.Data());
1521 return c;
1522}
1523
1524////////////////////////////////////////////////////////////////////////////////
1525/// Set option to move objects/pads in a canvas.
1526///
1527/// - set = 1 (default) graphics objects are moved in opaque mode
1528/// - set = 0 only the outline of objects is drawn when moving them
1529///
1530/// The option opaque produces the best effect. It requires however a
1531/// a reasonably fast workstation or response time.
1532
1534{
1535 SetBit(kMoveOpaque,set);
1536}
1537
1538////////////////////////////////////////////////////////////////////////////////
1539/// Paint canvas.
1540
1542{
1543 if (fCanvas)
1545}
1546
1547////////////////////////////////////////////////////////////////////////////////
1548/// Prepare for pick, call TPad::Pick() and when selected object
1549/// is different from previous then emit Picked() signal.
1550
1551TPad *TCanvas::Pick(Int_t px, Int_t py, TObject *prevSelObj)
1552{
1553 TObjLink *pickobj = 0;
1554
1555 fSelected = 0;
1556 fSelectedOpt = "";
1557 fSelectedPad = 0;
1558
1559 TPad *pad = Pick(px, py, pickobj);
1560 if (!pad) return 0;
1561
1562 if (!pickobj) {
1563 fSelected = pad;
1564 fSelectedOpt = "";
1565 } else {
1566 if (!fSelected) { // can be set via TCanvas::SetSelected()
1567 fSelected = pickobj->GetObject();
1568 fSelectedOpt = pickobj->GetOption();
1569 }
1570 }
1571 fSelectedPad = pad;
1572
1573 if (fSelected != prevSelObj)
1574 Picked(fSelectedPad, fSelected, fEvent); // emit signal
1575
1576 if ((fEvent == kButton1Down) || (fEvent == kButton2Down) || (fEvent == kButton3Down)) {
1580 Selected(fSelectedPad, fSelected, fEvent); // emit signal
1581 fSelectedX = px;
1582 fSelectedY = py;
1583 }
1584 }
1585 return pad;
1586}
1587
1588////////////////////////////////////////////////////////////////////////////////
1589/// Emit Picked() signal.
1590
1592{
1593 Longptr_t args[3];
1594
1595 args[0] = (Longptr_t) pad;
1596 args[1] = (Longptr_t) obj;
1597 args[2] = event;
1598
1599 Emit("Picked(TPad*,TObject*,Int_t)", args);
1600}
1601
1602////////////////////////////////////////////////////////////////////////////////
1603/// Emit Highlighted() signal.
1604///
1605/// - pad is pointer to pad with highlighted histogram or graph
1606/// - obj is pointer to highlighted histogram or graph
1607/// - x is highlighted x bin for 1D histogram or highlighted x-th point for graph
1608/// - y is highlighted y bin for 2D histogram (for 1D histogram or graph not in use)
1609
1611{
1612 Longptr_t args[4];
1613
1614 args[0] = (Longptr_t) pad;
1615 args[1] = (Longptr_t) obj;
1616 args[2] = x;
1617 args[3] = y;
1618
1619 Emit("Highlighted(TVirtualPad*,TObject*,Int_t,Int_t)", args);
1620}
1621
1622////////////////////////////////////////////////////////////////////////////////
1623/// This is "simplification" for function TCanvas::Connect with Highlighted
1624/// signal for specific slot.
1625///
1626/// Slot has to be defined "UserFunction(TVirtualPad *pad, TObject *obj, Int_t x, Int_t y)"
1627/// all parameters of UserFunction are taken from TCanvas::Highlighted
1628
1629void TCanvas::HighlightConnect(const char *slot)
1630{
1631 Connect("Highlighted(TVirtualPad*,TObject*,Int_t,Int_t)", 0, 0, slot);
1632}
1633
1634////////////////////////////////////////////////////////////////////////////////
1635/// Emit Selected() signal.
1636
1638{
1639 Longptr_t args[3];
1640
1641 args[0] = (Longptr_t) pad;
1642 args[1] = (Longptr_t) obj;
1643 args[2] = event;
1644
1645 Emit("Selected(TVirtualPad*,TObject*,Int_t)", args);
1646}
1647
1648////////////////////////////////////////////////////////////////////////////////
1649/// Emit ProcessedEvent() signal.
1650
1652{
1653 Longptr_t args[4];
1654
1655 args[0] = event;
1656 args[1] = x;
1657 args[2] = y;
1658 args[3] = (Longptr_t) obj;
1659
1660 Emit("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)", args);
1661}
1662
1663////////////////////////////////////////////////////////////////////////////////
1664/// Recompute canvas parameters following a X11 Resize.
1665
1667{
1668 if (fCanvasID == -1) return;
1669
1670 if ((!gROOT->IsLineProcessing()) && (!gVirtualX->IsCmdThread())) {
1671 gInterpreter->Execute(this, IsA(), "Resize", "");
1672 return;
1673 }
1674
1676
1677 TPad *padsav = (TPad*)gPad;
1678 cd();
1679
1680 if (!IsBatch()) {
1681 gVirtualX->SelectWindow(fCanvasID); //select current canvas
1682 gVirtualX->ResizeWindow(fCanvasID); //resize canvas and off-screen buffer
1683
1684 // Get effective window parameters including menubar and borders
1687
1688 // Get effective canvas parameters without borders
1689 Int_t dum1, dum2;
1690 gVirtualX->GetGeometry(fCanvasID, dum1, dum2, fCw, fCh);
1691 }
1692
1693 if (fXsizeUser && fYsizeUser) {
1694 UInt_t nwh = fCh;
1695 UInt_t nww = fCw;
1697 if (rxy < 1) {
1698 UInt_t twh = UInt_t(Double_t(fCw)/rxy);
1699 if (twh > fCh)
1700 nww = UInt_t(Double_t(fCh)*rxy);
1701 else
1702 nwh = twh;
1703 if (nww > fCw) {
1704 nww = fCw; nwh = twh;
1705 }
1706 if (nwh > fCh) {
1707 nwh = fCh; nww = UInt_t(Double_t(fCh)/rxy);
1708 }
1709 } else {
1710 UInt_t twh = UInt_t(Double_t(fCw)*rxy);
1711 if (twh > fCh)
1712 nwh = UInt_t(Double_t(fCw)/rxy);
1713 else
1714 nww = twh;
1715 if (nww > fCw) {
1716 nww = fCw; nwh = twh;
1717 }
1718 if (nwh > fCh) {
1719 nwh = fCh; nww = UInt_t(Double_t(fCh)*rxy);
1720 }
1721 }
1722 fCw = nww;
1723 fCh = nwh;
1724 }
1725
1726 if (fCw < fCh) {
1729 }
1730 else {
1733 }
1734
1735//*-*- Loop on all pads to recompute conversion coefficients
1737
1738 if (padsav) padsav->cd();
1739}
1740
1741
1742////////////////////////////////////////////////////////////////////////////////
1743/// Raise canvas window
1744
1746{
1747 if (fCanvasImp)
1749}
1750
1751////////////////////////////////////////////////////////////////////////////////
1752/// Set option to resize objects/pads in a canvas.
1753///
1754/// - set = 1 (default) graphics objects are resized in opaque mode
1755/// - set = 0 only the outline of objects is drawn when resizing them
1756///
1757/// The option opaque produces the best effect. It requires however a
1758/// a reasonably fast workstation or response time.
1759
1761{
1762 SetBit(kResizeOpaque,set);
1763}
1764
1765////////////////////////////////////////////////////////////////////////////////
1766/// Execute the list of TExecs in the current pad.
1767
1769{
1770 if (!TestBit(kAutoExec)) return;
1771 if (!gPad) return;
1772 ((TPad*)gPad)->AutoExec();
1773}
1774
1775
1776////////////////////////////////////////////////////////////////////////////////
1777/// Save primitives in this canvas in C++ macro file with GUI.
1778
1779void TCanvas::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1780{
1781 // Write canvas options (in $TROOT or $TStyle)
1782 if (gStyle->GetOptFit()) {
1783 out<<" gStyle->SetOptFit(1);"<<std::endl;
1784 }
1785 if (!gStyle->GetOptStat()) {
1786 out<<" gStyle->SetOptStat(0);"<<std::endl;
1787 }
1788 if (!gStyle->GetOptTitle()) {
1789 out<<" gStyle->SetOptTitle(0);"<<std::endl;
1790 }
1791 if (gROOT->GetEditHistograms()) {
1792 out<<" gROOT->SetEditHistograms();"<<std::endl;
1793 }
1794 if (GetShowEventStatus()) {
1795 out<<" "<<GetName()<<"->ToggleEventStatus();"<<std::endl;
1796 }
1797 if (GetShowToolTips()) {
1798 out<<" "<<GetName()<<"->ToggleToolTips();"<<std::endl;
1799 }
1800 if (GetShowToolBar()) {
1801 out<<" "<<GetName()<<"->ToggleToolBar();"<<std::endl;
1802 }
1803 if (GetHighLightColor() != 5) {
1804 if (GetHighLightColor() > 228) {
1806 out<<" "<<GetName()<<"->SetHighLightColor(ci);" << std::endl;
1807 } else
1808 out<<" "<<GetName()<<"->SetHighLightColor("<<GetHighLightColor()<<");"<<std::endl;
1809 }
1810
1811 // Now recursively scan all pads of this canvas
1812 cd();
1814}
1815
1816////////////////////////////////////////////////////////////////////////////////
1817/// Save primitives in this canvas as a C++ macro file.
1818/// This function loops on all the canvas primitives and for each primitive
1819/// calls the object SavePrimitive function.
1820/// When outputting floating point numbers, the default precision is 7 digits.
1821/// The precision can be changed (via system.rootrc) by changing the value
1822/// of the environment variable "Canvas.SavePrecision"
1823
1825{
1826 // reset bit TClass::kClassSaved for all classes
1827 TIter next(gROOT->GetListOfClasses());
1828 TClass *cl;
1829 while((cl = (TClass*)next())) {
1831 }
1832
1833 char quote = '"';
1834 std::ofstream out;
1835 TString fname;
1836 const char *cname = GetName();
1837 Bool_t invalid = kFALSE;
1838 // if filename is given, open this file, otherwise create a file
1839 // with a name equal to the canvasname.C
1840 if (filename && (strlen(filename) > 0)) {
1841 fname = filename;
1842 } else {
1843 fname = cname;
1844 fname = fname.Strip(TString::kBoth);
1845 if (fname.IsNull()) {
1846 invalid = kTRUE;
1847 fname = "c1";
1848 }
1849 fname.Append(".C");
1850 }
1851 out.open(fname.Data(), std::ios::out);
1852 if (!out.good()) {
1853 Error("SaveSource", "Cannot open file: %s", fname.Data());
1854 return;
1855 }
1856
1857 //set precision
1858 Int_t precision = gEnv->GetValue("Canvas.SavePrecision",7);
1859 out.precision(precision);
1860
1861 // Write macro header and date/time stamp
1862 TDatime t;
1864 Int_t topx,topy;
1865 UInt_t w, h;
1866 if (!fCanvasImp) {
1867 Error("SaveSource", "Cannot open TCanvas");
1868 return;
1869 }
1870 UInt_t editorWidth = fCanvasImp->GetWindowGeometry(topx,topy,w,h);
1871 w = UInt_t((fWindowWidth - editorWidth)/cx);
1872 h = UInt_t((fWindowHeight)/cx);
1873 topx = GetWindowTopX();
1874 topy = GetWindowTopY();
1875
1876 if (w == 0) {
1877 w = GetWw()+4; h = GetWh()+4;
1878 topx = 1; topy = 1;
1879 }
1880
1881 TString mname = fname;
1882 out << R"CODE(#ifdef __CLING__
1883#pragma cling optimize(0)
1884#endif
1885)CODE";
1886 Int_t p = mname.Last('.');
1887 Int_t s = mname.Last('/')+1;
1888
1889 // A named macro is generated only if the function name is valid. If not, the
1890 // macro is unnamed.
1891 TString first(mname(s,s+1));
1892 if (!first.IsDigit()) out <<"void " << mname(s,p-s) << "()" << std::endl;
1893
1894 out <<"{"<<std::endl;
1895 out <<"//=========Macro generated from canvas: "<<GetName()<<"/"<<GetTitle()<<std::endl;
1896 out <<"//========= ("<<t.AsString()<<") by ROOT version "<<gROOT->GetVersion()<<std::endl;
1897
1899 out <<std::endl<<" gStyle->SetCanvasPreferGL(kTRUE);"<<std::endl<<std::endl;
1900
1901 // Write canvas parameters (TDialogCanvas case)
1903 out<<" "<<ClassName()<<" *"<<cname<<" = new "<<ClassName()<<"("<<quote<<GetName()
1904 <<quote<<", "<<quote<<GetTitle()<<quote<<","<<w<<","<<h<<");"<<std::endl;
1905 } else {
1906 // Write canvas parameters (TCanvas case)
1907 out<<" TCanvas *"<<cname<<" = new TCanvas("<<quote<<GetName()<<quote<<", "<<quote<<GetTitle()
1908 <<quote;
1909 if (!HasMenuBar())
1910 out<<",-"<<topx<<","<<topy<<","<<w<<","<<h<<");"<<std::endl;
1911 else
1912 out<<","<<topx<<","<<topy<<","<<w<<","<<h<<");"<<std::endl;
1913 }
1914 // Write canvas options (in $TROOT or $TStyle)
1915 if (gStyle->GetOptFit()) {
1916 out<<" gStyle->SetOptFit(1);"<<std::endl;
1917 }
1918 if (!gStyle->GetOptStat()) {
1919 out<<" gStyle->SetOptStat(0);"<<std::endl;
1920 }
1921 if (!gStyle->GetOptTitle()) {
1922 out<<" gStyle->SetOptTitle(0);"<<std::endl;
1923 }
1924 if (gROOT->GetEditHistograms()) {
1925 out<<" gROOT->SetEditHistograms();"<<std::endl;
1926 }
1927 if (GetShowEventStatus()) {
1928 out<<" "<<GetName()<<"->ToggleEventStatus();"<<std::endl;
1929 }
1930 if (GetShowToolTips()) {
1931 out<<" "<<GetName()<<"->ToggleToolTips();"<<std::endl;
1932 }
1933 if (GetHighLightColor() != 5) {
1934 if (GetHighLightColor() > 228) {
1936 out<<" "<<GetName()<<"->SetHighLightColor(ci);" << std::endl;
1937 } else
1938 out<<" "<<GetName()<<"->SetHighLightColor("<<GetHighLightColor()<<");"<<std::endl;
1939 }
1940
1941 // Now recursively scan all pads of this canvas
1942 cd();
1943 if (invalid) SetName("c1");
1945 // Write canvas options related to pad editor
1946 out<<" "<<GetName()<<"->SetSelected("<<GetName()<<");"<<std::endl;
1947 if (GetShowToolBar()) {
1948 out<<" "<<GetName()<<"->ToggleToolBar();"<<std::endl;
1949 }
1950 if (invalid) SetName(" ");
1951
1952 out <<"}"<<std::endl;
1953 out.close();
1954 Info("SaveSource","C++ Macro file: %s has been generated", fname.Data());
1955
1956 // reset bit TClass::kClassSaved for all classes
1957 next.Reset();
1958 while((cl = (TClass*)next())) {
1960 }
1961}
1962
1963////////////////////////////////////////////////////////////////////////////////
1964/// Toggle batch mode. However, if the canvas is created without a window
1965/// then batch mode always stays set.
1966
1967void TCanvas::SetBatch(Bool_t batch)
1968{
1969 if (gROOT->IsBatch() || IsWeb())
1970 fBatch = kTRUE;
1971 else
1972 fBatch = batch;
1973}
1974
1975////////////////////////////////////////////////////////////////////////////////
1976/// Set Width and Height of canvas to ww and wh respectively. If ww and/or wh
1977/// are greater than the current canvas window a scroll bar is automatically
1978/// generated. Use this function to zoom in a canvas and navigate via
1979/// the scroll bars. The Width and Height in this method are different from those
1980/// given in the TCanvas constructors where these two dimension include the size
1981/// of the window decoration whereas they do not in this method.
1982
1984{
1985 if (fCanvasImp) {
1986 fCanvasImp->SetCanvasSize(ww, wh);
1987 fCw = ww;
1988 fCh = wh;
1989 TPad *padsav = (TPad*)gPad;
1990 cd();
1991 ResizePad();
1992 if (padsav) padsav->cd();
1993 }
1994}
1995
1996////////////////////////////////////////////////////////////////////////////////
1997/// Set cursor.
1998
2000{
2001 if (IsBatch()) return;
2002 gVirtualX->SetCursor(fCanvasID, cursor);
2003}
2004
2005////////////////////////////////////////////////////////////////////////////////
2006/// Set Double Buffer On/Off.
2007
2009{
2010 if (IsBatch()) return;
2012 gVirtualX->SetDoubleBuffer(fCanvasID, mode);
2013
2014 // depending of the buffer mode set the drawing window to either
2015 // the canvas pixmap or to the canvas on-screen window
2016 if (fDoubleBuffer) {
2018 } else
2020}
2021
2022////////////////////////////////////////////////////////////////////////////////
2023/// Fix canvas aspect ratio to current value if fixed is true.
2024
2026{
2027 if (fixed) {
2028 if (!fFixedAspectRatio) {
2029 if (fCh != 0)
2031 else {
2032 Error("SetAspectRatio", "cannot fix aspect ratio, height of canvas is 0");
2033 return;
2034 }
2036 }
2037 } else {
2039 fAspectRatio = 0;
2040 }
2041}
2042
2043////////////////////////////////////////////////////////////////////////////////
2044/// If isfolder=kTRUE, the canvas can be browsed like a folder
2045/// by default a canvas is not browsable.
2046
2047void TCanvas::SetFolder(Bool_t isfolder)
2048{
2049 fgIsFolder = isfolder;
2050}
2051
2052////////////////////////////////////////////////////////////////////////////////
2053/// Set canvas name. In case `name` is an empty string, a default name is set.
2054
2055void TCanvas::SetName(const char *name)
2056{
2057 if (!name || !name[0]) {
2058 const char *defcanvas = gROOT->GetDefCanvasName();
2059 char *cdef;
2060 auto lc = (TList*)gROOT->GetListOfCanvases();
2061 if (lc->FindObject(defcanvas)) {
2062 cdef = Form("%s_n%d",defcanvas,lc->GetSize()+1);
2063 } else {
2064 cdef = Form("%s",defcanvas);
2065 }
2066 fName = cdef;
2067 } else {
2068 fName = name;
2069 }
2070 if (gPad && TestBit(kMustCleanup)) gPad->Modified();
2071}
2072
2073
2074////////////////////////////////////////////////////////////////////////////////
2075/// Function to resize a canvas so that the plot inside is shown in real aspect
2076/// ratio
2077///
2078/// \param[in] axis 1 for resizing horizontally (x-axis) in order to get real
2079/// aspect ratio, 2 for the resizing vertically (y-axis)
2080/// \return false if error is encountered, true otherwise
2081///
2082/// ~~~ {.cpp}
2083/// hpxpy->Draw();
2084/// c1->SetRealAspectRatio();
2085/// ~~~
2086///
2087/// - For defining the concept of real aspect ratio, it is assumed that x and y
2088/// axes are in same units, e.g. both in MeV or both in ns.
2089/// - You can resize either the width of the canvas or the height, but not both
2090/// at the same time
2091/// - Call this function AFTER drawing AND zooming (SetUserRange) your TGraph or
2092/// Histogram, otherwise it cannot infer your actual axes lengths
2093/// - This function ensures that the TFrame has a real aspect ratio, this does not
2094/// mean that the full pad (i.e. the canvas or png output) including margins has
2095/// exactly the same ratio
2096/// - This function does not work if the canvas is divided in several subpads
2097
2098bool TCanvas::SetRealAspectRatio(const Int_t axis)
2099{
2100 Update();
2101
2102 //Get how many pixels are occupied by the canvas
2103 Int_t npx = GetWw();
2104 Int_t npy = GetWh();
2105
2106 //Get x-y coordinates at the edges of the canvas (extrapolating outside the axes, NOT at the edges of the histogram)
2107 Double_t x1 = GetX1();
2108 Double_t y1 = GetY1();
2109 Double_t x2 = GetX2();
2110 Double_t y2 = GetY2();
2111
2112 //Get the length of extrapolated x and y axes
2113 Double_t xlength2 = x2 - x1;
2114 Double_t ylength2 = y2 - y1;
2115 Double_t ratio2 = xlength2/ylength2;
2116
2117 //Now get the number of pixels including the canvas borders
2118 Int_t bnpx = GetWindowWidth();
2119 Int_t bnpy = GetWindowHeight();
2120
2121 if (axis==1) {
2122 SetCanvasSize(TMath::Nint(npy*ratio2), npy);
2123 SetWindowSize((bnpx-npx)+TMath::Nint(npy*ratio2), bnpy);
2124 } else if (axis==2) {
2125 SetCanvasSize(npx, TMath::Nint(npx/ratio2));
2126 SetWindowSize(bnpx, (bnpy-npy)+TMath::Nint(npx/ratio2));
2127 } else {
2128 Error("SetRealAspectRatio", "axis value %d is neither 1 (resize along x-axis) nor 2 (resize along y-axis).",axis);
2129 return false;
2130 }
2131
2132 //Check now that resizing has worked
2133
2134 Update();
2135
2136 //Get how many pixels are occupied by the canvas
2137 npx = GetWw();
2138 npy = GetWh();
2139
2140 //Get x-y coordinates at the edges of the canvas (extrapolating outside the axes,
2141 //NOT at the edges of the histogram)
2142 x1 = GetX1();
2143 y1 = GetY1();
2144 x2 = GetX2();
2145 y2 = GetY2();
2146
2147 //Get the length of extrapolated x and y axes
2148 xlength2 = x2 - x1;
2149 ylength2 = y2 - y1;
2150 ratio2 = xlength2/ylength2;
2151
2152 //Check accuracy +/-1 pixel due to rounding
2153 if (abs(TMath::Nint(npy*ratio2) - npx)<2) {
2154 return true;
2155 } else {
2156 Error("SetRealAspectRatio", "Resizing failed.");
2157 return false;
2158 }
2159}
2160
2161
2162////////////////////////////////////////////////////////////////////////////////
2163/// Set selected canvas.
2164
2166{
2167 fSelected = obj;
2168 if (obj) obj->SetBit(kMustCleanup);
2169}
2170
2171////////////////////////////////////////////////////////////////////////////////
2172/// Set canvas title.
2173
2174void TCanvas::SetTitle(const char *title)
2175{
2176 fTitle = title;
2178}
2179
2180////////////////////////////////////////////////////////////////////////////////
2181/// Set canvas window position
2182
2184{
2185 if (fCanvasImp)
2187}
2188
2189////////////////////////////////////////////////////////////////////////////////
2190/// Set canvas window size
2191
2193{
2194 if (fBatch)
2195 SetCanvasSize((ww + fCw) / 2, (wh + fCh) / 2);
2196 else if (fCanvasImp)
2197 fCanvasImp->SetWindowSize(ww, wh);
2198}
2199
2200////////////////////////////////////////////////////////////////////////////////
2201/// Set the canvas scale in centimeters.
2202///
2203/// This information is used by PostScript to set the page size.
2204///
2205/// \param[in] xsize size of the canvas in centimeters along X
2206/// \param[in] ysize size of the canvas in centimeters along Y
2207///
2208/// if xsize and ysize are not equal to 0, then the scale factors will
2209/// be computed to keep the ratio ysize/xsize independently of the canvas
2210/// size (parts of the physical canvas will be unused).
2211///
2212/// if xsize = 0 and ysize is not zero, then xsize will be computed
2213/// to fit to the current canvas scale. If the canvas is resized,
2214/// a new value for xsize will be recomputed. In this case the aspect
2215/// ratio is not preserved.
2216///
2217/// if both xsize = 0 and ysize = 0, then the scaling is automatic.
2218/// the largest dimension will be allocated a size of 20 centimeters.
2219
2220void TCanvas::Size(Float_t xsize, Float_t ysize)
2221{
2222 fXsizeUser = xsize;
2223 fYsizeUser = ysize;
2224
2225 Resize();
2226}
2227
2228////////////////////////////////////////////////////////////////////////////////
2229/// Show canvas
2230
2231void TCanvas::Show()
2232{
2233 if (fCanvasImp)
2234 fCanvasImp->Show();
2235}
2236
2237////////////////////////////////////////////////////////////////////////////////
2238/// Stream a class object.
2239
2241{
2242 UInt_t R__s, R__c;
2243 if (b.IsReading()) {
2244 Version_t v = b.ReadVersion(&R__s, &R__c);
2245 gPad = this;
2246 fCanvas = this;
2247 if (v>7) b.ClassBegin(TCanvas::IsA());
2248 if (v>7) b.ClassMember("TPad");
2250 gPad = this;
2251 //restore the colors
2252 TObjArray *colors = (TObjArray*)fPrimitives->FindObject("ListOfColors");
2253 if (colors) {
2254 TIter next(colors);
2255 TColor *colold;
2256 while ((colold = (TColor*)next())) {
2257 if (colold) {
2258 Int_t cn = 0;
2259 if (colold) cn = colold->GetNumber();
2260 TColor *colcur = gROOT->GetColor(cn);
2261 if (colcur) {
2262 colcur->SetRGB(colold->GetRed(),colold->GetGreen(),colold->GetBlue());
2263 } else {
2264 colcur = new TColor(cn,colold->GetRed(),
2265 colold->GetGreen(),
2266 colold->GetBlue(),
2267 colold->GetName());
2268 if (!colcur) return;
2269 }
2270 }
2271 }
2272 //restore the palette if needed
2273 TObjArray *currentpalette = (TObjArray*)fPrimitives->FindObject("CurrentColorPalette");
2274 if (currentpalette) {
2275 TIter nextpal(currentpalette);
2276 Int_t n = currentpalette->GetEntries();
2277 TArrayI palcolors(n);
2278 TColor *col = 0;
2279 Int_t i = 0;
2280 while ((col = (TColor*)nextpal())) palcolors[i++] = col->GetNumber();
2281 gStyle->SetPalette(n,palcolors.GetArray());
2282 fPrimitives->Remove(currentpalette);
2283 delete currentpalette;
2284 }
2286 colors->Delete();
2287 delete colors;
2288 }
2289
2290 if (v>7) b.ClassMember("fDISPLAY","TString");
2292 if (v>7) b.ClassMember("fDoubleBuffer", "Int_t");
2293 b >> fDoubleBuffer;
2294 if (v>7) b.ClassMember("fRetained", "Bool_t");
2295 b >> fRetained;
2296 if (v>7) b.ClassMember("fXsizeUser", "Size_t");
2297 b >> fXsizeUser;
2298 if (v>7) b.ClassMember("fYsizeUser", "Size_t");
2299 b >> fYsizeUser;
2300 if (v>7) b.ClassMember("fXsizeReal", "Size_t");
2301 b >> fXsizeReal;
2302 if (v>7) b.ClassMember("fYsizeReal", "Size_t");
2303 b >> fYsizeReal;
2304 fCanvasID = -1;
2305 if (v>7) b.ClassMember("fWindowTopX", "Int_t");
2306 b >> fWindowTopX;
2307 if (v>7) b.ClassMember("fWindowTopY", "Int_t");
2308 b >> fWindowTopY;
2309 if (v > 2) {
2310 if (v>7) b.ClassMember("fWindowWidth", "UInt_t");
2311 b >> fWindowWidth;
2312 if (v>7) b.ClassMember("fWindowHeight", "UInt_t");
2313 b >> fWindowHeight;
2314 }
2315 if (v>7) b.ClassMember("fCw", "UInt_t");
2316 b >> fCw;
2317 if (v>7) b.ClassMember("fCh", "UInt_t");
2318 b >> fCh;
2319 if (v <= 2) {
2320 fWindowWidth = fCw;
2322 }
2323 if (v>7) b.ClassMember("fCatt", "TAttCanvas");
2324 fCatt.Streamer(b);
2325 Bool_t dummy;
2326 if (v>7) b.ClassMember("kMoveOpaque", "Bool_t");
2327 b >> dummy; if (dummy) MoveOpaque(1);
2328 if (v>7) b.ClassMember("kResizeOpaque", "Bool_t");
2329 b >> dummy; if (dummy) ResizeOpaque(1);
2330 if (v>7) b.ClassMember("fHighLightColor", "Color_t");
2331 b >> fHighLightColor;
2332 if (v>7) b.ClassMember("fBatch", "Bool_t");
2333 b >> dummy; //was fBatch
2334 if (v < 2) return;
2335 if (v>7) b.ClassMember("kShowEventStatus", "Bool_t");
2336 b >> dummy; if (dummy) SetBit(kShowEventStatus);
2337
2338 if (v > 3) {
2339 if (v>7) b.ClassMember("kAutoExec", "Bool_t");
2340 b >> dummy; if (dummy) SetBit(kAutoExec);
2341 }
2342 if (v>7) b.ClassMember("kMenuBar", "Bool_t");
2343 b >> dummy; if (dummy) SetBit(kMenuBar);
2344 fBatch = gROOT->IsBatch();
2345 if (v>7) b.ClassEnd(TCanvas::IsA());
2346 b.CheckByteCount(R__s, R__c, TCanvas::IsA());
2347 } else {
2348 //save list of colors
2349 //we must protect the case when two or more canvases are saved
2350 //in the same buffer. If the list of colors has already been saved
2351 //in the buffer, do not add the list of colors to the list of primitives.
2352 TObjArray *colors = 0;
2353 TObjArray *CurrentColorPalette = 0;
2354 if (TColor::DefinedColors()) {
2355 if (!b.CheckObject(gROOT->GetListOfColors(),TObjArray::Class())) {
2356 colors = (TObjArray*)gROOT->GetListOfColors();
2358 }
2359 //save the current palette
2361 Int_t palsize = pal.GetSize();
2362 CurrentColorPalette = new TObjArray();
2363 CurrentColorPalette->SetName("CurrentColorPalette");
2364 for (Int_t i=0; i<palsize; i++) CurrentColorPalette->Add(gROOT->GetColor(pal[i]));
2365 fPrimitives->Add(CurrentColorPalette);
2366 }
2367
2368 R__c = b.WriteVersion(TCanvas::IsA(), kTRUE);
2369 b.ClassBegin(TCanvas::IsA());
2370 b.ClassMember("TPad");
2373 if (CurrentColorPalette) { fPrimitives->Remove(CurrentColorPalette); delete CurrentColorPalette; }
2374 b.ClassMember("fDISPLAY","TString");
2376 b.ClassMember("fDoubleBuffer", "Int_t");
2377 b << fDoubleBuffer;
2378 b.ClassMember("fRetained", "Bool_t");
2379 b << fRetained;
2380 b.ClassMember("fXsizeUser", "Size_t");
2381 b << fXsizeUser;
2382 b.ClassMember("fYsizeUser", "Size_t");
2383 b << fYsizeUser;
2384 b.ClassMember("fXsizeReal", "Size_t");
2385 b << fXsizeReal;
2386 b.ClassMember("fYsizeReal", "Size_t");
2387 b << fYsizeReal;
2389 Int_t topx = fWindowTopX, topy = fWindowTopY;
2390 UInt_t editorWidth = 0;
2391 if(fCanvasImp) editorWidth = fCanvasImp->GetWindowGeometry(topx,topy,w,h);
2392 b.ClassMember("fWindowTopX", "Int_t");
2393 b << topx;
2394 b.ClassMember("fWindowTopY", "Int_t");
2395 b << topy;
2396 b.ClassMember("fWindowWidth", "UInt_t");
2397 b << (UInt_t)(w-editorWidth);
2398 b.ClassMember("fWindowHeight", "UInt_t");
2399 b << h;
2400 b.ClassMember("fCw", "UInt_t");
2401 b << fCw;
2402 b.ClassMember("fCh", "UInt_t");
2403 b << fCh;
2404 b.ClassMember("fCatt", "TAttCanvas");
2405 fCatt.Streamer(b);
2406 b.ClassMember("kMoveOpaque", "Bool_t");
2407 b << TestBit(kMoveOpaque); //please remove in ROOT version 6
2408 b.ClassMember("kResizeOpaque", "Bool_t");
2409 b << TestBit(kResizeOpaque); //please remove in ROOT version 6
2410 b.ClassMember("fHighLightColor", "Color_t");
2411 b << fHighLightColor;
2412 b.ClassMember("fBatch", "Bool_t");
2413 b << fBatch; //please remove in ROOT version 6
2414 b.ClassMember("kShowEventStatus", "Bool_t");
2415 b << TestBit(kShowEventStatus); //please remove in ROOT version 6
2416 b.ClassMember("kAutoExec", "Bool_t");
2417 b << TestBit(kAutoExec); //please remove in ROOT version 6
2418 b.ClassMember("kMenuBar", "Bool_t");
2419 b << TestBit(kMenuBar); //please remove in ROOT version 6
2420 b.ClassEnd(TCanvas::IsA());
2421 b.SetByteCount(R__c, kTRUE);
2422 }
2423}
2424
2425////////////////////////////////////////////////////////////////////////////////
2426/// Toggle pad auto execution of list of TExecs.
2427
2429{
2430 Bool_t autoExec = TestBit(kAutoExec);
2431 SetBit(kAutoExec,!autoExec);
2432}
2433
2434////////////////////////////////////////////////////////////////////////////////
2435/// Toggle event statusbar.
2436
2438{
2439 Bool_t showEventStatus = !TestBit(kShowEventStatus);
2440 SetBit(kShowEventStatus,showEventStatus);
2441
2442 if (fCanvasImp) fCanvasImp->ShowStatusBar(showEventStatus);
2443}
2444
2445////////////////////////////////////////////////////////////////////////////////
2446/// Toggle toolbar.
2447
2449{
2450 Bool_t showToolBar = !TestBit(kShowToolBar);
2451 SetBit(kShowToolBar,showToolBar);
2452
2453 if (fCanvasImp) fCanvasImp->ShowToolBar(showToolBar);
2454}
2455
2456////////////////////////////////////////////////////////////////////////////////
2457/// Toggle editor.
2458
2460{
2461 Bool_t showEditor = !TestBit(kShowEditor);
2462 SetBit(kShowEditor,showEditor);
2463
2464 if (fCanvasImp) fCanvasImp->ShowEditor(showEditor);
2465}
2466
2467////////////////////////////////////////////////////////////////////////////////
2468/// Toggle tooltip display.
2469
2471{
2472 Bool_t showToolTips = !TestBit(kShowToolTips);
2473 SetBit(kShowToolTips, showToolTips);
2474
2475 if (fCanvasImp) fCanvasImp->ShowToolTips(showToolTips);
2476}
2477
2478
2479////////////////////////////////////////////////////////////////////////////////
2480/// Static function returning "true" if transparency is supported.
2481
2483{
2484 return gPad && (gVirtualX->InheritsFrom("TGQuartz") ||
2485 gPad->GetGLDevice() != -1);
2486}
2487
2488extern "C" void ROOT_TCanvas_Update(void* TheCanvas) {
2489 static_cast<TCanvas*>(TheCanvas)->Update();
2490}
2491
2492////////////////////////////////////////////////////////////////////////////////
2493/// Update canvas pad buffers.
2494
2495void TCanvas::Update()
2496{
2497 if (fUpdating) return;
2498
2499 if (fPixmapID == -1) return;
2500
2501 static const union CastFromFuncToVoidPtr_t {
2502 CastFromFuncToVoidPtr_t(): fFuncPtr(ROOT_TCanvas_Update) {}
2503 void (*fFuncPtr)(void*);
2504 void* fVoidPtr;
2505 } castFromFuncToVoidPtr;
2506
2507 if (gThreadXAR) {
2508 void *arr[3];
2509 arr[1] = this;
2510 arr[2] = castFromFuncToVoidPtr.fVoidPtr;
2511 if ((*gThreadXAR)("CUPD", 3, arr, 0)) return;
2512 }
2513
2514 if (!fCanvasImp) return;
2515
2516 if (!gVirtualX->IsCmdThread()) {
2517 // Why do we have this (which uses the interpreter to funnel the Update()
2518 // through the main thread) when the gThreadXAR mechanism does seemingly
2519 // the same?
2520 gInterpreter->Execute(this, IsA(), "Update", "");
2521 return;
2522 }
2523
2525
2526 fUpdating = kTRUE;
2527
2528 if (!fCanvasImp->PerformUpdate()) {
2529
2530 if (!IsBatch()) FeedbackMode(kFALSE); // Goto double buffer mode
2531
2532 if (!UseGL() || fGLDevice == -1) PaintModified(); // Repaint all modified pad's
2533
2534 Flush(); // Copy all pad pixmaps to the screen
2535
2537 }
2538
2539 fUpdating = kFALSE;
2540}
2541
2542////////////////////////////////////////////////////////////////////////////////
2543/// Used by friend class TCanvasImp.
2544
2546{
2547 fCanvasID = 0;
2548 fContextMenu = 0;
2549}
2550
2551////////////////////////////////////////////////////////////////////////////////
2552/// Check whether this canvas is to be drawn in grayscale mode.
2553
2555{
2556 return TestBit(kIsGrayscale);
2557}
2558
2559////////////////////////////////////////////////////////////////////////////////
2560/// Set whether this canvas should be painted in grayscale, and re-paint
2561/// it if necessary.
2562
2563void TCanvas::SetGrayscale(Bool_t set /*= kTRUE*/)
2564{
2565 if (IsGrayscale() == set) return;
2566 SetBit(kIsGrayscale, set);
2567 Paint(); // update canvas and all sub-pads, unconditionally!
2568}
2569
2570////////////////////////////////////////////////////////////////////////////////
2571/// Probably, TPadPainter must be placed in a separate ROOT module -
2572/// "padpainter" (the same as "histpainter"). But now, it's directly in a
2573/// gpad dir, so, in case of default painter, no *.so should be loaded,
2574/// no need in plugin managers.
2575/// May change in future.
2576
2578{
2579 //Even for batch mode painter is still required, just to delegate
2580 //some calls to batch "virtual X".
2581 if (!UseGL() || fBatch) {
2582 fPainter = 0;
2584 if (!fPainter) fPainter = new TPadPainter; // Do not need plugin manager for this!
2585 } else {
2587 if (!fPainter) {
2588 Error("CreatePainter", "GL Painter creation failed! Will use default!");
2589 fPainter = new TPadPainter;
2590 fUseGL = kFALSE;
2591 }
2592 }
2593}
2594
2595////////////////////////////////////////////////////////////////////////////////
2596/// Access and (probably) creation of pad painter.
2597
2599{
2600 if (!fPainter) CreatePainter();
2601 return fPainter;
2602}
2603
2604
2605////////////////////////////////////////////////////////////////////////////////
2606///assert on IsBatch() == false?
2607
2609{
2610 if (fGLDevice != -1) {
2611 //fPainter has a font manager.
2612 //Font manager will delete textures.
2613 //If context is wrong (we can have several canvases) -
2614 //wrong texture will be deleted, damaging some of our fonts.
2615 gGLManager->MakeCurrent(fGLDevice);
2616 }
2617
2619
2620 if (fGLDevice != -1) {
2621 gGLManager->DeleteGLContext(fGLDevice);//?
2622 fGLDevice = -1;
2623 }
2624}
EEventType
Definition: Buttons.h:15
@ kButton1ShiftMotion
Definition: Buttons.h:18
@ kMouseMotion
Definition: Buttons.h:23
@ kWheelUp
Definition: Buttons.h:18
@ kButton3Up
Definition: Buttons.h:19
@ kButton2Motion
Definition: Buttons.h:20
@ kButton3Motion
Definition: Buttons.h:20
@ kButton3Down
Definition: Buttons.h:17
@ kButton2Down
Definition: Buttons.h:17
@ kKeyPress
Definition: Buttons.h:20
@ kButton2Double
Definition: Buttons.h:24
@ kArrowKeyRelease
Definition: Buttons.h:21
@ kButton1Double
Definition: Buttons.h:24
@ kButton3Double
Definition: Buttons.h:24
@ kButton1Shift
Definition: Buttons.h:18
@ kButton1Motion
Definition: Buttons.h:20
@ kButton1Up
Definition: Buttons.h:19
@ kWheelDown
Definition: Buttons.h:18
@ kArrowKeyPress
Definition: Buttons.h:21
@ kButton2Up
Definition: Buttons.h:19
@ kMouseLeave
Definition: Buttons.h:23
@ kButton1Down
Definition: Buttons.h:17
@ kMouseEnter
Definition: Buttons.h:23
ECursor
Definition: GuiTypes.h:372
@ kCross
Definition: GuiTypes.h:374
#define SafeDelete(p)
Definition: RConfig.hxx:534
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
bool Bool_t
Definition: RtypesCore.h:63
int Int_t
Definition: RtypesCore.h:45
float Size_t
Definition: RtypesCore.h:96
long Longptr_t
Definition: RtypesCore.h:82
short Version_t
Definition: RtypesCore.h:65
const Bool_t kFALSE
Definition: RtypesCore.h:101
unsigned int UInt_t
Definition: RtypesCore.h:46
float Float_t
Definition: RtypesCore.h:57
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
@ kRed
Definition: Rtypes.h:66
R__EXTERN TApplication * gApplication
Definition: TApplication.h:165
void ROOT_TCanvas_Update(void *TheCanvas)
Definition: TCanvas.cxx:2485
class TCanvasInit gCanvasInit
const Size_t kDefaultCanvasSize
Definition: TCanvas.cxx:61
R__EXTERN TEnv * gEnv
Definition: TEnv.h:170
ClassImpQ(TGImageMap) TGRegionWithId *gCurrentRegion
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t cursor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char cname
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char mode
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TGuiFactory * gBatchGuiFactory
Definition: TGuiFactory.h:67
R__EXTERN TGuiFactory * gGuiFactory
Definition: TGuiFactory.h:66
#define gInterpreter
Definition: TInterpreter.h:564
Int_t gDebug
Definition: TROOT.cxx:585
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:63
#define gROOT
Definition: TROOT.h:404
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2447
R__EXTERN TStyle * gStyle
Definition: TStyle.h:414
#define gGLManager
Definition: TVirtualGL.h:160
#define R__LOCKGUARD(mutex)
R__EXTERN TVirtualPS * gVirtualPS
Definition: TVirtualPS.h:81
#define gPad
Definition: TVirtualPad.h:288
R__EXTERN Int_t(* gThreadXAR)(const char *xact, Int_t nb, void **ar, Int_t *iret)
Definition: TVirtualPad.h:290
#define gVirtualX
Definition: TVirtualX.h:338
Color * colors
Definition: X3DBuffer.c:21
#define snprintf
Definition: civetweb.c:1540
void InitializeGraphics()
Initialize the graphics environment.
static void CreateApplication()
Static function used to create a default application environment.
static void NeedGraphicsLibs()
Static method.
Array of integers (32 bits per element).
Definition: TArrayI.h:27
const Int_t * GetArray() const
Definition: TArrayI.h:43
Int_t GetSize() const
Definition: TArray.h:47
virtual void Streamer(TBuffer &)
Fill Area Attributes class.
Definition: TAttFill.h:19
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
void Copy(TAttFill &attfill) const
Copy this fill attributes to a new TAttFill.
Definition: TAttFill.cxx:204
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
Line Attributes class.
Definition: TAttLine.h:18
void Copy(TAttLine &attline) const
Copy this line attributes to a new TAttLine.
Definition: TAttLine.cxx:175
Manages default Pad attributes.
Definition: TAttPad.h:19
virtual void SetBottomMargin(Float_t bottommargin)
Set Pad bottom margin in fraction of the pad height.
Definition: TAttPad.cxx:99
virtual void SetLeftMargin(Float_t leftmargin)
Set Pad left margin in fraction of the pad width.
Definition: TAttPad.cxx:109
virtual void Copy(TAttPad &attpad) const
copy function
Definition: TAttPad.cxx:44
virtual void SetRightMargin(Float_t rightmargin)
Set Pad right margin in fraction of the pad width.
Definition: TAttPad.cxx:119
virtual void SetTopMargin(Float_t topmargin)
Set Pad top margin in fraction of the pad height.
Definition: TAttPad.cxx:129
Class to manage histogram axis.
Definition: TAxis.h:30
static TClass * Class()
virtual Bool_t GetTimeDisplay() const
Definition: TAxis.h:127
virtual const char * GetTimeFormat() const
Definition: TAxis.h:128
Create a Box.
Definition: TBox.h:22
static TClass * Class()
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual void Show()
Definition: TCanvasImp.h:66
virtual void Iconify()
Definition: TCanvasImp.h:59
virtual Int_t InitWindow()
Definition: TCanvasImp.h:60
virtual void Close()
Definition: TCanvasImp.h:56
virtual void SetWindowPosition(Int_t x, Int_t y)
Definition: TCanvasImp.h:90
virtual void SetWindowTitle(const char *newTitle)
Definition: TCanvasImp.h:92
virtual Bool_t IsWeb() const
Definition: TCanvasImp.h:45
virtual TVirtualPadPainter * CreatePadPainter()
Definition: TCanvasImp.h:47
virtual void ShowToolBar(Bool_t show=kTRUE)
Definition: TCanvasImp.h:100
virtual void RaiseWindow()
Definition: TCanvasImp.h:96
virtual void SetStatusText(const char *text=nullptr, Int_t partidx=0)
Definition: TCanvasImp.h:89
virtual void ShowMenuBar(Bool_t show=kTRUE)
Definition: TCanvasImp.h:94
virtual void ShowEditor(Bool_t show=kTRUE)
Definition: TCanvasImp.h:99
virtual Bool_t PerformUpdate()
Definition: TCanvasImp.h:46
virtual void SetWindowSize(UInt_t w, UInt_t h)
Definition: TCanvasImp.h:91
virtual void ShowStatusBar(Bool_t show=kTRUE)
Definition: TCanvasImp.h:95
virtual void ShowToolTips(Bool_t show=kTRUE)
Definition: TCanvasImp.h:101
virtual UInt_t GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
Definition: TCanvasImp.h:87
virtual void ForceUpdate()
Definition: TCanvasImp.h:57
virtual void SetCanvasSize(UInt_t w, UInt_t h)
Definition: TCanvasImp.h:93
The Canvas class.
Definition: TCanvas.h:23
void Init()
Initialize the TCanvas members. Called by all constructors.
Definition: TCanvas.cxx:525
UInt_t fCw
Width of the canvas along X (pixels)
Definition: TCanvas.h:42
void EmbedInto(Int_t winid, Int_t ww, Int_t wh)
Embedded a canvas into a TRootEmbeddedCanvas.
Definition: TCanvas.cxx:1037
void SetWindowSize(UInt_t ww, UInt_t wh)
Set canvas window size.
Definition: TCanvas.cxx:2189
static void SetFolder(Bool_t isfolder=kTRUE)
If isfolder=kTRUE, the canvas can be browsed like a folder by default a canvas is not browsable.
Definition: TCanvas.cxx:2044
void Browse(TBrowser *b) override
Browse.
Definition: TCanvas.cxx:672
UInt_t GetWindowHeight() const
Definition: TCanvas.h:160
virtual void EditorBar()
Get editor bar.
Definition: TCanvas.cxx:1028
static TCanvas * MakeDefCanvas()
Static function to build a default canvas.
Definition: TCanvas.cxx:1504
void EnterLeave(TPad *prevSelPad, TObject *prevSelObj)
Generate kMouseEnter and kMouseLeave events depending on the previously selected object and the curre...
Definition: TCanvas.cxx:1063
Size_t fYsizeReal
Current size of canvas along Y in CM.
Definition: TCanvas.h:35
void Constructor()
Canvas default constructor.
Definition: TCanvas.cxx:181
virtual void ToggleAutoExec()
Toggle pad auto execution of list of TExecs.
Definition: TCanvas.cxx:2425
TCanvas(const TCanvas &canvas)=delete
Int_t fWindowTopX
Top X position of window (in pixels)
Definition: TCanvas.h:38
void Draw(Option_t *option="") override
Draw a canvas.
Definition: TCanvas.cxx:843
void SetDoubleBuffer(Int_t mode=1) override
Set Double Buffer On/Off.
Definition: TCanvas.cxx:2005
virtual void ToggleToolTips()
Toggle tooltip display.
Definition: TCanvas.cxx:2467
void Clear(Option_t *option="") override
Remove all primitives from the canvas.
Definition: TCanvas.cxx:725
void UseCurrentStyle() override
Force a copy of current style for all objects in canvas.
Definition: TCanvas.cxx:1174
void Iconify()
Iconify canvas.
Definition: TCanvas.cxx:1467
Int_t GetWindowTopX()
Returns current top x position of window on screen.
Definition: TCanvas.cxx:1199
Bool_t IsWeb() const
Is web canvas.
Definition: TCanvas.cxx:1484
virtual void ToggleEventStatus()
Toggle event statusbar.
Definition: TCanvas.cxx:2434
void Destructor()
Actual canvas destructor.
Definition: TCanvas.cxx:682
void DeleteCanvasPainter()
assert on IsBatch() == false?
Definition: TCanvas.cxx:2605
TPad * fPadSave
! Pointer to saved pad in HandleInput
Definition: TCanvas.h:55
static Bool_t SupportAlpha()
Static function returning "true" if transparency is supported.
Definition: TCanvas.cxx:2479
Bool_t fBatch
! True when in batchmode
Definition: TCanvas.h:58
Bool_t fUseGL
! True when rendering is with GL
Definition: TCanvas.h:61
Int_t fEventX
! Last X mouse position in canvas
Definition: TCanvas.h:45
Bool_t IsBatch() const override
Definition: TCanvas.h:169
TObject * DrawClone(Option_t *option="") const override
Draw a clone of this canvas A new canvas is created that is a clone of this canvas.
Definition: TCanvas.cxx:890
Size_t fXsizeReal
Current size of canvas along X in CM.
Definition: TCanvas.h:34
Bool_t HasMenuBar() const
Definition: TCanvas.h:166
TVirtualPadPainter * GetCanvasPainter()
Access and (probably) creation of pad painter.
Definition: TCanvas.cxx:2595
virtual void HighlightConnect(const char *slot)
This is "simplification" for function TCanvas::Connect with Highlighted signal for specific slot.
Definition: TCanvas.cxx:1629
TPad * Pick(Int_t px, Int_t py, TObjLink *&pickobj) override
Search for an object at pixel position px,py.
Definition: TCanvas.h:180
void Close(Option_t *option="") override
Close canvas.
Definition: TCanvas.cxx:776
void SetFixedAspectRatio(Bool_t fixed=kTRUE) override
Fix canvas aspect ratio to current value if fixed is true.
Definition: TCanvas.cxx:2022
virtual void Resize(Option_t *option="")
Recompute canvas parameters following a X11 Resize.
Definition: TCanvas.cxx:1666
Color_t GetHighLightColor() const override
Definition: TCanvas.h:136
Bool_t GetShowToolBar() const
Definition: TCanvas.h:147
void DrawEventStatus(Int_t event, Int_t x, Int_t y, TObject *selected)
Report name and title of primitive below the cursor.
Definition: TCanvas.cxx:962
Bool_t IsFolder() const override
Is folder ?
Definition: TCanvas.cxx:1476
UInt_t fWindowWidth
Width of window (including borders, etc.)
Definition: TCanvas.h:40
TVirtualPadPainter * fPainter
! Canvas (pad) painter.
Definition: TCanvas.h:64
void CopyPixmaps() override
Copy the canvas pixmap of the pad to the canvas.
Definition: TCanvas.cxx:825
Bool_t IsGrayscale()
Check whether this canvas is to be drawn in grayscale mode.
Definition: TCanvas.cxx:2551
TPad * fClickSelectedPad
! Pad containing currently click-selected object
Definition: TCanvas.h:54
Bool_t fUpdating
! True when Updating the canvas
Definition: TCanvas.h:59
void SaveSource(const char *filename="", Option_t *option="")
Save primitives in this canvas as a C++ macro file.
Definition: TCanvas.cxx:1824
Color_t fHighLightColor
Highlight color of active pad.
Definition: TCanvas.h:36
virtual void Size(Float_t xsizeuser=0, Float_t ysizeuser=0)
Set the canvas scale in centimeters.
Definition: TCanvas.cxx:2217
virtual void ProcessedEvent(Int_t event, Int_t x, Int_t y, TObject *selected)
Emit ProcessedEvent() signal.
Definition: TCanvas.cxx:1651
virtual void HandleInput(EEventType button, Int_t x, Int_t y)
Handle Input Events.
Definition: TCanvas.cxx:1223
Size_t fXsizeUser
User specified size of canvas along X in CM.
Definition: TCanvas.h:32
Int_t fEventY
! Last Y mouse position in canvas
Definition: TCanvas.h:46
TVirtualPad * cd(Int_t subpadnumber=0) override
Set current canvas & pad.
Definition: TCanvas.cxx:706
UInt_t fWindowHeight
Height of window (including menubar, borders, etc.)
Definition: TCanvas.h:41
Int_t GetWindowTopY()
Returns current top y position of window on screen.
Definition: TCanvas.cxx:1210
TObject * fClickSelected
! Currently click-selected object
Definition: TCanvas.h:49
void SetCanvasSize(UInt_t ww, UInt_t wh) override
Set Width and Height of canvas to ww and wh respectively.
Definition: TCanvas.cxx:1980
void Show()
Show canvas.
Definition: TCanvas.cxx:2228
TPad * fSelectedPad
! Pad containing currently selected object
Definition: TCanvas.h:53
virtual void Selected(TVirtualPad *pad, TObject *obj, Int_t event)
Emit Selected() signal.
Definition: TCanvas.cxx:1637
Int_t fSelectedX
! X of selected object
Definition: TCanvas.h:50
virtual void ToggleEditor()
Toggle editor.
Definition: TCanvas.cxx:2456
TVirtualPad * GetSelectedPad() const override
Definition: TCanvas.h:144
virtual void Picked(TPad *selpad, TObject *selected, Int_t event)
Emit Picked() signal.
Definition: TCanvas.cxx:1591
TObject * fSelected
! Currently selected object
Definition: TCanvas.h:48
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitives in this canvas in C++ macro file with GUI.
Definition: TCanvas.cxx:1779
void SetCursor(ECursor cursor) override
Set cursor.
Definition: TCanvas.cxx:1996
void Streamer(TBuffer &) override
Stream a class object.
Definition: TCanvas.cxx:2237
Bool_t GetShowToolTips() const
Definition: TCanvas.h:149
Int_t fCanvasID
! Canvas identifier
Definition: TCanvas.h:47
void SetGrayscale(Bool_t set=kTRUE)
Set whether this canvas should be painted in grayscale, and re-paint it if necessary.
Definition: TCanvas.cxx:2560
void SetTitle(const char *title="") override
Set canvas title.
Definition: TCanvas.cxx:2171
UInt_t fCh
Height of the canvas along Y (pixels)
Definition: TCanvas.h:43
TContextMenu * fContextMenu
! Context menu pointer
Definition: TCanvas.h:57
TAttCanvas fCatt
Canvas attributes.
Definition: TCanvas.h:30
void SetName(const char *name="") override
Set canvas name. In case name is an empty string, a default name is set.
Definition: TCanvas.cxx:2052
UInt_t GetWindowWidth() const
Definition: TCanvas.h:159
Bool_t fRetained
Retain structure flag.
Definition: TCanvas.h:60
void DisconnectWidget()
Used by friend class TCanvasImp.
Definition: TCanvas.cxx:2542
void FeedbackMode(Bool_t set)
Turn rubberband feedback mode on or off.
Definition: TCanvas.cxx:1118
void ls(Option_t *option="") const override
List all pads.
Definition: TCanvas.cxx:1492
void RaiseWindow()
Raise canvas window.
Definition: TCanvas.cxx:1745
void Build()
Build a canvas. Called by all constructors.
Definition: TCanvas.cxx:574
Int_t fWindowTopY
Top Y position of window (in pixels)
Definition: TCanvas.h:39
void Paint(Option_t *option="") override
Paint canvas.
Definition: TCanvas.cxx:1541
TClass * IsA() const override
Definition: TCanvas.h:231
void Update() override
Update canvas pad buffers.
Definition: TCanvas.cxx:2492
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition: TCanvas.cxx:1100
void RunAutoExec()
Execute the list of TExecs in the current pad.
Definition: TCanvas.cxx:1768
virtual void Cleared(TVirtualPad *pad)
Emit pad Cleared signal.
Definition: TCanvas.cxx:758
UInt_t GetWw() const override
Definition: TCanvas.h:161
TCanvasImp * fCanvasImp
! Window system specific canvas implementation
Definition: TCanvas.h:56
UInt_t GetWh() const override
Definition: TCanvas.h:162
virtual void Highlighted(TVirtualPad *pad, TObject *obj, Int_t x, Int_t y)
Emit Highlighted() signal.
Definition: TCanvas.cxx:1610
void Flush()
Flush canvas buffers.
Definition: TCanvas.cxx:1132
Size_t fYsizeUser
User specified size of canvas along Y in CM.
Definition: TCanvas.h:33
Int_t fDoubleBuffer
Double buffer flag (0=off, 1=on)
Definition: TCanvas.h:37
void ForceUpdate()
Force canvas update.
Definition: TCanvas.cxx:1166
void CreatePainter()
Probably, TPadPainter must be placed in a separate ROOT module - "padpainter" (the same as "histpaint...
Definition: TCanvas.cxx:2574
void SetSelected(TObject *obj) override
Set selected canvas.
Definition: TCanvas.cxx:2162
void MoveOpaque(Int_t set=1)
Set option to move objects/pads in a canvas.
Definition: TCanvas.cxx:1533
virtual ~TCanvas()
Canvas destructor.
Definition: TCanvas.cxx:664
static Bool_t fgIsFolder
Indicates if canvas can be browsed as a folder.
Definition: TCanvas.h:66
void Closed() override
Emit Closed signal.
Definition: TCanvas.cxx:766
void SetWindowPosition(Int_t x, Int_t y)
Set canvas window position.
Definition: TCanvas.cxx:2180
TString fDISPLAY
Name of destination screen.
Definition: TCanvas.h:31
bool SetRealAspectRatio(const Int_t axis=1)
Function to resize a canvas so that the plot inside is shown in real aspect ratio.
Definition: TCanvas.cxx:2095
Int_t fEvent
! Type of current or last handled event
Definition: TCanvas.h:44
Bool_t GetShowEventStatus() const
Definition: TCanvas.h:146
TString fSelectedOpt
! Drawing option of selected object
Definition: TCanvas.h:52
Int_t fSelectedY
! Y of selected object
Definition: TCanvas.h:51
Bool_t fDrawn
! Set to True when the Draw method is called
Definition: TCanvas.h:62
void SetBatch(Bool_t batch=kTRUE) override
Toggle batch mode.
Definition: TCanvas.cxx:1964
Bool_t UseGL() const
Definition: TCanvas.h:223
@ kResizeOpaque
Definition: TCanvas.h:93
@ kShowToolTips
Definition: TCanvas.h:95
@ kShowToolBar
Definition: TCanvas.h:90
@ kMoveOpaque
Definition: TCanvas.h:92
@ kIsGrayscale
Definition: TCanvas.h:94
@ kShowEventStatus
Definition: TCanvas.h:87
@ kAutoExec
Definition: TCanvas.h:88
@ kMenuBar
Definition: TCanvas.h:89
@ kShowEditor
Definition: TCanvas.h:91
void ResizeOpaque(Int_t set=1)
Set option to resize objects/pads in a canvas.
Definition: TCanvas.cxx:1760
virtual void ToggleToolBar()
Toggle toolbar.
Definition: TCanvas.cxx:2445
virtual TObject * DrawClonePad()
Draw a clone of this canvas into the current pad In an interactive session, select the destination/cu...
Definition: TCanvas.cxx:907
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
@ kRealNew
Definition: TClass.h:107
static ENewType IsCallingNew()
Static method returning the defConstructor flag passed to TClass::New().
Definition: TClass.cxx:5890
@ kClassSaved
Definition: TClass.h:94
void SetName(const char *name)
Definition: TCollection.h:206
void Browse(TBrowser *b) override
Browse this collection (called by TBrowser).
The color creation and management class.
Definition: TColor.h:19
virtual void SetRGB(Float_t r, Float_t g, Float_t b)
Initialize this color and its associated colors.
Definition: TColor.cxx:1758
static const TArrayI & GetPalette()
Static function returning the current active palette.
Definition: TColor.cxx:1461
Float_t GetRed() const
Definition: TColor.h:58
static void SaveColor(std::ostream &out, Int_t ci)
Save a color with index > 228 as a C++ statement(s) on output stream out.
Definition: TColor.cxx:2186
Int_t GetNumber() const
Definition: TColor.h:56
Float_t GetBlue() const
Definition: TColor.h:60
Float_t GetGreen() const
Definition: TColor.h:59
static Bool_t DefinedColors()
Static function returning kTRUE if some new colors have been defined after initialisation or since th...
Definition: TColor.cxx:1479
This class provides an interface to context sensitive popup menus.
Definition: TContextMenu.h:44
virtual void Popup(Int_t x, Int_t y, TObject *obj, TVirtualPad *c=nullptr, TVirtualPad *p=nullptr)
Popup context menu at given location in canvas c and pad p for selected object.
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition: TDatime.h:37
const char * AsSQLString() const
Return the date & time in SQL compatible string format, like: 1997-01-15 20:16:28.
Definition: TDatime.cxx:152
UInt_t Convert(Bool_t toGMT=kFALSE) const
Convert fDatime from TDatime format to the standard time_t format.
Definition: TDatime.cxx:182
const char * AsString() const
Return the date & time as a string (ctime() format).
Definition: TDatime.cxx:102
static TClass * Class()
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition: TEnv.cxx:491
A TGraph is an object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
virtual TCanvasImp * CreateCanvasImp(TCanvas *c, const char *title, UInt_t width, UInt_t height)
Create a batch version of TCanvasImp.
Definition: TGuiFactory.cxx:58
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
Option_t * GetOption() const
Definition: TCollection.h:253
void Reset()
Definition: TCollection.h:254
A doubly linked list.
Definition: TList.h:38
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition: TList.cxx:578
void Add(TObject *obj) override
Definition: TList.h:81
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition: TList.cxx:822
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
An array of TObjects.
Definition: TObjArray.h:31
Int_t GetEntries() const override
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:523
static TClass * Class()
void Add(TObject *obj) override
Definition: TObjArray.h:68
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void Clear(Option_t *="")
Definition: TObject.h:115
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TObject.cxx:146
@ kNotDeleted
object has not been deleted
Definition: TObject.h:78
R__ALWAYS_INLINE Bool_t IsOnHeap() const
Definition: TObject.h:148
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:879
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to an event at (px,py).
Definition: TObject.cxx:313
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Returns string containing info about the object at position (px,py).
Definition: TObject.cxx:388
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
virtual const char * GetTitle() const
Returns title of object.
Definition: TObject.cxx:403
virtual void Pop()
Pop on object drawn in a pad to the top of the display list.
Definition: TObject.cxx:530
void ResetBit(UInt_t f)
Definition: TObject.h:186
@ kNoContextMenu
if object does not want context menu
Definition: TObject.h:65
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition: TObject.h:60
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:867
Implement TVirtualPadPainter which abstracts painting operations.
Definition: TPadPainter.h:26
The most important graphics class in the ROOT system.
Definition: TPad.h:27
void SetGridx(Int_t value=1) override
Definition: TPad.h:328
Short_t GetBorderMode() const override
Definition: TPad.h:194
void SetBorderSize(Short_t bordersize) override
Definition: TPad.h:318
Int_t GetTicky() const override
Definition: TPad.h:234
void PaintBorder(Color_t color, Bool_t tops)
Paint the pad border.
Definition: TPad.cxx:3468
void ResizePad(Option_t *option="") override
Compute pad conversion coefficients.
Definition: TPad.cxx:5446
void SetGrid(Int_t valuex=1, Int_t valuey=1) override
Definition: TPad.h:327
void SetTickx(Int_t value=1) override
Definition: TPad.h:348
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitives in this pad on the C++ source file out.
Definition: TPad.cxx:5671
Bool_t GetGridx() const override
Definition: TPad.h:230
Double_t fX2
X of upper X coordinate.
Definition: TPad.h:35
void SetLogz(Int_t value=1) override
Set Lin/Log scale for Z.
Definition: TPad.cxx:5934
Double_t GetY2() const override
Definition: TPad.h:238
void Close(Option_t *option="") override
Delete all primitives in pad and pad itself.
Definition: TPad.cxx:976
void PaintModified() override
Traverse pad hierarchy and (re)paint only modified pads.
Definition: TPad.cxx:3636
const char * GetTitle() const override
Returns title of object.
Definition: TPad.h:256
Double_t fX1
X of lower X coordinate.
Definition: TPad.h:33
TList * GetListOfPrimitives() const override
Definition: TPad.h:240
void SetFillStyle(Style_t fstyle) override
Override TAttFill::FillStyle for TPad because we want to handle style=0 as style 4000.
Definition: TPad.cxx:5897
void SetPad(const char *name, const char *title, Double_t xlow, Double_t ylow, Double_t xup, Double_t yup, Color_t color=35, Short_t bordersize=5, Short_t bordermode=-1) override
Set all pad parameters.
Definition: TPad.cxx:5994
void UseCurrentStyle() override
Force a copy of current style for all objects in pad.
Definition: TPad.cxx:6747
void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2) override
Set world coordinate system for the pad.
Definition: TPad.cxx:5165
Double_t fY1
Y of lower Y coordinate.
Definition: TPad.h:34
Int_t fGLDevice
! OpenGL off-screen pixmap identifier
Definition: TPad.h:82
void Update() override
Update pad.
Definition: TPad.cxx:2823
void Clear(Option_t *option="") override
Delete all pad primitives.
Definition: TPad.cxx:628
Int_t GetTickx() const override
Definition: TPad.h:233
Double_t fAspectRatio
ratio of w/h in case of fixed ratio
Definition: TPad.h:79
void Modified(Bool_t flag=1) override
Definition: TPad.h:414
void SetLogy(Int_t value=1) override
Set Lin/Log scale for Y.
Definition: TPad.cxx:5923
void HighLight(Color_t col=kRed, Bool_t set=kTRUE) override
Highlight pad.
Definition: TPad.cxx:2927
TCanvas * fCanvas
! Pointer to mother canvas
Definition: TPad.h:103
Bool_t fFixedAspectRatio
True if fixed aspect ratio.
Definition: TPad.h:101
void ls(Option_t *option="") const override
List all primitives in pad.
Definition: TPad.cxx:2962
void Streamer(TBuffer &) override
Stream a class object.
Definition: TPad.cxx:6538
TString fTitle
Pad title.
Definition: TPad.h:107
void CopyPixmaps() override
Copy the sub-pixmaps of the pad to the canvas.
Definition: TPad.cxx:1048
void CopyPixmap() override
Copy the pixmap of the pad to the canvas.
Definition: TPad.cxx:1034
Double_t GetY1() const override
Definition: TPad.h:237
Bool_t GetGridy() const override
Definition: TPad.h:231
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition: TPad.cxx:1685
Int_t GetLogz() const override
Definition: TPad.h:253
Short_t GetBorderSize() const override
Definition: TPad.h:195
TList * fPrimitives
->List of primitives (subpads)
Definition: TPad.h:104
TCanvas * GetCanvas() const override
Definition: TPad.h:257
Short_t fBorderSize
pad bordersize in pixels
Definition: TPad.h:94
void SetGridy(Int_t value=1) override
Definition: TPad.h:329
void Paint(Option_t *option="") override
Paint all primitives in pad.
Definition: TPad.cxx:3407
TString fName
Pad name.
Definition: TPad.h:106
Int_t fPixmapID
! Off-screen pixmap identifier
Definition: TPad.h:81
Color_t GetHighLightColor() const override
Get highlight color.
Definition: TPad.cxx:2681
TVirtualPad * cd(Int_t subpadnumber=0) override
Set Current pad.
Definition: TPad.cxx:599
Int_t GetLogy() const override
Definition: TPad.h:252
void SetBorderMode(Short_t bordermode) override
Definition: TPad.h:317
void SetTicks(Int_t valuex=1, Int_t valuey=1) override
Definition: TPad.h:347
void SetTicky(Int_t value=1) override
Definition: TPad.h:349
Double_t fY2
Y of upper Y coordinate.
Definition: TPad.h:36
Short_t fBorderMode
Bordermode (-1=down, 0 = no border, 1=up)
Definition: TPad.h:95
void SetLogx(Int_t value=1) override
Set Lin/Log scale for X.
Definition: TPad.cxx:5909
Int_t GetLogx() const override
Definition: TPad.h:251
Double_t GetX2() const override
Definition: TPad.h:236
Double_t GetX1() const override
Definition: TPad.h:235
TPad * fMother
! pointer to mother of the list
Definition: TPad.h:102
const char * GetName() const override
Returns name of object.
Definition: TPad.h:255
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
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
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition: TROOT.cxx:2799
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition: TROOT.cxx:2807
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition: TROOT.cxx:2692
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1150
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1131
const char * Data() const
Definition: TString.h:369
@ kBoth
Definition: TString.h:267
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition: TString.cxx:916
Bool_t IsNull() const
Definition: TString.h:407
virtual void Streamer(TBuffer &)
Stream a string object.
Definition: TString.cxx:1370
TString & Append(const char *cs)
Definition: TString.h:564
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2314
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
Double_t GetTimeOffset() const
Definition: TStyle.h:261
Int_t GetOptLogy() const
Definition: TStyle.h:240
Int_t GetOptStat() const
Definition: TStyle.h:237
Int_t GetOptTitle() const
Definition: TStyle.h:238
void SetCanvasBorderSize(Width_t size=1)
Definition: TStyle.h:329
Float_t GetScreenFactor() const
Definition: TStyle.h:248
Int_t GetPadTickX() const
Definition: TStyle.h:209
Bool_t IsReading() const
Definition: TStyle.h:283
void SetCanvasColor(Color_t color=19)
Definition: TStyle.h:328
Float_t GetPadRightMargin() const
Definition: TStyle.h:206
void SetCanvasBorderMode(Int_t mode=1)
Definition: TStyle.h:330
void SetPalette(Int_t ncolors=kBird, Int_t *colors=0, Float_t alpha=1.)
See TColor::SetPalette.
Definition: TStyle.cxx:1783
Int_t GetCanvasDefH() const
Definition: TStyle.h:184
Int_t GetCanvasDefX() const
Definition: TStyle.h:186
Bool_t GetPadGridY() const
Definition: TStyle.h:208
Float_t GetPadLeftMargin() const
Definition: TStyle.h:205
Bool_t GetCanvasPreferGL() const
Definition: TStyle.h:180
Int_t GetCanvasDefY() const
Definition: TStyle.h:187
Bool_t GetPadGridX() const
Definition: TStyle.h:207
Int_t GetPadTickY() const
Definition: TStyle.h:210
Color_t GetCanvasColor() const
Definition: TStyle.h:181
Float_t GetPadBottomMargin() const
Definition: TStyle.h:203
Int_t GetCanvasDefW() const
Definition: TStyle.h:185
Int_t GetOptLogx() const
Definition: TStyle.h:239
Int_t GetCanvasBorderMode() const
Definition: TStyle.h:183
Width_t GetCanvasBorderSize() const
Definition: TStyle.h:182
Int_t GetOptFit() const
Definition: TStyle.h:236
Int_t GetOptLogz() const
Definition: TStyle.h:241
Float_t GetPadTopMargin() const
Definition: TStyle.h:204
static TClass * Class()
TVirtualPS is an abstract interface to Postscript, PDF, SVG.
Definition: TVirtualPS.h:30
static TVirtualPadEditor * GetPadEditor(Bool_t load=kTRUE)
Returns the pad editor dialog. Static method.
To make it possible to use GL for 2D graphic in a TPad/TCanvas.
virtual void LockPainter()
Empty definition.
static TVirtualPadPainter * PadPainter(Option_t *opt="")
Create a pad painter of specified type.
virtual void SelectDrawable(Int_t device)=0
virtual void InitPainter()
Empty definition.
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:51
static TClass * Class()
RVec< PromoteType< T > > abs(const RVec< T > &v)
Definition: RVec.hxx:1739
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
void(off) SmallVectorTemplateBase< T
static constexpr double s
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition: TMath.h:690
Definition: first.py:1