Logo ROOT  
Reference Guide
TAttText.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Rene Brun 12/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include <iostream>
13#include "Strlen.h"
14#include "TROOT.h"
15#include "TAttText.h"
16#include "TVirtualPad.h"
17#include "TStyle.h"
18#include "TVirtualX.h"
19#include "TError.h"
20#include "TVirtualPadEditor.h"
21#include "TColor.h"
22
24
25/** \class TAttText
26\ingroup Base
27\ingroup GraphicsAtt
28
29Text Attributes class.
30
31This class is used (in general by secondary inheritance)
32by many other classes (graphics, histograms). It holds all the text attributes.
33
34## Text attributes
35Text attributes are:
36
37 - [Text Alignment](\ref ATTTEXT1)
38 - [Text Angle](\ref ATTTEXT2)
39 - [Text Color](\ref ATTTEXT3)
40 - [Text Size](\ref ATTTEXT4)
41 - [Text Font and Precision](\ref ATTTEXT5)
42 - [Font quality and speed](\ref ATTTEXT51)
43 - [How to use True Type Fonts](\ref ATTTEXT52)
44 - [List of the currently supported fonts](\ref ATTTEXT53)
45
46\anchor ATTTEXT1
47## Text Alignment
48
49The text alignment is an integer number (`align`) allowing to control
50the horizontal and vertical position of the text string with respect
51to the text position.
52The text alignment of any class inheriting from `TAttText` can
53be changed using the method `SetTextAlign` and retrieved using the
54method `GetTextAlign`.
55
56~~~ {.cpp}
57 align = 10*HorizontalAlign + VerticalAlign
58~~~
59
60For horizontal alignment the following convention applies:
61
62~~~ {.cpp}
63 1=left adjusted, 2=centered, 3=right adjusted
64~~~
65
66For vertical alignment the following convention applies:
67
68~~~ {.cpp}
69 1=bottom adjusted, 2=centered, 3=top adjusted
70~~~
71
72For example:
73
74~~~ {.cpp}
75 align = 11 = left adjusted and bottom adjusted
76 align = 32 = right adjusted and vertically centered
77~~~
78
79Begin_Macro(source)
80textalign.C
81End_Macro
82
83Mnemonic constants are available:
84
85~~~ {.cpp}
86kHAlignLeft = 10, kHAlignCenter = 20, kHAlignRight = 30,
87kVAlignBottom = 1, kVAlignCenter = 2, kVAlignTop = 3
88~~~
89
90They allow to write:
91
92~~~ {.cpp}
93object->SetTextAlign(kHAlignLeft+kVAlignTop);
94~~~
95
96\anchor ATTTEXT2
97## Text Angle
98
99Text angle in degrees.
100The text angle of any class inheriting from `TAttText` can
101be changed using the method `SetTextAngle` and retrieved using the
102method `GetTextAngle`.
103The following picture shows the text angle:
104
105Begin_Macro(source)
106textangle.C
107End_Macro
108
109\anchor ATTTEXT3
110## Text Color
111
112The text color is a color index (integer) pointing in the ROOT
113color table.
114The text color of any class inheriting from `TAttText` can
115be changed using the method `SetTextColor` and retrieved using the
116method `GetTextColor`.
117The following table shows the first 50 default colors.
118
119Begin_Macro
120{
121 TCanvas *c = new TCanvas("c","Fill Area colors",0,0,500,200);
122 c->DrawColorTable();
123 return c;
124}
125End_Macro
126
127### Color transparency
128`SetTextColorAlpha()`, allows to set a transparent color.
129In the following example the text color of the text `text`
130is set to blue with a transparency of 35%. The color `kBlue`
131itself remains fully opaque.
132
133~~~ {.cpp}
134text->SetTextColorAlpha(kBlue, 0.35);
135~~~
136
137The transparency is available on all platforms when the flag `OpenGL.CanvasPreferGL` is set to `1`
138in `$ROOTSYS/etc/system.rootrc`, or on Mac with the Cocoa backend. On the file output
139it is visible with PDF, PNG, Gif, JPEG, SVG, TeX ... but not PostScript.
140
141\anchor ATTTEXT4
142## Text Size
143
144If the text precision (see next paragraph) is smaller than 3, the text
145size (`textsize`) is a fraction of the current pad size. Therefore the
146same `textsize` value can generate text outputs with different absolute
147sizes in two different pads.
148The text size in pixels (`charheight`) is computed the following way:
149
150~~~ {.cpp}
151 pad_width = gPad->XtoPixel(gPad->GetX2());
152 pad_height = gPad->YtoPixel(gPad->GetY1());
153 if (pad_width < pad_height) charheight = textsize*pad_width;
154 else charheight = textsize*pad_height;
155~~~
156
157If the text precision is equal to 3, the text size doesn't depend on the pad's
158dimensions. A given `textsize` value always generates the same absolute
159size. The text size (`charheight`) is given in pixels:
160
161~~~ {.cpp}
162 charheight = textsize;
163~~~
164
165Note that to scale fonts to the same size as the old True Type package a
166scale factor of `0.93376068` is apply to the text size before drawing.
167
168The text size of any class inheriting from `TAttText` can
169be changed using the method `SetTextSize` and retrieved using the
170method `GetTextSize`.
171
172\anchor ATTTEXT5
173## Text Font and Precision
174
175The text font code is combination of the font number and the precision.
176~~~ {.cpp}
177 Text font code = 10*fontnumber + precision
178~~~
179Font numbers must be between 1 and 14.
180
181The precision can be:
182
183 - `precision = 0` fast hardware fonts (steps in the size)
184 - `precision = 1` scalable and rotatable hardware fonts (see below)
185 - `precision = 2` scalable and rotatable hardware fonts
186 - `precision = 3` scalable and rotatable hardware fonts. Text size
187 is given in pixels.
188
189The text font and precision of any class inheriting from `TAttText` can
190be changed using the method `SetTextFont` and retrieved using the
191method `GetTextFont`.
192
193\anchor ATTTEXT51
194### Font quality and speed
195
196When precision 0 is used, only the original non-scaled system fonts are
197used. The fonts have a minimum (4) and maximum (37) size in pixels. These
198fonts are fast and are of good quality. Their size varies with large steps
199and they cannot be rotated.
200Precision 1 and 2 fonts have a different behaviour depending if the
201True Type Fonts (TTF) are used or not. If TTF are used, you always get very good
202quality scalable and rotatable fonts. However TTF are slow.
203
204\anchor ATTTEXT52
205### How to use True Type Fonts
206
207One can activate the TTF by adding (or activating) the following line
208in the `.rootrc` file:
209
210~~~ {.cpp}
211 Unix.*.Root.UseTTFonts: true
212~~~
213
214It is possible to check the TTF are in use in a Root session
215with the command:
216
217~~~ {.cpp}
218 gEnv->Print();
219~~~
220
221If the TTF are in use the following line will appear at the beginning of the
222printout given by this command:
223
224~~~ {.cpp}
225 Unix.*.Root.UseTTFonts: true [Global]
226~~~
227
228\anchor ATTTEXT53
229### List of the currently supported fonts
230
231~~~ {.cpp}
232 Font number X11 Names Win32/TTF Names
233 1 : times-medium-i-normal "Times New Roman"
234 2 : times-bold-r-normal "Times New Roman"
235 3 : times-bold-i-normal "Times New Roman"
236 4 : helvetica-medium-r-normal "Arial"
237 5 : helvetica-medium-o-normal "Arial"
238 6 : helvetica-bold-r-normal "Arial"
239 7 : helvetica-bold-o-normal "Arial"
240 8 : courier-medium-r-normal "Courier New"
241 9 : courier-medium-o-normal "Courier New"
242 10 : courier-bold-r-normal "Courier New"
243 11 : courier-bold-o-normal "Courier New"
244 12 : symbol-medium-r-normal "Symbol"
245 13 : times-medium-r-normal "Times New Roman"
246 14 : "Wingdings"
247 15 : Symbol italic (derived from Symbol)
248~~~
249
250The following picture shows how each font looks. The number on the left
251is the "text font code". In this picture precision 2 was selected.
252
253Begin_Macro
254fonts.C
255End_Macro
256*/
257
258////////////////////////////////////////////////////////////////////////////////
259/// AttText default constructor.
260///
261/// Default text attributes are taken from the current style.
264{
265 if (!gStyle) {
266 ResetAttText();
267 return;
268 }
274}
275
276////////////////////////////////////////////////////////////////////////////////
277/// AttText normal constructor.
278///
279/// Text attributes are taken from the argument list.
281TAttText::TAttText(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize)
282{
283 fTextAlign = align;
284 fTextAngle = angle;
285 fTextColor = color;
286 fTextFont = font;
287 fTextSize = tsize;
288}
289
290////////////////////////////////////////////////////////////////////////////////
291/// AttText destructor.
294{
295}
296
297////////////////////////////////////////////////////////////////////////////////
298/// Copy this text attributes to a new TAttText.
300void TAttText::Copy(TAttText &atttext) const
301{
302 atttext.fTextAlign = fTextAlign;
303 atttext.fTextAngle = fTextAngle;
304 atttext.fTextColor = fTextColor;
305 atttext.fTextFont = fTextFont;
306 atttext.fTextSize = fTextSize;
307}
308
309////////////////////////////////////////////////////////////////////////////////
310/// Return the text in percent of the pad size.
311///
312/// If the font precision is greater than 2, the text size returned is the size in pixel
313/// converted into percent of the pad size, otherwise the size returned is the same as the
314/// size given as input parameter.
317{
318 Float_t rsize = size;
319 if (fTextFont%10 > 2 && gPad) {
320 UInt_t w = TMath::Abs(gPad->XtoAbsPixel(gPad->GetX2()) -
321 gPad->XtoAbsPixel(gPad->GetX1()));
322 UInt_t h = TMath::Abs(gPad->YtoAbsPixel(gPad->GetY2()) -
323 gPad->YtoAbsPixel(gPad->GetY1()));
324 if (w < h)
325 rsize = rsize/w;
326 else
327 rsize = rsize/h;
328 }
329 return rsize;
330}
331
332////////////////////////////////////////////////////////////////////////////////
333/// Change current text attributes if necessary.
335void TAttText::Modify()
336{
337 if (!gPad) return;
338
339 // Do we need to change font?
340 if (!gPad->IsBatch()) {
341 gVirtualX->SetTextAngle(fTextAngle);
342 Float_t wh = (Float_t)gPad->XtoPixel(gPad->GetX2());
343 Float_t hh = (Float_t)gPad->YtoPixel(gPad->GetY1());
344 Float_t tsize;
345 if (wh < hh) tsize = fTextSize*wh;
346 else tsize = fTextSize*hh;
347 if (fTextFont%10 > 2) tsize = fTextSize;
348
349 if (gVirtualX->GetTextFont() != fTextFont) {
350 gVirtualX->SetTextFont(fTextFont);
351 gVirtualX->SetTextSize(tsize);
352 }
353 if (gVirtualX->GetTextSize() != tsize)
354 gVirtualX->SetTextSize(tsize);
355 gVirtualX->SetTextAlign(fTextAlign);
356 gVirtualX->SetTextColor(fTextColor);
357 }
359}
360
361////////////////////////////////////////////////////////////////////////////////
362/// Reset this text attributes to default values.
365{
366 fTextAlign = 11;
367 fTextAngle = 0;
368 fTextColor = 1;
369 fTextFont = 62;
370 fTextSize = 0.05;
371}
372
373////////////////////////////////////////////////////////////////////////////////
374/// Save text attributes as C++ statement(s) on output stream out.
376void TAttText::SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef,
377 Float_t angdef, Int_t coldef, Int_t fondef,
378 Float_t sizdef)
379{
380 if (fTextAlign != alidef) {
381 out<<" "<<name<<"->SetTextAlign("<<fTextAlign<<");"<<std::endl;
382 }
383 if (fTextColor != coldef) {
384 if (fTextColor > 228) {
386 out<<" "<<name<<"->SetTextColor(ci);" << std::endl;
387 } else
388 out<<" "<<name<<"->SetTextColor("<<fTextColor<<");"<<std::endl;
389 }
390 if (fTextFont != fondef) {
391 out<<" "<<name<<"->SetTextFont("<<fTextFont<<");"<<std::endl;
392 }
393 if (fTextSize != sizdef) {
394 out<<" "<<name<<"->SetTextSize("<<fTextSize<<");"<<std::endl;
395 }
396 if (fTextAngle != angdef) {
397 out<<" "<<name<<"->SetTextAngle("<<fTextAngle<<");"<<std::endl;
398 }
399}
400
401////////////////////////////////////////////////////////////////////////////////
402/// Invoke the DialogCanvas Text attributes.
405{
408}
409
410////////////////////////////////////////////////////////////////////////////////
411/// Set a transparent marker color. talpha defines the percentage of
412/// the color opacity from 0. (fully transparent) to 1. (fully opaque).
415{
416 fTextColor = TColor::GetColorTransparent(tcolor, talpha);
417}
418
419////////////////////////////////////////////////////////////////////////////////
420/// Set the text size in pixels.
421///
422/// If the font precision is greater than 2, the text size is set to npixels,
423/// otherwise the text size is computed as a percent of the pad size.
426{
427 if (fTextFont%10 > 2) {
428 fTextSize = Float_t(npixels);
429 } else {
430 TVirtualPad *pad = gROOT->GetSelectedPad();
431 if (!pad) return;
432 Float_t dy = pad->AbsPixeltoY(0) - pad->AbsPixeltoY(npixels);
433 fTextSize = dy/(pad->GetY2() - pad->GetY1());
434 }
435}
#define h(i)
Definition: RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
int Int_t
Definition: RtypesCore.h:45
unsigned int UInt_t
Definition: RtypesCore.h:46
short Color_t
Definition: RtypesCore.h:92
short Style_t
Definition: RtypesCore.h:89
float Float_t
Definition: RtypesCore.h:57
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:364
char name[80]
Definition: TGX11.cxx:110
#define gROOT
Definition: TROOT.h:404
R__EXTERN TStyle * gStyle
Definition: TStyle.h:413
#define gPad
Definition: TVirtualPad.h:288
#define gVirtualX
Definition: TVirtualX.h:338
Text Attributes class.
Definition: TAttText.h:18
virtual Float_t GetTextSize() const
Return the text size.
Definition: TAttText.h:36
virtual void Modify()
Change current text attributes if necessary.
Definition: TAttText.cxx:334
virtual Short_t GetTextAlign() const
Return the text alignment.
Definition: TAttText.h:32
virtual Font_t GetTextFont() const
Return the text font.
Definition: TAttText.h:35
Color_t fTextColor
Text color.
Definition: TAttText.h:24
Float_t fTextAngle
Text angle.
Definition: TAttText.h:21
TAttText()
AttText default constructor.
Definition: TAttText.cxx:262
virtual void SetTextColorAlpha(Color_t tcolor, Float_t talpha)
Set a transparent marker color.
Definition: TAttText.cxx:413
virtual Color_t GetTextColor() const
Return the text color.
Definition: TAttText.h:34
virtual ~TAttText()
AttText destructor.
Definition: TAttText.cxx:292
virtual Float_t GetTextAngle() const
Return the text angle.
Definition: TAttText.h:33
virtual void SetTextAttributes()
Invoke the DialogCanvas Text attributes.
Definition: TAttText.cxx:403
virtual void SetTextSizePixels(Int_t npixels)
Set the text size in pixel.
Definition: TAttText.cxx:424
Font_t fTextFont
Text font.
Definition: TAttText.h:25
virtual void SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1)
Save text attributes as C++ statement(s) on output stream out.
Definition: TAttText.cxx:375
virtual Float_t GetTextSizePercent(Float_t size)
Return the text in percent of the pad size.
Definition: TAttText.cxx:315
Short_t fTextAlign
Text alignment.
Definition: TAttText.h:23
void Copy(TAttText &atttext) const
Copy this text attributes to a new TAttText.
Definition: TAttText.cxx:299
virtual void ResetAttText(Option_t *toption="")
Reset this text attributes to default values.
Definition: TAttText.cxx:363
Float_t fTextSize
Text size.
Definition: TAttText.h:22
static void SaveColor(std::ostream &out, Int_t ci)
Save a color with index > 228 as a C++ statement(s) on output stream out.
Definition: TColor.cxx:2174
static Int_t GetColorTransparent(Int_t color, Float_t a)
Static function: Returns the transparent color number corresponding to n.
Definition: TColor.cxx:2032
static void UpdateTextAttributes(Int_t align, Float_t angle, Int_t col, Int_t font, Float_t tsize)
Update text attributes via the pad editor.
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:51
virtual Double_t GetY1() const =0
virtual Double_t AbsPixeltoY(Int_t py)=0
virtual Double_t GetY2() const =0
Short_t Abs(Short_t d)
Definition: TMathBase.h:120