// @(#)root/x11ttf:$Id: 80028b538e60290371c1c5d73728f78b1c32f09a $
// Author: Valeriy Onuchin (Xft support)  02/10/07
// Author: Olivier Couet     01/10/02
// Author: Fons Rademakers   21/11/98

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGX11TTF                                                             //
//                                                                      //
// Interface to low level X11 (Xlib). This class gives access to basic  //
// X11 graphics via the parent class TGX11. However, all text and font  //
// handling is done via the Freetype TrueType library. When the         //
// shared library containing this class is loaded the global gVirtualX  //
// is redirected to point to this class.                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <stdlib.h>

#  include <ft2build.h>
#  include FT_FREETYPE_H
#  include FT_GLYPH_H
#include "TGX11TTF.h"
#include "TClass.h"
#include "TEnv.h"

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/cursorfont.h>
#include <X11/keysym.h>
#include <X11/xpm.h>

struct RXColor:XColor{};
struct RVisual:Visual{};
struct RXImage:XImage{};

#ifdef R__HAS_XFT

#include "THashTable.h"
#include "TRefCnt.h"
#include <X11/Xft/Xft.h>

/////////////////////////  xft font data //////////////////////////////////////
class TXftFontData : public TNamed, public TRefCnt {
public:
   XFontStruct   *fFontStruct;   // fontstruct
   XftFont       *fXftFont;      // xft font

   TXftFontData(FontStruct_t font, XftFont *xftfont, const char *name) :
      TNamed(name, ""), TRefCnt(), fXftFont(xftfont)
   {
      SetRefCount(1);
      fFontStruct = (XFontStruct*)font;
   }

   ~TXftFontData()
   {
      if (fFontStruct) ((TGX11*)gVirtualX)->DeleteFont((FontStruct_t)fFontStruct);
      if (fXftFont) XftFontClose((Display*)gVirtualX->GetDisplay(), fXftFont);
   }
};

/////////////////// hash table //////////////////////////////////////////////
class TXftFontHash {
public:
   THashTable  *fList;  // hash table

   TXftFontHash() { fList = new THashTable(50); }

   TXftFontData *FindByName(const char *name)
   {
      return (TXftFontData*)fList->FindObject(name);
   }

   TXftFontData *FindByStruct(FontStruct_t font)
   {
      TIter next(fList);
      TXftFontData *d = 0;

      while ((d = (TXftFontData*) next())) {
         if (d->fFontStruct == (XFontStruct*)font) {
            return d;
         }
      }
      return 0;
   }

   TXftFontData *FindByHandle(FontH_t id)
   {
      TIter next(fList);
      TXftFontData *d = 0;

      while ((d = (TXftFontData*) next())) {
         if (d->fFontStruct->fid == id) {
            return d;
         }
      }
      return 0;
   }

   void AddFont(TXftFontData *data)
   {
      fList->Add(data);
   }

   void FreeFont(TXftFontData *data)
   {
      if (data->RemoveReference() > 0)  return;
      fList->Remove(data);
      delete data;
   }
};
#endif  // R__HAS_XFT

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTFX11Init                                                           //
//                                                                      //
// Small utility class that takes care of switching the current         //
// gVirtualX to the new TGX11TTF class as soon as the shared library    //
// containing this class is loaded.                                     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TTFX11Init {
public:
   TTFX11Init() { TGX11TTF::Activate(); }
};
static TTFX11Init gTTFX11Init;


ClassImp(TGX11TTF)

//______________________________________________________________________________
TGX11TTF::TGX11TTF(const TGX11 &org) : TGX11(org)
{
   // Create copy of TGX11 but now use TrueType fonts.

   SetName("X11TTF");
   SetTitle("ROOT interface to X11 with TrueType fonts");

   if (!TTF::fgInit) TTF::Init();

   fHasTTFonts = kTRUE;
   fAlign.x = 0;
   fAlign.y = 0;

#ifdef R__HAS_XFT
   fXftFontHash = 0;
   if (gEnv->GetValue("X11.UseXft", 0)) {
      fXftFontHash = new TXftFontHash();
   }
#endif
}

//______________________________________________________________________________
void TGX11TTF::Activate()
{
   // Static method setting TGX11TTF as the acting gVirtualX.

   if (gVirtualX && dynamic_cast<TGX11*>(gVirtualX)) {
      TGX11 *oldg = (TGX11 *) gVirtualX;
      gVirtualX = new TGX11TTF(*oldg);
      delete oldg;
   }
}

//______________________________________________________________________________
Bool_t TGX11TTF::Init(void *display)
{
   // Initialize X11 system. Returns kFALSE in case of failure.

   Bool_t r = TGX11::Init(display);

   if (fDepth > 8) {
      TTF::SetSmoothing(kTRUE);
   } else {
      TTF::SetSmoothing(kFALSE);
   }

   return r;
}

//______________________________________________________________________________
void TGX11TTF::Align(void)
{
   // Compute alignment variables. The alignment is done on the horizontal string
   // then the rotation is applied on the alignment variables.
   // SetRotation and LayoutGlyphs should have been called before.

   EAlign align = (EAlign) fTextAlign;

   // vertical alignment
   if (align == kTLeft || align == kTCenter || align == kTRight) {
      fAlign.y = TTF::fgAscent;
   } else if (align == kMLeft || align == kMCenter || align == kMRight) {
      fAlign.y = TTF::fgAscent/2;
   } else {
      fAlign.y = 0;
   }

   // horizontal alignment
   if (align == kTRight || align == kMRight || align == kBRight) {
      fAlign.x = TTF::fgWidth;
   } else if (align == kTCenter || align == kMCenter || align == kBCenter) {
      fAlign.x = TTF::fgWidth/2;
   } else {
      fAlign.x = 0;
   }

   FT_Vector_Transform(&fAlign, TTF::fgRotMatrix);
   fAlign.x = fAlign.x >> 6;
   fAlign.y = fAlign.y >> 6;
}

//______________________________________________________________________________
void TGX11TTF::DrawImage(FT_Bitmap *source, ULong_t fore, ULong_t back,
                         RXImage *xim, Int_t bx, Int_t by)
{
   // Draw FT_Bitmap bitmap to xim image at position bx,by using specified
   // foreground color.

   UChar_t d = 0, *s = source->buffer;

   if (TTF::fgSmoothing) {

      static RXColor col[5];
      RXColor  *bcol = 0;
      XColor  *bc;
      Int_t    x, y;

      // background kClear, i.e. transparent, we take as background color
      // the average of the rgb values of all pixels covered by this character
      if (back == (ULong_t) -1 && (UInt_t)source->width) {
         ULong_t r, g, b;
         Int_t   dots, dotcnt;
         const Int_t maxdots = 50000;

         dots = Int_t(source->width * source->rows);
         dots = dots > maxdots ? maxdots : dots;
         bcol = new RXColor[dots];
         if (!bcol) return;
         bc = bcol;
         dotcnt = 0;
         for (y = 0; y < (int) source->rows; y++) {
            for (x = 0; x < (int) source->width; x++, bc++) {
///               bc->pixel = XGetPixel(xim, bx + x, by - c->TTF::fgAscent + y);
               bc->pixel = XGetPixel(xim, bx + x, by + y);
               bc->flags = DoRed | DoGreen | DoBlue;
               if (++dotcnt >= maxdots) break;
            }
         }
         QueryColors(fColormap, bcol, dots);
         r = g = b = 0;
         bc = bcol;
         dotcnt = 0;
         for (y = 0; y < (int) source->rows; y++) {
            for (x = 0; x < (int) source->width; x++, bc++) {
               r += bc->red;
               g += bc->green;
               b += bc->blue;
               if (++dotcnt >= maxdots) break;
            }
         }
         if (dots != 0) {
            r /= dots;
            g /= dots;
            b /= dots;
         }
         bc = &col[0];
         if (bc->red == r && bc->green == g && bc->blue == b)
            bc->pixel = back;
         else {
            bc->pixel = ~back;
            bc->red   = (UShort_t) r;
            bc->green = (UShort_t) g;
            bc->blue  = (UShort_t) b;
         }
      }
      delete [] bcol;

      // if fore or background have changed from previous character
      // recalculate the 3 smooting colors (interpolation between fore-
      // and background colors)
      if (fore != col[4].pixel || back != col[0].pixel) {
         col[4].pixel = fore;
         col[4].flags = DoRed|DoGreen|DoBlue;
         if (back != (ULong_t) -1) {
            col[3].pixel = back;
            col[3].flags = DoRed | DoGreen | DoBlue;
            QueryColors(fColormap, &col[3], 2);
            col[0] = col[3];
         } else {
            QueryColors(fColormap, &col[4], 1);
         }

         // interpolate between fore and backgound colors
         for (x = 3; x > 0; x--) {
            col[x].red   = (col[4].red  *x + col[0].red  *(4-x)) /4;
            col[x].green = (col[4].green*x + col[0].green*(4-x)) /4;
            col[x].blue  = (col[4].blue *x + col[0].blue *(4-x)) /4;
            if (!AllocColor(fColormap, &col[x])) {
               Warning("DrawImage", "cannot allocate smoothing color");
               col[x].pixel = col[x+1].pixel;
            }
         }
      }

      // put smoothed character, character pixmap values are an index
      // into the 5 colors used for aliasing (4 = foreground, 0 = background)
      for (y = 0; y < (int) source->rows; y++) {
         for (x = 0; x < (int) source->width; x++) {
            d = *s++ & 0xff;
            d = ((d + 10) * 5) / 256;
            if (d > 4) d = 4;
            if (d && x < (int) source->width) {
               ULong_t p = col[d].pixel;
               XPutPixel(xim, bx + x, by + y, p);
            }
         }
      }
   } else {
      // no smoothing, just put character using foreground color
      UChar_t* row=s;
      for (int y = 0; y < (int) source->rows; y++) {
         int n = 0;
         s = row;
         for (int x = 0; x < (int) source->width; x++) {
            if (n == 0) d = *s++;
            if (TESTBIT(d,7-n))
               XPutPixel(xim, bx + x, by + y, fore);
            if (++n == (int) kBitsPerByte) n = 0;
         }
         row += source->pitch;
      }
   }
}

//______________________________________________________________________________
void TGX11TTF::DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,
                        const char *text, ETextMode mode)
{
   // Draw text using TrueType fonts. If TrueType fonts are not available the
   // text is drawn with TGX11::DrawText.

   if (!fHasTTFonts) {
      TGX11::DrawText(x, y, angle, mgn, text, mode);
   } else {
      if (!TTF::fgInit) TTF::Init();
      TTF::SetRotationMatrix(angle);
      TTF::PrepareString(text);
      TTF::LayoutGlyphs();
      Align();
      RenderString(x, y, mode);
   }
}

//______________________________________________________________________________
void TGX11TTF::DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,
                        const wchar_t *text, ETextMode mode)
{
   // Draw text using TrueType fonts. If TrueType fonts are not available the
   // text is drawn with TGX11::DrawText.

   if (!fHasTTFonts) {
      TGX11::DrawText(x, y, angle, mgn, text, mode);
   } else {
      if (!TTF::fgInit) TTF::Init();
      TTF::SetRotationMatrix(angle);
      TTF::PrepareString(text);
      TTF::LayoutGlyphs();
      Align();
      RenderString(x, y, mode);
   }
}

//______________________________________________________________________________
RXImage *TGX11TTF::GetBackground(Int_t x, Int_t y, UInt_t w, UInt_t h)
{
   // Get the background of the current window in an XImage.

   Window_t cws = GetCurrentWindow();
   UInt_t width;
   UInt_t height;
   Int_t xy;
   gVirtualX->GetWindowSize(cws, xy, xy, width, height);

   if (x < 0) {
      w += x;
      x  = 0;
   }
   if (y < 0) {
      h += y;
      y  = 0;
   }

   if (x+w > width)  w = width - x;
   if (y+h > height) h = height - y;

   return (RXImage*)XGetImage((Display*)fDisplay, cws, x, y, w, h, AllPlanes, ZPixmap);
}

//______________________________________________________________________________
Bool_t TGX11TTF::IsVisible(Int_t x, Int_t y, UInt_t w, UInt_t h)
{
   // Test if there is really something to render.

   Window_t cws = GetCurrentWindow();
   UInt_t width;
   UInt_t height;
   Int_t xy;
   gVirtualX->GetWindowSize(cws, xy, xy, width, height);

   // If w or h is 0, very likely the string is only blank characters
   if ((int)w == 0 || (int)h == 0)  return kFALSE;

   // If string falls outside window, there is probably no need to draw it.
   if (x + (int)w <= 0 || x >= (int)width)  return kFALSE;
   if (y + (int)h <= 0 || y >= (int)height) return kFALSE;

   // If w or h are much larger than the window size, there is probably no need
   // to draw it. Moreover a to large text size may produce a Seg Fault in
   // malloc in RenderString.
   if (w > 10*width)  return kFALSE;
   if (h > 10*height) return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
void TGX11TTF::RenderString(Int_t x, Int_t y, ETextMode mode)
{
   // Perform the string rendering in the pad.
   // LayoutGlyphs should have been called before.

   TTGlyph* glyph = TTF::fgGlyphs;
   GC *gc;

   // compute the size and position of the XImage that will contain the text
   Int_t Xoff = 0; if (TTF::GetBox().xMin < 0) Xoff = -TTF::GetBox().xMin;
   Int_t Yoff = 0; if (TTF::GetBox().yMin < 0) Yoff = -TTF::GetBox().yMin;
   Int_t w    = TTF::GetBox().xMax + Xoff;
   Int_t h    = TTF::GetBox().yMax + Yoff;
   Int_t x1   = x-Xoff-fAlign.x;
   Int_t y1   = y+Yoff+fAlign.y-h;

   if (!IsVisible(x1, y1, w, h)) return;

   // create the XImage that will contain the text
   UInt_t depth = fDepth;
   XImage *xim  = 0;
   xim = XCreateImage((Display*)fDisplay, fVisual,
                      depth, ZPixmap, 0, 0, w, h,
                      depth == 24 ? 32 : (depth==15?16:depth), 0);
   if (!xim) return;

   // use malloc since Xlib will use free() in XDestroyImage
   xim->data = (char *) malloc(xim->bytes_per_line * h);
   memset(xim->data, 0, xim->bytes_per_line * h);

   ULong_t   bg;
   XGCValues values;
   gc = (GC*)GetGC(3);
   if (!gc) {
      Error("DrawText", "error getting Graphics Context");
      return;
   }
   XGetGCValues((Display*)fDisplay, *gc, GCForeground | GCBackground, &values);

   // get the background
   if (mode == kClear) {
      // if mode == kClear we need to get an image of the background
      XImage *bim = GetBackground(x1, y1, w, h);
      if (!bim) {
         Error("DrawText", "error getting background image");
         return;
      }

      // and copy it into the text image
      Int_t xo = 0, yo = 0;
      if (x1 < 0) xo = -x1;
      if (y1 < 0) yo = -y1;

      for (int yp = 0; yp < (int) bim->height; yp++) {
         for (int xp = 0; xp < (int) bim->width; xp++) {
            ULong_t pixel = XGetPixel(bim, xp, yp);
            XPutPixel(xim, xo+xp, yo+yp, pixel);
         }
      }
      XDestroyImage(bim);
      bg = (ULong_t) -1;
   } else {
      // if mode == kOpaque its simple, we just draw the background
      XAddPixel(xim, values.background);
      bg = values.background;
   }

   // paint the glyphs in the XImage
   glyph = TTF::fgGlyphs;
   for (int n = 0; n < TTF::fgNumGlyphs; n++, glyph++) {
      if (FT_Glyph_To_Bitmap(&glyph->fImage,
                             TTF::fgSmoothing ? ft_render_mode_normal
                                              : ft_render_mode_mono,
                             0, 1 )) continue;
      FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph->fImage;
      FT_Bitmap*     source = &bitmap->bitmap;
      Int_t          bx, by;

      bx = bitmap->left+Xoff;
      by = h - bitmap->top-Yoff;
      DrawImage(source, values.foreground, bg, (RXImage*)xim, bx, by);
   }

   // put the Ximage on the screen
   Window_t cws = GetCurrentWindow();
   gc = (GC*)GetGC(6);
   if (gc) XPutImage((Display*)fDisplay, cws, *gc, xim, 0, 0, x1, y1, w, h);
   XDestroyImage(xim);
}

//______________________________________________________________________________
void TGX11TTF::SetTextFont(Font_t fontnumber)
{
   // Set specified font.

   fTextFont = fontnumber;
   if (!fHasTTFonts) {
      TGX11::SetTextFont(fontnumber);
   } else {
      TTF::SetTextFont(fontnumber);
   }
}

//______________________________________________________________________________
Int_t TGX11TTF::SetTextFont(char *fontname, ETextSetMode mode)
{
   // Set text font to specified name.
   // mode       : loading flag
   // mode=0     : search if the font exist (kCheck)
   // mode=1     : search the font and load it if it exists (kLoad)
   // font       : font name
   //
   // Set text font to specified name. This function returns 0 if
   // the specified font is found, 1 if not.

   if (!fHasTTFonts) {
      return TGX11::SetTextFont(fontname, mode);
   } else {
      return TTF::SetTextFont(fontname);
   }
}

//______________________________________________________________________________
void TGX11TTF::SetTextSize(Float_t textsize)
{
   // Set current text size.

   fTextSize = textsize;
   if (!fHasTTFonts) {
      TGX11::SetTextSize(textsize);
   } else {
      TTF::SetTextSize(textsize);
   }
}

#ifdef R__HAS_XFT

///////////////////////////// Xft font methods /////////////////////////////////
//______________________________________________________________________________
FontStruct_t TGX11TTF::LoadQueryFont(const char *font_name)
{
   // Parses an XLFD name and opens a font.

   if (!fXftFontHash) {
      return TGX11::LoadQueryFont(font_name);
   }

   TXftFontData *data = fXftFontHash->FindByName(font_name);

   // already loaded
   if (data) {
      data->AddReference();
      return (FontStruct_t)data->fFontStruct;
   }

   // load both X11 and Xft fonts
   FontStruct_t font = TGX11::LoadQueryFont(font_name);

   if (!font) {
      return font;
   }

   XftFont *xftfont = XftFontOpenXlfd((Display*)fDisplay, fScreenNumber, font_name);

   data = new TXftFontData(font, xftfont, font_name);
   fXftFontHash->AddFont(data);

   return font;
}

//______________________________________________________________________________
void TGX11TTF::DeleteFont(FontStruct_t fs)
{
   // Explicitely delete font structure obtained with LoadQueryFont().

   if (!fXftFontHash) {
      TGX11::DeleteFont(fs);
      return;
   }

   TXftFontData *data = fXftFontHash->FindByStruct(fs);

   if (!data) {
      TGX11::DeleteFont(fs);
      return;
   }

   fXftFontHash->FreeFont(data);
}

//______________________________________________________________________________
Int_t TGX11TTF::TextWidth(FontStruct_t font, const char *s, Int_t len)
{
   // Return length of string in pixels. Size depends on font

   if (!fXftFontHash) {
      return TGX11::TextWidth(font, s, len);
   }

   TXftFontData *data = fXftFontHash->FindByStruct(font);

   if (!data) {
      return TGX11::TextWidth(font, s, len);
   }

   XftFont *xftfont = data->fXftFont;

   if (!xftfont) {
      return TGX11::TextWidth(font, s, len);
   }

   XGlyphInfo glyph_info;
   XftTextExtents8((Display*)fDisplay, xftfont, (XftChar8 *)s, len, &glyph_info);

   return glyph_info.xOff;
}

//______________________________________________________________________________
void TGX11TTF::GetFontProperties(FontStruct_t font, Int_t &max_ascent, Int_t &max_descent)
{
   //  Return some font properties

   if (!fXftFontHash) {
      TGX11::GetFontProperties(font, max_ascent, max_descent);
      return;
   }

   TXftFontData *data = fXftFontHash->FindByStruct(font);

   if (!data) {
      TGX11::GetFontProperties(font, max_ascent, max_descent);
      return;
   }

   XftFont *xftfont = data->fXftFont;

   if (!xftfont) {
      TGX11::GetFontProperties(font, max_ascent, max_descent);
      return;
   }

   max_ascent = xftfont->ascent;
   max_descent = xftfont->descent;
}

//______________________________________________________________________________
void TGX11TTF::DrawString(Drawable_t xwindow, GContext_t gc, Int_t x, Int_t y,
                          const char *text, Int_t len)
{
   // Draw text string

   XftDraw  *xftdraw;
   XftColor  xftcolor;
   XColor    xcolor;
   XftFont  *xftfont;

   if (!xwindow)  {
      return;
   }

   if (!gc) {
      return;
   }

   if (!text || (len < 1) || !text[0]) {
      return;
   }

   if (!fXftFontHash) {
      TGX11::DrawString(xwindow, gc, x, y, text, len);
      return;
   }

   GCValues_t gval;
   gval.fMask = kGCForeground | kGCBackground | kGCFont;  // retrieve GC values
   GetGCValues(gc, gval);

   TXftFontData *data = fXftFontHash->FindByHandle(gval.fFont);

   // no XftFont data
   if (!data) {
      TGX11::DrawString(xwindow, gc, x, y, text, len);
      return;
   }

   xftfont = data->fXftFont;

   // no Xft font
   if (!xftfont) {
      TGX11::DrawString(xwindow, gc, x, y, text, len);
      return;
   }

   // dummies
   Window droot;
   Int_t dx,dy;
   UInt_t bwidth, width, height, depth;

   // check if drawable is bitmap
   XGetGeometry((Display*)fDisplay, (Drawable)xwindow, &droot, &dx, &dy,
                &width, &height, &bwidth, &depth);

   if (depth <= 1) {
      TGX11::DrawString(xwindow, gc, x, y, text, len);
      return;
   }

   memset(&xcolor, 0, sizeof(xcolor));
   xcolor.pixel = gval.fForeground;

   XQueryColor((Display*)fDisplay, fColormap, &xcolor);

   // create  XftDraw
   xftdraw = XftDrawCreate((Display*)fDisplay, (Drawable)xwindow, fVisual, fColormap);

   if (!xftdraw) {
      //Warning("could not create an XftDraw");
      TGX11::DrawString(xwindow, gc, x, y, text, len);
      return;
   }

   xftcolor.color.red = xcolor.red;
   xftcolor.color.green = xcolor.green;
   xftcolor.color.blue = xcolor.blue;
   xftcolor.color.alpha = 0xffff;
   xftcolor.pixel = gval.fForeground;

   XftDrawString8(xftdraw, &xftcolor, xftfont, x, y, (XftChar8 *)text, len);

   // cleanup
   XftDrawDestroy(xftdraw);
}

#endif // R__HAS_XFT
 TGX11TTF.cxx:1
 TGX11TTF.cxx:2
 TGX11TTF.cxx:3
 TGX11TTF.cxx:4
 TGX11TTF.cxx:5
 TGX11TTF.cxx:6
 TGX11TTF.cxx:7
 TGX11TTF.cxx:8
 TGX11TTF.cxx:9
 TGX11TTF.cxx:10
 TGX11TTF.cxx:11
 TGX11TTF.cxx:12
 TGX11TTF.cxx:13
 TGX11TTF.cxx:14
 TGX11TTF.cxx:15
 TGX11TTF.cxx:16
 TGX11TTF.cxx:17
 TGX11TTF.cxx:18
 TGX11TTF.cxx:19
 TGX11TTF.cxx:20
 TGX11TTF.cxx:21
 TGX11TTF.cxx:22
 TGX11TTF.cxx:23
 TGX11TTF.cxx:24
 TGX11TTF.cxx:25
 TGX11TTF.cxx:26
 TGX11TTF.cxx:27
 TGX11TTF.cxx:28
 TGX11TTF.cxx:29
 TGX11TTF.cxx:30
 TGX11TTF.cxx:31
 TGX11TTF.cxx:32
 TGX11TTF.cxx:33
 TGX11TTF.cxx:34
 TGX11TTF.cxx:35
 TGX11TTF.cxx:36
 TGX11TTF.cxx:37
 TGX11TTF.cxx:38
 TGX11TTF.cxx:39
 TGX11TTF.cxx:40
 TGX11TTF.cxx:41
 TGX11TTF.cxx:42
 TGX11TTF.cxx:43
 TGX11TTF.cxx:44
 TGX11TTF.cxx:45
 TGX11TTF.cxx:46
 TGX11TTF.cxx:47
 TGX11TTF.cxx:48
 TGX11TTF.cxx:49
 TGX11TTF.cxx:50
 TGX11TTF.cxx:51
 TGX11TTF.cxx:52
 TGX11TTF.cxx:53
 TGX11TTF.cxx:54
 TGX11TTF.cxx:55
 TGX11TTF.cxx:56
 TGX11TTF.cxx:57
 TGX11TTF.cxx:58
 TGX11TTF.cxx:59
 TGX11TTF.cxx:60
 TGX11TTF.cxx:61
 TGX11TTF.cxx:62
 TGX11TTF.cxx:63
 TGX11TTF.cxx:64
 TGX11TTF.cxx:65
 TGX11TTF.cxx:66
 TGX11TTF.cxx:67
 TGX11TTF.cxx:68
 TGX11TTF.cxx:69
 TGX11TTF.cxx:70
 TGX11TTF.cxx:71
 TGX11TTF.cxx:72
 TGX11TTF.cxx:73
 TGX11TTF.cxx:74
 TGX11TTF.cxx:75
 TGX11TTF.cxx:76
 TGX11TTF.cxx:77
 TGX11TTF.cxx:78
 TGX11TTF.cxx:79
 TGX11TTF.cxx:80
 TGX11TTF.cxx:81
 TGX11TTF.cxx:82
 TGX11TTF.cxx:83
 TGX11TTF.cxx:84
 TGX11TTF.cxx:85
 TGX11TTF.cxx:86
 TGX11TTF.cxx:87
 TGX11TTF.cxx:88
 TGX11TTF.cxx:89
 TGX11TTF.cxx:90
 TGX11TTF.cxx:91
 TGX11TTF.cxx:92
 TGX11TTF.cxx:93
 TGX11TTF.cxx:94
 TGX11TTF.cxx:95
 TGX11TTF.cxx:96
 TGX11TTF.cxx:97
 TGX11TTF.cxx:98
 TGX11TTF.cxx:99
 TGX11TTF.cxx:100
 TGX11TTF.cxx:101
 TGX11TTF.cxx:102
 TGX11TTF.cxx:103
 TGX11TTF.cxx:104
 TGX11TTF.cxx:105
 TGX11TTF.cxx:106
 TGX11TTF.cxx:107
 TGX11TTF.cxx:108
 TGX11TTF.cxx:109
 TGX11TTF.cxx:110
 TGX11TTF.cxx:111
 TGX11TTF.cxx:112
 TGX11TTF.cxx:113
 TGX11TTF.cxx:114
 TGX11TTF.cxx:115
 TGX11TTF.cxx:116
 TGX11TTF.cxx:117
 TGX11TTF.cxx:118
 TGX11TTF.cxx:119
 TGX11TTF.cxx:120
 TGX11TTF.cxx:121
 TGX11TTF.cxx:122
 TGX11TTF.cxx:123
 TGX11TTF.cxx:124
 TGX11TTF.cxx:125
 TGX11TTF.cxx:126
 TGX11TTF.cxx:127
 TGX11TTF.cxx:128
 TGX11TTF.cxx:129
 TGX11TTF.cxx:130
 TGX11TTF.cxx:131
 TGX11TTF.cxx:132
 TGX11TTF.cxx:133
 TGX11TTF.cxx:134
 TGX11TTF.cxx:135
 TGX11TTF.cxx:136
 TGX11TTF.cxx:137
 TGX11TTF.cxx:138
 TGX11TTF.cxx:139
 TGX11TTF.cxx:140
 TGX11TTF.cxx:141
 TGX11TTF.cxx:142
 TGX11TTF.cxx:143
 TGX11TTF.cxx:144
 TGX11TTF.cxx:145
 TGX11TTF.cxx:146
 TGX11TTF.cxx:147
 TGX11TTF.cxx:148
 TGX11TTF.cxx:149
 TGX11TTF.cxx:150
 TGX11TTF.cxx:151
 TGX11TTF.cxx:152
 TGX11TTF.cxx:153
 TGX11TTF.cxx:154
 TGX11TTF.cxx:155
 TGX11TTF.cxx:156
 TGX11TTF.cxx:157
 TGX11TTF.cxx:158
 TGX11TTF.cxx:159
 TGX11TTF.cxx:160
 TGX11TTF.cxx:161
 TGX11TTF.cxx:162
 TGX11TTF.cxx:163
 TGX11TTF.cxx:164
 TGX11TTF.cxx:165
 TGX11TTF.cxx:166
 TGX11TTF.cxx:167
 TGX11TTF.cxx:168
 TGX11TTF.cxx:169
 TGX11TTF.cxx:170
 TGX11TTF.cxx:171
 TGX11TTF.cxx:172
 TGX11TTF.cxx:173
 TGX11TTF.cxx:174
 TGX11TTF.cxx:175
 TGX11TTF.cxx:176
 TGX11TTF.cxx:177
 TGX11TTF.cxx:178
 TGX11TTF.cxx:179
 TGX11TTF.cxx:180
 TGX11TTF.cxx:181
 TGX11TTF.cxx:182
 TGX11TTF.cxx:183
 TGX11TTF.cxx:184
 TGX11TTF.cxx:185
 TGX11TTF.cxx:186
 TGX11TTF.cxx:187
 TGX11TTF.cxx:188
 TGX11TTF.cxx:189
 TGX11TTF.cxx:190
 TGX11TTF.cxx:191
 TGX11TTF.cxx:192
 TGX11TTF.cxx:193
 TGX11TTF.cxx:194
 TGX11TTF.cxx:195
 TGX11TTF.cxx:196
 TGX11TTF.cxx:197
 TGX11TTF.cxx:198
 TGX11TTF.cxx:199
 TGX11TTF.cxx:200
 TGX11TTF.cxx:201
 TGX11TTF.cxx:202
 TGX11TTF.cxx:203
 TGX11TTF.cxx:204
 TGX11TTF.cxx:205
 TGX11TTF.cxx:206
 TGX11TTF.cxx:207
 TGX11TTF.cxx:208
 TGX11TTF.cxx:209
 TGX11TTF.cxx:210
 TGX11TTF.cxx:211
 TGX11TTF.cxx:212
 TGX11TTF.cxx:213
 TGX11TTF.cxx:214
 TGX11TTF.cxx:215
 TGX11TTF.cxx:216
 TGX11TTF.cxx:217
 TGX11TTF.cxx:218
 TGX11TTF.cxx:219
 TGX11TTF.cxx:220
 TGX11TTF.cxx:221
 TGX11TTF.cxx:222
 TGX11TTF.cxx:223
 TGX11TTF.cxx:224
 TGX11TTF.cxx:225
 TGX11TTF.cxx:226
 TGX11TTF.cxx:227
 TGX11TTF.cxx:228
 TGX11TTF.cxx:229
 TGX11TTF.cxx:230
 TGX11TTF.cxx:231
 TGX11TTF.cxx:232
 TGX11TTF.cxx:233
 TGX11TTF.cxx:234
 TGX11TTF.cxx:235
 TGX11TTF.cxx:236
 TGX11TTF.cxx:237
 TGX11TTF.cxx:238
 TGX11TTF.cxx:239
 TGX11TTF.cxx:240
 TGX11TTF.cxx:241
 TGX11TTF.cxx:242
 TGX11TTF.cxx:243
 TGX11TTF.cxx:244
 TGX11TTF.cxx:245
 TGX11TTF.cxx:246
 TGX11TTF.cxx:247
 TGX11TTF.cxx:248
 TGX11TTF.cxx:249
 TGX11TTF.cxx:250
 TGX11TTF.cxx:251
 TGX11TTF.cxx:252
 TGX11TTF.cxx:253
 TGX11TTF.cxx:254
 TGX11TTF.cxx:255
 TGX11TTF.cxx:256
 TGX11TTF.cxx:257
 TGX11TTF.cxx:258
 TGX11TTF.cxx:259
 TGX11TTF.cxx:260
 TGX11TTF.cxx:261
 TGX11TTF.cxx:262
 TGX11TTF.cxx:263
 TGX11TTF.cxx:264
 TGX11TTF.cxx:265
 TGX11TTF.cxx:266
 TGX11TTF.cxx:267
 TGX11TTF.cxx:268
 TGX11TTF.cxx:269
 TGX11TTF.cxx:270
 TGX11TTF.cxx:271
 TGX11TTF.cxx:272
 TGX11TTF.cxx:273
 TGX11TTF.cxx:274
 TGX11TTF.cxx:275
 TGX11TTF.cxx:276
 TGX11TTF.cxx:277
 TGX11TTF.cxx:278
 TGX11TTF.cxx:279
 TGX11TTF.cxx:280
 TGX11TTF.cxx:281
 TGX11TTF.cxx:282
 TGX11TTF.cxx:283
 TGX11TTF.cxx:284
 TGX11TTF.cxx:285
 TGX11TTF.cxx:286
 TGX11TTF.cxx:287
 TGX11TTF.cxx:288
 TGX11TTF.cxx:289
 TGX11TTF.cxx:290
 TGX11TTF.cxx:291
 TGX11TTF.cxx:292
 TGX11TTF.cxx:293
 TGX11TTF.cxx:294
 TGX11TTF.cxx:295
 TGX11TTF.cxx:296
 TGX11TTF.cxx:297
 TGX11TTF.cxx:298
 TGX11TTF.cxx:299
 TGX11TTF.cxx:300
 TGX11TTF.cxx:301
 TGX11TTF.cxx:302
 TGX11TTF.cxx:303
 TGX11TTF.cxx:304
 TGX11TTF.cxx:305
 TGX11TTF.cxx:306
 TGX11TTF.cxx:307
 TGX11TTF.cxx:308
 TGX11TTF.cxx:309
 TGX11TTF.cxx:310
 TGX11TTF.cxx:311
 TGX11TTF.cxx:312
 TGX11TTF.cxx:313
 TGX11TTF.cxx:314
 TGX11TTF.cxx:315
 TGX11TTF.cxx:316
 TGX11TTF.cxx:317
 TGX11TTF.cxx:318
 TGX11TTF.cxx:319
 TGX11TTF.cxx:320
 TGX11TTF.cxx:321
 TGX11TTF.cxx:322
 TGX11TTF.cxx:323
 TGX11TTF.cxx:324
 TGX11TTF.cxx:325
 TGX11TTF.cxx:326
 TGX11TTF.cxx:327
 TGX11TTF.cxx:328
 TGX11TTF.cxx:329
 TGX11TTF.cxx:330
 TGX11TTF.cxx:331
 TGX11TTF.cxx:332
 TGX11TTF.cxx:333
 TGX11TTF.cxx:334
 TGX11TTF.cxx:335
 TGX11TTF.cxx:336
 TGX11TTF.cxx:337
 TGX11TTF.cxx:338
 TGX11TTF.cxx:339
 TGX11TTF.cxx:340
 TGX11TTF.cxx:341
 TGX11TTF.cxx:342
 TGX11TTF.cxx:343
 TGX11TTF.cxx:344
 TGX11TTF.cxx:345
 TGX11TTF.cxx:346
 TGX11TTF.cxx:347
 TGX11TTF.cxx:348
 TGX11TTF.cxx:349
 TGX11TTF.cxx:350
 TGX11TTF.cxx:351
 TGX11TTF.cxx:352
 TGX11TTF.cxx:353
 TGX11TTF.cxx:354
 TGX11TTF.cxx:355
 TGX11TTF.cxx:356
 TGX11TTF.cxx:357
 TGX11TTF.cxx:358
 TGX11TTF.cxx:359
 TGX11TTF.cxx:360
 TGX11TTF.cxx:361
 TGX11TTF.cxx:362
 TGX11TTF.cxx:363
 TGX11TTF.cxx:364
 TGX11TTF.cxx:365
 TGX11TTF.cxx:366
 TGX11TTF.cxx:367
 TGX11TTF.cxx:368
 TGX11TTF.cxx:369
 TGX11TTF.cxx:370
 TGX11TTF.cxx:371
 TGX11TTF.cxx:372
 TGX11TTF.cxx:373
 TGX11TTF.cxx:374
 TGX11TTF.cxx:375
 TGX11TTF.cxx:376
 TGX11TTF.cxx:377
 TGX11TTF.cxx:378
 TGX11TTF.cxx:379
 TGX11TTF.cxx:380
 TGX11TTF.cxx:381
 TGX11TTF.cxx:382
 TGX11TTF.cxx:383
 TGX11TTF.cxx:384
 TGX11TTF.cxx:385
 TGX11TTF.cxx:386
 TGX11TTF.cxx:387
 TGX11TTF.cxx:388
 TGX11TTF.cxx:389
 TGX11TTF.cxx:390
 TGX11TTF.cxx:391
 TGX11TTF.cxx:392
 TGX11TTF.cxx:393
 TGX11TTF.cxx:394
 TGX11TTF.cxx:395
 TGX11TTF.cxx:396
 TGX11TTF.cxx:397
 TGX11TTF.cxx:398
 TGX11TTF.cxx:399
 TGX11TTF.cxx:400
 TGX11TTF.cxx:401
 TGX11TTF.cxx:402
 TGX11TTF.cxx:403
 TGX11TTF.cxx:404
 TGX11TTF.cxx:405
 TGX11TTF.cxx:406
 TGX11TTF.cxx:407
 TGX11TTF.cxx:408
 TGX11TTF.cxx:409
 TGX11TTF.cxx:410
 TGX11TTF.cxx:411
 TGX11TTF.cxx:412
 TGX11TTF.cxx:413
 TGX11TTF.cxx:414
 TGX11TTF.cxx:415
 TGX11TTF.cxx:416
 TGX11TTF.cxx:417
 TGX11TTF.cxx:418
 TGX11TTF.cxx:419
 TGX11TTF.cxx:420
 TGX11TTF.cxx:421
 TGX11TTF.cxx:422
 TGX11TTF.cxx:423
 TGX11TTF.cxx:424
 TGX11TTF.cxx:425
 TGX11TTF.cxx:426
 TGX11TTF.cxx:427
 TGX11TTF.cxx:428
 TGX11TTF.cxx:429
 TGX11TTF.cxx:430
 TGX11TTF.cxx:431
 TGX11TTF.cxx:432
 TGX11TTF.cxx:433
 TGX11TTF.cxx:434
 TGX11TTF.cxx:435
 TGX11TTF.cxx:436
 TGX11TTF.cxx:437
 TGX11TTF.cxx:438
 TGX11TTF.cxx:439
 TGX11TTF.cxx:440
 TGX11TTF.cxx:441
 TGX11TTF.cxx:442
 TGX11TTF.cxx:443
 TGX11TTF.cxx:444
 TGX11TTF.cxx:445
 TGX11TTF.cxx:446
 TGX11TTF.cxx:447
 TGX11TTF.cxx:448
 TGX11TTF.cxx:449
 TGX11TTF.cxx:450
 TGX11TTF.cxx:451
 TGX11TTF.cxx:452
 TGX11TTF.cxx:453
 TGX11TTF.cxx:454
 TGX11TTF.cxx:455
 TGX11TTF.cxx:456
 TGX11TTF.cxx:457
 TGX11TTF.cxx:458
 TGX11TTF.cxx:459
 TGX11TTF.cxx:460
 TGX11TTF.cxx:461
 TGX11TTF.cxx:462
 TGX11TTF.cxx:463
 TGX11TTF.cxx:464
 TGX11TTF.cxx:465
 TGX11TTF.cxx:466
 TGX11TTF.cxx:467
 TGX11TTF.cxx:468
 TGX11TTF.cxx:469
 TGX11TTF.cxx:470
 TGX11TTF.cxx:471
 TGX11TTF.cxx:472
 TGX11TTF.cxx:473
 TGX11TTF.cxx:474
 TGX11TTF.cxx:475
 TGX11TTF.cxx:476
 TGX11TTF.cxx:477
 TGX11TTF.cxx:478
 TGX11TTF.cxx:479
 TGX11TTF.cxx:480
 TGX11TTF.cxx:481
 TGX11TTF.cxx:482
 TGX11TTF.cxx:483
 TGX11TTF.cxx:484
 TGX11TTF.cxx:485
 TGX11TTF.cxx:486
 TGX11TTF.cxx:487
 TGX11TTF.cxx:488
 TGX11TTF.cxx:489
 TGX11TTF.cxx:490
 TGX11TTF.cxx:491
 TGX11TTF.cxx:492
 TGX11TTF.cxx:493
 TGX11TTF.cxx:494
 TGX11TTF.cxx:495
 TGX11TTF.cxx:496
 TGX11TTF.cxx:497
 TGX11TTF.cxx:498
 TGX11TTF.cxx:499
 TGX11TTF.cxx:500
 TGX11TTF.cxx:501
 TGX11TTF.cxx:502
 TGX11TTF.cxx:503
 TGX11TTF.cxx:504
 TGX11TTF.cxx:505
 TGX11TTF.cxx:506
 TGX11TTF.cxx:507
 TGX11TTF.cxx:508
 TGX11TTF.cxx:509
 TGX11TTF.cxx:510
 TGX11TTF.cxx:511
 TGX11TTF.cxx:512
 TGX11TTF.cxx:513
 TGX11TTF.cxx:514
 TGX11TTF.cxx:515
 TGX11TTF.cxx:516
 TGX11TTF.cxx:517
 TGX11TTF.cxx:518
 TGX11TTF.cxx:519
 TGX11TTF.cxx:520
 TGX11TTF.cxx:521
 TGX11TTF.cxx:522
 TGX11TTF.cxx:523
 TGX11TTF.cxx:524
 TGX11TTF.cxx:525
 TGX11TTF.cxx:526
 TGX11TTF.cxx:527
 TGX11TTF.cxx:528
 TGX11TTF.cxx:529
 TGX11TTF.cxx:530
 TGX11TTF.cxx:531
 TGX11TTF.cxx:532
 TGX11TTF.cxx:533
 TGX11TTF.cxx:534
 TGX11TTF.cxx:535
 TGX11TTF.cxx:536
 TGX11TTF.cxx:537
 TGX11TTF.cxx:538
 TGX11TTF.cxx:539
 TGX11TTF.cxx:540
 TGX11TTF.cxx:541
 TGX11TTF.cxx:542
 TGX11TTF.cxx:543
 TGX11TTF.cxx:544
 TGX11TTF.cxx:545
 TGX11TTF.cxx:546
 TGX11TTF.cxx:547
 TGX11TTF.cxx:548
 TGX11TTF.cxx:549
 TGX11TTF.cxx:550
 TGX11TTF.cxx:551
 TGX11TTF.cxx:552
 TGX11TTF.cxx:553
 TGX11TTF.cxx:554
 TGX11TTF.cxx:555
 TGX11TTF.cxx:556
 TGX11TTF.cxx:557
 TGX11TTF.cxx:558
 TGX11TTF.cxx:559
 TGX11TTF.cxx:560
 TGX11TTF.cxx:561
 TGX11TTF.cxx:562
 TGX11TTF.cxx:563
 TGX11TTF.cxx:564
 TGX11TTF.cxx:565
 TGX11TTF.cxx:566
 TGX11TTF.cxx:567
 TGX11TTF.cxx:568
 TGX11TTF.cxx:569
 TGX11TTF.cxx:570
 TGX11TTF.cxx:571
 TGX11TTF.cxx:572
 TGX11TTF.cxx:573
 TGX11TTF.cxx:574
 TGX11TTF.cxx:575
 TGX11TTF.cxx:576
 TGX11TTF.cxx:577
 TGX11TTF.cxx:578
 TGX11TTF.cxx:579
 TGX11TTF.cxx:580
 TGX11TTF.cxx:581
 TGX11TTF.cxx:582
 TGX11TTF.cxx:583
 TGX11TTF.cxx:584
 TGX11TTF.cxx:585
 TGX11TTF.cxx:586
 TGX11TTF.cxx:587
 TGX11TTF.cxx:588
 TGX11TTF.cxx:589
 TGX11TTF.cxx:590
 TGX11TTF.cxx:591
 TGX11TTF.cxx:592
 TGX11TTF.cxx:593
 TGX11TTF.cxx:594
 TGX11TTF.cxx:595
 TGX11TTF.cxx:596
 TGX11TTF.cxx:597
 TGX11TTF.cxx:598
 TGX11TTF.cxx:599
 TGX11TTF.cxx:600
 TGX11TTF.cxx:601
 TGX11TTF.cxx:602
 TGX11TTF.cxx:603
 TGX11TTF.cxx:604
 TGX11TTF.cxx:605
 TGX11TTF.cxx:606
 TGX11TTF.cxx:607
 TGX11TTF.cxx:608
 TGX11TTF.cxx:609
 TGX11TTF.cxx:610
 TGX11TTF.cxx:611
 TGX11TTF.cxx:612
 TGX11TTF.cxx:613
 TGX11TTF.cxx:614
 TGX11TTF.cxx:615
 TGX11TTF.cxx:616
 TGX11TTF.cxx:617
 TGX11TTF.cxx:618
 TGX11TTF.cxx:619
 TGX11TTF.cxx:620
 TGX11TTF.cxx:621
 TGX11TTF.cxx:622
 TGX11TTF.cxx:623
 TGX11TTF.cxx:624
 TGX11TTF.cxx:625
 TGX11TTF.cxx:626
 TGX11TTF.cxx:627
 TGX11TTF.cxx:628
 TGX11TTF.cxx:629
 TGX11TTF.cxx:630
 TGX11TTF.cxx:631
 TGX11TTF.cxx:632
 TGX11TTF.cxx:633
 TGX11TTF.cxx:634
 TGX11TTF.cxx:635
 TGX11TTF.cxx:636
 TGX11TTF.cxx:637
 TGX11TTF.cxx:638
 TGX11TTF.cxx:639
 TGX11TTF.cxx:640
 TGX11TTF.cxx:641
 TGX11TTF.cxx:642
 TGX11TTF.cxx:643
 TGX11TTF.cxx:644
 TGX11TTF.cxx:645
 TGX11TTF.cxx:646
 TGX11TTF.cxx:647
 TGX11TTF.cxx:648
 TGX11TTF.cxx:649
 TGX11TTF.cxx:650
 TGX11TTF.cxx:651
 TGX11TTF.cxx:652
 TGX11TTF.cxx:653
 TGX11TTF.cxx:654
 TGX11TTF.cxx:655
 TGX11TTF.cxx:656
 TGX11TTF.cxx:657
 TGX11TTF.cxx:658
 TGX11TTF.cxx:659
 TGX11TTF.cxx:660
 TGX11TTF.cxx:661
 TGX11TTF.cxx:662
 TGX11TTF.cxx:663
 TGX11TTF.cxx:664
 TGX11TTF.cxx:665
 TGX11TTF.cxx:666
 TGX11TTF.cxx:667
 TGX11TTF.cxx:668
 TGX11TTF.cxx:669
 TGX11TTF.cxx:670
 TGX11TTF.cxx:671
 TGX11TTF.cxx:672
 TGX11TTF.cxx:673
 TGX11TTF.cxx:674
 TGX11TTF.cxx:675
 TGX11TTF.cxx:676
 TGX11TTF.cxx:677
 TGX11TTF.cxx:678
 TGX11TTF.cxx:679
 TGX11TTF.cxx:680
 TGX11TTF.cxx:681
 TGX11TTF.cxx:682
 TGX11TTF.cxx:683
 TGX11TTF.cxx:684
 TGX11TTF.cxx:685
 TGX11TTF.cxx:686
 TGX11TTF.cxx:687
 TGX11TTF.cxx:688
 TGX11TTF.cxx:689
 TGX11TTF.cxx:690
 TGX11TTF.cxx:691
 TGX11TTF.cxx:692
 TGX11TTF.cxx:693
 TGX11TTF.cxx:694
 TGX11TTF.cxx:695
 TGX11TTF.cxx:696
 TGX11TTF.cxx:697
 TGX11TTF.cxx:698
 TGX11TTF.cxx:699
 TGX11TTF.cxx:700
 TGX11TTF.cxx:701
 TGX11TTF.cxx:702
 TGX11TTF.cxx:703
 TGX11TTF.cxx:704
 TGX11TTF.cxx:705
 TGX11TTF.cxx:706
 TGX11TTF.cxx:707
 TGX11TTF.cxx:708
 TGX11TTF.cxx:709
 TGX11TTF.cxx:710
 TGX11TTF.cxx:711
 TGX11TTF.cxx:712
 TGX11TTF.cxx:713
 TGX11TTF.cxx:714
 TGX11TTF.cxx:715
 TGX11TTF.cxx:716
 TGX11TTF.cxx:717
 TGX11TTF.cxx:718
 TGX11TTF.cxx:719
 TGX11TTF.cxx:720
 TGX11TTF.cxx:721
 TGX11TTF.cxx:722
 TGX11TTF.cxx:723
 TGX11TTF.cxx:724
 TGX11TTF.cxx:725
 TGX11TTF.cxx:726
 TGX11TTF.cxx:727
 TGX11TTF.cxx:728
 TGX11TTF.cxx:729
 TGX11TTF.cxx:730
 TGX11TTF.cxx:731
 TGX11TTF.cxx:732
 TGX11TTF.cxx:733
 TGX11TTF.cxx:734
 TGX11TTF.cxx:735
 TGX11TTF.cxx:736
 TGX11TTF.cxx:737
 TGX11TTF.cxx:738
 TGX11TTF.cxx:739
 TGX11TTF.cxx:740
 TGX11TTF.cxx:741
 TGX11TTF.cxx:742
 TGX11TTF.cxx:743
 TGX11TTF.cxx:744
 TGX11TTF.cxx:745
 TGX11TTF.cxx:746
 TGX11TTF.cxx:747
 TGX11TTF.cxx:748
 TGX11TTF.cxx:749
 TGX11TTF.cxx:750
 TGX11TTF.cxx:751
 TGX11TTF.cxx:752
 TGX11TTF.cxx:753
 TGX11TTF.cxx:754
 TGX11TTF.cxx:755
 TGX11TTF.cxx:756
 TGX11TTF.cxx:757
 TGX11TTF.cxx:758
 TGX11TTF.cxx:759
 TGX11TTF.cxx:760
 TGX11TTF.cxx:761
 TGX11TTF.cxx:762
 TGX11TTF.cxx:763
 TGX11TTF.cxx:764
 TGX11TTF.cxx:765
 TGX11TTF.cxx:766
 TGX11TTF.cxx:767
 TGX11TTF.cxx:768
 TGX11TTF.cxx:769
 TGX11TTF.cxx:770
 TGX11TTF.cxx:771
 TGX11TTF.cxx:772
 TGX11TTF.cxx:773