--- rxvt-unicode/src/rxvtfont.C	2010/03/30 23:36:14	1.156
+++ rxvt-unicode/src/rxvtfont.C	2010/12/30 18:19:38	1.172
@@ -28,6 +28,10 @@
 
 #include <inttypes.h>
 
+#if XFT
+# include <fontconfig/fontconfig.h>
+#endif
+
 #define MAX_OVERLAP_ROMAN  (8 + 2)	// max. character width in 8ths of the base width
 #define MAX_OVERLAP_ITALIC (8 + 3)	// max. overlap for italic fonts
 
@@ -37,7 +41,7 @@
     : ((prop)->width * (wcw) * MAX_OVERLAP_ROMAN  + 7) >> 3	\
   ))
 
-const struct rxvt_fallback_font {
+static const struct rxvt_fallback_font {
   codeset cs;
   const char *name;
 } fallback_fonts[] = {
@@ -157,8 +161,6 @@
   0x304c, 0x672c,				// が本
 };
 
-#define NUM_EXTENT_TEST_CHARS (sizeof (extent_test_chars) / sizeof (extent_test_chars[0]))
-
 #define dTermDisplay Display *disp = term->dpy
 #define dTermGC      GC gc = term->gc
 
@@ -450,7 +452,7 @@
           chrs [1] = NOCHAR;
 
           *chrs = cc->c1;
-          rxvt_font *f1 = fs->get (cc->c1);
+          rxvt_font *f1 = (*fs)[fs->find_font_idx (cc->c1)];
           f1->draw (d, x, y, chrs, width, fg, bg);
 
           if (cc->c2 != NOCHAR)
@@ -461,7 +463,7 @@
               *chrs = cc->c2;
               rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)
                                 ? f1
-                                : fs->get (cc->c2);
+                                : (*fs)[fs->find_font_idx (cc->c2)];
 
               f2->draw (d, x, y, chrs, width, fg, Color_none);
             }
@@ -484,6 +486,56 @@
     }
 }
 
+struct rxvt_font_overflow : rxvt_font {
+  struct rxvt_fontset *fs;
+
+  rxvt_font_overflow (rxvt_fontset *fs)
+  : rxvt_font ()
+  {
+    this->fs = fs;
+  }
+
+  rxvt_fontprop properties ()
+  {
+    rxvt_fontprop p;
+
+    p.width = p.height = 1;
+    p.ascent = rxvt_fontprop::unset;
+    p.weight = rxvt_fontprop::medium;
+    p.slant = rxvt_fontprop::roman;
+
+    return p;
+  }
+
+  bool load (const rxvt_fontprop &prop, bool force_prop)
+  {
+    width = 1; height = 1;
+    ascent = 1; descent = 0;
+
+    set_name (strdup ("built-in rendition overflow font"));
+
+    return true;
+  }
+
+  bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
+  {
+    return false;
+  }
+
+  void draw (rxvt_drawable &d, int x, int y,
+             const text_t *text, int len,
+             int fg, int bg)
+  {
+    while (len--)
+      {
+        int fid = fs->find_font_idx (*text);
+        (*fs)[fid]->draw (d, x, y, text, 1, fg, bg);
+        ++text;
+        x += term->fwidth;
+      }
+  }
+};
+
 /////////////////////////////////////////////////////////////////////////////
 
 struct rxvt_font_x11 : rxvt_font {
@@ -501,7 +553,7 @@
              const text_t *text, int len,
              int fg, int bg);
 
-  bool slow; // wether this is a proportional font or has other funny characteristics
+  bool slow; // whether this is a proportional font or has other funny characteristics
   XFontStruct *f;
   bool enc2b, encm;
 
@@ -668,12 +720,12 @@
           if (!f)
             return false;
 
-          char *new_name = get_property (f, XA_FONT, name);
+          char *new_name = get_property (f, XA_FONT, 0);
 
           if (new_name)
             set_name (new_name);
           else
-            rxvt_warn ("font '%s' has no FONT property, continuing without.", name);
+            rxvt_warn ("font '%s' has no FONT property, continuing without.\n", name);
 
           XFreeFont (disp, f);
           f = 0;
@@ -740,12 +792,14 @@
             diff += 300; // more heavily penalize what looks like scaled bitmap fonts
         }
 
-      if (!set_properties (p, fname))
-        continue;
-
-      if (prop.height != rxvt_fontprop::unset
-          && p.height > prop.height) // weed out too large fonts
-        continue;
+      if (!set_properties (p, fname)
+          // also weed out too large fonts
+          || (prop.height != rxvt_fontprop::unset
+              && p.height > prop.height))
+        {
+          free (fname);
+          continue;
+        }
 
       if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;
       if (prop.weight != rxvt_fontprop::unset) diff += abs (prop.weight - p.weight);
@@ -812,7 +866,8 @@
 
   if (cs == CS_UNKNOWN)
     {
-      const char *charset = get_property (f, XA_FONT, 0);
+      char *value = get_property (f, XA_FONT, 0);
+      const char *charset = value;
 
       if (!charset)
         charset = name;
@@ -825,6 +880,8 @@
       cs = codeset_from_name (charset);
       if (cs == CS_UNKNOWN)
         rxvt_warn ("%s: cannot deduce encoding from font name property \"%s\", ignoring font.\n", name, charset);
+
+      free (value);
     }
 
   if (cs == CS_UNKNOWN)
@@ -866,7 +923,7 @@
 
   width = 1;
 
-  for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )
+  for (uint16_t *t = extent_test_chars + ARRAY_LENGTH(extent_test_chars); t-- > extent_test_chars; )
     {
       if (FROM_UNICODE (cs, *t) == NOCHAR)
         continue;
@@ -917,7 +974,7 @@
   if (ch == NOCHAR)
     return false;
 
-  /* check wether the character exists in _this_ font. horrible. */
+  /* check whether the character exists in _this_ font. horrible. */
   XCharStruct *xcs;
 
   if (encm)
@@ -957,7 +1014,7 @@
   if (!prop || prop->width == rxvt_fontprop::unset)
     return true;
 
-  // check wether character overlaps previous/next character
+  // check whether character overlaps previous/next character
   int w = xcs->rbearing - xcs->lbearing;
   int wcw = max (WCWIDTH (unicode), 1);
 
@@ -1184,7 +1241,7 @@
 
       int glheight = height;
 
-      for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )
+      for (uint16_t *t = extent_test_chars + ARRAY_LENGTH(extent_test_chars); t-- > extent_test_chars; )
         {
           FcChar16 ch = *t;
 
@@ -1355,7 +1412,7 @@
             {
               int src_x = x, src_y = y;
 
-              if (term->bgPixmap.is_parentOrigin ())
+              if (term->bgPixmap.flags & bgPixmap_t::isTransparent)
                 {
                   src_x += term->window_vt_x;
                   src_y += term->window_vt_y;
@@ -1434,7 +1491,7 @@
   force_prop = false;
 
   for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
-    FONT_UNREF (*i);
+    (*i)->unref ();
 
   for (pagemap **p = fmap.begin (); p != fmap.end (); p++)
     delete *p;
@@ -1446,6 +1503,15 @@
   fallback = fallback_fonts;
 }
 
+void
+rxvt_fontset::prepare_font (rxvt_font *font, codeset cs)
+{
+  font->set_term (term);
+
+  font->cs = cs;
+  font->loaded = false;
+}
+
 rxvt_font *
 rxvt_fontset::new_font (const char *name, codeset cs)
 {
@@ -1471,11 +1537,8 @@
   else
     f = new rxvt_font_x11;
 
-  f->set_term (term);
   f->set_name (strdup (name));
-
-  f->cs = cs;
-  f->loaded = false;
+  prepare_font (f, cs);
 
   return f;
 }
@@ -1483,6 +1546,23 @@
 /////////////////////////////////////////////////////////////////////////////
 
 void
+rxvt_fontset::push_font (rxvt_font *font)
+{
+  // the fontCount index is reserved for the overflow font, it is only
+  // necessary when we get fontCount or more fonts, as they cannot be
+  // represented in the rendition.
+  if (fonts.size () == fontCount)
+    {
+      rxvt_font *f = new rxvt_font_overflow (this);
+
+      prepare_font (f, CS_UNICODE);
+      fonts.push_back (f);
+    }
+
+  fonts.push_back (font);
+}
+
+void
 rxvt_fontset::add_fonts (const char *desc)
 {
   if (desc)
@@ -1531,7 +1611,7 @@
               memcpy (buf, desc, end - desc);
               buf[end - desc] = 0;
 
-              fonts.push_back (new_font (buf, cs));
+              push_font (new_font (buf, cs));
             }
           else
             rxvt_warn ("fontset element too long (>511 bytes), ignored.");
@@ -1569,7 +1649,7 @@
 
   fontdesc = strdup (desc);
 
-  fonts.push_back (new_font (0, CS_UNICODE));
+  push_font (new_font (0, CS_UNICODE));
   realize_font (0);
 
   add_fonts (desc);
@@ -1588,23 +1668,17 @@
 }
 
 int
-rxvt_fontset::find_font_idx (unicode_t unicode, bool &careful)
+rxvt_fontset::find_font_idx (unicode_t unicode)
 {
   if (unicode >= 1<<20)
     return 0;
 
   unicode_t hi = unicode >> 8;
 
-  if (hi < fmap.size () && fmap[hi])
-    {
-      unsigned char m = (*fmap[hi])[unicode & 0xff];
-
-      if (m != 0xff)
-        {
-          careful = m & 128;
-          return m & 127;
-        }
-    }
+  if (hi < fmap.size ()
+      && fmap[hi]
+      && (*fmap[hi])[unicode & 0xff] != 0xff)
+    return (*fmap[hi])[unicode & 0xff];
 
   unsigned int i;
 
@@ -1627,8 +1701,13 @@
       if (f->cs == CS_UNKNOWN)
         goto next_font;
 
+      bool careful;
       if (f->has_char (unicode, &prop, careful))
-        goto found;
+        {
+          i = (i << 1) | careful;
+
+          goto found;
+        }
 
     next_font:
       if (i == fonts.size () - 1)
@@ -1636,7 +1715,7 @@
           if (fallback->name)
             {
               // search through the fallback list
-              fonts.push_back (new_font (fallback->name, fallback->cs));
+              push_font (new_font (fallback->name, fallback->cs));
               fallback++;
             }
           else
@@ -1679,7 +1758,7 @@
                       char fontname[4096];
                       snprintf (fontname, sizeof (fontname), "xft:%s", font);
 
-                      fonts.push_back (new_font (fontname, CS_UNICODE));
+                      push_font (new_font (fontname, CS_UNICODE));
                     }
 
                   free (font);
@@ -1691,7 +1770,6 @@
 
   /* we must return SOME font */
   i = 0;
-  careful = false;
 
 found:
   // found a font, cache it
@@ -1706,18 +1784,9 @@
           memset (fmap[hi], 0xff, sizeof (pagemap));
         }
 
-      (*fmap[hi])[unicode & 0xff] = i | (careful ? 128 : 0);
+      (*fmap[hi])[unicode & 0xff] = i;
     }
 
   return i;
 }
 
-int
-rxvt_fontset::find_font (unicode_t unicode)
-{
-  bool careful;
-  int id = find_font_idx (unicode, careful);
-
-  return min<int> (fontCount, id) | (careful ? Careful : 0);
-}
-