Fontconfig - Nov 2005 - how to use multiple fonts?

Keith Packard wrote:
> Around 11 o''clock on Mar 5, Federic Zhang wrote:
>
> > Thanks for this information.  I will refer to the corresponding
implemention
> > in Pango, using low-level FcFontSort is too complicated at least for
me.
>
> Yes, it is rather complicated.  Perhaps your experience can serve as a
> guide for a higher level interface that could be integrated into Xft.
>
I finished one by following implementation within Pango.

The attached APIs can be used as reference to implement  the new API
with multiple fonts, it would be great if they can be integreated into Xft.
They can be used as like:

        XftText *text = XftCreateText(dpy, scr, pattern, str, count_chars,
StringUtf8);
        XftDrawText(draw, color, text, x, y);

Of course, its performance is one outstanding issue.

-federic

-------------- next part --------------
#include <glib.h>
#include <fontconfig/fontconfig.h>
#include <Xfttext.h>

typedef struct _XftPatternSet {
   int num_patterns;
   FcPattern **patterns;
} XftPatternSet;

typedef struct _CharProp {
   int pattern_index; /* index of "patterns" */ 
   int count_chars;   /* number of characters sharing the same pattern */
} CharProp;

static void
XftFreePatternSet(XftPatternSet *set)
{
   int n;
   
   for (n=0; n < set->num_patterns; ++n)
       FcPatternDestroy(set->patterns[n]);
     
    g_free(set->patterns);
    g_free(set);
}

static XftPatternSet *
XftCreatePatternSet(FcPattern *pattern)
{
   XftPatternSet *set;
   FcFontSet     *font_patterns;
   int f;
   
   font_patterns = FcFontSort(NULL, pattern, FcTrue, 0, NULL);
   if (!font_patterns) return NULL;
 
   set = g_new0(XftPatternSet, 1);
   set->patterns = g_new0(FcPattern *, font_patterns->nfont);
   set->num_patterns = font_patterns->nfont;

   for (f=0; f < font_patterns->nfont; f++)
	set->patterns[f] = FcFontRenderPrepare(NULL, pattern,
font_patterns->fonts[f]);
    
   FcFontSetDestroy(font_patterns);

   return set;
}
   
static int
getFontIdx(FcChar32 ucs4, XftPatternSet *set)
{
   int n;
   
   for (n=0; n < set->num_patterns; ++n)
     {
       FcCharSet *charset;
       FcPattern *pattern = set->patterns[n];
	
       if (FcPatternGetCharSet(pattern, FC_CHARSET, 0, &charset) !=
FcResultMatch)
         return -1;

       if (FcCharSetHasChar(charset, ucs4)) return n;
     }
	
   return -1;
}

static CharProp *
getCharProp(XftPatternSet *set, void *v, int count_chars, XftTextEncoding
encoding)
{
    CharProp *charprop;
    int i, position,prev_index;
   
    charprop = g_new0(CharProp, count_chars);
    for (i = 0; i < count_chars; ++i)
     {
       gunichar ucs4;
       
       switch (encoding)
	  {
	  case String8:
	     {
		char *p = (char *)v;
		ucs4 = (FcChar32)*p;
		v = (void *)(p+1);
	     }	     
	     break;
	  case String16:
	     {
		FcChar16 *p = (FcChar16 *)v;
		ucs4 = (FcChar32)*p;
		v = (void *)(p+1);
	     }
	     break;
	  case String32:
	     {
		FcChar32 *p = (FcChar32 *)v;
		ucs4 = *p;
		v = (void *)(p+1);
	     }	     
	     break;
	  case StringUtf8:
	     {
	        char *p = (char *)v;
	        ucs4 = g_utf8_get_char(p);
	        v = (void *)g_utf8_next_char(p);
	      }
	     break;
	  case StringUtf16:
	     // not implemented yet
	     break;
	  }
	
       charprop[i].pattern_index = getFontIdx(ucs4, set);
     }
   
    position = 0;
    prev_index = charprop[0].pattern_index;
    for(i=1; i < count_chars; ++i)
     {
	if (charprop[i].pattern_index != prev_index)
	  {
	     charprop[position].count_chars = i - position;
	     prev_index = charprop[i].pattern_index;
	     position = i;
	  }	
     }   
   charprop[position].count_chars = i - position;
   
   return charprop;
}

XftText *
XftCreateText(Display *dpy, int scr, FcPattern *pattern, 
	      void *v, int count_chars, XftTextEncoding encoding)
{
   XftPatternSet *set;
   XftText *text;
   CharProp *charprop;
   int i, num_textitems = 0;
   
   set = XftCreatePatternSet(pattern);
   charprop = getCharProp(set, v, count_chars, encoding);
   
   for(i=0; i<count_chars; ++i)
       if (charprop[i].count_chars) ++num_textitems;
   
   text = g_new0(XftText, 1);
   text->num_textitems = num_textitems;
   text->textitems = g_new0(XftTextItem, num_textitems);
   
   num_textitems = 0;
   for(i=0; i < count_chars; ++i)
     {
	if (charprop[i].count_chars)
	  {
	      FcPattern *match;
	      FcResult result;
	      XftTextItem *item = &text->textitems[num_textitems];

	      item->encoding = encoding;
	     
	      switch (encoding)
	       {
		case String8:
		  {
		     char *string = (char *)v;
		     item->text = g_strndup(string, count_chars);
		  }
		  break;
		case String16:
		  {
		     FcChar16 *string = (FcChar16 *)v;

		     item->text = g_new0(FcChar16, count_chars + 1);
		     memcpy(item->text, string, count_chars *
sizeof(FcChar16)/sizeof(char));
		  }
		  break;
		case String32:
		  {
		     FcChar32 *string = (FcChar32 *)v;

		     item->text = g_new0(FcChar32, count_chars + 1);
		     memcpy(item->text, string, count_chars *
sizeof(FcChar32)/sizeof(char));
		  }
		  break;
		case StringUtf8:
	          {
		     char *string = (char *)v;
	     	     char *start = (char *)g_utf8_offset_to_pointer(string, i);
	             char *end = (char *)g_utf8_offset_to_pointer(string, i +
charprop[i].count_chars);
	    
	             item->text = g_new0(char, end - start + 1);
	             g_utf8_strncpy((char *)item->text, start,
charprop[i].count_chars);
	    	  } 
		  break;
		case StringUtf16:
		  // not implemented yet
		  break;
	       }

	     match = XftFontMatch(dpy, scr, 
			set->patterns[charprop[i].pattern_index], &result);
	     if (match) 
		 {
	     	    item->font = XftFontOpenPattern(dpy, match);
		    FcPatternDestroy(match);
		 }
	       
	     ++num_textitems;
	  }
     }   
  
   g_free(charprop);
   XftFreePatternSet(set);
   
   return text;
}

void
XftDrawText(XftDraw *draw, _Xconst XftColor *color, XftText *text, int x, int y)
{
   int i, xx = x, yy = y;
   
   for(i=0; i < text->num_textitems; ++i)
     {
	XftFont *font;
	Display *dpy = XftDrawDisplay(draw);
	XGlyphInfo extents;
	int len;
	
	font = text->textitems[i].font;
	switch (text->textitems[i].encoding)
	  {
	   case String8:
	     {
		char *string = (char *)text->textitems[i].text;
		
		len = strlen(string);
		XftDrawString8(draw, color, font, xx, yy, string, len);
		XftTextExtentsUtf8(dpy, font, string, len, &extents);
	     }
	     break;
	   case String16:
	     {
		FcChar16 *string = (FcChar16 *)text->textitems[i].text;

		len = 0;
		while (string[len] != (FcChar16)0) ++len;
		
		XftDrawString16(draw, color, font, xx, yy, string, len);
		XftTextExtents16(dpy, font, string, len, &extents);
	     }
	     break;
	   case String32:
	     {
		FcChar32 *string = (FcChar32 *)text->textitems[i].text;

		len = 0;
		while (string[len] != (FcChar32)0) ++len;
		
		XftDrawString32(draw, color, font, xx, yy, string, len);
		XftTextExtents32(dpy, font, string, len, &extents);
	     }
	     break;
	   case StringUtf8:
	     {
		char *string = (char *)text->textitems[i].text;
		
		len = strlen(string);
		
		XftDrawStringUtf8(draw, color, font, xx, yy, string, len);
		XftTextExtentsUtf8(dpy, font, string, len, &extents);
	     }
	     break;
	   case StringUtf16:
	     // not implemented yet
	     break;
	  }
	
	xx += extents.xOff;
     }
}

void
XftFreeText(Display *dpy, XftText *text)
{
   int i;
   
   if (!text) return;
   
   for (i=0; i < text->num_textitems; ++i)
     {
	XftTextItem textitem = text->textitems[i];
	
	if (textitem.text) g_free(textitem.text);
	XftFontClose(dpy, textitem.font);
     }
   
   g_free(text->textitems);
   g_free(text);
}
-------------- next part --------------
#ifndef _Xfttext_H_
#define _Xfttext_H_

#include <X11/Xlib.h>
#include <X11/Xft/Xft.h>
#include <X11/Xft/XftCompat.h>

typedef enum {String8, String16, String32, StringUtf8, StringUtf16 }
XftTextEncoding;

typedef struct _XftTextItem {
   XftFont         *font;
   void            *text;
   XftTextEncoding encoding; /* specify the encoding of ''text''
*/
} XftTextItem;

typedef struct _XftText {   
   int         num_textitems;
   XftTextItem *textitems;
} XftText;

extern XftText *XftCreateText(Display *, int, FcPattern *, void *, int,
XftTextEncoding);
extern void XftDrawText(XftDraw *, _Xconst XftColor *, XftText *, int, int);
extern void XftFreeText(Display *dpy, XftText *);

#endif

Around 11 o''clock on Mar 5, Federic Zhang wrote:
> Thanks for this information.  I will refer to the corresponding
implemention
> in Pango, using low-level FcFontSort is too complicated at least for me.
Yes, it is rather complicated.  Perhaps your experience can serve as a 
guide for a higher level interface that could be integrated into Xft.

-keith

Around 18 o''clock on Mar 4, Federic Zhang wrote:
> seems that it just picks ONLY one font and try to use it to render the
> string no matter that the font can''t cover all characters.
The API you were using uses a single font; there isn''t (yet?) an API 
within Xft to switch among multiple fonts.  I expected applications to
want to group glyphs in the same font, but so far that hasn''t happened.
I
may figure out a reasonable interface now.

For multiple font use (which all applications should use), you use
FcFontSort to compute the list of fonts needed to display as much Unicode
as you''ve got fonts for.  The list includes Unicode coverage for each
font,
so you can just walk the list looking for the first font supporting each
character.

There''s a bit more to it; you''ll find examples in Mozilla, Qt
and Pango at
this point.  I''d like help defining an appropriate Xft API for this 
operation; it may be as simple as extending an XftFont to support 
additional fonts or perhaps it should just use new APIs.  I don''t know 
what''s best.

Keith Packard        Cambridge Research Lab	Hewlett Packard

> The API you were using uses a single font; there isn''t (yet?) an
API
> within Xft to switch among multiple fonts.  I expected applications to
> want to group glyphs in the same font, but so far that hasn''t
happened.  I
> may figure out a reasonable interface now.
>
> For multiple font use (which all applications should use), you use
> FcFontSort to compute the list of fonts needed to display as much Unicode
> as you''ve got fonts for.  The list includes Unicode coverage for
each font,
> so you can just walk the list looking for the first font supporting each
> character.
>
> There''s a bit more to it; you''ll find examples in
Mozilla, Qt and Pango at
> this point.  I''d like help defining an appropriate Xft API for
this
> operation; it may be as simple as extending an XftFont to support
> additional fonts or perhaps it should just use new APIs.  I don''t
know
> what''s best.
Thanks for this information.  I will refer to the corresponding implemention
in Pango, using low-level FcFontSort is too complicated at least for me.

Regards,
Federic

Hi,

I am new to the Xft/FontConfig.  Today i try XftDrawStringUtf8() with
one sample program on Solaris, but encountered one problem. The program
is doing as below:

    XftOpenFont(dpy, scr, XFT_FAMILY, XftTypeString, "Sans-Serif",
                               XFT_SIZE, XftTypeDouble, 12.0, NULL);
    XftDrawStringUtf8(draw, &color, font, x, y, str, strlen(str));
    ==> the ''str'' string is sequence of UTF-8 encoding,
containing
Ascii,
                    Simplified chinese, traditional chinese and korean
characters.

After i updated the /etc/fonts/fonts.conf by adding the paths of korean,
japanese,
and chinese TrueType fonts and removed the cache $HOME/.fonts.cache-1,
run
the program, the outstanding problems is:

              seems that it just picks ONLY one font and try to use it
to render the string
              no matter that the font can''t cover all characters. So
korean character
              isn''t be rendered correctly with one chinese TT font
being
selected, and the ASCII
              glyph is also retrieved from the chinese TT font.

Would you please let me know what''s wrong with my configuration?

Thanks,
Federic