// @(#)root/gui:$Id$
// Author: Fons Rademakers   20/5/2003

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

    This source is based on Xclass95, a Win95-looking GUI toolkit.
    Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.

    Xclass95 is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

**************************************************************************/


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGFont and TGFontPool                                                //
//                                                                      //
// Encapsulate fonts used in the GUI system.                            //
// TGFontPool provides a pool of fonts.                                 //
// TGTextLayout is used to keep track of string  measurement            //
// information when  using the text layout facilities.                  //
// It can be displayed with respect to any origin.                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TGFont.h"
#include "TGClient.h"
#include "THashTable.h"
#include "TVirtualX.h"
#include "TObjString.h"
#include "TGWidget.h"
#include <errno.h>
#include <stdlib.h>
#include <limits.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TError.h"
#include "TMath.h"


ClassImp(TGFont)
ClassImp(TGFontPool)
ClassImp(TGTextLayout)

#define FONT_FAMILY     0
#define FONT_SIZE       1
#define FONT_WEIGHT     2
#define FONT_SLANT      3
#define FONT_UNDERLINE  4
#define FONT_OVERSTRIKE 5
#define FONT_NUMFIELDS  6

// The following defines specify the meaning of the fields in a fully
// qualified XLFD.

#define XLFD_FOUNDRY        0
#define XLFD_FAMILY         1
#define XLFD_WEIGHT         2
#define XLFD_SLANT          3
#define XLFD_SETWIDTH       4
#define XLFD_ADD_STYLE      5
#define XLFD_PIXEL_SIZE     6
#define XLFD_POINT_SIZE     7
#define XLFD_RESOLUTION_X   8
#define XLFD_RESOLUTION_Y   9
#define XLFD_SPACING        10
#define XLFD_AVERAGE_WIDTH  11
#define XLFD_REGISTRY       12
#define XLFD_ENCODING       13
#define XLFD_NUMFIELDS      14   // Number of fields in XLFD.


// A LayoutChunk_t represents a contiguous range of text that can be measured
// and displayed by low-level text calls. In general, chunks will be
// delimited by newlines and tabs. Low-level, platform-specific things
// like kerning and non-integer character widths may occur between the
// characters in a single chunk, but not between characters in different
// chunks.

struct LayoutChunk_t {

   const char *fStart;     // Pointer to simple string to be displayed.
                           // This is a pointer into the TGTextLayout's
                           // string.
   Int_t fNumChars;        // The number of characters in this chunk.
   Int_t fNumDisplayChars; // The number of characters to display when
                           // this chunk is displayed. Can be less than
                           // numChars if extra space characters were
                           // absorbed by the end of the chunk. This
                           // will be < 0 if this is a chunk that is
                           // holding a tab or newline.
   Int_t fX;               // The x origin and
   Int_t fY;               // the y origin of the first character in this
                           // chunk with respect to the upper-left hand
                           // corner of the TGTextLayout.
   Int_t fTotalWidth;      // Width in pixels of this chunk. Used
                           // when hit testing the invisible spaces at
                           // the end of a chunk.
   Int_t fDisplayWidth;    // Width in pixels of the displayable
                           // characters in this chunk. Can be less than
                           // width if extra space characters were
                           // absorbed by the end of the chunk.
};


// The following structure is used to return attributes when parsing an
// XLFD. The extra information is used to find the closest matching font.

struct XLFDAttributes_t {
   FontAttributes_t fFA; // Standard set of font attributes.
   const char *fFoundry; // The foundry of the font.
   Int_t fSlant;         // The tristate value for the slant
   Int_t fSetwidth;      // The proportionate width
   Int_t fCharset;       // The character set encoding (the glyph family).
   Int_t fEncoding;      // Variations within a charset for the glyphs above character 127.

   XLFDAttributes_t() :  // default constructor
      fFA(),
      fFoundry(0),
      fSlant(0),
      fSetwidth(0),
      fCharset(0),
      fEncoding(0) { }
};


// The following data structure is used to keep track of the font attributes
// for each named font that has been defined. The named font is only deleted
// when the last reference to it goes away.

class TNamedFont : public TObjString, public TRefCnt {
public:
   Int_t            fDeletePending; // Non-zero if font should be deleted when last reference goes away.
   FontAttributes_t fFA;            // Desired attributes for named font.
};

// enums
enum EFontSpacing { kFontProportional = 0,
                    kFontFixed = 1,
                    kFontMono = 1,
                    kFontCharcell = 2 };

enum EFontSetWidth { kFontSWNormal = 0,
                     kFontSWCondence = 1,
                     kFontSWExpand = 2,
                     kFontSWUnknown = 3 };

enum EFontCharset { kFontCSNormal = 0,
                    kFontCSSymbol = 1,
                    kFontCSOther = 2 };


// Possible values for entries in the "types" field in a TGFont structure,
// which classifies the types of all characters in the given font. This
// information is used when measuring and displaying characters.
//
// kCharNormal:         Standard character.
// kCharReplace:        This character doesn't print: instead of displaying
//                      character, display a replacement sequence like "\n"
//                      (for those characters where ANSI C defines such a
//                      sequence) or a sequence of the form "\xdd" where dd
//                      is the hex equivalent of the character.
// kCharSkip:           Don't display anything for this character. This is
//                      only used where the font doesn't contain all the
//                      characters needed to generate replacement sequences.
enum ECharType { kCharNormal, kCharReplace, kCharSkip };


// The following structures are used as two-way maps between the values for
// the fields in the FontAttributes_t structure and the strings used when
// parsing both option-value format and style-list format font name strings.

struct FontStateMap_t { Int_t fNumKey; const char *fStrKey; };

static const FontStateMap_t gWeightMap[] = {
   { kFontWeightNormal,  "normal" },
   { kFontWeightBold,    "bold"   },
   { kFontWeightUnknown, 0        }
};

static const FontStateMap_t gSlantMap[] = {
   { kFontSlantRoman,   "roman"  },
   { kFontSlantItalic,  "italic" },
   { kFontSlantUnknown, 0        }
};

static const FontStateMap_t gUnderlineMap[] = {
   { 1, "underline" },
   { 0, 0           }
};

static const FontStateMap_t gOverstrikeMap[] = {
   { 1, "overstrike" },
   { 0, 0            }
};

// The following structures are used when parsing XLFD's into a set of
// FontAttributes_t.

static const FontStateMap_t gXlfdgWeightMap[] = {
   { kFontWeightNormal, "normal"   },
   { kFontWeightNormal, "medium"   },
   { kFontWeightNormal, "book"     },
   { kFontWeightNormal, "light"    },
   { kFontWeightBold,   "bold"     },
   { kFontWeightBold,   "demi"     },
   { kFontWeightBold,   "demibold" },
   { kFontWeightNormal,  0         }  // Assume anything else is "normal".
};

static const FontStateMap_t gXlfdSlantMap[] = {
   { kFontSlantRoman,   "r"  },
   { kFontSlantItalic,  "i"  },
   { kFontSlantOblique, "o"  },
   { kFontSlantRoman,   0    }  // Assume anything else is "roman".
};

static const FontStateMap_t gXlfdSetwidthMap[] = {
   { kFontSWNormal,   "normal"        },
   { kFontSWCondence, "narrow"        },
   { kFontSWCondence, "semicondensed" },
   { kFontSWCondence, "condensed"     },
   { kFontSWUnknown,  0               }
};

static const FontStateMap_t gXlfdCharsetMap[] = {
   { kFontCSNormal, "iso8859" },
   { kFontCSSymbol, "adobe"   },
   { kFontCSSymbol, "sun"     },
   { kFontCSOther,  0         }
};


// Characters used when displaying control sequences.

static char gHexChars[] = "0123456789abcdefxtnvr\\";


// The following table maps some control characters to sequences like '\n'
// rather than '\x10'. A zero entry in the table means no such mapping
// exists, and the table only maps characters less than 0x10.

static char gMapChars[] = {
   0, 0, 0, 0, 0, 0, 0, 'a', 'b', 't', 'n', 'v', 'f', 'r', 0
};

static int GetControlCharSubst(int c, char buf[4]);


//______________________________________________________________________________
TGFont::~TGFont()
{
   // Delete font.

   if (fFontStruct) {
      gVirtualX->DeleteFont(fFontStruct);
   }
}

//______________________________________________________________________________
void TGFont::GetFontMetrics(FontMetrics_t *m) const
{
   // Get font metrics.

   if (!m) {
      Error("GetFontMetrics", "argument may not be 0");
      return;
   }

   *m = fFM;
   m->fLinespace = fFM.fAscent + fFM.fDescent;
}

//______________________________________________________________________________
FontStruct_t TGFont::operator()() const
{
   // Not inline due to a bug in g++ 2.96 20000731 (Red Hat Linux 7.0)

   return fFontStruct;
}

//______________________________________________________________________________
void TGFont::Print(Option_t *option) const
{
   // Print font info.

   TString opt = option;

   if ((opt == "full") && fNamedHash) {
      Printf("TGFont: %s, %s, ref cnt = %u",
              fNamedHash->GetName(),
              fFM.fFixed ? "fixed" : "prop", References());
   } else {
      Printf("TGFont: %s, %s, ref cnt = %u", fName.Data(),
              fFM.fFixed ? "fixed" : "prop", References());
   }
}

//______________________________________________________________________________
Int_t TGFont::PostscriptFontName(TString *dst) const
{
   // Return the name of the corresponding Postscript font for this TGFont.
   //
   // The return value is the pointsize of the TGFont. The name of the
   // Postscript font is appended to ds.
   //
   // If the font does not exist on the printer, the print job will fail at
   // print time. Given a "reasonable" Postscript printer, the following
   // TGFont font families should print correctly:
   //
   //     Avant Garde, Arial, Bookman, Courier, Courier New, Geneva,
   //     Helvetica, Monaco, New Century Schoolbook, New York,
   //     Palatino, Symbol, Times, Times New Roman, Zapf Chancery,
   //     and Zapf Dingbats.
   //
   // Any other TGFont font families may not print correctly because the
   // computed Postscript font name may be incorrect.
   //
   // dst -- Pointer to an initialized TString object to which the name of the
   //        Postscript font that corresponds to the font will be appended.

   const char *family;
   TString weightString;
   TString slantString;
   char *src, *dest;
   Int_t upper, len;

   len = dst->Length();

   // Convert the case-insensitive TGFont family name to the
   // case-sensitive Postscript family name. Take out any spaces and
   // capitalize the first letter of each word.

   family = fFA.fFamily;
   if (strncasecmp(family, "itc ", 4) == 0) {
      family = family + 4;
   }
   if ((strcasecmp(family, "Arial") == 0)
       || (strcasecmp(family, "Geneva") == 0)) {
      family = "Helvetica";
   } else if ((strcasecmp(family, "Times New Roman") == 0)
              || (strcasecmp(family, "New York") == 0)) {
      family = "Times";
   } else if ((strcasecmp(family, "Courier New") == 0)
              || (strcasecmp(family, "Monaco") == 0)) {
      family = "Courier";
   } else if (strcasecmp(family, "AvantGarde") == 0) {
      family = "AvantGarde";
   } else if (strcasecmp(family, "ZapfChancery") == 0) {
      family = "ZapfChancery";
   } else if (strcasecmp(family, "ZapfDingbats") == 0) {
      family = "ZapfDingbats";
   } else {

      // Inline, capitalize the first letter of each word, lowercase the
      // rest of the letters in each word, and then take out the spaces
      // between the words. This may make the TString shorter, which is
      // safe to do.

      dst->Append(family);

      src = dest = (char*)dst->Data() + len;
      upper = 1;
      for (; *src != '\0'; src++, dest++) {
         while (isspace(UChar_t(*src))) {
            src++;
            upper = 1;
         }
         *dest = *src;
         if ((upper != 0) && (islower(UChar_t(*src)))) {
            *dest = toupper(UChar_t(*src));
         }
         upper = 0;
      }
      *dest = '\0';
      //dst->SetLength(dest - dst->GetString()); // dst->ResetLength(); may be better
      family = (char *) dst->Data() + len;
   }
   if (family != (char *) dst->Data() + len) {
      dst->Append(family);
      family = (char *) dst->Data() + len;
   }
   if (strcasecmp(family, "NewCenturySchoolbook") == 0) {
//      dst->SetLength(len);
      dst->Append("NewCenturySchlbk");
      family = (char *) dst->Data() + len;
   }

   // Get the string to use for the weight.

   weightString = "";
   if (fFA.fWeight == kFontWeightNormal) {
      if (strcmp(family, "Bookman") == 0) {
         weightString = "Light";
      } else if (strcmp(family, "AvantGarde") == 0) {
         weightString = "Book";
      } else if (strcmp(family, "ZapfChancery") == 0) {
         weightString = "Medium";
      }
   } else {
      if ((strcmp(family, "Bookman") == 0)
           || (strcmp(family, "AvantGarde") == 0)) {
         weightString = "Demi";
      } else {
         weightString = "Bold";
      }
   }

   // Get the string to use for the slant.

   slantString = "";
   if (fFA.fSlant == kFontSlantRoman) {
      ;
   } else {
      if ((strcmp(family, "Helvetica") == 0)
           || (strcmp(family, "Courier") == 0)
           || (strcmp(family, "AvantGarde") == 0)) {
         slantString = "Oblique";
      } else {
         slantString = "Italic";
      }
   }

   // The string "Roman" needs to be added to some fonts that are not bold
   // and not italic.

   if ((slantString.IsNull()) && (weightString.IsNull())) {
      if ((strcmp(family, "Times") == 0)
           || (strcmp(family, "NewCenturySchlbk") == 0)
           || (strcmp(family, "Palatino") == 0)) {
         dst->Append("-Roman");
      }
   } else {
      dst->Append("-");
      if (!weightString.IsNull()) dst->Append(weightString);
      if (!slantString.IsNull()) dst->Append(slantString);
   }

   return fFA.fPointsize;
}

//______________________________________________________________________________
Int_t TGFont::MeasureChars(const char *source, Int_t numChars, Int_t maxLength,
                          Int_t flags, Int_t *length) const
{
   // Determine the number of characters from the string that will fit in the
   // given horizontal span. The measurement is done under the assumption that
   // DrawChars() will be used to actually display the characters.
   //
   // The return value is the number of characters from source that fit into
   // the span that extends from 0 to maxLength. *length is filled with the
   // x-coordinate of the right edge of the last character that did fit.
   //
   // source    -- Characters to be displayed. Need not be '\0' terminated.
   // numChars  -- Maximum number of characters to consider from source string.
   // maxLength -- If > 0, maxLength specifies the longest permissible line
   //              length; don't consider any character that would cross this
   //              x-position. If <= 0, then line length is unbounded and the
   //              flags argument is ignored.
   // flags     -- Various flag bits OR-ed together:
   //              TEXT_PARTIAL_OK means include the last char which only
   //              partially fit on this line.
   //              TEXT_WHOLE_WORDS means stop on a word boundary, if possible.
   //              TEXT_AT_LEAST_ONE means return at least one character even
   //              if no characters fit.
   // *length   -- Filled with x-location just after the terminating character.

   const char *p;    // Current character.
   const char *term; // Pointer to most recent character that may legally be a terminating character.
   Int_t termX;      // X-position just after term.
   Int_t curX;       // X-position corresponding to p.
   Int_t newX;       // X-position corresponding to p+1.
   Int_t c, sawNonSpace;

   if (!numChars) {
      *length = 0;
      return 0;
   }
   if (maxLength <= 0) {
      maxLength = INT_MAX;
   }
   newX = curX = termX = 0;
   p = term = source;
   sawNonSpace = !isspace(UChar_t(*p));

   // Scan the input string one character at a time, calculating width.

   for (c = UChar_t(*p);;) {
      newX += fWidths[c];
      if (newX > maxLength) {
         break;
      }
      curX = newX;
      numChars--;
      p++;
      if (!numChars) {
         term = p;
         termX = curX;
         break;
      }
      c = UChar_t(*p);
      if (isspace(c)) {
         if (sawNonSpace) {
            term = p;
            termX = curX;
            sawNonSpace = 0;
         }
      } else {
         sawNonSpace = 1;
      }
   }

   // P points to the first character that doesn't fit in the desired
   // span. Use the flags to figure out what to return.

   if ((flags & kTextPartialOK) && (numChars > 0) && (curX < maxLength)) {

      // Include the first character that didn't quite fit in the desired
      // span. The width returned will include the width of that extra
      // character.

      numChars--;
      curX = newX;
      p++;
   }
   if ((flags & kTextAtLeastOne) && (term == source) && (numChars > 0)) {
      term = p;
      termX = curX;
      if (term == source) {
         term++;
         termX = newX;
      }
   } else if ((numChars == 0) || !(flags & kTextWholeWords)) {
      term = p;
      termX = curX;
   }
   *length = termX;

   return term - source;
}

//______________________________________________________________________________
Int_t TGFont::TextWidth(const char *string, Int_t numChars) const
{
   // A wrapper function for the more complicated interface of MeasureChars.
   // Computes how much space the given simple string needs.
   //
   // The return value is the width (in pixels) of the given string.
   //
   // string   -- String whose width will be computed.
   // numChars -- Number of characters to consider from string, or < 0 for
   //             strlen().

   Int_t width;

   if (numChars < 0) {
      numChars = strlen(string);
   }
   MeasureChars(string, numChars, 0, 0, &width);

   return width;
}

//______________________________________________________________________________
Int_t TGFont::XTextWidth(const char *string, Int_t numChars) const
{
   // Return text widht in pixels

   int width;

   if (numChars < 0) {
      numChars = strlen(string);
   }
   width = gVirtualX->TextWidth(fFontStruct, string, numChars);

   return width;
}

//______________________________________________________________________________
void TGFont::UnderlineChars(Drawable_t dst, GContext_t gc,
                            const char *string, Int_t x, Int_t y,
                            Int_t firstChar, Int_t lastChar) const
{
   // This procedure draws an underline for a given range of characters in a
   // given string. It doesn't draw the characters (which are assumed to have
   // been displayed previously); it just draws the underline. This procedure
   // would mainly be used to quickly underline a few characters without having
   // to construct an underlined font. To produce properly underlined text, the
   // appropriate underlined font should be constructed and used.
   //
   // dst       -- Window or pixmap in which to draw.
   // gc        -- Graphics context for actually drawing line.
   // string    -- String containing characters to be underlined or overstruck.
   // x, y      -- Coordinates at which first character of string is drawn.
   // firstChar -- Index of first character.
   // lastChar  -- Index of one after the last character.

   Int_t startX, endX;

   MeasureChars(string, firstChar, 0, 0, &startX);
   MeasureChars(string, lastChar, 0, 0, &endX);

   gVirtualX->FillRectangle(dst, gc, x + startX, y + fUnderlinePos,
                            (UInt_t) (endX - startX),
                            (UInt_t) fUnderlineHeight);
}

//______________________________________________________________________________
TGTextLayout *TGFont::ComputeTextLayout(const char *string, Int_t numChars,
                                        Int_t wrapLength, Int_t justify, Int_t flags,
                                        UInt_t *width, UInt_t *height) const
{
   // Computes the amount of screen space needed to display a multi-line,
   // justified string of text. Records all the measurements that were done
   // to determine to size and positioning of the individual lines of text;
   // this information can be used by the TGTextLayout::DrawText() procedure
   // to display the text quickly (without remeasuring it).
   //
   // This procedure is useful for simple widgets that want to display
   // single-font, multi-line text and want TGFont to handle the details.
   //
   // The return value is a TGTextLayout token that holds the measurement
   // information for the given string. The token is only valid for the given
   // string. If the string is freed, the token is no longer valid and must
   // also be deleted.
   //
   // The dimensions of the screen area needed to display the text are stored
   // in *width and *height.
   //
   // string     -- String whose dimensions are to be computed.
   // numChars   -- Number of characters to consider from string, or < 0 for
   //               strlen().
   // wrapLength -- Longest permissible line length, in pixels. <= 0 means no
   //               automatic wrapping: just let lines get as long as needed.
   // justify    -- How to justify lines.
   // flags      -- Flag bits OR-ed together. kTextIgnoreTabs means that tab
   //               characters should not be expanded. kTextIgnoreNewlines
   //               means that newline characters should not cause a line break.
   // width      -- Filled with width of string.
   // height     -- Filled with height of string.

   const char *start, *end, *special;
   Int_t n, y=0, charsThisChunk, maxChunks;
   Int_t baseline, h, curX, newX, maxWidth;
   TGTextLayout *layout;
   LayoutChunk_t *chunk;

#define MAX_LINES 50
   Int_t staticLineLengths[MAX_LINES];
   Int_t *lineLengths;
   Int_t maxLines, curLine, layoutHeight;

   lineLengths = staticLineLengths;
   maxLines = MAX_LINES;

   h = fFM.fAscent + fFM.fDescent;

   if (numChars < 0) {
      numChars = strlen(string);
   }
   maxChunks = 0;

   layout = new TGTextLayout;
   layout->fFont = this;
   layout->fString = string;
   layout->fNumChunks = 0;
   layout->fChunks = 0;

   baseline = fFM.fAscent;
   maxWidth = 0;

   // Divide the string up into simple strings and measure each string.

   curX = 0;

   end = string + numChars;
   special = string;

   flags &= kTextIgnoreTabs | kTextIgnoreNewlines;
   flags |= kTextWholeWords | kTextAtLeastOne;
   curLine = 0;

   for (start = string; start < end;) {
      if (start >= special) {
         // Find the next special character in the string.

         for (special = start; special < end; special++) {
            if (!(flags & kTextIgnoreNewlines)) {
               if ((*special == '\n') || (*special == '\r')) {
                  break;
               }
            }
            if (!(flags & kTextIgnoreTabs)) {
               if (*special == '\t') {
                  break;
               }
            }
         }
      }

      // Special points at the next special character (or the end of the
      // string). Process characters between start and special.

      chunk = 0;
      if (start < special) {
         charsThisChunk = MeasureChars(start, special - start,
                                       wrapLength - curX, flags, &newX);
         newX += curX;
         flags &= ~kTextAtLeastOne;
         if (charsThisChunk > 0) {
            chunk = NewChunk(layout, &maxChunks, start,
                             charsThisChunk, curX, newX, baseline);

            start += charsThisChunk;
            curX = newX;
         }
      }
      if ((start == special) && (special < end)) {
         // Handle the special character.
         LayoutChunk_t *newchunk = 0;

         chunk = 0;
         if (*special == '\t') {
            newX = curX + fTabWidth;
            newX -= newX % fTabWidth;
            newchunk = NewChunk(layout, &maxChunks, start, 1, curX, newX, baseline);
            if (newchunk) newchunk->fNumDisplayChars = -1;
            start++;
            if ((start < end) && ((wrapLength <= 0) || (newX <= wrapLength))) {

               // More chars can still fit on this line.

               curX = newX;
               flags &= ~kTextAtLeastOne;
               continue;
            }
         } else {
            newchunk = NewChunk(layout, &maxChunks, start, 1, curX, 1000000000, baseline);
            if (newchunk) newchunk->fNumDisplayChars = -1;
            start++;
            goto wrapLine;
         }
      }

      // No more characters are going to go on this line, either because
      // no more characters can fit or there are no more characters left.
      // Consume all extra spaces at end of line.

      while ((start < end) && isspace(UChar_t(*start))) {
         if (!(flags & kTextIgnoreNewlines)) {
            if ((*start == '\n') || (*start == '\r')) {
               break;
            }
         }
         if (!(flags & kTextIgnoreTabs)) {
            if (*start == '\t') {
               break;
            }
         }
         start++;
      }
      if (chunk) {
         // Append all the extra spaces on this line to the end of the
         // last text chunk.

         charsThisChunk = start - (chunk->fStart + chunk->fNumChars);
         if (charsThisChunk > 0) {
            chunk->fNumChars += MeasureChars(chunk->fStart + chunk->fNumChars,
                                             charsThisChunk, 0, 0, &chunk->fTotalWidth);
            chunk->fTotalWidth += curX;
         }
      }
wrapLine:
      flags |= kTextAtLeastOne;

      // Save current line length, then move current position to start of
      // next line.

      if (curX > maxWidth) {
         maxWidth = curX;
      }

      // Remember width of this line, so that all chunks on this line
      // can be centered or right justified, if necessary.

      if (curLine >= maxLines) {
         int *newLengths;

         newLengths = new int[2 * maxLines];
         memcpy((void *) newLengths, lineLengths, maxLines * sizeof (int));

         if (lineLengths != staticLineLengths) {
            delete[] lineLengths;
         }
         lineLengths = newLengths;
         maxLines *= 2;
      }
      lineLengths[curLine] = curX;
      curLine++;

      curX = 0;
      baseline += h;
   }

   // If last line ends with a newline, then we need to make a 0 width
   // chunk on the next line. Otherwise "Hello" and "Hello\n" are the
   // same height.

   if ((layout->fNumChunks > 0) && ((flags & kTextIgnoreNewlines) == 0)) {
      if (layout->fChunks[layout->fNumChunks - 1].fStart[0] == '\n') {
         chunk = NewChunk(layout, &maxChunks, start, 0, curX, 1000000000, baseline);
         chunk->fNumDisplayChars = -1;
         baseline += h;
      }
   }

   // Using maximum line length, shift all the chunks so that the lines are
   // all justified correctly.

   curLine = 0;
   chunk = layout->fChunks;
   if (chunk) y = chunk->fY;
   for (n = 0; n < layout->fNumChunks; n++) {
      int extra;

      if (chunk->fY != y) {
         curLine++;
         y = chunk->fY;
      }
      extra = maxWidth - lineLengths[curLine];
      if (justify == kTextCenterX) {
         chunk->fX += extra / 2;
      } else if (justify == kTextRight) {
         chunk->fX += extra;
      }
      ++chunk;
   }

   layout->fWidth = maxWidth;
   layoutHeight = baseline - fFM.fAscent;
   if (layout->fNumChunks == 0) {
      layoutHeight = h;

      // This fake chunk is used by the other procedures so that they can
      // pretend that there is a chunk with no chars in it, which makes
      // the coding simpler.

      layout->fNumChunks = 1;
      layout->fChunks = new LayoutChunk_t[1];
      layout->fChunks[0].fStart = string;
      layout->fChunks[0].fNumChars = 0;
      layout->fChunks[0].fNumDisplayChars = -1;
      layout->fChunks[0].fX = 0;
      layout->fChunks[0].fY = fFM.fAscent;
      layout->fChunks[0].fTotalWidth = 0;
      layout->fChunks[0].fDisplayWidth = 0;
   }
   if (width) {
      *width = layout->fWidth;
   }
   if (height) {
      *height = layoutHeight;
   }
   if (lineLengths != staticLineLengths) {
      delete[] lineLengths;
   }

   return layout;
}

//______________________________________________________________________________
TGTextLayout::~TGTextLayout()
{
   // destructor

   if (fChunks) {
      delete[] fChunks;
   }
}

//______________________________________________________________________________
void TGTextLayout::DrawText(Drawable_t dst, GContext_t gc,
                            Int_t x, Int_t y, Int_t firstChar, Int_t lastChar) const
{
   // Use the information in the TGTextLayout object to display a multi-line,
   // justified string of text.
   //
   // This procedure is useful for simple widgets that need to display
   // single-font, multi-line text and want TGFont to handle the details.
   //
   // dst       -- Window or pixmap in which to draw.
   // gc        -- Graphics context to use for drawing text.
   // x, y      -- Upper-left hand corner of rectangle in which to draw
   //              (pixels).
   // firstChar -- The index of the first character to draw from the given
   //              text item. 0 specfies the beginning.
   // lastChar  -- The index just after the last character to draw from the
   //              given text item. A number < 0 means to draw all characters.

   Int_t i, numDisplayChars, drawX;
   LayoutChunk_t *chunk;

   if (lastChar < 0) lastChar = 100000000;
   chunk = fChunks;

   for (i = 0; i < fNumChunks; i++) {
      numDisplayChars = chunk->fNumDisplayChars;
      if ((numDisplayChars > 0) && (firstChar < numDisplayChars)) {
         if (firstChar <= 0) {
            drawX = 0;
            firstChar = 0;
         } else {
            fFont->MeasureChars(chunk->fStart, firstChar, 0, 0, &drawX);
         }
         if (lastChar < numDisplayChars) numDisplayChars = lastChar;
         fFont->DrawChars(dst, gc, chunk->fStart + firstChar, numDisplayChars - firstChar,
                           x + chunk->fX + drawX, y + chunk->fY);
      }
      firstChar -= chunk->fNumChars;
      lastChar -= chunk->fNumChars;

      if (lastChar <= 0) break;
      chunk++;
   }
}

//______________________________________________________________________________
void TGTextLayout::UnderlineChar(Drawable_t dst, GContext_t gc,
                                Int_t x, Int_t y, Int_t underline) const
{
   // Use the information in the TGTextLayout object to display an underline
   // below an individual character. This procedure does not draw the text,
   // just the underline.
   //
   // This procedure is useful for simple widgets that need to display
   // single-font, multi-line text with an individual character underlined
   // and want TGFont to handle the details. To display larger amounts of
   // underlined text, construct and use an underlined font.
   //
   // dst       -- Window or pixmap in which to draw.
   // gc        -- Graphics context to use for drawing text.
   // x, y      -- Upper-left hand corner of rectangle in which to draw
   //              (pixels).
   // underline -- Index of the single character to underline, or -1 for
   //              no underline.

   int xx, yy, width, height;

   if ((CharBbox(underline, &xx, &yy, &width, &height) != 0)
      && (width != 0)) {
      gVirtualX->FillRectangle(dst, gc, x + xx,
                               y + yy + fFont->fFM.fAscent + fFont->fUnderlinePos,
                               (UInt_t) width, (UInt_t) fFont->fUnderlineHeight);
   }
}

//______________________________________________________________________________
Int_t TGTextLayout::PointToChar(Int_t x, Int_t y) const
{
   // Use the information in the TGTextLayout token to determine the character
   // closest to the given point. The point must be specified with respect to
   // the upper-left hand corner of the text layout, which is considered to be
   // located at (0, 0).
   //
   // Any point whose y-value is less that 0 will be considered closest to the
   // first character in the text layout; any point whose y-value is greater
   // than the height of the text layout will be considered closest to the last
   // character in the text layout.
   //
   // Any point whose x-value is less than 0 will be considered closest to the
   // first character on that line; any point whose x-value is greater than the
   // width of the text layout will be considered closest to the last character
   // on that line.
   //
   // The return value is the index of the character that was closest to the
   // point. Given a text layout with no characters, the value 0 will always
   // be returned, referring to a hypothetical zero-width placeholder character.

   LayoutChunk_t *chunk, *last;
   Int_t i, n, dummy, baseline, pos;

   if (y < 0) {
      // Point lies above any line in this layout. Return the index of
      // the first char.

      return 0;
   }

   // Find which line contains the point.

   last = chunk = fChunks;
   for (i = 0; i < fNumChunks; i++) {
      baseline = chunk->fY;
      if (y < baseline + fFont->fFM.fDescent) {
         if (x < chunk->fX) {
            // Point is to the left of all chunks on this line. Return
            // the index of the first character on this line.

            return (chunk->fStart - fString);
         }
         if (x >= fWidth) {

         // If point lies off right side of the text layout, return
         // the last char in the last chunk on this line. Without
         // this, it might return the index of the first char that
         // was located outside of the text layout.

            x = INT_MAX;
         }

         // Examine all chunks on this line to see which one contains
         // the specified point.

         last = chunk;
         while ((i < fNumChunks) && (chunk->fY == baseline)) {
            if (x < chunk->fX + chunk->fTotalWidth) {

               // Point falls on one of the characters in this chunk.

               if (chunk->fNumDisplayChars < 0) {

                  // This is a special chunk that encapsulates a single
                  // tab or newline char.

                  return (chunk->fStart - fString);
               }
               n = fFont->MeasureChars(chunk->fStart, chunk->fNumChars,
                                       x + 1 - chunk->fX, kTextPartialOK, &dummy);
               return ((chunk->fStart + n - 1) - fString);
            }
            last = chunk;
            chunk++;
            i++;
         }

         // Point is to the right of all chars in all the chunks on this
         // line. Return the index just past the last char in the last
         // chunk on this line.

         pos = (last->fStart + last->fNumChars) - fString;
         if (i < fNumChunks) pos--;
         return pos;
      }
      last = chunk;
      chunk++;
   }

   // Point lies below any line in this text layout. Return the index
   // just past the last char.

   return ((last->fStart + last->fNumChars) - fString);
}

//______________________________________________________________________________
Int_t TGTextLayout::CharBbox(Int_t index, Int_t *x, Int_t *y, Int_t *w, Int_t *h) const
{
   // Use the information in the TGTextLayout token to return the bounding box
   // for the character specified by index.
   //
   // The width of the bounding box is the advance width of the character, and
   // does not include and left- or right-bearing. Any character that extends
   // partially outside of the text layout is considered to be truncated at the
   // edge. Any character which is located completely outside of the text
   // layout is considered to be zero-width and pegged against the edge.
   //
   // The height of the bounding box is the line height for this font,
   // extending from the top of the ascent to the bottom of the descent.
   // Information about the actual height of the individual letter is not
   // available.
   //
   // A text layout that contains no characters is considered to contain a
   // single zero-width placeholder character.
   //
   // The return value is 0 if the index did not specify a character in the
   // text layout, or non-zero otherwise. In that case, *bbox is filled with
   // the bounding box of the character.
   //
   // layout -- Layout information, from a previous call to ComputeTextLayout().
   // index  -- The index of the character whose bbox is desired.
   // x, y   -- Filled with the upper-left hand corner, in pixels, of the
   //           bounding box for the character specified by index, if non-NULL.
   // w, h   -- Filled with the width and height of the bounding box for the
   //           character specified by index, if non-NULL.

   LayoutChunk_t *chunk;
   Int_t i, xx = 0, ww = 0;

   if (index < 0) {
      return 0;
   }

   chunk = fChunks;

   for (i = 0; i < fNumChunks; i++) {
      if (chunk->fNumDisplayChars < 0) {
         if (!index) {
            xx = chunk->fX;
            ww = chunk->fTotalWidth;
            goto check;
         }
      } else if (index < chunk->fNumChars) {
         if (x) {
            fFont->MeasureChars(chunk->fStart, index, 0, 0, &xx);
            xx += chunk->fX;
         }
         if (w) {
            fFont->MeasureChars(chunk->fStart + index, 1, 0, 0, &ww);
         }
         goto check;
      }
      index -= chunk->fNumChars;
      chunk++;
   }
   if (!index) {

      // Special case to get location just past last char in layout.

      chunk--;
      xx = chunk->fX + chunk->fTotalWidth;
      ww = 0;
   } else {
      return 0;
   }

   // Ensure that the bbox lies within the text layout. This forces all
   // chars that extend off the right edge of the text layout to have
   // truncated widths, and all chars that are completely off the right
   // edge of the text layout to peg to the edge and have 0 width.

check:
   if (y) {
      *y = chunk->fY - fFont->fFM.fAscent;
   }
   if (h) {
      *h = fFont->fFM.fAscent + fFont->fFM.fDescent;
   }
   if (xx > fWidth) {
      xx = fWidth;
   }
   if (x) {
      *x = xx;
   }
   if (w) {
      if (xx + ww > fWidth) {
         ww = fWidth - xx;
      }
      *w = ww;
   }
   return 1;
}

//______________________________________________________________________________
Int_t TGTextLayout::DistanceToText(Int_t x, Int_t y) const
{
   // Computes the distance in pixels from the given point to the given
   // text layout. Non-displaying space characters that occur at the end of
   // individual lines in the text layout are ignored for hit detection
   // purposes.
   //
   // The return value is 0 if the point (x, y) is inside the text layout.
   // If the point isn't inside the text layout then the return value is the
   // distance in pixels from the point to the text item.
   //
   // x, y -- Coordinates of point to check, with respect to the upper-left
   //         corner of the text layout (in pixels).

   Int_t i, x1, x2, y1, y2, xDiff, yDiff, dist, minDist, ascent, descent;
   LayoutChunk_t *chunk;

   ascent = fFont->fFM.fAscent;
   descent = fFont->fFM.fDescent;

   minDist = 0;
   chunk = fChunks;
   for (i = 0; i < fNumChunks; i++) {
      if (chunk->fStart[0] == '\n') {

         // Newline characters are not counted when computing distance
         // (but tab characters would still be considered).

         chunk++;
         continue;
      }
      x1 = chunk->fX;
      y1 = chunk->fY - ascent;
      x2 = chunk->fX + chunk->fDisplayWidth;
      y2 = chunk->fY + descent;

      if (x < x1) {
         xDiff = x1 - x;
      } else if (x >= x2) {
         xDiff = x - x2 + 1;
      } else {
         xDiff = 0;
      }

      if (y < y1) {
         yDiff = y1 - y;
      } else if (y >= y2) {
         yDiff = y - y2 + 1;
      } else {
         yDiff = 0;
      }
      if ((xDiff == 0) && (yDiff == 0)) {
         return 0;
      }
      dist = (int) TMath::Hypot((Double_t) xDiff, (Double_t) yDiff);
      if ((dist < minDist) || !minDist) {
         minDist = dist;
      }
      chunk++;
   }
   return minDist;
}

//______________________________________________________________________________
Int_t TGTextLayout::IntersectText(Int_t x, Int_t y, Int_t w, Int_t h) const
{
   // Determines whether a text layout lies entirely inside, entirely outside,
   // or overlaps a given rectangle. Non-displaying space characters that occur
   // at the end of individual lines in the text layout are ignored for
   // intersection calculations.
   //
   // The return value is -1 if the text layout is entirely outside of the
   // rectangle, 0 if it overlaps, and 1 if it is entirely inside of the
   // rectangle.
   //
   // x, y -- Upper-left hand corner, in pixels, of rectangular area to compare
   //         with text layout. Coordinates are with respect to the upper-left
   //         hand corner of the text layout itself.
   // w, h -- The width and height of the above rectangular area, in pixels.

   Int_t result, i, x1, y1, x2, y2;
   LayoutChunk_t *chunk;
   Int_t left, top, right, bottom;

   // Scan the chunks one at a time, seeing whether each is entirely in,
   // entirely out, or overlapping the rectangle.  If an overlap is
   // detected, return immediately; otherwise wait until all chunks have
   // been processed and see if they were all inside or all outside.

   chunk = fChunks;

   left = x;
   top = y;
   right = x + w;
   bottom = y + h;

   result = 0;
   for (i = 0; i < fNumChunks; i++) {
      if (chunk->fStart[0] == '\n') {

         // Newline characters are not counted when computing area
         // intersection (but tab characters would still be considered).

         chunk++;
         continue;
      }
      x1 = chunk->fX;
      y1 = chunk->fY - fFont->fFM.fAscent;
      x2 = chunk->fX + chunk->fDisplayWidth;
      y2 = chunk->fY + fFont->fFM.fDescent;

      if ((right < x1) || (left >= x2) || (bottom < y1) || (top >= y2)) {
         if (result == 1) {
            return 0;
         }
         result = -1;
      } else if ((x1 < left) || (x2 >= right) || (y1 < top) || (y2 >= bottom)) {
         return 0;
      } else if (result == -1) {
         return 0;
      } else {
         result = 1;
      }
      chunk++;
   }
   return result;
}

//______________________________________________________________________________
void TGTextLayout::ToPostscript(TString *result) const
{
   // Outputs the contents of a text layout in Postscript format. The set of
   // lines in the text layout will be rendered by the user supplied Postscript
   // function. The function should be of the form:
   //
   //     justify x y string  function  --
   //
   // Justify is -1, 0, or 1, depending on whether the following string should
   // be left, center, or right justified, x and y is the location for the
   // origin of the string, string is the sequence of characters to be printed,
   // and function is the name of the caller-provided function; the function
   // should leave nothing on the stack.
   //
   // The meaning of the origin of the string (x and y) depends on the
   // justification. For left justification, x is where the left edge of the
   // string should appear. For center justification, x is where the center of
   // the string should appear. And for right justification, x is where the
   // right edge of the string should appear. This behavior is necessary
   // because, for example, right justified text on the screen is justified
   // with screen metrics. The same string needs to be justified with printer
   // metrics on the printer to appear in the correct place with respect to
   // other similarly justified strings. In all circumstances, y is the
   // location of the baseline for the string.
   //
   // result is modified to hold the Postscript code that will render the text
   // layout.

#define MAXUSE 128
   char buf[MAXUSE + 10];
   LayoutChunk_t *chunk;
   Int_t i, j, used, c, baseline;

   chunk = fChunks;
   baseline = chunk->fY;
   used = 0;
   buf[used++] = '(';

   for (i = 0; i < fNumChunks; i++) {
      if (baseline != chunk->fY) {
         buf[used++] = ')';
         buf[used++] = '\n';
         buf[used++] = '(';
         baseline = chunk->fY;
      }
      if (chunk->fNumDisplayChars <= 0) {
         if (chunk->fStart[0] == '\t') {
            buf[used++] = '\\';
            buf[used++] = 't';
         }
      } else {
         for (j = 0; j < chunk->fNumDisplayChars; j++) {
            c = UChar_t(chunk->fStart[j]);
            if ((c == '(') || (c == ')') || (c == '\\') || (c < 0x20) || (c >= UChar_t(0x7f))) {

            // Tricky point: the "03" is necessary in the sprintf
            // below, so that a full three digits of octal are
            // always generated. Without the "03", a number
            // following this sequence could be interpreted by
            // Postscript as part of this sequence.

               // coverity[secure_coding]
               sprintf(buf + used, "\\%03o", c);
               used += 4;
            } else {
               buf[used++] = c;
            }
            if (used >= MAXUSE) {
               buf[used] = '\0';
               result->Append(buf);
               used = 0;
            }
         }
      }
      if (used >= MAXUSE) {
         // If there are a whole bunch of returns or tabs in a row,
         // then buf[] could get filled up.

         buf[used] = '\0';
         result->Append(buf);
         used = 0;
      }
      chunk++;
   }
   buf[used++] = ')';
   buf[used++] = '\n';
   buf[used]   = '\0';

   result->Append(buf);
}

//______________________________________________________________________________
LayoutChunk_t *TGFont::NewChunk(TGTextLayout *layout, Int_t *maxPtr,
                                const char *start, Int_t numChars,
                                Int_t curX, Int_t newX, Int_t y) const
{
   // Helper function for ComputeTextLayout(). Encapsulates a measured set of
   // characters in a chunk that can be quickly drawn.
   //
   // Returns a pointer to the new chunk in the text layout. The text layout is
   // reallocated to hold more chunks as necessary.
   //
   // Currently, ComputeTextLayout() stores contiguous ranges of "normal"
   // characters in a chunk, along with individual tab and newline chars in
   // their own chunks. All characters in the text layout are accounted for.

   LayoutChunk_t *chunk;
   Int_t i, maxChunks;

   maxChunks = *maxPtr;
   if (layout->fNumChunks == maxChunks) {
      if (maxChunks == 0) {
         maxChunks = 1;
      } else {
         maxChunks *= 2;
      }
      chunk = new LayoutChunk_t[maxChunks];

      if (layout->fNumChunks > 0) {
         for (i=0; i<layout->fNumChunks; ++i) chunk[i] = layout->fChunks[i];
         delete[] layout->fChunks;
      }
      layout->fChunks = chunk;
      *maxPtr = maxChunks;
   }

   chunk = &layout->fChunks[layout->fNumChunks];
   chunk->fStart = start;
   chunk->fNumChars = numChars;
   chunk->fNumDisplayChars = numChars;
   chunk->fX = curX;
   chunk->fY = y;
   chunk->fTotalWidth = newX - curX;
   chunk->fDisplayWidth = newX - curX;
   layout->fNumChunks++;

   return chunk;
}

//______________________________________________________________________________
void TGFont::DrawCharsExp(Drawable_t dst, GContext_t gc,
                          const char *source, Int_t numChars,
                          Int_t x, Int_t y) const
{
   // Draw a string of characters on the screen. DrawCharsExp() expands
   // control characters that occur in the string to \X or \xXX sequences.
   // DrawChars() just draws the strings.
   //
   // dst      -- Window or pixmap in which to draw.
   // gc       -- Graphics context for drawing characters.
   // source   -- Characters to be displayed. Need not be'\0' terminated.
   //             For DrawChars(), all meta-characters (tabs, control
   //             characters, and newlines) should be stripped out of the
   //             string that is passed to this function. If they are not
   //             stripped out, they will be displayed as regular printing
   //             characters.
   // numChars -- Number of characters in string.
   // x, y     -- Coordinates at which to place origin of string when drawing.

   const char *p;
   Int_t i, type;
   char buf[4];

   p = source;
   for (i = 0; i < numChars; i++) {
      type = fTypes[UChar_t(*p)];
      if (type != kCharNormal) {
         DrawChars(dst, gc, source, p - source, x, y);
         x += gVirtualX->TextWidth(fFontStruct, source, p - source);
         if (type == kCharReplace) {
            DrawChars(dst, gc, buf, GetControlCharSubst(UChar_t(*p), buf), x, y);
            x += fWidths[UChar_t(*p)];
         }
         source = p + 1;
      }
      p++;
   }

   DrawChars(dst, gc, source, p - source, x, y);
}

//______________________________________________________________________________
void TGFont::DrawChars(Drawable_t dst, GContext_t gc,
                       const char *source, Int_t numChars,
                       Int_t x, Int_t y) const
{
   // Perform a quick sanity check to ensure we won't overflow the X
   // coordinate space.

   Int_t max_width =  gVirtualX->TextWidth(fFontStruct, "@", 1);

   if ((x + (max_width * numChars) > 0x7fff)) {
      int length;

      // The string we are being asked to draw is too big and would overflow
      // the X coordinate space. Unfortunatley X servers aren't too bright
      // and so they won't deal with this case cleanly. We need to truncate
      // the string before sending it to X.

      numChars = MeasureChars(source, numChars, 0x7fff - x, 0, &length);
   }

   gVirtualX->DrawString(dst, gc, x, y, source, numChars);

   if (fFA.fUnderline != 0) {
      gVirtualX->FillRectangle(dst, gc, x,  y + fUnderlinePos,
                          (UInt_t) gVirtualX->TextWidth(fFontStruct, source, numChars),
                          (UInt_t) fBarHeight);
   }
   if (fFA.fOverstrike != 0) {
      y -= fFM.fDescent + fFM.fAscent / 10;
      gVirtualX->FillRectangle(dst, gc, x, y,
                          (UInt_t) gVirtualX->TextWidth(fFontStruct, source, numChars),
                          (UInt_t) fBarHeight);
   }
}

//______________________________________________________________________________
TGFontPool::TGFontPool(TGClient *client)
{
   // Create a font pool.

   fClient = client;
   fList   = new THashTable(50);
   fList->SetOwner();

   fNamedTable = new THashTable(50);
   fNamedTable->SetOwner();

   fUidTable = new THashTable(50);
   fUidTable->SetOwner();
}

//______________________________________________________________________________
TGFontPool::~TGFontPool()
{
   // Cleanup font pool.

   delete fList;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetFont(const char *font, Bool_t fixedDefault)
{
   // Get the specified font.
   // The font can be one of the following forms:
   //        XLFD (see X documentation)
   //        "Family [size [style] [style ...]]"
   // Returns 0 if error or no font can be found.
   // If fixedDefault is false the "fixed" font will not be substituted
   // as fallback when the asked for font does not exist.

   if (!font || !*font) {
      Error("GetFont", "argument may not be 0 or empty");
      return 0;
   }

   TGFont *f = (TGFont*)fList->FindObject(font);

   if (f) {
      f->AddReference();
      return f;
   }

   TNamedFont *nf = (TNamedFont*)fNamedTable->FindObject(font);

   if (nf) {
      // Construct a font based on a named font.
      nf->AddReference();
      f = GetFontFromAttributes(&nf->fFA, 0);

   } else {

      // Native font (aka string in XLFD format)?
      Int_t errsav = gErrorIgnoreLevel;
      gErrorIgnoreLevel = kFatal;

      f = GetNativeFont(font, fixedDefault);
      gErrorIgnoreLevel = errsav;

      if (!f) {
         FontAttributes_t fa;

         if (!ParseFontName(font, &fa)) {
            //fontCache.DeleteHashEntry(cacheHash);

            return 0;
         }

         // String contained the attributes inline.
         f = GetFontFromAttributes(&fa, 0);
      }
   }

   if (!f) return 0;

   fList->Add(f);

   f->SetRefCount(1);
   //f->cacheHash = cacheHash;
   f->fNamedHash = nf;

   f->MeasureChars("0", 1, 0, 0, &f->fTabWidth);

   if (!f->fTabWidth) {
      f->fTabWidth = f->fFM.fMaxWidth;
   }
   f->fTabWidth *= 8;

   // Make sure the tab width isn't zero (some fonts may not have enough
   // information to set a reasonable tab width).

   if (!f->fTabWidth) {
      f->fTabWidth = 1;
   }

   // Get information used for drawing underlines in generic code on a
   // non-underlined font.

   Int_t descent = f->fFM.fDescent;
   f->fUnderlinePos = descent/2;  // ==!== could be set by MakeFont()
   f->fUnderlineHeight = f->fFA.fPointsize/10;

   if (!f->fUnderlineHeight) {
      f->fUnderlineHeight = 1;
   }
   if (f->fUnderlinePos + f->fUnderlineHeight > descent) {

      // If this set of values would cause the bottom of the underline
      // bar to stick below the descent of the font, jack the underline
      // up a bit higher.

      f->fUnderlineHeight = descent - f->fUnderlinePos;

      if (!f->fUnderlineHeight) {
         f->fUnderlinePos--;
         f->fUnderlineHeight = 1;
      }
   }

   return f;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetFont(const TGFont *font)
{
   // Use font, i.e. increases ref count of specified font. Returns 0
   // if font is not found.

   TGFont *f = (TGFont*)fList->FindObject(font);

   if (f) {
      f->AddReference();
      return f;
   }

   return 0;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetFont(FontStruct_t fs)
{
   // Use font, i.e. increases ref count of specified font.

   TGFont *f = FindFont(fs);

   if (f) {
      f->AddReference();
      return f;
   }

   static int i = 0;
   f = MakeFont(0, fs, TString::Format("unknown-%d", i));
   fList->Add(f);
   i++;

   return f;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetFont(const char *family, Int_t ptsize, Int_t weight, Int_t slant)
{
   // Returns font specified bay family, pixel/point size, weight and slant
   //  negative value of ptsize means size in pixels
   //  positive value of ptsize means size in points
   //
   //  For example:
   //    TGFont *font = fpool->GetFont("helvetica", -9, kFontWeightNormal, kFontSlantRoman);
   //    font->Print();

   const char *s;
   TString tmp;

   tmp = TString::Format("%s %d", family, ptsize);
   s = FindStateString(gWeightMap, weight);
   if (s) {
      tmp += " ";
      tmp + s;
   }
   s = FindStateString(gSlantMap, slant);
   if (s) {
      tmp += " ";
      tmp += s;
   }
   return GetFont(tmp.Data());
}

//______________________________________________________________________________
void TGFontPool::FreeFont(const TGFont *font)
{
   // Free font. If ref count is 0 delete font.

   TGFont *f = (TGFont*) fList->FindObject(font);
   if (f) {
      if (f->RemoveReference() == 0) {
         if (font->fNamedHash) {

            // The font is being deleted. Determine if the associated named
            // font definition should and/or can be deleted too.

            TNamedFont *nf = (TNamedFont *) font->fNamedHash;

            if ((nf->RemoveReference() == 0) && (nf->fDeletePending != 0)) {
               fNamedTable->Remove(nf);
               delete nf;
            }
         }
         fList->Remove(f);
         delete font;
      }
   }
}

//______________________________________________________________________________
TGFont *TGFontPool::FindFont(FontStruct_t font) const
{
   // Find font based on its font struct. Returns 0 if font is not found.

   TIter next(fList);
   TGFont *f = 0;

   while ((f = (TGFont*) next())) {
      if (f->fFontStruct == font) {
         return f;
      }
   }

   return 0;
}

//______________________________________________________________________________
TGFont *TGFontPool::FindFontByHandle(FontH_t font) const
{
   // Find font based on its font handle. Returns 0 if font is not found.

   TIter next(fList);
   TGFont *f = 0;

   while ((f = (TGFont*) next())) {
      if (f->fFontH == font) {
         return f;
      }
   }

   return 0;
}

//______________________________________________________________________________
const char *TGFontPool::GetUid(const char *string)
{
   // Given a string, this procedure returns a unique identifier for the string.
   //
   // This procedure returns a pointer to a new char string corresponding to
   // the "string" argument. The new string has a value identical to string
   // (strcmp will return 0), but it's guaranteed that any other calls to this
   // procedure with a string equal to "string" will return exactly the same
   // result (i.e. can compare pointer *values* directly, without having to
   // call strcmp on what they point to).

   TObjString *obj = 0;
   obj = (TObjString*)fUidTable->FindObject(string);

   if (!obj) {
      obj = new TObjString(string);
      fUidTable->Add(obj);
   }

   return (const char *)obj->GetName();
}

//______________________________________________________________________________
char **TGFontPool::GetAttributeInfo(const FontAttributes_t *fa)
{
   // Return information about the font attributes as an array of strings.
   //
   // An array of FONT_NUMFIELDS strings is returned holding the value of the
   // font attributes in the following order:
   // family size weight slant underline overstrike

   Int_t i, num;
   const char *str = 0;

   char **result = new char*[FONT_NUMFIELDS];

   for (i = 0; i < FONT_NUMFIELDS; ++i) {
      str = 0;
      num = 0;

      switch (i) {
      case FONT_FAMILY:
         str = fa->fFamily;
         if (!str) str = "";
         break;

      case FONT_SIZE:
         num = fa->fPointsize;
         break;

      case FONT_WEIGHT:
         str = FindStateString(gWeightMap, fa->fWeight);
         break;

      case FONT_SLANT:
         str = FindStateString(gSlantMap, fa->fSlant);
         break;

      case FONT_UNDERLINE:
         num = fa->fUnderline;
         break;

      case FONT_OVERSTRIKE:
         num = fa->fOverstrike;
         break;
      }

      if (str) {
         int len = strlen(str)+1;
         result[i] = new char[len];
         strlcpy(result[i], str, len);
      } else {
         result[i] = new char[20];
         snprintf(result[i], 20, "%d", num);
      }
   }

   return result;
}

//______________________________________________________________________________
void TGFontPool::FreeAttributeInfo(char **info)
{
   // Free attributes info.

   Int_t i;

   if (info) {
      for (i = 0; i < FONT_NUMFIELDS; ++i) {
         if (info[i]) {
            delete[] info[i];
         }
      }
      delete[] info;
   }
}

//______________________________________________________________________________
void TGFontPool::Print(Option_t *opt) const
{
   // List all fonts in the pool.

   fList->Print(opt);
}

//______________________________________________________________________________
void TGFont::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
{
    // Save the used font as a C++ statement(s) on output stream out.

   char quote = '"';

   if (gROOT->ClassSaved(TGFont::Class())) {
      out << std::endl;
   } else {
      //  declare a font object to reflect required user changes
      out << std::endl;
      out << "   TGFont *ufont;         // will reflect user font changes" << std::endl;
   }
   out << "   ufont = gClient->GetFont(" << quote << GetName() << quote << ");" << std::endl;
}

//______________________________________________________________________________
static char *GetToken(char *str)
{
   static char *p = 0;
   char *retp;

   if (str) p = str;

   if (!p) {
      return 0;
   }
   if (!*p) {
      return 0;
   }

   while (*p && ((*p == ' ') || (*p == '\t'))) {   // skip spaces
      ++p;
   }

   if (!*p) {
      return 0;
   }

   if (*p == '"') {  // quoted string
      retp = ++p;

      if (!*p) {
         return 0;
      }

      while (*p && (*p != '"')) {
         ++p;
      }

      if (*p == '"') {
         *p++ = '\0';
      }
   } else {
      retp = p;
      while (*p && (*p != ' ') && (*p != '\t')) {
         ++p;
      }
      if (*p) {
         *p++ = '\0';
      }
   }

   return retp;
}

//______________________________________________________________________________
Bool_t TGFontPool::ParseFontName(const char *string, FontAttributes_t *fa)
{
   // Converts a string into a set of font attributes that can be used to
   // construct a font.
   //
   // The string can be one of the following forms:
   //        XLFD (see X documentation)
   //        "Family [size [style] [style ...]]"
   //
   // The return value is kFALSE if the object was syntactically
   // invalid. Otherwise, fills the font attribute buffer with the values
   // parsed from the string and returns kTRUE. The structure must already be
   // properly initialized.

   char *s;
   int n, result;

   XLFDAttributes_t xa;

   int len = strlen(string)+1;
   char *str = new char[len];
   strlcpy(str, string, len);

   if (*str == '-' || *str == '*') {

    // This appears to be an XLFD.

      xa.fFA = *fa;
      result = ParseXLFD(str, &xa);
      if (result) {
         *fa = xa.fFA;
         delete[] str;
         return kTRUE;  //OK
      }
   }

   // Wasn't an XLFD or "-option value" string. Try it as a
   // "font size style" list.

   s = GetToken(str);
   if (!s) {
      delete[] str;
      return kFALSE;
   }
   fa->fFamily = GetUid(s);

   s = GetToken(0);

   if (s) {
      char *end;

      fa->fPointsize = strtol(s, &end, 0);
      if ((errno == ERANGE) || (end == s)) {
         return kFALSE;
      }
   }

   while ((s = GetToken(0))) {
      n = FindStateNum(gWeightMap, s);
      if ((EFontWeight)n != kFontWeightUnknown) {
         fa->fWeight = n;
         continue;
      }
      n = FindStateNum(gSlantMap, s);
      // tell coverity that n is an integer value, and not an enum, even if
      // we compare it with an enum value (which is -1 in both case anyway)
      // coverity[mixed_enums]
      if ((EFontSlant)n != kFontSlantUnknown) {
         fa->fSlant = n;
         continue;
      }
      n = FindStateNum(gUnderlineMap, s);
      if (n) {
         fa->fUnderline = n;
         continue;
      }
      n = FindStateNum(gOverstrikeMap, s);
      if (n) {
         fa->fOverstrike = n;
         continue;
      }

      // Unknown style.

      delete[] str;
      return kFALSE;
   }

   delete[] str;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TGFontPool::ParseXLFD(const char *string, XLFDAttributes_t *xa)
{
   // Break up a fully specified XLFD into a set of font attributes.
   //
   // Return value is kFALSE if string was not a fully specified XLFD.
   // Otherwise, fills font attribute buffer with the values parsed from
   // the XLFD and returns kTRUE.
   //
   // string -- Parseable font description string.
   // xa     -- XLFD attributes structure whose fields are to be modified.
   //           Structure must already be properly initialized.

   char *src;
   const char *str;
   int i, j;
   char *field[XLFD_NUMFIELDS + 2];
   TString ds("");

   memset(field, '\0', sizeof (field));

   str = string;
   if (*str == '-') str++;

   ds.Append((char *) str);
   src = (char*)ds.Data();

   field[0] = src;
   for (i = 0; *src != '\0'; src++) {
      if (isupper(UChar_t(*src))) {
         *src = tolower(UChar_t(*src));
      }
      if (*src == '-') {
         i++;
         if (i > XLFD_NUMFIELDS) {
           break;
         }
         *src = '\0';
         field[i] = src + 1;
      }
   }

   // An XLFD of the form -adobe-times-medium-r-*-12-*-* is pretty common,
   // but it is (strictly) malformed, because the first * is eliding both
   // the Setwidth and the Addstyle fields. If the Addstyle field is a
   // number, then assume the above incorrect form was used and shift all
   // the rest of the fields up by one, so the number gets interpreted
   // as a pixelsize.

   if ((i > XLFD_ADD_STYLE) && (FieldSpecified(field[XLFD_ADD_STYLE]))) {
      if (atoi(field[XLFD_ADD_STYLE]) != 0) {
         for (j = XLFD_NUMFIELDS - 1; j >= XLFD_ADD_STYLE; j--) {
            field[j + 1] = field[j];
         }
         field[XLFD_ADD_STYLE] = 0;
         i++;
      }
   }

   // Bail if we don't have enough of the fields (up to pointsize).

   if (i < XLFD_FAMILY) {
      return kFALSE;
   }
   if (FieldSpecified(field[XLFD_FOUNDRY])) {
      xa->fFoundry = GetUid(field[XLFD_FOUNDRY]);
   }
   if (FieldSpecified(field[XLFD_FAMILY])) {
      xa->fFA.fFamily = GetUid(field[XLFD_FAMILY]);
   }
   if (FieldSpecified(field[XLFD_WEIGHT])) {
      xa->fFA.fWeight = FindStateNum(gXlfdgWeightMap, field[XLFD_WEIGHT]);
   }
   if (FieldSpecified(field[XLFD_SLANT])) {
      xa->fSlant = FindStateNum(gXlfdSlantMap, field[XLFD_SLANT]);
      if (xa->fSlant == kFontSlantRoman) {
         xa->fFA.fSlant = kFontSlantRoman;
      } else {
         xa->fFA.fSlant = kFontSlantItalic;
      }
   }
   if (FieldSpecified(field[XLFD_SETWIDTH])) {
      xa->fSetwidth = FindStateNum(gXlfdSetwidthMap, field[XLFD_SETWIDTH]);
   }
   // XLFD_ADD_STYLE ignored.

   // Pointsize in tenths of a point, but treat it as tenths of a pixel.

   if (FieldSpecified(field[XLFD_POINT_SIZE])) {
      if (field[XLFD_POINT_SIZE][0] == '[') {

         // Some X fonts have the point size specified as follows:
         //
         //      [ N1 N2 N3 N4 ]
         //
         // where N1 is the point size (in points, not decipoints!), and
         // N2, N3, and N4 are some additional numbers that I don't know
         // the purpose of, so I ignore them.

         xa->fFA.fPointsize = atoi(field[XLFD_POINT_SIZE] + 1);
      } else {
         char *end;

         xa->fFA.fPointsize = strtol(field[XLFD_POINT_SIZE], &end, 0);
         if (errno == ERANGE || end == field[XLFD_POINT_SIZE]) {
            return kFALSE;
         }
         xa->fFA.fPointsize /= 10;
      }
   }

   // Pixel height of font. If specified, overrides pointsize.

   if (FieldSpecified(field[XLFD_PIXEL_SIZE])) {
      if (field[XLFD_PIXEL_SIZE][0] == '[') {

         // Some X fonts have the pixel size specified as follows:
         //
         //      [ N1 N2 N3 N4 ]
         //
         // where N1 is the pixel size, and where N2, N3, and N4
         // are some additional numbers that I don't know
         // the purpose of, so I ignore them.

         xa->fFA.fPointsize = atoi(field[XLFD_PIXEL_SIZE] + 1);
      } else {
         char *end;

         xa->fFA.fPointsize = strtol(field[XLFD_PIXEL_SIZE], &end, 0);
         if (errno == ERANGE || end == field[XLFD_PIXEL_SIZE]) {
            return kFALSE;
         }
      }
   }
   xa->fFA.fPointsize = -xa->fFA.fPointsize;

   // XLFD_RESOLUTION_X ignored.

   // XLFD_RESOLUTION_Y ignored.

   // XLFD_SPACING ignored.

   // XLFD_AVERAGE_WIDTH ignored.

   if (FieldSpecified(field[XLFD_REGISTRY])) {
      xa->fCharset = FindStateNum(gXlfdCharsetMap, field[XLFD_REGISTRY]);
   }
   if (FieldSpecified(field[XLFD_ENCODING])) {
      xa->fEncoding = atoi(field[XLFD_ENCODING]);
   }

   return kTRUE;
}

//______________________________________________________________________________
Int_t TGFontPool::FindStateNum(const FontStateMap_t *map, const char *strKey)
{
   // Given a lookup table, map a string to a number in the table.
   //
   // If strKey was equal to the string keys of one of the elements in the
   // table, returns the numeric key of that element. Returns the numKey
   // associated with the last element (the NULL string one) in the table
   // if strKey was not equal to any of the string keys in the table.

   const FontStateMap_t *m;

   if (!map->fStrKey) {
      return 0;
   }

   for (m = map; m->fStrKey != 0; m++) {
      if (strcasecmp(strKey, m->fStrKey) == 0) {
         return m->fNumKey;
      }
   }
   return m->fNumKey;
}

//______________________________________________________________________________
const char *TGFontPool::FindStateString(const FontStateMap_t *map, Int_t numKey)
{
   // Given a lookup table, map a number to a string in the table.
   //
   // If numKey was equal to the numeric key of one of the elements in the
   // table, returns the string key of that element. Returns NULL if numKey
   // was not equal to any of the numeric keys in the table

   for ( ; map->fStrKey != 0; map++) {
      if (numKey == map->fNumKey) return map->fStrKey;
   }
   return 0;
}

//______________________________________________________________________________
Bool_t TGFontPool::FieldSpecified(const char *field)
{
   // Helper function for ParseXLFD(). Determines if a field in the XLFD was
   // set to a non-null, non-don't-care value.
   //
   // The return value is kFALSE if the field in the XLFD was not set and
   // should be ignored, kTRUE otherwise.
   //
   // field -- The field of the XLFD to check. Strictly speaking, only when
   //          the string is "*" does it mean don't-care. However, an
   //          unspecified or question mark is also interpreted as don't-care.

   char ch;

   if (!field) {
      return kFALSE;
   }
   ch = field[0];

   return (ch != '*' && ch != '?');
}

//______________________________________________________________________________
const char *TGFontPool::NameOfFont(TGFont *font)
{
   // Given a font, return a textual string identifying it.

   return font->GetName();
}

//______________________________________________________________________________
char **TGFontPool::GetFontFamilies()
{
   // Return information about the font families that are available on the
   // current display.
   //
   // An array of strings is returned holding a list of all the available font
   // families. The array is terminated with a NULL pointer.

   Int_t i, numNames;
   char *family, *end, *p;

   THashTable familyTable(100);
   familyTable.SetOwner();

   char **nameList;
   char **dst;

   // coverity[returned_null]
   // coverity[dereference]
   nameList = gVirtualX->ListFonts("*", 10000, numNames);

   for (i = 0; i < numNames; i++) {
      if (nameList[i][0] != '-') {
         continue;
      }
      family = strchr(nameList[i] + 1, '-');
      if (!family) {
         continue;
      }
      family++;
      end = strchr(family, '-');
      if (!end) {
         continue;
      }
      *end = '\0';
      for (p = family; *p != '\0'; p++) {
         if (isupper(UChar_t(*p))) {
            *p = tolower(UChar_t(*p));
         }
      }
      if (!familyTable.FindObject(family)) {
         familyTable.Add(new TObjString(family));
      }
   }

   UInt_t entries = familyTable.GetEntries();
   dst = new char*[entries+1];

   TIter next(&familyTable);
   i = 0;
   TObject *obj;

   while ((obj = next())) {
      dst[i] = StrDup(obj->GetName());
      i++;
   }
   dst[i] = 0;

   gVirtualX->FreeFontNames(nameList);
   return dst;
}

//______________________________________________________________________________
void TGFontPool::FreeFontFamilies(char **f)
{
   // Delete an array of families allocated GetFontFamilies() method

   Int_t i;

   if (!f) return;

   for (i = 0; f[i] != 0; ++i) {
      delete[] f[i];
   }
   delete[] f;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetFontFromAttributes(FontAttributes_t *fa, TGFont *fontPtr)
{
   // Given a desired set of attributes for a font, find a font with the
   // closest matching attributes and create a new TGFont object.
   // The return value is a pointer to a TGFont object that represents the
   // font with the desired attributes. If a font with the desired attributes
   // could not be constructed, some other font will be substituted
   // automatically.
   //
   // Every call to this procedure returns a new TGFont object, even if the
   // specified attributes have already been seen before.

   Int_t numNames, score, i, scaleable, pixelsize, xaPixelsize;
   Int_t bestIdx, bestScore, bestScaleableIdx, bestScaleableScore;
   XLFDAttributes_t xa;
   TString buf;
   char **nameList;
   TGFont *font;
   FontStruct_t fontStruct;
   const char *fmt, *family;

   family = fa->fFamily;
   if (!family) {
      family = "*";
   }
   pixelsize = -fa->fPointsize;

   if (pixelsize < 0) {
      double d;
      d = -pixelsize * 25.4/72;
      Int_t xx; Int_t yy; UInt_t ww; UInt_t hh;
      gVirtualX->GetWindowSize(gVirtualX->GetDefaultRootWindow(), xx, yy, ww, hh);
      d *= ww;

      d /= gVirtualX->ScreenWidthMM();
      d += 0.5;
      pixelsize = (int) d;
   }

   fontStruct = 0;

   // Couldn't find exact match. Now fall back to other available physical fonts.

   fmt = "-*-%.240s-*-*-*-*-*-*-*-*-*-*-*-*";
   buf = TString::Format(fmt, family);
   nameList = gVirtualX->ListFonts(buf.Data(), 32768, numNames);
   if (!numNames) {
      // Try getting some system font.

      buf = TString::Format(fmt, "fixed");
      // coverity[returned_null]
      // coverity[dereference]
      nameList = gVirtualX->ListFonts(buf.Data(), 32768, numNames);

      if (!numNames) {

getsystem:
         fontStruct = gVirtualX->LoadQueryFont("fixed");

         if (!fontStruct) {
            fontStruct = gVirtualX->LoadQueryFont("*");
            if (!fontStruct) {
               return 0;
            }
         }
         goto end;
      }
   }

   // Inspect each of the XLFDs and pick the one that most closely
   // matches the desired attributes.

   bestIdx = 0;
   bestScore = kMaxInt;
   bestScaleableIdx = 0;
   bestScaleableScore = kMaxInt;

   for (i = 0; i < numNames; i++) {
      score = 0;
      scaleable = 0;
      if (!ParseXLFD(nameList[i], &xa)) {
         continue;
      }
      xaPixelsize = -xa.fFA.fPointsize;

      // Since most people used to use -adobe-* in their XLFDs,
      // preserve the preference for "adobe" foundry. Otherwise
      // some applications looks may change slightly if another foundry
      // is chosen.

      if (xa.fFoundry && (strcasecmp(xa.fFoundry, "adobe") != 0)) {
         score += 3000;
      }
      if (!xa.fFA.fPointsize) {

         // A scaleable font is almost always acceptable, but the
         // corresponding bitmapped font would be better.

         score += 10;
         scaleable = 1;
      } else {

         // A font that is too small is better than one that is too big.

         if (xaPixelsize > pixelsize) {
            score += (xaPixelsize - pixelsize) * 120;
         } else {
            score += (pixelsize - xaPixelsize) * 100;
         }
      }

      score += TMath::Abs(xa.fFA.fWeight - fa->fWeight) * 30;
      score += TMath::Abs(xa.fFA.fSlant - fa->fSlant) * 25;

      if (xa.fSlant == kFontSlantOblique) {

         // Italic fonts are preferred over oblique.

         //score += 4;
      }
      if (xa.fSetwidth != kFontSWNormal) {

         // The normal setwidth is highly preferred.

         score += 2000;
      }
      if (xa.fCharset == kFontCSOther) {

         // The standard character set is highly preferred over
         // foreign languages charsets (because we don't support
         // other languages yet).

         score += 11000;
      }
      if ((xa.fCharset == kFontCSNormal) && (xa.fEncoding != 1)) {

         // The '1' encoding for the characters above 0x7f is highly
         // preferred over the other encodings.

         score += 8000;
      }
      if (scaleable) {
         if (score < bestScaleableScore) {
            bestScaleableIdx = i;
            bestScaleableScore = score;
         }
      } else {
         if (score < bestScore) {
            bestIdx = i;
            bestScore = score;
         }
      }
      if (!score) {
         break;
      }
   }

   // Now we know which is the closest matching scaleable font and the
   // closest matching bitmapped font. If the scaleable font was a
   // better match, try getting the scaleable font; however, if the
   // scalable font was not actually available in the desired pointsize,
   // fall back to the closest bitmapped font.

   fontStruct = 0;

   if (bestScaleableScore < bestScore) {
      char *str, *rest;

      // Fill in the desired pointsize info for this font.

tryscale:
      str = nameList[bestScaleableIdx];
      for (i = 0; i < XLFD_PIXEL_SIZE - 1; i++) {
         str = strchr(str + 1, '-');
      }
      rest = str;
      for (i = XLFD_PIXEL_SIZE - 1; i < XLFD_REGISTRY; i++) {
         rest = strchr(rest + 1, '-');
      }
      *str = '\0';
      buf = TString::Format("%.240s-*-%d-*-*-*-*-*%s", nameList[bestScaleableIdx], pixelsize, rest);
      *str = '-';
      fontStruct = gVirtualX->LoadQueryFont(buf.Data());
      bestScaleableScore = kMaxInt;
   }
   if (!fontStruct) {
      buf = nameList[bestIdx];
      fontStruct = gVirtualX->LoadQueryFont(buf.Data());

      if (!fontStruct) {

         // This shouldn't happen because the font name is one of the
         // names that X gave us to use, but it does anyhow.

         if (bestScaleableScore < kMaxInt) {
            goto tryscale;
         } else {
            gVirtualX->FreeFontNames(nameList);
            goto getsystem;
         }
      }
   }
   gVirtualX->FreeFontNames(nameList);

end:
   font = MakeFont(fontPtr, fontStruct, buf);
   font->fFA.fUnderline = fa->fUnderline;
   font->fFA.fOverstrike = fa->fOverstrike;

   return font;
}

//______________________________________________________________________________
TGFont *TGFontPool::GetNativeFont(const char *name, Bool_t fixedDefault)
{
   // The return value is a pointer to an TGFont object that represents the
   // native font. If a native font by the given name could not be found,
   // the return value is NULL.
   //
   // Every call to this procedure returns a new TGFont object, even if the
   // name has already been seen before. The caller should call FreeFont
   // when the font is no longer needed.

   FontStruct_t fontStruct;
   fixedDefault = fixedDefault && ((*name == '-') || (*name == '*'));
   fontStruct = fClient->GetFontByName(name, fixedDefault);

   if (!fontStruct) {
      return 0;
   }

   return MakeFont(0, fontStruct, name);
}

//______________________________________________________________________________
TGFont *TGFontPool::MakeFont(TGFont *font, FontStruct_t fontStruct,
                             const char *fontName)
{
   // Helper for GetNativeFont() and GetFontFromAttributes(). Creates and
   // intializes a new TGFont object.
   //
   // font       -- If non-NULL, store the information in this existing TGFont
   //               object, rather than creating a new one; the existing
   //               contents of the font will be released. If NULL, a new
   //               TGFont object is created.
   // fontStruct -- information about font.
   // fontName   -- The string passed to TVirtualX::LoadQueryFont() to construct the
   //               fontStruct.

   TGFont *newFont;

   Int_t i, width, firstChar, lastChar, n, replaceOK;
   char *p;
   char buf[4];
   XLFDAttributes_t xa;

   if (font) {
      gVirtualX->FreeFontStruct(font->fFontStruct);
      newFont = font;
   } else {
      newFont = new TGFont(fontName);
   }

   if (!ParseXLFD(fontName, &xa)) {
      newFont->fFA.fFamily = GetUid(fontName);
   } else {
      newFont->fFA = xa.fFA;
   }

   if (newFont->fFA.fPointsize < 0) {
      double d;
      Int_t xx; Int_t yy; UInt_t ww; UInt_t hh;
      gVirtualX->GetWindowSize(gVirtualX->GetDefaultRootWindow(), xx, yy, ww, hh);
      d = -newFont->fFA.fPointsize * 72/25.4;
      d *= gVirtualX->ScreenWidthMM();
      d /= ww;
      d += 0.5;
      newFont->fFA.fPointsize = (int) d;
   }

   Int_t ascent;
   Int_t descent;
   gVirtualX->GetFontProperties(fontStruct, ascent, descent);

   newFont->fFM.fAscent = ascent;
   newFont->fFM.fDescent = descent;
   newFont->fFM.fLinespace = ascent + descent;
   newFont->fFM.fMaxWidth = gVirtualX->TextWidth(fontStruct, "@", 1);
   newFont->fFM.fFixed = kTRUE;
   newFont->fFontStruct = fontStruct;
   newFont->fFontH      = gVirtualX->GetFontHandle(fontStruct);

   // Classify the characters.

   firstChar = 0x20; //fontStruct->min_char_or_byte2;
   lastChar = 0xff; //fontStruct->max_char_or_byte2;

   for (i = 0; i < 256; i++) {
      if ((i == 160) || (i == 173) || (i == 177) ||
          (i < firstChar) || (i > lastChar)) {
         newFont->fTypes[i] = kCharReplace;
      } else {
         newFont->fTypes[i] = kCharNormal;
      }
   }

   // Compute the widths for all the normal characters. Any other
   // characters are given an initial width of 0. Also, this determines
   // if this is a fixed or variable width font, by comparing the widths
   // of all the normal characters.

   char ch[2] = {0, 0};
   width = 0;
   for (i = 0; i < 256; i++) {
      if (newFont->fTypes[i] != kCharNormal) {
         n = 0;
      } else {
         ch[0] = i;
         n = gVirtualX->TextWidth(fontStruct, ch, 1);
      }
      newFont->fWidths[i] = n;
      if (n) {
         if (!width) {
            width = n;
         } else if (width != n) {
            newFont->fFM.fFixed = kFALSE;
         }
      }
   }

   // Compute the widths of the characters that should be replaced with
   // control character expansions. If the appropriate chars are not
   // available in this font, then control character expansions will not
   // be used; control chars will be invisible & zero-width.

   replaceOK = kTRUE;
   for (p = gHexChars; *p != '\0'; p++) {
      if ((UChar_t(*p) < firstChar) || (UChar_t(*p) > lastChar)) {
         replaceOK = kFALSE;
         break;
      }
   }
   for (i = 0; i < 256; i++) {
      if (newFont->fTypes[i] == kCharReplace) {
         if (replaceOK) {
            n = GetControlCharSubst(i, buf);
            for (; --n >= 0;) {
               newFont->fWidths[i] += newFont->fWidths[UChar_t(buf[n])];
            }
         } else {
            newFont->fTypes[i] = kCharSkip;
         }
      }
   }

   newFont->fUnderlinePos = descent >> 1;
   newFont->fBarHeight = newFont->fWidths[(int)'I']/3;

   if (newFont->fBarHeight == 0) {
      newFont->fBarHeight = 1;
   }

   if (newFont->fUnderlinePos + newFont->fBarHeight > descent) {

      // If this set of cobbled together values would cause the bottom of
      // the underline bar to stick below the descent of the font, jack
      // the underline up a bit higher.

      newFont->fBarHeight = descent - newFont->fUnderlinePos;

      if (!newFont->fBarHeight) {
         newFont->fUnderlinePos--;
         newFont->fBarHeight = 1;
      }
   }

   return newFont;
}

//______________________________________________________________________________
static Int_t GetControlCharSubst(Int_t c, char buf[4])
{
   // When displaying text in a widget, a backslashed escape sequence is
   // substituted for control characters that occur in the text. Given a
   // control character, fill in a buffer with the replacement string that
   // should be displayed.
   //
   // The return value is the length of the substitute string, buf is
   // filled with the substitute string; it is not '\0' terminated.
   //
   // c   -- The control character to be replaced.
   // buf -- Buffer that gets replacement string. It only needs to be
   //        4 characters long.

   buf[0] = '\\';

   if (((UInt_t)c < sizeof(gMapChars)) && (gMapChars[c] != 0)) {
      buf[1] = gMapChars[c];
      return 2;
   } else {
      buf[1] = 'x';
      buf[2] = gHexChars[(c >> 4) & 0xf];
      buf[3] = gHexChars[c & 0xf];
      return 4;
   }
}
 TGFont.cxx:1
 TGFont.cxx:2
 TGFont.cxx:3
 TGFont.cxx:4
 TGFont.cxx:5
 TGFont.cxx:6
 TGFont.cxx:7
 TGFont.cxx:8
 TGFont.cxx:9
 TGFont.cxx:10
 TGFont.cxx:11
 TGFont.cxx:12
 TGFont.cxx:13
 TGFont.cxx:14
 TGFont.cxx:15
 TGFont.cxx:16
 TGFont.cxx:17
 TGFont.cxx:18
 TGFont.cxx:19
 TGFont.cxx:20
 TGFont.cxx:21
 TGFont.cxx:22
 TGFont.cxx:23
 TGFont.cxx:24
 TGFont.cxx:25
 TGFont.cxx:26
 TGFont.cxx:27
 TGFont.cxx:28
 TGFont.cxx:29
 TGFont.cxx:30
 TGFont.cxx:31
 TGFont.cxx:32
 TGFont.cxx:33
 TGFont.cxx:34
 TGFont.cxx:35
 TGFont.cxx:36
 TGFont.cxx:37
 TGFont.cxx:38
 TGFont.cxx:39
 TGFont.cxx:40
 TGFont.cxx:41
 TGFont.cxx:42
 TGFont.cxx:43
 TGFont.cxx:44
 TGFont.cxx:45
 TGFont.cxx:46
 TGFont.cxx:47
 TGFont.cxx:48
 TGFont.cxx:49
 TGFont.cxx:50
 TGFont.cxx:51
 TGFont.cxx:52
 TGFont.cxx:53
 TGFont.cxx:54
 TGFont.cxx:55
 TGFont.cxx:56
 TGFont.cxx:57
 TGFont.cxx:58
 TGFont.cxx:59
 TGFont.cxx:60
 TGFont.cxx:61
 TGFont.cxx:62
 TGFont.cxx:63
 TGFont.cxx:64
 TGFont.cxx:65
 TGFont.cxx:66
 TGFont.cxx:67
 TGFont.cxx:68
 TGFont.cxx:69
 TGFont.cxx:70
 TGFont.cxx:71
 TGFont.cxx:72
 TGFont.cxx:73
 TGFont.cxx:74
 TGFont.cxx:75
 TGFont.cxx:76
 TGFont.cxx:77
 TGFont.cxx:78
 TGFont.cxx:79
 TGFont.cxx:80
 TGFont.cxx:81
 TGFont.cxx:82
 TGFont.cxx:83
 TGFont.cxx:84
 TGFont.cxx:85
 TGFont.cxx:86
 TGFont.cxx:87
 TGFont.cxx:88
 TGFont.cxx:89
 TGFont.cxx:90
 TGFont.cxx:91
 TGFont.cxx:92
 TGFont.cxx:93
 TGFont.cxx:94
 TGFont.cxx:95
 TGFont.cxx:96
 TGFont.cxx:97
 TGFont.cxx:98
 TGFont.cxx:99
 TGFont.cxx:100
 TGFont.cxx:101
 TGFont.cxx:102
 TGFont.cxx:103
 TGFont.cxx:104
 TGFont.cxx:105
 TGFont.cxx:106
 TGFont.cxx:107
 TGFont.cxx:108
 TGFont.cxx:109
 TGFont.cxx:110
 TGFont.cxx:111
 TGFont.cxx:112
 TGFont.cxx:113
 TGFont.cxx:114
 TGFont.cxx:115
 TGFont.cxx:116
 TGFont.cxx:117
 TGFont.cxx:118
 TGFont.cxx:119
 TGFont.cxx:120
 TGFont.cxx:121
 TGFont.cxx:122
 TGFont.cxx:123
 TGFont.cxx:124
 TGFont.cxx:125
 TGFont.cxx:126
 TGFont.cxx:127
 TGFont.cxx:128
 TGFont.cxx:129
 TGFont.cxx:130
 TGFont.cxx:131
 TGFont.cxx:132
 TGFont.cxx:133
 TGFont.cxx:134
 TGFont.cxx:135
 TGFont.cxx:136
 TGFont.cxx:137
 TGFont.cxx:138
 TGFont.cxx:139
 TGFont.cxx:140
 TGFont.cxx:141
 TGFont.cxx:142
 TGFont.cxx:143
 TGFont.cxx:144
 TGFont.cxx:145
 TGFont.cxx:146
 TGFont.cxx:147
 TGFont.cxx:148
 TGFont.cxx:149
 TGFont.cxx:150
 TGFont.cxx:151
 TGFont.cxx:152
 TGFont.cxx:153
 TGFont.cxx:154
 TGFont.cxx:155
 TGFont.cxx:156
 TGFont.cxx:157
 TGFont.cxx:158
 TGFont.cxx:159
 TGFont.cxx:160
 TGFont.cxx:161
 TGFont.cxx:162
 TGFont.cxx:163
 TGFont.cxx:164
 TGFont.cxx:165
 TGFont.cxx:166
 TGFont.cxx:167
 TGFont.cxx:168
 TGFont.cxx:169
 TGFont.cxx:170
 TGFont.cxx:171
 TGFont.cxx:172
 TGFont.cxx:173
 TGFont.cxx:174
 TGFont.cxx:175
 TGFont.cxx:176
 TGFont.cxx:177
 TGFont.cxx:178
 TGFont.cxx:179
 TGFont.cxx:180
 TGFont.cxx:181
 TGFont.cxx:182
 TGFont.cxx:183
 TGFont.cxx:184
 TGFont.cxx:185
 TGFont.cxx:186
 TGFont.cxx:187
 TGFont.cxx:188
 TGFont.cxx:189
 TGFont.cxx:190
 TGFont.cxx:191
 TGFont.cxx:192
 TGFont.cxx:193
 TGFont.cxx:194
 TGFont.cxx:195
 TGFont.cxx:196
 TGFont.cxx:197
 TGFont.cxx:198
 TGFont.cxx:199
 TGFont.cxx:200
 TGFont.cxx:201
 TGFont.cxx:202
 TGFont.cxx:203
 TGFont.cxx:204
 TGFont.cxx:205
 TGFont.cxx:206
 TGFont.cxx:207
 TGFont.cxx:208
 TGFont.cxx:209
 TGFont.cxx:210
 TGFont.cxx:211
 TGFont.cxx:212
 TGFont.cxx:213
 TGFont.cxx:214
 TGFont.cxx:215
 TGFont.cxx:216
 TGFont.cxx:217
 TGFont.cxx:218
 TGFont.cxx:219
 TGFont.cxx:220
 TGFont.cxx:221
 TGFont.cxx:222
 TGFont.cxx:223
 TGFont.cxx:224
 TGFont.cxx:225
 TGFont.cxx:226
 TGFont.cxx:227
 TGFont.cxx:228
 TGFont.cxx:229
 TGFont.cxx:230
 TGFont.cxx:231
 TGFont.cxx:232
 TGFont.cxx:233
 TGFont.cxx:234
 TGFont.cxx:235
 TGFont.cxx:236
 TGFont.cxx:237
 TGFont.cxx:238
 TGFont.cxx:239
 TGFont.cxx:240
 TGFont.cxx:241
 TGFont.cxx:242
 TGFont.cxx:243
 TGFont.cxx:244
 TGFont.cxx:245
 TGFont.cxx:246
 TGFont.cxx:247
 TGFont.cxx:248
 TGFont.cxx:249
 TGFont.cxx:250
 TGFont.cxx:251
 TGFont.cxx:252
 TGFont.cxx:253
 TGFont.cxx:254
 TGFont.cxx:255
 TGFont.cxx:256
 TGFont.cxx:257
 TGFont.cxx:258
 TGFont.cxx:259
 TGFont.cxx:260
 TGFont.cxx:261
 TGFont.cxx:262
 TGFont.cxx:263
 TGFont.cxx:264
 TGFont.cxx:265
 TGFont.cxx:266
 TGFont.cxx:267
 TGFont.cxx:268
 TGFont.cxx:269
 TGFont.cxx:270
 TGFont.cxx:271
 TGFont.cxx:272
 TGFont.cxx:273
 TGFont.cxx:274
 TGFont.cxx:275
 TGFont.cxx:276
 TGFont.cxx:277
 TGFont.cxx:278
 TGFont.cxx:279
 TGFont.cxx:280
 TGFont.cxx:281
 TGFont.cxx:282
 TGFont.cxx:283
 TGFont.cxx:284
 TGFont.cxx:285
 TGFont.cxx:286
 TGFont.cxx:287
 TGFont.cxx:288
 TGFont.cxx:289
 TGFont.cxx:290
 TGFont.cxx:291
 TGFont.cxx:292
 TGFont.cxx:293
 TGFont.cxx:294
 TGFont.cxx:295
 TGFont.cxx:296
 TGFont.cxx:297
 TGFont.cxx:298
 TGFont.cxx:299
 TGFont.cxx:300
 TGFont.cxx:301
 TGFont.cxx:302
 TGFont.cxx:303
 TGFont.cxx:304
 TGFont.cxx:305
 TGFont.cxx:306
 TGFont.cxx:307
 TGFont.cxx:308
 TGFont.cxx:309
 TGFont.cxx:310
 TGFont.cxx:311
 TGFont.cxx:312
 TGFont.cxx:313
 TGFont.cxx:314
 TGFont.cxx:315
 TGFont.cxx:316
 TGFont.cxx:317
 TGFont.cxx:318
 TGFont.cxx:319
 TGFont.cxx:320
 TGFont.cxx:321
 TGFont.cxx:322
 TGFont.cxx:323
 TGFont.cxx:324
 TGFont.cxx:325
 TGFont.cxx:326
 TGFont.cxx:327
 TGFont.cxx:328
 TGFont.cxx:329
 TGFont.cxx:330
 TGFont.cxx:331
 TGFont.cxx:332
 TGFont.cxx:333
 TGFont.cxx:334
 TGFont.cxx:335
 TGFont.cxx:336
 TGFont.cxx:337
 TGFont.cxx:338
 TGFont.cxx:339
 TGFont.cxx:340
 TGFont.cxx:341
 TGFont.cxx:342
 TGFont.cxx:343
 TGFont.cxx:344
 TGFont.cxx:345
 TGFont.cxx:346
 TGFont.cxx:347
 TGFont.cxx:348
 TGFont.cxx:349
 TGFont.cxx:350
 TGFont.cxx:351
 TGFont.cxx:352
 TGFont.cxx:353
 TGFont.cxx:354
 TGFont.cxx:355
 TGFont.cxx:356
 TGFont.cxx:357
 TGFont.cxx:358
 TGFont.cxx:359
 TGFont.cxx:360
 TGFont.cxx:361
 TGFont.cxx:362
 TGFont.cxx:363
 TGFont.cxx:364
 TGFont.cxx:365
 TGFont.cxx:366
 TGFont.cxx:367
 TGFont.cxx:368
 TGFont.cxx:369
 TGFont.cxx:370
 TGFont.cxx:371
 TGFont.cxx:372
 TGFont.cxx:373
 TGFont.cxx:374
 TGFont.cxx:375
 TGFont.cxx:376
 TGFont.cxx:377
 TGFont.cxx:378
 TGFont.cxx:379
 TGFont.cxx:380
 TGFont.cxx:381
 TGFont.cxx:382
 TGFont.cxx:383
 TGFont.cxx:384
 TGFont.cxx:385
 TGFont.cxx:386
 TGFont.cxx:387
 TGFont.cxx:388
 TGFont.cxx:389
 TGFont.cxx:390
 TGFont.cxx:391
 TGFont.cxx:392
 TGFont.cxx:393
 TGFont.cxx:394
 TGFont.cxx:395
 TGFont.cxx:396
 TGFont.cxx:397
 TGFont.cxx:398
 TGFont.cxx:399
 TGFont.cxx:400
 TGFont.cxx:401
 TGFont.cxx:402
 TGFont.cxx:403
 TGFont.cxx:404
 TGFont.cxx:405
 TGFont.cxx:406
 TGFont.cxx:407
 TGFont.cxx:408
 TGFont.cxx:409
 TGFont.cxx:410
 TGFont.cxx:411
 TGFont.cxx:412
 TGFont.cxx:413
 TGFont.cxx:414
 TGFont.cxx:415
 TGFont.cxx:416
 TGFont.cxx:417
 TGFont.cxx:418
 TGFont.cxx:419
 TGFont.cxx:420
 TGFont.cxx:421
 TGFont.cxx:422
 TGFont.cxx:423
 TGFont.cxx:424
 TGFont.cxx:425
 TGFont.cxx:426
 TGFont.cxx:427
 TGFont.cxx:428
 TGFont.cxx:429
 TGFont.cxx:430
 TGFont.cxx:431
 TGFont.cxx:432
 TGFont.cxx:433
 TGFont.cxx:434
 TGFont.cxx:435
 TGFont.cxx:436
 TGFont.cxx:437
 TGFont.cxx:438
 TGFont.cxx:439
 TGFont.cxx:440
 TGFont.cxx:441
 TGFont.cxx:442
 TGFont.cxx:443
 TGFont.cxx:444
 TGFont.cxx:445
 TGFont.cxx:446
 TGFont.cxx:447
 TGFont.cxx:448
 TGFont.cxx:449
 TGFont.cxx:450
 TGFont.cxx:451
 TGFont.cxx:452
 TGFont.cxx:453
 TGFont.cxx:454
 TGFont.cxx:455
 TGFont.cxx:456
 TGFont.cxx:457
 TGFont.cxx:458
 TGFont.cxx:459
 TGFont.cxx:460
 TGFont.cxx:461
 TGFont.cxx:462
 TGFont.cxx:463
 TGFont.cxx:464
 TGFont.cxx:465
 TGFont.cxx:466
 TGFont.cxx:467
 TGFont.cxx:468
 TGFont.cxx:469
 TGFont.cxx:470
 TGFont.cxx:471
 TGFont.cxx:472
 TGFont.cxx:473
 TGFont.cxx:474
 TGFont.cxx:475
 TGFont.cxx:476
 TGFont.cxx:477
 TGFont.cxx:478
 TGFont.cxx:479
 TGFont.cxx:480
 TGFont.cxx:481
 TGFont.cxx:482
 TGFont.cxx:483
 TGFont.cxx:484
 TGFont.cxx:485
 TGFont.cxx:486
 TGFont.cxx:487
 TGFont.cxx:488
 TGFont.cxx:489
 TGFont.cxx:490
 TGFont.cxx:491
 TGFont.cxx:492
 TGFont.cxx:493
 TGFont.cxx:494
 TGFont.cxx:495
 TGFont.cxx:496
 TGFont.cxx:497
 TGFont.cxx:498
 TGFont.cxx:499
 TGFont.cxx:500
 TGFont.cxx:501
 TGFont.cxx:502
 TGFont.cxx:503
 TGFont.cxx:504
 TGFont.cxx:505
 TGFont.cxx:506
 TGFont.cxx:507
 TGFont.cxx:508
 TGFont.cxx:509
 TGFont.cxx:510
 TGFont.cxx:511
 TGFont.cxx:512
 TGFont.cxx:513
 TGFont.cxx:514
 TGFont.cxx:515
 TGFont.cxx:516
 TGFont.cxx:517
 TGFont.cxx:518
 TGFont.cxx:519
 TGFont.cxx:520
 TGFont.cxx:521
 TGFont.cxx:522
 TGFont.cxx:523
 TGFont.cxx:524
 TGFont.cxx:525
 TGFont.cxx:526
 TGFont.cxx:527
 TGFont.cxx:528
 TGFont.cxx:529
 TGFont.cxx:530
 TGFont.cxx:531
 TGFont.cxx:532
 TGFont.cxx:533
 TGFont.cxx:534
 TGFont.cxx:535
 TGFont.cxx:536
 TGFont.cxx:537
 TGFont.cxx:538
 TGFont.cxx:539
 TGFont.cxx:540
 TGFont.cxx:541
 TGFont.cxx:542
 TGFont.cxx:543
 TGFont.cxx:544
 TGFont.cxx:545
 TGFont.cxx:546
 TGFont.cxx:547
 TGFont.cxx:548
 TGFont.cxx:549
 TGFont.cxx:550
 TGFont.cxx:551
 TGFont.cxx:552
 TGFont.cxx:553
 TGFont.cxx:554
 TGFont.cxx:555
 TGFont.cxx:556
 TGFont.cxx:557
 TGFont.cxx:558
 TGFont.cxx:559
 TGFont.cxx:560
 TGFont.cxx:561
 TGFont.cxx:562
 TGFont.cxx:563
 TGFont.cxx:564
 TGFont.cxx:565
 TGFont.cxx:566
 TGFont.cxx:567
 TGFont.cxx:568
 TGFont.cxx:569
 TGFont.cxx:570
 TGFont.cxx:571
 TGFont.cxx:572
 TGFont.cxx:573
 TGFont.cxx:574
 TGFont.cxx:575
 TGFont.cxx:576
 TGFont.cxx:577
 TGFont.cxx:578
 TGFont.cxx:579
 TGFont.cxx:580
 TGFont.cxx:581
 TGFont.cxx:582
 TGFont.cxx:583
 TGFont.cxx:584
 TGFont.cxx:585
 TGFont.cxx:586
 TGFont.cxx:587
 TGFont.cxx:588
 TGFont.cxx:589
 TGFont.cxx:590
 TGFont.cxx:591
 TGFont.cxx:592
 TGFont.cxx:593
 TGFont.cxx:594
 TGFont.cxx:595
 TGFont.cxx:596
 TGFont.cxx:597
 TGFont.cxx:598
 TGFont.cxx:599
 TGFont.cxx:600
 TGFont.cxx:601
 TGFont.cxx:602
 TGFont.cxx:603
 TGFont.cxx:604
 TGFont.cxx:605
 TGFont.cxx:606
 TGFont.cxx:607
 TGFont.cxx:608
 TGFont.cxx:609
 TGFont.cxx:610
 TGFont.cxx:611
 TGFont.cxx:612
 TGFont.cxx:613
 TGFont.cxx:614
 TGFont.cxx:615
 TGFont.cxx:616
 TGFont.cxx:617
 TGFont.cxx:618
 TGFont.cxx:619
 TGFont.cxx:620
 TGFont.cxx:621
 TGFont.cxx:622
 TGFont.cxx:623
 TGFont.cxx:624
 TGFont.cxx:625
 TGFont.cxx:626
 TGFont.cxx:627
 TGFont.cxx:628
 TGFont.cxx:629
 TGFont.cxx:630
 TGFont.cxx:631
 TGFont.cxx:632
 TGFont.cxx:633
 TGFont.cxx:634
 TGFont.cxx:635
 TGFont.cxx:636
 TGFont.cxx:637
 TGFont.cxx:638
 TGFont.cxx:639
 TGFont.cxx:640
 TGFont.cxx:641
 TGFont.cxx:642
 TGFont.cxx:643
 TGFont.cxx:644
 TGFont.cxx:645
 TGFont.cxx:646
 TGFont.cxx:647
 TGFont.cxx:648
 TGFont.cxx:649
 TGFont.cxx:650
 TGFont.cxx:651
 TGFont.cxx:652
 TGFont.cxx:653
 TGFont.cxx:654
 TGFont.cxx:655
 TGFont.cxx:656
 TGFont.cxx:657
 TGFont.cxx:658
 TGFont.cxx:659
 TGFont.cxx:660
 TGFont.cxx:661
 TGFont.cxx:662
 TGFont.cxx:663
 TGFont.cxx:664
 TGFont.cxx:665
 TGFont.cxx:666
 TGFont.cxx:667
 TGFont.cxx:668
 TGFont.cxx:669
 TGFont.cxx:670
 TGFont.cxx:671
 TGFont.cxx:672
 TGFont.cxx:673
 TGFont.cxx:674
 TGFont.cxx:675
 TGFont.cxx:676
 TGFont.cxx:677
 TGFont.cxx:678
 TGFont.cxx:679
 TGFont.cxx:680
 TGFont.cxx:681
 TGFont.cxx:682
 TGFont.cxx:683
 TGFont.cxx:684
 TGFont.cxx:685
 TGFont.cxx:686
 TGFont.cxx:687
 TGFont.cxx:688
 TGFont.cxx:689
 TGFont.cxx:690
 TGFont.cxx:691
 TGFont.cxx:692
 TGFont.cxx:693
 TGFont.cxx:694
 TGFont.cxx:695
 TGFont.cxx:696
 TGFont.cxx:697
 TGFont.cxx:698
 TGFont.cxx:699
 TGFont.cxx:700
 TGFont.cxx:701
 TGFont.cxx:702
 TGFont.cxx:703
 TGFont.cxx:704
 TGFont.cxx:705
 TGFont.cxx:706
 TGFont.cxx:707
 TGFont.cxx:708
 TGFont.cxx:709
 TGFont.cxx:710
 TGFont.cxx:711
 TGFont.cxx:712
 TGFont.cxx:713
 TGFont.cxx:714
 TGFont.cxx:715
 TGFont.cxx:716
 TGFont.cxx:717
 TGFont.cxx:718
 TGFont.cxx:719
 TGFont.cxx:720
 TGFont.cxx:721
 TGFont.cxx:722
 TGFont.cxx:723
 TGFont.cxx:724
 TGFont.cxx:725
 TGFont.cxx:726
 TGFont.cxx:727
 TGFont.cxx:728
 TGFont.cxx:729
 TGFont.cxx:730
 TGFont.cxx:731
 TGFont.cxx:732
 TGFont.cxx:733
 TGFont.cxx:734
 TGFont.cxx:735
 TGFont.cxx:736
 TGFont.cxx:737
 TGFont.cxx:738
 TGFont.cxx:739
 TGFont.cxx:740
 TGFont.cxx:741
 TGFont.cxx:742
 TGFont.cxx:743
 TGFont.cxx:744
 TGFont.cxx:745
 TGFont.cxx:746
 TGFont.cxx:747
 TGFont.cxx:748
 TGFont.cxx:749
 TGFont.cxx:750
 TGFont.cxx:751
 TGFont.cxx:752
 TGFont.cxx:753
 TGFont.cxx:754
 TGFont.cxx:755
 TGFont.cxx:756
 TGFont.cxx:757
 TGFont.cxx:758
 TGFont.cxx:759
 TGFont.cxx:760
 TGFont.cxx:761
 TGFont.cxx:762
 TGFont.cxx:763
 TGFont.cxx:764
 TGFont.cxx:765
 TGFont.cxx:766
 TGFont.cxx:767
 TGFont.cxx:768
 TGFont.cxx:769
 TGFont.cxx:770
 TGFont.cxx:771
 TGFont.cxx:772
 TGFont.cxx:773
 TGFont.cxx:774
 TGFont.cxx:775
 TGFont.cxx:776
 TGFont.cxx:777
 TGFont.cxx:778
 TGFont.cxx:779
 TGFont.cxx:780
 TGFont.cxx:781
 TGFont.cxx:782
 TGFont.cxx:783
 TGFont.cxx:784
 TGFont.cxx:785
 TGFont.cxx:786
 TGFont.cxx:787
 TGFont.cxx:788
 TGFont.cxx:789
 TGFont.cxx:790
 TGFont.cxx:791
 TGFont.cxx:792
 TGFont.cxx:793
 TGFont.cxx:794
 TGFont.cxx:795
 TGFont.cxx:796
 TGFont.cxx:797
 TGFont.cxx:798
 TGFont.cxx:799
 TGFont.cxx:800
 TGFont.cxx:801
 TGFont.cxx:802
 TGFont.cxx:803
 TGFont.cxx:804
 TGFont.cxx:805
 TGFont.cxx:806
 TGFont.cxx:807
 TGFont.cxx:808
 TGFont.cxx:809
 TGFont.cxx:810
 TGFont.cxx:811
 TGFont.cxx:812
 TGFont.cxx:813
 TGFont.cxx:814
 TGFont.cxx:815
 TGFont.cxx:816
 TGFont.cxx:817
 TGFont.cxx:818
 TGFont.cxx:819
 TGFont.cxx:820
 TGFont.cxx:821
 TGFont.cxx:822
 TGFont.cxx:823
 TGFont.cxx:824
 TGFont.cxx:825
 TGFont.cxx:826
 TGFont.cxx:827
 TGFont.cxx:828
 TGFont.cxx:829
 TGFont.cxx:830
 TGFont.cxx:831
 TGFont.cxx:832
 TGFont.cxx:833
 TGFont.cxx:834
 TGFont.cxx:835
 TGFont.cxx:836
 TGFont.cxx:837
 TGFont.cxx:838
 TGFont.cxx:839
 TGFont.cxx:840
 TGFont.cxx:841
 TGFont.cxx:842
 TGFont.cxx:843
 TGFont.cxx:844
 TGFont.cxx:845
 TGFont.cxx:846
 TGFont.cxx:847
 TGFont.cxx:848
 TGFont.cxx:849
 TGFont.cxx:850
 TGFont.cxx:851
 TGFont.cxx:852
 TGFont.cxx:853
 TGFont.cxx:854
 TGFont.cxx:855
 TGFont.cxx:856
 TGFont.cxx:857
 TGFont.cxx:858
 TGFont.cxx:859
 TGFont.cxx:860
 TGFont.cxx:861
 TGFont.cxx:862
 TGFont.cxx:863
 TGFont.cxx:864
 TGFont.cxx:865
 TGFont.cxx:866
 TGFont.cxx:867
 TGFont.cxx:868
 TGFont.cxx:869
 TGFont.cxx:870
 TGFont.cxx:871
 TGFont.cxx:872
 TGFont.cxx:873
 TGFont.cxx:874
 TGFont.cxx:875
 TGFont.cxx:876
 TGFont.cxx:877
 TGFont.cxx:878
 TGFont.cxx:879
 TGFont.cxx:880
 TGFont.cxx:881
 TGFont.cxx:882
 TGFont.cxx:883
 TGFont.cxx:884
 TGFont.cxx:885
 TGFont.cxx:886
 TGFont.cxx:887
 TGFont.cxx:888
 TGFont.cxx:889
 TGFont.cxx:890
 TGFont.cxx:891
 TGFont.cxx:892
 TGFont.cxx:893
 TGFont.cxx:894
 TGFont.cxx:895
 TGFont.cxx:896
 TGFont.cxx:897
 TGFont.cxx:898
 TGFont.cxx:899
 TGFont.cxx:900
 TGFont.cxx:901
 TGFont.cxx:902
 TGFont.cxx:903
 TGFont.cxx:904
 TGFont.cxx:905
 TGFont.cxx:906
 TGFont.cxx:907
 TGFont.cxx:908
 TGFont.cxx:909
 TGFont.cxx:910
 TGFont.cxx:911
 TGFont.cxx:912
 TGFont.cxx:913
 TGFont.cxx:914
 TGFont.cxx:915
 TGFont.cxx:916
 TGFont.cxx:917
 TGFont.cxx:918
 TGFont.cxx:919
 TGFont.cxx:920
 TGFont.cxx:921
 TGFont.cxx:922
 TGFont.cxx:923
 TGFont.cxx:924
 TGFont.cxx:925
 TGFont.cxx:926
 TGFont.cxx:927
 TGFont.cxx:928
 TGFont.cxx:929
 TGFont.cxx:930
 TGFont.cxx:931
 TGFont.cxx:932
 TGFont.cxx:933
 TGFont.cxx:934
 TGFont.cxx:935
 TGFont.cxx:936
 TGFont.cxx:937
 TGFont.cxx:938
 TGFont.cxx:939
 TGFont.cxx:940
 TGFont.cxx:941
 TGFont.cxx:942
 TGFont.cxx:943
 TGFont.cxx:944
 TGFont.cxx:945
 TGFont.cxx:946
 TGFont.cxx:947
 TGFont.cxx:948
 TGFont.cxx:949
 TGFont.cxx:950
 TGFont.cxx:951
 TGFont.cxx:952
 TGFont.cxx:953
 TGFont.cxx:954
 TGFont.cxx:955
 TGFont.cxx:956
 TGFont.cxx:957
 TGFont.cxx:958
 TGFont.cxx:959
 TGFont.cxx:960
 TGFont.cxx:961
 TGFont.cxx:962
 TGFont.cxx:963
 TGFont.cxx:964
 TGFont.cxx:965
 TGFont.cxx:966
 TGFont.cxx:967
 TGFont.cxx:968
 TGFont.cxx:969
 TGFont.cxx:970
 TGFont.cxx:971
 TGFont.cxx:972
 TGFont.cxx:973
 TGFont.cxx:974
 TGFont.cxx:975
 TGFont.cxx:976
 TGFont.cxx:977
 TGFont.cxx:978
 TGFont.cxx:979
 TGFont.cxx:980
 TGFont.cxx:981
 TGFont.cxx:982
 TGFont.cxx:983
 TGFont.cxx:984
 TGFont.cxx:985
 TGFont.cxx:986
 TGFont.cxx:987
 TGFont.cxx:988
 TGFont.cxx:989
 TGFont.cxx:990
 TGFont.cxx:991
 TGFont.cxx:992
 TGFont.cxx:993
 TGFont.cxx:994
 TGFont.cxx:995
 TGFont.cxx:996
 TGFont.cxx:997
 TGFont.cxx:998
 TGFont.cxx:999
 TGFont.cxx:1000
 TGFont.cxx:1001
 TGFont.cxx:1002
 TGFont.cxx:1003
 TGFont.cxx:1004
 TGFont.cxx:1005
 TGFont.cxx:1006
 TGFont.cxx:1007
 TGFont.cxx:1008
 TGFont.cxx:1009
 TGFont.cxx:1010
 TGFont.cxx:1011
 TGFont.cxx:1012
 TGFont.cxx:1013
 TGFont.cxx:1014
 TGFont.cxx:1015
 TGFont.cxx:1016
 TGFont.cxx:1017
 TGFont.cxx:1018
 TGFont.cxx:1019
 TGFont.cxx:1020
 TGFont.cxx:1021
 TGFont.cxx:1022
 TGFont.cxx:1023
 TGFont.cxx:1024
 TGFont.cxx:1025
 TGFont.cxx:1026
 TGFont.cxx:1027
 TGFont.cxx:1028
 TGFont.cxx:1029
 TGFont.cxx:1030
 TGFont.cxx:1031
 TGFont.cxx:1032
 TGFont.cxx:1033
 TGFont.cxx:1034
 TGFont.cxx:1035
 TGFont.cxx:1036
 TGFont.cxx:1037
 TGFont.cxx:1038
 TGFont.cxx:1039
 TGFont.cxx:1040
 TGFont.cxx:1041
 TGFont.cxx:1042
 TGFont.cxx:1043
 TGFont.cxx:1044
 TGFont.cxx:1045
 TGFont.cxx:1046
 TGFont.cxx:1047
 TGFont.cxx:1048
 TGFont.cxx:1049
 TGFont.cxx:1050
 TGFont.cxx:1051
 TGFont.cxx:1052
 TGFont.cxx:1053
 TGFont.cxx:1054
 TGFont.cxx:1055
 TGFont.cxx:1056
 TGFont.cxx:1057
 TGFont.cxx:1058
 TGFont.cxx:1059
 TGFont.cxx:1060
 TGFont.cxx:1061
 TGFont.cxx:1062
 TGFont.cxx:1063
 TGFont.cxx:1064
 TGFont.cxx:1065
 TGFont.cxx:1066
 TGFont.cxx:1067
 TGFont.cxx:1068
 TGFont.cxx:1069
 TGFont.cxx:1070
 TGFont.cxx:1071
 TGFont.cxx:1072
 TGFont.cxx:1073
 TGFont.cxx:1074
 TGFont.cxx:1075
 TGFont.cxx:1076
 TGFont.cxx:1077
 TGFont.cxx:1078
 TGFont.cxx:1079
 TGFont.cxx:1080
 TGFont.cxx:1081
 TGFont.cxx:1082
 TGFont.cxx:1083
 TGFont.cxx:1084
 TGFont.cxx:1085
 TGFont.cxx:1086
 TGFont.cxx:1087
 TGFont.cxx:1088
 TGFont.cxx:1089
 TGFont.cxx:1090
 TGFont.cxx:1091
 TGFont.cxx:1092
 TGFont.cxx:1093
 TGFont.cxx:1094
 TGFont.cxx:1095
 TGFont.cxx:1096
 TGFont.cxx:1097
 TGFont.cxx:1098
 TGFont.cxx:1099
 TGFont.cxx:1100
 TGFont.cxx:1101
 TGFont.cxx:1102
 TGFont.cxx:1103
 TGFont.cxx:1104
 TGFont.cxx:1105
 TGFont.cxx:1106
 TGFont.cxx:1107
 TGFont.cxx:1108
 TGFont.cxx:1109
 TGFont.cxx:1110
 TGFont.cxx:1111
 TGFont.cxx:1112
 TGFont.cxx:1113
 TGFont.cxx:1114
 TGFont.cxx:1115
 TGFont.cxx:1116
 TGFont.cxx:1117
 TGFont.cxx:1118
 TGFont.cxx:1119
 TGFont.cxx:1120
 TGFont.cxx:1121
 TGFont.cxx:1122
 TGFont.cxx:1123
 TGFont.cxx:1124
 TGFont.cxx:1125
 TGFont.cxx:1126
 TGFont.cxx:1127
 TGFont.cxx:1128
 TGFont.cxx:1129
 TGFont.cxx:1130
 TGFont.cxx:1131
 TGFont.cxx:1132
 TGFont.cxx:1133
 TGFont.cxx:1134
 TGFont.cxx:1135
 TGFont.cxx:1136
 TGFont.cxx:1137
 TGFont.cxx:1138
 TGFont.cxx:1139
 TGFont.cxx:1140
 TGFont.cxx:1141
 TGFont.cxx:1142
 TGFont.cxx:1143
 TGFont.cxx:1144
 TGFont.cxx:1145
 TGFont.cxx:1146
 TGFont.cxx:1147
 TGFont.cxx:1148
 TGFont.cxx:1149
 TGFont.cxx:1150
 TGFont.cxx:1151
 TGFont.cxx:1152
 TGFont.cxx:1153
 TGFont.cxx:1154
 TGFont.cxx:1155
 TGFont.cxx:1156
 TGFont.cxx:1157
 TGFont.cxx:1158
 TGFont.cxx:1159
 TGFont.cxx:1160
 TGFont.cxx:1161
 TGFont.cxx:1162
 TGFont.cxx:1163
 TGFont.cxx:1164
 TGFont.cxx:1165
 TGFont.cxx:1166
 TGFont.cxx:1167
 TGFont.cxx:1168
 TGFont.cxx:1169
 TGFont.cxx:1170
 TGFont.cxx:1171
 TGFont.cxx:1172
 TGFont.cxx:1173
 TGFont.cxx:1174
 TGFont.cxx:1175
 TGFont.cxx:1176
 TGFont.cxx:1177
 TGFont.cxx:1178
 TGFont.cxx:1179
 TGFont.cxx:1180
 TGFont.cxx:1181
 TGFont.cxx:1182
 TGFont.cxx:1183
 TGFont.cxx:1184
 TGFont.cxx:1185
 TGFont.cxx:1186
 TGFont.cxx:1187
 TGFont.cxx:1188
 TGFont.cxx:1189
 TGFont.cxx:1190
 TGFont.cxx:1191
 TGFont.cxx:1192
 TGFont.cxx:1193
 TGFont.cxx:1194
 TGFont.cxx:1195
 TGFont.cxx:1196
 TGFont.cxx:1197
 TGFont.cxx:1198
 TGFont.cxx:1199
 TGFont.cxx:1200
 TGFont.cxx:1201
 TGFont.cxx:1202
 TGFont.cxx:1203
 TGFont.cxx:1204
 TGFont.cxx:1205
 TGFont.cxx:1206
 TGFont.cxx:1207
 TGFont.cxx:1208
 TGFont.cxx:1209
 TGFont.cxx:1210
 TGFont.cxx:1211
 TGFont.cxx:1212
 TGFont.cxx:1213
 TGFont.cxx:1214
 TGFont.cxx:1215
 TGFont.cxx:1216
 TGFont.cxx:1217
 TGFont.cxx:1218
 TGFont.cxx:1219
 TGFont.cxx:1220
 TGFont.cxx:1221
 TGFont.cxx:1222
 TGFont.cxx:1223
 TGFont.cxx:1224
 TGFont.cxx:1225
 TGFont.cxx:1226
 TGFont.cxx:1227
 TGFont.cxx:1228
 TGFont.cxx:1229
 TGFont.cxx:1230
 TGFont.cxx:1231
 TGFont.cxx:1232
 TGFont.cxx:1233
 TGFont.cxx:1234
 TGFont.cxx:1235
 TGFont.cxx:1236
 TGFont.cxx:1237
 TGFont.cxx:1238
 TGFont.cxx:1239
 TGFont.cxx:1240
 TGFont.cxx:1241
 TGFont.cxx:1242
 TGFont.cxx:1243
 TGFont.cxx:1244
 TGFont.cxx:1245
 TGFont.cxx:1246
 TGFont.cxx:1247
 TGFont.cxx:1248
 TGFont.cxx:1249
 TGFont.cxx:1250
 TGFont.cxx:1251
 TGFont.cxx:1252
 TGFont.cxx:1253
 TGFont.cxx:1254
 TGFont.cxx:1255
 TGFont.cxx:1256
 TGFont.cxx:1257
 TGFont.cxx:1258
 TGFont.cxx:1259
 TGFont.cxx:1260
 TGFont.cxx:1261
 TGFont.cxx:1262
 TGFont.cxx:1263
 TGFont.cxx:1264
 TGFont.cxx:1265
 TGFont.cxx:1266
 TGFont.cxx:1267
 TGFont.cxx:1268
 TGFont.cxx:1269
 TGFont.cxx:1270
 TGFont.cxx:1271
 TGFont.cxx:1272
 TGFont.cxx:1273
 TGFont.cxx:1274
 TGFont.cxx:1275
 TGFont.cxx:1276
 TGFont.cxx:1277
 TGFont.cxx:1278
 TGFont.cxx:1279
 TGFont.cxx:1280
 TGFont.cxx:1281
 TGFont.cxx:1282
 TGFont.cxx:1283
 TGFont.cxx:1284
 TGFont.cxx:1285
 TGFont.cxx:1286
 TGFont.cxx:1287
 TGFont.cxx:1288
 TGFont.cxx:1289
 TGFont.cxx:1290
 TGFont.cxx:1291
 TGFont.cxx:1292
 TGFont.cxx:1293
 TGFont.cxx:1294
 TGFont.cxx:1295
 TGFont.cxx:1296
 TGFont.cxx:1297
 TGFont.cxx:1298
 TGFont.cxx:1299
 TGFont.cxx:1300
 TGFont.cxx:1301
 TGFont.cxx:1302
 TGFont.cxx:1303
 TGFont.cxx:1304
 TGFont.cxx:1305
 TGFont.cxx:1306
 TGFont.cxx:1307
 TGFont.cxx:1308
 TGFont.cxx:1309
 TGFont.cxx:1310
 TGFont.cxx:1311
 TGFont.cxx:1312
 TGFont.cxx:1313
 TGFont.cxx:1314
 TGFont.cxx:1315
 TGFont.cxx:1316
 TGFont.cxx:1317
 TGFont.cxx:1318
 TGFont.cxx:1319
 TGFont.cxx:1320
 TGFont.cxx:1321
 TGFont.cxx:1322
 TGFont.cxx:1323
 TGFont.cxx:1324
 TGFont.cxx:1325
 TGFont.cxx:1326
 TGFont.cxx:1327
 TGFont.cxx:1328
 TGFont.cxx:1329
 TGFont.cxx:1330
 TGFont.cxx:1331
 TGFont.cxx:1332
 TGFont.cxx:1333
 TGFont.cxx:1334
 TGFont.cxx:1335
 TGFont.cxx:1336
 TGFont.cxx:1337
 TGFont.cxx:1338
 TGFont.cxx:1339
 TGFont.cxx:1340
 TGFont.cxx:1341
 TGFont.cxx:1342
 TGFont.cxx:1343
 TGFont.cxx:1344
 TGFont.cxx:1345
 TGFont.cxx:1346
 TGFont.cxx:1347
 TGFont.cxx:1348
 TGFont.cxx:1349
 TGFont.cxx:1350
 TGFont.cxx:1351
 TGFont.cxx:1352
 TGFont.cxx:1353
 TGFont.cxx:1354
 TGFont.cxx:1355
 TGFont.cxx:1356
 TGFont.cxx:1357
 TGFont.cxx:1358
 TGFont.cxx:1359
 TGFont.cxx:1360
 TGFont.cxx:1361
 TGFont.cxx:1362
 TGFont.cxx:1363
 TGFont.cxx:1364
 TGFont.cxx:1365
 TGFont.cxx:1366
 TGFont.cxx:1367
 TGFont.cxx:1368
 TGFont.cxx:1369
 TGFont.cxx:1370
 TGFont.cxx:1371
 TGFont.cxx:1372
 TGFont.cxx:1373
 TGFont.cxx:1374
 TGFont.cxx:1375
 TGFont.cxx:1376
 TGFont.cxx:1377
 TGFont.cxx:1378
 TGFont.cxx:1379
 TGFont.cxx:1380
 TGFont.cxx:1381
 TGFont.cxx:1382
 TGFont.cxx:1383
 TGFont.cxx:1384
 TGFont.cxx:1385
 TGFont.cxx:1386
 TGFont.cxx:1387
 TGFont.cxx:1388
 TGFont.cxx:1389
 TGFont.cxx:1390
 TGFont.cxx:1391
 TGFont.cxx:1392
 TGFont.cxx:1393
 TGFont.cxx:1394
 TGFont.cxx:1395
 TGFont.cxx:1396
 TGFont.cxx:1397
 TGFont.cxx:1398
 TGFont.cxx:1399
 TGFont.cxx:1400
 TGFont.cxx:1401
 TGFont.cxx:1402
 TGFont.cxx:1403
 TGFont.cxx:1404
 TGFont.cxx:1405
 TGFont.cxx:1406
 TGFont.cxx:1407
 TGFont.cxx:1408
 TGFont.cxx:1409
 TGFont.cxx:1410
 TGFont.cxx:1411
 TGFont.cxx:1412
 TGFont.cxx:1413
 TGFont.cxx:1414
 TGFont.cxx:1415
 TGFont.cxx:1416
 TGFont.cxx:1417
 TGFont.cxx:1418
 TGFont.cxx:1419
 TGFont.cxx:1420
 TGFont.cxx:1421
 TGFont.cxx:1422
 TGFont.cxx:1423
 TGFont.cxx:1424
 TGFont.cxx:1425
 TGFont.cxx:1426
 TGFont.cxx:1427
 TGFont.cxx:1428
 TGFont.cxx:1429
 TGFont.cxx:1430
 TGFont.cxx:1431
 TGFont.cxx:1432
 TGFont.cxx:1433
 TGFont.cxx:1434
 TGFont.cxx:1435
 TGFont.cxx:1436
 TGFont.cxx:1437
 TGFont.cxx:1438
 TGFont.cxx:1439
 TGFont.cxx:1440
 TGFont.cxx:1441
 TGFont.cxx:1442
 TGFont.cxx:1443
 TGFont.cxx:1444
 TGFont.cxx:1445
 TGFont.cxx:1446
 TGFont.cxx:1447
 TGFont.cxx:1448
 TGFont.cxx:1449
 TGFont.cxx:1450
 TGFont.cxx:1451
 TGFont.cxx:1452
 TGFont.cxx:1453
 TGFont.cxx:1454
 TGFont.cxx:1455
 TGFont.cxx:1456
 TGFont.cxx:1457
 TGFont.cxx:1458
 TGFont.cxx:1459
 TGFont.cxx:1460
 TGFont.cxx:1461
 TGFont.cxx:1462
 TGFont.cxx:1463
 TGFont.cxx:1464
 TGFont.cxx:1465
 TGFont.cxx:1466
 TGFont.cxx:1467
 TGFont.cxx:1468
 TGFont.cxx:1469
 TGFont.cxx:1470
 TGFont.cxx:1471
 TGFont.cxx:1472
 TGFont.cxx:1473
 TGFont.cxx:1474
 TGFont.cxx:1475
 TGFont.cxx:1476
 TGFont.cxx:1477
 TGFont.cxx:1478
 TGFont.cxx:1479
 TGFont.cxx:1480
 TGFont.cxx:1481
 TGFont.cxx:1482
 TGFont.cxx:1483
 TGFont.cxx:1484
 TGFont.cxx:1485
 TGFont.cxx:1486
 TGFont.cxx:1487
 TGFont.cxx:1488
 TGFont.cxx:1489
 TGFont.cxx:1490
 TGFont.cxx:1491
 TGFont.cxx:1492
 TGFont.cxx:1493
 TGFont.cxx:1494
 TGFont.cxx:1495
 TGFont.cxx:1496
 TGFont.cxx:1497
 TGFont.cxx:1498
 TGFont.cxx:1499
 TGFont.cxx:1500
 TGFont.cxx:1501
 TGFont.cxx:1502
 TGFont.cxx:1503
 TGFont.cxx:1504
 TGFont.cxx:1505
 TGFont.cxx:1506
 TGFont.cxx:1507
 TGFont.cxx:1508
 TGFont.cxx:1509
 TGFont.cxx:1510
 TGFont.cxx:1511
 TGFont.cxx:1512
 TGFont.cxx:1513
 TGFont.cxx:1514
 TGFont.cxx:1515
 TGFont.cxx:1516
 TGFont.cxx:1517
 TGFont.cxx:1518
 TGFont.cxx:1519
 TGFont.cxx:1520
 TGFont.cxx:1521
 TGFont.cxx:1522
 TGFont.cxx:1523
 TGFont.cxx:1524
 TGFont.cxx:1525
 TGFont.cxx:1526
 TGFont.cxx:1527
 TGFont.cxx:1528
 TGFont.cxx:1529
 TGFont.cxx:1530
 TGFont.cxx:1531
 TGFont.cxx:1532
 TGFont.cxx:1533
 TGFont.cxx:1534
 TGFont.cxx:1535
 TGFont.cxx:1536
 TGFont.cxx:1537
 TGFont.cxx:1538
 TGFont.cxx:1539
 TGFont.cxx:1540
 TGFont.cxx:1541
 TGFont.cxx:1542
 TGFont.cxx:1543
 TGFont.cxx:1544
 TGFont.cxx:1545
 TGFont.cxx:1546
 TGFont.cxx:1547
 TGFont.cxx:1548
 TGFont.cxx:1549
 TGFont.cxx:1550
 TGFont.cxx:1551
 TGFont.cxx:1552
 TGFont.cxx:1553
 TGFont.cxx:1554
 TGFont.cxx:1555
 TGFont.cxx:1556
 TGFont.cxx:1557
 TGFont.cxx:1558
 TGFont.cxx:1559
 TGFont.cxx:1560
 TGFont.cxx:1561
 TGFont.cxx:1562
 TGFont.cxx:1563
 TGFont.cxx:1564
 TGFont.cxx:1565
 TGFont.cxx:1566
 TGFont.cxx:1567
 TGFont.cxx:1568
 TGFont.cxx:1569
 TGFont.cxx:1570
 TGFont.cxx:1571
 TGFont.cxx:1572
 TGFont.cxx:1573
 TGFont.cxx:1574
 TGFont.cxx:1575
 TGFont.cxx:1576
 TGFont.cxx:1577
 TGFont.cxx:1578
 TGFont.cxx:1579
 TGFont.cxx:1580
 TGFont.cxx:1581
 TGFont.cxx:1582
 TGFont.cxx:1583
 TGFont.cxx:1584
 TGFont.cxx:1585
 TGFont.cxx:1586
 TGFont.cxx:1587
 TGFont.cxx:1588
 TGFont.cxx:1589
 TGFont.cxx:1590
 TGFont.cxx:1591
 TGFont.cxx:1592
 TGFont.cxx:1593
 TGFont.cxx:1594
 TGFont.cxx:1595
 TGFont.cxx:1596
 TGFont.cxx:1597
 TGFont.cxx:1598
 TGFont.cxx:1599
 TGFont.cxx:1600
 TGFont.cxx:1601
 TGFont.cxx:1602
 TGFont.cxx:1603
 TGFont.cxx:1604
 TGFont.cxx:1605
 TGFont.cxx:1606
 TGFont.cxx:1607
 TGFont.cxx:1608
 TGFont.cxx:1609
 TGFont.cxx:1610
 TGFont.cxx:1611
 TGFont.cxx:1612
 TGFont.cxx:1613
 TGFont.cxx:1614
 TGFont.cxx:1615
 TGFont.cxx:1616
 TGFont.cxx:1617
 TGFont.cxx:1618
 TGFont.cxx:1619
 TGFont.cxx:1620
 TGFont.cxx:1621
 TGFont.cxx:1622
 TGFont.cxx:1623
 TGFont.cxx:1624
 TGFont.cxx:1625
 TGFont.cxx:1626
 TGFont.cxx:1627
 TGFont.cxx:1628
 TGFont.cxx:1629
 TGFont.cxx:1630
 TGFont.cxx:1631
 TGFont.cxx:1632
 TGFont.cxx:1633
 TGFont.cxx:1634
 TGFont.cxx:1635
 TGFont.cxx:1636
 TGFont.cxx:1637
 TGFont.cxx:1638
 TGFont.cxx:1639
 TGFont.cxx:1640
 TGFont.cxx:1641
 TGFont.cxx:1642
 TGFont.cxx:1643
 TGFont.cxx:1644
 TGFont.cxx:1645
 TGFont.cxx:1646
 TGFont.cxx:1647
 TGFont.cxx:1648
 TGFont.cxx:1649
 TGFont.cxx:1650
 TGFont.cxx:1651
 TGFont.cxx:1652
 TGFont.cxx:1653
 TGFont.cxx:1654
 TGFont.cxx:1655
 TGFont.cxx:1656
 TGFont.cxx:1657
 TGFont.cxx:1658
 TGFont.cxx:1659
 TGFont.cxx:1660
 TGFont.cxx:1661
 TGFont.cxx:1662
 TGFont.cxx:1663
 TGFont.cxx:1664
 TGFont.cxx:1665
 TGFont.cxx:1666
 TGFont.cxx:1667
 TGFont.cxx:1668
 TGFont.cxx:1669
 TGFont.cxx:1670
 TGFont.cxx:1671
 TGFont.cxx:1672
 TGFont.cxx:1673
 TGFont.cxx:1674
 TGFont.cxx:1675
 TGFont.cxx:1676
 TGFont.cxx:1677
 TGFont.cxx:1678
 TGFont.cxx:1679
 TGFont.cxx:1680
 TGFont.cxx:1681
 TGFont.cxx:1682
 TGFont.cxx:1683
 TGFont.cxx:1684
 TGFont.cxx:1685
 TGFont.cxx:1686
 TGFont.cxx:1687
 TGFont.cxx:1688
 TGFont.cxx:1689
 TGFont.cxx:1690
 TGFont.cxx:1691
 TGFont.cxx:1692
 TGFont.cxx:1693
 TGFont.cxx:1694
 TGFont.cxx:1695
 TGFont.cxx:1696
 TGFont.cxx:1697
 TGFont.cxx:1698
 TGFont.cxx:1699
 TGFont.cxx:1700
 TGFont.cxx:1701
 TGFont.cxx:1702
 TGFont.cxx:1703
 TGFont.cxx:1704
 TGFont.cxx:1705
 TGFont.cxx:1706
 TGFont.cxx:1707
 TGFont.cxx:1708
 TGFont.cxx:1709
 TGFont.cxx:1710
 TGFont.cxx:1711
 TGFont.cxx:1712
 TGFont.cxx:1713
 TGFont.cxx:1714
 TGFont.cxx:1715
 TGFont.cxx:1716
 TGFont.cxx:1717
 TGFont.cxx:1718
 TGFont.cxx:1719
 TGFont.cxx:1720
 TGFont.cxx:1721
 TGFont.cxx:1722
 TGFont.cxx:1723
 TGFont.cxx:1724
 TGFont.cxx:1725
 TGFont.cxx:1726
 TGFont.cxx:1727
 TGFont.cxx:1728
 TGFont.cxx:1729
 TGFont.cxx:1730
 TGFont.cxx:1731
 TGFont.cxx:1732
 TGFont.cxx:1733
 TGFont.cxx:1734
 TGFont.cxx:1735
 TGFont.cxx:1736
 TGFont.cxx:1737
 TGFont.cxx:1738
 TGFont.cxx:1739
 TGFont.cxx:1740
 TGFont.cxx:1741
 TGFont.cxx:1742
 TGFont.cxx:1743
 TGFont.cxx:1744
 TGFont.cxx:1745
 TGFont.cxx:1746
 TGFont.cxx:1747
 TGFont.cxx:1748
 TGFont.cxx:1749
 TGFont.cxx:1750
 TGFont.cxx:1751
 TGFont.cxx:1752
 TGFont.cxx:1753
 TGFont.cxx:1754
 TGFont.cxx:1755
 TGFont.cxx:1756
 TGFont.cxx:1757
 TGFont.cxx:1758
 TGFont.cxx:1759
 TGFont.cxx:1760
 TGFont.cxx:1761
 TGFont.cxx:1762
 TGFont.cxx:1763
 TGFont.cxx:1764
 TGFont.cxx:1765
 TGFont.cxx:1766
 TGFont.cxx:1767
 TGFont.cxx:1768
 TGFont.cxx:1769
 TGFont.cxx:1770
 TGFont.cxx:1771
 TGFont.cxx:1772
 TGFont.cxx:1773
 TGFont.cxx:1774
 TGFont.cxx:1775
 TGFont.cxx:1776
 TGFont.cxx:1777
 TGFont.cxx:1778
 TGFont.cxx:1779
 TGFont.cxx:1780
 TGFont.cxx:1781
 TGFont.cxx:1782
 TGFont.cxx:1783
 TGFont.cxx:1784
 TGFont.cxx:1785
 TGFont.cxx:1786
 TGFont.cxx:1787
 TGFont.cxx:1788
 TGFont.cxx:1789
 TGFont.cxx:1790
 TGFont.cxx:1791
 TGFont.cxx:1792
 TGFont.cxx:1793
 TGFont.cxx:1794
 TGFont.cxx:1795
 TGFont.cxx:1796
 TGFont.cxx:1797
 TGFont.cxx:1798
 TGFont.cxx:1799
 TGFont.cxx:1800
 TGFont.cxx:1801
 TGFont.cxx:1802
 TGFont.cxx:1803
 TGFont.cxx:1804
 TGFont.cxx:1805
 TGFont.cxx:1806
 TGFont.cxx:1807
 TGFont.cxx:1808
 TGFont.cxx:1809
 TGFont.cxx:1810
 TGFont.cxx:1811
 TGFont.cxx:1812
 TGFont.cxx:1813
 TGFont.cxx:1814
 TGFont.cxx:1815
 TGFont.cxx:1816
 TGFont.cxx:1817
 TGFont.cxx:1818
 TGFont.cxx:1819
 TGFont.cxx:1820
 TGFont.cxx:1821
 TGFont.cxx:1822
 TGFont.cxx:1823
 TGFont.cxx:1824
 TGFont.cxx:1825
 TGFont.cxx:1826
 TGFont.cxx:1827
 TGFont.cxx:1828
 TGFont.cxx:1829
 TGFont.cxx:1830
 TGFont.cxx:1831
 TGFont.cxx:1832
 TGFont.cxx:1833
 TGFont.cxx:1834
 TGFont.cxx:1835
 TGFont.cxx:1836
 TGFont.cxx:1837
 TGFont.cxx:1838
 TGFont.cxx:1839
 TGFont.cxx:1840
 TGFont.cxx:1841
 TGFont.cxx:1842
 TGFont.cxx:1843
 TGFont.cxx:1844
 TGFont.cxx:1845
 TGFont.cxx:1846
 TGFont.cxx:1847
 TGFont.cxx:1848
 TGFont.cxx:1849
 TGFont.cxx:1850
 TGFont.cxx:1851
 TGFont.cxx:1852
 TGFont.cxx:1853
 TGFont.cxx:1854
 TGFont.cxx:1855
 TGFont.cxx:1856
 TGFont.cxx:1857
 TGFont.cxx:1858
 TGFont.cxx:1859
 TGFont.cxx:1860
 TGFont.cxx:1861
 TGFont.cxx:1862
 TGFont.cxx:1863
 TGFont.cxx:1864
 TGFont.cxx:1865
 TGFont.cxx:1866
 TGFont.cxx:1867
 TGFont.cxx:1868
 TGFont.cxx:1869
 TGFont.cxx:1870
 TGFont.cxx:1871
 TGFont.cxx:1872
 TGFont.cxx:1873
 TGFont.cxx:1874
 TGFont.cxx:1875
 TGFont.cxx:1876
 TGFont.cxx:1877
 TGFont.cxx:1878
 TGFont.cxx:1879
 TGFont.cxx:1880
 TGFont.cxx:1881
 TGFont.cxx:1882
 TGFont.cxx:1883
 TGFont.cxx:1884
 TGFont.cxx:1885
 TGFont.cxx:1886
 TGFont.cxx:1887
 TGFont.cxx:1888
 TGFont.cxx:1889
 TGFont.cxx:1890
 TGFont.cxx:1891
 TGFont.cxx:1892
 TGFont.cxx:1893
 TGFont.cxx:1894
 TGFont.cxx:1895
 TGFont.cxx:1896
 TGFont.cxx:1897
 TGFont.cxx:1898
 TGFont.cxx:1899
 TGFont.cxx:1900
 TGFont.cxx:1901
 TGFont.cxx:1902
 TGFont.cxx:1903
 TGFont.cxx:1904
 TGFont.cxx:1905
 TGFont.cxx:1906
 TGFont.cxx:1907
 TGFont.cxx:1908
 TGFont.cxx:1909
 TGFont.cxx:1910
 TGFont.cxx:1911
 TGFont.cxx:1912
 TGFont.cxx:1913
 TGFont.cxx:1914
 TGFont.cxx:1915
 TGFont.cxx:1916
 TGFont.cxx:1917
 TGFont.cxx:1918
 TGFont.cxx:1919
 TGFont.cxx:1920
 TGFont.cxx:1921
 TGFont.cxx:1922
 TGFont.cxx:1923
 TGFont.cxx:1924
 TGFont.cxx:1925
 TGFont.cxx:1926
 TGFont.cxx:1927
 TGFont.cxx:1928
 TGFont.cxx:1929
 TGFont.cxx:1930
 TGFont.cxx:1931
 TGFont.cxx:1932
 TGFont.cxx:1933
 TGFont.cxx:1934
 TGFont.cxx:1935
 TGFont.cxx:1936
 TGFont.cxx:1937
 TGFont.cxx:1938
 TGFont.cxx:1939
 TGFont.cxx:1940
 TGFont.cxx:1941
 TGFont.cxx:1942
 TGFont.cxx:1943
 TGFont.cxx:1944
 TGFont.cxx:1945
 TGFont.cxx:1946
 TGFont.cxx:1947
 TGFont.cxx:1948
 TGFont.cxx:1949
 TGFont.cxx:1950
 TGFont.cxx:1951
 TGFont.cxx:1952
 TGFont.cxx:1953
 TGFont.cxx:1954
 TGFont.cxx:1955
 TGFont.cxx:1956
 TGFont.cxx:1957
 TGFont.cxx:1958
 TGFont.cxx:1959
 TGFont.cxx:1960
 TGFont.cxx:1961
 TGFont.cxx:1962
 TGFont.cxx:1963
 TGFont.cxx:1964
 TGFont.cxx:1965
 TGFont.cxx:1966
 TGFont.cxx:1967
 TGFont.cxx:1968
 TGFont.cxx:1969
 TGFont.cxx:1970
 TGFont.cxx:1971
 TGFont.cxx:1972
 TGFont.cxx:1973
 TGFont.cxx:1974
 TGFont.cxx:1975
 TGFont.cxx:1976
 TGFont.cxx:1977
 TGFont.cxx:1978
 TGFont.cxx:1979
 TGFont.cxx:1980
 TGFont.cxx:1981
 TGFont.cxx:1982
 TGFont.cxx:1983
 TGFont.cxx:1984
 TGFont.cxx:1985
 TGFont.cxx:1986
 TGFont.cxx:1987
 TGFont.cxx:1988
 TGFont.cxx:1989
 TGFont.cxx:1990
 TGFont.cxx:1991
 TGFont.cxx:1992
 TGFont.cxx:1993
 TGFont.cxx:1994
 TGFont.cxx:1995
 TGFont.cxx:1996
 TGFont.cxx:1997
 TGFont.cxx:1998
 TGFont.cxx:1999
 TGFont.cxx:2000
 TGFont.cxx:2001
 TGFont.cxx:2002
 TGFont.cxx:2003
 TGFont.cxx:2004
 TGFont.cxx:2005
 TGFont.cxx:2006
 TGFont.cxx:2007
 TGFont.cxx:2008
 TGFont.cxx:2009
 TGFont.cxx:2010
 TGFont.cxx:2011
 TGFont.cxx:2012
 TGFont.cxx:2013
 TGFont.cxx:2014
 TGFont.cxx:2015
 TGFont.cxx:2016
 TGFont.cxx:2017
 TGFont.cxx:2018
 TGFont.cxx:2019
 TGFont.cxx:2020
 TGFont.cxx:2021
 TGFont.cxx:2022
 TGFont.cxx:2023
 TGFont.cxx:2024
 TGFont.cxx:2025
 TGFont.cxx:2026
 TGFont.cxx:2027
 TGFont.cxx:2028
 TGFont.cxx:2029
 TGFont.cxx:2030
 TGFont.cxx:2031
 TGFont.cxx:2032
 TGFont.cxx:2033
 TGFont.cxx:2034
 TGFont.cxx:2035
 TGFont.cxx:2036
 TGFont.cxx:2037
 TGFont.cxx:2038
 TGFont.cxx:2039
 TGFont.cxx:2040
 TGFont.cxx:2041
 TGFont.cxx:2042
 TGFont.cxx:2043
 TGFont.cxx:2044
 TGFont.cxx:2045
 TGFont.cxx:2046
 TGFont.cxx:2047
 TGFont.cxx:2048
 TGFont.cxx:2049
 TGFont.cxx:2050
 TGFont.cxx:2051
 TGFont.cxx:2052
 TGFont.cxx:2053
 TGFont.cxx:2054
 TGFont.cxx:2055
 TGFont.cxx:2056
 TGFont.cxx:2057
 TGFont.cxx:2058
 TGFont.cxx:2059
 TGFont.cxx:2060
 TGFont.cxx:2061
 TGFont.cxx:2062
 TGFont.cxx:2063
 TGFont.cxx:2064
 TGFont.cxx:2065
 TGFont.cxx:2066
 TGFont.cxx:2067
 TGFont.cxx:2068
 TGFont.cxx:2069
 TGFont.cxx:2070
 TGFont.cxx:2071
 TGFont.cxx:2072
 TGFont.cxx:2073
 TGFont.cxx:2074
 TGFont.cxx:2075
 TGFont.cxx:2076
 TGFont.cxx:2077
 TGFont.cxx:2078
 TGFont.cxx:2079
 TGFont.cxx:2080
 TGFont.cxx:2081
 TGFont.cxx:2082
 TGFont.cxx:2083
 TGFont.cxx:2084
 TGFont.cxx:2085
 TGFont.cxx:2086
 TGFont.cxx:2087
 TGFont.cxx:2088
 TGFont.cxx:2089
 TGFont.cxx:2090
 TGFont.cxx:2091
 TGFont.cxx:2092
 TGFont.cxx:2093
 TGFont.cxx:2094
 TGFont.cxx:2095
 TGFont.cxx:2096
 TGFont.cxx:2097
 TGFont.cxx:2098
 TGFont.cxx:2099
 TGFont.cxx:2100
 TGFont.cxx:2101
 TGFont.cxx:2102
 TGFont.cxx:2103
 TGFont.cxx:2104
 TGFont.cxx:2105
 TGFont.cxx:2106
 TGFont.cxx:2107
 TGFont.cxx:2108
 TGFont.cxx:2109
 TGFont.cxx:2110
 TGFont.cxx:2111
 TGFont.cxx:2112
 TGFont.cxx:2113
 TGFont.cxx:2114
 TGFont.cxx:2115
 TGFont.cxx:2116
 TGFont.cxx:2117
 TGFont.cxx:2118
 TGFont.cxx:2119
 TGFont.cxx:2120
 TGFont.cxx:2121
 TGFont.cxx:2122
 TGFont.cxx:2123
 TGFont.cxx:2124
 TGFont.cxx:2125
 TGFont.cxx:2126
 TGFont.cxx:2127
 TGFont.cxx:2128
 TGFont.cxx:2129
 TGFont.cxx:2130
 TGFont.cxx:2131
 TGFont.cxx:2132
 TGFont.cxx:2133
 TGFont.cxx:2134
 TGFont.cxx:2135
 TGFont.cxx:2136
 TGFont.cxx:2137
 TGFont.cxx:2138
 TGFont.cxx:2139
 TGFont.cxx:2140
 TGFont.cxx:2141
 TGFont.cxx:2142
 TGFont.cxx:2143
 TGFont.cxx:2144
 TGFont.cxx:2145
 TGFont.cxx:2146
 TGFont.cxx:2147
 TGFont.cxx:2148
 TGFont.cxx:2149
 TGFont.cxx:2150
 TGFont.cxx:2151
 TGFont.cxx:2152
 TGFont.cxx:2153
 TGFont.cxx:2154
 TGFont.cxx:2155
 TGFont.cxx:2156
 TGFont.cxx:2157
 TGFont.cxx:2158
 TGFont.cxx:2159
 TGFont.cxx:2160
 TGFont.cxx:2161
 TGFont.cxx:2162
 TGFont.cxx:2163
 TGFont.cxx:2164
 TGFont.cxx:2165
 TGFont.cxx:2166
 TGFont.cxx:2167
 TGFont.cxx:2168
 TGFont.cxx:2169
 TGFont.cxx:2170
 TGFont.cxx:2171
 TGFont.cxx:2172
 TGFont.cxx:2173
 TGFont.cxx:2174
 TGFont.cxx:2175
 TGFont.cxx:2176
 TGFont.cxx:2177
 TGFont.cxx:2178
 TGFont.cxx:2179
 TGFont.cxx:2180
 TGFont.cxx:2181
 TGFont.cxx:2182
 TGFont.cxx:2183
 TGFont.cxx:2184
 TGFont.cxx:2185
 TGFont.cxx:2186
 TGFont.cxx:2187
 TGFont.cxx:2188
 TGFont.cxx:2189
 TGFont.cxx:2190
 TGFont.cxx:2191
 TGFont.cxx:2192
 TGFont.cxx:2193
 TGFont.cxx:2194
 TGFont.cxx:2195
 TGFont.cxx:2196
 TGFont.cxx:2197
 TGFont.cxx:2198
 TGFont.cxx:2199
 TGFont.cxx:2200
 TGFont.cxx:2201
 TGFont.cxx:2202
 TGFont.cxx:2203
 TGFont.cxx:2204
 TGFont.cxx:2205
 TGFont.cxx:2206
 TGFont.cxx:2207
 TGFont.cxx:2208
 TGFont.cxx:2209
 TGFont.cxx:2210
 TGFont.cxx:2211
 TGFont.cxx:2212
 TGFont.cxx:2213
 TGFont.cxx:2214
 TGFont.cxx:2215
 TGFont.cxx:2216
 TGFont.cxx:2217
 TGFont.cxx:2218
 TGFont.cxx:2219
 TGFont.cxx:2220
 TGFont.cxx:2221
 TGFont.cxx:2222
 TGFont.cxx:2223
 TGFont.cxx:2224
 TGFont.cxx:2225
 TGFont.cxx:2226
 TGFont.cxx:2227
 TGFont.cxx:2228
 TGFont.cxx:2229
 TGFont.cxx:2230
 TGFont.cxx:2231
 TGFont.cxx:2232
 TGFont.cxx:2233
 TGFont.cxx:2234
 TGFont.cxx:2235
 TGFont.cxx:2236
 TGFont.cxx:2237
 TGFont.cxx:2238
 TGFont.cxx:2239
 TGFont.cxx:2240
 TGFont.cxx:2241
 TGFont.cxx:2242
 TGFont.cxx:2243
 TGFont.cxx:2244
 TGFont.cxx:2245
 TGFont.cxx:2246
 TGFont.cxx:2247
 TGFont.cxx:2248
 TGFont.cxx:2249
 TGFont.cxx:2250
 TGFont.cxx:2251
 TGFont.cxx:2252
 TGFont.cxx:2253
 TGFont.cxx:2254
 TGFont.cxx:2255
 TGFont.cxx:2256
 TGFont.cxx:2257
 TGFont.cxx:2258
 TGFont.cxx:2259
 TGFont.cxx:2260
 TGFont.cxx:2261
 TGFont.cxx:2262
 TGFont.cxx:2263
 TGFont.cxx:2264
 TGFont.cxx:2265
 TGFont.cxx:2266
 TGFont.cxx:2267
 TGFont.cxx:2268
 TGFont.cxx:2269
 TGFont.cxx:2270
 TGFont.cxx:2271
 TGFont.cxx:2272
 TGFont.cxx:2273
 TGFont.cxx:2274
 TGFont.cxx:2275
 TGFont.cxx:2276
 TGFont.cxx:2277
 TGFont.cxx:2278
 TGFont.cxx:2279
 TGFont.cxx:2280
 TGFont.cxx:2281
 TGFont.cxx:2282
 TGFont.cxx:2283
 TGFont.cxx:2284
 TGFont.cxx:2285
 TGFont.cxx:2286
 TGFont.cxx:2287
 TGFont.cxx:2288
 TGFont.cxx:2289
 TGFont.cxx:2290
 TGFont.cxx:2291
 TGFont.cxx:2292
 TGFont.cxx:2293
 TGFont.cxx:2294
 TGFont.cxx:2295
 TGFont.cxx:2296
 TGFont.cxx:2297
 TGFont.cxx:2298
 TGFont.cxx:2299
 TGFont.cxx:2300
 TGFont.cxx:2301
 TGFont.cxx:2302
 TGFont.cxx:2303
 TGFont.cxx:2304
 TGFont.cxx:2305
 TGFont.cxx:2306
 TGFont.cxx:2307
 TGFont.cxx:2308
 TGFont.cxx:2309
 TGFont.cxx:2310
 TGFont.cxx:2311
 TGFont.cxx:2312
 TGFont.cxx:2313
 TGFont.cxx:2314
 TGFont.cxx:2315
 TGFont.cxx:2316
 TGFont.cxx:2317
 TGFont.cxx:2318
 TGFont.cxx:2319
 TGFont.cxx:2320
 TGFont.cxx:2321
 TGFont.cxx:2322
 TGFont.cxx:2323
 TGFont.cxx:2324
 TGFont.cxx:2325
 TGFont.cxx:2326
 TGFont.cxx:2327
 TGFont.cxx:2328
 TGFont.cxx:2329
 TGFont.cxx:2330
 TGFont.cxx:2331
 TGFont.cxx:2332
 TGFont.cxx:2333
 TGFont.cxx:2334
 TGFont.cxx:2335
 TGFont.cxx:2336
 TGFont.cxx:2337
 TGFont.cxx:2338
 TGFont.cxx:2339
 TGFont.cxx:2340
 TGFont.cxx:2341
 TGFont.cxx:2342
 TGFont.cxx:2343
 TGFont.cxx:2344
 TGFont.cxx:2345
 TGFont.cxx:2346
 TGFont.cxx:2347
 TGFont.cxx:2348
 TGFont.cxx:2349
 TGFont.cxx:2350
 TGFont.cxx:2351
 TGFont.cxx:2352
 TGFont.cxx:2353
 TGFont.cxx:2354
 TGFont.cxx:2355
 TGFont.cxx:2356
 TGFont.cxx:2357
 TGFont.cxx:2358
 TGFont.cxx:2359
 TGFont.cxx:2360
 TGFont.cxx:2361
 TGFont.cxx:2362
 TGFont.cxx:2363
 TGFont.cxx:2364
 TGFont.cxx:2365
 TGFont.cxx:2366
 TGFont.cxx:2367
 TGFont.cxx:2368
 TGFont.cxx:2369
 TGFont.cxx:2370
 TGFont.cxx:2371
 TGFont.cxx:2372
 TGFont.cxx:2373
 TGFont.cxx:2374
 TGFont.cxx:2375
 TGFont.cxx:2376
 TGFont.cxx:2377
 TGFont.cxx:2378
 TGFont.cxx:2379
 TGFont.cxx:2380
 TGFont.cxx:2381
 TGFont.cxx:2382
 TGFont.cxx:2383
 TGFont.cxx:2384
 TGFont.cxx:2385
 TGFont.cxx:2386
 TGFont.cxx:2387
 TGFont.cxx:2388
 TGFont.cxx:2389
 TGFont.cxx:2390
 TGFont.cxx:2391
 TGFont.cxx:2392
 TGFont.cxx:2393
 TGFont.cxx:2394
 TGFont.cxx:2395
 TGFont.cxx:2396
 TGFont.cxx:2397
 TGFont.cxx:2398
 TGFont.cxx:2399
 TGFont.cxx:2400
 TGFont.cxx:2401
 TGFont.cxx:2402
 TGFont.cxx:2403
 TGFont.cxx:2404
 TGFont.cxx:2405
 TGFont.cxx:2406
 TGFont.cxx:2407
 TGFont.cxx:2408
 TGFont.cxx:2409
 TGFont.cxx:2410
 TGFont.cxx:2411
 TGFont.cxx:2412
 TGFont.cxx:2413
 TGFont.cxx:2414
 TGFont.cxx:2415
 TGFont.cxx:2416
 TGFont.cxx:2417
 TGFont.cxx:2418
 TGFont.cxx:2419
 TGFont.cxx:2420
 TGFont.cxx:2421
 TGFont.cxx:2422
 TGFont.cxx:2423
 TGFont.cxx:2424
 TGFont.cxx:2425
 TGFont.cxx:2426
 TGFont.cxx:2427
 TGFont.cxx:2428
 TGFont.cxx:2429
 TGFont.cxx:2430
 TGFont.cxx:2431
 TGFont.cxx:2432
 TGFont.cxx:2433
 TGFont.cxx:2434
 TGFont.cxx:2435
 TGFont.cxx:2436
 TGFont.cxx:2437
 TGFont.cxx:2438
 TGFont.cxx:2439
 TGFont.cxx:2440
 TGFont.cxx:2441
 TGFont.cxx:2442
 TGFont.cxx:2443
 TGFont.cxx:2444
 TGFont.cxx:2445
 TGFont.cxx:2446
 TGFont.cxx:2447
 TGFont.cxx:2448
 TGFont.cxx:2449
 TGFont.cxx:2450
 TGFont.cxx:2451
 TGFont.cxx:2452
 TGFont.cxx:2453
 TGFont.cxx:2454
 TGFont.cxx:2455
 TGFont.cxx:2456
 TGFont.cxx:2457
 TGFont.cxx:2458
 TGFont.cxx:2459
 TGFont.cxx:2460
 TGFont.cxx:2461
 TGFont.cxx:2462
 TGFont.cxx:2463
 TGFont.cxx:2464
 TGFont.cxx:2465
 TGFont.cxx:2466
 TGFont.cxx:2467
 TGFont.cxx:2468
 TGFont.cxx:2469
 TGFont.cxx:2470
 TGFont.cxx:2471
 TGFont.cxx:2472
 TGFont.cxx:2473
 TGFont.cxx:2474
 TGFont.cxx:2475
 TGFont.cxx:2476
 TGFont.cxx:2477
 TGFont.cxx:2478
 TGFont.cxx:2479
 TGFont.cxx:2480
 TGFont.cxx:2481
 TGFont.cxx:2482
 TGFont.cxx:2483
 TGFont.cxx:2484
 TGFont.cxx:2485
 TGFont.cxx:2486
 TGFont.cxx:2487
 TGFont.cxx:2488
 TGFont.cxx:2489
 TGFont.cxx:2490
 TGFont.cxx:2491
 TGFont.cxx:2492
 TGFont.cxx:2493
 TGFont.cxx:2494
 TGFont.cxx:2495
 TGFont.cxx:2496
 TGFont.cxx:2497
 TGFont.cxx:2498
 TGFont.cxx:2499
 TGFont.cxx:2500
 TGFont.cxx:2501
 TGFont.cxx:2502
 TGFont.cxx:2503
 TGFont.cxx:2504
 TGFont.cxx:2505
 TGFont.cxx:2506
 TGFont.cxx:2507
 TGFont.cxx:2508
 TGFont.cxx:2509
 TGFont.cxx:2510
 TGFont.cxx:2511
 TGFont.cxx:2512
 TGFont.cxx:2513
 TGFont.cxx:2514
 TGFont.cxx:2515
 TGFont.cxx:2516
 TGFont.cxx:2517
 TGFont.cxx:2518
 TGFont.cxx:2519
 TGFont.cxx:2520
 TGFont.cxx:2521
 TGFont.cxx:2522
 TGFont.cxx:2523
 TGFont.cxx:2524
 TGFont.cxx:2525
 TGFont.cxx:2526
 TGFont.cxx:2527
 TGFont.cxx:2528
 TGFont.cxx:2529
 TGFont.cxx:2530
 TGFont.cxx:2531
 TGFont.cxx:2532
 TGFont.cxx:2533
 TGFont.cxx:2534
 TGFont.cxx:2535
 TGFont.cxx:2536
 TGFont.cxx:2537
 TGFont.cxx:2538
 TGFont.cxx:2539
 TGFont.cxx:2540
 TGFont.cxx:2541
 TGFont.cxx:2542
 TGFont.cxx:2543
 TGFont.cxx:2544
 TGFont.cxx:2545
 TGFont.cxx:2546
 TGFont.cxx:2547
 TGFont.cxx:2548
 TGFont.cxx:2549
 TGFont.cxx:2550
 TGFont.cxx:2551
 TGFont.cxx:2552
 TGFont.cxx:2553
 TGFont.cxx:2554
 TGFont.cxx:2555
 TGFont.cxx:2556
 TGFont.cxx:2557
 TGFont.cxx:2558
 TGFont.cxx:2559
 TGFont.cxx:2560
 TGFont.cxx:2561
 TGFont.cxx:2562
 TGFont.cxx:2563
 TGFont.cxx:2564
 TGFont.cxx:2565
 TGFont.cxx:2566
 TGFont.cxx:2567
 TGFont.cxx:2568
 TGFont.cxx:2569
 TGFont.cxx:2570
 TGFont.cxx:2571
 TGFont.cxx:2572
 TGFont.cxx:2573
 TGFont.cxx:2574
 TGFont.cxx:2575
 TGFont.cxx:2576
 TGFont.cxx:2577
 TGFont.cxx:2578
 TGFont.cxx:2579
 TGFont.cxx:2580
 TGFont.cxx:2581
 TGFont.cxx:2582
 TGFont.cxx:2583
 TGFont.cxx:2584
 TGFont.cxx:2585
 TGFont.cxx:2586
 TGFont.cxx:2587
 TGFont.cxx:2588
 TGFont.cxx:2589
 TGFont.cxx:2590
 TGFont.cxx:2591
 TGFont.cxx:2592
 TGFont.cxx:2593
 TGFont.cxx:2594
 TGFont.cxx:2595
 TGFont.cxx:2596
 TGFont.cxx:2597
 TGFont.cxx:2598
 TGFont.cxx:2599
 TGFont.cxx:2600
 TGFont.cxx:2601
 TGFont.cxx:2602
 TGFont.cxx:2603
 TGFont.cxx:2604
 TGFont.cxx:2605
 TGFont.cxx:2606
 TGFont.cxx:2607
 TGFont.cxx:2608
 TGFont.cxx:2609
 TGFont.cxx:2610
 TGFont.cxx:2611
 TGFont.cxx:2612
 TGFont.cxx:2613
 TGFont.cxx:2614
 TGFont.cxx:2615
 TGFont.cxx:2616
 TGFont.cxx:2617
 TGFont.cxx:2618
 TGFont.cxx:2619
 TGFont.cxx:2620
 TGFont.cxx:2621
 TGFont.cxx:2622
 TGFont.cxx:2623
 TGFont.cxx:2624
 TGFont.cxx:2625
 TGFont.cxx:2626
 TGFont.cxx:2627
 TGFont.cxx:2628
 TGFont.cxx:2629
 TGFont.cxx:2630
 TGFont.cxx:2631
 TGFont.cxx:2632
 TGFont.cxx:2633
 TGFont.cxx:2634
 TGFont.cxx:2635
 TGFont.cxx:2636
 TGFont.cxx:2637
 TGFont.cxx:2638
 TGFont.cxx:2639
 TGFont.cxx:2640
 TGFont.cxx:2641
 TGFont.cxx:2642
 TGFont.cxx:2643
 TGFont.cxx:2644
 TGFont.cxx:2645
 TGFont.cxx:2646
 TGFont.cxx:2647
 TGFont.cxx:2648
 TGFont.cxx:2649
 TGFont.cxx:2650
 TGFont.cxx:2651
 TGFont.cxx:2652
 TGFont.cxx:2653
 TGFont.cxx:2654
 TGFont.cxx:2655
 TGFont.cxx:2656
 TGFont.cxx:2657
 TGFont.cxx:2658
 TGFont.cxx:2659
 TGFont.cxx:2660
 TGFont.cxx:2661
 TGFont.cxx:2662
 TGFont.cxx:2663
 TGFont.cxx:2664
 TGFont.cxx:2665
 TGFont.cxx:2666
 TGFont.cxx:2667
 TGFont.cxx:2668
 TGFont.cxx:2669
 TGFont.cxx:2670
 TGFont.cxx:2671
 TGFont.cxx:2672
 TGFont.cxx:2673
 TGFont.cxx:2674
 TGFont.cxx:2675
 TGFont.cxx:2676
 TGFont.cxx:2677
 TGFont.cxx:2678
 TGFont.cxx:2679
 TGFont.cxx:2680
 TGFont.cxx:2681
 TGFont.cxx:2682
 TGFont.cxx:2683
 TGFont.cxx:2684
 TGFont.cxx:2685
 TGFont.cxx:2686
 TGFont.cxx:2687
 TGFont.cxx:2688
 TGFont.cxx:2689
 TGFont.cxx:2690
 TGFont.cxx:2691
 TGFont.cxx:2692
 TGFont.cxx:2693
 TGFont.cxx:2694
 TGFont.cxx:2695
 TGFont.cxx:2696
 TGFont.cxx:2697
 TGFont.cxx:2698
 TGFont.cxx:2699
 TGFont.cxx:2700
 TGFont.cxx:2701
 TGFont.cxx:2702
 TGFont.cxx:2703
 TGFont.cxx:2704
 TGFont.cxx:2705
 TGFont.cxx:2706
 TGFont.cxx:2707
 TGFont.cxx:2708
 TGFont.cxx:2709
 TGFont.cxx:2710
 TGFont.cxx:2711
 TGFont.cxx:2712
 TGFont.cxx:2713
 TGFont.cxx:2714
 TGFont.cxx:2715
 TGFont.cxx:2716
 TGFont.cxx:2717
 TGFont.cxx:2718
 TGFont.cxx:2719
 TGFont.cxx:2720
 TGFont.cxx:2721
 TGFont.cxx:2722
 TGFont.cxx:2723
 TGFont.cxx:2724
 TGFont.cxx:2725
 TGFont.cxx:2726
 TGFont.cxx:2727
 TGFont.cxx:2728
 TGFont.cxx:2729
 TGFont.cxx:2730
 TGFont.cxx:2731
 TGFont.cxx:2732
 TGFont.cxx:2733
 TGFont.cxx:2734