Logo ROOT  

Reference Guide
Loading...
Searching...
No Matches
TGLFontManager.cxx
Go to the documentation of this file.
1// @(#)root/gl:$Id$
2// Author: Alja Mrak-Tadel 2008
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 "RConfigure.h"
13#include "TGLFontManager.h"
14
15
16#include "TROOT.h"
17#include "TVirtualX.h"
18#include "TMath.h"
19#include "TSystem.h"
20#include "TEnv.h"
21#include "TObjString.h"
22#include "TGLUtil.h"
23#include "TGLIncludes.h"
24
25// Direct inclusion of FTGL headers is deprecated in ftgl-2.1.3 while
26// ftgl-2.1.2 shipped with ROOT requires manual inclusion.
27#ifndef BUILTIN_FTGL
28# include <FTGL/ftgl.h>
29#else
30# include "FTFont.h"
31# include "FTGLExtrdFont.h"
32# include "FTGLOutlineFont.h"
33# include "FTGLPolygonFont.h"
34# include "FTGLTextureFont.h"
35# include "FTGLPixmapFont.h"
36# include "FTGLBitmapFont.h"
37#endif
38
39namespace {
40#ifdef HAVE_UTF8
41// https://github.com/root-project/root/issues/22076#issuecomment-4342764706
42TString AsUTF8(const char *txt)
43{
44 TString utxt;
45 const auto len = strlen(txt);
46 for (auto i = 0UL; i < len; ++i) {
47 if (static_cast<unsigned char>(txt[i]) >= static_cast<unsigned char>(192)) {
48 utxt.Append(static_cast<unsigned char>(0xc3));
49 utxt.Append(static_cast<unsigned char>(0x80) +
50 (static_cast<unsigned char>(txt[i]) - static_cast<unsigned char>(192)));
51 } else {
52 utxt.Append(txt[i]);
53 }
54 }
55 return utxt;
56}
57#endif
58} // namespace
59
60/** \class TGLFont
61\ingroup opengl
62A wrapper class for FTFont.
63Holds pointer to FTFont object and its description: face size, font file
64and class ID. It wraps Render and BBox functions.
65*/
66
67
68////////////////////////////////////////////////////////////////////////////////
69/// Constructor.
70
71TGLFont::TGLFont():
72 fFont(0), fManager(0), fDepth(0),
73 fSize(0), fFile(0), fMode(kUndef),
74 fTrashCount(0)
75{
76}
77
78////////////////////////////////////////////////////////////////////////////////
79/// Constructor.
80
81TGLFont::TGLFont(Int_t size, Int_t font, EMode mode, FTFont* f, TGLFontManager* mng):
82 fFont(f), fManager(mng), fDepth(0),
83 fSize(size), fFile(font), fMode(mode),
84 fTrashCount(0)
85{
86}
87
88////////////////////////////////////////////////////////////////////////////////
89/// Assignment operator.
90
91TGLFont::TGLFont(const TGLFont &o):
92 fFont(0), fManager(0), fDepth(0), fTrashCount(0)
93{
94 fFont = (FTFont*)o.GetFont();
95
96 fSize = o.fSize;
97 fFile = o.fFile;
98 fMode = o.fMode;
99
100 fTrashCount = o.fTrashCount;
101}
102
103////////////////////////////////////////////////////////////////////////////////
104///Destructor
105
106TGLFont::~TGLFont()
107{
108 if (fManager) fManager->ReleaseFont(*this);
109}
110
111////////////////////////////////////////////////////////////////////////////////
112/// Assignment operator.
113
114void TGLFont::CopyAttributes(const TGLFont &o)
115{
116 SetFont(o.fFont);
117 SetManager(o.fManager);
118
119 SetDepth(o.fDepth);
120
121 fSize = o.fSize;
122 fFile = o.fFile;
123 fMode = o.fMode;
124
125 fTrashCount = o.fTrashCount;
126}
127
128
129/******************************************************************************/
130
131////////////////////////////////////////////////////////////////////////////////
132/// Get font's ascent.
133
134Float_t TGLFont::GetAscent() const
135{
136 return fFont->Ascender();
137}
138
139////////////////////////////////////////////////////////////////////////////////
140/// Get font's descent. The returned value is positive.
141
142Float_t TGLFont::GetDescent() const
143{
144 return -fFont->Descender();
145}
146
147////////////////////////////////////////////////////////////////////////////////
148/// Get font's line-height.
149
150Float_t TGLFont::GetLineHeight() const
151{
152 return fFont->LineHeight();
153}
154
155////////////////////////////////////////////////////////////////////////////////
156/// Measure font's base-line parameters from the passed text.
157/// Note that the measured parameters are not the same as the ones
158/// returned by get-functions - those were set by the font designer.
159
160void TGLFont::MeasureBaseLineParams(Float_t& ascent, Float_t& descent, Float_t& line_height,
161 const char* txt) const
162{
163#ifdef HAVE_UTF8
164 TString utxt = AsUTF8(txt);
165 txt = utxt.Data();
166#endif
167 Float_t dum, lly, ury;
168 const_cast<FTFont*>(fFont)->BBox(txt, dum, lly, dum, dum, ury, dum);
169 ascent = ury;
170 descent = -lly;
171 line_height = ury - lly;
172}
173
174////////////////////////////////////////////////////////////////////////////////
175/// Get bounding box.
176
177void TGLFont::BBox(const char* txt,
178 Float_t& llx, Float_t& lly, Float_t& llz,
179 Float_t& urx, Float_t& ury, Float_t& urz) const
180{
181 // HAVE_UTF8 was already called by functions above BBox so no need to transform here
182 // FTGL is not const correct.
183 const_cast<FTFont*>(fFont)->BBox(txt, llx, lly, llz, urx, ury, urz);
184}
185
186////////////////////////////////////////////////////////////////////////////////
187/// Get bounding box.
188
189void TGLFont::BBox(const wchar_t* txt,
190 Float_t& llx, Float_t& lly, Float_t& llz,
191 Float_t& urx, Float_t& ury, Float_t& urz) const
192{
193 // HAVE_UTF8 was already called by functions above BBox so no need to transform here
194 // FTGL is not const correct.
195 const_cast<FTFont*>(fFont)->BBox(txt, llx, lly, llz, urx, ury, urz);
196}
197
198////////////////////////////////////////////////////////////////////////////////
199/// Get advance
200
201Float_t TGLFont::Advance(const char* txt) const
202{
203#ifdef HAVE_UTF8
204 TString utxt = AsUTF8(txt);
205 txt = utxt.Data();
206#endif
207 // FTGL is not const correct.
208 return const_cast<FTFont*>(fFont)->Advance(txt);
209}
210
211////////////////////////////////////////////////////////////////////////////////
212///mgn is simply ignored, because ROOT's TVirtualX TGX11 are complete mess with
213///painting attributes.
214
215template<class Char>
216void TGLFont::RenderHelper(const Char *txt, Double_t x, Double_t y, Double_t angle, Double_t /*mgn*/) const
217{
218 // no need to check HAVE_UTF8 here, since it was called by functions above it
219
220 glPushMatrix();
221 //glLoadIdentity();
222
223 // FTGL is not const correct.
224 Float_t llx = 0.f, lly = 0.f, llz = 0.f, urx = 0.f, ury = 0.f, urz = 0.f;
225 BBox(txt, llx, lly, llz, urx, ury, urz);
226
227 /*
228 V\H | left | center | right
229 _______________________________
230 bottom | 7 | 8 | 9
231 _______________________________
232 center | 4 | 5 | 6
233 _______________________________
234 top | 1 | 2 | 3
235 */
236 const Double_t dx = urx - llx, dy = ury - lly;
237 Double_t xc = 0., yc = 0.;
238
239 // if align was not set before - use value from gVirtualX
240 const UInt_t align = fTextAlign ? fTextAlign : gVirtualX->GetTextAlign();
241
242 //Timur: Here's the nice X11 bullshido: you call gVirtualX->SetTextAlign(11),
243 //later gVirtualX->GetTextAling() will give you 7. Brilliant!
244 //But with Cocoa you'll have 11. As it should be, of course.
245 //Sergey: problem with gVirtualX solved, now all platforms works same way
246
247 const UInt_t hAlign = UInt_t(align / 10);
248 const UInt_t vAlign = UInt_t(align % 10);
249 switch (hAlign) {
250 case 1:
251 xc = 0.5 * dx;
252 break;
253 case 2:
254 break;
255 case 3:
256 xc = -0.5 * dy;
257 break;
258 }
259
260 switch (vAlign) {
261 case 1:
262 yc = 0.5 * dy;
263 break;
264 case 2:
265 break;
266 case 3:
267 yc = -0.5 * dy;
268 break;
269 }
270
271 glTranslated(x, y, 0.);
272 glRotated(angle, 0., 0., 1.);
273 glTranslated(xc, yc, 0.);
274 glTranslated(-0.5 * dx, -0.5 * dy, 0.);
275 //glScaled(mgn, mgn, 1.);
276
277 const_cast<FTFont*>(fFont)->Render(txt);
278
279 glPopMatrix();
280}
281
282////////////////////////////////////////////////////////////////////////////////
283
284void TGLFont::Render(const wchar_t* txt, Double_t x, Double_t y, Double_t angle, Double_t mgn) const
285{
286 // TODO handle UTF8
287 RenderHelper(txt, x, y, angle, mgn);
288}
289
290////////////////////////////////////////////////////////////////////////////////
291
292void TGLFont::Render(const char* txt, Double_t x, Double_t y, Double_t angle, Double_t mgn) const
293{
294#ifdef HAVE_UTF8
295 TString utxt = AsUTF8(txt);
296 txt = utxt.Data();
297#endif
298 RenderHelper(txt, x, y, angle, mgn);
299}
300
301////////////////////////////////////////////////////////////////////////////////
302/// Render text.
303
304void TGLFont::Render(const TString &txt) const
305{
306 Bool_t scaleDepth = (fMode == kExtrude && fDepth != 1.0f);
307
308 if (scaleDepth) {
309 glPushMatrix();
310 // !!! 0.2*fSize is hard-coded in TGLFontManager::GetFont(), too.
311 glTranslatef(0.0f, 0.0f, 0.5f*fDepth * 0.2f*fSize);
312 glScalef(1.0f, 1.0f, fDepth);
313 }
314
315#ifdef HAVE_UTF8
316 TString utxt = AsUTF8(txt);
317 // FTGL is not const correct.
318 const_cast<FTFont *>(fFont)->Render(utxt.Data());
319#else
320 // FTGL is not const correct.
321 const_cast<FTFont *>(fFont)->Render(txt.Data());
322#endif
323
324 if (scaleDepth) {
325 glPopMatrix();
326 }
327}
328
329////////////////////////////////////////////////////////////////////////////////
330/// Render text with given alignmentrepl and at given position.
331
332void TGLFont::Render(const TString &txt, Float_t x, Float_t y, Float_t z, ETextAlignH_e alignH,
333 ETextAlignV_e alignV) const
334{
335 glPushMatrix();
336
337 glTranslatef(x, y, z);
338
339 x=0, y=0;
340 Float_t llx, lly, llz, urx, ury, urz;
341
342#ifdef HAVE_UTF8
343 TString utxt = AsUTF8(txt);
344 BBox(utxt.Data(), llx, lly, llz, urx, ury, urz);
345#else
346 BBox(txt.Data(), llx, lly, llz, urx, ury, urz);
347#endif
348
349 switch (alignH)
350 {
351 case TGLFont::kRight:
352 x = -urx;
353 break;
354
355 case TGLFont::kCenterH:
356 x = -urx*0.5;
357 break;
358 default:
359 break;
360 };
361
362 switch (alignV)
363 {
364 case TGLFont::kBottom:
365 y = -ury;
366 break;
367 case TGLFont::kCenterV:
368 y = -ury*0.5;
369 break;
370 default:
371 break;
372 };
373
374 if (fMode == TGLFont::kPixmap || fMode == TGLFont::kBitmap)
375 {
376 glRasterPos2i(0, 0);
377 glBitmap(0, 0, 0, 0, x, y, 0);
378 }
379 else
380 {
381 glTranslatef(x, y, 0);
382 }
383
384 Bool_t scaleDepth = (fMode == kExtrude && fDepth != 1.0f);
385
386 if (scaleDepth) {
387 glPushMatrix();
388 // !!! 0.2*fSize is hard-coded in TGLFontManager::GetFont(), too.
389 glTranslatef(0.0f, 0.0f, 0.5f * fDepth * 0.2f * fSize);
390 glScalef(1.0f, 1.0f, fDepth);
391 }
392
393#ifdef HAVE_UTF8
394 // FTGL is not const correct.
395 const_cast<FTFont *>(fFont)->Render(utxt.Data());
396#else
397 // FTGL is not const correct.
398 const_cast<FTFont *>(fFont)->Render(txt.Data());
399#endif
400
401 if (scaleDepth) {
402 glPopMatrix();
403 }
404 glPopMatrix();
405}
406
407////////////////////////////////////////////////////////////////////////////////
408/// Set-up GL state before FTFont rendering.
409
410void TGLFont::PreRender(Bool_t autoLight, Bool_t lightOn) const
411{
412 switch (fMode)
413 {
414 case kBitmap:
415 case kPixmap:
416 glPushAttrib(GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
417 glEnable(GL_ALPHA_TEST);
418 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
419 glAlphaFunc(GL_GEQUAL, 0.0625);
420 break;
421 case kTexture:
422 glPushAttrib(GL_POLYGON_BIT | GL_ENABLE_BIT);
423 glEnable(GL_TEXTURE_2D);
424 glDisable(GL_CULL_FACE);
425 glEnable(GL_ALPHA_TEST);
426 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
427 glAlphaFunc(GL_GEQUAL, 0.0625);
428 break;
429 case kOutline:
430 case kPolygon:
431 case kExtrude:
432 glPushAttrib(GL_POLYGON_BIT | GL_ENABLE_BIT);
433 glEnable(GL_NORMALIZE);
434 glDisable(GL_CULL_FACE);
435 break;
436 default:
437 Warning("TGLFont::PreRender", "Font mode undefined.");
438 glPushAttrib(GL_LIGHTING_BIT);
439 break;
440 }
441
442 if ((autoLight && fMode > TGLFont::kOutline) || (!autoLight && lightOn))
443 glEnable(GL_LIGHTING);
444 else
445 glDisable(GL_LIGHTING);
446}
447
448////////////////////////////////////////////////////////////////////////////////
449/// Reset GL state after FTFont rendering.
450
451void TGLFont::PostRender() const
452{
453 glPopAttrib();
454}
455
456/** \class TGLFontManager
457\ingroup opengl
458A FreeType GL font manager.
459
460Each GL rendering context has an instance of FTGLManager.
461This enables FTGL fonts to be shared same way as textures and display lists.
462*/
463
464
465TObjArray TGLFontManager::fgFontFileArray;
466Int_t TGLFontManager::fgExtendedFontStart;
467TGLFontManager::FontSizeVec_t TGLFontManager::fgFontSizeArray;
468Bool_t TGLFontManager::fgStaticInitDone = kFALSE;
469
470////////////////////////////////////////////////////////////////////////////////
471/// Destructor.
472
473TGLFontManager::~TGLFontManager()
474{
475 FontMap_i it = fFontMap.begin();
476 while (it != fFontMap.end()) {
477 delete it->first.GetFont();
478 it++;
479 }
480 fFontMap.clear();
481}
482
483////////////////////////////////////////////////////////////////////////////////
484/// Provide font with given size, file and FTGL class.
485
486void TGLFontManager::RegisterFont(Int_t sizeIn, Int_t fileID, TGLFont::EMode mode, TGLFont &out)
487{
488 if (fgStaticInitDone == kFALSE)
489 InitStatics();
490
491 Int_t size = GetFontSize(sizeIn);
492 if (mode == out.GetMode() && fileID == out.GetFile() && size == out.GetSize())
493 return;
494
495 FontMap_i it = fFontMap.find(TGLFont(size, fileID, mode));
496 if (it == fFontMap.end())
497 {
498 TString ttpath = gEnv->GetValue("Root.TTGLFontPath", TROOT::GetTTFFontDir());
499 TString file = fgFontFileArray[fileID]->GetName();
500 if (fileID < fgExtendedFontStart)
501 file += ".ttf";
502 gSystem->FindFile(ttpath, file);
503 if (file.IsNull()) {
504 Error("RegisterFont", "File for font id %d not found", fileID);
505 return;
506 }
507
508 FTFont* ftfont = nullptr;
509 switch (mode)
510 {
511 case TGLFont::kBitmap:
512 ftfont = new FTGLBitmapFont(file);
513 break;
514 case TGLFont::kPixmap:
515 ftfont = new FTGLPixmapFont(file);
516 break;
517 case TGLFont::kOutline:
518 ftfont = new FTGLOutlineFont(file);
519 break;
520 case TGLFont::kPolygon:
521 ftfont = new FTGLPolygonFont(file);
522 break;
523 case TGLFont::kExtrude:
524 ftfont = new FTGLExtrdFont(file);
525 ftfont->Depth(0.2*size);
526 break;
527 case TGLFont::kTexture:
528 ftfont = new FTGLTextureFont(file);
529 break;
530 default:
531 Error("RegisterFont", "invalid FTGL type");
532 return;
533 }
534 ftfont->FaceSize(size);
535 const TGLFont &mf = fFontMap.insert(std::make_pair(TGLFont(size, fileID, mode, ftfont, 0), 1)).first->first;
536 out.CopyAttributes(mf);
537 }
538 else
539 {
540 if (it->first.GetTrashCount() > 0) {
541 fFontTrash.remove(&(it->first));
542 it->first.SetTrashCount(0);
543 }
544 ++(it->second);
545 out.CopyAttributes(it->first);
546 }
547 out.SetManager(this);
548}
549
550////////////////////////////////////////////////////////////////////////////////
551/// Get mapping from ttf id to font names. Table taken from TTF.cxx.
552
553void TGLFontManager::RegisterFont(Int_t size, const char* name, TGLFont::EMode mode, TGLFont &out)
554{
555 TObjArray* farr = GetFontFileArray();
556 TIter next(farr);
557 TObjString* os;
558 Int_t cnt = 0;
559 while ((os = (TObjString*) next()) != 0)
560 {
561 if (os->String() == name)
562 break;
563 cnt++;
564 }
565
566 if (cnt < farr->GetEntries())
567 RegisterFont(size, cnt, mode, out);
568 else
569 Error("TGLFontManager::RegisterFont", "unknown font name %s", name);
570}
571
572////////////////////////////////////////////////////////////////////////////////
573/// Release font with given attributes. Returns false if font has
574/// not been found in the managers font set.
575
576void TGLFontManager::ReleaseFont(TGLFont& font)
577{
578 FontMap_i it = fFontMap.find(font);
579
580 if (it != fFontMap.end())
581 {
582 --(it->second);
583 if (it->second == 0)
584 {
585 assert(it->first.GetTrashCount() == 0);
586 it->first.IncTrashCount();
587 fFontTrash.push_back(&it->first);
588 }
589 }
590}
591
592////////////////////////////////////////////////////////////////////////////////
593/// Get id to file name map.
594
600
601////////////////////////////////////////////////////////////////////////////////
602/// Get valid font size vector.
603
609
610////////////////////////////////////////////////////////////////////////////////
611
612Int_t TGLFontManager::GetExtendedFontStartIndex()
613{
614 if (fgStaticInitDone == kFALSE) InitStatics();
615
616 assert(fgExtendedFontStart > 0 && "GetExtendedFontStartIndex, invalid index");
617
618 return fgExtendedFontStart;
619}
620
621////////////////////////////////////////////////////////////////////////////////
622/// Get availabe font size.
623
624Int_t TGLFontManager::GetFontSize(Int_t ds)
625{
626 if (fgStaticInitDone == kFALSE) InitStatics();
627
628 Int_t idx = TMath::BinarySearch(fgFontSizeArray.size(), &fgFontSizeArray[0],
629 TMath::CeilNint(ds));
630
631 if (idx < 0) idx = 0;
632 return fgFontSizeArray[idx];
633}
634
635////////////////////////////////////////////////////////////////////////////////
636/// Get availabe font size.
637
638Int_t TGLFontManager::GetFontSize(Int_t ds, Int_t min, Int_t max)
639{
640 if (ds < min) ds = min;
641 if (ds > max) ds = max;
642 return GetFontSize(ds);
643}
644
645////////////////////////////////////////////////////////////////////////////////
646/// Get font name from TAttAxis font id.
647
648const char* TGLFontManager::GetFontNameFromId(Int_t id)
649{
650 if (fgStaticInitDone == kFALSE) InitStatics();
651
652 Int_t fontIndex = id / 10;
653
654 if (fontIndex > fgFontFileArray.GetEntries() || !fontIndex)
655 fontIndex = 5;//arialbd
656 else
657 fontIndex -= 1;
658
659 TObjString* os = (TObjString*)fgFontFileArray[fontIndex];
660 return os->String().Data();
661}
662
663////////////////////////////////////////////////////////////////////////////////
664/// Create a list of available font files and allowed font sizes.
665
666void TGLFontManager::InitStatics()
667{
668 fgFontFileArray.Add(new TObjString("timesi")); // 10
669 fgFontFileArray.Add(new TObjString("timesbd")); // 20
670 fgFontFileArray.Add(new TObjString("timesbi")); // 30
671
672 fgFontFileArray.Add(new TObjString("arial")); // 40
673 fgFontFileArray.Add(new TObjString("ariali")); // 50
674 fgFontFileArray.Add(new TObjString("arialbd")); // 60
675 fgFontFileArray.Add(new TObjString("arialbi")); // 70
676
677 fgFontFileArray.Add(new TObjString("cour")); // 80
678 fgFontFileArray.Add(new TObjString("couri")); // 90
679 fgFontFileArray.Add(new TObjString("courbd")); // 100
680 fgFontFileArray.Add(new TObjString("courbi")); // 110
681
682 fgFontFileArray.Add(new TObjString("symbol")); // 120
683 fgFontFileArray.Add(new TObjString("times")); // 130
684 fgFontFileArray.Add(new TObjString("wingding")); // 140
685 fgFontFileArray.Add(new TObjString("symbol")); // 150
686
687 fgExtendedFontStart = fgFontFileArray.GetEntries();
688 //"Extended" fonts for gl-pad.
689 //fgPadFontStart + ...
690 fgFontFileArray.Add(new TObjString("FreeSerifItalic.otf")); // 10 (160)
691 fgFontFileArray.Add(new TObjString("FreeSerifBold.otf")); // 20 (170)
692 fgFontFileArray.Add(new TObjString("FreeSerifBoldItalic.otf")); // 30
693
694 fgFontFileArray.Add(new TObjString("FreeSans.otf")); // 40
695 fgFontFileArray.Add(new TObjString("FreeSansOblique.otf")); // 50
696 fgFontFileArray.Add(new TObjString("FreeSansBold.otf")); // 60
697 fgFontFileArray.Add(new TObjString("FreeSansBoldOblique.otf")); // 70
698
699 fgFontFileArray.Add(new TObjString("FreeMono.otf")); // 80
700 fgFontFileArray.Add(new TObjString("FreeMonoOblique.otf")); // 90
701 fgFontFileArray.Add(new TObjString("FreeMonoBold.otf")); // 100
702 fgFontFileArray.Add(new TObjString("FreeMonoBoldOblique.otf")); // 110
703
704 fgFontFileArray.Add(new TObjString("symbol.ttf")); // 120
705 fgFontFileArray.Add(new TObjString("FreeSerif.otf")); // 130
706 fgFontFileArray.Add(new TObjString("wingding.ttf")); // 140
707 fgFontFileArray.Add(new TObjString("symbol.ttf")); // 150
708
709 fgFontFileArray.Add(new TObjString("STIXGeneral.otf")); // 200
710 fgFontFileArray.Add(new TObjString("STIXGeneralItalic.otf")); // 210
711 fgFontFileArray.Add(new TObjString("STIXGeneralBol.otf")); // 220
712 fgFontFileArray.Add(new TObjString("STIXGeneralBolIta.otf")); // 230
713
714 fgFontFileArray.Add(new TObjString("STIXSiz1Sym.otf")); // 240
715 fgFontFileArray.Add(new TObjString("STIXSiz1SymBol.otf")); // 250
716 fgFontFileArray.Add(new TObjString("STIXSiz2Sym.otf")); // 260
717 fgFontFileArray.Add(new TObjString("STIXSiz2SymBol.otf")); // 270
718
719 fgFontFileArray.Add(new TObjString("STIXSiz3Sym.otf")); // 280
720 fgFontFileArray.Add(new TObjString("STIXSiz3SymBol.otf")); // 290
721 fgFontFileArray.Add(new TObjString("STIXSiz4Sym.otf")); // 300
722 fgFontFileArray.Add(new TObjString("STIXSiz4SymBol.otf")); // 310
723
724 fgFontFileArray.Add(new TObjString("STIXSiz5Sym.otf")); // 320
725 fgFontFileArray.Add(new TObjString("DroidSansFallback.ttf")); // 330
726 fgFontFileArray.Add(new TObjString("DroidSansFallback.ttf")); // 340
727 fgFontFileArray.Add(new TObjString("DroidSansFallback.ttf")); // 350
728
729 for (Int_t i = 10; i <= 20; i+=2)
730 fgFontSizeArray.push_back(i);
731 for (Int_t i = 24; i <= 64; i+=4)
732 fgFontSizeArray.push_back(i);
733 for (Int_t i = 72; i <= 128; i+=8)
734 fgFontSizeArray.push_back(i);
735
736 fgStaticInitDone = kTRUE;
737}
738
739////////////////////////////////////////////////////////////////////////////////
740/// Delete FTFFont objects registered for destruction.
741
742void TGLFontManager::ClearFontTrash()
743{
744 FontList_i it = fFontTrash.begin();
745 while (it != fFontTrash.end())
746 {
747 if ((*it)->IncTrashCount() > 10000)
748 {
749 FontMap_i mi = fFontMap.find(**it);
750 assert(mi != fFontMap.end());
751 fFontMap.erase(mi);
752 delete (*it)->GetFont();
753
754 FontList_i li = it++;
755 fFontTrash.erase(li);
756 }
757 else
758 {
759 ++it;
760 }
761 }
762}
f
#define f(i)
Definition RSha256.hxx:104
size
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
Int_t
int Int_t
Signed integer 4 bytes (int).
Definition RtypesCore.h:59
UInt_t
unsigned int UInt_t
Unsigned integer 4 bytes (unsigned int).
Definition RtypesCore.h:60
Bool_t
bool Bool_t
Boolean (0=false, 1=true) (bool).
Definition RtypesCore.h:77
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
Double_t
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
Float_t
float Float_t
Float 4 bytes (float).
Definition RtypesCore.h:71
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
Error
Error("WriteTObject","The current directory (%s) is not associated with a file. The object (%s) has not been written.", GetName(), objname)
gEnv
externTEnv * gEnv
Definition TEnv.h:170
Warning
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:252
name
char name[80]
Definition TGX11.cxx:148
gSystem
externTSystem * gSystem
Definition TSystem.h:582
gVirtualX
#define gVirtualX
Definition TVirtualX.h:375
TGLFontManager
A FreeType GL font manager.
Definition TGLFontManager.h:124
TGLFontManager::~TGLFontManager
virtual ~TGLFontManager()
Destructor.
Definition TGLFontManager.cxx:473
TGLFontManager::fgFontFileArray
static TObjArray fgFontFileArray
Definition TGLFontManager.h:143
TGLFontManager::RegisterFont
void RegisterFont(Int_t size, Int_t file, TGLFont::EMode mode, TGLFont &out)
Provide font with given size, file and FTGL class.
Definition TGLFontManager.cxx:486
TGLFontManager::GetFontSize
static Int_t GetFontSize(Int_t ds)
Get availabe font size.
Definition TGLFontManager.cxx:624
TGLFontManager::InitStatics
static void InitStatics()
Create a list of available font files and allowed font sizes.
Definition TGLFontManager.cxx:666
TGLFontManager::GetExtendedFontStartIndex
static Int_t GetExtendedFontStartIndex()
Definition TGLFontManager.cxx:612
TGLFontManager::fgStaticInitDone
static Bool_t fgStaticInitDone
Definition TGLFontManager.h:148
TGLFontManager::fgFontSizeArray
static FontSizeVec_t fgFontSizeArray
Definition TGLFontManager.h:147
TGLFontManager::fgExtendedFontStart
static Int_t fgExtendedFontStart
Definition TGLFontManager.h:145
TGLFontManager::GetFontSizeArray
static FontSizeVec_t * GetFontSizeArray()
Get valid font size vector.
Definition TGLFontManager.cxx:604
TGLFontManager::FontList_i
std::list< constTGLFont * >::iterator FontList_i
Definition TGLFontManager.h:137
TGLFontManager::ClearFontTrash
void ClearFontTrash()
Delete FTFFont objects registered for destruction.
Definition TGLFontManager.cxx:742
TGLFontManager::FontMap_i
std::map< TGLFont, Int_t >::iterator FontMap_i
Definition TGLFontManager.h:134
TGLFontManager::FontSizeVec_t
std::vector< Int_t > FontSizeVec_t
Definition TGLFontManager.h:126
TGLFontManager::GetFontNameFromId
static const char * GetFontNameFromId(Int_t)
Get font name from TAttAxis font id.
Definition TGLFontManager.cxx:648
TGLFontManager::GetFontFileArray
static TObjArray * GetFontFileArray()
Get id to file name map.
Definition TGLFontManager.cxx:595
TGLFontManager::ReleaseFont
void ReleaseFont(TGLFont &font)
Release font with given attributes.
Definition TGLFontManager.cxx:576
TGLFontManager::fFontTrash
FontList_t fFontTrash
Definition TGLFontManager.h:141
TGLFont
A wrapper class for FTFont.
Definition TGLFontManager.h:24
TGLFont::MeasureBaseLineParams
void MeasureBaseLineParams(Float_t &ascent, Float_t &descent, Float_t &line_height, const char *txt="Xj") const
Measure font's base-line parameters from the passed text.
Definition TGLFontManager.cxx:160
TGLFont::GetDescent
Float_t GetDescent() const
Get font's descent. The returned value is positive.
Definition TGLFontManager.cxx:142
TGLFont::~TGLFont
virtual ~TGLFont()
Destructor.
Definition TGLFontManager.cxx:106
TGLFont::GetAscent
Float_t GetAscent() const
Get font's ascent.
Definition TGLFontManager.cxx:134
TGLFont::GetMode
EMode GetMode() const
Definition TGLFontManager.h:64
TGLFont::SetManager
void SetManager(TGLFontManager *mng)
Definition TGLFontManager.h:72
TGLFont::SetFont
void SetFont(FTFont *f)
Definition TGLFontManager.h:70
TGLFont::GetLineHeight
Float_t GetLineHeight() const
Get font's line-height.
Definition TGLFontManager.cxx:150
TGLFont::fMode
EMode fMode
Definition TGLFontManager.h:50
TGLFont::Advance
Float_t Advance(const char *txt) const
Get advance.
Definition TGLFontManager.cxx:201
TGLFont::GetSize
Int_t GetSize() const
Definition TGLFontManager.h:62
TGLFont::GetFont
const FTFont * GetFont() const
Definition TGLFontManager.h:71
TGLFont::RenderHelper
void RenderHelper(const Char *txt, Double_t x, Double_t y, Double_t angle, Double_t) const
mgn is simply ignored, because ROOT's TVirtualX TGX11 are complete mess with painting attributes.
Definition TGLFontManager.cxx:216
TGLFont::fFont
FTFont * fFont
Definition TGLFontManager.h:39
TGLFont::fManager
TGLFontManager * fManager
Definition TGLFontManager.h:40
TGLFont::GetFile
Int_t GetFile() const
Definition TGLFontManager.h:63
TGLFont::fTextAlign
UInt_t fTextAlign
Definition TGLFontManager.h:51
TGLFont::BBox
void BBox(const char *txt, Float_t &llx, Float_t &lly, Float_t &llz, Float_t &urx, Float_t &ury, Float_t &urz) const
Get bounding box.
Definition TGLFontManager.cxx:177
TGLFont::fTrashCount
Int_t fTrashCount
Definition TGLFontManager.h:53
TGLFont::fDepth
Float_t fDepth
Definition TGLFontManager.h:42
TGLFont::Render
void Render(const char *txt, Double_t x, Double_t y, Double_t angle, Double_t mgn) const
Definition TGLFontManager.cxx:292
TGLFont::PostRender
virtual void PostRender() const
Reset GL state after FTFont rendering.
Definition TGLFontManager.cxx:451
TGLFont::SetDepth
void SetDepth(Float_t d)
Definition TGLFontManager.h:76
TGLFont::PreRender
virtual void PreRender(Bool_t autoLight=kTRUE, Bool_t lightOn=kFALSE) const
Set-up GL state before FTFont rendering.
Definition TGLFontManager.cxx:410
TGLFont::fSize
Int_t fSize
Definition TGLFontManager.h:48
TGLFont::TGLFont
TGLFont()
Constructor.
Definition TGLFontManager.cxx:71
TGLFont::CopyAttributes
void CopyAttributes(const TGLFont &o)
Assignment operator.
Definition TGLFontManager.cxx:114
TGLFont::fFile
Int_t fFile
Definition TGLFontManager.h:49
TObjArray
An array of TObjects.
Definition TObjArray.h:31
TObjString
Collectable string class.
Definition TObjString.h:28
TObjString::String
TString & String()
Definition TObjString.h:48
TString
Basic string class.
Definition TString.h:138
TString::Data
const char * Data() const
Definition TString.h:384
TString::IsNull
Bool_t IsNull() const
Definition TString.h:422
TString::Append
TString & Append(const char *cs)
Definition TString.h:581
y
Double_t y[n]
Definition legend1.C:17
x
Double_t x[n]
Definition legend1.C:17
TMath::CeilNint
Int_t CeilNint(Double_t x)
Returns the nearest integer of TMath::Ceil(x).
Definition TMath.h:685
TMath::BinarySearch
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Binary search in an array of n values to locate value.
Definition TMathBase.h:329