1 files changed, 632 insertions, 483 deletions

diff --git a/src/w32font.c b/src/w32font.c
index e0e3f69cac6..b8b8e6a71d9 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -35,25 +35,33 @@ struct w32font_info
 {
   struct font font;
   TEXTMETRIC metrics;
-  /* Unicode subset bitfield. See MSDN documentation for FONTSIGNATURE.  */
-  DWORD *subranges;
 };
 
 extern struct font_driver w32font_driver;
 
-Lisp_Object Qw32, QCsubranges;
-static Lisp_Object Qmodern, Qswiss, Qroman, Qdecorative, Qscript, Qunknown;
+Lisp_Object Qw32, QCfamily;
+static Lisp_Object Qmonospace, Qsans_serif, Qserif, Qmono, Qsans, Qsans__serif;
+static Lisp_Object Qscript, Qdecorative, Qraster, Qoutline, Qunknown;
+
+/* scripts */
+static Lisp_Object Qlatin, Qgreek, Qcoptic, Qcyrillic, Qarmenian, Qhebrew;
+static Lisp_Object Qarabic, Qsyriac, Qnko, Qthaana, Qdevanagari, Qbengali;
+static Lisp_Object Qgurmukhi, Qgujarati, Qoriya, Qtamil, Qtelugu;
+static Lisp_Object Qkannada, Qmalayalam, Qsinhala, Qthai, Qlao;
+static Lisp_Object Qtibetan, Qmyanmar, Qgeorgian, Qhangul, Qethiopic;
+static Lisp_Object Qcherokee, Qcanadian_aboriginal, Qogham, Qrunic;
+static Lisp_Object Qkhmer, Qmongolian, Qsymbol, Qbraille, Qhan;
+static Lisp_Object Qideographic_description, Qcjk_misc, Qkana, Qbopomofo;
+static Lisp_Object Qkanbun, Qyi, Qbyzantine_musical_symbol;
+static Lisp_Object Qmusical_symbol, Qmathematical;
+
+/* Font spacing symbols - defined in font.c.  */
+extern Lisp_Object Qc, Qp, Qm;
 
 static void fill_in_logfont P_ ((FRAME_PTR f, LOGFONT *logfont,
                                  Lisp_Object font_spec));
 
-static void set_fonts_frame P_ ((Lisp_Object fontlist, Lisp_Object frame));
-
-static int unicode_range_for_char (unsigned c);
-
-static void list_all_matching_fonts P_ ((Lisp_Object frame,
-                                         LOGFONT *font_match_pattern,
-                                         Lisp_Object* list));
+static Lisp_Object font_supported_scripts P_ ((FONTSIGNATURE * sig));
 
 /* From old font code in w32fns.c */
 char * w32_to_x_charset P_ ((int charset, char * matching));
@@ -71,11 +79,27 @@ static int CALLBACK add_font_name_to_list P_ ((ENUMLOGFONTEX *,
                                                NEWTEXTMETRICEX *,
                                                DWORD, LPARAM));
 
-/* W32 API functions only available on some versions of Windows  */
-typedef DWORD (*GETGLYPHINDICES) (HDC, wchar_t *, int, LPWORD, DWORD);
-typedef BOOL (*GETTEXTEXTENTPTI) (HDC, LPWORD, int, LPSIZE);
-static GETGLYPHINDICES get_glyph_indices_fn = NULL;
-static GETTEXTEXTENTPTI get_text_extent_pointi_fn = NULL;
+/* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
+   of what we really want.  */
+struct font_callback_data
+{
+  /* The logfont we are matching against. EnumFontFamiliesEx only matches
+     face name and charset, so we need to manually match everything else
+     in the callback function.  */
+  LOGFONT pattern;
+  /* The original font spec or entity.  */
+  Lisp_Object orig_font_spec;
+  /* The frame the font is being loaded on.  */
+  Lisp_Object frame;
+  /* The list to add matches to.  */
+  Lisp_Object list;
+};
+
+/* Handles the problem that EnumFontFamiliesEx will not return all
+   style variations if the font name is not specified.  */
+static void list_all_matching_fonts P_ ((struct font_callback_data *match_data));
+
+
 /* MingW headers only define this when _WIN32_WINNT >= 0x0500, but we
    target older versions.  */
 #define GGI_MARK_NONEXISTING_GLYPHS 1
@@ -109,34 +133,34 @@ static Lisp_Object
 w32font_list (frame, font_spec)
      Lisp_Object frame, font_spec;
 {
-  Lisp_Object list = Qnil;
-  LOGFONT font_match_pattern;
+  Lisp_Object tem;
+  struct font_callback_data match_data;
   HDC dc;
   FRAME_PTR f = XFRAME (frame);
 
-  bzero (&font_match_pattern, sizeof (font_match_pattern));
-  fill_in_logfont (f, &font_match_pattern, font_spec);
+  match_data.orig_font_spec = font_spec;
+  match_data.list = Qnil;
+  match_data.frame = frame;
+  bzero (&match_data.pattern, sizeof (LOGFONT));
+  fill_in_logfont (f, &match_data.pattern, font_spec);
 
-
-  if (font_match_pattern.lfFaceName[0] == '\0')
+  if (match_data.pattern.lfFaceName[0] == '\0')
     {
       /* EnumFontFamiliesEx does not take other fields into account if
          font name is blank, so need to use two passes.  */
-      list_all_matching_fonts (frame, &font_match_pattern, &list);
+      list_all_matching_fonts (&match_data);
     }
   else
     {
       dc = get_frame_dc (f);
 
-      EnumFontFamiliesEx (dc, &font_match_pattern,
+      EnumFontFamiliesEx (dc, &match_data.pattern,
                           (FONTENUMPROC) add_font_entity_to_list,
-                          (LPARAM) &list, 0);
+                          (LPARAM) &match_data, 0);
       release_frame_dc (f, dc);
     }
 
-  set_fonts_frame (list, frame);
-
-  return list;
+  return NILP (match_data.list) ? null_vector : Fvconcat (1, &match_data.list);
 }
 
 /* w32 implementation of match for font backend.
@@ -147,24 +171,24 @@ static Lisp_Object
 w32font_match (frame, font_spec)
      Lisp_Object frame, font_spec;
 {
-  Lisp_Object list = Qnil;
-  LOGFONT font_match_pattern;
+  struct font_callback_data match_data;
   HDC dc;
   FRAME_PTR f = XFRAME (frame);
 
-  bzero (&font_match_pattern, sizeof (font_match_pattern));
-  fill_in_logfont (f, &font_match_pattern, font_spec);
+  match_data.orig_font_spec = font_spec;
+  match_data.frame = frame;
+  match_data.list = Qnil;
+  bzero (&match_data.pattern, sizeof (LOGFONT));
+  fill_in_logfont (f, &match_data.pattern, font_spec);
 
   dc = get_frame_dc (f);
 
-  EnumFontFamiliesEx (dc, &font_match_pattern,
+  EnumFontFamiliesEx (dc, &match_data.pattern,
                       (FONTENUMPROC) add_one_font_entity_to_list,
-                      (LPARAM) &list, 0);
+                      (LPARAM) &match_data, 0);
   release_frame_dc (f, dc);
 
-  set_fonts_frame (list, frame);
-
-  return NILP (list) ? Qnil : XCAR (list);
+  return NILP (match_data.list) ? Qnil : XCAR (match_data.list);
 }
 
 
@@ -219,7 +243,7 @@ w32font_open (f, font_entity, pixel_size)
   fill_in_logfont (f, &logfont, font_entity);
 
   size = XINT (AREF (font_entity, FONT_SIZE_INDEX));
-  if (size == 0)
+  if (!size)
     size = pixel_size;
 
   logfont.lfHeight = -size;
@@ -281,22 +305,6 @@ w32font_open (f, font_entity, pixel_size)
   font->descent = w32_font->metrics.tmDescent;
   font->scalable = w32_font->metrics.tmPitchAndFamily & TMPF_VECTOR;
 
-  /* Truetype fonts will have extra information about the characters
-     covered by the font.  */
-  ((struct w32font_info *)(font))->subranges = NULL;
-  extra = AREF (font_entity, FONT_EXTRA_INDEX);
-  if (CONSP (extra))
-    {
-      val = assq_no_quit (extra, QCsubranges);
-      if (CONSP (val))
-        {
-          val = XCDR (val);
-
-          if (XTYPE (val) == Lisp_Misc && XMISCTYPE (val) == Lisp_Misc_Save_Value)
-            ((struct w32font_info *)(font))->subranges = XSAVE_VALUE (val)->pointer;
-        }
-    }
-
   return font;
 }
 
@@ -330,33 +338,22 @@ w32font_has_char (entity, c)
      Lisp_Object entity;
      int c;
 {
-  Lisp_Object val, extra;
-  DWORD *ranges;
-  int index;
+  Lisp_Object supported_scripts, extra, script;
   DWORD mask;
 
   extra = AREF (entity, FONT_EXTRA_INDEX);
   if (!CONSP (extra))
     return -1;
 
-  val = assq_no_quit (extra, QCsubranges);
-  if (!CONSP (val))
-    return -1;
-
-  val = XCDR (val);
-  if (XTYPE (val) != Lisp_Misc || XMISCTYPE (val) != Lisp_Misc_Save_Value)
+  supported_scripts = assq_no_quit (QCscript, extra);
+  if (!CONSP (supported_scripts))
     return -1;
 
-  ranges = XSAVE_VALUE (val)->pointer;
+  supported_scripts = XCDR (supported_scripts);
 
-  index = unicode_range_for_char (c);
-  mask = 1 << (index % 32);
-  index = index / 32;
+  script = CHAR_TABLE_REF (Vchar_script_table, c);
 
-  if (ranges[index] & mask)
-    return 1;
-  else
-    return 0;
+  return (memq_no_quit (script, supported_scripts)) ? 1 : 0;
 }
 
 /* w32 implementation of encode_char for font backend.
@@ -367,32 +364,8 @@ w32font_encode_char (font, c)
      struct font *font;
      int c;
 {
-  if (get_glyph_indices_fn)
-    {
-      HFONT old_font;
-      WORD glyph[2];
-      int converted;
-      /* FIXME: Be nice if we had a frame here, rather than getting
-         the desktop's device context to measure against... */
-      HDC dc = GetDC (NULL);
-      wchar_t string[2];
-      string[0] = c;
-      string[1] = 0x0000;
-
-      if (get_glyph_indices_fn)
-        converted = (*get_glyph_indices_fn) (dc, string, 1, glyph,
-                                             GGI_MARK_NONEXISTING_GLYPHS);
-
-      /* Restore state and release DC.  */
-      SelectObject (dc, old_font);
-      ReleaseDC (NULL, dc);
-      if (converted > 0 && glyph[0] != 0xFFFF)
-        return glyph[0];
-      else if (converted != GDI_ERROR)
-        return FONT_INVALID_CODE;
-    }
-  /* On older platforms, or if the above fails, return the unicode
-     code point.  */
+  /* Avoid unneccesary conversion - all the Win32 APIs will take a unicode
+     character.  */
   return c;
 }
 
@@ -417,21 +390,34 @@ w32font_text_extents (font, code, nglyphs, metrics)
 
   /* TODO: Allow some extra room for surrogates. */
   WORD *wcode = alloca(nglyphs * sizeof (WORD));
+  SIZE size;
 
   old_font = SelectObject (dc, ((W32FontStruct *)(font->font.font))->hfont);
 
   if (metrics)
     {
       GLYPHMETRICS gm;
-      int i;
+      MAT2 transform;
+      int i, width;
       UINT format = GGO_METRICS;
-      if (get_text_extent_pointi_fn)
-        format |= GGO_GLYPH_INDEX;
+
+      /* Set transform to the identity matrix.  */
+      bzero (&transform, sizeof (transform));
+      transform.eM11.value = 1;
+      transform.eM22.value = 1;
 
       for (i = 0; i < nglyphs; i++)
         {
-          if (GetGlyphOutline (dc, *(code + i), format, &gm, 0, NULL, NULL)
-              != GDI_ERROR)
+          if (code[i] < 0x10000)
+            wcode[i] = code[i];
+          else
+            {
+              /* TODO: Convert to surrogate, reallocating array if needed */
+              wcode[i] = 0xffff;
+            }
+
+          if (GetGlyphOutlineW (dc, *(code + i), format, &gm, 0,
+                                NULL, &transform) != GDI_ERROR)
             {
               metrics[i].lbearing = gm.gmptGlyphOrigin.x;
               metrics[i].rbearing = gm.gmptGlyphOrigin.x + gm.gmBlackBoxX;
@@ -450,28 +436,26 @@ w32font_text_extents (font, code, nglyphs, metrics)
             }
         }
     }
-
-  for (i = 0; i < nglyphs; i++)
+  else
     {
-      if (code[i] < 0x10000)
-        wcode[i] = code[i];
-      else
-        {
-          /* TODO: Convert to surrogate, reallocating array if needed */
-          wcode[i] = 0xffff;
-        }
+      for (i = 0; i < nglyphs; i++)
+        {
+          if (code[i] < 0x10000)
+            wcode[i] = code[i];
+          else
+            {
+              /* TODO: Convert to surrogate, reallocating array if needed */
+              wcode[i] = 0xffff;
+            }
+        }
     }
 
-  if (get_text_extent_pointi_fn)
+  if (GetTextExtentPoint32W (dc, wcode, nglyphs, &size))
     {
-      SIZE size;
-      if ((*get_text_extent_pointi_fn) (dc, wcode, nglyphs, &size))
-        {
-          total_width = size.cx;
-        }
+      total_width = size.cx;
     }
 
-  if (total_width == 0)
+  if (!total_width)
     {
       RECT rect;
       rect.top = 0; rect.bottom = font->font.height; rect.left = 0; rect.right = 1;
@@ -479,6 +463,7 @@ w32font_text_extents (font, code, nglyphs, metrics)
                  DT_CALCRECT | DT_NOPREFIX | DT_SINGLELINE);
       total_width = rect.right;
     }
+
   /* Restore state and release DC.  */
   SelectObject (dc, old_font);
   ReleaseDC (NULL, dc);
@@ -497,7 +482,6 @@ w32font_draw (s, from, to, x, y, with_background)
      struct glyph_string *s;
      int from, to, x, y, with_background;
 {
-  /* TODO: Do we need to specify ETO_GLYPH_INDEX or is char2b always utf-16?  */
   UINT options = 0;
 
   if (with_background)
@@ -619,7 +603,8 @@ add_font_name_to_list (logical_font, physical_font, font_type, list_object)
 
 /* Convert an enumerated Windows font to an Emacs font entity.  */
 static Lisp_Object
-w32_enumfont_pattern_entity (logical_font, physical_font, font_type)
+w32_enumfont_pattern_entity (frame, logical_font, physical_font, font_type)
+     Lisp_Object frame;
      ENUMLOGFONTEX *logical_font;
      NEWTEXTMETRICEX *physical_font;
      DWORD font_type;
@@ -628,37 +613,58 @@ w32_enumfont_pattern_entity (logical_font, physical_font, font_type)
   LOGFONT *lf = (LOGFONT*) logical_font;
   BYTE generic_type;
 
-  entity = Fmake_vector (make_number (FONT_ENTITY_MAX), null_string);
+  entity = Fmake_vector (make_number (FONT_ENTITY_MAX), Qnil);
 
   ASET (entity, FONT_TYPE_INDEX, Qw32);
+  ASET (entity, FONT_FRAME_INDEX, frame);
   ASET (entity, FONT_REGISTRY_INDEX, w32_registry (lf->lfCharSet));
   ASET (entity, FONT_OBJLIST_INDEX, Qnil);
 
   /* Foundry is difficult to get in readable form on Windows.
-     But Emacs crashes if it is not set, so set it to the generic type.  */
+     But Emacs crashes if it is not set, so set it to something more
+     generic.  Thes values make xflds compatible with Emacs 22. */
+  if (lf->lfOutPrecision == OUT_STRING_PRECIS)
+    tem = Qraster;
+  else if (lf->lfOutPrecision == OUT_STROKE_PRECIS)
+    tem = Qoutline;
+  else
+    tem = Qunknown;
+
+  ASET (entity, FONT_FOUNDRY_INDEX, tem);
+
+  /* Save the generic family in the extra info, as it is likely to be
+     useful to users looking for a close match.  */
   generic_type = physical_font->ntmTm.tmPitchAndFamily & 0xF0;
   if (generic_type == FF_DECORATIVE)
     tem = Qdecorative;
   else if (generic_type == FF_MODERN)
-    tem = Qmodern;
+    tem = Qmonospace;
   else if (generic_type == FF_ROMAN)
-    tem = Qroman;
+    tem = Qserif;
   else if (generic_type == FF_SCRIPT)
     tem = Qscript;
   else if (generic_type == FF_SWISS)
-    tem = Qswiss;
+    tem = Qsans_serif;
   else
-    tem = Qunknown;
+    tem = Qnil;
+    
+  if (! NILP (tem))
+    font_put_extra (entity, QCfamily, tem);
 
-  ASET (entity, FONT_FOUNDRY_INDEX, tem);
+
+  if (physical_font->ntmTm.tmPitchAndFamily & 0x01)
+    font_put_extra (entity, QCspacing, make_number (FONT_SPACING_PROPORTIONAL));
+  else
+    font_put_extra (entity, QCspacing, make_number (FONT_SPACING_MONO));
 
   ASET (entity, FONT_FAMILY_INDEX,
         intern_downcase (lf->lfFaceName, strlen (lf->lfFaceName)));
 
   ASET (entity, FONT_WEIGHT_INDEX, make_number (lf->lfWeight));
   ASET (entity, FONT_SLANT_INDEX, make_number (lf->lfItalic ? 200 : 100));
-  ASET (entity, FONT_WIDTH_INDEX,
-        make_number (physical_font->ntmTm.tmAveCharWidth));
+  /* TODO: PANOSE struct has this info, but need to call GetOutlineTextMetrics
+     to get it.  */
+  ASET (entity, FONT_WIDTH_INDEX, make_number (100));
 
   if (font_type & RASTER_FONTTYPE)
     ASET (entity, FONT_SIZE_INDEX, make_number (physical_font->ntmTm.tmHeight));
@@ -669,43 +675,255 @@ w32_enumfont_pattern_entity (logical_font, physical_font, font_type)
      of getting this information easily.  */
   if (font_type & TRUETYPE_FONTTYPE)
     {
-      DWORD *subranges = xmalloc(16);
-      memcpy (subranges, physical_font->ntmFontSig.fsUsb, 16);
-      font_put_extra (entity, QCsubranges, make_save_value (subranges, 0));
+      font_put_extra (entity, QCscript,
+                      font_supported_scripts (&physical_font->ntmFontSig));
     }
+
   return entity;
 }
 
+
+/* Convert generic families to the family portion of lfPitchAndFamily.  */
+BYTE
+w32_generic_family (Lisp_Object name)
+{
+  /* Generic families.  */
+  if (EQ (name, Qmonospace) || EQ (name, Qmono))
+    return FF_MODERN;
+  else if (EQ (name, Qsans_serif) || EQ (name, Qsans__serif)
+           || EQ (name, Qsans))
+    return FF_SWISS;
+  else if (EQ (name, Qserif))
+    return FF_ROMAN;
+  else if (EQ (name, Qdecorative))
+    return FF_DECORATIVE;
+  else if (EQ (name, Qscript))
+    return FF_SCRIPT;
+  else
+    return FF_DONTCARE;
+}
+
+static int
+logfonts_match (font, pattern)
+     LOGFONT *font, *pattern;
+{
+  /* Only check height for raster fonts.  */
+  if (pattern->lfHeight && font->lfOutPrecision == OUT_STRING_PRECIS
+      && font->lfHeight != pattern->lfHeight)
+    return 0;
+
+  /* Have some flexibility with weights.  */
+  if (pattern->lfWeight
+      && ((font->lfWeight < (pattern->lfWeight - 150))
+          || font->lfWeight > (pattern->lfWeight + 150)))
+      return 0;
+
+  /* Charset and face should be OK.  Italic has to be checked
+     against the original spec, in case we don't have any preference.  */
+  return 1;
+}
+
+static int
+font_matches_spec (type, font, spec)
+     DWORD type;
+     NEWTEXTMETRICEX *font;
+     Lisp_Object spec;
+{
+  Lisp_Object extra, val;
+
+  /* Check italic. Can't check logfonts, since it is a boolean field,
+     so there is no difference between "non-italic" and "don't care".  */
+  val = AREF (spec, FONT_SLANT_INDEX);
+  if (INTEGERP (val))
+    {
+      int slant = XINT (val);
+      if ((slant > 150 && !font->ntmTm.tmItalic)
+          || (slant <= 150 && font->ntmTm.tmItalic))
+        {
+          OutputDebugString ("italic mismatch");
+        return 0;
+        }
+    }
+
+  /* Check extra parameters.  */
+  for (extra = AREF (spec, FONT_EXTRA_INDEX);
+       CONSP (extra); extra = XCDR (extra))
+    {
+      Lisp_Object extra_entry;
+      extra_entry = XCAR (extra);
+      if (CONSP (extra_entry))
+        {
+          Lisp_Object key = XCAR (extra_entry);
+          val = XCDR (extra_entry);
+          if (EQ (key, QCfamily))
+            {
+              /* Generic family. Most useful when there is no font name
+                 specified. eg, if a script does not exist in the default
+                 font, we could look for a font with the same generic family
+                 that does support the script. Full PANOSE support would
+                 be better, but we need to open the font to get that.  */
+              BYTE w32_family = w32_generic_family (val);
+
+              /* Reject if FF_DONTCARE is returned, as it means the
+                 font spec is bad.  */
+              if (w32_family == FF_DONTCARE
+                  || w32_family != (font->ntmTm.tmPitchAndFamily & 0xF0))
+                return 0;
+            }
+          else if (EQ (key, QCspacing))
+            {
+              int proportional;
+              if (INTEGERP (val))
+                {
+                  int spacing = XINT (val);
+                  proportional = (spacing < FONT_SPACING_MONO);
+                }
+              else if (EQ (val, Qp))
+                proportional = 1;
+              else if (EQ (val, Qc) || EQ (val, Qm))
+                proportional = 0;
+              else
+                return 0; /* Bad font spec.  */
+
+              if ((proportional && !(font->ntmTm.tmPitchAndFamily & 0x01))
+                  || (!proportional && (font->ntmTm.tmPitchAndFamily & 0x01)))
+                return 0;
+            }
+          else if (EQ (key, QCscript) && SYMBOLP (val))
+            {
+              /* Only truetype fonts will have information about what
+                 scripts they support.  This probably means the user
+                 will have to force Emacs to use raster, postscript
+                 or atm fonts for non-ASCII text.  */
+              if (type & TRUETYPE_FONTTYPE)
+                {
+                  Lisp_Object support
+                    = font_supported_scripts (&font->ntmFontSig);
+                  if (! memq_no_quit (val, support))
+                    return 0;
+                }
+              else
+                {
+                  /* Return specific matches, but play it safe. Fonts
+                     that cover more than their charset would suggest
+                     are likely to be truetype or opentype fonts,
+                     covered above.  */
+                  if (EQ (val, Qlatin))
+                    {
+                      /* Although every charset but symbol, thai and
+                         arabic contains the basic ASCII set of latin
+                         characters, Emacs expects much more.  */
+                      if (font->ntmTm.tmCharSet != ANSI_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qsymbol))
+                    {
+                      if (font->ntmTm.tmCharSet != SYMBOL_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qcyrillic))
+                    {
+                      if (font->ntmTm.tmCharSet != RUSSIAN_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qgreek))
+                    {
+                      if (font->ntmTm.tmCharSet != GREEK_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qarabic))
+                    {
+                      if (font->ntmTm.tmCharSet != ARABIC_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qhebrew))
+                    {
+                      if (font->ntmTm.tmCharSet != HEBREW_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qthai))
+                    {
+                      if (font->ntmTm.tmCharSet != THAI_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qkana))
+                    {
+                      if (font->ntmTm.tmCharSet != SHIFTJIS_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qbopomofo))
+                    {
+                      if (font->ntmTm.tmCharSet != CHINESEBIG5_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qhangul))
+                    {
+                      if (font->ntmTm.tmCharSet != HANGUL_CHARSET
+                          && font->ntmTm.tmCharSet != JOHAB_CHARSET)
+                        return 0;
+                    }
+                  else if (EQ (val, Qhan))
+                    {
+                      if (font->ntmTm.tmCharSet != CHINESEBIG5_CHARSET
+                          && font->ntmTm.tmCharSet != GB2312_CHARSET
+                          && font->ntmTm.tmCharSet != HANGUL_CHARSET
+                          && font->ntmTm.tmCharSet != JOHAB_CHARSET
+                          && font->ntmTm.tmCharSet != SHIFTJIS_CHARSET)
+                        return 0;
+                    }
+                  else
+                    /* Other scripts unlikely to be handled.  */
+                    return 0;
+                }
+            }
+        }
+    }
+  return 1;
+}
+
 /* Callback function for EnumFontFamiliesEx.
- * Adds the name of a font to a Lisp list (passed in as the lParam arg).  */
+ * Checks if a font matches everything we are trying to check agaist,
+ * and if so, adds it to a list. Both the data we are checking against
+ * and the list to which the fonts are added are passed in via the
+ * lparam argument, in the form of a font_callback_data struct. */
 static int CALLBACK
-add_font_entity_to_list (logical_font, physical_font, font_type, list_object)
+add_font_entity_to_list (logical_font, physical_font, font_type, lParam)
      ENUMLOGFONTEX *logical_font;
      NEWTEXTMETRICEX *physical_font;
      DWORD font_type;
-     LPARAM list_object;
+     LPARAM lParam;
 {
-  Lisp_Object *list = (Lisp_Object *) list_object;
-  Lisp_Object entity = w32_enumfont_pattern_entity (logical_font,
-                                                    physical_font, font_type);
-  if (!NILP (entity))
-    *list = Fcons (entity, *list);
+  struct font_callback_data *match_data
+    = (struct font_callback_data *) lParam;
 
+  if (logfonts_match (&logical_font->elfLogFont, &match_data->pattern)
+      && font_matches_spec (font_type, physical_font,
+                            match_data->orig_font_spec))
+    {
+      Lisp_Object entity
+        = w32_enumfont_pattern_entity (match_data->frame, logical_font,
+                                       physical_font, font_type);
+      if (!NILP (entity))
+        match_data->list = Fcons (entity, match_data->list);
+    }
   return 1;
 }
 
 /* Callback function for EnumFontFamiliesEx.
- * Adds the name of a font to a Lisp list (passed in as the lParam arg),
- * then terminate the search.  */
+ * Terminates the search once we have a match. */
 static int CALLBACK
-add_one_font_entity_to_list (logical_font, physical_font, font_type, list)
+add_one_font_entity_to_list (logical_font, physical_font, font_type, lParam)
      ENUMLOGFONTEX *logical_font;
      NEWTEXTMETRICEX *physical_font;
      DWORD font_type;
-     LPARAM list;
+     LPARAM lParam;
 {
-  add_font_entity_to_list (logical_font, physical_font, font_type, list);
-  return 0;
+  struct font_callback_data *match_data
+    = (struct font_callback_data *) lParam;
+  add_font_entity_to_list (logical_font, physical_font, font_type, lParam);
+
+  /* If we have a font in the list, terminate the search.  */
+  return !NILP (match_data->list);
 }
 
 /* Convert a Lisp font registry (symbol) to a windows charset.  */
@@ -731,7 +949,7 @@ w32_registry (w32_charset)
      LONG w32_charset;
 {
   if (w32_charset == ANSI_CHARSET)
-    return Qiso8859_1;
+    return Qiso10646_1;
   else
     {
       char * charset = w32_to_x_charset (w32_charset, NULL);
@@ -739,24 +957,6 @@ w32_registry (w32_charset)
     }
 }
 
-static void
-set_fonts_frame (fontlist, frame)
-     Lisp_Object fontlist;
-     Lisp_Object frame;
-{
-  if (VECTORP (fontlist))
-    ASET (fontlist, FONT_FRAME_INDEX, frame);
-  else
-    {
-      for ( ; CONSP (fontlist); fontlist = XCDR (fontlist))
-        {
-          Lisp_Object entity = XCAR (fontlist);
-          if (VECTORP (entity))
-            ASET (entity, FONT_FRAME_INDEX, frame);
-        }
-    }
-}
-
 /* Fill in all the available details of LOGFONT from FONT_SPEC.  */
 static void
 fill_in_logfont (f, logfont, font_spec)
@@ -764,23 +964,30 @@ fill_in_logfont (f, logfont, font_spec)
      LOGFONT *logfont;
      Lisp_Object font_spec;
 {
-  Lisp_Object val, tmp, extra;
+  Lisp_Object tmp, extra;
   int dpi = FRAME_W32_DISPLAY_INFO (f)->resy;
 
-  /* TODO: Allow user to override dpi settings.  */
+  extra = AREF (font_spec, FONT_EXTRA_INDEX);
+  /* Allow user to override dpi settings.  */
+  if (CONSP (extra))
+    {
+      tmp = assq_no_quit (QCdpi, extra);
+      if (CONSP (tmp) && INTEGERP (XCDR (tmp)))
+        {
+          dpi = XINT (XCDR (tmp));
+        }
+      else if (CONSP (tmp) && FLOATP (XCDR (tmp)))
+        {
+          dpi = (int) (XFLOAT_DATA (XCDR (tmp)) + 0.5);
+        }
+    }
 
   /* Height  */
   tmp = AREF (font_spec, FONT_SIZE_INDEX);
   if (INTEGERP (tmp))
     logfont->lfHeight = -1 * XINT (tmp);
   else if (FLOATP (tmp))
-    logfont->lfHeight = (int) (-1.0 *  dpi * XFLOAT_DATA (tmp) / 72.0);
-
-  /* Width  TODO: makes fonts look distorted.
-  tmp = AREF (font_spec, FONT_WIDTH_INDEX);
-  if (INTEGERP (tmp))
-    logfont->lfWidth = XINT (tmp);
- */
+    logfont->lfHeight = (int) (-1.0 *  dpi * XFLOAT_DATA (tmp) / 72.27 + 0.5);
 
   /* Escapement  */
 
@@ -806,12 +1013,7 @@ fill_in_logfont (f, logfont, font_spec)
   /* Charset  */
   tmp = AREF (font_spec, FONT_REGISTRY_INDEX);
   if (! NILP (tmp))
-    {
-      if (STRINGP (tmp))
-        logfont->lfCharSet = x_to_w32_charset (SDATA (tmp));
-      else
-        logfont->lfCharSet = registry_to_w32_charset (tmp);
-    }
+    logfont->lfCharSet = registry_to_w32_charset (tmp);
 
   /* Out Precision  */
   /* Clip Precision  */
@@ -819,311 +1021,211 @@ fill_in_logfont (f, logfont, font_spec)
      can enable/disable anti-aliasing for individual fonts.  */
   logfont->lfQuality = DEFAULT_QUALITY;
 
-  /* Pitch and Family  */
-  /* Facename  TODO: handle generic names  */
+  /* Generic Family and Face Name  */
+  logfont->lfPitchAndFamily = FF_DONTCARE | DEFAULT_PITCH;
+
   tmp = AREF (font_spec, FONT_FAMILY_INDEX);
-  /* Font families are interned  */
-  if (SYMBOLP (tmp))
-    strncpy (logfont->lfFaceName, SDATA (SYMBOL_NAME (tmp)), LF_FACESIZE);
-  else if (STRINGP (tmp))
-    strncpy (logfont->lfFaceName, SDATA (tmp), LF_FACESIZE);
+  if (! NILP (tmp))
+    {
+      logfont->lfPitchAndFamily = w32_generic_family (tmp) | DEFAULT_PITCH;
+      if ((logfont->lfPitchAndFamily & 0xF0) != FF_DONTCARE)
+        ; /* Font name was generic, don't fill in font name.  */
+        /* Font families are interned, but allow for strings also in case of
+           user input.  */
+      else if (SYMBOLP (tmp))
+        strncpy (logfont->lfFaceName, SDATA (SYMBOL_NAME (tmp)), LF_FACESIZE);
+      else if (STRINGP (tmp))
+        strncpy (logfont->lfFaceName, SDATA (tmp), LF_FACESIZE);
+    }
 
+  /* Process EXTRA info.  */
+  for ( ; CONSP (extra); extra = XCDR (extra))
+    {
+      tmp = XCAR (extra);
+      if (CONSP (tmp))
+        {
+          Lisp_Object key, val;
+          key = XCAR (tmp), val = XCDR (tmp);
+          if (EQ (key, QCfamily))
+            {
+              /* Override generic family.  */
+              BYTE family = w32_generic_family (val);
+              if (family != FF_DONTCARE)
+                logfont->lfPitchAndFamily
+                  = logfont->lfPitchAndFamily & 0x0F | family;
+            }
+          else if (EQ (key, QCspacing))
+            {
+              /* Set pitch based on the spacing property.  */
+              if (INTEGERP (val))
+                {
+                  int spacing = XINT (val);
+                  if (spacing < FONT_SPACING_MONO)
+                    logfont->lfPitchAndFamily
+                      = logfont->lfPitchAndFamily & 0xF0 | VARIABLE_PITCH;
+                  else
+                    logfont->lfPitchAndFamily
+                      = logfont->lfPitchAndFamily & 0xF0 | FIXED_PITCH;
+                }
+              else if (EQ (val, Qp))
+                logfont->lfPitchAndFamily
+                  = logfont->lfPitchAndFamily & 0xF0 | VARIABLE_PITCH;
+              else if (EQ (val, Qc) || EQ (val, Qm))
+                logfont->lfPitchAndFamily
+                  = logfont->lfPitchAndFamily & 0xF0 | FIXED_PITCH;
+            }
+          /* Only use QCscript if charset is not provided, or is unicode
+             and a single script is specified.  This is rather crude,
+             and is only used to narrow down the fonts returned where
+             there is a definite match.  Some scripts, such as latin, han,
+             cjk-misc match multiple lfCharSet values, so we can't pre-filter
+             them.  */
+          else if (EQ (key, QCscript)
+                   && logfont->lfCharSet == DEFAULT_CHARSET
+                   && SYMBOLP (val))
+            {
+              if (EQ (val, Qgreek))
+                logfont->lfCharSet = GREEK_CHARSET;
+              else if (EQ (val, Qhangul))
+                logfont->lfCharSet = HANGUL_CHARSET;
+              else if (EQ (val, Qkana) || EQ (val, Qkanbun))
+                logfont->lfCharSet = SHIFTJIS_CHARSET;
+              else if (EQ (val, Qbopomofo))
+                logfont->lfCharSet = CHINESEBIG5_CHARSET;
+              /* GB 18030 supports tibetan, yi, mongolian,
+                 fonts that support it should show up if we ask for
+                 GB2312 fonts. */
+              else if (EQ (val, Qtibetan) || EQ (val, Qyi)
+                       || EQ (val, Qmongolian))
+                logfont->lfCharSet = GB2312_CHARSET;
+              else if (EQ (val, Qhebrew))
+                logfont->lfCharSet = HEBREW_CHARSET;
+              else if (EQ (val, Qarabic))
+                logfont->lfCharSet = ARABIC_CHARSET;
+              else if (EQ (val, Qthai))
+                logfont->lfCharSet = THAI_CHARSET;
+              else if (EQ (val, Qsymbol))
+                logfont->lfCharSet = SYMBOL_CHARSET;
+            }
+        }
+    }
 }
 
 static void
-list_all_matching_fonts (frame, font_match_pattern, list)
-     Lisp_Object frame;
-     LOGFONT *font_match_pattern;
-     Lisp_Object* list;
+list_all_matching_fonts (match_data)
+     struct font_callback_data *match_data;
 {
   HDC dc;
-  Lisp_Object families = w32font_list_family (frame);
-  struct frame *f = XFRAME (frame);
+  Lisp_Object families = w32font_list_family (match_data->frame);
+  struct frame *f = XFRAME (match_data->frame);
 
   dc = get_frame_dc (f);
 
   while (!NILP (families))
     {
+      /* TODO: Use the Unicode versions of the W32 APIs, so we can
+         handle non-ASCII font names.  */
+      char *name;
       Lisp_Object family = CAR (families);
       families = CDR (families);
-      if (STRINGP (family))
-        {
-          /* TODO: Use the Unicode versions of the W32 APIs, so we can
-             handle non-ASCII font names.  */
-          char * name = SDATA (family);
-          strncpy (font_match_pattern->lfFaceName, name, LF_FACESIZE);
-          font_match_pattern->lfFaceName[LF_FACESIZE - 1] = '\0';
-
-          EnumFontFamiliesEx (dc, font_match_pattern,
-                              (FONTENUMPROC) add_font_entity_to_list,
-                              (LPARAM)&list, 0);
-        }
+      if (NILP (family))
+        continue;
+      else if (STRINGP (family))
+        name = SDATA (family);
+      else
+        name = SDATA (SYMBOL_NAME (family)); 
+
+      strncpy (match_data->pattern.lfFaceName, name, LF_FACESIZE);
+      match_data->pattern.lfFaceName[LF_FACESIZE - 1] = '\0';
+
+      EnumFontFamiliesEx (dc, &match_data->pattern,
+                          (FONTENUMPROC) add_font_entity_to_list,
+                          (LPARAM) match_data, 0);
     }
 
   release_frame_dc (f, dc);
 }
 
-static int
-unicode_range_for_char (c)
-     unsigned c;
+/* Return a list of all the scripts that the font supports.  */
+static Lisp_Object
+font_supported_scripts (FONTSIGNATURE * sig)
 {
-  /* Is there really no Windows API function for this?!!! */
-  if (c < 0x80)
-    return 0;              // Basic Latin
-  else if (c < 0x100)
-    return 1;              // Latin-1 supplement
-  else if (c < 0x180)
-    return 2;              // Latin Extended-A
-  else if (c < 0x250)
-    return 3;              // Latin Extended-B
-  else if (c < 0x2B0)
-    return 4;              // IPA Extensions
-  else if (c < 0x300)
-    return 5;              // Spacing modifiers
-  else if (c < 0x370)
-    return 6;              // Combining diacritical marks
-  else if (c < 0x400)
-    return 7;              // Greek and Coptic
-  else if (c < 0x530)
-    return 9;              // Cyrillic, Cyrillic supplementary
-  else if (c < 0x590)
-    return 10;             // Armenian
-  else if (c < 0x600)
-    return 11;             // Hebrew
-  else if (c < 0x700)
-    return 13;             // Arabic
-  else if (c < 0x750)
-    return 71;             // Syriac
-  else if (c < 0x780)
-    return 13;             // Arabic supplement
-  else if (c < 0x7c0)
-    return 72;             // Thaana
-  else if (c < 0x800)
-    return 14;             // N'Ko
-  else if (c < 0x900)
-    return -1;             // Unsupported range
-  else if (c < 0x980)
-    return 15;             // Devanagari
-  else if (c < 0xA00)
-    return 16;             // Bengali
-  else if (c < 0xA80)
-    return 17;             // Gurmukhi
-  else if (c < 0xB00)
-    return 18;             // Gujarati
-  else if (c < 0xB80)
-    return 19;             // Oriya
-  else if (c < 0xC00)
-    return 20;             // Tamil
-  else if (c < 0xC80)
-    return 21;             // Telugu
-  else if (c < 0xD00)
-    return 22;             // Kannada
-  else if (c < 0xD80)
-    return 23;             // Malayalam
-  else if (c < 0xE00)
-    return 73;             // Sinhala
-  else if (c < 0xE80)
-    return 24;             // Thai
-  else if (c < 0xF00)
-    return 25;             // Lao
-  else if (c < 0x1000)
-    return 70;             // Tibetan
-  else if (c < 0x10A0)
-    return 74;             // Myanmar
-  else if (c < 0x1100)
-    return 26;             // Georgian
-  else if (c < 0x1200)
-    return 28;             // Hangul Jamo
-  else if (c < 0x13A0)
-    return 75;             // Ethiopic, Ethiopic Supplement
-  else if (c < 0x1400)
-    return 76;             // Cherokee
-  else if (c < 0x1680)
-    return 77;             // Unified Canadian Aboriginal Syllabics
-  else if (c < 0x16A0)
-    return 78;             // Ogham
-  else if (c < 0x1700)
-    return 79;             // Runic
-  else if (c < 0x1780)
-    return 84;             // Tagalog, Hanunoo, Buhid, Tagbanwa
-  else if (c < 0x1800)
-    return 80;             // Khmer
-  else if (c < 0x18B0)
-    return 81;             // Mongolian
-  else if (c < 0x1900)
-    return -1;             // Unsupported range
-  else if (c < 0x1950)
-    return 93;             // Limbu
-  else if (c < 0x1980)
-    return 94;             // Tai Le
-  else if (c < 0x19E0)
-    return 95;             // New Tai Le
-  else if (c < 0x1A00)
-    return 80;             // Khmer Symbols
-  else if (c < 0x1A20)
-    return 96;             // Buginese
-  else if (c < 0x1B00)
-    return -1;             // Unsupported range
-  else if (c < 0x1B80)
-    return 27;             // Balinese
-  else if (c < 0x1D00)
-    return -1;             // Unsupported range
-  else if (c < 0x1DC0)
-    return 4;              // Phonetic extensions + supplement
-  else if (c < 0x1E00)
-    return 6;              // Combining diacritical marks supplement
-  else if (c < 0x1F00)
-    return 29;             // Latin Extended additional
-  else if (c < 0x2000)
-    return 30;             // Greek Extended
-  else if (c < 0x2070)
-    return 31;             // General Punctuation
-  else if (c < 0x20A0)
-    return 32;             // Subscripts and Superscripts
-  else if (c < 0x20D0)
-    return 33;             // Currency symbols
-  else if (c < 0x2100)
-    return 34;             // Combining marks for diacriticals
-  else if (c < 0x2150)
-    return 35;             // Letterlike symbols
-  else if (c < 0x2190)
-    return 36;             // Number forms
-  else if (c < 0x2200)
-    return 37;             // Arrows
-  else if (c < 0x2300)
-    return 38;             // Mathematical operators
-  else if (c < 0x2400)
-    return 39;             // Miscellaneous technical
-  else if (c < 0x2440)
-    return 40;             // Control pictures
-  else if (c < 0x2460)
-    return 41;             // Optical character recognition
-  else if (c < 0x2500)
-    return 42;             // Enclosed alphanumerics
-  else if (c < 0x2580)
-    return 43;             // Box drawing
-  else if (c < 0x25A0)
-    return 44;             // Block elements
-  else if (c < 0x2600)
-    return 45;             // Geometric shapes
-  else if (c < 0x2700)
-    return 46;             // Miscellaneous symbols
-  else if (c < 0x27C0)
-    return 47;             // Dingbats
-  else if (c < 0x27F0)
-    return 38;             // Misc Math symbols-A
-  else if (c < 0x2800)
-    return 37;             // Supplemental arrows-A
-  else if (c < 0x2900)
-    return 82;             // Braille patterns
-  else if (c < 0x2980)
-    return 37;             // Supplemental arrows-B
-  else if (c < 0x2B00)
-    return 38;             // Misc Math symbols-B, Supplemental Math operators
-  else if (c < 0x2C00)
-    return 37;             // Misc Symbols and Arrows
-  else if (c < 0x2C60)
-    return 97;             // Galgolitic
-  else if (c < 0x2C80)
-    return 29;             // Latin Extended-C
-  else if (c < 0x2D00)
-    return 8;              // Coptic
-  else if (c < 0x2D30)
-    return 26;             // Georgian supplement
-  else if (c < 0x2D80)
-    return 98;             // Tifinagh
-  else if (c < 0x2DE0)
-    return 75;             // Ethiopic extended
-  else if (c < 0x2E00)
-    return -1;             // Unsupported range
-  else if (c < 0x2E80)
-    return 31;             // Supplemental punctuation
-  else if (c < 0x2FE0)
-    return 59;             // CJK radicals supplement, Kangxi radicals
-  else if (c < 0x2FF0)
-    return -1;             // Unsupported range
-  else if (c < 0x3000)
-    return 59;             // Ideographic description characters
-  else if (c < 0x3040)
-    return 48;             // CJK symbols and punctuation
-  else if (c < 0x30A0)
-    return 49;             // Hiragana
-  else if (c < 0x3100)
-    return 50;             // Katakana
-  else if (c < 0x3130)
-    return 51;             // Bopomofo
-  else if (c < 0x3190)
-    return 52;             // Hangul compatibility Jamo
-  else if (c < 0x31A0)
-    return 59;             // Kanbun
-  else if (c < 0x31C0)
-    return 51;             // Bopomofo extended
-  else if (c < 0x31F0)
-    return 61;             // CJK strokes
-  else if (c < 0x3200)
-    return 50;             // Katakana phonetic extensions
-  else if (c < 0x3300)
-    return 54;             // CJK enclosed letters and months
-  else if (c < 0x3400)
-    return 55;             // CJK compatibility
-  else if (c < 0x4DC0)
-    return 59;             // CJK unified ideographs extension-A
-  else if (c < 0x4E00)
-    return 99;             // Yijing Hexagram Symbols
-  else if (c < 0xA000)
-    return 59;             // CJK unified ideographs
-  else if (c < 0xA4D0)
-    return 83;             // Yi syllables, Yi radicals
-  else if (c < 0xA700)
-    return -1;             // Unsupported range
-  else if (c < 0xA720)
-    return 5;              // Modifier tone letters
-  else if (c < 0xA800)
-    return 29;             // Latin Extended-D
-  else if (c < 0xA830)
-    return 100;            // Syloti Nagri
-  else if (c < 0xA840)
-    return -1;             // Unsupported range
-  else if (c < 0xA880)
-    return 53;             // Phags-pa
-  else if (c < 0xAC00)
-    return -1;             // Unsupported range
-  else if (c < 0xD7A4)
-    return 56;             // Hangul syllables
-  else if (c < 0xD800)
-    return -1;             // Unsupported range
-  else if (c < 0xE000)
-    return 57;             // Surrogates
-  else if (c < 0xF900)
-    return 60;             // Private use (plane 0)
-  else if (c < 0xFB00)
-    return 61;             // CJK Compatibility ideographs
-  else if (c < 0xFB50)
-    return 62;             // Alphabetic Presentation Forms
-  else if (c < 0xFE00)
-    return 63;             // Arabic Presentation Forms-A
-  else if (c < 0xFE10)
-    return 91;             // Variation selectors
-  else if (c < 0xFE20)
-    return 65;             // Vertical forms
-  else if (c < 0xFE30)
-    return 64;             // Combining half marks
-  else if (c < 0xFE50)
-    return 65;             // CJK compatibility forms
-  else if (c < 0xFE70)
-    return 66;             // Small form variants
-  else if (c < 0xFEFF)
-    return 67;             // Arabic Presentation Forms-B
-  else if (c == 0xFEFF)
-    return -1;             // Unsupported range
-  else if (c < 0xFFF0)
-    return 68;             // Halfwidth and fullwidth forms
-  else if (c <= 0xFFFF)
-    return 69;             // Specials
-
-  // If int is 64 bit, it could represent characters from 10000 up, but 
-  // any font that handles them should have the surrogate bit set (57).
-  return 57;
+  DWORD * subranges = sig->fsUsb;
+  Lisp_Object supported = Qnil;
+
+  /* Match a single subrange. SYM is set if bit N is set in subranges.  */
+#define SUBRANGE(n,sym) \
+  if (subranges[(n) / 32] & (1 << ((n) % 32))) \
+    supported = Fcons ((sym), supported)
+
+  /* Match multiple subranges. SYM is set if any MASK bit is set in
+     subranges[0 - 3].  */
+#define MASK_ANY(mask0,mask1,mask2,mask3,sym)      \
+  if ((subranges[0] & (mask0)) || (subranges[1] & (mask1))     \
+      || (subranges[2] & (mask2)) || (subranges[3] & (mask3))) \
+    supported = Fcons ((sym), supported)
+
+  SUBRANGE (0, Qlatin); /* There are many others... */
+
+  SUBRANGE (7, Qgreek);
+  SUBRANGE (8, Qcoptic);
+  SUBRANGE (9, Qcyrillic);
+  SUBRANGE (10, Qarmenian);
+  SUBRANGE (11, Qhebrew);
+  SUBRANGE (13, Qarabic);
+  SUBRANGE (14, Qnko);
+  SUBRANGE (15, Qdevanagari);
+  SUBRANGE (16, Qbengali);
+  SUBRANGE (17, Qgurmukhi);
+  SUBRANGE (18, Qgujarati);
+  SUBRANGE (19, Qoriya);
+  SUBRANGE (20, Qtamil);
+  SUBRANGE (21, Qtelugu);
+  SUBRANGE (22, Qkannada);
+  SUBRANGE (23, Qmalayalam);
+  SUBRANGE (24, Qthai);
+  SUBRANGE (25, Qlao);
+  SUBRANGE (26, Qgeorgian);
+
+  SUBRANGE (48, Qcjk_misc);
+  SUBRANGE (51, Qbopomofo);
+  SUBRANGE (54, Qkanbun); /* Is this right?  */
+  SUBRANGE (56, Qhangul);
+
+  SUBRANGE (59, Qhan); /* There are others, but this is the main one.  */
+  SUBRANGE (59, Qideographic_description); /* Windows lumps this in  */
+
+  SUBRANGE (70, Qtibetan);
+  SUBRANGE (71, Qsyriac);
+  SUBRANGE (72, Qthaana);
+  SUBRANGE (73, Qsinhala);
+  SUBRANGE (74, Qmyanmar);
+  SUBRANGE (75, Qethiopic);
+  SUBRANGE (76, Qcherokee);
+  SUBRANGE (77, Qcanadian_aboriginal);
+  SUBRANGE (78, Qogham);
+  SUBRANGE (79, Qrunic);
+  SUBRANGE (80, Qkhmer);
+  SUBRANGE (81, Qmongolian);
+  SUBRANGE (82, Qbraille);
+  SUBRANGE (83, Qyi);
+
+  SUBRANGE (88, Qbyzantine_musical_symbol);
+  SUBRANGE (88, Qmusical_symbol); /* Windows doesn't distinguish these.  */
+
+  SUBRANGE (89, Qmathematical);
+
+  /* Match either katakana or hiragana for kana.  */
+  MASK_ANY (0, 0x00060000, 0, 0, Qkana);
+
+  /* There isn't really a main symbol range, so include symbol if any
+     relevant range is set.  */
+  MASK_ANY (0x8000000, 0x0000FFFF, 0, 0, Qsymbol);
+
+#undef SUBRANGE
+#undef MASK_ANY
+
+  return supported;
 }
 
 
@@ -1152,19 +1254,6 @@ struct font_driver w32font_driver =
     NULL /* otf_drive */
   };
 
-/* Initialize the font subsystem for the environment on which
-   Emacs is running.   */
-void
-w32font_initialize ()
-{
-  /* Load functions that might not exist on older versions of Windows.  */
-  HANDLE gdi = LoadLibrary ("gdi32.dll");
-
-  get_glyph_indices_fn
-    = (GETGLYPHINDICES) GetProcAddress (gdi, "GetGlyphIndicesW");
-  get_text_extent_pointi_fn
-    = (GETTEXTEXTENTPTI) GetProcAddress (gdi, "GetTextExtentPoint32W");
-}
 
 /* Initialize state that does not change between invocations. This is only
    called when Emacs is dumped.  */
@@ -1172,13 +1261,73 @@ void
 syms_of_w32font ()
 {
   DEFSYM (Qw32, "w32");
-  DEFSYM (Qdecorative, "decorative");
-  DEFSYM (Qmodern, "modern");
-  DEFSYM (Qroman, "roman");
+
+  /* Generic font families.  */
+  DEFSYM (Qmonospace, "monospace");
+  DEFSYM (Qserif, "serif");
+  DEFSYM (Qsans_serif, "sans-serif");
   DEFSYM (Qscript, "script");
-  DEFSYM (Qswiss, "swiss");
+  DEFSYM (Qdecorative, "decorative");
+  /* Aliases.  */
+  DEFSYM (Qsans__serif, "sans_serif");
+  DEFSYM (Qsans, "sans");
+  DEFSYM (Qmono, "mono");
+
+  /* Fake foundries.  */
+  DEFSYM (Qraster, "raster");
+  DEFSYM (Qoutline, "outline");
   DEFSYM (Qunknown, "unknown");
-  DEFSYM (QCsubranges, ":subranges");
+
+  /* Indexes for extra info.  */
+  DEFSYM (QCfamily, ":family");
+
+  /* Scripts  */
+  DEFSYM (Qlatin, "latin");
+  DEFSYM (Qgreek, "greek");
+  DEFSYM (Qcoptic, "coptic");
+  DEFSYM (Qcyrillic, "cyrillic");
+  DEFSYM (Qarmenian, "armenian");
+  DEFSYM (Qhebrew, "hebrew");
+  DEFSYM (Qarabic, "arabic");
+  DEFSYM (Qsyriac, "syriac");
+  DEFSYM (Qnko, "nko");
+  DEFSYM (Qthaana, "thaana");
+  DEFSYM (Qdevanagari, "devanagari");
+  DEFSYM (Qbengali, "bengali");
+  DEFSYM (Qgurmukhi, "gurmukhi");
+  DEFSYM (Qgujarati, "gujarati");
+  DEFSYM (Qoriya, "oriya");
+  DEFSYM (Qtamil, "tamil");
+  DEFSYM (Qtelugu, "telugu");
+  DEFSYM (Qkannada, "kannada");
+  DEFSYM (Qmalayalam, "malayalam");
+  DEFSYM (Qsinhala, "sinhala");
+  DEFSYM (Qthai, "thai");
+  DEFSYM (Qlao, "lao");
+  DEFSYM (Qtibetan, "tibetan");
+  DEFSYM (Qmyanmar, "myanmar");
+  DEFSYM (Qgeorgian, "georgian");
+  DEFSYM (Qhangul, "hangul");
+  DEFSYM (Qethiopic, "ethiopic");
+  DEFSYM (Qcherokee, "cherokee");
+  DEFSYM (Qcanadian_aboriginal, "canadian-aboriginal");
+  DEFSYM (Qogham, "ogham");
+  DEFSYM (Qrunic, "runic");
+  DEFSYM (Qkhmer, "khmer");
+  DEFSYM (Qmongolian, "mongolian");
+  DEFSYM (Qsymbol, "symbol");
+  DEFSYM (Qbraille, "braille");
+  DEFSYM (Qhan, "han");
+  DEFSYM (Qideographic_description, "ideographic-description");
+  DEFSYM (Qcjk_misc, "cjk-misc");
+  DEFSYM (Qkana, "kana");
+  DEFSYM (Qbopomofo, "bopomofo");
+  DEFSYM (Qkanbun, "kanbun");
+  DEFSYM (Qyi, "yi");
+  DEFSYM (Qbyzantine_musical_symbol, "byzantine-musical-symbol");
+  DEFSYM (Qmusical_symbol, "musical-symbol");
+  DEFSYM (Qmathematical, "mathematical");
+
   w32font_driver.type = Qw32;
   register_font_driver (&w32font_driver, NULL);
 }