- Usage of xft-fonts is prefered, except a font-description starts with '-'

- Removed "antialias"-option completly, to enable/disable "antialias"
  use either  <fontname>:antialias=<bool> in the style or use
  Xft.antialias: <bool> in your .Xdefaults
- Added new styleresources: 
    *.font.effect: <halo|shadow>
    *.font.shadow.x : <int>       - shadow x offset
    *.font.shadow.y : <int>       - shadow y offset
    *.font.shadow.color : <color> - color of shadow
    *.font.halo.color : <color>   - color of halo
- Removed 'shadow' and 'halo' options from fontdefinitions:
    !! Style authors have to update their styles !!
- Simplified XmbFontImp to not try all possible fonts to match locale
- Style authors may specify multiple fonts:
    <font1>|<font2>|<font3>
  if loading of font1 fails, fluxbox probes <font2>, etc. The last font is
  "fixed". Hints for style authors:
    - if xft tries to load a font it will _ALWAYS_ return a valid font,
      it doesnt have to look like the one you want to have, read more
      about it: http://fontconfig.org/fontconfig-user.html
    - export XFT_DEBUG=1  before running fluxbox helps to see
      which fonts are picked.
  eg:
      *.font: Verdana,Arial-12:antialias=true|-artwiz-snap-*-
      if fluxbox is compiled with xft this will NEVER try to
      load "-artwiz-snap-*-" since xft gives for sure a font,
      most likely Verdana or Arial but noone knows. So, if
      fluxbox has no xft support the first fontpattern fails
      and fluxbox tries the next one, which might be successful.
      if everything fails, it will use "fixed"
- Added caching of fonts, fonts are only loaded once.
- Fixed #1090902 (slow utf8 start)

1 files changed, 95 insertions, 166 deletions

diff --git a/src/FbTk/Font.cc b/src/FbTk/Font.cc
index 05dae54..365637d 100644
--- a/src/FbTk/Font.cc
+++ b/src/FbTk/Font.cc
@@ -27,6 +27,7 @@
 #include "Font.hh"
 #include "FontImp.hh"
 #include "I18n.hh"
+#include "App.hh"
 
 #ifdef    HAVE_CONFIG_H
 #include "config.h"
@@ -67,6 +68,7 @@
   #include <stdlib.h>
 #endif
 #include <list>
+#include <map>
 #include <typeinfo>
 #include <langinfo.h>
 
@@ -148,69 +150,15 @@ char *recode(int cd,
 }
 #endif // HAVE_ICONV
 
-int extract_halo_options(const std::string& opts, std::string& color) {
-   std::list< std::string > tokens;
-   size_t sep= opts.find_first_of(':');
+// use to map <font1>|<font2>|<font3> => <fontthatworks>
+typedef std::map<std::string, std::string> StringMap;
+typedef StringMap::iterator StringMapIt;
+StringMap lookup_map;
 
-   if ( sep == std::string::npos )
-       return 1;
-
-   FbTk::StringUtil::stringtok(tokens, opts.substr(sep + 1, opts.length()), ";");
-   tokens.unique();
-   std::list< std::string >::const_iterator token;
-
-   for ( token= tokens.begin(); token != tokens.end(); token++ ) {
-       if ( (*token).find("color=", 0) != std::string::npos ) {
-           size_t s= (*token).find_first_of('=');
-           std::string c= (*token).substr(s + 1, (*token).length());
-           if ( !c.empty() )
-               std::swap(color, c);
-       }
-   }
-
-   return 1;
-}
-
-int extract_shadow_options(const std::string& opts, 
-                           std::string& color, 
-                           int& offx, int& offy) {
-
-   std::list< std::string > tokens;
-   size_t sep= opts.find_first_of(':');
-
-   if ( sep == std::string::npos )
-       return 1;
-
-   FbTk::StringUtil::stringtok(tokens, opts.substr(sep + 1, opts.length()), ";");
-   tokens.unique();
-   std::list< std::string >::const_iterator token;
-
-   for ( token= tokens.begin(); token != tokens.end(); token++ ) {
-       if ( (*token).find("color=", 0) != std::string::npos ) {
-           size_t s= (*token).find_first_of('=');
-           std::string c= (*token).substr(s + 1, (*token).length());
-           if ( !c.empty() )
-               std::swap(color, c);
-       }
-       else if ( (*token).find("offsetx=", 0) != std::string::npos ) {
-           size_t s= (*token).find_first_of('=');
-           FbTk_istringstream o((*token).substr(s + 1, (*token).length()).c_str());
-           if ( !o.eof() ) {
-               o >> offx;
-           }
-       }
-       else if ( (*token).find("offsety=", 0) != std::string::npos ) {
-           size_t s= (*token).find_first_of('=');
-           FbTk_istringstream o((*token).substr(s + 1, (*token).length()).c_str());
-           if ( !o.eof() ) {
-               o >> offy;
-           }
-       }
-   }
-
-   return 1;
-
-};
+// stores <fontthatworks and the fontimp
+typedef std::map<std::string, FbTk::FontImp* > FontCache;
+typedef FontCache::iterator FontCacheIt;
+FontCache font_cache;
 
 }; // end nameless namespace
 
@@ -218,8 +166,8 @@ int extract_shadow_options(const std::string& opts,
 
 namespace FbTk {
 
-bool Font::m_multibyte = false; 
-bool Font::m_utf8mode = false;
+bool Font::s_multibyte = false; 
+bool Font::s_utf8mode = false;
 
 
 void Font::init() {
@@ -229,24 +177,34 @@ void Font::init() {
 
 void Font::shutdown() {
 
+    FontCacheIt fit;
+    for (fit = font_cache.begin(); fit != font_cache.end(); fit++) {
+        FontImp* font = fit->second;
+        if (font) {
+            FontCacheIt it;
+            for (it = fit; it != font_cache.end(); it++)
+                if (it->second == font)
+                    it->second = 0;
+            delete font;
+        }
+    }
 }
 
-Font::Font(const char *name, bool antialias):
+Font::Font(const char *name):
     m_fontimp(0),
-    m_antialias(false), m_rotated(false), 
-    m_shadow(false), m_shadow_color("#000000"), 
-    m_shadow_offx(1), m_shadow_offy(1),
-    m_halo(false), m_halo_color("#ffffff"),
+    m_rotated(false), 
+    m_shadow(false), m_shadow_color("black", DefaultScreen(App::instance()->display())), 
+    m_shadow_offx(2), m_shadow_offy(2),
+    m_halo(false), m_halo_color("white", DefaultScreen(App::instance()->display())),
 #ifdef HAVE_ICONV
     m_iconv((iconv_t)(-1))
 #else
     m_iconv(-1)
 #endif // HAVE_ICONV
 {
-
     // MB_CUR_MAX returns the size of a char in the current locale
     if (MB_CUR_MAX > 1) // more than one byte, then we're multibyte
-        m_multibyte = true;
+        s_multibyte = true;
 
     // check for utf-8 mode
 #ifdef CODESET
@@ -256,7 +214,7 @@ Font::Font(const char *name, bool antialias):
 #endif // CODESET
 
     if (locale_codeset && strcmp("UTF-8", locale_codeset) == 0) {
-        m_utf8mode = true;
+        s_utf8mode = true;
     } else if (locale_codeset != 0) {
         // if locale isn't UTF-8 we try to
         // create a iconv pointer so we can
@@ -272,13 +230,13 @@ Font::Font(const char *name, bool antialias):
             cerr<<"FbTk::Font: code error: from "<<locale_codeset<<" to: UTF-8"<<endl;
             // if we failed with iconv then we can't convert
             // the strings to utf-8, so we disable utf8 mode
-            m_utf8mode = false;
+            s_utf8mode = false;
         } else {
             // success, we can now enable utf8mode 
             // and if antialias is on later we can recode
             // the non utf-8 string to utf-8 and use utf-8 
             // drawing functions
-            m_utf8mode = true;
+            s_utf8mode = true;
         }
 #endif // HAVE_ICONV
     }
@@ -287,23 +245,6 @@ Font::Font(const char *name, bool antialias):
     cerr<<"FbTk::Font m_iconv = "<<(int)m_iconv<<endl;
 #endif // DEBUG
 
-    // create the right font implementation
-    // antialias is prio 1
-#ifdef USE_XFT
-    if (antialias) {
-        m_fontimp.reset(new XftFontImp(0, m_utf8mode));
-    }
-#endif //USE_XFT
-    // if we didn't create a Xft font then create basic font
-    if (m_fontimp.get() == 0) {
-#ifdef USE_XMB
-        if (m_multibyte || m_utf8mode)
-            m_fontimp.reset(new XmbFontImp(0, m_utf8mode));
-        else // basic font implementation
-#endif // USE_XMB
-            m_fontimp.reset(new XFontImp());
-    }
-
     if (name != 0) {
         load(name);
     }
@@ -317,82 +258,68 @@ Font::~Font() {
 #endif // HAVE_ICONV
 }
 
-void Font::setAntialias(bool flag) {
-    bool loaded = m_fontimp->loaded();
-#ifdef USE_XFT
-    if (flag && !isAntialias() && !m_rotated) {
-        m_fontimp.reset(new XftFontImp(m_fontstr.c_str(), m_utf8mode));
-    } else if (!flag && isAntialias()) 
-#endif // USE_XFT
-        {
-#ifdef USE_XMB
-            if (m_multibyte || m_utf8mode)
-                m_fontimp.reset(new XmbFontImp(m_fontstr.c_str(), m_utf8mode));
-            else
-#endif // USE_XMB
-                m_fontimp.reset(new XFontImp(m_fontstr.c_str()));
-        }
-
-    if (m_fontimp->loaded() != loaded) { // if the new font failed to load, fall back to 'fixed'
-        if (!m_fontimp->load("fixed")) {// if that failes too, output warning
-            _FB_USES_NLS;
-            cerr<<_FBTKTEXT(Error, CantFallbackFont, "Warning: can't load fallback font", "Attempt to load the last-resort default font failed")<<" 'fixed'."<<endl;
-        } 
-    }
-    
-    m_antialias = flag;
-}
-
 bool Font::load(const std::string &name) {
 
     if (name.size() == 0)
         return false;
-    // default values for font options
-    m_shadow = false;
-    m_halo = false;
-
-    // everything after ':' is a fontoption
-    // -> extract 'halo' and 'shadow' and
-    // load remaining fname
-    size_t                   sep= name.find_first_of(':');
-
-    if ( sep != std::string::npos ) {
-
-        std::list< std::string > tokens;
-        std::string              fname;
-
-        fname= std::string(name.c_str(), sep);
-
-        FbTk::StringUtil::stringtok(tokens, name.substr(sep + 1), ",");
-
-        tokens.unique();
-        bool firstone= true;
-        std::list< std::string >::const_iterator token;
-
-        // check tokens and extract extraoptions for halo and shadow
-        for( token= tokens.begin(); token != tokens.end(); token++ ) {
-            if ( (*token).find("halo",0) != std::string::npos ) {
-                m_halo= true;
-                extract_halo_options(*token, m_halo_color);
-            }
-            else if ( (*token).find("shadow", 0) != std::string::npos ) {
-                m_shadow= true;
-                extract_shadow_options(*token, m_shadow_color, m_shadow_offx, m_shadow_offy);
-            }
-            else {
-                if ( !firstone )
-                    fname+= ", ";
-                else
-                    firstone= false;
-                fname= fname + ":" + *token;
-            }
+ 
+    StringMapIt lookup_entry;
+    FontCacheIt cache_entry;
+
+    // check if one of <font1>|<font2>|<font3> is already there
+    if ((lookup_entry = lookup_map.find(name)) != lookup_map.end() &&
+            (cache_entry = font_cache.find(lookup_entry->second)) != font_cache.end()) {
+        m_fontstr = cache_entry->first;
+        m_fontimp = cache_entry->second;
+        return true;
+     }
+    
+    // split up the namelist
+    typedef std::list<std::string> StringList;
+    typedef StringList::iterator StringListIt;
+    StringList names;
+    FbTk::StringUtil::stringtok<StringList>(names, name, "|");
+    
+    StringListIt name_it;
+    for (name_it = names.begin(); name_it != names.end(); name_it++) {
+        FbTk::StringUtil::removeTrailingWhitespace(*name_it);
+        FbTk::StringUtil::removeFirstWhitespace(*name_it);
+
+        if ((cache_entry = font_cache.find(*name_it)) != font_cache.end()) {
+            m_fontstr = cache_entry->first;
+            m_fontimp = cache_entry->second;
+            lookup_map[name] = m_fontstr;
+            return true;
         }
 
-        m_fontstr = fname;
-    } else
-        m_fontstr = name;
+        FontImp* tmp_font(0);
+        
+#ifdef USE_XFT
+        if ((*name_it)[0] != '-')
+            tmp_font = new XftFontImp(0, s_utf8mode);
+#endif // USE_XFT
+    
+        if (!tmp_font) {
+#ifdef USE_XMB
+            if (s_multibyte || s_utf8mode)
+                tmp_font = new XmbFontImp(0, s_utf8mode);
+            else // basic font implementation
+#endif // USE_XMB
+                tmp_font = new XFontImp();
+        }
+
+        if (tmp_font && tmp_font->load((*name_it).c_str())) {
+            lookup_map[name] = (*name_it);
+            m_fontimp = tmp_font;
+            font_cache[(*name_it)] = tmp_font;
+            m_fontstr = name;
+            return true;
+        }
+        
+        delete tmp_font;
+    }
 
-    return m_fontimp->load(m_fontstr.c_str());
+    return false;;
 }
 
 unsigned int Font::textWidth(const char * const text, unsigned int size) const {
@@ -449,14 +376,14 @@ void Font::drawText(const FbDrawable &w, int screen, GC gc,
     if (first_run) {
         if (m_shadow) {
             FbTk::GContext shadow_gc(w);
-            shadow_gc.setForeground(FbTk::Color(m_shadow_color.c_str(), screen));
+            shadow_gc.setForeground(m_shadow_color);
             first_run = false;
             drawText(w, screen, shadow_gc.gc(), real_text, len,
                      x + m_shadow_offx, y + m_shadow_offy, rotate);
             first_run = true;
         } else if (m_halo) {
             FbTk::GContext halo_gc(w);
-            halo_gc.setForeground(FbTk::Color(m_halo_color.c_str(), screen));
+            halo_gc.setForeground(m_halo_color);
             first_run = false;
             drawText(w, screen, halo_gc.gc(), real_text, len, x + 1, y + 1, rotate);
             drawText(w, screen, halo_gc.gc(), real_text, len, x - 1, y + 1, rotate);
@@ -473,7 +400,7 @@ void Font::drawText(const FbDrawable &w, int screen, GC gc,
         // Using dynamic_cast just temporarly until there's a better solution 
         // to put in FontImp
         try {
-            XFontImp *font = dynamic_cast<XFontImp *>(m_fontimp.get());
+            XFontImp *font = dynamic_cast<XFontImp *>(m_fontimp);
             font->setRotate(false); // disable rotation temporarly
 
             font->drawText(w, screen, gc, real_text, len, x, y);
@@ -492,15 +419,16 @@ void Font::drawText(const FbDrawable &w, int screen, GC gc,
 }       
 
 void Font::rotate(float angle) {
+/* TODO: reimplement rotated text
 #ifdef USE_XFT
     // if we are rotated and we are changing to horiz text 
     // and we were antialiased before we rotated then change to XftFontImp
-    if (isRotated() && angle == 0 && isAntialias())
-        m_fontimp.reset(new XftFontImp(m_fontstr.c_str(), m_utf8mode));
+    if (isRotated() && angle == 0 && !m_xftfontstr.empty())
+        m_fontimp.reset(new XftFontImp(m_fontstr.c_str(),s_utf8mode));
 #endif // USE_XFT
     // change to a font imp that handles rotated fonts (i.e just XFontImp at the moment)
     // if we're going to rotate this font
-    if (angle != 0 && isAntialias() && !isRotated()) {
+    if (angle != 0 && !isRotated()) {
         m_fontimp.reset(new XFontImp(m_fontstr.c_str()));
         if (!m_fontimp->loaded()) // if it failed to load font, try default font fixed
             m_fontimp->load("fixed");
@@ -511,6 +439,7 @@ void Font::rotate(float angle) {
 
     m_rotated = (angle == 0 ? false : true);
     m_angle = angle;
+    */
 }