Logo ROOT  
Reference Guide
TPie.cxx
Go to the documentation of this file.
1 // @(#)root/graf:$Id$
2 // Author: Guido Volpi, Olivier Couet 03/11/2006
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 "TPie.h"
13 #include "TPieSlice.h"
14 
15 #include <iostream>
16 #include <TROOT.h>
17 #include <TVirtualPad.h>
18 #include <TVirtualX.h>
19 #include <TArc.h>
20 #include <TLegend.h>
21 #include <TMath.h>
22 #include <TStyle.h>
23 #include <TLatex.h>
24 #include <TPaveText.h>
25 #include <TH1.h>
26 #include <TColor.h>
27 #include <TLine.h>
28 
29 ClassImp(TPie);
30 
31 /** \class TPie
32 \ingroup BasicGraphics
33 
34 Draw a Pie Chart,
35 
36 Example:
37 
38 Begin_Macro(source)
39 ../../../tutorials/graphics/piechart.C
40 End_Macro
41 */
42 
43 Double_t gX = 0; // Temporary pie X position.
44 Double_t gY = 0; // Temporary pie Y position.
45 Double_t gRadius = 0; // Temporary pie Radius of the TPie.
46 Double_t gRadiusOffset = 0; // Temporary slice's radial offset.
47 Double_t gAngularOffset = 0; // Temporary slice's angular offset.
48 Bool_t gIsUptSlice = kFALSE; // True if a slice in the TPie should
49  // be updated.
50 Int_t gCurrent_slice = -1;// Current slice under mouse.
51 Double_t gCurrent_phi1 = 0; // Phimin of the current slice.
52 Double_t gCurrent_phi2 = 0; // Phimax of the current slice.
53 Double_t gCurrent_rad = 0; // Current distance from the vertex of the
54  // current slice.
55 Double_t gCurrent_x = 0; // Current x in the pad metric.
56 Double_t gCurrent_y = 0; // Current y in the pad metric.
57 Double_t gCurrent_ang = 0; // Current angular, within current_phi1
58  // and current_phi2.
59 
60 ////////////////////////////////////////////////////////////////////////////////
61 /// Default constructor.
62 
64 {
65  Init(1, 0, 0.5, 0.5, 0.4);
66 }
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// This constructor creates a pie chart when only the number of
70 /// the slices is known. The number of slices is fixed.
71 
72 TPie::TPie(const char *name, const char *title, Int_t npoints) :
73  TNamed(name,title)
74 {
75  Init(npoints, 0, 0.5, 0.5, 0.4);
76 }
77 
78 ////////////////////////////////////////////////////////////////////////////////
79 /// Normal constructor. The 1st and 2nd parameters are the name of the object
80 /// and its title.
81 ///
82 /// The number of points passed at this point is used to allocate the memory.
83 ///
84 /// Slices values are given as Double_t.
85 ///
86 /// The 4th elements is an array containing, in double precision format,
87 /// the value of each slice. It is also possible to specify the filled color
88 /// of each slice. If the color array is not specified the slices are colored
89 /// using a color sequence in the standard palette.
90 
91 TPie::TPie(const char *name, const char *title,
92  Int_t npoints, Double_t *vals,
93  Int_t *colors, const char *lbls[]) : TNamed(name,title)
94 {
95  Init(npoints, 0, 0.5, 0.5, 0.4);
96  for (Int_t i=0; i<fNvals; ++i) fPieSlices[i]->SetValue(vals[i]);
97 
99  SetLabels(lbls);
100 }
101 
102 ////////////////////////////////////////////////////////////////////////////////
103 /// Normal constructor (Float_t).
104 
105 TPie::TPie(const char *name,
106  const char *title,
107  Int_t npoints, Float_t *vals,
108  Int_t *colors, const char *lbls[]) : TNamed(name,title)
109 {
110  Init(npoints, 0, 0.5, 0.5, 0.4);
111  for (Int_t i=0; i<fNvals; ++i) fPieSlices[i]->SetValue(vals[i]);
112 
114  SetLabels(lbls);
115 }
116 
117 ////////////////////////////////////////////////////////////////////////////////
118 /// Constructor from a TH1
119 
120 TPie::TPie(const TH1 *h) : TNamed(h->GetName(),h->GetTitle())
121 {
122  Int_t i;
123 
124  const TAxis *axis = h->GetXaxis();
125  Int_t first = axis->GetFirst();
126  Int_t last = axis->GetLast();
127  Int_t np = last-first+1;
128  Init(np, 0, 0.5, 0.5, 0.4);
129 
130  for (i=first; i<=last; ++i) fPieSlices[i-first]->SetValue(h->GetBinContent(i));
131  if (axis->GetLabels()) {
132  for (i=first; i<=last; ++i) fPieSlices[i-first]->SetTitle(axis->GetBinLabel(i));
133  } else {
134  SetLabelFormat("%val");
135  }
136  SetTextSize(axis->GetLabelSize());
137  SetTextColor(axis->GetLabelColor());
138  SetTextFont(axis->GetLabelFont());
139 }
140 
141 ////////////////////////////////////////////////////////////////////////////////
142 /// Copy constructor.
143 
144 TPie::TPie(const TPie &cpy) : TNamed(cpy), TAttText(cpy)
145 {
146  Init(cpy.fNvals, cpy.fAngularOffset, cpy.fX, cpy.fY, cpy.fRadius);
147 
148  for (Int_t i=0;i<fNvals;++i) {
149  fPieSlices[i] = cpy.fPieSlices[i];
150  }
151 }
152 
153 ////////////////////////////////////////////////////////////////////////////////
154 /// Destructor.
155 
157 {
158  if (fNvals>0) {
159  for (int i=0; i<fNvals; ++i) delete fPieSlices[i];
160  delete [] fPieSlices;
161  }
162 
163  if (fSlices) delete [] fSlices;
164  if (fLegend) delete fLegend;
165 }
166 
167 ////////////////////////////////////////////////////////////////////////////////
168 /// Evaluate the distance to the chart in gPad.
169 
171 {
172  Int_t dist = 9999;
173 
175  if ( gCurrent_slice>=0 ) {
176  if (gCurrent_rad<=fRadius) {
177  dist = 0;
178  }
179  }
180 
181  return dist;
182 }
183 
184 ////////////////////////////////////////////////////////////////////////////////
185 /// Returns the slice number at the pixel position (px,py).
186 /// Returns -1 if no slice is picked.
187 ///
188 /// Used by DistancetoPrimitive.
189 
191 {
192  MakeSlices();
193 
194  Int_t result(-1);
195 
196  // coordinates
197  Double_t xx = gPad->AbsPixeltoX(px); //gPad->PadtoX(gPad->AbsPixeltoX(px));
198  Double_t yy = gPad->AbsPixeltoY(py); //gPad->PadtoY(gPad->AbsPixeltoY(py));
199 
200  // XY metric
201  Double_t radX = fRadius;
202  Double_t radY = fRadius;
203  Double_t radXY = 1.;
204  if (fIs3D==kTRUE) {
205  radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
206  radY = radXY*radX;
207  }
208 
209  Double_t phimin;
210  Double_t cphi;
211  Double_t phimax;
212 
213  Float_t dPxl = (gPad->PixeltoY(0)-gPad->PixeltoY(1))/radY;
214  for (Int_t i=0;i<fNvals;++i) {
216 
217  if (gIsUptSlice && gCurrent_slice!=i) continue;
218 
219  // Angles' values for this slice
220  phimin = fSlices[2*i ]*TMath::Pi()/180.;
221  cphi = fSlices[2*i+1]*TMath::Pi()/180.;
222  phimax = fSlices[2*i+2]*TMath::Pi()/180.;
223 
224  Double_t radOffset = fPieSlices[i]->GetRadiusOffset();
225 
226  Double_t dx = (xx-fX-radOffset*TMath::Cos(cphi))/radX;
227  Double_t dy = (yy-fY-radOffset*TMath::Sin(cphi)*radXY)/radY;
228 
229  if (TMath::Abs(dy)<dPxl) dy = dPxl;
230 
231  Double_t ang = TMath::ATan2(dy,dx);
232  if (ang<0) ang += TMath::TwoPi();
233 
234  Double_t dist = TMath::Sqrt(dx*dx+dy*dy);
235 
236  if ( ((ang>=phimin && ang <= phimax) || (phimax>TMath::TwoPi() &&
237  ang+TMath::TwoPi()>=phimin && ang+TMath::TwoPi()<phimax)) &&
238  dist<=1.) { // if true the pointer is in the slice region
239 
240  gCurrent_x = dx;
241  gCurrent_y = dy;
242  gCurrent_ang = ang;
243  gCurrent_phi1 = phimin;
244  gCurrent_phi2 = phimax;
246 
247  if (dist<.95 && dist>.65) {
248  Double_t range = phimax-phimin;
249  Double_t lang = ang-phimin;
250  Double_t rang = phimax-ang;
251  if (lang<0) lang += TMath::TwoPi();
252  else if (lang>=TMath::TwoPi()) lang -= TMath::TwoPi();
253  if (rang<0) rang += TMath::TwoPi();
254  else if (rang>=TMath::TwoPi()) rang -= TMath::TwoPi();
255 
256  if (lang/range<.25 || rang/range<.25) {
258  result = -1;
259  }
260  else result = i;
261  } else {
262  result = i;
263  }
264 
265  break;
266  }
267  }
268  return result;
269 }
270 
271 ////////////////////////////////////////////////////////////////////////////////
272 /// Draw the pie chart.
273 ///
274 /// The possible options are listed in the TPie::Paint() method.
275 
276 void TPie::Draw(Option_t *option)
277 {
278  TString soption(option);
279  soption.ToLower();
280 
281  if (soption.Length()==0) soption = "l";
282 
283  if (gPad) {
284  if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
285  if (!soption.Contains("same")) {
286  gPad->Clear();
287  gPad->Range(0.,0.,1.,1.);
288  }
289  }
290 
291  for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->AppendPad();
292  AppendPad(soption.Data());
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// This method is for internal use. It is used by Execute event to draw the
297 /// outline of "this" TPie. Used when the opaque movements are not permitted.
298 
300 {
301  MakeSlices();
302 
303  // XY metric
304  Double_t radXY = 1.;
305  if (fIs3D) {
306  radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
307  }
308 
309  for (Int_t i=0;i<fNvals&&fIs3D==kTRUE;++i) {
310  Float_t minphi = (fSlices[i*2]+gAngularOffset+.5)*TMath::Pi()/180.;
311  Float_t avgphi = (fSlices[i*2+1]+gAngularOffset)*TMath::Pi()/180.;
312  Float_t maxphi = (fSlices[i*2+2]+gAngularOffset-.5)*TMath::Pi()/180.;
313 
314  Double_t radOffset = (i == gCurrent_slice ? gRadiusOffset : fPieSlices[i]->GetRadiusOffset());
315  Double_t x0 = gX+radOffset*TMath::Cos(avgphi);
316  Double_t y0 = gY+radOffset*TMath::Sin(avgphi)*radXY-fHeight;
317 
318  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0),
319  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
320  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY) );
321 
322  Int_t ndiv = 10;
323  Double_t dphi = (maxphi-minphi)/ndiv;
324 
325  if (dphi>.15) ndiv = (Int_t) ((maxphi-minphi)/.15);
326  dphi = (maxphi-minphi)/ndiv;
327 
328  // Loop to draw the arc
329  for (Int_t j=0;j<ndiv;++j) {
330  Double_t phi = minphi+dphi*j;
331  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi)),
332  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi)*radXY),
333  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi+dphi)),
334  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi+dphi)*radXY));
335  }
336 
337  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
338  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
339  gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0) );
340 
341  gVirtualX->DrawLine(gPad->XtoAbsPixel(x0),
342  gPad->YtoAbsPixel(y0),
343  gPad->XtoAbsPixel(x0),
344  gPad->YtoAbsPixel(y0+fHeight));
345  gVirtualX->DrawLine(gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
346  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY),
347  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
348  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY+fHeight));
349  gVirtualX->DrawLine(gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
350  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
351  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
352  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY+fHeight));
353  }
354 
355 
356  // Loop over slices
357  for (Int_t i=0;i<fNvals;++i) {
358  Float_t minphi = (fSlices[i*2]+gAngularOffset+.5)*TMath::Pi()/180.;
359  Float_t avgphi = (fSlices[i*2+1]+gAngularOffset)*TMath::Pi()/180.;
360  Float_t maxphi = (fSlices[i*2+2]+gAngularOffset-.5)*TMath::Pi()/180.;
361 
362  Double_t radOffset = (i == gCurrent_slice ? gRadiusOffset : fPieSlices[i]->GetRadiusOffset());
363  Double_t x0 = gX+radOffset*TMath::Cos(avgphi);
364  Double_t y0 = gY+radOffset*TMath::Sin(avgphi)*radXY;
365 
366  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0),
367  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
368  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY) );
369 
370 
371  Int_t ndiv = 10;
372  Double_t dphi = (maxphi-minphi)/ndiv;
373 
374  if (dphi>.15) ndiv = (Int_t) ((maxphi-minphi)/.15);
375  dphi = (maxphi-minphi)/ndiv;
376 
377  // Loop to draw the arc
378  for (Int_t j=0;j<ndiv;++j) {
379  Double_t phi = minphi+dphi*j;
380  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi)),
381  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi)*radXY),
382  gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi+dphi)),
383  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi+dphi)*radXY));
384  }
385 
386  gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
387  gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
388  gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0) );
389  }
390 }
391 
392 ////////////////////////////////////////////////////////////////////////////////
393 /// Execute the mouse events.
394 
395 void TPie::ExecuteEvent(Int_t event, Int_t px, Int_t py)
396 {
397  if (!gPad) return;
398  if (!gPad->IsEditable() && event != kMouseEnter) return;
399 
400  if (gCurrent_slice<=-10) {
401  gPad->SetCursor(kCross);
402  return;
403  }
404 
405  MakeSlices();
406 
407  static bool isMovingPie(kFALSE);
408  static bool isMovingSlice(kFALSE);
409  static bool isResizing(kFALSE);
410  static bool isRotating(kFALSE);
411  static bool onBorder(kFALSE);
412  bool isRedrawing(kFALSE);
413  static Int_t prev_event(-1);
414  static Int_t oldpx, oldpy;
415 
416  // Portion of pie considered as "border"
417  const Double_t dr = gPad->PixeltoX(3);
418  const Double_t minRad = gPad->PixeltoX(10);
419 
420  // Angular divisions in radial direction
421  const Double_t angstep1 = 0.5*TMath::PiOver4();
422  const Double_t angstep2 = 1.5*TMath::PiOver4();
423  const Double_t angstep3 = 2.5*TMath::PiOver4();
424  const Double_t angstep4 = 3.5*TMath::PiOver4();
425  const Double_t angstep5 = 4.5*TMath::PiOver4();
426  const Double_t angstep6 = 5.5*TMath::PiOver4();
427  const Double_t angstep7 = 6.5*TMath::PiOver4();
428  const Double_t angstep8 = 7.5*TMath::PiOver4();
429 
430  // XY metric
431  Double_t radXY = 1.;
432  if (fIs3D==kTRUE) {
433  radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
434  }
435 
436  Int_t dx, dy;
437  Double_t mdx, mdy;
438 
439  switch(event) {
440  case kArrowKeyPress:
441  case kButton1Down:
442  // Change cursor to show pie's movement.
443  gVirtualX->SetLineColor(1);
444  gVirtualX->SetLineWidth(2);
445 
446  // Current center and radius.
447  gX = fX;
448  gY = fY;
449  gRadius = fRadius;
451  gAngularOffset = 0;
452  gIsUptSlice = kTRUE;
453 
454  prev_event = kButton1Down;
455 
456  case kMouseMotion:
457  if (gCurrent_rad>=fRadius-2.*dr && gCurrent_rad<=fRadius+dr
458  && !isMovingPie && !isMovingSlice && !isResizing) {
459  if (gCurrent_ang>=angstep8 || gCurrent_ang<angstep1)
460  gPad->SetCursor(kRightSide);
461  else if (gCurrent_ang>=angstep1 && gCurrent_ang<angstep2)
462  gPad->SetCursor(kTopRight);
463  else if (gCurrent_ang>=angstep2 && gCurrent_ang<angstep3)
464  gPad->SetCursor(kTopSide);
465  else if (gCurrent_ang>=angstep3 && gCurrent_ang<angstep4)
466  gPad->SetCursor(kTopLeft);
467  else if (gCurrent_ang>=angstep4 && gCurrent_ang<=angstep5)
468  gPad->SetCursor(kLeftSide);
469  else if (gCurrent_ang>=angstep5 && gCurrent_ang<angstep6)
470  gPad->SetCursor(kBottomLeft);
471  else if (gCurrent_ang>=angstep6 && gCurrent_ang<angstep7)
472  gPad->SetCursor(kBottomSide);
473  else if (gCurrent_ang>=angstep7 && gCurrent_ang<angstep8)
474  gPad->SetCursor(kBottomRight);
475  onBorder = kTRUE;
476  } else {
477  onBorder = kFALSE;
478  if (gCurrent_rad>fRadius*.6) {
479  gPad->SetCursor(kPointer);
480  } else if (gCurrent_rad<=fRadius*.3) {
481  gPad->SetCursor(kHand);
482  } else if (gCurrent_rad<=fRadius*.6 && gCurrent_rad>=fRadius*.3) {
483  gPad->SetCursor(kRotate);
484  }
485  }
486  oldpx = px;
487  oldpy = py;
488  if (isMovingPie || isMovingSlice) gPad->SetCursor(kMove);
489  break;
490 
491  case kArrowKeyRelease:
492  case kButton1Motion:
493  if (!isMovingSlice || !isMovingPie || !isResizing || !isRotating) {
494  if (prev_event==kButton1Down) {
495  if (onBorder) {
496  isResizing = kTRUE;
497  } else if (gCurrent_rad>=fRadius*.6 && gCurrent_slice>=0) {
498  isMovingSlice = kTRUE;
499  } else if (gCurrent_rad<=fRadius*.3) {
500  isMovingPie = kTRUE;
501  } else if (gCurrent_rad<fRadius*.6 && gCurrent_rad>fRadius*.3) {
502  isRotating = kTRUE;
503  }
504  }
505  }
506 
507  dx = px-oldpx;
508  dy = py-oldpy;
509 
510  mdx = gPad->PixeltoX(dx);
511  mdy = gPad->PixeltoY(dy);
512 
513  if (isMovingPie || isMovingSlice) {
514  gPad->SetCursor(kMove);
515  if (isMovingSlice) {
516  Float_t avgphi = fSlices[gCurrent_slice*2+1]*TMath::Pi()/180.;
517 
518  if (!gPad->OpaqueMoving()) DrawGhost();
519 
520  gRadiusOffset += TMath::Cos(avgphi)*mdx +TMath::Sin(avgphi)*mdy/radXY;
521  if (gRadiusOffset<0) gRadiusOffset = .0;
522  gIsUptSlice = kTRUE;
523 
524  if (!gPad->OpaqueMoving()) DrawGhost();
525  } else {
526  if (!gPad->OpaqueMoving()) DrawGhost();
527 
528  gX += mdx;
529  gY += mdy;
530 
531  if (!gPad->OpaqueMoving()) DrawGhost();
532  }
533  } else if (isResizing) {
534  if (!gPad->OpaqueResizing()) DrawGhost();
535 
536  Float_t dr1 = mdx*TMath::Cos(gCurrent_ang)+mdy*TMath::Sin(gCurrent_ang)/radXY;
537  if (gRadius+dr1>=minRad) {
538  gRadius += dr1;
539  } else {
540  gRadius = minRad;
541  }
542 
543  if (!gPad->OpaqueResizing()) DrawGhost();
544  } else if (isRotating) {
545  if (!gPad->OpaqueMoving()) DrawGhost();
546 
547  Double_t xx = gPad->AbsPixeltoX(px);
548  Double_t yy = gPad->AbsPixeltoY(py);
549 
550  Double_t dx1 = xx-gX;
551  Double_t dy1 = yy-gY;
552 
553  Double_t ang = TMath::ATan2(dy1,dx1);
554  if (ang<0) ang += TMath::TwoPi();
555 
556  gAngularOffset = (ang-gCurrent_ang)*180/TMath::Pi();
557 
558  if (!gPad->OpaqueMoving()) DrawGhost();
559  }
560 
561  oldpx = px;
562  oldpy = py;
563 
564  if ( ((isMovingPie || isMovingSlice || isRotating) && gPad->OpaqueMoving()) ||
565  (isResizing && gPad->OpaqueResizing()) ) {
566  isRedrawing = kTRUE;
567  // event = kButton1Up;
568  // intentionally no break to continue with kButton1Up handling
569  }
570  else break;
571 
572  case kButton1Up:
573  if (!isRedrawing) {
574  prev_event = kButton1Up;
576  }
577 
578  if (gROOT->IsEscaped()) {
579  gROOT->SetEscape(kFALSE);
581  break;
582  }
583 
584  fX = gX;
585  fY = gY;
586  fRadius = gRadius;
589 
590  if (isRedrawing && (isMovingPie || isMovingSlice)) gPad->SetCursor(kMove);
591 
592  if (isMovingPie) isMovingPie = kFALSE;
593  if (isMovingSlice) isMovingSlice = kFALSE;
594  if (isResizing) isResizing = kFALSE;
595  if (isRotating) {
596  isRotating = kFALSE;
597  // this is important mainly when OpaqueMoving==kTRUE
599  }
600 
601  gPad->Modified(kTRUE);
602 
603 
605 
606  gVirtualX->SetLineColor(-1);
607  gVirtualX->SetLineWidth(-1);
608 
609  break;
610  case kButton1Locate:
611 
612  ExecuteEvent(kButton1Down, px, py);
613 
614  while (1) {
615  px = py = 0;
616  event = gVirtualX->RequestLocator(1, 1, px, py);
617 
618  ExecuteEvent(kButton1Motion, px, py);
619 
620  if (event != -1) { // button is released
621  ExecuteEvent(kButton1Up, px, py);
622  return;
623  }
624  }
625  break;
626 
627  case kMouseEnter:
628  break;
629 
630  default:
631  // unknown event
632  break;
633  }
634 }
635 
636 ////////////////////////////////////////////////////////////////////////////////
637 /// Returns the label of the entry number "i".
638 
640 {
641  return GetSlice(i)->GetTitle();
642 }
643 
644 ////////////////////////////////////////////////////////////////////////////////
645 /// Return the color of the slice number "i".
646 
648 {
649  return GetSlice(i)->GetFillColor();
650 }
651 
652 ////////////////////////////////////////////////////////////////////////////////
653 /// Return the style use to fill the slice number "i".
654 
656 {
657  return GetSlice(i)->GetFillStyle();
658 }
659 
660 ////////////////////////////////////////////////////////////////////////////////
661 /// Return the line color used to outline thi "i" slice
662 
664 {
665  return GetSlice(i)->GetLineColor();
666 }
667 
668 ////////////////////////////////////////////////////////////////////////////////
669 /// Return the style used to outline thi "i" slice
670 
672 {
673  return GetSlice(i)->GetLineStyle();
674 }
675 
676 ////////////////////////////////////////////////////////////////////////////////
677 /// Return the line width used to outline thi "i" slice
678 
680 {
681  return GetSlice(i)->GetLineWidth();
682 }
683 
684 ////////////////////////////////////////////////////////////////////////////////
685 /// Return the radial offset's value for the slice number "i".
686 
688 {
689  return GetSlice(i)->GetRadiusOffset();
690 }
691 
692 ////////////////////////////////////////////////////////////////////////////////
693 /// Return the value associated with the slice number "i".
694 
696 {
697  return GetSlice(i)->GetValue();
698 }
699 
700 ////////////////////////////////////////////////////////////////////////////////
701 /// If created before by Paint option or by MakeLegend method return
702 /// the pointer to the legend, otherwise return 0;
703 
705 {
706  return fLegend;
707 }
708 
709 ////////////////////////////////////////////////////////////////////////////////
710 /// Return the reference to the slice of index 'id'. There are no controls
711 /// of memory corruption, be carefull.
712 
714 {
715  return fPieSlices[id];
716 }
717 
718 ////////////////////////////////////////////////////////////////////////////////
719 /// Common initialization for all constructors.
720 /// This is a private function called to allocate the memory.
721 
723 {
725 
726  fAngularOffset = ao;
727  fX = x;
728  fY = y;
729  fRadius = r;
730  fNvals = np;
731  fSum = 0.;
732  fSlices = 0;
733  fLegend = 0;
734  fHeight = 0.08;
735  fAngle3D = 30;
736  fIs3D = kFALSE;
737 
739 
740  fPieSlices = new TPieSlice*[fNvals];
741 
742  for (Int_t i=0;i<fNvals;++i) {
743  TString tmplbl = "Slice";
744  tmplbl += i;
745  fPieSlices[i] = new TPieSlice(tmplbl.Data(), tmplbl.Data(), this);
746  fPieSlices[i]->SetRadiusOffset(0.);
747  fPieSlices[i]->SetLineColor(1);
748  fPieSlices[i]->SetLineStyle(1);
749  fPieSlices[i]->SetLineWidth(1);
751  fPieSlices[i]->SetFillStyle(1001);
752  }
753 
754  fLabelFormat = "%txt";
755  fFractionFormat = "%3.2f";
756  fValueFormat = "%4.2f";
757  fPercentFormat = "%3.1f";
758 }
759 
760 ////////////////////////////////////////////////////////////////////////////////
761 /// This method create a legend that explains the contents
762 /// of the slice for this pie-chart.
763 ///
764 /// The parameter passed reppresents the option passed to shown the slices,
765 /// see TLegend::AddEntry() for further details.
766 ///
767 /// The pointer of the TLegend is returned.
768 
769 TLegend* TPie::MakeLegend(Double_t x1, Double_t y1, Double_t x2, Double_t y2, const char *leg_header)
770 {
771  if (!fLegend) fLegend = new TLegend(x1,y1,x2,y2,leg_header);
772  else fLegend->Clear();
773 
774  for (Int_t i=0;i<fNvals;++i) {
775  fLegend->AddEntry(*(fPieSlices+i),fPieSlices[i]->GetTitle(),"f");
776  }
777 
778  if (gPad) fLegend->Draw();
779 
780  return fLegend;
781 }
782 
783 ////////////////////////////////////////////////////////////////////////////////
784 /// Paint a Pie chart in a canvas.
785 /// The possible option are:
786 ///
787 /// - "R" Print the labels along the central "R"adius of slices.
788 /// - "T" Print the label in a direction "T"angent to circle that describes
789 /// the TPie.
790 /// - "SC" Paint the the labels with the "S"ame "C"olor as the slices.
791 /// - "3D" Draw the pie-chart with a pseudo 3D effect.
792 /// - "NOL" No OutLine: Don't draw the slices' outlines, any property over the
793 /// slices' line is ignored.
794 /// - ">" Sort the slices in increasing order.
795 /// - "<" Sort the slices in decreasing order.
796 ///
797 /// After the use of > or < options the internal order of the TPieSlices
798 /// is changed.
799 ///
800 /// Other options changing the labels' format are described in
801 /// TPie::SetLabelFormat().
802 
803 void TPie::Paint(Option_t *option)
804 {
805  MakeSlices();
806 
807  TString soption(option);
808 
809  bool optionSame(kFALSE);
810 
811  // if true the lines around the slices are drawn, if false not
812  Bool_t optionLine(kTRUE);
813 
814  // if true the labels' colors are the same as the slices' colors
815  Bool_t optionSameColor(kFALSE);
816 
817  // For the label orientation there are 3 possibilities:
818  // 0: horizontal
819  // 1: radial
820  // 2: tangent
821  Int_t lblor(0);
822 
823  // Parse the options
824  Int_t idx;
825  // Paint the TPie in an existing canvas
826  if ( (idx=soption.Index("same"))>=0 ) {
827  optionSame = kTRUE;
828  soption.Remove(idx,4);
829  }
830 
831  if ( (idx=soption.Index("nol"))>=0 ) {
832  optionLine = kFALSE;
833  soption.Remove(idx,3);
834  }
835 
836  if ( (idx=soption.Index("sc"))>=0 ) {
837  optionSameColor = kTRUE;
838  soption.Remove(idx,2);
839  }
840 
841  // check if is active the pseudo-3d
842  if ( (idx=soption.Index("3d"))>=0 ) {
843  fIs3D = kTRUE;
844  soption.Remove(idx,2);
845  } else {
846  fIs3D = kFALSE;
847  }
848 
849  // seek if have to draw the labels around the pie chart
850  if ( (idx=soption.Index("t"))>=0 ) {
851  lblor = 2;
852  soption.Remove(idx,1);
853  }
854 
855  // Seek if have to paint the labels along the radii
856  if ( (idx=soption.Index("r"))>=0 ) {
857  lblor = 1;
858  soption.Remove(idx,1);
859  }
860 
861  // Seeks if has to paint sort the slices in increasing mode
862  if ( (idx=soption.Index(">"))>=0 ) {
863  SortSlices(kTRUE);
864  soption.Remove(idx,1);
865  }
866 
867  // Seeks if has to paint sort the slices in decreasing mode
868  if ( (idx=soption.Index("<"))>=0 ) {
870  soption.Remove(idx,1);
871  }
872 
873  if (fNvals<=0) {
874  Warning("Paint","No vals");
875  return;
876  }
877 
878  if (!fPieSlices) {
879  Warning("Paint","No valid arrays of values");
880  return;
881  }
882 
883  // Check if gPad exists and define the drawing range.
884  if (!gPad) return;
885 
886  // Objects useful to draw labels and slices
887  TLatex *textlabel = new TLatex();
888  TArc *arc = new TArc();
889  TLine *line = new TLine();
890 
891  // XY metric
892  Double_t radX = fRadius;
893  Double_t radY = fRadius;
894  Double_t radXY = 1.;
895 
896  if (fIs3D) {
897  radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
898  radY = fRadius*radXY;
899  }
900 
901  // Draw the slices.
902  Int_t pixelHeight = gPad->YtoPixel(0)-gPad->YtoPixel(fHeight);
903  for (Int_t pi=0;pi<pixelHeight&&fIs3D==kTRUE; ++pi) { // loop for pseudo-3d effect
904  for (Int_t i=0;i<fNvals;++i) {
905  // draw the arc
906  // set the color of the next slice
907  if (pi>0) {
908  arc->SetFillStyle(0);
909  arc->SetLineColor(TColor::GetColorDark((fPieSlices[i]->GetFillColor())));
910  } else {
911  arc->SetFillStyle(0);
912  if (optionLine==kTRUE) {
913  arc->SetLineColor(fPieSlices[i]->GetLineColor());
914  arc->SetLineStyle(fPieSlices[i]->GetLineStyle());
915  arc->SetLineWidth(fPieSlices[i]->GetLineWidth());
916  } else {
917  arc->SetLineWidth(1);
918  arc->SetLineColor(TColor::GetColorDark((fPieSlices[i]->GetFillColor())));
919  }
920  }
921  // Paint the slice
922  Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
923 
925  Double_t ay = fY+TMath::Sin(aphi)*fPieSlices[i]->GetRadiusOffset()*radXY+gPad->PixeltoY(pixelHeight-pi);
926 
927  arc->PaintEllipse(ax, ay, radX, radY, fSlices[2*i],
928  fSlices[2*i+2], 0.);
929 
930  if (optionLine==kTRUE) {
931  line->SetLineColor(fPieSlices[i]->GetLineColor());
932  line->SetLineStyle(fPieSlices[i]->GetLineStyle());
933  line->SetLineWidth(fPieSlices[i]->GetLineWidth());
934  line->PaintLine(ax,ay,ax,ay);
935 
936  Double_t x0, y0;
937  x0 = ax+radX*TMath::Cos(fSlices[2*i]/180.*TMath::Pi());
938  y0 = ay+radY*TMath::Sin(fSlices[2*i]/180.*TMath::Pi());
939  line->PaintLine(x0,y0,x0,y0);
940 
941  x0 = ax+radX*TMath::Cos(fSlices[2*i+2]/180.*TMath::Pi());
942  y0 = ay+radY*TMath::Sin(fSlices[2*i+2]/180.*TMath::Pi());
943  line->PaintLine(x0,y0,x0,y0);
944  }
945  }
946  } // end loop for pseudo-3d effect
947 
948  for (Int_t i=0;i<fNvals;++i) { // loop for the piechart
949  // Set the color of the next slice
950  arc->SetFillColor(fPieSlices[i]->GetFillColor());
951  arc->SetFillStyle(fPieSlices[i]->GetFillStyle());
952  if (optionLine==kTRUE) {
953  arc->SetLineColor(fPieSlices[i]->GetLineColor());
954  arc->SetLineStyle(fPieSlices[i]->GetLineStyle());
955  arc->SetLineWidth(fPieSlices[i]->GetLineWidth());
956  } else {
957  arc->SetLineWidth(1);
958  arc->SetLineColor(fPieSlices[i]->GetFillColor());
959  }
960 
961  // Paint the slice
962  Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
963 
965  Double_t ay = fY+TMath::Sin(aphi)*fPieSlices[i]->GetRadiusOffset()*radXY;
966  arc->PaintEllipse(ax, ay, radX, radY, fSlices[2*i],
967  fSlices[2*i+2], 0.);
968 
969  } // end loop to draw the slices
970 
971 
972  // Set the font
973  textlabel->SetTextFont(GetTextFont());
974  textlabel->SetTextSize(GetTextSize());
975  textlabel->SetTextColor(GetTextColor());
976 
977  // Loop to place the labels.
978  for (Int_t i=0;i<fNvals;++i) {
979  Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
980  //aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
981 
982  Float_t label_off = fLabelsOffset;
983 
984 
985  // Paint the text in the pad
986  TString tmptxt = fLabelFormat;
987 
988  tmptxt.ReplaceAll("%txt",fPieSlices[i]->GetTitle());
989  tmptxt.ReplaceAll("%val",Form(fValueFormat.Data(),fPieSlices[i]->GetValue()));
990  tmptxt.ReplaceAll("%frac",Form(fFractionFormat.Data(),fPieSlices[i]->GetValue()/fSum));
991  tmptxt.ReplaceAll("%perc",Form(Form("%s %s",fPercentFormat.Data(),"%s"),(fPieSlices[i]->GetValue()/fSum)*100,"%"));
992 
993  textlabel->SetTitle(tmptxt.Data());
994  Double_t h = textlabel->GetYsize();
995  Double_t w = textlabel->GetXsize();
996 
997  Float_t lx = fX+(fRadius+fPieSlices[i]->GetRadiusOffset()+label_off)*TMath::Cos(aphi);
998  Float_t ly = fY+(fRadius+fPieSlices[i]->GetRadiusOffset()+label_off)*TMath::Sin(aphi)*radXY;
999 
1000  Double_t lblang = 0;
1001 
1002  if (lblor==1) { // radial direction for the label
1003  aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1004  lblang += aphi;
1005  if (lblang<=0) lblang += TMath::TwoPi();
1006  if (lblang>TMath::TwoPi()) lblang-= TMath::TwoPi();
1007 
1008  lx += h/2.*TMath::Sin(lblang);
1009  ly -= h/2.*TMath::Cos(lblang);
1010 
1011  // This control prevent text up-side
1012  if (lblang>TMath::PiOver2() && lblang<=3.*TMath::PiOver2()) {
1013  lx += w*TMath::Cos(lblang)-h*TMath::Sin(lblang);
1014  ly += w*TMath::Sin(lblang)+h*TMath::Cos(lblang);
1015  lblang -= TMath::Pi();
1016  }
1017  } else if (lblor==2) { // tangential direction of the labels
1018  aphi -=TMath::PiOver2();
1019  aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1020  lblang += aphi;//-TMath::PiOver2();
1021  if (lblang<0) lblang+=TMath::TwoPi();
1022 
1023  lx -= w/2.*TMath::Cos(lblang);
1024  ly -= w/2.*TMath::Sin(lblang);
1025 
1026  if (lblang>TMath::PiOver2() && lblang<3.*TMath::PiOver2()) {
1027  lx += w*TMath::Cos(lblang)-h*TMath::Sin(lblang);
1028  ly += w*TMath::Sin(lblang)+h*TMath::Cos(lblang);
1029  lblang -= TMath::Pi();
1030  }
1031  } else { // horizontal labels (default direction)
1032  aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1033  if (aphi>TMath::PiOver2() || aphi<=-TMath::PiOver2()) lx -= w;
1034  if (aphi<0) ly -= h;
1035  }
1036 
1037  Float_t rphi = TMath::ATan2((ly-fY)*radXY,lx-fX);
1038  if (rphi < 0 && fIs3D && label_off>=0.)
1039  ly -= fHeight;
1040 
1041  if (optionSameColor) textlabel->SetTextColor((fPieSlices[i]->GetFillColor()));
1042  textlabel->PaintLatex(lx,ly,
1043  lblang*180/TMath::Pi()+GetTextAngle(),
1044  GetTextSize(), tmptxt.Data());
1045  }
1046 
1047  delete arc;
1048  delete line;
1049  delete textlabel;
1050 
1051  if (optionSame) return;
1052 
1053  // Draw title
1054  TPaveText *title = 0;
1055  TObject *obj;
1056  if ((obj = gPad->GetListOfPrimitives()->FindObject("title"))) {
1057  title = dynamic_cast<TPaveText*>(obj);
1058  }
1059 
1060  // Check the OptTitle option
1061  if (strlen(GetTitle()) == 0 || gStyle->GetOptTitle() <= 0) {
1062  if (title) delete title;
1063  return;
1064  }
1065 
1066  // Height and width of the title
1067  Double_t ht = gStyle->GetTitleH();
1068  Double_t wt = gStyle->GetTitleW();
1069  if (ht<=0) ht = 1.1*gStyle->GetTitleFontSize();
1070  if (ht<=0) ht = 0.05; // minum height
1071  if (wt<=0) { // eval the width of the title
1072  TLatex l;
1073  l.SetTextSize(ht);
1074  l.SetTitle(GetTitle());
1075  // adjustment in case the title has several lines (#splitline)
1076  ht = TMath::Max(ht, 1.2*l.GetYsize()/(gPad->GetY2() - gPad->GetY1()));
1077  Double_t wndc = l.GetXsize()/(gPad->GetX2() - gPad->GetX1());
1078  wt = TMath::Min(0.7, 0.02+wndc);
1079  }
1080 
1081  if (title) {
1082  TText *t0 = (TText*)title->GetLine(0);
1083  if (t0) {
1084  if (!strcmp(t0->GetTitle(),GetTitle())) return;
1085  t0->SetTitle(GetTitle());
1086  if (wt > 0) title->SetX2NDC(title->GetX1NDC()+wt);
1087  }
1088  return;
1089  }
1090 
1091  Int_t talh = gStyle->GetTitleAlign()/10;
1092  if (talh < 1) talh = 1; else if (talh > 3) talh = 3;
1093  Int_t talv = gStyle->GetTitleAlign()%10;
1094  if (talv < 1) talv = 1; else if (talv > 3) talv = 3;
1095  Double_t xpos, ypos;
1096  xpos = gStyle->GetTitleX();
1097  ypos = gStyle->GetTitleY();
1098  if (talh == 2) xpos = xpos-wt/2.;
1099  if (talh == 3) xpos = xpos-wt;
1100  if (talv == 2) ypos = ypos+ht/2.;
1101  if (talv == 1) ypos = ypos+ht;
1102 
1103  title = new TPaveText(xpos,ypos-ht,xpos+wt,ypos,"blNDC");
1105  title->SetFillStyle(gStyle->GetTitleStyle());
1106  title->SetName("title");
1107 
1110  title->SetTextFont(gStyle->GetTitleFont(""));
1111  if (gStyle->GetTitleFont("")%10 > 2)
1112  title->SetTextSize(gStyle->GetTitleFontSize());
1113  title->AddText(GetTitle());
1114 
1115  title->SetBit(kCanDelete);
1116 
1117  title->Draw();
1118  title->Paint();
1119 }
1120 
1121 ////////////////////////////////////////////////////////////////////////////////
1122 /// Save primitive as a C++ statement(s) on output stream out
1123 
1124 void TPie::SavePrimitive(std::ostream &out, Option_t *option)
1125 {
1126  out << " " << std::endl;
1127  if (gROOT->ClassSaved(TPie::Class())) {
1128  out << " ";
1129  } else {
1130  out << " TPie *";
1131  }
1132  out << GetName() << " = new TPie(\"" << GetName() << "\", \"" << GetTitle()
1133  << "\", " << fNvals << ");" << std::endl;
1134  out << " " << GetName() << "->SetCircle(" << fX << ", " << fY << ", "
1135  << fRadius << ");" << std::endl;
1136  out << " " << GetName() << "->SetValueFormat(\"" << GetValueFormat()
1137  << "\");" << std::endl;
1138  out << " " << GetName() << "->SetLabelFormat(\"" << GetLabelFormat()
1139  << "\");" << std::endl;
1140  out << " " << GetName() << "->SetPercentFormat(\"" << GetPercentFormat()
1141  << "\");" << std::endl;
1142  out << " " << GetName() << "->SetLabelsOffset(" << GetLabelsOffset()
1143  << ");" << std::endl;
1144  out << " " << GetName() << "->SetAngularOffset(" << GetAngularOffset()
1145  << ");" << std::endl;
1146  out << " " << GetName() << "->SetTextAngle(" << GetTextAngle() << ");" << std::endl;
1147  out << " " << GetName() << "->SetTextColor(" << GetTextColor() << ");" << std::endl;
1148  out << " " << GetName() << "->SetTextFont(" << GetTextFont() << ");" << std::endl;
1149  out << " " << GetName() << "->SetTextSize(" << GetTextSize() << ");" << std::endl;
1150 
1151 
1152  // Save the values for the slices
1153  for (Int_t i=0;i<fNvals;++i) {
1154  out << " " << GetName() << "->GetSlice(" << i << ")->SetTitle(\""
1155  << fPieSlices[i]->GetTitle() << "\");" << std::endl;
1156  out << " " << GetName() << "->GetSlice(" << i << ")->SetValue("
1157  << fPieSlices[i]->GetValue() << ");" << std::endl;
1158  out << " " << GetName() << "->GetSlice(" << i << ")->SetRadiusOffset("
1159  << fPieSlices[i]->GetRadiusOffset() << ");" << std::endl;
1160  out << " " << GetName() << "->GetSlice(" << i << ")->SetFillColor("
1161  << fPieSlices[i]->GetFillColor() << ");" << std::endl;
1162  out << " " << GetName() << "->GetSlice(" << i << ")->SetFillStyle("
1163  << fPieSlices[i]->GetFillStyle() << ");" << std::endl;
1164  out << " " << GetName() << "->GetSlice(" << i << ")->SetLineColor("
1165  << fPieSlices[i]->GetLineColor() << ");" << std::endl;
1166  out << " " << GetName() << "->GetSlice(" << i << ")->SetLineStyle("
1167  << fPieSlices[i]->GetLineStyle() << ");" << std::endl;
1168  out << " " << GetName() << "->GetSlice(" << i << ")->SetLineWidth("
1169  << fPieSlices[i]->GetLineWidth() << ");" << std::endl;
1170  }
1171 
1172  out << " " << GetName() << "->Draw(\"" << option << "\");" << std::endl;
1173 }
1174 
1175 ////////////////////////////////////////////////////////////////////////////////
1176 /// Set the value of for the pseudo 3D view angle, in degree.
1177 /// The range of the permitted values is: [0,90]
1178 
1180  // check if val is in the permitted range
1181  while (val>360.) val -= 360.;
1182  while (val<0) val += 360.;
1183  if (val>=90 && val<180) val = 180-val;
1184  else if (val>=180 && val<=360) val = 360-val;
1185 
1186  fAngle3D = val;
1187 }
1188 
1189 ////////////////////////////////////////////////////////////////////////////////
1190 /// Set the global angular offset for slices in degree [0,360]
1191 
1193 {
1194  fAngularOffset = offset;
1195 
1196  while (fAngularOffset>=360.) fAngularOffset -= 360.;
1197  while (fAngularOffset<0.) fAngularOffset += 360.;
1198 
1199  MakeSlices(kTRUE);
1200 }
1201 
1202 ////////////////////////////////////////////////////////////////////////////////
1203 /// Set the coordinates of the circle that describe the pie:
1204 /// - the 1st and the 2nd arguments are the x and y center's coordinates.
1205 /// - the 3rd value is the pie-chart's radius.
1206 ///
1207 /// All the coordinates are in NDC space.
1208 
1210 {
1211  fX = x;
1212  fY = y;
1213  fRadius = rad;
1214 }
1215 
1216 ////////////////////////////////////////////////////////////////////////////////
1217 /// Set slice number "i" label. The first parameter is the index of the slice,
1218 /// the other is the label text.
1219 
1220 void TPie::SetEntryLabel(Int_t i, const char *text)
1221 {
1222  // Set the Label of a single slice
1223  if (i>=0 && i<fNvals) fPieSlices[i]->SetTitle(text);
1224 }
1225 
1226 ////////////////////////////////////////////////////////////////////////////////
1227 /// Set the color for the slice's outline. "i" is the slice number.
1228 
1230 {
1231  if (i>=0 && i<fNvals) fPieSlices[i]->SetLineColor(color);
1232 }
1233 
1234 ////////////////////////////////////////////////////////////////////////////////
1235 /// Set the style for the slice's outline. "i" is the slice number.
1236 
1238 {
1239  if (i>=0 && i<fNvals) fPieSlices[i]->SetLineStyle(style);
1240 }
1241 
1242 ////////////////////////////////////////////////////////////////////////////////
1243 /// Set the width of the slice's outline. "i" is the slice number.
1244 
1246 {
1247  if (i>=0 && i<fNvals) fPieSlices[i]->SetLineWidth(width);
1248 }
1249 
1250 ////////////////////////////////////////////////////////////////////////////////
1251 /// Set the color for the slice "i".
1252 
1254 {
1255  if (i>=0 && i<fNvals) fPieSlices[i]->SetFillColor(color);
1256 }
1257 
1258 ////////////////////////////////////////////////////////////////////////////////
1259 /// Set the fill style for the "i" slice
1260 
1262 {
1263  if (i>=0 && i<fNvals) fPieSlices[i]->SetFillStyle(style);
1264 }
1265 
1266 ////////////////////////////////////////////////////////////////////////////////
1267 /// Set the distance, in the direction of the radius of the slice.
1268 
1270 {
1271  if (i>=0 && i<fNvals) fPieSlices[i]->SetRadiusOffset(shift);
1272 }
1273 
1274 ////////////////////////////////////////////////////////////////////////////////
1275 /// Set the value of a slice
1276 
1278 {
1279  if (i>=0 && i<fNvals) fPieSlices[i]->SetValue(val);
1280 
1281  MakeSlices(kTRUE);
1282 }
1283 
1284 ////////////////////////////////////////////////////////////////////////////////
1285 /// Set the fill colors for all the TPie's slices.
1286 
1288 {
1289  if (!colors) return;
1290  for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->SetFillColor(colors[i]);
1291 }
1292 
1293 ////////////////////////////////////////////////////////////////////////////////
1294 /// Set the height, in pixel, for the piechart if is drawn using
1295 /// the pseudo-3d mode.
1296 ///
1297 /// The default value is 20 pixel.
1298 
1299 void TPie::SetHeight(Double_t val/*=20*/)
1300 {
1301  fHeight = val;
1302 }
1303 
1304 ////////////////////////////////////////////////////////////////////////////////
1305 /// This method is used to customize the label format. The format string
1306 /// must contain one of these modifiers:
1307 ///
1308 /// - %txt : to print the text label associated with the slice
1309 /// - %val : to print the numeric value of the slice
1310 /// - %frac : to print the relative fraction of this slice
1311 /// - %perc : to print the % of this slice
1312 ///
1313 /// ex. : mypie->SetLabelFormat("%txt (%frac)");
1314 
1315 void TPie::SetLabelFormat(const char *fmt)
1316 {
1317  fLabelFormat = fmt;
1318 }
1319 
1320 ////////////////////////////////////////////////////////////////////////////////
1321 /// Set numeric format in the label, is used if the label format
1322 /// there is the modifier %frac, in this case the value is printed
1323 /// using this format.
1324 ///
1325 /// The numeric format use the standard C modifier used in stdio library:
1326 /// %f, %2.1$, %e... for further documentation you can use the printf
1327 /// man page ("man 3 printf" on linux)
1328 ///
1329 /// Example:
1330 /// ~~~ {.cpp}
1331 /// mypie->SetLabelFormat("%txt (%frac)");
1332 /// mypie->SetFractionFormat("2.1f");
1333 /// ~~~
1334 
1335 void TPie::SetFractionFormat(const char *fmt)
1336 {
1337  fFractionFormat = fmt;
1338 }
1339 
1340 ////////////////////////////////////////////////////////////////////////////////
1341 /// Set the labels for all the slices.
1342 
1343 void TPie::SetLabels(const char *lbls[])
1344 {
1345  if (!lbls) return;
1346  for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->SetTitle(lbls[i]);
1347 }
1348 
1349 ////////////////////////////////////////////////////////////////////////////////
1350 /// Set the distance between the label end the external line of the TPie.
1351 
1352 void TPie::SetLabelsOffset(Float_t labelsoffset)
1353 {
1354  fLabelsOffset = labelsoffset;
1355 }
1356 
1357 ////////////////////////////////////////////////////////////////////////////////
1358 /// Set the numeric format for the percent value of a slice, default: %3.1f
1359 
1360 void TPie::SetPercentFormat(const char *fmt)
1361 {
1362  fPercentFormat = fmt;
1363 }
1364 
1365 ////////////////////////////////////////////////////////////////////////////////
1366 /// Set the pie chart's radius' value.
1367 
1369 {
1370  if (rad>0) {
1371  fRadius = rad;
1372  } else {
1373  Warning("SetRadius",
1374  "It's not possible set the radius to a negative value");
1375  }
1376 }
1377 
1378 ////////////////////////////////////////////////////////////////////////////////
1379 /// Set the numeric format the slices' values.
1380 /// Used by %val (see SetLabelFormat()).
1381 
1382 void TPie::SetValueFormat(const char *fmt)
1383 {
1384  fValueFormat = fmt;
1385 }
1386 
1387 ////////////////////////////////////////////////////////////////////////////////
1388 /// Set X value.
1389 
1391 {
1392  fX = x;
1393 }
1394 
1395 ////////////////////////////////////////////////////////////////////////////////
1396 /// Set Y value.
1397 
1399 {
1400  fY = y;
1401 }
1402 
1403 ////////////////////////////////////////////////////////////////////////////////
1404 /// Make the slices.
1405 /// If they already exist it does nothing unless force=kTRUE.
1406 
1408 {
1409  if (fSlices && !force) return;
1410 
1411  fSum = .0;
1412 
1413  for (Int_t i=0;i<fNvals;++i) {
1414  if (fPieSlices[i]->GetValue()<0) {
1415  Warning("MakeSlices",
1416  "Negative values in TPie, absolute value will be used");
1417  fPieSlices[i]->SetValue(-1.*fPieSlices[i]->GetValue());
1418  }
1419  fSum += fPieSlices[i]->GetValue();
1420  }
1421 
1422  if (fSum<=.0) return;
1423 
1424  if (!fSlices) fSlices = new Float_t[2*fNvals+1];
1425 
1426  // Compute the slices size and position (2 angles for each slice)
1427  fSlices[0] = fAngularOffset;
1428  for (Int_t i=0;i<fNvals;++i) {
1429  Float_t dphi = fPieSlices[i]->GetValue()/fSum*360.;
1430  fSlices[2*i+1] = fSlices[2*i]+dphi/2.;
1431  fSlices[2*i+2] = fSlices[2*i]+dphi;
1432  }
1433 }
1434 
1435 ////////////////////////////////////////////////////////////////////////////////
1436 /// This method, mainly intended for internal use, ordered the slices according their values.
1437 /// The default (amode=kTRUE) is increasing order, but is also possible in decreasing order (amode=kFALSE).
1438 ///
1439 /// If the merge_threshold>0 the slice that contains a quantity smaller than merge_threshold are merged
1440 /// together
1441 
1442 void TPie::SortSlices(Bool_t amode, Float_t merge_threshold)
1443 {
1444 
1445  // main loop to order, bubble sort, the array
1446  Bool_t isDone = kFALSE;
1447 
1448  while (isDone==kFALSE) {
1449  isDone = kTRUE;
1450 
1451  for (Int_t i=0;i<fNvals-1;++i) { // loop over the values
1452  if ( (amode && (fPieSlices[i]->GetValue()>fPieSlices[i+1]->GetValue())) ||
1453  (!amode && (fPieSlices[i]->GetValue()<fPieSlices[i+1]->GetValue()))
1454  )
1455  {
1456  // exchange the order
1457  TPieSlice *tmpcpy = fPieSlices[i];
1458  fPieSlices[i] = fPieSlices[i+1];
1459  fPieSlices[i+1] = tmpcpy;
1460 
1461  isDone = kFALSE;
1462  }
1463  } // end loop the values
1464  } // end main ordering loop
1465 
1466  if (merge_threshold>0) {
1467  // merge smallest slices
1468  TPieSlice *merged_slice = new TPieSlice("merged","other",this);
1469  merged_slice->SetRadiusOffset(0.);
1470  merged_slice->SetLineColor(1);
1471  merged_slice->SetLineStyle(1);
1472  merged_slice->SetLineWidth(1);
1473  merged_slice->SetFillColor(gStyle->GetColorPalette( (amode ? 0 : fNvals-1) ));
1474  merged_slice->SetFillStyle(1001);
1475 
1476  if (amode) {
1477  // search slices under the threshold
1478  Int_t iMerged = 0;
1479  for (;iMerged<fNvals&&fPieSlices[iMerged]->GetValue()<merge_threshold;++iMerged) {
1480  merged_slice->SetValue( merged_slice->GetValue()+fPieSlices[iMerged]->GetValue() );
1481  }
1482 
1483  // evaluate number of valid slices
1484  if (iMerged<=1) { // no slices to merge
1485  delete merged_slice;
1486  }
1487  else { // write a new array with the right dimension
1488  Int_t old_fNvals = fNvals;
1489  fNvals = fNvals-iMerged+1;
1490  TPieSlice **new_array = new TPieSlice*[fNvals];
1491  new_array[0] = merged_slice;
1492  for (Int_t i=0;i<old_fNvals;++i) {
1493  if (i<iMerged) delete fPieSlices[i];
1494  else new_array[i-iMerged+1] = fPieSlices[i];
1495  }
1496  delete [] fPieSlices;
1497  fPieSlices = new_array;
1498  }
1499  }
1500  else {
1501  Int_t iMerged = fNvals-1;
1502  for (;iMerged>=0&&fPieSlices[iMerged]->GetValue()<merge_threshold;--iMerged) {
1503  merged_slice->SetValue( merged_slice->GetValue()+fPieSlices[iMerged]->GetValue() );
1504  }
1505 
1506  // evaluate number of valid slices
1507  Int_t nMerged = fNvals-1-iMerged;
1508  if (nMerged<=1) { // no slices to merge
1509  delete merged_slice;
1510  }
1511  else { // write a new array with the right dimension
1512  Int_t old_fNvals = fNvals;
1513  fNvals = fNvals-nMerged+1;
1514  TPieSlice **new_array = new TPieSlice*[fNvals];
1515  new_array[fNvals-1] = merged_slice;
1516  for (Int_t i=old_fNvals-1;i>=0;--i) {
1517  if (i>iMerged) delete fPieSlices[i];
1518  else new_array[i-nMerged-1] = fPieSlices[i];
1519  }
1520  delete [] fPieSlices;
1521  fPieSlices = new_array;
1522  }
1523 
1524  }
1525  }
1526 
1527  MakeSlices(kTRUE);
1528 }
1529 
TAxis::GetBinLabel
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition: TAxis.cxx:440
TPie::fIs3D
Bool_t fIs3D
! true if the pseudo-3d is enabled
Definition: TPie.h:44
l
auto * l
Definition: textangle.C:4
TPieSlice::GetValue
Double_t GetValue()
Return the value of this slice.
Definition: TPieSlice.cxx:76
TAttText
Text Attributes class.
Definition: TAttText.h:18
TPie::SetY
void SetY(Double_t)
Set Y value.
Definition: TPie.cxx:1398
TPie.h
TPave::SetBorderSize
virtual void SetBorderSize(Int_t bordersize=4)
Definition: TPave.h:73
TPie::SetX
void SetX(Double_t)
Set X value.
Definition: TPie.cxx:1390
TAxis
Class to manage histogram axis.
Definition: TAxis.h:30
kLeftSide
@ kLeftSide
Definition: GuiTypes.h:373
first
Definition: first.py:1
TPaveText::Paint
virtual void Paint(Option_t *option="")
Paint this pavetext with its current attributes.
Definition: TPaveText.cxx:409
TPie::SortSlices
void SortSlices(Bool_t amode=kTRUE, Float_t merge_thresold=.0)
This method, mainly intended for internal use, ordered the slices according their values.
Definition: TPie.cxx:1442
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:95
TLine.h
TArc
Create an Arc.
Definition: TArc.h:26
TMath::ATan2
Double_t ATan2(Double_t y, Double_t x)
Definition: TMath.h:679
kTopSide
@ kTopSide
Definition: GuiTypes.h:373
TPie::fValueFormat
TString fValueFormat
Vform numeric format for the value.
Definition: TPie.h:39
kRightSide
@ kRightSide
Definition: GuiTypes.h:373
TLine
A simple line.
Definition: TLine.h:22
TAttFill::SetFillStyle
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition: TAttFill.h:39
TPieSlice::GetRadiusOffset
Double_t GetRadiusOffset()
return the value of the offset in radial direction for this slice.
Definition: TPieSlice.cxx:68
Option_t
const char Option_t
Definition: RtypesCore.h:66
TStyle::GetTitleY
Float_t GetTitleY() const
Definition: TStyle.h:272
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TPie::SetLabels
void SetLabels(const char *[])
Set the labels for all the slices.
Definition: TPie.cxx:1343
TPie::SetCircle
void SetCircle(Double_t x=.5, Double_t y=.5, Double_t rad=.4)
Set the coordinates of the circle that describe the pie:
Definition: TPie.cxx:1209
kButton1Motion
@ kButton1Motion
Definition: Buttons.h:20
TPie::ExecuteEvent
virtual void ExecuteEvent(Int_t, Int_t, Int_t)
Execute the mouse events.
Definition: TPie.cxx:395
TMath::Cos
Double_t Cos(Double_t)
Definition: TMath.h:643
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
TString::Data
const char * Data() const
Definition: TString.h:369
kBottomLeft
@ kBottomLeft
Definition: GuiTypes.h:372
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TAttText::GetTextColor
virtual Color_t GetTextColor() const
Return the text color.
Definition: TAttText.h:34
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
TAttText::SetTextColor
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition: TAttText.h:43
TPie::SetRadius
void SetRadius(Double_t)
Set the pie chart's radius' value.
Definition: TPie.cxx:1368
r
ROOT::R::TRInterface & r
Definition: Object.C:4
TPie::TPie
TPie()
Default constructor.
Definition: TPie.cxx:63
TPie::fPieSlices
TPieSlice ** fPieSlices
[fNvals] Slice array of this pie-chart
Definition: TPie.h:43
colors
Color * colors
Definition: X3DBuffer.c:21
TStyle::GetTitleFontSize
Float_t GetTitleFontSize() const
Definition: TStyle.h:265
TPie::SetFillColors
void SetFillColors(Int_t *)
Set the fill colors for all the TPie's slices.
Definition: TPie.cxx:1287
kButton1Up
@ kButton1Up
Definition: Buttons.h:19
TLegend.h
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
TAttAxis::GetLabelSize
virtual Float_t GetLabelSize() const
Definition: TAttAxis.h:41
TPie::MakeLegend
TLegend * MakeLegend(Double_t x1=.65, Double_t y1=.65, Double_t x2=.95, Double_t y2=.95, const char *leg_header="")
This method create a legend that explains the contents of the slice for this pie-chart.
Definition: TPie.cxx:769
TArc.h
TPie::SetLabelsOffset
void SetLabelsOffset(Float_t)
Set the distance between the label end the external line of the TPie.
Definition: TPie.cxx:1352
TAxis::GetFirst
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:458
TPie::fAngle3D
Float_t fAngle3D
The angle of the pseudo-3d view.
Definition: TPie.h:46
Float_t
float Float_t
Definition: RtypesCore.h:57
width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
TPie::fAngularOffset
Double_t fAngularOffset
Offset angular offset for the first slice.
Definition: TPie.h:36
TStyle.h
TMath::PiOver2
constexpr Double_t PiOver2()
Definition: TMath.h:51
Int_t
int Int_t
Definition: RtypesCore.h:45
TPie::SetLabelFormat
void SetLabelFormat(const char *)
This method is used to customize the label format.
Definition: TPie.cxx:1315
TPie::fLabelFormat
TString fLabelFormat
Format format of the slices' label.
Definition: TPie.h:38
TObject::AppendPad
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:107
TPie::SetEntryFillColor
void SetEntryFillColor(Int_t, Int_t)
Set the color for the slice "i".
Definition: TPie.cxx:1253
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TAttText::SetTextSize
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition: TAttText.h:46
x
Double_t x[n]
Definition: legend1.C:17
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
TPave::SetX2NDC
virtual void SetX2NDC(Double_t x2)
Definition: TPave.h:79
TPie
Draw a Pie Chart,.
Definition: TPie.h:23
TLatex
To draw Mathematical Formula.
Definition: TLatex.h:18
TColor.h
TVirtualX.h
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
kBottomSide
@ kBottomSide
Definition: GuiTypes.h:373
TPie::GetLegend
TLegend * GetLegend()
If created before by Paint option or by MakeLegend method return the pointer to the legend,...
Definition: TPie.cxx:704
TAttLine::SetLineColor
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
kMove
@ kMove
Definition: GuiTypes.h:374
TAttText::GetTextSize
virtual Float_t GetTextSize() const
Return the text size.
Definition: TAttText.h:36
gCurrent_x
Double_t gCurrent_x
Definition: TPie.cxx:55
kMouseMotion
@ kMouseMotion
Definition: Buttons.h:23
TLatex::GetXsize
Double_t GetXsize()
Return size of the formula along X in pad coordinates.
Definition: TLatex.cxx:2522
TPie::SetEntryLineColor
void SetEntryLineColor(Int_t, Int_t)
Set the color for the slice's outline. "i" is the slice number.
Definition: TPie.cxx:1229
gCurrent_ang
Double_t gCurrent_ang
Definition: TPie.cxx:57
TPie::fX
Double_t fX
X coordinate of the pie centre.
Definition: TPie.h:33
TPie::GetPercentFormat
const char * GetPercentFormat()
Definition: TPie.h:77
TString
Basic string class.
Definition: TString.h:136
TPaveText::GetLine
virtual TText * GetLine(Int_t number) const
Get Pointer to line number in this pavetext.
Definition: TPaveText.cxx:275
gRadius
Double_t gRadius
Definition: TPie.cxx:45
TPie::Init
void Init(Int_t np, Double_t ao, Double_t x, Double_t y, Double_t r)
Common initialization for all constructors.
Definition: TPie.cxx:722
TPie::fHeight
Double_t fHeight
Height of the slice in pixel.
Definition: TPie.h:45
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
text
TText * text
Definition: entrylist_figure1.C:10
kBottomRight
@ kBottomRight
Definition: GuiTypes.h:372
TPie::SetEntryLineStyle
void SetEntryLineStyle(Int_t, Int_t)
Set the style for the slice's outline. "i" is the slice number.
Definition: TPie.cxx:1237
TPie::Draw
virtual void Draw(Option_t *option="l")
Draw the pie chart.
Definition: TPie.cxx:276
bool
TString::ReplaceAll
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
TStyle::GetTitleStyle
Style_t GetTitleStyle() const
Definition: TStyle.h:264
TPaveText.h
TPie::SetEntryLineWidth
void SetEntryLineWidth(Int_t, Int_t)
Set the width of the slice's outline. "i" is the slice number.
Definition: TPie.cxx:1245
id
XFontStruct * id
Definition: TGX11.cxx:109
TStyle::GetLabelOffset
Float_t GetLabelOffset(Option_t *axis="X") const
Return label offset.
Definition: TStyle.cxx:1088
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TROOT.h
gIsUptSlice
Bool_t gIsUptSlice
Definition: TPie.cxx:48
TPie::GetLabelsOffset
Float_t GetLabelsOffset()
Definition: TPie.h:74
TPaveText::Draw
virtual void Draw(Option_t *option="")
Draw this pavetext with its current attributes.
Definition: TPaveText.cxx:234
TPie::GetEntryLineWidth
Int_t GetEntryLineWidth(Int_t)
Return the line width used to outline thi "i" slice.
Definition: TPie.cxx:679
style
TCanvas * style()
Definition: style.C:1
TAttText::GetTextAngle
virtual Float_t GetTextAngle() const
Return the text angle.
Definition: TAttText.h:33
TAxis::GetLabels
THashList * GetLabels() const
Definition: TAxis.h:117
ROOT::Math::gv_detail::dist
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
gCurrent_rad
Double_t gCurrent_rad
Definition: TPie.cxx:53
TPie::SetValueFormat
void SetValueFormat(const char *)
Set the numeric format the slices' values.
Definition: TPie.cxx:1382
TPave::GetX1NDC
Double_t GetX1NDC() const
Definition: TPave.h:59
TMath::Pi
constexpr Double_t Pi()
Definition: TMath.h:37
kRotate
@ kRotate
Definition: GuiTypes.h:374
TLine::PaintLine
virtual void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Draw this line with new coordinates.
Definition: TLine.cxx:384
TStyle::GetTitleBorderSize
Width_t GetTitleBorderSize() const
Definition: TStyle.h:266
TPie::SetPercentFormat
void SetPercentFormat(const char *)
Set the numeric format for the percent value of a slice, default: %3.1f.
Definition: TPie.cxx:1360
TPie::GetLabelFormat
const char * GetLabelFormat()
Definition: TPie.h:73
TStyle::GetTitleAlign
Int_t GetTitleAlign()
Definition: TStyle.h:261
TLegend::Clear
virtual void Clear(Option_t *option="")
Clear all entries in this legend, including the header.
Definition: TLegend.cxx:390
TLatex::GetYsize
Double_t GetYsize()
Return size of the formula along Y in pad coordinates.
Definition: TLatex.cxx:2609
kTopLeft
@ kTopLeft
Definition: GuiTypes.h:372
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
SetFillColor
h1 SetFillColor(kGreen)
TPie::MakeSlices
void MakeSlices(Bool_t force=kFALSE)
Make the slices.
Definition: TPie.cxx:1407
TAttText::GetTextFont
virtual Font_t GetTextFont() const
Return the text font.
Definition: TAttText.h:35
TPie::SetEntryLabel
void SetEntryLabel(Int_t, const char *text="Slice")
Set slice number "i" label.
Definition: TPie.cxx:1220
TStyle::GetTitleFillColor
Color_t GetTitleFillColor() const
Definition: TStyle.h:262
gCurrent_phi2
Double_t gCurrent_phi2
Definition: TPie.cxx:52
TPie::DrawGhost
void DrawGhost()
This method is for internal use.
Definition: TPie.cxx:299
TStyle::GetOptTitle
Int_t GetOptTitle() const
Definition: TStyle.h:237
h
#define h(i)
Definition: RSha256.hxx:106
TPie::fFractionFormat
TString fFractionFormat
Rform numeric format for the fraction of a slice.
Definition: TPie.h:40
TAttLine::GetLineColor
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
TPieSlice.h
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TAttAxis::GetLabelColor
virtual Color_t GetLabelColor() const
Definition: TAttAxis.h:38
TString::Remove
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
TAttLine::GetLineStyle
virtual Style_t GetLineStyle() const
Return the line style.
Definition: TAttLine.h:34
TPieSlice
A slice of a piechart, see the TPie class.
Definition: TPieSlice.h:18
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:96
kCross
@ kCross
Definition: GuiTypes.h:374
gY
Double_t gY
Definition: TPie.cxx:44
TPie::fSlices
Float_t * fSlices
!Subdivisions of the slices
Definition: TPie.h:29
TLegend::AddEntry
TLegendEntry * AddEntry(const TObject *obj, const char *label="", Option_t *option="lpf")
Add a new entry to this legend.
Definition: TLegend.cxx:330
TStyle::GetTitleTextColor
Color_t GetTitleTextColor() const
Definition: TStyle.h:263
TPie::GetEntryFillColor
Int_t GetEntryFillColor(Int_t)
Return the color of the slice number "i".
Definition: TPie.cxx:647
TPieSlice::SetValue
void SetValue(Double_t)
Set the value for this slice.
Definition: TPieSlice.cxx:101
TAxis::GetLast
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:469
TPie::SavePrimitive
void SavePrimitive(std::ostream &out, Option_t *opts="")
Save primitive as a C++ statement(s) on output stream out.
Definition: TPie.cxx:1124
TStyle::GetColorPalette
Int_t GetColorPalette(Int_t i) const
Return color number i in current palette.
Definition: TStyle.cxx:1056
TPie::fNvals
Int_t fNvals
Number of elements.
Definition: TPie.h:42
TMath::PiOver4
constexpr Double_t PiOver4()
Definition: TMath.h:58
TMath::Sin
Double_t Sin(Double_t)
Definition: TMath.h:639
TPie::GetValueFormat
const char * GetValueFormat()
Definition: TPie.h:80
TVirtualPad.h
TAttFill::GetFillStyle
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition: TAttFill.h:31
y
Double_t y[n]
Definition: legend1.C:17
kButton1Locate
@ kButton1Locate
Definition: Buttons.h:22
gCurrent_phi1
Double_t gCurrent_phi1
Definition: TPie.cxx:51
TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
line
TLine * line
Definition: entrylistblock_figure1.C:235
TGeant4Unit::rad
static constexpr double rad
Definition: TGeant4SystemOfUnits.h:142
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:879
kPointer
@ kPointer
Definition: GuiTypes.h:375
gX
Double_t gX
Definition: TPie.cxx:43
TObject::kCanDelete
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:58
gCurrent_y
Double_t gCurrent_y
Definition: TPie.cxx:56
gCurrent_slice
Int_t gCurrent_slice
Definition: TPie.cxx:50
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
kHand
@ kHand
Definition: GuiTypes.h:374
TPie::GetSlice
TPieSlice * GetSlice(Int_t i)
Return the reference to the slice of index 'id'.
Definition: TPie.cxx:713
TMath::TwoPi
constexpr Double_t TwoPi()
Definition: TMath.h:44
kTopRight
@ kTopRight
Definition: GuiTypes.h:372
TPaveText::AddText
virtual TText * AddText(Double_t x1, Double_t y1, const char *label)
Add a new Text line to this pavetext at given coordinates.
Definition: TPaveText.cxx:183
TPieSlice::SetRadiusOffset
void SetRadiusOffset(Double_t)
Set the radial offset of this slice.
Definition: TPieSlice.cxx:91
TString::Index
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
kArrowKeyPress
@ kArrowKeyPress
Definition: Buttons.h:21
TStyle::GetTitleH
Float_t GetTitleH() const
Definition: TStyle.h:274
TPie::GetEntryLineColor
Int_t GetEntryLineColor(Int_t)
Return the line color used to outline thi "i" slice.
Definition: TPie.cxx:663
TAttLine::SetLineWidth
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition: TAttLine.h:43
TPie::SetEntryFillStyle
void SetEntryFillStyle(Int_t, Int_t)
Set the fill style for the "i" slice.
Definition: TPie.cxx:1261
TEllipse::PaintEllipse
virtual void PaintEllipse(Double_t x1, Double_t y1, Double_t r1, Double_t r2, Double_t phimin, Double_t phimax, Double_t theta, Option_t *option="")
Draw this ellipse with new coordinates.
Definition: TEllipse.cxx:528
TText
Base class for several text objects.
Definition: TText.h:22
kButton1Down
@ kButton1Down
Definition: Buttons.h:17
TPie::fLegend
TLegend * fLegend
!Legend for this piechart
Definition: TPie.h:30
TPie::fRadius
Double_t fRadius
Radius Pie radius.
Definition: TPie.h:35
Double_t
double Double_t
Definition: RtypesCore.h:59
TPie::SetAngularOffset
void SetAngularOffset(Double_t)
Set the global angular offset for slices in degree [0,360].
Definition: TPie.cxx:1192
TPie::fSum
Float_t fSum
!Sum for the slice values
Definition: TPie.h:28
TGeant4Unit::pi
static constexpr double pi
Definition: TGeant4SystemOfUnits.h:67
TLatex.h
TPie::SetEntryVal
void SetEntryVal(Int_t, Double_t)
Set the value of a slice.
Definition: TPie.cxx:1277
TPie::GetEntryLineStyle
Int_t GetEntryLineStyle(Int_t)
Return the style used to outline thi "i" slice.
Definition: TPie.cxx:671
TLatex::PaintLatex
virtual void PaintLatex(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text)
Main drawing function.
Definition: TLatex.cxx:2051
TAttFill::SetFillColor
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
TPie::Paint
virtual void Paint(Option_t *)
Paint a Pie chart in a canvas.
Definition: TPie.cxx:803
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TH1
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
TColor::GetColorDark
static Int_t GetColorDark(Int_t color)
Static function: Returns the dark color number corresponding to n If the TColor object does not exist...
Definition: TColor.cxx:1945
TPie::GetEntryFillStyle
Int_t GetEntryFillStyle(Int_t)
Return the style use to fill the slice number "i".
Definition: TPie.cxx:655
name
char name[80]
Definition: TGX11.cxx:110
gRadiusOffset
Double_t gRadiusOffset
Definition: TPie.cxx:46
TPie::GetEntryRadiusOffset
Double_t GetEntryRadiusOffset(Int_t)
Return the radial offset's value for the slice number "i".
Definition: TPie.cxx:687
TStyle::GetTitleFont
Style_t GetTitleFont(Option_t *axis="X") const
Return title font.
Definition: TStyle.cxx:1164
TPie::fPercentFormat
TString fPercentFormat
Pfrom numeric format for the percent of a slice.
Definition: TPie.h:41
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
gPad
#define gPad
Definition: TVirtualPad.h:287
TAttFill::GetFillColor
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
TLegend::Draw
virtual void Draw(Option_t *option="")
Draw this legend with its current attributes.
Definition: TLegend.cxx:423
TPaveText
A Pave (see TPave) with text, lines or/and boxes inside.
Definition: TPaveText.h:21
TPie::SetAngle3D
void SetAngle3D(Float_t val=30.)
Set the value of for the pseudo 3D view angle, in degree.
Definition: TPie.cxx:1179
TPie::GetEntryLabel
const char * GetEntryLabel(Int_t)
Returns the label of the entry number "i".
Definition: TPie.cxx:639
kMouseEnter
@ kMouseEnter
Definition: Buttons.h:23
TAttLine::GetLineWidth
virtual Width_t GetLineWidth() const
Return the line width.
Definition: TAttLine.h:35
TAttAxis::GetLabelFont
virtual Style_t GetLabelFont() const
Definition: TAttAxis.h:39
gAngularOffset
Double_t gAngularOffset
Definition: TPie.cxx:47
TLegend
This class displays a legend box (TPaveText) containing several legend entries.
Definition: TLegend.h:23
TPie::fY
Double_t fY
Y coordinate of the pie centre.
Definition: TPie.h:34
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TStyle::GetTitleW
Float_t GetTitleW() const
Definition: TStyle.h:273
TPave::SetName
virtual void SetName(const char *name="")
Definition: TPave.h:75
TPieSlice::SetIsActive
void SetIsActive(Bool_t is)
Definition: TPieSlice.h:37
TStyle::GetTitleX
Float_t GetTitleX() const
Definition: TStyle.h:271
Class
void Class()
Definition: Class.C:29
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1147
TPie::GetEntryVal
Double_t GetEntryVal(Int_t)
Return the value associated with the slice number "i".
Definition: TPie.cxx:695
TAttLine::SetLineStyle
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition: TAttLine.h:42
kArrowKeyRelease
@ kArrowKeyRelease
Definition: Buttons.h:21
TPie::SetEntryRadiusOffset
void SetEntryRadiusOffset(Int_t, Double_t)
Set the distance, in the direction of the radius of the slice.
Definition: TPie.cxx:1269
TPie::SetHeight
void SetHeight(Double_t val=.08)
Set the height, in pixel, for the piechart if is drawn using the pseudo-3d mode.
Definition: TPie.cxx:1299
TAttText::SetTextFont
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition: TAttText.h:45
TH1.h
TPie::DistancetoSlice
Int_t DistancetoSlice(Int_t, Int_t)
Returns the slice number at the pixel position (px,py).
Definition: TPie.cxx:190
TPie::SetFractionFormat
void SetFractionFormat(const char *)
Set numeric format in the label, is used if the label format there is the modifier frac,...
Definition: TPie.cxx:1335
TPie::fLabelsOffset
Float_t fLabelsOffset
LabelsOffset offset of label.
Definition: TPie.h:37
TMath.h
TPie::GetAngularOffset
Double_t GetAngularOffset()
Definition: TPie.h:62
gROOT
#define gROOT
Definition: TROOT.h:406
int
TPie::~TPie
~TPie()
Destructor.
Definition: TPie.cxx:156
TPie::DistancetoPrimitive
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Evaluate the distance to the chart in gPad.
Definition: TPie.cxx:170