Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 X11 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.
203These days TTF fonts are rendered fast enough and can be used in all cases.
204
205\anchor ATTTEXT52
206### How to use True Type Fonts
207
208TTF fonts are used by default. They can be deactivated via the following line
209in the `.rootrc` file:
210
211~~~ {.cpp}
212 Unix.*.Root.UseTTFonts: false
213~~~
214
215\anchor ATTTEXT53
216### List of the currently supported fonts
217
218~~~ {.cpp}
219 Font number TTF Names PostScript/PDF Names
220 1 : "Free Serif Italic" "Times-Italic"
221 2 : "Free Serif Bold" "Times-Bold"
222 3 : "Free Serif Bold Italic" "Times-BoldItalic"
223 4 : "Free Sans" "Helvetica"
224 5 : "Free Sans Oblique" "Helvetica-Oblique"
225 6 : "Free Sans Bold" "Helvetica-Bold"
226 7 : "Free Sans Bold Oblique" "Helvetica-BoldOblique"
227 8 : "Free Mono" "Courier"
228 9 : "Free Mono Oblique" "Courier-Oblique"
229 10 : "Free Mono Bold" "Courier-Bold"
230 11 : "Free Mono Bold Oblique" "Courier-BoldOblique"
231 12 : "Symbol" "Symbol"
232 13 : "Free Serif" "Times-Roman"
233 14 : "Wingdings" "ZapfDingbats"
234~~~
235
236The PostScript and PDF backends use the original PostScript-defined 13 fonts' styles
237forming four type families (Courier, Helvetica, Times, Symbol) as listed in the
238"Core Font Set" section of [this page](https://en.wikipedia.org/wiki/PostScript_fonts).
239These fonts are always available and do not need to be loaded in the PS or PDF files
240allowing to keep the files' sizes small.
241
242On screen, text is rendered using free TTF fonts similar to the PDF ones. The corresponding
243font files are coming with the ROOT distribution in `$ROOTSYS/fonts/Free*`.
244
245Begin_Macro
246fonts.C
247End_Macro
248*/
249
250////////////////////////////////////////////////////////////////////////////////
251/// AttText default constructor.
252///
253/// Default text attributes are taken from the current style.
256{
257 if (!gStyle) {
258 ResetAttText();
259 return;
260 }
266}
267
268////////////////////////////////////////////////////////////////////////////////
269/// AttText normal constructor.
270///
271/// Text attributes are taken from the argument list.
273TAttText::TAttText(Int_t align, Float_t angle, Color_t color, Style_t font, Float_t tsize)
274{
275 fTextAlign = align;
277 fTextColor = color;
278 fTextFont = font;
279 fTextSize = tsize;
280}
281
282////////////////////////////////////////////////////////////////////////////////
283/// AttText destructor.
286{
287}
288
289////////////////////////////////////////////////////////////////////////////////
290/// Copy this text attributes to a new TAttText.
292void TAttText::Copy(TAttText &atttext) const
293{
294 atttext.fTextAlign = fTextAlign;
295 atttext.fTextAngle = fTextAngle;
296 atttext.fTextColor = fTextColor;
297 atttext.fTextFont = fTextFont;
298 atttext.fTextSize = fTextSize;
299}
300
301////////////////////////////////////////////////////////////////////////////////
302/// Return the text in percent of the pad size.
303///
304/// If the font precision is greater than 2, the text size returned is the size in pixel
305/// converted into percent of the pad size, otherwise the size returned is the same as the
306/// size given as input parameter.
309{
310 Float_t rsize = size;
311 if (fTextFont%10 > 2 && gPad) {
312 UInt_t w = TMath::Abs(gPad->XtoAbsPixel(gPad->GetX2()) -
313 gPad->XtoAbsPixel(gPad->GetX1()));
314 UInt_t h = TMath::Abs(gPad->YtoAbsPixel(gPad->GetY2()) -
315 gPad->YtoAbsPixel(gPad->GetY1()));
316 if (w < h)
317 rsize = rsize/w;
318 else
319 rsize = rsize/h;
320 }
321 return rsize;
322}
323
324////////////////////////////////////////////////////////////////////////////////
325/// Change current text attributes if necessary.
327void TAttText::Modify()
328{
329 if (!gPad) return;
330
331 // Do we need to change font?
332 if (!gPad->IsBatch()) {
333 gVirtualX->SetTextAngle(fTextAngle);
334 Float_t tsize;
335 if (fTextFont%10 > 2) {
336 tsize = fTextSize;
337 } else {
338 Float_t wh = (Float_t)gPad->XtoPixel(gPad->GetX2());
339 Float_t hh = (Float_t)gPad->YtoPixel(gPad->GetY1());
340 if (wh < hh) tsize = fTextSize*wh;
341 else tsize = fTextSize*hh;
342 }
343
344 if (gVirtualX->GetTextFont() != fTextFont) {
345 gVirtualX->SetTextFont(fTextFont);
346 gVirtualX->SetTextSize(tsize);
347 } else if (gVirtualX->GetTextSize() != tsize) {
348 gVirtualX->SetTextSize(tsize);
349 }
350 gVirtualX->SetTextAlign(fTextAlign);
351 gVirtualX->SetTextColor(fTextColor);
352 }
354}
355
356////////////////////////////////////////////////////////////////////////////////
357/// Reset this text attributes to default values.
360{
361 fTextAlign = 11;
362 fTextAngle = 0;
363 fTextColor = 1;
364 fTextFont = 62;
365 fTextSize = 0.05;
366}
367
368////////////////////////////////////////////////////////////////////////////////
369/// Save text attributes as C++ statement(s) on output stream out.
371void TAttText::SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef,
372 Float_t angdef, Int_t coldef, Int_t fondef,
373 Float_t sizdef)
374{
375 if (fTextAlign != alidef) {
376 out<<" "<<name<<"->SetTextAlign("<<fTextAlign<<");"<<std::endl;
377 }
378 if (fTextColor != coldef) {
380 out<<" "<<name<<"->SetTextColor(ci);" << std::endl;
381 else
382 out<<" "<<name<<"->SetTextColor("<<fTextColor<<");"<<std::endl;
383 }
384 if (fTextFont != fondef) {
385 out<<" "<<name<<"->SetTextFont("<<fTextFont<<");"<<std::endl;
386 }
387 if (fTextSize != sizdef) {
388 out<<" "<<name<<"->SetTextSize("<<fTextSize<<");"<<std::endl;
389 }
390 if (fTextAngle != angdef) {
391 out<<" "<<name<<"->SetTextAngle("<<fTextAngle<<");"<<std::endl;
392 }
393}
394
395////////////////////////////////////////////////////////////////////////////////
396/// Invoke the DialogCanvas Text attributes.
399{
402}
403
404////////////////////////////////////////////////////////////////////////////////
405/// Set a transparent marker color. talpha defines the percentage of
406/// the color opacity from 0. (fully transparent) to 1. (fully opaque).
409{
410 fTextColor = TColor::GetColorTransparent(tcolor, talpha);
411}
412
413////////////////////////////////////////////////////////////////////////////////
414/// Set the text size in pixels.
415///
416/// If the font precision is greater than 2, the text size is set to npixels,
417/// otherwise the text size is computed as a percent of the pad size.
420{
421 if (fTextFont%10 > 2) {
422 fTextSize = Float_t(npixels);
423 } else {
425 if (!pad) return;
426 Float_t dy = pad->AbsPixeltoY(0) - pad->AbsPixeltoY(npixels);
427 fTextSize = dy/(pad->GetY2() - pad->GetY1());
428 }
429}
#define h(i)
Definition RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
short Style_t
Definition RtypesCore.h:89
short Color_t
Definition RtypesCore.h:92
float Float_t
Definition RtypesCore.h:57
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:377
Option_t Option_t TPoint TPoint angle
char name[80]
Definition TGX11.cxx:110
#define gROOT
Definition TROOT.h:406
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
#define gPad
#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:326
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:254
virtual void SetTextColorAlpha(Color_t tcolor, Float_t talpha)
Set a transparent marker color.
Definition TAttText.cxx:407
virtual Color_t GetTextColor() const
Return the text color.
Definition TAttText.h:34
virtual ~TAttText()
AttText destructor.
Definition TAttText.cxx:284
virtual Float_t GetTextAngle() const
Return the text angle.
Definition TAttText.h:33
virtual void SetTextAttributes()
Invoke the DialogCanvas Text attributes.
Definition TAttText.cxx:397
virtual void SetTextSizePixels(Int_t npixels)
Set the text size in pixel.
Definition TAttText.cxx:418
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:370
virtual Float_t GetTextSizePercent(Float_t size)
Return the text in percent of the pad size.
Definition TAttText.cxx:307
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:291
virtual void ResetAttText(Option_t *toption="")
Reset this text attributes to default values.
Definition TAttText.cxx:358
Float_t fTextSize
Text size.
Definition TAttText.h:22
static Bool_t 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:2358
static Int_t GetColorTransparent(Int_t color, Float_t a)
Static function: Returns the transparent color number corresponding to n.
Definition TColor.cxx:2052
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 TVirtualPad * GetSelectedPad() const =0
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)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123