Logo ROOT   6.14/05
Reference Guide
TColorWheel.cxx
Go to the documentation of this file.
1 // @(#)root/gpad:$Id$
2 // Author: Rene Brun 10/03/2007
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2007, 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 "Riostream.h"
13 #include "TROOT.h"
14 #include "TColorWheel.h"
15 #include "TCanvas.h"
16 #include "TText.h"
17 #include "TGraph.h"
18 #include "TArc.h"
19 #include "TLine.h"
20 #include "TColor.h"
21 #include "TMath.h"
22 
24 
25 /** \class TColorWheel
26 \ingroup gpad
27 
28 Draw the ROOT Color Wheel.
29 
30 The wheel contains the recommended 216 colors to be used in web applications.
31 The colors in the Color Wheel are created by TColor::CreateColorWheel.
32 
33 Using this color set for your text, background or graphics will give your
34 application a consistent appearance across different platforms and browsers.
35 
36 Colors are grouped by hue, the aspect most important in human perception.
37 Touching color chips have the same hue, but with different brightness and vividness.
38 
39 Colors of slightly different hues __clash__. If you intend to display
40 colors of the same hue together, you should pick them from the same group.
41 
42 Each color chip is identified by a mnemonic (e.g. kYellow) and a number.
43 The keywords, kRed, kBlue, kYellow, kPink, etc are defined in the header file __Rtypes.h__
44 that is included in all ROOT other header files. We strongly recommend to use these keywords
45 in your code instead of hardcoded color numbers, e.g.:
46 ~~~ {.cpp}
47  myObject.SetFillColor(kRed);
48  myObject.SetFillColor(kYellow-10);
49  myLine.SetLineColor(kMagenta+2);
50 ~~~
51 
52 Begin_Macro
53 {
54  TColorWheel *w = new TColorWheel();
55  cw = new TCanvas("cw","cw",0,0,400,400);
56  w->SetCanvas(cw);
57  w->Draw();
58 }
59 End_Macro
60 */
61 
62 ////////////////////////////////////////////////////////////////////////////////
63 /// constructor
64 
65 TColorWheel::TColorWheel() :TNamed("wheel","ROOT Color Wheel")
66 {
67  fCanvas = 0;
68  fArc = 0;
69  fLine = 0;
70  fText = 0;
71  fGraph = 0;
72  fRmin = 2.1;
73  fRmax = 9.5;
74  fR0 = 4;
75  fDr = 1;
76  fRgray = 1.8;
77  fX[ 0] = fR0-0.2*fDr; fY[ 0] = 0;
78  fX[ 1] = fR0+fDr; fY[ 1] = 0.75*fDr;
79  fX[ 2] = fR0+fDr; fY[ 2] = -0.75*fDr;
80  fX[ 3] = fR0+2.2*fDr; fY[ 3] = 1.5*fDr;
81  fX[ 4] = fR0+2.2*fDr; fY[ 4] = 0;
82  fX[ 5] = fR0+2.2*fDr; fY[ 5] = -1.5*fDr;
83  fX[ 6] = fR0+3.4*fDr; fY[ 6] = 2.2*fDr;
84  fX[ 7] = fR0+3.4*fDr; fY[ 7] = 0.7*fDr;
85  fX[ 8] = fR0+3.4*fDr; fY[ 8] = -0.7*fDr;
86  fX[ 9] = fR0+3.4*fDr; fY[ 9] = -2.2*fDr;
87  fX[10] = fR0+4.6*fDr; fY[10] = 2.8*fDr;
88  fX[11] = fR0+4.6*fDr; fY[11] = 1.4*fDr;
89  fX[12] = fR0+4.6*fDr; fY[12] = 0;
90  fX[13] = fR0+4.6*fDr; fY[13] = -1.4*fDr;
91  fX[14] = fR0+4.6*fDr; fY[14] = -2.8*fDr;
92 
94 }
95 
96 ////////////////////////////////////////////////////////////////////////////////
97 /// destructor
98 
100 {
101  //delete fCanvas; please don't do that
102  delete fArc;
103  delete fLine;
104  delete fText;
105  delete fGraph;
106 }
107 
108 ////////////////////////////////////////////////////////////////////////////////
109 /// always return the color wheel
110 
112 {
113  if (px+py < 0) return 1;
114  return 0;
115 }
116 
117 ////////////////////////////////////////////////////////////////////////////////
118 /// Paint the color wheel
119 
121 {
122  if (!fCanvas) {
123  fCanvas = new TCanvas("wheel","ROOT Color Wheel",10,10,400,400);
125  }
126  fCanvas->Range(-10.5,-10.5,10.5,10.5);
128  fCanvas->SetFillColor(TColor::GetColor(243,241,174));
129  AppendPad(option);
130 }
131 
132 ////////////////////////////////////////////////////////////////////////////////
133 /// Return the color number pointed by the mouse
134 
136 {
137  Double_t x = fCanvas->AbsPixeltoX(px);
138  Double_t y = fCanvas->AbsPixeltoY(py);
139  Int_t n = 0;
140 
141  n = InGray(x,y); if (n >= 0) return n;
142  n = InCircles (x,y,kMagenta, 0); if (n >= 0) return n;
143  n = InRectangles(x,y,kPink, 30); if (n >= 0) return n;
144  n = InCircles (x,y,kRed, 60); if (n >= 0) return n;
145  n = InRectangles(x,y,kOrange, 90); if (n >= 0) return n;
146  n = InCircles (x,y,kYellow,120); if (n >= 0) return n;
147  n = InRectangles(x,y,kSpring,150); if (n >= 0) return n;
148  n = InCircles (x,y,kGreen, 180); if (n >= 0) return n;
149  n = InRectangles(x,y,kTeal, 210); if (n >= 0) return n;
150  n = InCircles (x,y,kCyan, 240); if (n >= 0) return n;
151  n = InRectangles(x,y,kAzure, 270); if (n >= 0) return n;
152  n = InCircles (x,y,kBlue, 300); if (n >= 0) return n;
153  n = InRectangles(x,y,kViolet,330); if (n >= 0) return n;
154  return -1;
155 }
156 
157 ////////////////////////////////////////////////////////////////////////////////
158 /// Return the color number pointed by the mouse
159 
161 {
162  static char info[50];
163  info[0] = 0;
164 
165  Int_t n = GetColor(px,py);
166  if (n < 0) return info;
167  TColor *color = gROOT->GetColor(n);
168  if (!color) return info;
169  Int_t r = (Int_t)(255.01*color->GetRed());
170  Int_t g = (Int_t)(255.01*color->GetGreen());
171  Int_t b = (Int_t)(255.01*color->GetBlue());
172  snprintf(info,50,"col %d, %s, r=%3d, g=%3d, b=%3d",n,color->GetName(),r,g,b);
173  return info;
174 }
175 
176 ////////////////////////////////////////////////////////////////////////////////
177 /// Return the color number when the mouse point to a circle
178 
180 {
181  Double_t ang = angle*TMath::DegToRad();
182  Double_t u,v;
183  Rotate(x,y,u,v,ang);
184  Double_t r2 = 0.7*0.7*fDr*fDr;
185  for (Int_t i=0;i<15;i++) {
186  Double_t dx = u-fX[i];
187  Double_t dy = v-fY[i];
188  if (dx*dx+dy*dy < r2) return coffset+i-10;
189  }
190  return -1;
191 }
192 
193 ////////////////////////////////////////////////////////////////////////////////
194 /// Return the color number when the mouse point to the gray circle
195 
197 {
198  if (x*x+y*y > fRgray*fRgray) return -1;
200  if (ang < 0) ang += 360;
201  if (ang < 60) return kWhite;
202  if (ang < 120) return kGray;
203  if (ang < 180) return kGray+1;
204  if (ang < 240) return kGray+2;
205  if (ang < 300) return kGray+3;
206  return kBlack;
207 }
208 
209 ////////////////////////////////////////////////////////////////////////////////
210 /// Return the color number when the mouse point to a rectangle
211 
213 {
214  Double_t ang = angle*TMath::DegToRad();
215  Double_t u,v;
216  Rotate(x,y,u,v,ang);
217  if (TMath::Abs(v) > 1) return -1;
218  if (u < fRmin || u > fRmax) return -1;
219  Int_t div = (Int_t)(10*(u-fRmin)/(fRmax-fRmin));
220  if (v > 0) return coffset + div+1;
221  return coffset+div-9;
222 }
223 
224 ////////////////////////////////////////////////////////////////////////////////
225 /// Paint the color wheel
226 
227 void TColorWheel::Paint(Option_t * /*option*/)
228 {
229  if (!fArc) {
230  fArc = new TArc;
231  fLine = new TLine;
232  fText = new TText();
233  fGraph = new TGraph();
234  }
235  PaintGray();
236  PaintCircles (kMagenta, 0);
237  PaintRectangles(kPink, 30);
238  PaintCircles (kRed, 60);
240  PaintCircles (kYellow,120);
242  PaintCircles (kGreen, 180);
243  PaintRectangles(kTeal, 210);
244  PaintCircles (kCyan, 240);
245  PaintRectangles(kAzure, 270);
246  PaintCircles (kBlue, 300);
248 
249  fText->SetTextFont(72);
251  fText->SetTextAlign(11);
252  fText->SetTextSize(0.03);
253  fText->SetTextAngle(0);
254  fText->PaintText(-10.2,-10.2,"ROOT Color Wheel");
255 }
256 
257 ////////////////////////////////////////////////////////////////////////////////
258 /// Draw one color of type circle
259 
261 {
262  Double_t u,v;
263  Rotate(x,y,u,v,ang);
264  Int_t colorn = coffset+n;
265  TColor *color = gROOT->GetColor(colorn);
266  if (!color) return;
267  fArc->SetFillColor(colorn);
268  fArc->SetLineColor(14);
269  Double_t r = 0.7*fDr;
270  fArc->PaintEllipse(u,v,r,r,0,360,0);
271  fText->SetTextSize(0.03);
272  fText->SetTextAlign(22);
273  if (255*color->GetLight() <150 && n != 0) fText->SetTextColor(0);
274  if (n>0) fText->PaintText(u,v,Form("+%d",n));
275  else fText->PaintText(u,v,Form("%d", n));
276 }
277 
278 ////////////////////////////////////////////////////////////////////////////////
279 /// Draw all colors of type circle
280 
281 void TColorWheel::PaintCircles(Int_t coffset, Double_t angle) const
282 {
283  Double_t ang = TMath::DegToRad()*angle;
284  Double_t u,v,u0,v0;
285  Rotate(fR0+4.6*fDr,2.8*fDr,u0,v0,ang);
286  Rotate(fR0+5.8*fDr,2.1*fDr,u,v,ang);
287  fLine->PaintLine(u,v,u0,v0);
288  fText->SetTextAlign(22);
289  fText->SetTextFont(72);
290  fText->SetTextColor(1);
291  fText->SetTextSize(0.03);
292  Double_t tangle = angle-90;
293  if (angle == 240) tangle = -30;
294  if (angle == 300) tangle = 30;
295  TColor *col = gROOT->GetColor(coffset);
296  if (!col) return;
297  fText->SetTextAngle(tangle);
298  fText->PaintText(u,v,col->GetName());
299 
300  for (Int_t i=0;i<15;i++) {
301  PaintCircle(coffset,i-10, fX[i], fY[i], ang);
302  }
303 }
304 
305 ////////////////////////////////////////////////////////////////////////////////
306 /// Draw all colors of type rectangle
307 
308 void TColorWheel::PaintRectangles(Int_t coffset, Double_t angle) const
309 {
310  Double_t ang = TMath::DegToRad()*angle;
311  Double_t rmin = fRmin, rmax=fRmax;
312  Double_t dr = (rmax-rmin)/10;
313  Double_t dy = -1.0;
314 
315  Double_t u,v,u0,v0;
316  Rotate(rmax+0.62*dr,0,u,v,ang);
317  Rotate(rmax-dr,0.9*dy,u0,v0,ang);
318  fLine->PaintLine(u,v,u0,v0);
319  fText->SetTextAlign(22);
320  fText->SetTextFont(72);
321  fText->SetTextColor(1);
322  fText->SetTextSize(0.03);
323  Double_t tangle = angle+90;
324  if (angle == 30) tangle = -60;
325  if (angle == 90) tangle = 0;
326  if (angle == 150) tangle = 60;
327  if (angle == 210) tangle = -60;
328  if (angle == 270) tangle = 0;
329  fText->SetTextAngle(tangle);
330  TColor *color = gROOT->GetColor(coffset);
331  if (!color) return;
332  fText->PaintText(u,v,color->GetName());
333 
334  Double_t x[5],y[5];
335  Int_t n=-10;
336  for (Int_t j=0;j<2;j++) {
337  for (Int_t i=0;i<10;i++) {
338  n++;
339  Int_t colorn = coffset +n;
340  color = gROOT->GetColor(colorn);
341  Rotate(rmin+i*dr, 0,x[0],y[0],ang);
342  Rotate(rmin+i*dr, dy,x[1],y[1],ang);
343  Rotate(rmin+i*dr+dr,dy,x[2],y[2],ang);
344  Rotate(rmin+i*dr+dr, 0,x[3],y[3],ang);
345  fGraph->SetFillColor(colorn);
346  fGraph->PaintGraph(4,x,y,"f");
347  Rotate(rmin+i*dr+0.5*dr,0.5*dy,x[0],y[0],ang);
348  fText->SetTextSize(0.03);
349  fText->SetTextAlign(22);
350  if (color) {
351  if (255*color->GetLight() <110) fText->SetTextColor(0);
352  }
353  Double_t tang = angle-90;
354  if (angle > 180) tang -=180;
355  fText->SetTextAngle(tang);
356  if (n > 0) fText->PaintText(x[0],y[0],Form("+%d",n));
357  else fText->PaintText(x[0],y[0],Form("%d",n));
358  }
359  dy=1;
360  }
361 
362  Rotate(rmin,-dy,x[0],y[0],ang);
363  Rotate(rmax,-dy,x[1],y[1],ang);
364  Rotate(rmax, dy,x[2],y[2],ang);
365  Rotate(rmin, dy,x[3],y[3],ang);
366  Rotate(rmin,-dy,x[4],y[4],ang);
367  fGraph->SetLineColor(1);
368  fGraph->SetLineWidth(1);
369  fGraph->PaintGraph(5,x,y,"l");
370  fLine->SetLineWidth(1);
371  Rotate(rmin+3*dr,-dy,x[0],y[0],ang);
372  Rotate(rmin+3*dr, dy,x[1],y[1],ang);
373  fLine->PaintLine(x[0],y[0],x[1],y[1]);
374  Rotate(rmin+6*dr,-dy,x[0],y[0],ang);
375  Rotate(rmin+6*dr, dy,x[1],y[1],ang);
376  fLine->PaintLine(x[0],y[0],x[1],y[1]);
377  Rotate(rmin+9*dr,-dy,x[0],y[0],ang);
378  Rotate(rmin+9*dr, dy,x[1],y[1],ang);
379  fLine->PaintLine(x[0],y[0],x[1],y[1]);
380  Rotate(rmin+7*dr,-dy,x[0],y[0],ang);
381  Rotate(rmin+7*dr, dy,x[1],y[1],ang);
382  fLine->PaintLine(x[0],y[0],x[1],y[1]);
383  Rotate(rmin+6*dr,0,x[0],y[0],ang);
384  Rotate(rmax, 0,x[1],y[1],ang);
385  fLine->PaintLine(x[0],y[0],x[1],y[1]);
386 }
387 
388 ////////////////////////////////////////////////////////////////////////////////
389 /// Draw the gray colors + white + black
390 
392 {
393  Double_t r = fRgray;
395  fArc->PaintEllipse(0,0,r,r,0,60,0);
397  fArc->PaintEllipse(0,0,r,r,60,120,0);
398  fArc->SetFillColor(kGray+1);
399  fArc->PaintEllipse(0,0,r,r,120,180,0);
400  fArc->SetFillColor(kGray+2);
401  fArc->PaintEllipse(0,0,r,r,180,240,0);
402  fArc->SetFillColor(kGray+3);
403  fArc->PaintEllipse(0,0,r,r,240,300,0);
405  fArc->PaintEllipse(0,0,r,r,300,360,0);
406 
407  fText->SetTextAlign(22);
408  fText->SetTextFont(62);
409  fText->SetTextColor(1);
410  fText->SetTextSize(0.02);
411  fText->SetTextAngle(40);
412  fText->PaintText(0.5*r,0.3*r,"kWhite");
413  fText->SetTextAngle(0);
414  fText->PaintText(0,0.8*r,"kGray");
415  fText->SetTextColor(10);
416  fText->SetTextFont(72);
417  fText->SetTextSize(0.03);
418  fText->PaintText(-0.6*r, 0.3*r,"+1");
419  fText->PaintText(-0.6*r,-0.3*r,"+2");
420  fText->PaintText(0,-0.6*r,"+3");
421  fText->SetTextAngle(-40);
422  fText->SetTextSize(0.02);
423  fText->SetTextFont(62);
424  fText->PaintText(0.5*r,-0.35*r,"kBlack");
425 }
426 
427 ////////////////////////////////////////////////////////////////////////////////
428 /// Rotate point x,y with an angle=ang
429 
431 {
432  u = x*TMath::Cos(ang) + y*TMath::Sin(ang);
433  v = x*TMath::Sin(ang) - y*TMath::Cos(ang);
434 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition: TAttLine.h:43
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:526
Float_t GetRed() const
Definition: TColor.h:56
virtual void ToggleEventStatus()
Toggle event statusbar.
Definition: TCanvas.cxx:2190
void PaintGraph(Int_t npoints, const Double_t *x, const Double_t *y, Option_t *chopt)
Draw the (x,y) as a graph.
Definition: TGraph.cxx:1968
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Return the color number pointed by the mouse.
const char Option_t
Definition: RtypesCore.h:62
Definition: Rtypes.h:59
#define g(i)
Definition: RSha256.hxx:105
TLine * fLine
! pointer to utility line
Definition: TColorWheel.h:36
Definition: Rtypes.h:58
virtual void SetBorderMode(Short_t bordermode)
Definition: TPad.h:317
Double_t fY[15]
Y coordinates of the center of circles.
Definition: TColorWheel.h:33
Definition: Rtypes.h:58
Definition: Rtypes.h:60
void PaintGray() const
Draw the gray colors + white + black.
#define gROOT
Definition: TROOT.h:410
Float_t GetLight() const
Definition: TColor.h:60
virtual ~TColorWheel()
destructor
Definition: TColorWheel.cxx:99
int Int_t
Definition: RtypesCore.h:41
Int_t InGray(Double_t x, Double_t y) const
Return the color number when the mouse point to the gray circle.
Definition: Rtypes.h:59
Definition: Rtypes.h:59
Double_t fRgray
Maximum radius of gray circle.
Definition: TColorWheel.h:31
Float_t GetBlue() const
Definition: TColor.h:58
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
if object in a list can be deleted
Definition: TObject.h:58
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:105
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition: TAttText.h:45
Double_t x[n]
Definition: legend1.C:17
void PaintCircle(Int_t coffset, Int_t n, Double_t x, Double_t y, Double_t ang) const
Draw one color of type circle.
virtual void Draw(Option_t *option="")
Paint the color wheel.
Definition: Rtypes.h:60
Float_t GetGreen() const
Definition: TColor.h:57
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
constexpr Double_t DegToRad()
Conversion from degree to radian: .
Definition: TMath.h:82
Int_t InRectangles(Double_t x, Double_t y, Int_t coffset, Double_t angle) const
Return the color number when the mouse point to a rectangle.
Base class for several text objects.
Definition: TText.h:23
Double_t ATan2(Double_t, Double_t)
Definition: TMath.h:678
TCanvas * fCanvas
! Canvas used to draw the Color Wheel
Definition: TColorWheel.h:34
void Rotate(Double_t x, Double_t y, Double_t &u, Double_t &v, Double_t ang) const
Rotate point x,y with an angle=ang.
Definition: Rtypes.h:60
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition: TAttText.h:41
Definition: Rtypes.h:58
virtual void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Draw this line with new coordinates.
Definition: TLine.cxx:380
Create an Arc.
Definition: TArc.h:28
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
Int_t InCircles(Double_t x, Double_t y, Int_t coffset, Double_t angle) const
Return the color number when the mouse point to a circle.
ROOT::R::TRInterface & r
Definition: Object.C:4
SVector< double, 2 > v
Definition: Dict.h:5
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
Definition: Rtypes.h:60
void PaintRectangles(Int_t coffset, Double_t angle) const
Draw all colors of type rectangle.
void PaintCircles(Int_t coffset, Double_t angle) const
Draw all colors of type circle.
virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Set world coordinate system for the pad.
Definition: TPad.cxx:5121
virtual void Paint(Option_t *option="")
Paint the color wheel.
virtual void SetTextAngle(Float_t tangle=0)
Set the text angle.
Definition: TAttText.h:42
Double_t fRmin
Minimum radius for rectangles.
Definition: TColorWheel.h:27
char * Form(const char *fmt,...)
A simple line.
Definition: TLine.h:23
static Int_t GetColor(const char *hexcolor)
Static method returning color number for color specified by hex color string of form: "#rrggbb"...
Definition: TColor.cxx:1758
virtual Int_t GetColor(Int_t px, Int_t py) const
Return the color number pointed by the mouse.
Double_t Cos(Double_t)
Definition: TMath.h:640
Double_t fRmax
Maximum radius for rectangles.
Definition: TColorWheel.h:28
The Canvas class.
Definition: TCanvas.h:31
#define ClassImp(name)
Definition: Rtypes.h:359
double Double_t
Definition: RtypesCore.h:55
Double_t y[n]
Definition: legend1.C:17
The color creation and management class.
Definition: TColor.h:19
Definition: Rtypes.h:59
Double_t fR0
Minimum radius for circles.
Definition: TColorWheel.h:29
constexpr Double_t RadToDeg()
Conversion from radian to degree: .
Definition: TMath.h:74
A Graph is a graphics object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
Double_t Sin(Double_t)
Definition: TMath.h:636
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
always return the color wheel
Definition: Rtypes.h:60
TGraph * fGraph
! pointer to utility graph
Definition: TColorWheel.h:38
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define snprintf
Definition: civetweb.c:1351
Double_t AbsPixeltoX(Int_t px)
Definition: TPad.h:167
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition: TAttText.h:43
Definition: Rtypes.h:59
Double_t fDr
Circles radius.
Definition: TColorWheel.h:30
TArc * fArc
! pointer to utility arc
Definition: TColorWheel.h:35
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition: TAttText.h:46
Double_t AbsPixeltoY(Int_t py)
Definition: TPad.h:168
virtual void PaintText(Double_t x, Double_t y, const char *text)
Draw this text with new coordinates.
Definition: TText.cxx:745
const Int_t n
Definition: legend1.C:16
Draw the ROOT Color Wheel.
Definition: TColorWheel.h:24
Double_t fX[15]
X coordinates of the center of circles.
Definition: TColorWheel.h:32
Definition: Rtypes.h:60
TColorWheel()
constructor
Definition: TColorWheel.cxx:65
TText * fText
! pointer to utility text
Definition: TColorWheel.h:37