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