Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TTF.cxx
Go to the documentation of this file.
1// @(#)root/graf:$Id$
2// Author: Olivier Couet 01/10/02
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/** \class TTF
13\ingroup BasicGraphics
14
15Interface to the freetype 2 library.
16*/
17
18# include <ft2build.h>
19# include FT_FREETYPE_H
20# include FT_GLYPH_H
21#include "TROOT.h"
22#include "TTF.h"
23#include "TSystem.h"
24#include "TEnv.h"
25#include "TMath.h"
26#include "TError.h"
27
28// to scale fonts to the same size as the old TT version
29const Float_t kScale = 0.93376068;
30
31TTF gCleanupTTF; // Allows to call "Cleanup" at the end of the session
32
33Bool_t TTF::fgInit = kFALSE;
34Bool_t TTF::fgSmoothing = kTRUE;
35Bool_t TTF::fgKerning = kTRUE;
36Bool_t TTF::fgHinting = kFALSE;
37Int_t TTF::fgTBlankW = 0;
38Int_t TTF::fgWidth = 0;
39Int_t TTF::fgAscent = 0;
40Int_t TTF::fgCurFontIdx = -1;
41Int_t TTF::fgSymbItaFontIdx = -1;
42Int_t TTF::fgFontCount = 0;
43Int_t TTF::fgNumGlyphs = 0;
44char *TTF::fgFontName[kTTMaxFonts];
45FT_Matrix *TTF::fgRotMatrix = nullptr;
46FT_Library TTF::fgLibrary;
47FT_BBox TTF::fgCBox;
48FT_Face TTF::fgFace[kTTMaxFonts];
49FT_CharMap TTF::fgCharMap[kTTMaxFonts];
50TTF::TTGlyph TTF::fgGlyphs[kMaxGlyphs];
51
52ClassImp(TTF);
53
54////////////////////////////////////////////////////////////////////////////////
55/// Cleanup TTF environment.
56
57TTF::~TTF()
58{
59 Cleanup();
60}
61
62////////////////////////////////////////////////////////////////////////////////
63/// Initialise the TrueType fonts interface.
64
65void TTF::Init()
66{
67 fgInit = kTRUE;
68
69 // initialize FTF library
70 if (FT_Init_FreeType(&fgLibrary)) {
71 Error("TTF::Init", "error initializing FreeType");
72 return;
73 }
74
75 // load default font (arialbd)
76 SetTextFont(62);
77}
78
79////////////////////////////////////////////////////////////////////////////////
80/// Cleanup. Is called by the gCleanupTTF destructor.
81
82void TTF::Cleanup()
83{
84 if (!fgInit) return;
85
86 for (int i = 0; i < fgFontCount; i++) {
87 delete [] fgFontName[i];
88 FT_Done_Face(fgFace[i]);
89 }
90 if (fgRotMatrix) delete fgRotMatrix;
91 FT_Done_FreeType(fgLibrary);
92
93 fgInit = kFALSE;
94}
95
96////////////////////////////////////////////////////////////////////////////////
97/// Map char to unicode. Returns 0 in case no mapping exists.
98
99Short_t TTF::CharToUnicode(UInt_t code)
100{
101 if (!fgCharMap[fgCurFontIdx]) {
102 UShort_t i, platform, encoding;
103 FT_CharMap charmap;
104
105 if (!fgFace[fgCurFontIdx]) return 0;
106 Int_t n = fgFace[fgCurFontIdx]->num_charmaps;
107 for (i = 0; i < n; i++) {
108 if (!fgFace[fgCurFontIdx]) continue;
109 charmap = fgFace[fgCurFontIdx]->charmaps[i];
110 platform = charmap->platform_id;
111 encoding = charmap->encoding_id;
112 if ((platform == 3 && encoding == 1) ||
113 (platform == 0 && encoding == 0) ||
114 (platform == 1 && encoding == 0 &&
115 !strcmp(fgFontName[fgCurFontIdx], "wingding.ttf")) ||
116 (platform == 1 && encoding == 0 &&
117 !strcmp(fgFontName[fgCurFontIdx], "symbol.ttf")))
118 {
119 fgCharMap[fgCurFontIdx] = charmap;
120 if (FT_Set_Charmap(fgFace[fgCurFontIdx], fgCharMap[fgCurFontIdx]))
121 Error("TTF::CharToUnicode", "error in FT_Set_CharMap");
122 return FT_Get_Char_Index(fgFace[fgCurFontIdx], (FT_ULong)code);
123 }
124 }
125 }
126 return FT_Get_Char_Index(fgFace[fgCurFontIdx], (FT_ULong)code);
127}
128
129////////////////////////////////////////////////////////////////////////////////
130/// Get width (w) and height (h) when text is horizontal.
131
132void TTF::GetTextExtent(UInt_t &w, UInt_t &h, char *text)
133{
134 if (!fgInit) Init();
135
136 SetRotationMatrix(0);
137 PrepareString(text);
138 LayoutGlyphs();
139 Int_t Xoff = 0; if (fgCBox.xMin < 0) Xoff = -fgCBox.xMin;
140 Int_t Yoff = 0; if (fgCBox.yMin < 0) Yoff = -fgCBox.yMin;
141 w = fgCBox.xMax + Xoff + fgTBlankW;
142 h = fgCBox.yMax + Yoff;
143}
144
145////////////////////////////////////////////////////////////////////////////////
146/// Get advance (a) when text is horizontal.
147
148void TTF::GetTextAdvance(UInt_t &a, char *text)
149{
150 if (!fgInit) Init();
151
152 SetRotationMatrix(0);
153 PrepareString(text);
154 LayoutGlyphs();
155 a = GetWidth()>>6;
156}
157
158////////////////////////////////////////////////////////////////////////////////
159/// Get width (w) and height (h) when text is horizontal.
160
161void TTF::GetTextExtent(UInt_t &w, UInt_t &h, wchar_t *text)
162{
163 if (!fgInit) Init();
164
165 SetRotationMatrix(0);
166 PrepareString(text);
167 LayoutGlyphs();
168 Int_t Xoff = 0; if (fgCBox.xMin < 0) Xoff = -fgCBox.xMin;
169 Int_t Yoff = 0; if (fgCBox.yMin < 0) Yoff = -fgCBox.yMin;
170 w = fgCBox.xMax + Xoff + fgTBlankW;
171 h = fgCBox.yMax + Yoff;
172}
173
174////////////////////////////////////////////////////////////////////////////////
175/// Compute the glyphs positions, fgAscent and fgWidth (needed for alignment).
176/// Perform the Glyphs transformation.
177/// Compute the string control box.
178/// If required take the "kerning" into account.
179/// SetRotation and PrepareString should have been called before.
180
181void TTF::LayoutGlyphs()
182{
183 TTGlyph* glyph = fgGlyphs;
184 FT_Vector origin;
185 FT_UInt load_flags;
186 FT_UInt prev_index = 0;
187
188 fgAscent = 0;
189 fgWidth = 0;
190
191 load_flags = FT_LOAD_DEFAULT;
192 if (!fgHinting) load_flags |= FT_LOAD_NO_HINTING;
193
194 fgCBox.xMin = fgCBox.yMin = 32000;
195 fgCBox.xMax = fgCBox.yMax = -32000;
196
197 for (int n = 0; n < fgNumGlyphs; n++, glyph++) {
198
199 // compute glyph origin
200 if (fgKerning) {
201 if (prev_index) {
202 FT_Vector kern;
203 FT_Get_Kerning(fgFace[fgCurFontIdx], prev_index, glyph->fIndex,
204 fgHinting ? ft_kerning_default : ft_kerning_unfitted,
205 &kern);
206 fgWidth += kern.x;
207 }
208 prev_index = glyph->fIndex;
209 }
210
211 origin.x = fgWidth;
212 origin.y = 0;
213
214 // clear existing image if there is one
215 if (glyph->fImage) {
216 FT_Done_Glyph(glyph->fImage);
217 glyph->fImage = nullptr;
218 }
219
220 // load the glyph image (in its native format)
221 if (FT_Load_Glyph(fgFace[fgCurFontIdx], glyph->fIndex, load_flags))
222 continue;
223
224 // extract the glyph image
225 if (FT_Get_Glyph (fgFace[fgCurFontIdx]->glyph, &glyph->fImage))
226 continue;
227
228 glyph->fPos = origin;
229 fgWidth += fgFace[fgCurFontIdx]->glyph->advance.x;
230 fgAscent = TMath::Max((Int_t)(fgFace[fgCurFontIdx]->glyph->metrics.horiBearingY), fgAscent);
231
232 // transform the glyphs
233 FT_Vector_Transform(&glyph->fPos, fgRotMatrix);
234 if (FT_Glyph_Transform(glyph->fImage, fgRotMatrix, &glyph->fPos))
235 continue;
236
237 // compute the string control box
238 FT_BBox bbox;
239 FT_Glyph_Get_CBox(glyph->fImage, ft_glyph_bbox_pixels, &bbox);
240 if (bbox.xMin < fgCBox.xMin) fgCBox.xMin = bbox.xMin;
241 if (bbox.yMin < fgCBox.yMin) fgCBox.yMin = bbox.yMin;
242 if (bbox.xMax > fgCBox.xMax) fgCBox.xMax = bbox.xMax;
243 if (bbox.yMax > fgCBox.yMax) fgCBox.yMax = bbox.yMax;
244 }
245}
246
247////////////////////////////////////////////////////////////////////////////////
248/// Put the characters in "string" in the "glyphs" array.
249
250void TTF::PrepareString(const char *string)
251{
252 const unsigned char *p = (const unsigned char*) string;
253 TTGlyph *glyph = fgGlyphs;
254 UInt_t index; // Unicode value
255 Int_t NbTBlank = 0; // number of trailing blanks
256
257 fgTBlankW = 0;
258 fgNumGlyphs = 0;
259 while (*p) {
260 index = CharToUnicode((FT_ULong)*p);
261 if (index != 0) {
262 glyph->fIndex = index;
263 glyph++;
264 fgNumGlyphs++;
265 }
266 if (*p == ' ') {
267 NbTBlank++;
268 } else {
269 NbTBlank = 0;
270 }
271 if (fgNumGlyphs >= kMaxGlyphs) break;
272 p++;
273 }
274
275 // compute the trailing blanks width. It is use to compute the text
276 // width in GetTextExtent
277 if (NbTBlank) {
278 FT_UInt load_flags = FT_LOAD_DEFAULT;
279 if (!fgHinting) load_flags |= FT_LOAD_NO_HINTING;
280 if (FT_Load_Glyph(fgFace[fgCurFontIdx], 3, load_flags)) return;
281 fgTBlankW = (Int_t)((fgFace[fgCurFontIdx]->glyph->advance.x)>>6)*NbTBlank;
282 }
283}
284
285////////////////////////////////////////////////////////////////////////////////
286/// Put the characters in "string" in the "glyphs" array.
287
288void TTF::PrepareString(const wchar_t *string)
289{
290 const wchar_t *p = string;
291 TTGlyph *glyph = fgGlyphs;
292 UInt_t index; // Unicode value
293 Int_t NbTBlank = 0; // number of trailing blanks
294
295 fgTBlankW = 0;
296 fgNumGlyphs = 0;
297 while (*p) {
298 index = FT_Get_Char_Index(fgFace[fgCurFontIdx], (FT_ULong)*p);
299 if (index != 0) {
300 glyph->fIndex = index;
301 glyph++;
302 fgNumGlyphs++;
303 }
304 if (*p == ' ') {
305 NbTBlank++;
306 } else {
307 NbTBlank = 0;
308 }
309 if (fgNumGlyphs >= kMaxGlyphs) break;
310 p++;
311 }
312
313 // compute the trailing blanks width. It is use to compute the text
314 // width in GetTextExtent
315 if (NbTBlank) {
316 FT_UInt load_flags = FT_LOAD_DEFAULT;
317 if (!fgHinting) load_flags |= FT_LOAD_NO_HINTING;
318 if (FT_Load_Glyph(fgFace[fgCurFontIdx], 3, load_flags)) return;
319 fgTBlankW = (Int_t)((fgFace[fgCurFontIdx]->glyph->advance.x)>>6)*NbTBlank;
320 }
321}
322
323////////////////////////////////////////////////////////////////////////////////
324/// Set hinting flag.
325
326void TTF::SetHinting(Bool_t state)
327{
328 fgHinting = state;
329}
330
331////////////////////////////////////////////////////////////////////////////////
332/// Set kerning flag.
333
334void TTF::SetKerning(Bool_t state)
335{
336 fgKerning = state;
337}
338
339////////////////////////////////////////////////////////////////////////////////
340/// Set the rotation matrix used to rotate the font outlines.
341
342void TTF::SetRotationMatrix(Float_t angle)
343{
344 Float_t rangle = Float_t(angle * TMath::Pi() / 180.); // Angle in radian
345#if defined(FREETYPE_PATCH) && \
346 (FREETYPE_MAJOR == 2) && (FREETYPE_MINOR == 1) && (FREETYPE_PATCH == 2)
347 Float_t sin = TMath::Sin(rangle);
348 Float_t cos = TMath::Cos(rangle);
349#else
350 Float_t sin = TMath::Sin(-rangle);
351 Float_t cos = TMath::Cos(-rangle);
352#endif
353
354 if (!fgRotMatrix) fgRotMatrix = new FT_Matrix;
355
356 fgRotMatrix->xx = (FT_Fixed) (cos * (1<<16));
357 fgRotMatrix->xy = (FT_Fixed) (sin * (1<<16));
358 fgRotMatrix->yx = -fgRotMatrix->xy;
359 fgRotMatrix->yy = fgRotMatrix->xx;
360}
361
362////////////////////////////////////////////////////////////////////////////////
363/// Set smoothing (anti-aliasing) flag.
364
365void TTF::SetSmoothing(Bool_t state)
366{
367 fgSmoothing = state;
368}
369
370////////////////////////////////////////////////////////////////////////////////
371/// Set text font to specified name.
372/// - font : font name
373/// - italic : the fonts should be slanted. Used for symbol font.
374///
375/// Set text font to specified name. This function returns 0 if
376/// the specified font is found, 1 if not.
377
378Int_t TTF::SetTextFont(const char *fontname, Int_t italic)
379{
380 if (!fgInit) Init();
381
382 if (!fontname || !fontname[0]) {
383 Warning("TTF::SetTextFont",
384 "no font name specified, using default font %s", fgFontName[0]);
385 fgCurFontIdx = 0;
386 return 0;
387 }
388 const char *basename = gSystem->BaseName(fontname);
389
390 // check if font is in cache
391 int i;
392 for (i = 0; i < fgFontCount; i++) {
393 if (!strcmp(fgFontName[i], basename)) {
394 if (italic) {
395 if (i==fgSymbItaFontIdx) {
396 fgCurFontIdx = i;
397 return 0;
398 }
399 } else {
400 if (i!=fgSymbItaFontIdx) {
401 fgCurFontIdx = i;
402 return 0;
403 }
404 }
405 }
406 }
407
408 // enough space in cache to load font?
409 if (fgFontCount >= kTTMaxFonts) {
410 Error("TTF::SetTextFont", "too many fonts opened (increase kTTMaxFont = %d)",
411 kTTMaxFonts);
412 Warning("TTF::SetTextFont", "using default font %s", fgFontName[0]);
413 fgCurFontIdx = 0; // use font 0 (default font, set in ctor)
414 return 0;
415 }
416
417 // try to load font (font must be in Root.TTFontPath resource)
418 const char *ttpath = gEnv->GetValue("Root.TTFontPath",
419 TROOT::GetTTFFontDir());
420 char *ttfont = gSystem->Which(ttpath, fontname, kReadPermission);
421
422 if (!ttfont) {
423 Error("TTF::SetTextFont", "font file %s not found in path", fontname);
424 if (fgFontCount) {
425 Warning("TTF::SetTextFont", "using default font %s", fgFontName[0]);
426 fgCurFontIdx = 0; // use font 0 (default font, set in ctor)
427 return 0;
428 } else {
429 return 1;
430 }
431 }
432
433 FT_Face tface = 0;
434
435 if (FT_New_Face(fgLibrary, ttfont, 0, &tface)) {
436 Error("TTF::SetTextFont", "error loading font %s", ttfont);
437 delete [] ttfont;
438 if (tface) FT_Done_Face(tface);
439 if (fgFontCount) {
440 Warning("TTF::SetTextFont", "using default font %s", fgFontName[0]);
441 fgCurFontIdx = 0;
442 return 0;
443 } else {
444 return 1;
445 }
446 }
447
448 delete [] ttfont;
449
450 fgFontName[fgFontCount] = StrDup(basename);
451 fgCurFontIdx = fgFontCount;
452 fgFace[fgCurFontIdx] = tface;
453 fgCharMap[fgCurFontIdx] = 0;
454 fgFontCount++;
455
456 if (italic) {
457 fgSymbItaFontIdx = fgCurFontIdx;
458 FT_Matrix slantMat;
459 slantMat.xx = (1 << 16);
460 slantMat.xy = ((1 << 16) >> 2);
461 slantMat.yx = 0;
462 slantMat.yy = (1 << 16);
463 FT_Set_Transform( fgFace[fgSymbItaFontIdx], &slantMat, NULL );
464 }
465
466 return 0;
467}
468
469////////////////////////////////////////////////////////////////////////////////
470/// Set specified font.
471/// List of the currently supported fonts (screen and PostScript)
472///
473/// | Font ID | X11 | TTF |
474/// |---------|---------------------------|------------------|
475/// | 1 | times-medium-i-normal | timesi.ttf |
476/// | 2 | times-bold-r-normal | timesbd.ttf |
477/// | 3 | times-bold-i-normal | timesbi.ttf |
478/// | 4 | helvetica-medium-r-normal | arial.ttf |
479/// | 5 | helvetica-medium-o-normal | ariali.ttf |
480/// | 6 | helvetica-bold-r-normal | arialbd.ttf |
481/// | 7 | helvetica-bold-o-normal | arialbi.ttf |
482/// | 8 | courier-medium-r-normal | cour.ttf |
483/// | 9 | courier-medium-o-normal | couri.ttf |
484/// | 10 | courier-bold-r-normal | courbd.ttf |
485/// | 11 | courier-bold-o-normal | courbi.ttf |
486/// | 12 | symbol-medium-r-normal | symbol.ttf |
487/// | 13 | times-medium-r-normal | times.ttf |
488/// | 14 | | wingding.ttf |
489/// | 15 | symbol oblique is emulated from symbol.ttf | |
490
491void TTF::SetTextFont(Font_t fontnumber)
492{
493 // Added by cholm for use of DFSG - fonts - based on Kevins fix.
494 // Table of Microsoft and (for non-MSFT operating systems) backup
495 // FreeFont TTF fonts.
496 static const char *fonttable[][2] = {
497 { "Root.TTFont.0", "FreeSansBold.otf" },
498 { "Root.TTFont.1", "FreeSerifItalic.otf" },
499 { "Root.TTFont.2", "FreeSerifBold.otf" },
500 { "Root.TTFont.3", "FreeSerifBoldItalic.otf" },
501 { "Root.TTFont.4", "FreeSans.otf" },
502 { "Root.TTFont.5", "FreeSansOblique.otf" },
503 { "Root.TTFont.6", "FreeSansBold.otf" },
504 { "Root.TTFont.7", "FreeSansBoldOblique.otf" },
505 { "Root.TTFont.8", "FreeMono.otf" },
506 { "Root.TTFont.9", "FreeMonoOblique.otf" },
507 { "Root.TTFont.10", "FreeMonoBold.otf" },
508 { "Root.TTFont.11", "FreeMonoBoldOblique.otf" },
509 { "Root.TTFont.12", "symbol.ttf" },
510 { "Root.TTFont.13", "FreeSerif.otf" },
511 { "Root.TTFont.14", "wingding.ttf" },
512 { "Root.TTFont.15", "symbol.ttf" },
513 { "Root.TTFont.STIXGen", "STIXGeneral.otf" },
514 { "Root.TTFont.STIXGenIt", "STIXGeneralItalic.otf" },
515 { "Root.TTFont.STIXGenBd", "STIXGeneralBol.otf" },
516 { "Root.TTFont.STIXGenBdIt", "STIXGeneralBolIta.otf" },
517 { "Root.TTFont.STIXSiz1Sym", "STIXSiz1Sym.otf" },
518 { "Root.TTFont.STIXSiz1SymBd", "STIXSiz1SymBol.otf" },
519 { "Root.TTFont.STIXSiz2Sym", "STIXSiz2Sym.otf" },
520 { "Root.TTFont.STIXSiz2SymBd", "STIXSiz2SymBol.otf" },
521 { "Root.TTFont.STIXSiz3Sym", "STIXSiz3Sym.otf" },
522 { "Root.TTFont.STIXSiz3SymBd", "STIXSiz3SymBol.otf" },
523 { "Root.TTFont.STIXSiz4Sym", "STIXSiz4Sym.otf" },
524 { "Root.TTFont.STIXSiz4SymBd", "STIXSiz4SymBol.otf" },
525 { "Root.TTFont.STIXSiz5Sym", "STIXSiz5Sym.otf" },
526 { "Root.TTFont.ME", "DroidSansFallback.ttf" },
527 { "Root.TTFont.CJKMing", "DroidSansFallback.ttf" },
528 { "Root.TTFont.CJKGothic", "DroidSansFallback.ttf" }
529 };
530
531 static int fontset = -1;
532 int thisset = fontset;
533
534 int fontid = fontnumber / 10;
535 if (fontid < 0 || fontid > 31) fontid = 0;
536
537 if (thisset == -1) {
538 // try to load font (font must be in Root.TTFontPath resource)
539 // to see which fontset we have available
540 const char *ttpath = gEnv->GetValue("Root.TTFontPath",
541 TROOT::GetTTFFontDir());
542 char *ttfont = gSystem->Which(ttpath, gEnv->GetValue(fonttable[fontid][0], fonttable[fontid][1]), kReadPermission);
543 if (ttfont) {
544 delete [] ttfont;
545 thisset = 0;
546 } else {
547 // try backup free font
548 thisset = 1;
549 }
550 }
551 Int_t italic = 0;
552 if (fontid==15) italic = 1;
553 int ret = SetTextFont(gEnv->GetValue(fonttable[fontid][thisset], fonttable[fontid][1]), italic);
554 // Do not define font set is we're loading the symbol.ttf - it's
555 // the same in both cases.
556 if (ret == 0 && fontid != 12) fontset = thisset;
557}
558
559////////////////////////////////////////////////////////////////////////////////
560/// Set current text size.
561
562void TTF::SetTextSize(Float_t textsize)
563{
564 if (!fgInit) Init();
565 if (textsize < 0) return;
566
567 if (fgCurFontIdx < 0 || fgFontCount <= fgCurFontIdx) {
568 Error("TTF::SetTextSize", "current font index out of bounds");
569 fgCurFontIdx = 0;
570 return;
571 }
572
573 Int_t tsize = (Int_t)(textsize*kScale+0.5) << 6;
574 if (FT_Set_Char_Size(fgFace[fgCurFontIdx], tsize, tsize, 72, 72))
575 Error("TTF::SetTextSize", "error in FT_Set_Char_Size");
576}
577
578////////////////////////////////////////////////////////////////////////////////
579
580void TTF::Version(Int_t &major, Int_t &minor, Int_t &patch)
581{
582 FT_Library_Version(fgLibrary, &major, &minor, &patch);
583}
584
585////////////////////////////////////////////////////////////////////////////////
586
587Bool_t TTF::GetHinting()
588{
589 return fgHinting;
590}
591
592////////////////////////////////////////////////////////////////////////////////
593
594Bool_t TTF::GetKerning()
595{
596 return fgKerning;
597}
598
599////////////////////////////////////////////////////////////////////////////////
600
601Bool_t TTF::GetSmoothing()
602{
603 return fgSmoothing;
604}
605
606////////////////////////////////////////////////////////////////////////////////
607
608Bool_t TTF::IsInitialized()
609{
610 return fgInit;
611}
612
613////////////////////////////////////////////////////////////////////////////////
614
615Int_t TTF::GetWidth()
616{
617 return fgWidth;
618}
619
620////////////////////////////////////////////////////////////////////////////////
621
622Int_t TTF::GetAscent()
623{
624 return fgAscent;
625}
626
627////////////////////////////////////////////////////////////////////////////////
628
629Int_t TTF::GetNumGlyphs()
630{
631 return fgNumGlyphs;
632}
633
634////////////////////////////////////////////////////////////////////////////////
635
636FT_Matrix *TTF::GetRotMatrix()
637{
638 return fgRotMatrix;
639}
640
641////////////////////////////////////////////////////////////////////////////////
642
643const FT_BBox &TTF::GetBox()
644{
645 return fgCBox;
646}
647
648////////////////////////////////////////////////////////////////////////////////
649
650TTF::TTGlyph *TTF::GetGlyphs()
651{
652 return fgGlyphs;
653}
a
#define a(i)
Definition RSha256.hxx:99
h
#define h(i)
Definition RSha256.hxx:106
UShort_t
unsigned short UShort_t
Definition RtypesCore.h:40
Int_t
int Int_t
Definition RtypesCore.h:45
kFALSE
const Bool_t kFALSE
Definition RtypesCore.h:92
Bool_t
bool Bool_t
Definition RtypesCore.h:63
Font_t
short Font_t
Definition RtypesCore.h:79
Short_t
short Short_t
Definition RtypesCore.h:39
Float_t
float Float_t
Definition RtypesCore.h:57
kTRUE
const Bool_t kTRUE
Definition RtypesCore.h:91
ClassImp
#define ClassImp(name)
Definition Rtypes.h:364
kScale
const Float_t kScale
Definition TASImage.cxx:130
gEnv
R__EXTERN TEnv * gEnv
Definition TEnv.h:171
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:187
Warning
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:231
cos
double cos(double)
sin
double sin(double)
StrDup
char * StrDup(const char *str)
Duplicate the string str.
Definition TString.cxx:2510
kReadPermission
@ kReadPermission
Definition TSystem.h:47
gSystem
R__EXTERN TSystem * gSystem
Definition TSystem.h:559
kScale
const Float_t kScale
Definition TTF.cxx:29
gCleanupTTF
TTF gCleanupTTF
Definition TTF.cxx:31
TEnv::GetValue
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
TROOT::GetTTFFontDir
static const TString & GetTTFFontDir()
Get the fonts directory in the installation. Static utility function.
Definition TROOT.cxx:3106
TSystem::BaseName
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition TSystem.cxx:933
TSystem::Which
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition TSystem.cxx:1544
TTF::TTGlyph
TTF helper class containing glyphs description.
Definition TTF.h:65
TTF::TTGlyph::fPos
FT_Vector fPos
position of glyph origin
Definition TTF.h:68
TTF::TTGlyph::fImage
FT_Glyph fImage
glyph image
Definition TTF.h:69
TTF::TTGlyph::fIndex
UInt_t fIndex
glyph index in face
Definition TTF.h:67
TTF
Interface to the freetype 2 library.
Definition TTF.h:53
TTF::SetKerning
static void SetKerning(Bool_t state)
Set kerning flag.
Definition TTF.cxx:334
TTF::fgHinting
static Bool_t fgHinting
use hinting (true by default)
Definition TTF.h:84
TTF::kMaxGlyphs
@ kMaxGlyphs
Definition TTF.h:73
TTF::kTTMaxFonts
@ kTTMaxFonts
Definition TTF.h:73
TTF::IsInitialized
static Bool_t IsInitialized()
Definition TTF.cxx:608
TTF::GetTextAdvance
static void GetTextAdvance(UInt_t &a, char *text)
Get advance (a) when text is horizontal.
Definition TTF.cxx:148
TTF::PrepareString
static void PrepareString(const char *string)
Put the characters in "string" in the "glyphs" array.
Definition TTF.cxx:250
TTF::fgGlyphs
static TTF::TTGlyph fgGlyphs[kMaxGlyphs]
glyphs
Definition TTF.h:83
TTF::GetKerning
static Bool_t GetKerning()
Definition TTF.cxx:594
TTF::fgSmoothing
static Bool_t fgSmoothing
use anti-aliasing (true when >8 planes, false otherwise)
Definition TTF.h:90
TTF::Version
static void Version(Int_t &major, Int_t &minor, Int_t &patch)
Definition TTF.cxx:580
TTF::SetHinting
static void SetHinting(Bool_t state)
Set hinting flag.
Definition TTF.cxx:326
TTF::Init
static void Init()
Initialise the TrueType fonts interface.
Definition TTF.cxx:65
TTF::fgFace
static FT_Face fgFace[kTTMaxFonts]
font face
Definition TTF.h:82
TTF::fgCharMap
static FT_CharMap fgCharMap[kTTMaxFonts]
font character map
Definition TTF.h:77
TTF::LayoutGlyphs
static void LayoutGlyphs()
Compute the glyphs positions, fgAscent and fgWidth (needed for alignment).
Definition TTF.cxx:181
TTF::SetSmoothing
static void SetSmoothing(Bool_t state)
Set smoothing (anti-aliasing) flag.
Definition TTF.cxx:365
TTF::SetRotationMatrix
static void SetRotationMatrix(Float_t angle)
Set the rotation matrix used to rotate the font outlines.
Definition TTF.cxx:342
TTF::SetTextFont
static void SetTextFont(Font_t fontnumber)
Set specified font.
Definition TTF.cxx:491
TTF::CharToUnicode
static Short_t CharToUnicode(UInt_t code)
Map char to unicode. Returns 0 in case no mapping exists.
Definition TTF.cxx:99
TTF::GetAscent
static Int_t GetAscent()
Definition TTF.cxx:622
TTF::GetTextExtent
static void GetTextExtent(UInt_t &w, UInt_t &h, char *text)
Get width (w) and height (h) when text is horizontal.
Definition TTF.cxx:132
TTF::GetGlyphs
static TTGlyph * GetGlyphs()
Definition TTF.cxx:650
TTF::GetNumGlyphs
static Int_t GetNumGlyphs()
Definition TTF.cxx:629
TTF::fgAscent
static Int_t fgAscent
string ascent, used to compute Y alignment
Definition TTF.h:75
TTF::fgWidth
static Int_t fgWidth
string width, used to compute X alignment
Definition TTF.h:92
TTF::fgInit
static Bool_t fgInit
true if the Init has been called
Definition TTF.h:85
TTF::fgCurFontIdx
static Int_t fgCurFontIdx
current font index
Definition TTF.h:78
TTF::fgSymbItaFontIdx
static Int_t fgSymbItaFontIdx
Symbol italic font index.
Definition TTF.h:79
TTF::Cleanup
static void Cleanup()
Cleanup. Is called by the gCleanupTTF destructor.
Definition TTF.cxx:82
TTF::~TTF
virtual ~TTF()
Cleanup TTF environment.
Definition TTF.cxx:57
TTF::GetWidth
static Int_t GetWidth()
Definition TTF.cxx:615
TTF::GetBox
static const FT_BBox & GetBox()
Definition TTF.cxx:643
TTF::fgFontName
static char * fgFontName[kTTMaxFonts]
font name
Definition TTF.h:81
TTF::fgLibrary
static FT_Library fgLibrary
FreeType font library.
Definition TTF.h:87
TTF::fgNumGlyphs
static Int_t fgNumGlyphs
number of glyphs in the string
Definition TTF.h:88
TTF::fgRotMatrix
static FT_Matrix * fgRotMatrix
rotation matrix
Definition TTF.h:89
TTF::fgKerning
static Bool_t fgKerning
use kerning (true by default)
Definition TTF.h:86
TTF::fgTBlankW
static Int_t fgTBlankW
trailing blanks width
Definition TTF.h:91
TTF::GetHinting
static Bool_t GetHinting()
Definition TTF.cxx:587
TTF::GetSmoothing
static Bool_t GetSmoothing()
Definition TTF.cxx:601
TTF::fgFontCount
static Int_t fgFontCount
number of fonts loaded
Definition TTF.h:80
TTF::SetTextSize
static void SetTextSize(Float_t textsize)
Set current text size.
Definition TTF.cxx:562
TTF::GetRotMatrix
static FT_Matrix * GetRotMatrix()
Definition TTF.cxx:636
TTF::fgCBox
static FT_BBox fgCBox
string control box
Definition TTF.h:76
text
TText * text
Definition entrylist_figure1.C:10
n
const Int_t n
Definition legend1.C:16
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition TMathBase.h:212
TMath::Cos
Double_t Cos(Double_t)
Definition TMath.h:643
TMath::Pi
constexpr Double_t Pi()
Definition TMath.h:37
TMath::Sin
Double_t Sin(Double_t)
Definition TMath.h:639