--- rxvt-unicode/src/defaultfont.C	2003/11/25 15:25:17	1.2
+++ rxvt-unicode/src/defaultfont.C	2003/12/18 04:27:36	1.8
@@ -23,6 +23,8 @@
 #include "rxvt.h"
 #include "defaultfont.h"
 
+#include <cstdlib>
+
 #define DISPLAY  r->Xdisplay
 #define DRAWABLE r->TermWin.vt
 #define GC       r->TermWin.gc
@@ -59,7 +61,7 @@
 #if ENCODING_JP || ENCODING_JP_EXT
 # if XFT
   // prefer xft for complex scripts
-  { CS_UNICODE,        "xft:Kochi Gothic"                     },
+  { CS_UNICODE,        "xft:Kochi Gothic:antialias=false"     },
 # endif
   { CS_JIS0201_1976_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0201*-0" },
   { CS_JIS0208_1983_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0208*-0" },
@@ -170,8 +172,70 @@
     }
 }
 
+static const char *linedraw_cmds[128] = {
+  "1hH", "2hH", "1vV", "2vV",
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+  "1HV", "2H1V", "1H2V", "2HV",
+
+  // 2510
+  "1hV", "2h1V", "1h2V", "2hV",
+  "1Hv", "2H1v", "1H2v", "2Hv",
+  "1hv", "2h1v", "1h2v", "2hv",
+  "1HvV", "2H1vV", "1HV2v", "1Hv2V",
+
+  // 2520
+  "1H2vV", "2Hv1V", "2HV1v", "2HvV",
+  "1hvV", "2h1vV", "1hV2v", "1hv2V",
+  "1h2vV", "2hv1V", "1v2hV", "2hvV",
+  "1hHV", "2h1HV", "2H1hV", "2hH1V",
+
+  // 2530
+  "1hH2V", "2hV1H", "1h2HV", "2hHV",
+  "1hHv", "1vH2h", "1hv2H", "1v2hH",
+  "1hH2v", "1H2hv", "1h2Hv", "2hHv",
+  "1hHvV", "1vVH2h", "1hvV2H", "1vV2hH",
+
+  // 2540
+  "1hHV2v", "1hHv2V", "1hH2vV", "1HV2hv",
+  "1hV2Hv", "1Hv2hV", "1hv2HV", "1V2hHv",
+  "1v2hHV", "1H2hvV", "1h2HvV", "2hHvV",
+  0, 0, 0, 0,
+
+  // 2550
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+
+  // 2560
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+  0, 0, 0, 0,
+
+  // 2570
+  0, "1a", "1b", "1ab",
+  "1h", "1v", "1H", "1V",
+  "2h", "2v", "2H", "2V",
+  "1h2H", "1v2V", "1H2h", "1V2v"
+
+  // to be done
+};
+
 struct rxvt_font_default : rxvt_font {
-  bool load (int maxheight)
+  rxvt_fontprop properties ()
+  {
+    rxvt_fontprop p;
+
+    p.height = 1;
+    p.weight = rxvt_fontprop::medium;
+    p.slant = rxvt_fontprop::roman;
+
+    return p;
+  }
+
+  bool load (const rxvt_fontprop &prop)
   {
     width = 1; height = 1;
     ascent = 1; descent = 0;
@@ -181,8 +245,13 @@
 
   bool has_codepoint (uint32_t unicode)
   {
-    if (unicode <= 0x001f
-        || (unicode >= 0x80 && unicode <= 0x9f))
+    if (unicode <= 0x001f)
+      return true;
+    if (unicode >= 0x0080 && unicode <= 0x009f)
+      return true;
+
+    if (unicode >= 0x2500 && unicode <= 0x257f
+        && linedraw_cmds[unicode - 0x2500])
       return true;
 
     switch (unicode)
@@ -206,17 +275,56 @@
 {
   clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
 
+  XSetForeground (DISPLAY, GC, r->PixColors[fg]);
+
   while (len--)
     {
-      switch (*text++)
+      text_t t = *text++;
+
+      if (t >= 0x2500 & t <= 0x2580 && linedraw_cmds[t - 0x2500])
         {
-          case NOCHAR:
-          case ZERO_WIDTH_CHAR:
-            break;
-          default:
-            XSetForeground (DISPLAY, GC, r->PixColors[fg]);
-            XDrawRectangle (DISPLAY, DRAWABLE, GC, x + 2, y + 2, r->TermWin.fwidth - 5, r->TermWin.fheight - 5);
+          const char *p = linedraw_cmds[t - 0x2500];
+
+          int x0 = x, x1 = x + r->TermWin.fwidth  / 2, x2 = x + r->TermWin.fwidth ;
+          int y0 = y, y1 = y + r->TermWin.fheight / 2, y2 = y + r->TermWin.fheight;
+
+          XGCValues gcv;
+
+          while (*p)
+            {
+              switch (*p++)
+                {
+                  case '1':
+                    gcv.line_width = 0;
+                    XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);
+                    break;
+
+                  case '2':
+                    gcv.line_width = 2;
+                    XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);
+                    break;
+
+                  case 'h': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y1, x1, y1); break;
+                  case 'H': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y1, x2, y1); break;
+                  case 'v': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y0, x1, y1); break;
+                  case 'V': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y1, x1, y2); break;
+                  case 'a': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y2, x2, y0); break;
+                  case 'b': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y0, x2, y2); break;
+                }
+            }
+
+          gcv.line_width = 0;
+          XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);
         }
+      else
+        switch (*text++)
+          {
+            case NOCHAR:
+            case ZERO_WIDTH_CHAR:
+              break;
+            default:
+              XDrawRectangle (DISPLAY, DRAWABLE, GC, x + 2, y + 2, r->TermWin.fwidth - 5, r->TermWin.fheight - 5);
+          }
 
       x += r->TermWin.fwidth;
     }
@@ -229,7 +337,10 @@
 
   void clear ();
 
-  bool load (int maxheight);
+  rxvt_fontprop properties ();
+  rxvt_fontprop properties (XFontStruct *f);
+
+  bool load (const rxvt_fontprop &prop);
 
   bool has_codepoint (uint32_t unicode);
 
@@ -241,11 +352,11 @@
   codeset cs;
   bool enc2b, encm;
 
-  const char *get_property (const char *property, const char *repl) const;
+  const char *get_property (XFontStruct *f, const char *property, const char *repl) const;
 };
 
 const char *
-rxvt_font_x11::get_property (const char *property, const char *repl) const
+rxvt_font_x11::get_property (XFontStruct *f, const char *property, const char *repl) const
 {
   unsigned long value;
 
@@ -255,11 +366,66 @@
     return repl;
 }
 
+rxvt_fontprop
+rxvt_font_x11::properties ()
+{
+  return properties (f);
+}
+
+rxvt_fontprop
+rxvt_font_x11::properties (XFontStruct *f)
+{
+  rxvt_fontprop p;
+
+  const char *weight = get_property (f, "WEIGHT_NAME", "medium");
+  const char *slant  = get_property (f, "SLANT", "r");
+
+  p.height = height;
+  p.weight = *weight == 'B' || *weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;
+  p.slant = *slant == 'r' || *slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;
+
+  return p;
+}
+
 bool
-rxvt_font_x11::load (int maxheight)
+rxvt_font_x11::load (const rxvt_fontprop &prop)
 {
   clear ();
 
+  char **list;
+  int count;
+  XFontStruct *info;
+  list = XListFontsWithInfo (DISPLAY, name, 128, &count, &info);
+
+  if (!list)
+    return false;
+
+  int bestdiff = 0x7fffffff;
+  XFontStruct *best = 0;
+  for (int i = 0; i < count; i++)
+    {
+      XFontStruct *f = info + i;
+
+      if (f->ascent + f->descent <= prop.height) // weed out too large fonts
+        {
+          rxvt_fontprop p = properties (f);
+          int diff = (prop.height - f->ascent + f->descent) * 32
+                   + abs (prop.weight - p.weight)
+                   + abs (prop.slant  - p.slant );
+
+          if (!best // compare against best found so far
+              || diff < bestdiff)
+            {
+              best = f;
+              bestdiff = diff;
+            }
+        }
+    }
+
+  set_name (strdup (list[best - info]));
+
+  XFreeFontInfo (list, info, count);
+
   f = XLoadQueryFont (DISPLAY, name);
 
   if (!f)
@@ -267,8 +433,8 @@
 
   unsigned long value;
 
-  const char *registry = get_property ("CHARSET_REGISTRY", 0);
-  const char *encoding = get_property ("CHARSET_ENCODING", 0);
+  const char *registry = get_property (f, "CHARSET_REGISTRY", 0);
+  const char *encoding = get_property (f, "CHARSET_ENCODING", 0);
 
   if (registry && encoding)
     {
@@ -279,7 +445,7 @@
     }
   else
     {
-      const char *charset = get_property ("FONT", 0);
+      const char *charset = get_property (f, "FONT", 0);
 
       if (!charset)
         charset = name;
@@ -302,7 +468,7 @@
   descent = f->descent;
   height = ascent + descent;
 
-  prop = false;
+  slow = false;
 
   if (f->min_bounds.width == f->max_bounds.width)
     width = f->min_bounds.width;
@@ -310,7 +476,7 @@
     width = f->max_bounds.width;
   else
     {
-      prop = true;
+      slow = true;
 
       int N = f->max_char_or_byte2 - f->min_char_or_byte2;
 
@@ -405,7 +571,7 @@
   // yet we are trying to be perfect /.
   // but the result still isn't perfect /.
 
-  bool slow = prop
+  bool slow = this->slow
               || width != r->TermWin.fwidth
               || height != r->TermWin.fheight;
 
@@ -520,7 +686,9 @@
 
   void clear ();
 
-  bool load (int maxheight);
+  rxvt_fontprop properties ();
+
+  bool load (const rxvt_fontprop &prop);
 
   void draw (int x, int y,
              const text_t *text, int len,
@@ -562,8 +730,24 @@
 #endif
 }
 
+rxvt_fontprop
+rxvt_font_xft::properties ()
+{
+  rxvt_fontprop p;
+
+  FT_Face face = XftLockFace (f);
+
+  p.height = height;
+  p.weight = face->style_flags & FT_STYLE_FLAG_BOLD ? rxvt_fontprop::bold : rxvt_fontprop::medium;
+  p.slant = face->style_flags & FT_STYLE_FLAG_ITALIC ? rxvt_fontprop::italic : rxvt_fontprop::roman;
+
+  XftUnlockFace (f);
+
+  return p;
+}
+
 bool
-rxvt_font_xft::load (int maxheight)
+rxvt_font_xft::load (const rxvt_fontprop &prop)
 {
 #if 0
   for (int i = 0; i < SWATHCOUNT; i++)
@@ -572,14 +756,40 @@
 
   clear ();
 
-  f = XftFontOpenName (DISPLAY, DefaultScreen (DISPLAY), name);
+  FcPattern *p = FcNameParse ((FcChar8 *) name);
 
-  if (!f)
+  if (!p)
     return false;
 
+  FcValue v;
+
+  if (FcPatternGet (p, FC_WEIGHT, 0, &v) != FcResultMatch)
+    FcPatternAddInteger (p, FC_WEIGHT, prop.weight);
+
+  if (FcPatternGet (p, FC_SLANT, 0, &v) != FcResultMatch)
+    FcPatternAddInteger (p, FC_SLANT, prop.slant);
+
+  //FcPatternAddBool (p, FC_MINSPACE, 1);
+
+  XftResult result;
+  FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);
+
+  FcPatternDestroy (p);
+
+  if (!match)
+    return false;
+
+  f = XftFontOpenPattern (DISPLAY, match);
+
+  if (!f)
+    {
+      FcPatternDestroy (match);
+      return false;
+    }
+
   FT_Face face = XftLockFace (f);
 
-  prop = !FT_IS_FIXED_WIDTH (face);
+  slow = !FT_IS_FIXED_WIDTH (face);
 
   int ftheight = 0;
 
@@ -591,27 +801,28 @@
       c = 'i'; XftTextExtents8 (DISPLAY, f, &c, 1, &g1);
       c = 'W'; XftTextExtents8 (DISPLAY, f, &c, 1, &g2);
 
-      prop = prop || g1.xOff != g2.xOff; // don't simply trust the font
+      if (g1.xOff != g2.xOff) // don't simply trust the font
+        slow = true;
 
       width = g2.xOff;
       ascent = (face->size->metrics.ascender + 63) >> 6;
       descent = (-face->size->metrics.descender + 63) >> 6;
       height = ascent + descent;
 
-      if (height <= maxheight || !maxheight)
+      if (height <= prop.height || !prop.height)
         break;
 
       if (ftheight)
         {
           // take smaller steps near the end
-          if (height > maxheight + 1) ftheight++;
-          if (height > maxheight + 2) ftheight++;
-          if (height > maxheight + 3) ftheight++;
+          if (height > prop.height + 1) ftheight++;
+          if (height > prop.height + 2) ftheight++;
+          if (height > prop.height + 3) ftheight++;
 
-          FT_Set_Pixel_Sizes (face, 0, ftheight -= height - maxheight);
+          FT_Set_Pixel_Sizes (face, 0, ftheight -= height - prop.height);
         }
       else
-        FT_Set_Pixel_Sizes (face, 0, ftheight = maxheight);
+        FT_Set_Pixel_Sizes (face, 0, ftheight = prop.height);
     }
 
   XftUnlockFace (f);
@@ -653,7 +864,7 @@
   else
     clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
 
-  if (!prop && width == r->TermWin.fwidth)
+  if (!slow && width == r->TermWin.fwidth)
     {
       if (sizeof (text_t) == sizeof (FcChar16))
         XftDrawString16 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar16 *)text, len);
@@ -703,7 +914,9 @@
 
   fonts.clear ();
   base_id = 0;
-  height = 0x7fffffff;
+  base_prop.height = 0x7fffffff;
+  base_prop.weight = rxvt_fontprop::medium;
+  base_prop.slant = rxvt_fontprop::roman;
 
   fallback = fallback_fonts;
 }
@@ -798,13 +1011,15 @@
   if (fonts[i]->loaded)
     return true;
 
-  if (fonts[i]->load (height))
-    return fonts[i]->loaded = true;
+  fonts[i]->loaded = true;
 
-  delete fonts[i];
-  fonts.erase (fonts.begin () + i);
+  if (!fonts[i]->load (base_prop))
+    {
+      fonts[i]->cs = CS_UNKNOWN;
+      return false;
+    }
 
-  return false;
+  return true;
 }
 
 void
@@ -821,10 +1036,10 @@
     base_id = 1;
 
   // we currently need a base-font, no matter what
-  if (fonts.size () <= base_id)
+  if (fonts.size () <= base_id || !realize_font (base_id))
     {
       add_fonts ("fixed");
-      base_id = 1;
+      base_id = fonts.size () - 1;
     }
 
   if (fonts.size () <= base_id || !realize_font (base_id))
@@ -833,9 +1048,7 @@
       exit (1);
     }
 
-  height = fonts[base_id]->height;
-
-  /*add_fonts ("-efont-fixed-medium-r-normal-*-14-*-*-*-*-*-iso10646-1,"*/
+  base_prop = fonts[base_id]->properties ();
 }
 
 int
@@ -851,15 +1064,10 @@
             goto next_font;
 
           if (!realize_font (i))
-            {
-              --i;
-              goto next_font;
-            }
-
-          //printf ("added font %s for %04lx\n", f->name, unicode);
+            goto next_font;
         }
 
-      if (f->has_codepoint (unicode))
+      if (f->cs != CS_UNKNOWN && f->has_codepoint (unicode))
         return i;
 
     next_font:
@@ -867,6 +1075,7 @@
         {
           fonts.push_back (new_font (fallback->name, fallback->cs));
           fallback++;
+          i = 0;
         }
     }