/[dtapublic]/projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkwinfont.c

Diff of /projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkwinfont.c

Parent Directory | Revision Log | View Patch Patch

-revision 69 by dashley,
Sat Nov  5 10:54:17 2016 UTC
+revision 71 by dashley,
Sat Nov  5 11:07:06 2016 UTC
 Line 1
  /* $Header$ */
  /*
   * tkWinFont.c --
   *
   *      Contains the Windows implementation of the platform-independant
   *      font package interface.
   *
   * Copyright (c) 1994 Software Research Associates, Inc.
   * Copyright (c) 1995-1997 Sun Microsystems, Inc.
   * Copyright (c) 1998-1999 by Scriptics Corporation.
   *
   * See the file "license.terms" for information on usage and redistribution
   * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   *
   * RCS: @(#) $Id: tkwinfont.c,v 1.1.1.1 2001/06/13 05:13:30 dtashley Exp $
   */
  #include "tkWinInt.h"
  #include "tkFont.h"
  /*
   * The following structure represents a font family.  It is assumed that
   * all screen fonts constructed from the same "font family" share certain
   * properties; all screen fonts with the same "font family" point to a
   * shared instance of this structure.  The most important shared property
   * is the character existence metrics, used to determine if a screen font
   * can display a given Unicode character.
   *
   * Under Windows, a "font family" is uniquely identified by its face name.
   */
  #define FONTMAP_SHIFT       10
  #define FONTMAP_PAGES           (1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
  #define FONTMAP_BITSPERPAGE     (1 << FONTMAP_SHIFT)
  typedef struct FontFamily {
      struct FontFamily *nextPtr; /* Next in list of all known font families. */
      int refCount;               /* How many SubFonts are referring to this
                                   * FontFamily.  When the refCount drops to
                                   * zero, this FontFamily may be freed. */
      /*
       * Key.
       */
      Tk_Uid faceName;            /* Face name key for this FontFamily. */
      /*
       * Derived properties.
       */
      Tcl_Encoding encoding;      /* Encoding for this font family. */
      int isSymbolFont;           /* Non-zero if this is a symbol font. */
      int isWideFont;             /* 1 if this is a double-byte font, 0
                                   * otherwise. */
      BOOL (WINAPI *textOutProc)(HDC, int, int, TCHAR *, int);
                                  /* The procedure to use to draw text after
                                   * it has been converted from UTF-8 to the
                                   * encoding of this font. */
      BOOL (WINAPI *getTextExtentPoint32Proc)(HDC, TCHAR *, int, LPSIZE);
                                  /* The procedure to use to measure text after
                                   * it has been converted from UTF-8 to the
                                   * encoding of this font. */
      char *fontMap[FONTMAP_PAGES];
                                  /* Two-level sparse table used to determine
                                   * quickly if the specified character exists.
                                   * As characters are encountered, more pages
                                   * in this table are dynamically added.  The
                                   * contents of each page is a bitmask
                                   * consisting of FONTMAP_BITSPERPAGE bits,
                                   * representing whether this font can be used
                                   * to display the given character at the
                                   * corresponding bit position.  The high bits
                                   * of the character are used to pick which
                                   * page of the table is used. */
      /*
       * Cached Truetype font info.
       */
      int segCount;               /* The length of the following arrays. */
      USHORT *startCount;         /* Truetype information about the font, */
      USHORT *endCount;           /* indicating which characters this font
                                   * can display (malloced).  The format of
                                   * this information is (relatively) compact,
                                   * but would take longer to search than
                                   * indexing into the fontMap[][] table. */
  } FontFamily;
  /*
   * The following structure encapsulates an individual screen font.  A font
   * object is made up of however many SubFonts are necessary to display a
   * stream of multilingual characters.
   */
  typedef struct SubFont {
      char **fontMap;             /* Pointer to font map from the FontFamily,
                                   * cached here to save a dereference. */
      HFONT hFont;                /* The specific screen font that will be
                                   * used when displaying/measuring chars
                                   * belonging to the FontFamily. */
      FontFamily *familyPtr;      /* The FontFamily for this SubFont. */
  } SubFont;
  /*
   * The following structure represents Windows' implementation of a font
   * object.
   */
  #define SUBFONT_SPACE           3
  #define BASE_CHARS              128
  typedef struct WinFont {
      TkFont font;                /* Stuff used by generic font package.  Must
                                   * be first in structure. */
      SubFont staticSubFonts[SUBFONT_SPACE];
                                  /* Builtin space for a limited number of
                                   * SubFonts. */
      int numSubFonts;            /* Length of following array. */
      SubFont *subFontArray;      /* Array of SubFonts that have been loaded
                                   * in order to draw/measure all the characters
                                   * encountered by this font so far.  All fonts
                                   * start off with one SubFont initialized by
                                   * AllocFont() from the original set of font
                                   * attributes.  Usually points to
                                   * staticSubFonts, but may point to malloced
                                   * space if there are lots of SubFonts. */
      HWND hwnd;                  /* Toplevel window of application that owns
                                   * this font, used for getting HDC for
                                   * offscreen measurements. */
      int pixelSize;              /* Original pixel size used when font was
                                   * constructed. */
      int widths[BASE_CHARS];     /* Widths of first 128 chars in the base
                                   * font, for handling common case.  The base
                                   * font is always used to draw characters
                                   * between 0x0000 and 0x007f. */
  } WinFont;
  /*
   * The following structure is passed as the LPARAM when calling the font
   * enumeration procedure to determine if a font can support the given
   * character.
   */
  typedef struct CanUse {
      HDC hdc;
      WinFont *fontPtr;
      Tcl_DString *nameTriedPtr;
      int ch;
      SubFont *subFontPtr;
  } CanUse;
  /*
   * The following structure is used to map between the Tcl strings that
   * represent the system fonts and the numbers used by Windows.
   */
  static TkStateMap systemMap[] = {
      {ANSI_FIXED_FONT,       "ansifixed"},
      {ANSI_VAR_FONT,         "ansi"},
      {DEVICE_DEFAULT_FONT,   "device"},
      {OEM_FIXED_FONT,        "oemfixed"},
      {SYSTEM_FIXED_FONT,     "systemfixed"},
      {SYSTEM_FONT,           "system"},
      {-1,                    NULL}
  };
  typedef struct ThreadSpecificData {
      FontFamily *fontFamilyList; /* The list of font families that are
                                   * currently loaded.  As screen fonts
                                   * are loaded, this list grows to hold
                                   * information about what characters
                                   * exist in each font family.  */
      Tcl_HashTable uidTable;
  } ThreadSpecificData;
  static Tcl_ThreadDataKey dataKey;
  /*
   * Information cached about the system at startup time.
   */
  static Tcl_Encoding unicodeEncoding;
  static Tcl_Encoding systemEncoding;
  /*
   * Procedures used only in this file.
   */
  static FontFamily *     AllocFontFamily(HDC hdc, HFONT hFont, int base);
  static SubFont *        CanUseFallback(HDC hdc, WinFont *fontPtr,
                              char *fallbackName, int ch);
  static SubFont *        CanUseFallbackWithAliases(HDC hdc, WinFont *fontPtr,
                              char *faceName, int ch, Tcl_DString *nameTriedPtr);
  static int              FamilyExists(HDC hdc, CONST char *faceName);
  static char *           FamilyOrAliasExists(HDC hdc, CONST char *faceName);
  static SubFont *        FindSubFontForChar(WinFont *fontPtr, int ch);
  static void             FontMapInsert(SubFont *subFontPtr, int ch);
  static void             FontMapLoadPage(SubFont *subFontPtr, int row);
  static int              FontMapLookup(SubFont *subFontPtr, int ch);
  static void             FreeFontFamily(FontFamily *familyPtr);
  static HFONT            GetScreenFont(CONST TkFontAttributes *faPtr,
                              CONST char *faceName, int pixelSize);
  static void             InitFont(Tk_Window tkwin, HFONT hFont,
                              int overstrike, WinFont *tkFontPtr);
  static void             InitSubFont(HDC hdc, HFONT hFont, int base,
                              SubFont *subFontPtr);
  static int              LoadFontRanges(HDC hdc, HFONT hFont,
                              USHORT **startCount, USHORT **endCount,
                              int *symbolPtr);
  static void             MultiFontTextOut(HDC hdc, WinFont *fontPtr,
                              CONST char *source, int numBytes, int x, int y);
  static void             ReleaseFont(WinFont *fontPtr);
  static void             ReleaseSubFont(SubFont *subFontPtr);
  static int              SeenName(CONST char *name, Tcl_DString *dsPtr);
  static void             SwapLong(PULONG p);
  static void             SwapShort(USHORT *p);
  static int CALLBACK     WinFontCanUseProc(ENUMLOGFONT *lfPtr,
                              NEWTEXTMETRIC *tmPtr, int fontType,
                              LPARAM lParam);
  static int CALLBACK     WinFontExistProc(ENUMLOGFONT *lfPtr,
                              NEWTEXTMETRIC *tmPtr, int fontType,
                              LPARAM lParam);
  static int CALLBACK     WinFontFamilyEnumProc(ENUMLOGFONT *lfPtr,
                              NEWTEXTMETRIC *tmPtr, int fontType,
                              LPARAM lParam);
  /*
   *-------------------------------------------------------------------------
   *
   * TkpFontPkgInit --
   *
   *      This procedure is called when an application is created.  It
   *      initializes all the structures that are used by the
   *      platform-dependent code on a per application basis.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  void
  TkpFontPkgInit(
      TkMainInfo *mainPtr)        /* The application being created. */
  {
      unicodeEncoding = Tcl_GetEncoding(NULL, "unicode");
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          /*
           * If running NT, then we will be calling some Unicode functions
           * explictly.  So, even if the Tcl system encoding isn't Unicode,
           * make sure we convert to/from the Unicode char set.
           */
          systemEncoding = unicodeEncoding;
      }
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TkpGetNativeFont --
   *
   *      Map a platform-specific native font name to a TkFont.
   *
   * Results:
   *      The return value is a pointer to a TkFont 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 TkFont structure,
   *      even if the name has already been seen before.  The caller should
   *      call TkpDeleteFont() when the font is no longer needed.
   *
   *      The caller is responsible for initializing the memory associated
   *      with the generic TkFont when this function returns and releasing
   *      the contents of the generic TkFont before calling TkpDeleteFont().
   *
   * Side effects:
   *      Memory allocated.
   *
   *---------------------------------------------------------------------------
   */
  TkFont *
  TkpGetNativeFont(
      Tk_Window tkwin,            /* For display where font will be used. */
      CONST char *name)           /* Platform-specific font name. */
  {
      int object;
      WinFont *fontPtr;
      object = TkFindStateNum(NULL, NULL, systemMap, name);
      if (object < 0) {
          return NULL;
      }
      tkwin = (Tk_Window) ((TkWindow *) tkwin)->mainPtr->winPtr;
      fontPtr = (WinFont *) ckalloc(sizeof(WinFont));
      InitFont(tkwin, GetStockObject(object), 0, fontPtr);
      return (TkFont *) fontPtr;
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TkpGetFontFromAttributes --
   *
   *      Given a desired set of attributes for a font, find a font with
   *      the closest matching attributes.
   *
   * Results:
   *      The return value is a pointer to a TkFont 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.  NULL is never returned.
   *
   *      Every call to this procedure returns a new TkFont structure,
   *      even if the specified attributes have already been seen before.
   *      The caller should call TkpDeleteFont() to free the platform-
   *      specific data when the font is no longer needed.
   *
   *      The caller is responsible for initializing the memory associated
   *      with the generic TkFont when this function returns and releasing
   *      the contents of the generic TkFont before calling TkpDeleteFont().
   *
   * Side effects:
   *      Memory allocated.
   *
   *---------------------------------------------------------------------------
   */
  TkFont *
  TkpGetFontFromAttributes(
      TkFont *tkFontPtr,          /* If non-NULL, store the information in
                                   * this existing TkFont structure, rather than
                                   * allocating a new structure to hold the
                                   * font; the existing contents of the font
                                   * will be released.  If NULL, a new TkFont
                                   * structure is allocated. */
      Tk_Window tkwin,            /* For display where font will be used. */
      CONST TkFontAttributes *faPtr)
                                  /* Set of attributes to match. */
  {
      int i, j;
      HDC hdc;
      HWND hwnd;
      HFONT hFont;
      Window window;
      WinFont *fontPtr;
      char ***fontFallbacks;
      char *faceName, *fallback, *actualName;
      tkwin   = (Tk_Window) ((TkWindow *) tkwin)->mainPtr->winPtr;
      window  = Tk_WindowId(tkwin);
      hwnd    = (window == None) ? NULL : TkWinGetHWND(window);
      hdc     = GetDC(hwnd);
      /*
       * Algorithm to get the closest font name to the one requested.
       *
       * try fontname
       * try all aliases for fontname
       * foreach fallback for fontname
       *      try the fallback
       *      try all aliases for the fallback
       */
      faceName = faPtr->family;
      if (faceName != NULL) {
          actualName = FamilyOrAliasExists(hdc, faceName);
          if (actualName != NULL) {
              faceName = actualName;
              goto found;
          }
          fontFallbacks = TkFontGetFallbacks();
          for (i = 0; fontFallbacks[i] != NULL; i++) {
              for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
                  if (strcasecmp(faceName, fallback) == 0) {
                      break;
                  }
              }
              if (fallback != NULL) {
                  for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
                      actualName = FamilyOrAliasExists(hdc, fallback);
                      if (actualName != NULL) {
                          faceName = actualName;
                          goto found;
                      }
                  }
              }
          }
      }
      found:
      ReleaseDC(hwnd, hdc);
      hFont = GetScreenFont(faPtr, faceName, TkFontGetPixels(tkwin, faPtr->size));
      if (tkFontPtr == NULL) {
          fontPtr = (WinFont *) ckalloc(sizeof(WinFont));
      } else {
          fontPtr = (WinFont *) tkFontPtr;
          ReleaseFont(fontPtr);
      }
      InitFont(tkwin, hFont, faPtr->overstrike, fontPtr);
      return (TkFont *) fontPtr;
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TkpDeleteFont --
   *
   *      Called to release a font allocated by TkpGetNativeFont() or
   *      TkpGetFontFromAttributes().  The caller should have already
   *      released the fields of the TkFont that are used exclusively by
   *      the generic TkFont code.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      TkFont is deallocated.
   *
   *---------------------------------------------------------------------------
   */
  void
  TkpDeleteFont(
      TkFont *tkFontPtr)          /* Token of font to be deleted. */
  {
      WinFont *fontPtr;
      fontPtr = (WinFont *) tkFontPtr;
      ReleaseFont(fontPtr);
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TkpGetFontFamilies, WinFontFamilyEnumProc --
   *
   *      Return information about the font families that are available
   *      on the display of the given window.
   *
   * Results:
   *      Modifies interp's result object to hold a list of all the available
   *      font families.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  void
  TkpGetFontFamilies(
      Tcl_Interp *interp,         /* Interp to hold result. */
      Tk_Window tkwin)            /* For display to query. */
  {
      HDC hdc;
      HWND hwnd;
      Window window;
      window  = Tk_WindowId(tkwin);
      hwnd    = (window == None) ? NULL : TkWinGetHWND(window);
      hdc     = GetDC(hwnd);
      /*
       * On any version NT, there may fonts with international names.
       * Use the NT-only Unicode version of EnumFontFamilies to get the
       * font names.  If we used the ANSI version on a non-internationalized
       * version of NT, we would get font names with '?' replacing all
       * the international characters.
       *
       * On a non-internationalized verson of 95, fonts with international
       * names are not allowed, so the ANSI version of EnumFontFamilies will
       * work.  On an internationalized version of 95, there may be fonts with
       * international names; the ANSI version will work, fetching the
       * name in the system code page.  Can't use the Unicode version of
       * EnumFontFamilies because it only exists under NT.
       */
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          EnumFontFamiliesW(hdc, NULL, (FONTENUMPROCW) WinFontFamilyEnumProc,
                  (LPARAM) interp);
      } else {
          EnumFontFamiliesA(hdc, NULL, (FONTENUMPROCA) WinFontFamilyEnumProc,
                  (LPARAM) interp);
      }
      ReleaseDC(hwnd, hdc);
  }
  static int CALLBACK
  WinFontFamilyEnumProc(
      ENUMLOGFONT *lfPtr,         /* Logical-font data. */
      NEWTEXTMETRIC *tmPtr,       /* Physical-font data (not used). */
      int fontType,               /* Type of font (not used). */
      LPARAM lParam)              /* Result object to hold result. */
  {
      char *faceName;
      Tcl_DString faceString;
      Tcl_Obj *strPtr;
      Tcl_Interp *interp;
      interp = (Tcl_Interp *) lParam;
      faceName = lfPtr->elfLogFont.lfFaceName;
      Tcl_ExternalToUtfDString(systemEncoding, faceName, -1, &faceString);
      strPtr = Tcl_NewStringObj(Tcl_DStringValue(&faceString),
              Tcl_DStringLength(&faceString));
      Tcl_ListObjAppendElement(NULL, Tcl_GetObjResult(interp), strPtr);
      Tcl_DStringFree(&faceString);
      return 1;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * TkpGetSubFonts --
   *
   *      A function used by the testing package for querying the actual
   *      screen fonts that make up a font object.
   *
   * Results:
   *      Modifies interp's result object to hold a list containing the
   *      names of the screen fonts that make up the given font object.
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  void
  TkpGetSubFonts(
      Tcl_Interp *interp,         /* Interp to hold result. */
      Tk_Font tkfont)             /* Font object to query. */
  {
      int i;
      WinFont *fontPtr;
      FontFamily *familyPtr;
      Tcl_Obj *resultPtr, *strPtr;
      resultPtr = Tcl_GetObjResult(interp);
      fontPtr = (WinFont *) tkfont;
      for (i = 0; i < fontPtr->numSubFonts; i++) {
          familyPtr = fontPtr->subFontArray[i].familyPtr;
          strPtr = Tcl_NewStringObj(familyPtr->faceName, -1);
          Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
      }
  }
  /*
   *---------------------------------------------------------------------------
   *
   *  Tk_MeasureChars --
   *
   *      Determine the number of bytes from the string that will fit
   *      in the given horizontal span.  The measurement is done under the
   *      assumption that Tk_DrawChars() will be used to actually display
   *      the characters.
   *
   * Results:
   *      The return value is the number of bytes from source that
   *      fit into the span that extends from 0 to maxLength.  *lengthPtr is
   *      filled with the x-coordinate of the right edge of the last
   *      character that did fit.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  int
  Tk_MeasureChars(
      Tk_Font tkfont,             /* Font in which characters will be drawn. */
      CONST char *source,         /* UTF-8 string to be displayed.  Need not be
                                   * '\0' terminated. */
      int numBytes,               /* Maximum number of bytes to consider
                                   * from source string. */
      int maxLength,              /* If >= 0, maxLength specifies the longest
                                   * permissible line length in pixels; don't
                                   * consider any character that would cross
                                   * this x-position.  If < 0, then line length
                                   * is unbounded and the flags argument is
                                   * ignored. */
      int flags,                  /* Various flag bits OR-ed together:
                                   * TK_PARTIAL_OK means include the last char
                                   * which only partially fit on this line.
                                   * TK_WHOLE_WORDS means stop on a word
                                   * boundary, if possible.
                                   * TK_AT_LEAST_ONE means return at least one
                                   * character even if no characters fit. */
      int *lengthPtr)             /* Filled with x-location just after the
                                   * terminating character. */
  {
      HDC hdc;
      HFONT oldFont;
      WinFont *fontPtr;
      int curX, curByte;
      SubFont *lastSubFontPtr;
      /*
       * According to Microsoft tech support, Windows does not use kerning
       * or fractional character widths when displaying text on the screen.
       * So that means we can safely measure individual characters or spans
       * of characters and add up the widths w/o any "off-by-one-pixel"
       * errors.
       */
      fontPtr = (WinFont *) tkfont;
      hdc = GetDC(fontPtr->hwnd);
      lastSubFontPtr = &fontPtr->subFontArray[0];
      oldFont = SelectObject(hdc, lastSubFontPtr->hFont);
      if (numBytes == 0) {
          curX = 0;
          curByte = 0;
      } else if (maxLength < 0) {
          Tcl_UniChar ch;
          SIZE size;
          FontFamily *familyPtr;
          Tcl_DString runString;
          SubFont *thisSubFontPtr;
          CONST char *p, *end, *next;
          /*
           * A three step process:
           * 1. Find a contiguous range of characters that can all be
           *    represented by a single screen font.
           * 2. Convert those chars to the encoding of that font.
           * 3. Measure converted chars.
           */
          curX = 0;
          end = source + numBytes;
          for (p = source; p < end; ) {
              next = p + Tcl_UtfToUniChar(p, &ch);
              thisSubFontPtr = FindSubFontForChar(fontPtr, ch);
              if (thisSubFontPtr != lastSubFontPtr) {
                  familyPtr = lastSubFontPtr->familyPtr;
                  Tcl_UtfToExternalDString(familyPtr->encoding, source,
                          p - source, &runString);
                  (*familyPtr->getTextExtentPoint32Proc)(hdc,
                          Tcl_DStringValue(&runString),
                          Tcl_DStringLength(&runString) >> familyPtr->isWideFont,
                          &size);
                  curX += size.cx;
                  Tcl_DStringFree(&runString);
                  lastSubFontPtr = thisSubFontPtr;
                  source = p;
                  SelectObject(hdc, lastSubFontPtr->hFont);
              }
              p = next;
          }
          familyPtr = lastSubFontPtr->familyPtr;
          Tcl_UtfToExternalDString(familyPtr->encoding, source, p - source,
                  &runString);
          (*familyPtr->getTextExtentPoint32Proc)(hdc,
                  Tcl_DStringValue(&runString),
                  Tcl_DStringLength(&runString) >> familyPtr->isWideFont,
                  &size);
          curX += size.cx;
          Tcl_DStringFree(&runString);
          curByte = numBytes;
      } else {
          Tcl_UniChar ch;
          SIZE size;
          char buf[16];
          FontFamily *familyPtr;
          SubFont *thisSubFontPtr;
          CONST char *term, *end, *p, *next;
          int newX, termX, sawNonSpace, dstWrote;
          /*
           * How many chars will fit in the space allotted?
           * This first version may be inefficient because it measures
           * every character individually.  There is a function call that
           * can measure multiple characters at once and return the
           * offset of each of them, but it only works on NT, even though
           * the documentation claims it works for 95.
           * TODO: verify that GetTextExtentExPoint is still broken in '95, and
           * possibly use it for NT anyway since it should be much faster and
           * more accurate.
           */
          next = source + Tcl_UtfToUniChar(source, &ch);
          newX = curX = termX = 0;
          term = source;
          end = source + numBytes;
          sawNonSpace = (ch > 255) || !isspace(ch);
          for (p = source; ; ) {
              if (ch < BASE_CHARS) {
                  newX += fontPtr->widths[ch];
              } else {
                  thisSubFontPtr = FindSubFontForChar(fontPtr, ch);
                  if (thisSubFontPtr != lastSubFontPtr) {
                      SelectObject(hdc, thisSubFontPtr->hFont);
                      lastSubFontPtr = thisSubFontPtr;
                  }
                  familyPtr = lastSubFontPtr->familyPtr;
                  Tcl_UtfToExternal(NULL, familyPtr->encoding, p, next - p,
 , NULL, buf, sizeof(buf), NULL, &dstWrote, NULL);
                  (*familyPtr->getTextExtentPoint32Proc)(hdc, buf,
                          dstWrote >> familyPtr->isWideFont, &size);
                  newX += size.cx;
              }
              if (newX > maxLength) {
                  break;
              }
              curX = newX;
              p = next;
              if (p >= end) {
                  term = end;
                  termX = curX;
                  break;
              }
              next += Tcl_UtfToUniChar(next, &ch);
              if ((ch < 256) && isspace(ch)) {
                  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 & TK_PARTIAL_OK) && (p < end) && (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.
               */
              curX = newX;
              p += Tcl_UtfToUniChar(p, &ch);
          }
          if ((flags & TK_AT_LEAST_ONE) && (term == source) && (p < end)) {
              term = p;
              termX = curX;
              if (term == source) {
                  term += Tcl_UtfToUniChar(term, &ch);
                  termX = newX;
              }
          } else if ((p >= end) || !(flags & TK_WHOLE_WORDS)) {
              term = p;
              termX = curX;
          }
          curX = termX;
          curByte = term - source;
      }
      SelectObject(hdc, oldFont);
      ReleaseDC(fontPtr->hwnd, hdc);
      *lengthPtr = curX;
      return curByte;
  }
  /*
   *---------------------------------------------------------------------------
   *
   * Tk_DrawChars --
   *
   *      Draw a string of characters on the screen.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Information gets drawn on the screen.
   *
   *---------------------------------------------------------------------------
   */
  void
  Tk_DrawChars(
      Display *display,           /* Display on which to draw. */
      Drawable drawable,          /* Window or pixmap in which to draw. */
      GC gc,                      /* Graphics context for drawing characters. */
      Tk_Font tkfont,             /* Font in which characters will be drawn;
                                   * must be the same as font used in GC. */
      CONST char *source,         /* UTF-8 string to be displayed.  Need not be
                                   * '\0' terminated.  All Tk 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. */
      int numBytes,               /* Number of bytes in string. */
      int x, int y)               /* Coordinates at which to place origin of
                                   * string when drawing. */
  {
      HDC dc;
      WinFont *fontPtr;
      TkWinDCState state;
      fontPtr = (WinFont *) gc->font;
      display->request++;
      if (drawable == None) {
          return;
      }
      dc = TkWinGetDrawableDC(display, drawable, &state);
      SetROP2(dc, tkpWinRopModes[gc->function]);
      if ((gc->fill_style == FillStippled
              || gc->fill_style == FillOpaqueStippled)
              && gc->stipple != None) {
          TkWinDrawable *twdPtr = (TkWinDrawable *)gc->stipple;
          HBRUSH oldBrush, stipple;
          HBITMAP oldBitmap, bitmap;
          HDC dcMem;
          TEXTMETRIC tm;
          SIZE size;
          if (twdPtr->type != TWD_BITMAP) {
              panic("unexpected drawable type in stipple");
          }
          /*
           * Select stipple pattern into destination dc.
           */
          dcMem = CreateCompatibleDC(dc);
          stipple = CreatePatternBrush(twdPtr->bitmap.handle);
          SetBrushOrgEx(dc, gc->ts_x_origin, gc->ts_y_origin, NULL);
          oldBrush = SelectObject(dc, stipple);
          SetTextAlign(dcMem, TA_LEFT | TA_BASELINE);
          SetTextColor(dcMem, gc->foreground);
          SetBkMode(dcMem, TRANSPARENT);
          SetBkColor(dcMem, RGB(0, 0, 0));
          /*
           * Compute the bounding box and create a compatible bitmap.
           */
          GetTextExtentPoint(dcMem, source, numBytes, &size);
          GetTextMetrics(dcMem, &tm);
          size.cx -= tm.tmOverhang;
          bitmap = CreateCompatibleBitmap(dc, size.cx, size.cy);
          oldBitmap = SelectObject(dcMem, bitmap);
          /*
           * The following code is tricky because fonts are rendered in multiple
           * colors.  First we draw onto a black background and copy the white
           * bits.  Then we draw onto a white background and copy the black bits.
           * Both the foreground and background bits of the font are ANDed with
           * the stipple pattern as they are copied.
           */
          PatBlt(dcMem, 0, 0, size.cx, size.cy, BLACKNESS);
          MultiFontTextOut(dc, fontPtr, source, numBytes, x, y);
          BitBlt(dc, x, y - tm.tmAscent, size.cx, size.cy, dcMem,
 , 0, 0xEA02E9);
          PatBlt(dcMem, 0, 0, size.cx, size.cy, WHITENESS);
          MultiFontTextOut(dc, fontPtr, source, numBytes, x, y);
          BitBlt(dc, x, y - tm.tmAscent, size.cx, size.cy, dcMem,
 , 0, 0x8A0E06);
          /*
           * Destroy the temporary bitmap and restore the device context.
           */
          SelectObject(dcMem, oldBitmap);
          DeleteObject(bitmap);
          DeleteDC(dcMem);
          SelectObject(dc, oldBrush);
          DeleteObject(stipple);
      } else {
          SetTextAlign(dc, TA_LEFT | TA_BASELINE);
          SetTextColor(dc, gc->foreground);
          SetBkMode(dc, TRANSPARENT);
          MultiFontTextOut(dc, fontPtr, source, numBytes, x, y);
      }
      TkWinReleaseDrawableDC(drawable, dc, &state);
  }
  /*
   *-------------------------------------------------------------------------
   *
   * MultiFontTextOut --
   *
   *      Helper function for Tk_DrawChars.  Draws characters, using the
   *      various screen fonts in fontPtr to draw multilingual characters.
   *      Note: No bidirectional support.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Information gets drawn on the screen.
   *      Contents of fontPtr may be modified if more subfonts were loaded
   *      in order to draw all the multilingual characters in the given
   *      string.
   *
   *-------------------------------------------------------------------------
   */
  static void
  MultiFontTextOut(
      HDC hdc,                    /* HDC to draw into. */
      WinFont *fontPtr,           /* Contains set of fonts to use when drawing
                                   * following string. */
      CONST char *source,         /* Potentially multilingual UTF-8 string. */
      int numBytes,               /* Length of string in bytes. */
      int x, int y)               /* Coordinates at which to place origin *
                                   * of string when drawing. */
  {
      Tcl_UniChar ch;
      SIZE size;
      HFONT oldFont;
      FontFamily *familyPtr;
      Tcl_DString runString;
      CONST char *p, *end, *next;
      SubFont *lastSubFontPtr, *thisSubFontPtr;
      lastSubFontPtr = &fontPtr->subFontArray[0];
      oldFont = SelectObject(hdc, lastSubFontPtr->hFont);
      end = source + numBytes;
      for (p = source; p < end; ) {
          next = p + Tcl_UtfToUniChar(p, &ch);
          thisSubFontPtr = FindSubFontForChar(fontPtr, ch);
          if (thisSubFontPtr != lastSubFontPtr) {
              if (p > source) {
                  familyPtr = lastSubFontPtr->familyPtr;
                  Tcl_UtfToExternalDString(familyPtr->encoding, source,
                          p - source, &runString);
                  (*familyPtr->textOutProc)(hdc, x, y,
                          Tcl_DStringValue(&runString),
                          Tcl_DStringLength(&runString) >> familyPtr->isWideFont);
                  (*familyPtr->getTextExtentPoint32Proc)(hdc,
                          Tcl_DStringValue(&runString),
                          Tcl_DStringLength(&runString) >> familyPtr->isWideFont,
                          &size);
                  x += size.cx;
                  Tcl_DStringFree(&runString);
              }
              lastSubFontPtr = thisSubFontPtr;
              source = p;
              SelectObject(hdc, lastSubFontPtr->hFont);
          }
          p = next;
      }
      if (p > source) {
          familyPtr = lastSubFontPtr->familyPtr;
          Tcl_UtfToExternalDString(familyPtr->encoding, source, p - source,
                  &runString);
          (*familyPtr->textOutProc)(hdc, x, y, Tcl_DStringValue(&runString),
                  Tcl_DStringLength(&runString) >> familyPtr->isWideFont);
          Tcl_DStringFree(&runString);
      }
      SelectObject(hdc, oldFont);
  }
  /*
   *---------------------------------------------------------------------------
   *
   * InitFont --
   *
   *      Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
   *      Initializes the memory for a new WinFont that wraps the
   *      platform-specific data.
   *
   *      The caller is responsible for initializing the fields of the
   *      WinFont that are used exclusively by the generic TkFont code, and
   *      for releasing those fields before calling TkpDeleteFont().
   *
   * Results:
   *      Fills the WinFont structure.
   *
   * Side effects:
   *      Memory allocated.
   *
   *---------------------------------------------------------------------------
   */
  static void
  InitFont(
      Tk_Window tkwin,            /* Main window of interp in which font will
                                   * be used, for getting HDC. */
      HFONT hFont,                /* Windows token for font. */
      int overstrike,             /* The overstrike attribute of logfont used
                                   * to allocate this font.  For some reason,
                                   * the TEXTMETRICs may contain incorrect info
                                   * in the tmStruckOut field. */
      WinFont *fontPtr)           /* Filled with information constructed from
                                   * the above arguments. */
  {
      HDC hdc;
      HWND hwnd;
      HFONT oldFont;
      TEXTMETRIC tm;
      Window window;
      TkFontMetrics *fmPtr;
      Tcl_Encoding encoding;
      Tcl_DString faceString;
      TkFontAttributes *faPtr;
      char buf[LF_FACESIZE * sizeof(WCHAR)];
      window  = Tk_WindowId(tkwin);
      hwnd    = (window == None) ? NULL : TkWinGetHWND(window);
      hdc     = GetDC(hwnd);
      oldFont = SelectObject(hdc, hFont);
      GetTextMetrics(hdc, &tm);
      /*
       * On any version NT, there may fonts with international names.
       * Use the NT-only Unicode version of GetTextFace to get the font's
       * name.  If we used the ANSI version on a non-internationalized
       * version of NT, we would get a font name with '?' replacing all
       * the international characters.
       *
       * On a non-internationalized verson of 95, fonts with international
       * names are not allowed, so the ANSI version of GetTextFace will work.
       * On an internationalized version of 95, there may be fonts with
       * international names; the ANSI version will work, fetching the
       * name in the international system code page.  Can't use the Unicode
       * version of GetTextFace because it only exists under NT.
       */
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          GetTextFaceW(hdc, LF_FACESIZE, (WCHAR *) buf);
      } else {
          GetTextFaceA(hdc, LF_FACESIZE, (char *) buf);
      }
      Tcl_ExternalToUtfDString(systemEncoding, buf, -1, &faceString);
      fontPtr->font.fid   = (Font) fontPtr;
      faPtr               = &fontPtr->font.fa;
      faPtr->family       = Tk_GetUid(Tcl_DStringValue(&faceString));
      faPtr->size         = TkFontGetPoints(tkwin, -(tm.tmHeight - tm.tmInternalLeading));
      faPtr->weight       = (tm.tmWeight > FW_MEDIUM) ? TK_FW_BOLD : TK_FW_NORMAL;
      faPtr->slant        = (tm.tmItalic != 0) ? TK_FS_ITALIC : TK_FS_ROMAN;
      faPtr->underline    = (tm.tmUnderlined != 0) ? 1 : 0;
      faPtr->overstrike   = overstrike;
      fmPtr               = &fontPtr->font.fm;
      fmPtr->ascent       = tm.tmAscent;
      fmPtr->descent      = tm.tmDescent;
      fmPtr->maxWidth     = tm.tmMaxCharWidth;
      fmPtr->fixed        = !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH);
      fontPtr->hwnd       = hwnd;
      fontPtr->pixelSize  = tm.tmHeight - tm.tmInternalLeading;
      fontPtr->numSubFonts        = 1;
      fontPtr->subFontArray       = fontPtr->staticSubFonts;
      InitSubFont(hdc, hFont, 1, &fontPtr->subFontArray[0]);
      encoding = fontPtr->subFontArray[0].familyPtr->encoding;
      if (encoding == unicodeEncoding) {
          GetCharWidthW(hdc, 0, BASE_CHARS - 1, fontPtr->widths);
      } else {
          GetCharWidthA(hdc, 0, BASE_CHARS - 1, fontPtr->widths);
      }
      Tcl_DStringFree(&faceString);
      SelectObject(hdc, oldFont);
      ReleaseDC(hwnd, hdc);
  }
  /*
   *-------------------------------------------------------------------------
   *
   * ReleaseFont --
   *
   *      Called to release the windows-specific contents of a TkFont.
   *      The caller is responsible for freeing the memory used by the
   *      font itself.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Memory is freed.
   *
   *---------------------------------------------------------------------------
   */
  static void
  ReleaseFont(
      WinFont *fontPtr)           /* The font to delete. */
  {
      int i;
      for (i = 0; i < fontPtr->numSubFonts; i++) {
          ReleaseSubFont(&fontPtr->subFontArray[i]);
      }
      if (fontPtr->subFontArray != fontPtr->staticSubFonts) {
          ckfree((char *) fontPtr->subFontArray);
      }
  }
  /*
   *-------------------------------------------------------------------------
   *
   * InitSubFont --
   *
   *      Wrap a screen font and load the FontFamily that represents
   *      it.  Used to prepare a SubFont so that characters can be mapped
   *      from UTF-8 to the charset of the font.
   *
   * Results:
   *      The subFontPtr is filled with information about the font.
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  static void
  InitSubFont(
      HDC hdc,                    /* HDC in which font can be selected. */
      HFONT hFont,                /* The screen font. */
      int base,                   /* Non-zero if this SubFont is being used
                                   * as the base font for a font object. */
      SubFont *subFontPtr)        /* Filled with SubFont constructed from
                                   * above attributes. */
  {
      subFontPtr->hFont       = hFont;
      subFontPtr->familyPtr   = AllocFontFamily(hdc, hFont, base);
      subFontPtr->fontMap     = subFontPtr->familyPtr->fontMap;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * ReleaseSubFont --
   *
   *      Called to release the contents of a SubFont.  The caller is
   *      responsible for freeing the memory used by the SubFont itself.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Memory and resources are freed.
   *
   *---------------------------------------------------------------------------
   */
  static void
  ReleaseSubFont(
      SubFont *subFontPtr)        /* The SubFont to delete. */
  {
      DeleteObject(subFontPtr->hFont);
      FreeFontFamily(subFontPtr->familyPtr);
  }
  /*
   *-------------------------------------------------------------------------
   *
   * AllocFontFamily --
   *
   *      Find the FontFamily structure associated with the given font
   *      name.  The information should be stored by the caller in a
   *      SubFont and used when determining if that SubFont supports a
   *      character.
   *
   *      Cannot use the string name used to construct the font as the
   *      key, because the capitalization may not be canonical.  Therefore
   *      use the face name actually retrieved from the font metrics as
   *      the key.
   *
   * Results:
   *      A pointer to a FontFamily.  The reference count in the FontFamily
   *      is automatically incremented.  When the SubFont is released, the
   *      reference count is decremented.  When no SubFont is using this
   *      FontFamily, it may be deleted.
   *
   * Side effects:
   *      A new FontFamily structure will be allocated if this font family
   *      has not been seen.  TrueType character existence metrics are
   *      loaded into the FontFamily structure.
   *
   *-------------------------------------------------------------------------
   */
  static FontFamily *
  AllocFontFamily(
      HDC hdc,                    /* HDC in which font can be selected. */
      HFONT hFont,                /* Screen font whose FontFamily is to be
                                   * returned. */
      int base)                   /* Non-zero if this font family is to be
                                   * used in the base font of a font object. */
  {
      Tk_Uid faceName;
      FontFamily *familyPtr;
      Tcl_DString faceString;
      Tcl_Encoding encoding;
      char buf[LF_FACESIZE * sizeof(WCHAR)];
      ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
              Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
      hFont = SelectObject(hdc, hFont);
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          GetTextFaceW(hdc, LF_FACESIZE, (WCHAR *) buf);
      } else {
          GetTextFaceA(hdc, LF_FACESIZE, (char *) buf);
      }
      Tcl_ExternalToUtfDString(systemEncoding, buf, -1, &faceString);
      faceName = Tk_GetUid(Tcl_DStringValue(&faceString));
      Tcl_DStringFree(&faceString);
      hFont = SelectObject(hdc, hFont);
      familyPtr = tsdPtr->fontFamilyList;
      for ( ; familyPtr != NULL; familyPtr = familyPtr->nextPtr) {
          if (familyPtr->faceName == faceName) {
              familyPtr->refCount++;
              return familyPtr;
          }
      }
      familyPtr = (FontFamily *) ckalloc(sizeof(FontFamily));
      memset(familyPtr, 0, sizeof(FontFamily));
      familyPtr->nextPtr = tsdPtr->fontFamilyList;
      tsdPtr->fontFamilyList = familyPtr;
      /*
       * Set key for this FontFamily.
       */
      familyPtr->faceName = faceName;
      /*
       * An initial refCount of 2 means that FontFamily information will
       * persist even when the SubFont that loaded the FontFamily is released.
       * Change it to 1 to cause FontFamilies to be unloaded when not in use.
       */
      familyPtr->refCount = 2;
      familyPtr->segCount = LoadFontRanges(hdc, hFont, &familyPtr->startCount,
              &familyPtr->endCount, &familyPtr->isSymbolFont);
      encoding = NULL;
      if (familyPtr->isSymbolFont != 0) {
          /*
           * Symbol fonts are handled specially.  For instance, Unicode 0393
           * (GREEK CAPITAL GAMMA) must be mapped to Symbol character 0047
           * (GREEK CAPITAL GAMMA), because the Symbol font doesn't have a
           * GREEK CAPITAL GAMMA at location 0393.  If Tk interpreted the
           * Symbol font using the Unicode encoding, it would decide that
           * the Symbol font has no GREEK CAPITAL GAMMA, because the Symbol
           * encoding (of course) reports that character 0393 doesn't exist.
           *
           * With non-symbol Windows fonts, such as Times New Roman, if the
           * font has a GREEK CAPITAL GAMMA, it will be found in the correct
           * Unicode location (0393); the GREEK CAPITAL GAMMA will not be off
           * hiding at some other location.
           */
          encoding = Tcl_GetEncoding(NULL, faceName);
      }
      if (encoding == NULL) {
          encoding = Tcl_GetEncoding(NULL, "unicode");
          familyPtr->textOutProc =
              (BOOL (WINAPI *)(HDC, int, int, TCHAR *, int)) TextOutW;
          familyPtr->getTextExtentPoint32Proc =
              (BOOL (WINAPI *)(HDC, TCHAR *, int, LPSIZE)) GetTextExtentPoint32W;
          familyPtr->isWideFont = 1;
      } else {
          familyPtr->textOutProc =
              (BOOL (WINAPI *)(HDC, int, int, TCHAR *, int)) TextOutA;
          familyPtr->getTextExtentPoint32Proc =
              (BOOL (WINAPI *)(HDC, TCHAR *, int, LPSIZE)) GetTextExtentPoint32A;
          familyPtr->isWideFont = 0;
      }
      familyPtr->encoding = encoding;
      return familyPtr;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FreeFontFamily --
   *
   *      Called to free a FontFamily when the SubFont is finished using it.
   *      Frees the contents of the FontFamily and the memory used by the
   *      FontFamily itself.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  static void
  FreeFontFamily(
      FontFamily *familyPtr)      /* The FontFamily to delete. */
  {
      int i;
      FontFamily **familyPtrPtr;
      ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
              Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
      if (familyPtr == NULL) {
          return;
      }
      familyPtr->refCount--;
      if (familyPtr->refCount > 0) {
          return;
      }
      for (i = 0; i < FONTMAP_PAGES; i++) {
          if (familyPtr->fontMap[i] != NULL) {
              ckfree(familyPtr->fontMap[i]);
          }
      }
      if (familyPtr->startCount != NULL) {
          ckfree((char *) familyPtr->startCount);
      }
      if (familyPtr->endCount != NULL) {
          ckfree((char *) familyPtr->endCount);
      }
      if (familyPtr->encoding != unicodeEncoding) {
          Tcl_FreeEncoding(familyPtr->encoding);
      }
      /*
       * Delete from list.
       */
      for (familyPtrPtr = &tsdPtr->fontFamilyList; ; ) {
          if (*familyPtrPtr == familyPtr) {
              *familyPtrPtr = familyPtr->nextPtr;
              break;
          }
          familyPtrPtr = &(*familyPtrPtr)->nextPtr;
      }
      ckfree((char *) familyPtr);
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FindSubFontForChar --
   *
   *      Determine which screen font is necessary to use to display the
   *      given character.  If the font object does not have a screen font
   *      that can display the character, another screen font may be loaded
   *      into the font object, following a set of preferred fallback rules.
   *
   * Results:
   *      The return value is the SubFont to use to display the given
   *      character.
   *
   * Side effects:
   *      The contents of fontPtr are modified to cache the results
   *      of the lookup and remember any SubFonts that were dynamically
   *      loaded.
   *
   *-------------------------------------------------------------------------
   */
  static SubFont *
  FindSubFontForChar(
      WinFont *fontPtr,           /* The font object with which the character
                                   * will be displayed. */
      int ch)                     /* The Unicode character to be displayed. */
  {
      HDC hdc;
      int i, j, k;
      CanUse canUse;
      char **aliases, **anyFallbacks;
      char ***fontFallbacks;
      char *fallbackName;
      SubFont *subFontPtr;
      Tcl_DString ds;
      if (ch < BASE_CHARS) {
          return &fontPtr->subFontArray[0];
      }
      for (i = 0; i < fontPtr->numSubFonts; i++) {
          if (FontMapLookup(&fontPtr->subFontArray[i], ch)) {
              return &fontPtr->subFontArray[i];
          }
      }
      /*
       * Keep track of all face names that we check, so we don't check some
       * name multiple times if it can be reached by multiple paths.
       */
      Tcl_DStringInit(&ds);
      hdc = GetDC(fontPtr->hwnd);
      aliases = TkFontGetAliasList(fontPtr->font.fa.family);
      fontFallbacks = TkFontGetFallbacks();
      for (i = 0; fontFallbacks[i] != NULL; i++) {
          for (j = 0; fontFallbacks[i][j] != NULL; j++) {
              fallbackName = fontFallbacks[i][j];
              if (strcasecmp(fallbackName, fontPtr->font.fa.family) == 0) {
                  /*
                   * If the base font has a fallback...
                   */
                  goto tryfallbacks;
              } else if (aliases != NULL) {
                  /*
                   * Or if an alias for the base font has a fallback...
                   */
                  for (k = 0; aliases[k] != NULL; k++) {
                      if (strcasecmp(aliases[k], fallbackName) == 0) {
                          goto tryfallbacks;
                      }
                  }
              }
          }
          continue;
          /*
           * ...then see if we can use one of the fallbacks, or an
           * alias for one of the fallbacks.
           */
          tryfallbacks:
          for (j = 0; fontFallbacks[i][j] != NULL; j++) {
              fallbackName = fontFallbacks[i][j];
              subFontPtr = CanUseFallbackWithAliases(hdc, fontPtr, fallbackName,
                      ch, &ds);
              if (subFontPtr != NULL) {
                  goto end;
              }
          }
      }
      /*
       * See if we can use something from the global fallback list.
       */
      anyFallbacks = TkFontGetGlobalClass();
      for (i = 0; anyFallbacks[i] != NULL; i++) {
          fallbackName = anyFallbacks[i];
          subFontPtr = CanUseFallbackWithAliases(hdc, fontPtr, fallbackName,
                  ch, &ds);
          if (subFontPtr != NULL) {
              goto end;
          }
      }
      /*
       * Try all face names available in the whole system until we
       * find one that can be used.
       */
      canUse.hdc = hdc;
      canUse.fontPtr = fontPtr;
      canUse.nameTriedPtr = &ds;
      canUse.ch = ch;
      canUse.subFontPtr = NULL;
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          EnumFontFamiliesW(hdc, NULL, (FONTENUMPROCW) WinFontCanUseProc,
                  (LPARAM) &canUse);
      } else {
          EnumFontFamiliesA(hdc, NULL, (FONTENUMPROCA) WinFontCanUseProc,
                  (LPARAM) &canUse);
      }
      subFontPtr = canUse.subFontPtr;
      end:
      Tcl_DStringFree(&ds);
      if (subFontPtr == NULL) {
          /*
           * No font can display this character.  We will use the base font
           * and have it display the "unknown" character.
           */
          subFontPtr = &fontPtr->subFontArray[0];
          FontMapInsert(subFontPtr, ch);
      }
      ReleaseDC(fontPtr->hwnd, hdc);
      return subFontPtr;
  }
  static int CALLBACK
  WinFontCanUseProc(
      ENUMLOGFONT *lfPtr,         /* Logical-font data. */
      NEWTEXTMETRIC *tmPtr,       /* Physical-font data (not used). */
      int fontType,               /* Type of font (not used). */
      LPARAM lParam)              /* Result object to hold result. */
  {
      int ch;
      HDC hdc;
      WinFont *fontPtr;
      CanUse *canUsePtr;
      char *fallbackName;
      SubFont *subFontPtr;
      Tcl_DString faceString;
      Tcl_DString *nameTriedPtr;
      canUsePtr       = (CanUse *) lParam;
      ch              = canUsePtr->ch;
      hdc             = canUsePtr->hdc;
      fontPtr         = canUsePtr->fontPtr;
      nameTriedPtr    = canUsePtr->nameTriedPtr;
      fallbackName = lfPtr->elfLogFont.lfFaceName;
      Tcl_ExternalToUtfDString(systemEncoding, fallbackName, -1, &faceString);
      fallbackName = Tcl_DStringValue(&faceString);
      if (SeenName(fallbackName, nameTriedPtr) == 0) {
          subFontPtr = CanUseFallback(hdc, fontPtr, fallbackName, ch);
          if (subFontPtr != NULL) {
              canUsePtr->subFontPtr = subFontPtr;
              Tcl_DStringFree(&faceString);
              return 0;
          }
      }
      Tcl_DStringFree(&faceString);
      return 1;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FontMapLookup --
   *
   *      See if the screen font can display the given character.
   *
   * Results:
   *      The return value is 0 if the screen font cannot display the
   *      character, non-zero otherwise.
   *
   * Side effects:
   *      New pages are added to the font mapping cache whenever the
   *      character belongs to a page that hasn't been seen before.
   *      When a page is loaded, information about all the characters on
   *      that page is stored, not just for the single character in
   *      question.
   *
   *-------------------------------------------------------------------------
   */
  static int
  FontMapLookup(
      SubFont *subFontPtr,        /* Contains font mapping cache to be queried
                                   * and possibly updated. */
      int ch)                     /* Character to be tested. */
  {
      int row, bitOffset;
      row = ch >> FONTMAP_SHIFT;
      if (subFontPtr->fontMap[row] == NULL) {
          FontMapLoadPage(subFontPtr, row);
      }
      bitOffset = ch & (FONTMAP_BITSPERPAGE - 1);
      return (subFontPtr->fontMap[row][bitOffset >> 3] >> (bitOffset & 7)) & 1;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FontMapInsert --
   *
   *      Tell the font mapping cache that the given screen font should be
   *      used to display the specified character.  This is called when no
   *      font on the system can be be found that can display that
   *      character; we lie to the font and tell it that it can display
   *      the character, otherwise we would end up re-searching the entire
   *      fallback hierarchy every time that character was seen.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      New pages are added to the font mapping cache whenever the
   *      character belongs to a page that hasn't been seen before.
   *      When a page is loaded, information about all the characters on
   *      that page is stored, not just for the single character in
   *      question.
   *
   *-------------------------------------------------------------------------
   */
  static void
  FontMapInsert(
      SubFont *subFontPtr,        /* Contains font mapping cache to be
                                   * updated. */
      int ch)                     /* Character to be added to cache. */
  {
      int row, bitOffset;
      row = ch >> FONTMAP_SHIFT;
      if (subFontPtr->fontMap[row] == NULL) {
          FontMapLoadPage(subFontPtr, row);
      }
      bitOffset = ch & (FONTMAP_BITSPERPAGE - 1);
      subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FontMapLoadPage --
   *
   *      Load information about all the characters on a given page.
   *      This information consists of one bit per character that indicates
   *      whether the associated HFONT can (1) or cannot (0) display the
   *      characters on the page.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Mempry allocated.
   *
   *-------------------------------------------------------------------------
   */
  static void
  FontMapLoadPage(
      SubFont *subFontPtr,        /* Contains font mapping cache to be
                                   * updated. */
      int row)                    /* Index of the page to be loaded into
                                   * the cache. */
  {
      FontFamily *familyPtr;
      Tcl_Encoding encoding;
      char src[TCL_UTF_MAX], buf[16];
      USHORT *startCount, *endCount;
      int i, j, bitOffset, end, segCount;
      subFontPtr->fontMap[row] = (char *) ckalloc(FONTMAP_BITSPERPAGE / 8);
      memset(subFontPtr->fontMap[row], 0, FONTMAP_BITSPERPAGE / 8);
      familyPtr = subFontPtr->familyPtr;
      encoding = familyPtr->encoding;
      if (familyPtr->encoding == unicodeEncoding) {
          /*
           * Font is Unicode.  Few fonts are going to have all characters, so
           * examine the TrueType character existence metrics to determine
           * what characters actually exist in this font.
           */
          segCount    = familyPtr->segCount;
          startCount  = familyPtr->startCount;
          endCount    = familyPtr->endCount;
          j = 0;
          end = (row + 1) << FONTMAP_SHIFT;
          for (i = row << FONTMAP_SHIFT; i < end; i++) {
              for ( ; j < segCount; j++) {
                  if (endCount[j] >= i) {
                      if (startCount[j] <= i) {
                          bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
                          subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
                      }
                      break;
                  }
              }
          }
      } else if (familyPtr->isSymbolFont) {
          /*
           * Assume that a symbol font with a known encoding has all the
           * characters that its encoding claims it supports.
           *
           * The test for "encoding == unicodeEncoding"
           * must occur before this case, to catch all symbol fonts (such
           * as {Comic Sans MS} or Wingdings) for which we don't have
           * encoding information; those symbol fonts are treated as if
           * they were in the Unicode encoding and their symbolic
           * character existence metrics are treated as if they were Unicode
           * character existence metrics.  This way, although we don't know
           * the proper Unicode -> symbol font mapping, we can install the
           * symbol font as the base font and access its glyphs.
           */
          end = (row + 1) << FONTMAP_SHIFT;
          for (i = row << FONTMAP_SHIFT; i < end; i++) {
              if (Tcl_UtfToExternal(NULL, encoding, src,
                      Tcl_UniCharToUtf(i, src), TCL_ENCODING_STOPONERROR, NULL,
                      buf, sizeof(buf), NULL, NULL, NULL) != TCL_OK) {
                  continue;
              }
              bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
              subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
          }
      }
  }
  /*
   *---------------------------------------------------------------------------
   *
   * CanUseFallbackWithAliases --
   *
   *      Helper function for FindSubFontForChar.  Determine if the
   *      specified face name (or an alias of the specified face name)
   *      can be used to construct a screen font that can display the
   *      given character.
   *
   * Results:
   *      See CanUseFallback().
   *
   * Side effects:
   *      If the name and/or one of its aliases was rejected, the
   *      rejected string is recorded in nameTriedPtr so that it won't
   *      be tried again.
   *
   *---------------------------------------------------------------------------
   */
  static SubFont *
  CanUseFallbackWithAliases(
      HDC hdc,                    /* HDC in which font can be selected. */
      WinFont *fontPtr,           /* The font object that will own the new
                                   * screen font. */
      char *faceName,             /* Desired face name for new screen font. */
      int ch,                     /* The Unicode character that the new
                                   * screen font must be able to display. */
      Tcl_DString *nameTriedPtr)  /* Records face names that have already
                                   * been tried.  It is possible for the same
                                   * face name to be queried multiple times when
                                   * trying to find a suitable screen font. */
  {
      int i;
      char **aliases;
      SubFont *subFontPtr;
      if (SeenName(faceName, nameTriedPtr) == 0) {
          subFontPtr = CanUseFallback(hdc, fontPtr, faceName, ch);
          if (subFontPtr != NULL) {
              return subFontPtr;
          }
      }
      aliases = TkFontGetAliasList(faceName);
      if (aliases != NULL) {
          for (i = 0; aliases[i] != NULL; i++) {
              if (SeenName(aliases[i], nameTriedPtr) == 0) {
                  subFontPtr = CanUseFallback(hdc, fontPtr, aliases[i], ch);
                  if (subFontPtr != NULL) {
                      return subFontPtr;
                  }
              }
          }
      }
      return NULL;
  }
  /*
   *---------------------------------------------------------------------------
   *
   * SeenName --
   *
   *      Used to determine we have already tried and rejected the given
   *      face name when looking for a screen font that can support some
   *      Unicode character.
   *
   * Results:
   *      The return value is 0 if this face name has not already been seen,
   *      non-zero otherwise.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  static int
  SeenName(
      CONST char *name,           /* The name to check. */
      Tcl_DString *dsPtr)         /* Contains names that have already been
                                   * seen. */
  {
      CONST char *seen, *end;
      seen = Tcl_DStringValue(dsPtr);
      end = seen + Tcl_DStringLength(dsPtr);
      while (seen < end) {
          if (strcasecmp(seen, name) == 0) {
              return 1;
          }
          seen += strlen(seen) + 1;
      }
      Tcl_DStringAppend(dsPtr, (char *) name, (int) (strlen(name) + 1));
      return 0;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * CanUseFallback --
   *
   *      If the specified screen font has not already been loaded into
   *      the font object, determine if it can display the given character.
   *
   * Results:
   *      The return value is a pointer to a newly allocated SubFont, owned
   *      by the font object.  This SubFont can be used to display the given
   *      character.  The SubFont represents the screen font with the base set
   *      of font attributes from the font object, but using the specified
   *      font name.  NULL is returned if the font object already holds
   *      a reference to the specified physical font or if the specified
   *      physical font cannot display the given character.
   *
   * Side effects:
   *      The font object's subFontArray is updated to contain a reference
   *      to the newly allocated SubFont.
   *
   *-------------------------------------------------------------------------
   */
  static SubFont *
  CanUseFallback(
      HDC hdc,                    /* HDC in which font can be selected. */
      WinFont *fontPtr,           /* The font object that will own the new
                                   * screen font. */
      char *faceName,             /* Desired face name for new screen font. */
      int ch)                     /* The Unicode character that the new
                                   * screen font must be able to display. */
  {
      int i;
      HFONT hFont;
      SubFont subFont;
      if (FamilyExists(hdc, faceName) == 0) {
          return NULL;
      }
      /*
       * Skip all fonts we've already used.
       */
      for (i = 0; i < fontPtr->numSubFonts; i++) {
          if (faceName == fontPtr->subFontArray[i].familyPtr->faceName) {
              return NULL;
          }
      }
      /*
       * Load this font and see if it has the desired character.
       */
      hFont = GetScreenFont(&fontPtr->font.fa, faceName, fontPtr->pixelSize);
      InitSubFont(hdc, hFont, 0, &subFont);
      if (((ch < 256) && (subFont.familyPtr->isSymbolFont))
              || (FontMapLookup(&subFont, ch) == 0)) {
          /*
           * Don't use a symbol font as a fallback font for characters below
           * 256.
           */
          ReleaseSubFont(&subFont);
          return NULL;
      }
      if (fontPtr->numSubFonts >= SUBFONT_SPACE) {
          SubFont *newPtr;
          newPtr = (SubFont *) ckalloc(sizeof(SubFont)
                  * (fontPtr->numSubFonts + 1));
          memcpy((char *) newPtr, fontPtr->subFontArray,
                  fontPtr->numSubFonts * sizeof(SubFont));
          if (fontPtr->subFontArray != fontPtr->staticSubFonts) {
              ckfree((char *) fontPtr->subFontArray);
          }
          fontPtr->subFontArray = newPtr;
      }
      fontPtr->subFontArray[fontPtr->numSubFonts] = subFont;
      fontPtr->numSubFonts++;
      return &fontPtr->subFontArray[fontPtr->numSubFonts - 1];
  }
  /*
   *---------------------------------------------------------------------------
   *
   * GetScreenFont --
   *
   *      Given the name and other attributes, construct an HFONT.
   *      This is where all the alias and fallback substitution bottoms
   *      out.
   *
   * Results:
   *      The screen font that corresponds to the attributes.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  static HFONT
  GetScreenFont(
      CONST TkFontAttributes *faPtr,
                                  /* Desired font attributes for new HFONT. */
      CONST char *faceName,       /* Overrides font family specified in font
                                   * attributes. */
      int pixelSize)              /* Overrides size specified in font
                                   * attributes. */
  {
      Tcl_DString ds;
      HFONT hFont;
      LOGFONTW lf;
      lf.lfHeight         = -pixelSize;
      lf.lfWidth          = 0;
      lf.lfEscapement     = 0;
      lf.lfOrientation    = 0;
      lf.lfWeight         = (faPtr->weight == TK_FW_NORMAL) ? FW_NORMAL : FW_BOLD;
      lf.lfItalic         = faPtr->slant;
      lf.lfUnderline      = faPtr->underline;
      lf.lfStrikeOut      = faPtr->overstrike;
      lf.lfCharSet        = DEFAULT_CHARSET;
      lf.lfOutPrecision   = OUT_TT_PRECIS;
      lf.lfClipPrecision  = CLIP_DEFAULT_PRECIS;
      lf.lfQuality        = DEFAULT_QUALITY;
      lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
      Tcl_UtfToExternalDString(systemEncoding, faceName, -1, &ds);
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          Tcl_UniChar *src, *dst;
          /*
           * We can only store up to LF_FACESIZE wide characters
           */
          if (Tcl_DStringLength(&ds) >= (LF_FACESIZE * sizeof(WCHAR))) {
              Tcl_DStringSetLength(&ds, LF_FACESIZE);
          }
          src = (Tcl_UniChar *) Tcl_DStringValue(&ds);
          dst = (Tcl_UniChar *) lf.lfFaceName;
          while (*src != '\0') {
              *dst++ = *src++;
          }
          *dst = '\0';
          hFont = CreateFontIndirectW(&lf);
      } else {
          /*
           * We can only store up to LF_FACESIZE characters
           */
          if (Tcl_DStringLength(&ds) >= LF_FACESIZE) {
              Tcl_DStringSetLength(&ds, LF_FACESIZE);
          }
          strcpy((char *) lf.lfFaceName, Tcl_DStringValue(&ds));
          hFont = CreateFontIndirectA((LOGFONTA *) &lf);
      }
      Tcl_DStringFree(&ds);
      return hFont;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * FamilyExists, FamilyOrAliasExists, WinFontExistsProc --
   *
   *      Determines if any physical screen font exists on the system with
   *      the given family name.  If the family exists, then it should be
   *      possible to construct some physical screen font with that family
   *      name.
   *
   * Results:
   *      The return value is 0 if the specified font family does not exist,
   *      non-zero otherwise.
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  static int
  FamilyExists(
      HDC hdc,                    /* HDC in which font family will be used. */
      CONST char *faceName)       /* Font family to query. */
  {
      int result;
      Tcl_DString faceString;
      /*
       * Just immediately rule out the following fonts, because they look so
       * ugly on windows.  The caller's fallback mechanism will cause the
       * corresponding appropriate TrueType fonts to be selected.
       */
      if (strcasecmp(faceName, "Courier") == 0) {
          return 0;
      }
      if (strcasecmp(faceName, "Times") == 0) {
          return 0;
      }
      if (strcasecmp(faceName, "Helvetica") == 0) {
          return 0;
      }
      Tcl_UtfToExternalDString(systemEncoding, faceName, -1, &faceString);
      /*
       * If the family exists, WinFontExistProc() will be called and
       * EnumFontFamilies() will return whatever WinFontExistProc() returns.
       * If the family doesn't exist, EnumFontFamilies() will just return a
       * non-zero value.
       */
      if (TkWinGetPlatformId() == VER_PLATFORM_WIN32_NT) {
          result = EnumFontFamiliesW(hdc, (WCHAR *) Tcl_DStringValue(&faceString),
                  (FONTENUMPROCW) WinFontExistProc, 0);
      } else {
          result = EnumFontFamiliesA(hdc, (char *) Tcl_DStringValue(&faceString),
                  (FONTENUMPROCA) WinFontExistProc, 0);
      }
      Tcl_DStringFree(&faceString);
      return (result == 0);
  }
  static char *
  FamilyOrAliasExists(
      HDC hdc,
      CONST char *faceName)
  {
      char **aliases;
      int i;
      if (FamilyExists(hdc, faceName) != 0) {
          return (char *) faceName;
      }
      aliases = TkFontGetAliasList(faceName);
      if (aliases != NULL) {
          for (i = 0; aliases[i] != NULL; i++) {
              if (FamilyExists(hdc, aliases[i]) != 0) {
                  return aliases[i];
              }
          }
      }
      return NULL;
  }
  static int CALLBACK
  WinFontExistProc(
      ENUMLOGFONT *lfPtr,         /* Logical-font data. */
      NEWTEXTMETRIC *tmPtr,       /* Physical-font data (not used). */
      int fontType,               /* Type of font (not used). */
      LPARAM lParam)              /* EnumFontData to hold result. */
  {
      return 0;
  }
  /*
   * The following data structures are used when querying a TrueType font file
   * to determine which characters the font supports.
   */
  #pragma pack(1)                 /* Structures are byte aligned in file. */
  #define CMAPHEX  0x636d6170     /* Key for character map resource. */
  typedef struct CMAPTABLE {
      USHORT version;             /* Table version number (0). */
      USHORT numTables;           /* Number of encoding tables following. */
  } CMAPTABLE;
  typedef struct ENCODINGTABLE {
      USHORT platform;            /* Platform for which data is targeted.
                                   * 3 means data is for Windows. */
      USHORT encoding;            /* How characters in font are encoded.
                                   * 1 means that the following subtable is
                                   * keyed based on Unicode. */
      ULONG offset;               /* Byte offset from beginning of CMAPTABLE
                                   * to the subtable for this encoding. */
  } ENCODINGTABLE;
  typedef struct ANYTABLE {
      USHORT format;              /* Format number. */
      USHORT length;              /* The actual length in bytes of this
                                   * subtable. */
      USHORT version;             /* Version number (starts at 0). */
  } ANYTABLE;
  typedef struct BYTETABLE {
      USHORT format;              /* Format number is set to 0. */
      USHORT length;              /* The actual length in bytes of this
                                   * subtable. */
      USHORT version;             /* Version number (starts at 0). */
      BYTE glyphIdArray[256];     /* Array that maps up to 256 single-byte char
                                   * codes to glyph indices. */
  } BYTETABLE;
  typedef struct SUBHEADER {
      USHORT firstCode;           /* First valid low byte for subHeader. */
      USHORT entryCount;          /* Number valid low bytes for subHeader. */
      SHORT idDelta;              /* Constant adder to get base glyph index. */
      USHORT idRangeOffset;       /* Byte offset from here to appropriate
                                   * glyphIndexArray. */
  } SUBHEADER;
  typedef struct HIBYTETABLE {
      USHORT format;              /* Format number is set to 2. */
      USHORT length;              /* The actual length in bytes of this
                                   * subtable. */
      USHORT version;             /* Version number (starts at 0). */
      USHORT subHeaderKeys[256];  /* Maps high bytes to subHeaders: value is
                                   * subHeader index * 8. */
  #if 0
      SUBHEADER subHeaders[];     /* Variable-length array of SUBHEADERs. */
      USHORT glyphIndexArray[];   /* Variable-length array containing subarrays
                                   * used for mapping the low byte of 2-byte
                                   * characters. */
  #endif
  } HIBYTETABLE;
  typedef struct SEGMENTTABLE {
      USHORT format;              /* Format number is set to 4. */
      USHORT length;              /* The actual length in bytes of this
                                   * subtable. */
      USHORT version;             /* Version number (starts at 0). */
      USHORT segCountX2;          /* 2 x segCount. */
      USHORT searchRange;         /* 2 x (2**floor(log2(segCount))). */
      USHORT entrySelector;       /* log2(searchRange/2). */
      USHORT rangeShift;          /* 2 x segCount - searchRange. */
  #if 0
      USHORT endCount[segCount]   /* End characterCode for each segment. */
      USHORT reservedPad;         /* Set to 0. */
      USHORT startCount[segCount];/* Start character code for each segment. */
      USHORT idDelta[segCount];   /* Delta for all character in segment. */
      USHORT idRangeOffset[segCount]; /* Offsets into glyphIdArray or 0. */
      USHORT glyphIdArray[]       /* Glyph index array. */
  #endif
  } SEGMENTTABLE;
  typedef struct TRIMMEDTABLE {
      USHORT format;              /* Format number is set to 6. */
      USHORT length;              /* The actual length in bytes of this
                                   * subtable. */
      USHORT version;             /* Version number (starts at 0). */
      USHORT firstCode;           /* First character code of subrange. */
      USHORT entryCount;          /* Number of character codes in subrange. */
  #if 0
      USHORT glyphIdArray[];      /* Array of glyph index values for
                                          character codes in the range. */
  #endif
  } TRIMMEDTABLE;
  typedef union SUBTABLE {
      ANYTABLE any;
      BYTETABLE byte;
      HIBYTETABLE hiByte;
      SEGMENTTABLE segment;
      TRIMMEDTABLE trimmed;
  } SUBTABLE;
  #pragma pack()
  /*
   *-------------------------------------------------------------------------
   *
   * LoadFontRanges --
   *
   *      Given an HFONT, get the information about the characters that
   *      this font can display.
   *
   * Results:
   *      If the font has no Unicode character information, the return value
   *      is 0 and *startCountPtr and *endCountPtr are filled with NULL.
   *      Otherwise, *startCountPtr and *endCountPtr are set to pointers to
   *      arrays of TrueType character existence information and the return
   *      value is the length of the arrays (the two arrays are always the
   *      same length as each other).
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  static int
  LoadFontRanges(
      HDC hdc,                    /* HDC into which font can be selected. */
      HFONT hFont,                /* HFONT to query. */
      USHORT **startCountPtr,     /* Filled with malloced pointer to
                                   * character range information. */
      USHORT **endCountPtr,       /* Filled with malloced pointer to
                                   * character range information. */
      int *symbolPtr)
   {
      int n, i, swapped, offset, cbData, segCount;
      DWORD cmapKey;
      USHORT *startCount, *endCount;
      CMAPTABLE cmapTable;
      ENCODINGTABLE encTable;
      SUBTABLE subTable;
      char *s;
      segCount = 0;
      startCount = NULL;
      endCount = NULL;
      *symbolPtr = 0;
      hFont = SelectObject(hdc, hFont);
      i = 0;
      s = (char *) &i;
      *s = '\1';
      swapped = 0;
      if (i == 1) {
          swapped = 1;
      }
      cmapKey = CMAPHEX;
      if (swapped) {
          SwapLong(&cmapKey);
      }
      n = GetFontData(hdc, cmapKey, 0, &cmapTable, sizeof(cmapTable));
      if (n != GDI_ERROR) {
          if (swapped) {
              SwapShort(&cmapTable.numTables);
          }
          for (i = 0; i < cmapTable.numTables; i++) {
              offset = sizeof(cmapTable) + i * sizeof(encTable);
              GetFontData(hdc, cmapKey, offset, &encTable, sizeof(encTable));
              if (swapped) {
                  SwapShort(&encTable.platform);
                  SwapShort(&encTable.encoding);
                  SwapLong(&encTable.offset);
              }
              if (encTable.platform != 3) {
                  /*
                   * Not Microsoft encoding.
                   */
                  continue;
              }
              if (encTable.encoding == 0) {
                  *symbolPtr = 1;
              } else if (encTable.encoding != 1) {
                  continue;
              }
              GetFontData(hdc, cmapKey, encTable.offset, &subTable,
                      sizeof(subTable));
              if (swapped) {
                  SwapShort(&subTable.any.format);
              }
              if (subTable.any.format == 4) {
                  if (swapped) {
                      SwapShort(&subTable.segment.segCountX2);
                  }
                  segCount = subTable.segment.segCountX2 / 2;
                  cbData = segCount * sizeof(USHORT);
                  startCount = (USHORT *) ckalloc(cbData);
                  endCount = (USHORT *) ckalloc(cbData);
                  offset = encTable.offset + sizeof(subTable.segment);
                  GetFontData(hdc, cmapKey, offset, endCount, cbData);
                  offset += cbData + sizeof(USHORT);
                  GetFontData(hdc, cmapKey, offset, startCount, cbData);
                  if (swapped) {
                      for (i = 0; i < segCount; i++) {
                          SwapShort(&endCount[i]);
                          SwapShort(&startCount[i]);
                      }
                  }
                  if (*symbolPtr != 0) {
                      /*
                       * Empirically determined:  When a symbol font is
                       * loaded, the character existence metrics obtained
                       * from the system are mildly wrong.  If the real range
                       * of the symbol font is from 0020 to 00FE, then the
                       * metrics are reported as F020 to F0FE.  When we load
                       * a symbol font, we must fix the character existence
                       * metrics.
                       *
                       * Symbol fonts should only use the symbol encoding
                       * for 8-bit characters [note Bug: 2406]
                       */
                      for (i = 0; i < segCount; i++) {
                          if (((startCount[i] & 0xff00) == 0xf000)
                                  && ((endCount[i] & 0xff00) == 0xf000)) {
                              startCount[i] &= 0xff;
                              endCount[i] &= 0xff;
                          }
                      }
                  }
              }
          }
      }
      SelectObject(hdc, hFont);
      *startCountPtr = startCount;
      *endCountPtr = endCount;
      return segCount;
  }
  /*
   *-------------------------------------------------------------------------
   *
   * SwapShort, SwapLong --
   *
   *      Helper functions to convert the data loaded from TrueType font
   *      files to Intel byte ordering.
   *
   * Results:
   *      Bytes of input value are swapped and stored back in argument.
   *
   * Side effects:
   *      None.
   *
   *-------------------------------------------------------------------------
   */
  static void
  SwapShort(PUSHORT p)
  {
      *p = (SHORT)(HIBYTE(*p) + (LOBYTE(*p) << 8));
  }
  static void
  SwapLong(PULONG p)
  {
      ULONG temp;
      temp = (LONG) ((BYTE) *p);
      temp <<= 8;
      *p >>=8;
      temp += (LONG) ((BYTE) *p);
      temp <<= 8;
      *p >>=8;
      temp += (LONG) ((BYTE) *p);
      temp <<= 8;
      *p >>=8;
      temp += (LONG) ((BYTE) *p);
      *p = temp;
  }
  /* End of tkwinfont.c */

 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
-Removed from v.69
+Added in v.71

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25