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