Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TLegend.cxx
Go to the documentation of this file.
1// @(#)root/graf:$Id$
2// Author: Matthew.Adam.Dobbs 06/09/99
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 <cstdio>
13#include <iostream>
14
15#include "TStyle.h"
16#include "TLatex.h"
17#include "TLine.h"
18#include "TPolyLine.h"
19#include "TMarker.h"
20#include "TLegend.h"
21#include "TList.h"
22#include "TVirtualPad.h"
23#include "TMath.h"
24#include "TROOT.h"
25#include "TLegendEntry.h"
26#include "TMultiGraph.h"
27#include "TGraph.h"
28#include "TH1.h"
29#include "THStack.h"
30
32
33/** \class TLegend
34\ingroup BasicGraphics
35
36This class displays a legend box (TPaveText) containing several legend entries.
37
38Each legend entry is made of a reference to a ROOT object, a text label and an
39option specifying which graphical attributes (marker/line/fill) should be
40displayed.
41
42The following example shows how to create a legend. In this example the legend
43contains a histogram, a function and a graph. The histogram is put in the legend
44using its reference pointer whereas the graph and the function are added
45using their names. Note that, because `TGraph` constructors do not have the
46`TGraph` name as parameter, the graph name should be specified using the
47`SetName` method.
48
49When an object is added by name, a scan is performed on the list of objects
50contained in the current pad (`gPad`) and also in the possible
51`TMultiGraph` and `THStack` present in the pad. If a matching
52name is found, the corresponding object is added in the legend using its pointer.
53
54Begin_Macro(source)
55{
56 auto c1 = new TCanvas("c1","c1",600,500);
57 gStyle->SetOptStat(0);
58
59 auto h1 = new TH1F("h1","TLegend Example",200,-10,10);
60 h1->FillRandom("gaus",30000);
61 h1->SetFillColor(kGreen);
62 h1->SetFillStyle(3003);
63 h1->Draw();
64
65 auto f1=new TF1("f1","1000*TMath::Abs(sin(x)/x)",-10,10);
66 f1->SetLineColor(kBlue);
67 f1->SetLineWidth(4);
68 f1->Draw("same");
69
70 const Int_t n = 20;
71 Double_t x[n], y[n], ex[n], ey[n];
72 for (Int_t i=0;i<n;i++) {
73 x[i] = i*0.1;
74 y[i] = 1000*sin(x[i]+0.2);
75 x[i] = 17.8*x[i]-8.9;
76 ex[i] = 1.0;
77 ey[i] = 10.*i;
78 }
79 auto gr = new TGraphErrors(n,x,y,ex,ey);
80 gr->SetName("gr");
81 gr->SetLineColor(kRed);
82 gr->SetLineWidth(2);
83 gr->SetMarkerStyle(21);
84 gr->SetMarkerSize(1.3);
85 gr->SetMarkerColor(7);
86 gr->Draw("P");
87
88 auto legend = new TLegend(0.1,0.7,0.48,0.9);
89 legend->SetHeader("The Legend Title","C"); // option "C" allows to center the header
90 legend->AddEntry(h1,"Histogram filled with random numbers","f");
91 legend->AddEntry("f1","Function abs(#frac{sin(x)}{x})","l");
92 legend->AddEntry("gr","Graph with error bars","lep");
93 legend->Draw();
94}
95End_Macro
96
97
98`TLegend` inherits from `TAttText` therefore changing any
99text attributes (text alignment, font, color...) on a legend will changed the
100text attributes on each line.
101
102In particular it can be interesting to change the text alignement that way. In
103order to have a base-line vertical alignment instead of a centered one simply do:
104~~~ {.cpp}
105 legend->SetTextAlign(13);
106~~~
107or
108~~~ {.cpp}
109 legend->SetTextAlign(11);
110~~~
111The default value of some `TLegend` attributes can be changed using
112`gStyle`. The default settings are:
113~~~ {.cpp}
114 SetLegendBorderSize(1);
115 SetLegendFillColor(0);
116 SetLegendFont(42);
117 SetLegendTextSize(0.);
118~~~
119The global attributes change the default values for the next created legends.
120
121Text attributes can be also changed individually on each legend entry:
122~~~ {.cpp}
123 TLegendEntry *le = leg->AddEntry(h1,"Histogram filled with random numbers","f");
124 le->SetTextColor(kBlue);;
125~~~
126
127Note that the `TPad` class has a method to build automatically a legend
128for all objects in the pad. It is called `TPad::BuildLegend()`.
129
130Each item in the legend is added using the `AddEntry` method. This
131method defines the object to be added (by reference or name), the label
132associated to this object and an option which a combination of:
133
134 - L: draw line associated with TAttLine if obj inherits from TAttLine
135 - P: draw polymarker associated with TAttMarker if obj inherits from TAttMarker
136 - F: draw a box with fill associated wit TAttFill if obj inherits TAttFill
137 - E: draw vertical error bar
138
139As shown in the following example, passing a NULL pointer as first parameter in
140`AddEntry` is also valid. This allows to add text or blank lines in a
141legend.
142
143Begin_Macro(source)
144{
145 auto c2 = new TCanvas("c2","c2",500,300);
146
147 auto* legend = new TLegend(0.2, 0.2, .8, .8);
148 auto h = new TH1F("", "", 1, 0, 1);
149
150 legend->AddEntry(h, "Histogram \"h\"", "l");
151 legend->AddEntry((TObject*)0, "", "");
152 legend->AddEntry((TObject*)0, "Some text", "");
153 legend->AddEntry((TObject*)0, "", "");
154 legend->AddEntry(h, "Histogram \"h\" again", "l");
155
156 legend->Draw();
157}
158End_Macro
159
160It is possible to draw the legend entries over several columns using
161the method `SetNColumns()` like in the following example.
162
163Begin_Macro(source)
164{
165 auto c3 = new TCanvas("c2","c2",500,300);
166
167 auto legend = new TLegend(0.2, 0.2, .8, .8);
168 auto h = new TH1F("", "", 1, 0, 1);
169
170 legend->SetNColumns(2);
171
172 legend->AddEntry(h, "Column 1 line 1", "l");
173 legend->AddEntry(h, "Column 2 line 1", "l");
174 legend->AddEntry(h, "Column 1 line 2", "l");
175 legend->AddEntry(h, "Column 2 line 2", "l");
176
177 legend->Draw();
178}
179End_Macro
180
181\since **ROOT version 6.09/03**
182
183The legend can be placed automatically in the current pad in an empty space
184found at painting time.
185
186The following example illustrate this facility. Only the width and height of the
187legend is specified in percentage of the pad size.
188
189Begin_Macro(source)
190../../../tutorials/hist/legendautoplaced.C
191End_Macro
192
193*/
194
195////////////////////////////////////////////////////////////////////////////////
196/// Default constructor.
197/// This constructor allows to place automatically the legend with a default
198/// width(0.3) and a default height (0.15) in normalize coordinates.
199
200TLegend::TLegend(): TPave(0.3,0.15,0.3,0.15,4,"brNDC"),
201 TAttText(12,0,1,gStyle->GetLegendFont(),0)
202{
203 fPrimitives = nullptr;
204 SetDefaults();
207}
208
209////////////////////////////////////////////////////////////////////////////////
210/// Normal constructor.
211///
212/// A TLegend is a Pave with several TLegendEntry(s).
213///
214/// x1,y1,x2,y2 are the coordinates of the Legend in the current pad
215/// (in normalised coordinates by default)
216///
217/// `header` is the title displayed at the top of the legend
218/// it is a TLatex string treated like a regular entry. The default
219/// is no header (header = 0).
220///
221/// The options are the same as for TPave.
222
224 const char *header, Option_t *option)
225 :TPave(x1,y1,x2,y2,4,option), TAttText(12,0,1,gStyle->GetLegendFont(),0)
226{
227 fPrimitives = new TList;
228 if (header && strlen(header) > 0) {
229 TLegendEntry *headerEntry = new TLegendEntry( nullptr, header, "h" );
230 headerEntry->SetTextAlign(0);
231 headerEntry->SetTextAngle(0);
232 headerEntry->SetTextColor(0);
233 headerEntry->SetTextFont(gStyle->GetLegendFont());
234 headerEntry->SetTextSize(0);
235 fPrimitives->AddFirst(headerEntry);
236 }
237 SetDefaults();
240}
241
242////////////////////////////////////////////////////////////////////////////////
243/// Constructor with automatic placement.
244///
245/// A TLegend is a Pave with several TLegendEntry(s).
246///
247/// This constructor doesn't define the legend position. `w` and `h` are the
248/// width and height of the legend in percentage of the current pad size.
249/// The position will be automatically defined at painting time.
250///
251/// `header` is the title displayed at the top of the legend
252/// it is a TLatex string treated like a regular entry. The default
253/// is no header (header = 0).
254///
255/// The options are the same as for TPave.
256
258 :TPave(w,h,w,h,4,option), TAttText(12,0,1,gStyle->GetLegendFont(),0)
259{
260 fPrimitives = new TList;
261 if (header && strlen(header) > 0) {
262 TLegendEntry *headerEntry = new TLegendEntry(nullptr, header, "h");
263 headerEntry->SetTextAlign(0);
264 headerEntry->SetTextAngle(0);
265 headerEntry->SetTextColor(0);
266 headerEntry->SetTextFont(gStyle->GetLegendFont());
267 headerEntry->SetTextSize(0);
268 fPrimitives->AddFirst(headerEntry);
269 }
270 SetDefaults();
273}
274
275////////////////////////////////////////////////////////////////////////////////
276/// Copy constructor.
277
278TLegend::TLegend(const TLegend &legend) : TPave(legend), TAttText(legend),
279 fPrimitives(nullptr)
280{
281 legend.TLegend::Copy(*this);
282}
283
284////////////////////////////////////////////////////////////////////////////////
285/// Assignment operator.
286
288{
289 if(this != &lg)
290 lg.TLegend::Copy(*this);
291 return *this;
292}
293
294////////////////////////////////////////////////////////////////////////////////
295/// Default destructor.
296
298{
299 if (fPrimitives)
301 delete fPrimitives;
302 fPrimitives = nullptr;
303}
304
305////////////////////////////////////////////////////////////////////////////////
306/// Add a new entry to this legend. "obj" is the object to be represented.
307/// "label" is the text you wish to associate with obj in the legend.
308/// If "label" is null or empty, the title of the object will be used.
309///
310/// Options are:
311///
312/// - L: draw line associated with TAttLine if obj inherits from TAttLine
313/// - P: draw polymarker associated with TAttMarker if obj inherits from TAttMarker
314/// - F: draw a box with fill associated wit TAttFill if obj inherits TAttFill
315/// - E: draw vertical error bar if option "L" is also specified
316
317TLegendEntry *TLegend::AddEntry(const TObject *obj, const char *label, Option_t *option)
318{
319 const char *lab = label;
320
321 if (obj && (!label || strlen(label)==0)) lab = obj->GetTitle();
322 TLegendEntry *newentry = new TLegendEntry( obj, lab, option );
323 if ( !fPrimitives ) fPrimitives = new TList;
324 fPrimitives->Add(newentry);
325 return newentry;
326}
327
328////////////////////////////////////////////////////////////////////////////////
329/// Add a new entry to this legend. "name" is the name of an object in the pad to
330/// be represented label is the text you wish to associate with obj in the legend
331/// if label is null or empty, the title of the object will be used.
332///
333/// Options are:
334///
335/// - L: draw line associated with TAttLine if obj inherits from TAttLine
336/// - P: draw polymarker associated with TAttMarker if obj inherits from TAttMarker
337/// - F: draw a box with fill associated wit TAttFill if obj inherits TAttFill
338/// - E: draw vertical error bar if option "L" is also specified
339
340TLegendEntry *TLegend::AddEntry(const char *name, const char *label, Option_t *option)
341{
342 if (!gPad) {
343 Error("AddEntry", "need to create a canvas first");
344 return nullptr;
345 }
346
347 TObject *obj = gPad->FindObject(name);
348
349 // If the object "name" has not been found, the following code tries to
350 // find it in TMultiGraph or THStack possibly present in the current pad.
351 if (!obj) {
352 TList *lop = gPad->GetListOfPrimitives();
353 if (lop) {
354 TIter next(lop);
355 while(auto o = next()) {
356 if ( o->InheritsFrom(TMultiGraph::Class() ) ) {
357 TList * grlist = ((TMultiGraph *)o)->GetListOfGraphs();
358 obj = grlist->FindObject(name);
359 if (obj) break;
360 }
361 if ( o->InheritsFrom(THStack::Class() ) ) {
362 TList * hlist = ((THStack *)o)->GetHists();
363 obj = hlist->FindObject(name);
364 if (obj) break;
365 }
366 }
367 }
368 }
369
370 return AddEntry( obj, label, option );
371}
372
373////////////////////////////////////////////////////////////////////////////////
374/// Clear all entries in this legend, including the header.
375
377{
378 if (!fPrimitives) return;
380}
381
382////////////////////////////////////////////////////////////////////////////////
383/// Copy this legend into "obj".
384
385void TLegend::Copy(TObject &obj) const
386{
387 auto &tgt = static_cast<TLegend &> (obj);
388 TPave::Copy(tgt);
389 TAttText::Copy(tgt);
390 tgt.fEntrySeparation = fEntrySeparation;
391 tgt.fMargin = fMargin;
392 tgt.fNColumns = fNColumns;
393
394 if (tgt.fPrimitives) {
395 tgt.fPrimitives->Delete();
396 delete tgt.fPrimitives;
397 tgt.fPrimitives = nullptr;
398 }
399 if (fPrimitives) {
400 tgt.fPrimitives = new TList();
401 TIter next(fPrimitives);
402 while (auto entry = (TLegendEntry *) next())
403 tgt.fPrimitives->Add(new TLegendEntry(*entry));
404 }
405}
406
407////////////////////////////////////////////////////////////////////////////////
408/// Delete entry at the mouse position.
409
411{
412 if ( !fPrimitives ) return;
413 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
414 if ( !entry ) return;
415 fPrimitives->Remove(entry);
416 delete entry;
417}
418
419////////////////////////////////////////////////////////////////////////////////
420/// Draw this legend with its current attributes.
421
423{
425}
426
427////////////////////////////////////////////////////////////////////////////////
428/// Edit the fill attributes for the entry pointed by the mouse.
429
431{
432 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
433 if ( !entry ) return;
434 gROOT->SetSelectedPrimitive( entry );
435 entry->SetFillAttributes();
436}
437
438////////////////////////////////////////////////////////////////////////////////
439/// Edit the line attributes for the entry pointed by the mouse.
440
442{
443 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
444 if ( !entry ) return;
445 gROOT->SetSelectedPrimitive( entry );
446 entry->SetLineAttributes();
447}
448
449////////////////////////////////////////////////////////////////////////////////
450/// Edit the marker attributes for the entry pointed by the mouse.
451
453{
454 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
455 if ( !entry ) return;
456 gROOT->SetSelectedPrimitive( entry );
457 entry->SetMarkerAttributes();
458}
459
460////////////////////////////////////////////////////////////////////////////////
461/// Edit the text attributes for the entry pointed by the mouse.
462
464{
465 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
466 if ( !entry ) return;
467 gROOT->SetSelectedPrimitive( entry );
468 entry->SetTextAttributes();
469}
470
471////////////////////////////////////////////////////////////////////////////////
472/// Get entry pointed to by the mouse.
473/// This method is mostly a tool for other methods inside this class.
474
476{
477 if (!gPad) {
478 Error("GetEntry", "need to create a canvas first");
479 return nullptr;
480 }
481
482 Int_t nRows = GetNRows();
483 if ( nRows == 0 )
484 return nullptr;
485
486 Double_t ymouse = gPad->AbsPixeltoY(gPad->GetEventY())-fY1;
487 Double_t yspace = (fY2 - fY1)/nRows;
488
489 Int_t nColumns = GetNColumns();
490 Double_t xmouse = gPad->AbsPixeltoX(gPad->GetEventX())-fX1;
491 Double_t xspace = 0.;
492 if (nColumns > 0) xspace = (fX2 - fX1)/nColumns;
493
494 Int_t ix = 1;
495 if (xspace > 0.) ix = (Int_t)(xmouse/xspace)+1;
496 if (ix > nColumns) ix = nColumns;
497 if (ix < 1) ix = 1;
498
499 Int_t iy = nRows-(Int_t)(ymouse/yspace);
500 if (iy > nRows) iy = nRows;
501 if (iy < 1) iy = 1;
502
503 Int_t nloops = TMath::Min(ix+(nColumns*(iy-1)), fPrimitives->GetSize());
504
505 TIter next(fPrimitives);
506 TLegendEntry *entry = nullptr;
507
508 for (Int_t i=1; i<= nloops; i++)
509 entry = (TLegendEntry *)next();
510
511 return entry;
512}
513
514////////////////////////////////////////////////////////////////////////////////
515/// Returns the header, which is the title that appears at the top
516/// of the legend.
517
518const char *TLegend::GetHeader() const
519{
520 if ( !fPrimitives ) return nullptr;
521 TIter next(fPrimitives);
522 if (auto first = (TLegendEntry*)next()) {
523 TString opt = first->GetOption();
524 opt.ToLower();
525 if ( opt.Contains("h") ) return first->GetLabel();
526 }
527 return nullptr;
528}
529
530////////////////////////////////////////////////////////////////////////////////
531/// Add a new entry before the entry at the mouse position.
532
533void TLegend::InsertEntry( const char* objectName, const char* label, Option_t* option)
534{
535 if (!gPad) {
536 Error("InsertEntry", "need to create a canvas first");
537 return;
538 }
539
540 TLegendEntry* beforeEntry = GetEntry(); // get entry pointed by the mouse
541 TObject *obj = gPad->FindObject( objectName );
542
543 // note either obj OR beforeEntry may be zero at this point
544
545 TLegendEntry *newentry = new TLegendEntry( obj, label, option );
546
547 if ( !fPrimitives ) fPrimitives = new TList;
548 if ( beforeEntry ) {
549 fPrimitives->AddBefore( (TObject*)beforeEntry, (TObject*)newentry );
550 } else {
551 fPrimitives->Add((TObject*)newentry);
552 }
553}
554
555////////////////////////////////////////////////////////////////////////////////
556/// Paint this legend with its current attributes.
557
559{
560 // The legend need to be placed automatically in some empty space
561 if (fX1 == fX2 && fY1 == fY2) {
562 if (gPad && gPad->PlaceBox(this, fX1, fY1, fX1, fY1)) {
563 fY2 = fY2 + fY1;
564 fX2 = fX2 + fX1;
565 } else {
566 Warning("Paint", "Legend too large to be automatically placed; a default position is used");
567 fX1 = 0.5;
568 fY1 = 0.67;
569 fX2 = 0.88;
570 fY2 = 0.88;
571 }
572 }
573
574 // Paint the Legend
578}
579
580////////////////////////////////////////////////////////////////////////////////
581/// Get the number of rows.
582
584{
585 Int_t nEntries = 0;
586 if ( fPrimitives ) nEntries = fPrimitives->GetSize();
587 if ( nEntries == 0 ) return 0;
588
589 Int_t nRows;
590 if(GetHeader() != nullptr) nRows = 1 + (Int_t) TMath::Ceil((Double_t) (nEntries-1)/fNColumns);
591 else nRows = (Int_t) TMath::Ceil((Double_t) nEntries/fNColumns);
592
593 return nRows;
594}
595
596////////////////////////////////////////////////////////////////////////////////
597/// Set the number of columns for the legend. The header, if set, is given
598/// its own row. After that, every nColumns entries are inserted into the
599/// same row. For example, if one calls legend.SetNColumns(2), and there
600/// is no header, then the first two TObjects added to the legend will be
601/// in the first row, the next two will appear in the second row, and so on.
602
604{
605 if(nColumns < 1) {
606 Warning("TLegend::SetNColumns", "illegal value nColumns = %d; keeping fNColumns = %d", nColumns, fNColumns);
607 return;
608 }
609 fNColumns = nColumns;
610}
611
612////////////////////////////////////////////////////////////////////////////////
613/// Paint the entries (list of primitives) for this legend.
614
616{
617 Int_t nRows = GetNRows();
618 if ( nRows == 0 ) return;
619
620 // Evaluate text size as a function of the number of entries
621 // taking into account their real size after drawing latex
622 // Note: in pixel coords y1 > y2=0, but x2 > x1=0
623 // in NDC y2 > y1, and x2 > x1
624
629 Double_t margin = fMargin*( x2-x1 )/fNColumns;
630 Double_t boxw = margin*0.35;
631 Double_t barw = boxw*0.1*gStyle->GetEndErrorSize();
632 Double_t yspace = (y2-y1)/nRows;
633 Double_t yspace2 = yspace/2.;
635 Double_t save_textsize = textsize;
636 if (textsize==0.) {
639 }
640 Bool_t autosize = kFALSE;
641 std::vector<Double_t> columnWidths(fNColumns, 0.);
642
643 if ( textsize == 0 ) {
644 autosize = kTRUE;
645 textsize = ( 1. - fEntrySeparation ) * yspace;
646
647 // find the max width and height (in pad coords) of one latex entry label
648 Double_t maxentrywidth = 0, maxentryheight = 0;
649 TIter nextsize(fPrimitives);
650 TLegendEntry *entrysize;
651 Int_t iColumn = 0;
652 while (( entrysize = (TLegendEntry *)nextsize() )) {
653 TLatex entrytex( 0, 0, entrysize->GetLabel() );
654 entrytex.SetNDC();
655 Style_t tfont = entrysize->GetTextFont();
656 if (tfont == 0) tfont = GetTextFont();
657 if (tfont%10 == 3) --tfont;
658 entrytex.SetTextFont(tfont);
659 entrytex.SetTextSize(textsize);
660 if ( entrytex.GetYsize() > maxentryheight ) {
661 maxentryheight = entrytex.GetYsize();
662 }
663 TString opt = entrysize->GetOption();
664 opt.ToLower();
665 if ( opt.Contains("h") ) {
666 if ( entrytex.GetXsize() > maxentrywidth ) {
667 maxentrywidth = entrytex.GetXsize();
668 }
669 } else {
670 if ( entrytex.GetXsize() > columnWidths[iColumn] ) {
671 columnWidths[iColumn] = entrytex.GetXsize();
672 }
673 iColumn++;
674 iColumn %= fNColumns;
675 }
676 Double_t tmpMaxWidth = 0.0;
677 for(int i=0; i<fNColumns; i++) tmpMaxWidth += columnWidths[i];
678 if ( tmpMaxWidth > maxentrywidth) maxentrywidth = tmpMaxWidth;
679 }
680 // make sure all labels fit in the allotted space
681 Double_t tmpsize_h = maxentryheight /(gPad->GetY2() - gPad->GetY1());
682 textsize = TMath::Min( textsize, tmpsize_h );
683 Double_t tmpsize_w = textsize*(fX2-fX1)*(1.0-fMargin)/maxentrywidth;
684 if(fNColumns > 1) tmpsize_w = textsize*(fX2-fX1)*(1.0-fMargin-fColumnSeparation)/maxentrywidth;
685 textsize = TMath::Min( textsize, tmpsize_w );
687 }
688
689 // Update column widths, put into NDC units
690 // block off this section of code to make sure all variables are local:
691 // don't want to ruin initialisation of these variables later on
692 {
693 TIter next(fPrimitives);
694 Int_t iColumn = 0;
695 for (Int_t k = 0; k < fNColumns; ++k)
696 columnWidths[k] = 0.;
697 while (auto entry = (TLegendEntry *)next()) {
698 TLatex entrytex( 0, 0, entry->GetLabel() );
699 entrytex.SetNDC();
700 Style_t tfont = entry->GetTextFont();
701 if (tfont == 0) tfont = GetTextFont();
702 if (autosize && tfont%10 == 3) --tfont;
703 entrytex.SetTextFont(tfont);
704 if(entry->GetTextSize() == 0) entrytex.SetTextSize(textsize);
705 TString opt = entry->GetOption();
706 opt.ToLower();
707 if (!opt.Contains("h")) {
708 if ( entrytex.GetXsize() > columnWidths[iColumn] ) {
709 columnWidths[iColumn] = entrytex.GetXsize();
710 }
711 iColumn++;
712 iColumn %= fNColumns;
713 }
714 }
715 double totalWidth = 0.0;
716 for(int i=0; i<fNColumns; i++) totalWidth += columnWidths[i];
717 if(fNColumns > 1) totalWidth /= (1.0-fMargin-fColumnSeparation);
718 else totalWidth /= (1.0 - fMargin);
719 for(int i=0; i<fNColumns; i++) {
720 columnWidths[i] = columnWidths[i]/totalWidth*(x2-x1) + margin;
721 }
722 }
723
724 Double_t ytext = y2 + 0.5*yspace; // y-location of 0th entry
725
726 // iterate over and paint all the TLegendEntries
727 TIter next(fPrimitives);
728 TLegendEntry *entry;
729 Int_t iColumn = 0;
730 while (( entry = (TLegendEntry *)next() )) {
731 if(iColumn == 0) ytext -= yspace;
732
733 // Draw Label in Latexmargin
734
735 Short_t talign = entry->GetTextAlign();
736 Float_t tangle = entry->GetTextAngle();
737 Color_t tcolor = entry->GetTextColor();
738 Style_t tfont = entry->GetTextFont();
739 Size_t tsize = entry->GetTextSize();
740 // if the user hasn't set a parameter, then set it to the TLegend value
741 if (talign == 0) entry->SetTextAlign(GetTextAlign());
742 if (tangle == 0) entry->SetTextAngle(GetTextAngle());
743 if (tcolor == 0) entry->SetTextColor(GetTextColor());
744 if (tfont == 0) {
745 tfont = GetTextFont();
746 if (autosize && tfont%10 == 3) --tfont;
747 entry->SetTextFont(tfont);
748 }
749 if (tsize == 0) entry->SetTextSize(GetTextSize());
750 // set x,y according to the requested alignment
751 Double_t x=0,y=0;
752 Int_t halign = entry->GetTextAlign()/10;
753 Double_t entrymargin = margin;
754 // for the header the margin is near zero
755 TString opt = entry->GetOption();
756 opt.ToLower();
757 x1 = fX1NDC;
758 x2 = fX2NDC;
759 if ( opt.Contains("h") ) entrymargin = margin/10.;
760 else if (fNColumns > 1) {
761 for(int i=0; i<iColumn; i++) x1 += columnWidths[i] + fColumnSeparation*(fX2NDC-fX1NDC)/(fNColumns-1);
762 x2 = x1 + columnWidths[iColumn];
763 iColumn++;
764 iColumn %= fNColumns;
765 }
766 if (halign == 1) x = x1 + entrymargin;
767 if (halign == 2) x = 0.5*( (x1+entrymargin) + x2 );
768 if (halign == 3) x = x2 - entrymargin/10.;
769 Int_t valign = entry->GetTextAlign()%10;
770
771 if (valign == 1) y = ytext - (1. - fEntrySeparation)* yspace2;
772 if (valign == 3) y = ytext + (1. - fEntrySeparation)* yspace2;
773
774 // The vertical alignment "centered" is treated in a special way
775 // to ensure a better spacing between lines.
776 if (valign == 2) {
777 Float_t tsizepad = textsize;
778 if (tfont%10 == 3) tsizepad = (gPad->AbsPixeltoY(0) - gPad->AbsPixeltoY(textsize))/(gPad->GetY2() - gPad->GetY1());
779 if (yspace2 < tsizepad) {
780 entry->SetTextAlign(10*halign+1);
781 y = ytext - (1. - fEntrySeparation)* yspace2/2.;
782 } else {
783 y = ytext;
784 }
785 }
786
787 TLatex entrytex( x, y, entry->GetLabel() );
788 entrytex.SetNDC();
789 entry->TAttText::Copy(entrytex);
790 entrytex.Paint();
791
792 // reset attributes back to their original values
793 entry->SetTextAlign(talign);
794 entry->SetTextAngle(tangle);
795 entry->SetTextColor(tcolor);
796 entry->SetTextFont(tfont);
797 entry->SetTextSize(tsize);
798
799 // define x,y as the center of the symbol for this entry
800 Double_t xsym = x1 + margin/2.;
801 Double_t ysym = ytext;
802
803 TObject *eobj = entry->GetObject();
804
805 // depending on the object drawing option, the endcaps for error
806 // bar are drawn differently.
807 Int_t endcaps = 0; // no endcaps.
808 if (eobj) { // eobj == nullptr for the legend header
809 TString eobjopt = eobj->GetDrawOption();
810 eobjopt.ToLower();
811 if (eobjopt.Contains("e1") && eobj->InheritsFrom(TH1::Class())) endcaps = 1; // a bar
812 if (eobj->InheritsFrom(TGraph::Class())) {
813 endcaps = 1; // a bar, default for TGraph
814 if (eobjopt.Contains("z")) endcaps = 0; // no endcaps.
815 if (eobjopt.Contains(">")) endcaps = 2; // empty arrow.
816 if (eobjopt.Contains("|>")) endcaps = 3; // filled arrow.
817 }
818 }
819 float arrow_shift = 0.3;
820 if (endcaps == 3) arrow_shift = 0.2;
821 // Draw fill pattern (in a box)
822
823 if ( opt.Contains("f")) {
824 if (eobj && eobj->InheritsFrom(TAttFill::Class())) {
825 dynamic_cast<TAttFill*>(eobj)->Copy(*entry);
826 }
827
828 // Case of exclusion graphs
829 Float_t wl = 1., wu = 1.;
830 if (eobj && eobj->InheritsFrom(TAttLine::Class())
831 && eobj->InheritsFrom(TGraph::Class())) {
832 Int_t w = dynamic_cast<TAttLine*>(eobj)->GetLineWidth();
833 if (TMath::Abs(w)>99) {
834 if (w<0) wu = 0;
835 else wl = 0;
836 }
837 }
838
839 // box total height is yspace*0.7
840 entry->TAttFill::Modify();
841 Double_t xf[4],yf[4];
842 xf[0] = xsym - boxw;
843 yf[0] = ysym - wl*yspace*0.35;
844 xf[1] = xsym + boxw;
845 yf[1] = yf[0];
846 xf[2] = xf[1];
847 yf[2] = ysym + wu*yspace*0.35;
848 xf[3] = xf[0];
849 yf[3] = yf[2];
850 for (Int_t i=0;i<4;i++) {
851 xf[i] = gPad->GetX1() + xf[i]*(gPad->GetX2()-gPad->GetX1());
852 yf[i] = gPad->GetY1() + yf[i]*(gPad->GetY2()-gPad->GetY1());
853 }
854 gPad->PaintFillArea(4,xf,yf);
855 }
856
857 // Get Polymarker size
858
859 Double_t symbolsize = 0.;
860 TMarker entrymarker( xsym, ysym, 0 );
861
862 if ( opt.Contains("p")) {
863 if (eobj && eobj->InheritsFrom(TAttMarker::Class())) {
864 dynamic_cast<TAttMarker*>(eobj)->Copy(*entry);
865 }
866 entrymarker.SetNDC();
867 entry->TAttMarker::Copy(entrymarker);
868 if (entrymarker.GetMarkerStyle() >= 5 ) symbolsize = entrymarker.GetMarkerSize();
869 }
870
871 // Lambda function to draw end caps 3
872 auto DrawEndCaps = [&]() {
873 if (endcaps == 1) {
874 TLine entrytop1(xsym-barw, ysym + yspace*0.30, xsym+barw, ysym + yspace*0.30);
875 entrytop1.SetBit(TLine::kLineNDC);
876 entry->TAttLine::Copy(entrytop1);
877 entrytop1.Paint();
878 TLine entrytop2(xsym-barw, ysym - yspace*0.30, xsym+barw, ysym - yspace*0.30);
879 entrytop2.SetBit(TLine::kLineNDC);
880 entry->TAttLine::Copy(entrytop2);
881 entrytop2.Paint();
882 } else if (endcaps == 2) {
883 Double_t xe1[3] = {xsym-barw, xsym ,xsym+barw};
884 Double_t ye1[3] = {ysym+yspace*0.20, ysym + yspace*0.30 ,ysym+yspace*0.20};
885 TPolyLine ple1(3,xe1,ye1);
887 entry->TAttLine::Copy(ple1);
888 ple1.Paint();
889 Double_t xe2[3] = {xsym-barw, xsym ,xsym+barw};
890 Double_t ye2[3] = {ysym-yspace*0.20, ysym - yspace*0.30 ,ysym-yspace*0.20};
891 TPolyLine ple2(3,xe2,ye2);
893 entry->TAttLine::Copy(ple2);
894 ple2.Paint();
895 } else if (endcaps == 3) {
896 if (eobj && eobj->InheritsFrom(TAttFill::Class())) {
897 dynamic_cast<TAttFill*>(eobj)->Copy(*entry);
898 }
899 Double_t xe1[3] = {xsym-barw, xsym ,xsym+barw};
900 Double_t ye1[3] = {ysym+yspace*0.20, ysym + yspace*0.30 ,ysym+yspace*0.20};
901 Double_t xe2[3] = {xsym-barw, xsym ,xsym+barw};
902 Double_t ye2[3] = {ysym-yspace*0.20, ysym - yspace*0.30 ,ysym-yspace*0.20};
903 for (Int_t i=0;i<3;i++) {
904 xe1[i] = gPad->GetX1() + xe1[i]*(gPad->GetX2()-gPad->GetX1());
905 ye1[i] = gPad->GetY1() + ye1[i]*(gPad->GetY2()-gPad->GetY1());
906 xe2[i] = gPad->GetX1() + xe2[i]*(gPad->GetX2()-gPad->GetX1());
907 ye2[i] = gPad->GetY1() + ye2[i]*(gPad->GetY2()-gPad->GetY1());
908 }
909 int lc = entry->GetLineColor();
910 int lw = entry->GetLineWidth();
911 int fc = entry->GetFillColor();
912 int fs = entry->GetFillStyle();
913 if (fs==1) fs=1001;
914
915 TPolyLine ple1(3,xe1,ye1);
916 ple1.SetLineColor(lc);
917 ple1.SetLineWidth(lw);
918 ple1.SetFillColor(fc);
919 ple1.SetFillStyle(fs);
920 ple1.Paint("f");
921 ple1.Paint();
922
923 TPolyLine ple2(3,xe2,ye2);
924 ple2.SetLineColor(lc);
925 ple2.SetLineWidth(lw);
926 ple2.SetFillColor(fc);
927 ple2.SetFillStyle(fs);
928 ple2.Paint("f");
929 ple2.Paint();
930 }
931 };
932
933 // Draw line
934
935 if ( opt.Contains("l") || opt.Contains("f")) {
936 if (eobj && eobj->InheritsFrom(TAttLine::Class())) {
937 dynamic_cast<TAttLine*>(eobj)->Copy(*entry);
938 }
939 // line total length (in x) is margin*0.8
940 TLine entryline( xsym - boxw, ysym, xsym + boxw, ysym );
941 entryline.SetBit(TLine::kLineNDC);
942 entry->TAttLine::Copy(entryline);
943 // if the entry is filled, then surround the box with the line instead
944 if ( opt.Contains("f") && !opt.Contains("l")) {
945 entryline.PaintLineNDC( xsym - boxw, ysym + yspace*0.35,
946 xsym + boxw, ysym + yspace*0.35);
947 entryline.PaintLineNDC( xsym - boxw, ysym - yspace*0.35,
948 xsym + boxw, ysym - yspace*0.35);
949 entryline.PaintLineNDC( xsym + boxw, ysym - yspace*0.35,
950 xsym + boxw, ysym + yspace*0.35);
951 entryline.PaintLineNDC( xsym - boxw, ysym - yspace*0.35,
952 xsym - boxw, ysym + yspace*0.35);
953 } else {
954 entryline.Paint();
955 if (opt.Contains("e")) {
956 if ( !opt.Contains("p")) {
957 entryline.PaintLineNDC( xsym, ysym - yspace*arrow_shift,
958 xsym, ysym + yspace*arrow_shift);
959 } else {
960 Double_t sy = (fY2NDC-fY1NDC)*((0.5*(gPad->PixeltoY(0) - gPad->PixeltoY(Int_t(symbolsize*8.))))/(fY2-fY1));
961 TLine entryline1(xsym, ysym + sy, xsym, ysym + yspace*arrow_shift);
962 entryline1.SetBit(TLine::kLineNDC);
963 entry->TAttLine::Copy(entryline1);
964 entryline1.Paint();
965 TLine entryline2(xsym, ysym - sy, xsym, ysym - yspace*arrow_shift);
966 entryline2.SetBit(TLine::kLineNDC);
967 entry->TAttLine::Copy(entryline2);
968 entryline2.Paint();
969 }
970 DrawEndCaps();
971 }
972 }
973 }
974
975 // Draw error only
976
977 if (opt.Contains("e") && !(opt.Contains("l") || opt.Contains("f"))) {
978 if (eobj && eobj->InheritsFrom(TAttLine::Class())) {
979 dynamic_cast<TAttLine*>(eobj)->Copy(*entry);
980 }
981 if ( !opt.Contains("p")) {
982 TLine entryline(xsym, ysym - yspace*arrow_shift,
983 xsym, ysym + yspace*arrow_shift);
984 entryline.SetBit(TLine::kLineNDC);
985 entry->TAttLine::Copy(entryline);
986 entryline.Paint();
987 } else {
988 Double_t sy = (fY2NDC-fY1NDC)*((0.5*(gPad->PixeltoY(0) - gPad->PixeltoY(Int_t(symbolsize*8.))))/(fY2-fY1));
989 TLine entryline1(xsym, ysym + sy, xsym, ysym + yspace*arrow_shift);
990 entryline1.SetBit(TLine::kLineNDC);
991 entry->TAttLine::Copy(entryline1);
992 entryline1.Paint();
993 TLine entryline2(xsym, ysym - sy, xsym, ysym - yspace*arrow_shift);
994 entryline2.SetBit(TLine::kLineNDC);
995 entry->TAttLine::Copy(entryline2);
996 entryline2.Paint();
997 }
998 DrawEndCaps();
999 }
1000
1001 // Draw Polymarker
1002 if ( opt.Contains("p")) entrymarker.Paint();
1003 }
1004 SetTextSize(save_textsize);
1005}
1006
1007////////////////////////////////////////////////////////////////////////////////
1008/// Dump this TLegend and its contents.
1009
1011{
1014}
1015
1016////////////////////////////////////////////////////////////////////////////////
1017/// Reset the legend entries pointing to "obj".
1018
1020{
1021 TIter next(fPrimitives);
1022 while (auto entry = (TLegendEntry *)next()) {
1023 if (entry->GetObject() == obj)
1024 entry->SetObject((TObject *)nullptr);
1025 }
1026}
1027
1028////////////////////////////////////////////////////////////////////////////////
1029/// Save this legend as C++ statements on output stream out
1030/// to be used with the SaveAs .C option.
1031
1032void TLegend::SavePrimitive(std::ostream &out, Option_t* )
1033{
1034
1035 out << " " << std::endl;
1036 char quote = '"';
1037 if ( gROOT->ClassSaved( TLegend::Class() ) ) {
1038 out << " ";
1039 } else {
1040 out << " TLegend *";
1041 }
1042 // note, we can always use NULL header, since its included in primitives
1043 out << "leg = new TLegend("<<GetX1NDC()<<","<<GetY1NDC()<<","
1044 <<GetX2NDC()<<","<<GetY2NDC()<<","
1045 << "NULL" << "," <<quote<< fOption <<quote<<");" << std::endl;
1046 if (fBorderSize != 4) {
1047 out<<" leg->SetBorderSize("<<fBorderSize<<");"<<std::endl;
1048 }
1049 SaveTextAttributes(out,"leg",12,0,1,42,0);
1050 SaveLineAttributes(out,"leg",-1,-1,-1);
1051 SaveFillAttributes(out,"leg",-1,-1);
1052 if ( fPrimitives ) {
1053 TIter next(fPrimitives);
1054 TLegendEntry *entry;
1055 while (( entry = (TLegendEntry *)next() )) entry->SaveEntry(out,"leg");
1056 }
1057 out << " leg->Draw();"<<std::endl;
1058}
1059
1060////////////////////////////////////////////////////////////////////////////////
1061/// Edit the label of the entry pointed to by the mouse.
1062
1063void TLegend::SetEntryLabel( const char* label )
1064{
1065 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
1066 if ( entry ) entry->SetLabel( label );
1067}
1068
1069////////////////////////////////////////////////////////////////////////////////
1070/// Edit the option of the entry pointed to by the mouse.
1071
1073{
1074 TLegendEntry* entry = GetEntry(); // get entry pointed by the mouse
1075 if ( entry ) entry->SetOption( option );
1076}
1077
1078////////////////////////////////////////////////////////////////////////////////
1079/// Sets the header, which is the "title" that appears at the top of the legend.
1080/// If `option` contains `C`, the title will be centered.
1081
1082void TLegend::SetHeader( const char *header, Option_t* option )
1083{
1084 TString opt;
1085
1086 if ( !fPrimitives ) fPrimitives = new TList;
1087 TIter next(fPrimitives);
1088 TLegendEntry *first; // header is always the first entry
1089 if (( first = (TLegendEntry*)next() )) {
1090 opt = first->GetOption();
1091 opt.ToLower();
1092 if ( opt.Contains("h") ) {
1093 first->SetLabel(header);
1094 opt = option;
1095 opt.ToLower();
1096 if ( opt.Contains("c") ) first->SetTextAlign(22);
1097 else first->SetTextAlign(0);
1098 return;
1099 }
1100 }
1101 first = new TLegendEntry( nullptr, header, "h" );
1102 opt = option;
1103 opt.ToLower();
1104 if ( opt.Contains("c") ) first->SetTextAlign(22);
1105 else first->SetTextAlign(0);
1106 first->SetTextAngle(0);
1107 first->SetTextColor(0);
1108 first->SetTextFont(GetTextFont()); // default font is TLegend font for the header
1109 first->SetTextSize(0);
1110 fPrimitives->AddFirst((TObject*)first);
1111}
#define h(i)
Definition RSha256.hxx:106
short Style_t
Definition RtypesCore.h:89
int Int_t
Definition RtypesCore.h:45
short Color_t
Definition RtypesCore.h:92
float Size_t
Definition RtypesCore.h:96
float Float_t
Definition RtypesCore.h:57
short Short_t
Definition RtypesCore.h:39
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:377
Option_t Option_t option
Option_t Option_t SetTextSize
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t textsize
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t SetFillColor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize fs
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition TGX11.cxx:110
#define gROOT
Definition TROOT.h:406
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
#define gPad
Fill Area Attributes class.
Definition TAttFill.h:19
virtual Color_t GetFillColor() const
Return the fill area color.
Definition TAttFill.h:30
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition TAttFill.h:31
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:37
virtual void SetFillAttributes()
Invoke the DialogCanvas Fill attributes.
Definition TAttFill.cxx:254
static TClass * Class()
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:39
virtual void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition TAttFill.cxx:239
Line Attributes class.
Definition TAttLine.h:18
virtual Color_t GetLineColor() const
Return the line color.
Definition TAttLine.h:33
virtual Width_t GetLineWidth() const
Return the line width.
Definition TAttLine.h:35
virtual void SetLineAttributes()
Invoke the DialogCanvas Line attributes.
Definition TAttLine.cxx:294
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:43
static TClass * Class()
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:40
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition TAttLine.cxx:275
Marker Attributes class.
Definition TAttMarker.h:19
virtual Style_t GetMarkerStyle() const
Return the marker style.
Definition TAttMarker.h:32
virtual Size_t GetMarkerSize() const
Return the marker size.
Definition TAttMarker.h:33
virtual void SetMarkerAttributes()
Invoke the DialogCanvas Marker attributes.
static TClass * Class()
Text Attributes class.
Definition TAttText.h:18
virtual Float_t GetTextSize() const
Return the text size.
Definition TAttText.h:36
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition TAttText.h:42
virtual Short_t GetTextAlign() const
Return the text alignment.
Definition TAttText.h:32
virtual Font_t GetTextFont() const
Return the text font.
Definition TAttText.h:35
virtual Color_t GetTextColor() const
Return the text color.
Definition TAttText.h:34
virtual void SetTextAngle(Float_t tangle=0)
Set the text angle.
Definition TAttText.h:43
virtual Float_t GetTextAngle() const
Return the text angle.
Definition TAttText.h:33
virtual void SetTextAttributes()
Invoke the DialogCanvas Text attributes.
Definition TAttText.cxx:400
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition TAttText.h:44
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition TAttText.h:46
virtual void SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1)
Save text attributes as C++ statement(s) on output stream out.
Definition TAttText.cxx:373
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition TAttText.h:47
void Copy(TAttText &atttext) const
Copy this text attributes to a new TAttText.
Definition TAttText.cxx:294
Double_t fX1
X of 1st point.
Definition TBox.h:28
Double_t fY2
Y of 2nd point.
Definition TBox.h:31
Double_t fX2
X of 2nd point.
Definition TBox.h:30
Double_t fY1
Y of 1st point.
Definition TBox.h:29
void Print(Option_t *option="") const override
Default print for collections, calls Print(option, 1).
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
static TClass * Class()
static TClass * Class()
The Histogram stack class.
Definition THStack.h:38
static TClass * Class()
To draw Mathematical Formula.
Definition TLatex.h:18
Double_t GetXsize()
Return size of the formula along X in pad coordinates when the text precision is smaller than 3.
Definition TLatex.cxx:2569
Double_t GetYsize()
Return size of the formula along Y in pad coordinates when the text precision is smaller than 3.
Definition TLatex.cxx:2657
void Paint(Option_t *option="") override
Paint.
Definition TLatex.cxx:2092
Storage class for one entry of a TLegend.
virtual TObject * GetObject() const
virtual void SetLabel(const char *label="")
virtual void SetOption(Option_t *option="lpf")
virtual void SaveEntry(std::ostream &out, const char *name)
Save this TLegendEntry as C++ statements on output stream out to be used with the SaveAs ....
virtual const char * GetLabel() const
Option_t * GetOption() const override
This class displays a legend box (TPaveText) containing several legend entries.
Definition TLegend.h:23
void Copy(TObject &obj) const override
Copy this legend into "obj".
Definition TLegend.cxx:385
TLegendEntry * AddEntry(const TObject *obj, const char *label="", Option_t *option="lpf")
Add a new entry to this legend.
Definition TLegend.cxx:317
void SetNColumns(Int_t nColumns)
Set the number of columns for the legend.
Definition TLegend.cxx:603
void Draw(Option_t *option="") override
Draw this legend with its current attributes.
Definition TLegend.cxx:422
virtual void SetHeader(const char *header="", Option_t *option="")
Sets the header, which is the "title" that appears at the top of the legend.
Definition TLegend.cxx:1082
virtual void DeleteEntry()
Delete entry at the mouse position.
Definition TLegend.cxx:410
TLegendEntry * GetEntry() const
Get entry pointed to by the mouse.
Definition TLegend.cxx:475
void Clear(Option_t *option="") override
Clear all entries in this legend, including the header.
Definition TLegend.cxx:376
Float_t fEntrySeparation
Separation between entries, as a fraction of The space allocated to one entry.
Definition TLegend.h:74
virtual void EditEntryAttMarker()
Edit the marker attributes for the entry pointed by the mouse.
Definition TLegend.cxx:452
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save this legend as C++ statements on output stream out to be used with the SaveAs ....
Definition TLegend.cxx:1032
virtual void EditEntryAttText()
Edit the text attributes for the entry pointed by the mouse.
Definition TLegend.cxx:463
void Paint(Option_t *option="") override
Paint this legend with its current attributes.
Definition TLegend.cxx:558
Int_t GetNColumns() const
Definition TLegend.h:52
void SetDefaults()
Definition TLegend.h:61
void RecursiveRemove(TObject *obj) override
Reset the legend entries pointing to "obj".
Definition TLegend.cxx:1019
Float_t fMargin
Fraction of total width used for symbol.
Definition TLegend.h:77
Int_t GetNRows() const
Get the number of rows.
Definition TLegend.cxx:583
TList * fPrimitives
List of TLegendEntries.
Definition TLegend.h:73
Int_t fNColumns
Number of columns in the legend.
Definition TLegend.h:78
Float_t fColumnSeparation
Separation between columns, as a fraction of The space allowed to one column.
Definition TLegend.h:79
TLegend()
Default constructor.
Definition TLegend.cxx:200
virtual void EditEntryAttLine()
Edit the line attributes for the entry pointed by the mouse.
Definition TLegend.cxx:441
~TLegend() override
Default destructor.
Definition TLegend.cxx:297
static TClass * Class()
virtual void SetEntryOption(Option_t *option)
Edit the option of the entry pointed to by the mouse.
Definition TLegend.cxx:1072
TLegend & operator=(const TLegend &)
Assignment operator.
Definition TLegend.cxx:287
virtual void SetEntryLabel(const char *label)
Edit the label of the entry pointed to by the mouse.
Definition TLegend.cxx:1063
void Print(Option_t *option="") const override
Dump this TLegend and its contents.
Definition TLegend.cxx:1010
virtual void PaintPrimitives()
Paint the entries (list of primitives) for this legend.
Definition TLegend.cxx:615
virtual void EditEntryAttFill()
Edit the fill attributes for the entry pointed by the mouse.
Definition TLegend.cxx:430
virtual const char * GetHeader() const
Returns the header, which is the title that appears at the top of the legend.
Definition TLegend.cxx:518
virtual void InsertEntry(const char *objectName="", const char *label="", Option_t *option="lpf")
Add a new entry before the entry at the mouse position.
Definition TLegend.cxx:533
Use the TLine constructor to create a simple line.
Definition TLine.h:22
@ kLineNDC
Use NDC coordinates.
Definition TLine.h:33
void Paint(Option_t *option="") override
Paint this line with its current attributes.
Definition TLine.cxx:389
virtual void PaintLineNDC(Double_t u1, Double_t v1, Double_t u2, Double_t v2)
Draw this line with new coordinates in NDC.
Definition TLine.cxx:409
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
void AddBefore(const TObject *before, TObject *obj) override
Insert object before object before in the list.
Definition TList.cxx:196
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:470
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition TList.cxx:100
Manages Markers.
Definition TMarker.h:22
virtual void SetNDC(Bool_t isNDC=kTRUE)
Set NDC mode on if isNDC = kTRUE, off otherwise.
Definition TMarker.cxx:364
void Paint(Option_t *option="") override
Paint this marker with its current attributes.
Definition TMarker.cxx:304
A TMultiGraph is a collection of TGraph (or derived) objects.
Definition TMultiGraph.h:34
static TClass * Class()
Mother of all ROOT objects.
Definition TObject.h:41
virtual Option_t * GetDrawOption() const
Get option used by the graphics system to draw this object.
Definition TObject.cxx:423
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:962
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:403
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition TObject.cxx:184
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:525
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:976
virtual const char * GetTitle() const
Returns title of object.
Definition TObject.cxx:483
A TBox with a bordersize and a shadow option.
Definition TPave.h:19
void Print(Option_t *option="") const override
Dump this pave with its attributes.
Definition TPave.cxx:616
Double_t GetY2NDC() const
Definition TPave.h:62
Int_t GetBorderSize() const
Definition TPave.h:54
virtual void ConvertNDCtoPad()
Convert pave coordinates from NDC to Pad coordinates.
Definition TPave.cxx:139
Double_t GetX2NDC() const
Definition TPave.h:60
void Copy(TObject &pave) const override
Copy this pave to pave.
Definition TPave.cxx:186
Int_t fBorderSize
window box bordersize in pixels
Definition TPave.h:26
Double_t fX2NDC
X2 point in NDC coordinates.
Definition TPave.h:24
Double_t GetY1NDC() const
Definition TPave.h:61
virtual void SetBorderSize(Int_t bordersize=4)
Definition TPave.h:73
TString fOption
Pave style.
Definition TPave.h:30
Double_t fY2NDC
Y2 point in NDC coordinates.
Definition TPave.h:25
Double_t fX1NDC
X1 point in NDC coordinates.
Definition TPave.h:22
Double_t fY1NDC
Y1 point in NDC coordinates.
Definition TPave.h:23
Double_t GetX1NDC() const
Definition TPave.h:59
virtual void PaintPave(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Int_t bordersize=4, Option_t *option="br")
Draw this pave with new coordinates.
Definition TPave.cxx:315
Defined by an array on N points in a 2-D space.
Definition TPolyLine.h:23
void Paint(Option_t *option="") override
Paint this polyline with its current attributes.
Basic string class.
Definition TString.h:139
void ToLower()
Change string to lower-case.
Definition TString.cxx:1170
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:634
Width_t GetLegendBorderSize() const
Definition TStyle.h:201
Double_t GetLegendTextSize() const
Definition TStyle.h:204
Float_t GetEndErrorSize() const
Definition TStyle.h:184
Style_t GetLegendFont() const
Definition TStyle.h:203
Color_t GetLegendFillColor() const
Definition TStyle.h:202
virtual void SetNDC(Bool_t isNDC=kTRUE)
Set NDC mode on if isNDC = kTRUE, off otherwise.
Definition TText.cxx:823
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Double_t Ceil(Double_t x)
Rounds x upward, returning the smallest integral value that is not less than x.
Definition TMath.h:668
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:198
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123