xutf8 files code conformance:

    o C files containing C++ "//" comments -> C style "/* */" comments
    o Converted unintended doxygen style comments to regular C comments
    o FLTK brace/indent coding standard conformance
    o Tested linux + sgi
    o Avoided mods to xutf8/lcUniConv [libiconv/FSF code]
      to avoid unwanted diffs with future updates of that lib
      as per Fabien's fltk.dev request 03/14/09.
      (Those files already compliant anyway)



git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@6698 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

1 files changed, 737 insertions, 772 deletions

diff --git a/src/xutf8/utf8Wrap.c b/src/xutf8/utf8Wrap.c
index 88d9fc5f2..4961ac0f4 100644
--- a/src/xutf8/utf8Wrap.c
+++ b/src/xutf8/utf8Wrap.c
@@ -49,45 +49,44 @@
 static int 
 get_font_list(
 	const char	*base_font_name_list, 
-	char 		***flist)
-{
-	const char *ptr;
-	const char *p;
-	int nb;
-	int nb_name;
-	
-	ptr = base_font_name_list;
-	p = NULL;
-	nb = 0;
-	nb_name = 1;
-
-	while (*ptr) {
-		if (*ptr == ',') nb_name++;
-		ptr++;
-	}
-
-	*flist = (char **) malloc(sizeof(char*) * nb_name);
-	ptr = base_font_name_list;
-
-	while (*ptr) {
-		int l = 0, i = 0;
-	
-		while(isspace(*ptr)) ptr++;
-		p = ptr;
-		while (*ptr && *ptr != ',') { ptr++; l++; }
-		if (l > 2) {
-			(*flist)[nb] = (char*) malloc((unsigned)l + 2);
-			while (p != ptr) { ((*flist)[nb])[i] = *p; i++; p++; }
-			(*flist)[nb][i] = '\0';
-			nb++;
-		}
-		if (*ptr) ptr++;
-	}
-	if (nb < 1) {
-		free(*flist);
-		*flist = (char**)NULL;
-	}
-	return nb;	
+	char 		***flist) {
+  const char *ptr;
+  const char *p;
+  int nb;
+  int nb_name;
+  
+  ptr = base_font_name_list;
+  p = NULL;
+  nb = 0;
+  nb_name = 1;
+
+  while (*ptr) {
+    if (*ptr == ',') nb_name++;
+    ptr++;
+  }
+
+  *flist = (char **) malloc(sizeof(char*) * nb_name);
+  ptr = base_font_name_list;
+
+  while (*ptr) {
+    int l = 0, i = 0;
+
+    while(isspace(*ptr)) ptr++;
+    p = ptr;
+    while (*ptr && *ptr != ',') { ptr++; l++; }
+    if (l > 2) {
+      (*flist)[nb] = (char*) malloc((unsigned)l + 2);
+      while (p != ptr) { ((*flist)[nb])[i] = *p; i++; p++; }
+      (*flist)[nb][i] = '\0';
+      nb++;
+    }
+    if (*ptr) ptr++;
+  }
+  if (nb < 1) {
+    free(*flist);
+    *flist = (char**)NULL;
+  }
+  return nb;	
 }
 
 /*********************************************************************/
@@ -95,26 +94,24 @@ get_font_list(
 /** (mainly used for adobe-symbol and adobe-zapfdingbats)	    **/
 /*********************************************************************/
 static int 
-font_spec_enc(
-	char *font)
-{
-	int ret;
-	char *enc;
-	char *end;
-
-	enc = font;
-	while (*enc != '-') enc++; 
-	enc++;
-	while (*enc != '-') enc++;
-	enc++;
-	end = enc;
-	while (*end != '-') end++;
-	*end = '\0';
-	
-	ret = encoding_number(enc);
-	*end = '-';
-
-	return ret;
+font_spec_enc(char *font) {
+  int ret;
+  char *enc;
+  char *end;
+
+  enc = font;
+  while (*enc != '-') enc++; 
+  enc++;
+  while (*enc != '-') enc++;
+  enc++;
+  end = enc;
+  while (*end != '-') end++;
+  *end = '\0';
+  
+  ret = encoding_number(enc);
+  *end = '-';
+
+  return ret;
 }
 
 
@@ -122,174 +119,168 @@ font_spec_enc(
 /** get the sub range of a iso10646-1 font			    **/
 /*********************************************************************/
 static void
-get_range(
-	const char	*enc,
-	int 		*min,
-	int		*max)
-{
-	const char *ptr = enc;
-	const char *ptr1;
-
-	if (!enc) return;
-
-	while (*ptr && *ptr != '-') ptr++;
-	if (!*ptr) return;
-	while (*ptr && *ptr != '[') ptr++;
-	if (!*ptr) return;
-	*min = 0xFFFF;
-	*max = 0;
-	while (*ptr && *ptr != ']') {
-		int val;
-		ptr++;
-		ptr1 = ptr;
-		while (*ptr && *ptr != ']' && *ptr != ' ' && *ptr != '_') ptr++;
-		val = strtol(ptr1, NULL, 0);
-		if (val < *min) *min = val;
-		if (val > *max) *max = val;
-	}	
+get_range(const char	*enc,
+	  int 		*min,
+	  int		*max) {
+
+  const char *ptr = enc;
+  const char *ptr1;
+
+  if (!enc) return;
+
+  while (*ptr && *ptr != '-') ptr++;
+  if (!*ptr) return;
+  while (*ptr && *ptr != '[') ptr++;
+  if (!*ptr) return;
+  *min = 0xFFFF;
+  *max = 0;
+  while (*ptr && *ptr != ']') {
+    int val;
+    ptr++;
+    ptr1 = ptr;
+    while (*ptr && *ptr != ']' && *ptr != ' ' && *ptr != '_') ptr++;
+    val = strtol(ptr1, NULL, 0);
+    if (val < *min) *min = val;
+    if (val > *max) *max = val;
+  }	
 }
 
 /*********************************************************************/
 /** get the internal encoding number of each fonts 		    **/
 /*********************************************************************/
 static int *
-get_encodings(
-	char	**font_name_list, 
-	int 	*ranges,
-	int 	nb_font)
-{
-	int *font_encoding_list;
-	int i;
-	i = 0;
-
-	font_encoding_list = (int *) malloc(sizeof(int) * nb_font);
-	while (i < nb_font) {
-		char *ptr;
-		int ec;
-		ptr = font_name_list[i];
-		ec = 0;
-		font_encoding_list[i] = -1;
-		ranges[i * 2] = 0;
-		ranges[i * 2 + 1] = 0xFFFF;
-		
-		if (ptr && strstr(ptr, "fontspecific")) {
-			font_encoding_list[i] = font_spec_enc(ptr);
-			ptr = NULL;
-		}
-		while (ptr && *ptr) {
-			if (*ptr == '-') {
-				ec++;
-				if (ec == 13) {
-					font_encoding_list[i] = 
-						encoding_number(ptr + 1);
-					if (font_encoding_list[i] == 0) {
-						get_range(ptr + 1, 
-							ranges + i * 2,
-							ranges + i * 2 + 1);
-					}
-					break;
-				}
-			}	
-			ptr++;
-		}
-		if (font_encoding_list[i] < 0) font_encoding_list[i] = 1;
-		i++;
+get_encodings(char	**font_name_list, 
+	      int 	*ranges,
+	      int 	nb_font) {
+
+  int *font_encoding_list;
+  int i;
+  i = 0;
+
+  font_encoding_list = (int *) malloc(sizeof(int) * nb_font);
+  while (i < nb_font) {
+    char *ptr;
+    int ec;
+    ptr = font_name_list[i];
+    ec = 0;
+    font_encoding_list[i] = -1;
+    ranges[i * 2] = 0;
+    ranges[i * 2 + 1] = 0xFFFF;
+    
+    if (ptr && strstr(ptr, "fontspecific")) {
+      font_encoding_list[i] = font_spec_enc(ptr);
+      ptr = NULL;
+    }
+    while (ptr && *ptr) {
+      if (*ptr == '-') {
+	ec++;
+	if (ec == 13) {
+	  font_encoding_list[i] = encoding_number(ptr + 1);
+	  if (font_encoding_list[i] == 0) {
+	    get_range(ptr + 1, 
+		      ranges + i * 2,
+		      ranges + i * 2 + 1);
+	  }
+	  break;
 	}
-	return font_encoding_list;
+      }	
+      ptr++;
+    }
+    if (font_encoding_list[i] < 0) font_encoding_list[i] = 1;
+    i++;
+  }
+  return font_encoding_list;
 }
 
 /*********************************************************************/
 /** find the first font which matches the name and load it.	    **/
 /*********************************************************************/
 XFontStruct *
-find_best_font(
-	Display         *dpy,
-	char		**name)
-{
-	char **list;
-	int cnt;
-	XFontStruct *s;
-
-	list = XListFonts(dpy, *name, 1, &cnt);
-	if (cnt && list) {
-		free(*name);
-		*name = strdup(list[0]);
-		s = XLoadQueryFont(dpy, *name);
-		XFreeFontNames(list);
-		return s;
-	}
-	return NULL;
+find_best_font(Display  *dpy,
+	       char     **name) {
+
+  char **list;
+  int cnt;
+  XFontStruct *s;
+
+  list = XListFonts(dpy, *name, 1, &cnt);
+  if (cnt && list) {
+    free(*name);
+    *name = strdup(list[0]);
+    s = XLoadQueryFont(dpy, *name);
+    XFreeFontNames(list);
+    return s;
+  }
+  return NULL;
 }
 
 /*********************************************************************/
 /** load all fonts 						    **/
 /*********************************************************************/
 static void 
-load_fonts(
-	Display 		*dpy, 
-	XUtf8FontStruct	*font_set) 
-{
-	int i;
-	char **list;
-
-	i = 0;
-	list = NULL;
-
-	font_set->fonts = (XFontStruct**) 
-		malloc(sizeof(XFontStruct*) * font_set->nb_font);
-	
-	font_set->ranges = (int*) 
-		malloc(sizeof(int) *  font_set->nb_font * 2);
-
-	font_set->descent = 0;
-	font_set->ascent = 0;
-	font_set->fid = 0;
-
-	while (i < font_set->nb_font) {
-		XFontStruct *fnt;
-
-		fnt = font_set->fonts[i] = 
-			find_best_font(dpy, &(font_set->font_name_list[i]));
-		if (fnt) {
-			font_set->fid = fnt->fid;
-			if (fnt->ascent > font_set->ascent) {
-				font_set->ascent = fnt->ascent;
-			}
-			if (fnt->descent > font_set->descent) {
-				font_set->descent = fnt->descent;
-			}
-		} else {
-			free(font_set->font_name_list[i]);
-			font_set->font_name_list[i] = NULL;
-		}
-		i++;
+load_fonts(Display 	   *dpy, 
+	   XUtf8FontStruct *font_set) {
+
+  int i;
+  char **list;
+
+  i = 0;
+  list = NULL;
+
+  font_set->fonts = (XFontStruct**) malloc(sizeof(XFontStruct*) *
+                                           font_set->nb_font);
+  
+  font_set->ranges = (int*) malloc(sizeof(int) * 
+                                   font_set->nb_font * 2);
+
+  font_set->descent = 0;
+  font_set->ascent = 0;
+  font_set->fid = 0;
+
+  while (i < font_set->nb_font) {
+    XFontStruct *fnt;
+
+    fnt = font_set->fonts[i] = 
+      find_best_font(dpy, &(font_set->font_name_list[i]));
+    if (fnt) {
+      font_set->fid = fnt->fid;
+      if (fnt->ascent > font_set->ascent) {
+	font_set->ascent = fnt->ascent;
+      }
+      if (fnt->descent > font_set->descent) {
+	font_set->descent = fnt->descent;
+      }
+    } else {
+      free(font_set->font_name_list[i]);
+      font_set->font_name_list[i] = NULL;
+    }
+    i++;
+  }
+
+  font_set->encodings = 
+    get_encodings(font_set->font_name_list, 
+      font_set->ranges, font_set->nb_font);
+
+  /* unload fonts with same encoding */
+  for (i = 0; i < font_set->nb_font; i++) {
+    if (font_set->font_name_list[i]) {
+      int j;
+      for (j = 0; j < i; j++) {
+	if (font_set->font_name_list[j] &&
+	    font_set->encodings[j] ==
+	    font_set->encodings[i] &&
+	    font_set->ranges[2*j] ==
+	    font_set->ranges[2*i] &&
+	    font_set->ranges[(2*j)+1] &&
+	    font_set->ranges[(2*i)+1]) {
+	  XFreeFont(dpy, font_set->fonts[i]);
+	  free(font_set->font_name_list[i]);
+	  font_set->font_name_list[i] = NULL;
+	  font_set->fonts[i] = 0;
 	}
-
-	font_set->encodings = 
-		get_encodings(font_set->font_name_list, 
-			font_set->ranges, font_set->nb_font);
-
-	/* unload fonts with same encoding */
-	for (i = 0; i < font_set->nb_font; i++) {
-		if (font_set->font_name_list[i]) {
-			int j;
-			for (j = 0; j < i; j++) {
-				if (font_set->font_name_list[j] &&
-					font_set->encodings[j] ==
-					font_set->encodings[i] &&
-					font_set->ranges[2*j] ==
-					font_set->ranges[2*i] &&
-					font_set->ranges[(2*j)+1] &&
-					font_set->ranges[(2*i)+1]) 
-				{
-	                       		XFreeFont(dpy, font_set->fonts[i]);
-                        		free(font_set->font_name_list[i]);
-					font_set->font_name_list[i] = NULL;
-					font_set->fonts[i] = 0;
-				}
-			}
-		}
-	} 
+      }
+    }
+  } 
 }
 
 /*********************************************************************/
@@ -297,30 +288,28 @@ load_fonts(
 /** list of fonts. XLoad all fonts.				    **/
 /*********************************************************************/
 XUtf8FontStruct *
-XCreateUtf8FontStruct (
-    	Display        	*dpy,
-    	const char   	*base_font_name_list)
-{
-	XUtf8FontStruct *font_set;
-	
-	font_set = (XUtf8FontStruct*) 
-		malloc(sizeof(XUtf8FontStruct));
-
- 	if (!font_set) {
-		return NULL;
-        }
-
-	font_set->nb_font = get_font_list(base_font_name_list, 
-					&font_set->font_name_list);
-
-	if (font_set->nb_font < 1) {
-		free(font_set);
-		return NULL;
-	}
+XCreateUtf8FontStruct(Display    *dpy,
+		      const char *base_font_name_list) {
+
+  XUtf8FontStruct *font_set;
+  
+  font_set = (XUtf8FontStruct*)malloc(sizeof(XUtf8FontStruct));
+
+  if (!font_set) {
+    return NULL;
+  }
 
-	load_fonts(dpy, font_set);
+  font_set->nb_font = get_font_list(base_font_name_list, 
+				    &font_set->font_name_list);
 
-	return font_set;	
+  if (font_set->nb_font < 1) {
+    free(font_set);
+    return NULL;
+  }
+
+  load_fonts(dpy, font_set);
+
+  return font_set;
 }
 
 
@@ -328,126 +317,120 @@ XCreateUtf8FontStruct (
 /** draw a Right To Left UTF-8 string using multiple fonts as needed.	    **/
 /*****************************************************************************/
 void 
-XUtf8DrawRtlString(
-	Display 	*display, 
-	Drawable 	d,
-        XUtf8FontStruct 	*font_set, 
-	GC 		gc, 
-	int 		x, 
-	int 		y, 
-	const char	*string,
-        int 		num_bytes)
-{
-	int 		*encodings; /* encodings array */
-	XFontStruct 	**fonts; /* fonts array */
-	XChar2b 	buf[128]; /* drawing buffer */
-	XChar2b		*ptr;	/* pointer to the drawing buffer */
-	int 		fnum; /* index of the current font in the fonts array*/
-	int 		i; /* current byte in the XChar2b buffer */
-	int 		first; /* first valid font index */
-	int 		last_fnum; /* font index of the previous char */
-	int 		nb_font;  /* quantity of fonts in the font array */
-	char 		glyph[2]; /* byte1 and byte1 value of the UTF-8 char */
-	int		*ranges; /* sub range of iso10646 */
-
-	nb_font = font_set->nb_font;
-
-	if (nb_font < 1) {
-		/* there is no font in the font_set :-( */
-		return;
-	}
-	
-	ranges = font_set->ranges;
-	fonts = font_set->fonts;
-	encodings = font_set->encodings;
-	i = 0;
-	fnum = 0;
-	ptr = buf + 128;
-	
-	while(fnum < nb_font && !fonts[fnum]) fnum++;
-	if (fnum >= nb_font) {
-		/* there is no valid font for the X server */
-		return;
-	}
-
-	first = fnum;
-	last_fnum = fnum;
-
-	while (num_bytes > 0) {
-		int 		ulen; /* byte length of the UTF-8 char */
-		unsigned int 	ucs;  /* Unicode value of the UTF-8 char */
-		unsigned int	no_spc; /* Spacing char equivalent of a 
-					   non-spacing char */
-
-		if (i > 120) {
-			/*** draw the buffer **/
-			XSetFont(display, gc, fonts[fnum]->fid);
-			x -= XTextWidth16(fonts[fnum], ptr, i);
-			XDrawString16(display, d, gc, x, y, ptr, i);
-			i = 0;
-			ptr = buf + 128;
-		}
-
-		ulen = XFastConvertUtf8ToUcs((unsigned char*)string, 
-				num_bytes, &ucs); 
-
-		if (ulen < 1) ulen = 1; 
-
-		no_spc = XUtf8IsNonSpacing(ucs);
-		if (no_spc) ucs = no_spc; 
-
-		/* 
-		 * find the first encoding which can be used to 	
-		 * draw the glyph 				
-		 */
-		fnum = first;
-		while (fnum < nb_font) {
-			if (fonts[fnum] && 
-				ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) 
-			{
-				if (encodings[fnum] != 0 || 
-					(ucs >= ranges[fnum * 2] &&
-					ucs <= ranges[fnum * 2 + 1]))
-				{
-					break;
-				}
-			}
-			fnum++;
-		}
-		if (fnum == nb_font) {
-			/** the char is not valid in all encodings ->
-			  * draw it using the first font :-( **/
-			fnum = first;
-			ucs2fontmap(glyph, '?', encodings[fnum]);
-		}
-
-		if (last_fnum != fnum || no_spc) {
-			XSetFont(display, gc, fonts[last_fnum]->fid);
-			x -= XTextWidth16(fonts[last_fnum], ptr, i);
-			XDrawString16(display, d, gc, x, y, ptr, i);
-			i = 0;
-			ptr = buf + 127;
-			(*ptr).byte1 = glyph[0];
-			(*ptr).byte2 = glyph[1];
-			if (no_spc) {
-				x += XTextWidth16(fonts[fnum], ptr, 1);
-			}
-		} else {
-			ptr--;
-			(*ptr).byte1 = glyph[0];
-			(*ptr).byte2 = glyph[1];
-		}
-		last_fnum = fnum;
-		i++;
-		string += ulen;
-		num_bytes -= ulen;
+XUtf8DrawRtlString(Display 		*display, 
+		   Drawable 		d,
+		   XUtf8FontStruct 	*font_set, 
+		   GC 			gc, 
+		   int 			x, 
+		   int 			y, 
+		   const char		*string,
+		   int 			num_bytes) {
+
+  int 		*encodings;	/* encodings array */
+  XFontStruct 	**fonts;	/* fonts array */
+  XChar2b 	buf[128];	/* drawing buffer */
+  XChar2b	*ptr;		/* pointer to the drawing buffer */
+  int 		fnum;		/* index of the current font in the fonts array*/
+  int 		i;		/* current byte in the XChar2b buffer */
+  int 		first;		/* first valid font index */
+  int 		last_fnum;	/* font index of the previous char */
+  int 		nb_font;	/* quantity of fonts in the font array */
+  char 		glyph[2];	/* byte1 and byte1 value of the UTF-8 char */
+  int		*ranges;	/* sub range of iso10646 */
+
+  nb_font = font_set->nb_font;
+
+  if (nb_font < 1) {
+    /* there is no font in the font_set :-( */
+    return;
+  }
+  
+  ranges = font_set->ranges;
+  fonts = font_set->fonts;
+  encodings = font_set->encodings;
+  i = 0;
+  fnum = 0;
+  ptr = buf + 128;
+  
+  while(fnum < nb_font && !fonts[fnum]) fnum++;
+  if (fnum >= nb_font) {
+    /* there is no valid font for the X server */
+    return;
+  }
+
+  first = fnum;
+  last_fnum = fnum;
+
+  while (num_bytes > 0) {
+    int 	 ulen;   /* byte length of the UTF-8 char */
+    unsigned int ucs;    /* Unicode value of the UTF-8 char */
+    unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
+
+    if (i > 120) {
+      /*** draw the buffer **/
+      XSetFont(display, gc, fonts[fnum]->fid);
+      x -= XTextWidth16(fonts[fnum], ptr, i);
+      XDrawString16(display, d, gc, x, y, ptr, i);
+      i = 0;
+      ptr = buf + 128;
+    }
+
+    ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs); 
+
+    if (ulen < 1) ulen = 1; 
+
+    no_spc = XUtf8IsNonSpacing(ucs);
+    if (no_spc) ucs = no_spc; 
+
+    /* 
+     * find the first encoding which can be used to 	
+     * draw the glyph 				
+     */
+    fnum = first;
+    while (fnum < nb_font) {
+      if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
+	if (encodings[fnum] != 0 || 
+	    (ucs >= ranges[fnum * 2] && ucs <= ranges[fnum * 2 + 1])) {
+	  break;
 	}
-
-	if (i < 1) return;
-
-	XSetFont(display, gc, fonts[fnum]->fid);
-	x -= XTextWidth16(fonts[last_fnum], ptr, i);
-	XDrawString16(display, d, gc, x, y, ptr, i);
+      }
+      fnum++;
+    }
+    if (fnum == nb_font) {
+      /* the char is not valid in all encodings ->
+       * draw it using the first font :-(
+       */
+      fnum = first;
+      ucs2fontmap(glyph, '?', encodings[fnum]);
+    }
+
+    if (last_fnum != fnum || no_spc) {
+      XSetFont(display, gc, fonts[last_fnum]->fid);
+      x -= XTextWidth16(fonts[last_fnum], ptr, i);
+      XDrawString16(display, d, gc, x, y, ptr, i);
+      i = 0;
+      ptr = buf + 127;
+      (*ptr).byte1 = glyph[0];
+      (*ptr).byte2 = glyph[1];
+      if (no_spc) {
+	x += XTextWidth16(fonts[fnum], ptr, 1);
+      }
+    } else {
+      ptr--;
+      (*ptr).byte1 = glyph[0];
+      (*ptr).byte2 = glyph[1];
+    }
+    last_fnum = fnum;
+    i++;
+    string += ulen;
+    num_bytes -= ulen;
+  }
+
+  if (i < 1) return;
+
+  XSetFont(display, gc, fonts[fnum]->fid);
+  x -= XTextWidth16(fonts[last_fnum], ptr, i);
+  XDrawString16(display, d, gc, x, y, ptr, i);
 }
 
 
@@ -455,117 +438,112 @@ XUtf8DrawRtlString(
 /** draw an UTF-8 string using multiple fonts as needed.		    **/
 /*****************************************************************************/
 void 
-XUtf8DrawString(
-	Display 	*display, 
-	Drawable 	d,
-        XUtf8FontStruct 	*font_set, 
-	GC 		gc, 
-	int 		x, 
-	int 		y, 
-	const char	*string,
-        int 		num_bytes)
-{
-	int 		*encodings; /* encodings array */
-	XFontStruct 	**fonts; /* fonts array */
-	XChar2b 	buf[128]; /* drawing buffer */
-	int 		fnum; /* index of the current font in the fonts array*/
-	int 		i; /* current byte in the XChar2b buffer */
-	int 		first; /* first valid font index */
-	int 		last_fnum; /* font index of the previous char */
-	int 		nb_font;  /* quantity of fonts in the font array */
-	char 		glyph[2]; /* byte1 and byte1 value of the UTF-8 char */
-	int		*ranges; /* sub range of iso10646 */
-
-	nb_font = font_set->nb_font;
-
-	if (nb_font < 1) {
-		/* there is no font in the font_set :-( */
-		return;
-	}
-	ranges = font_set->ranges;
-	fonts = font_set->fonts;
-	encodings = font_set->encodings;
-	i = 0;
-	fnum = 0;
-	
-	while(fnum < nb_font && !fonts[fnum]) fnum++;
-	if (fnum >= nb_font) {
-		/* there is no valid font for the X server */
-		return;
-	}
-
-	first = fnum;
-	last_fnum = fnum;
-
-	while (num_bytes > 0) {
-		int 		ulen; /* byte length of the UTF-8 char */
-		unsigned int 	ucs;  /* Unicode value of the UTF-8 char */
-		unsigned int	no_spc; /* Spacing char equivalent of a 
-					   non-spacing char */
-
-		if (i > 120) {
-			/*** draw the buffer **/
-			XSetFont(display, gc, fonts[fnum]->fid);
-			XDrawString16(display, d, gc, x, y, buf, i);
-			x += XTextWidth16(fonts[fnum], buf, i);
-			i = 0;
-		}
-
-		ulen = XFastConvertUtf8ToUcs((unsigned char*)string, 
-				num_bytes, &ucs); 
-
-		if (ulen < 1) ulen = 1; 
-
-		no_spc = XUtf8IsNonSpacing(ucs);
-		if (no_spc) ucs = no_spc; 
-
-		/* 
-		 * find the first encoding which can be used to 	
-		 * draw the glyph 				
-		 */
-		fnum = first;
-		while (fnum < nb_font) {
-			if (fonts[fnum] && 
-				ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) 
-			{
-				if (encodings[fnum] != 0 || 
-					(ucs >= ranges[fnum * 2] &&
-					ucs <= ranges[fnum * 2 + 1]))
-				{
-					break;
-				}
-			}
-			fnum++;
-		}
-		if (fnum == nb_font) {
-			/** the char is not valid in all encodings ->
-			  * draw it using the first font :-( **/
-			fnum = first;
-			ucs2fontmap(glyph, '?', encodings[fnum]);
-		}
-
-		if (last_fnum != fnum || no_spc) {
-			XSetFont(display, gc, fonts[last_fnum]->fid);
-			XDrawString16(display, d, gc, x, y, buf, i);
-			x += XTextWidth16(fonts[last_fnum], buf, i);
-			i = 0;
-			(*buf).byte1 = glyph[0];
-			(*buf).byte2 = glyph[1];
-			if (no_spc) {
-				x -= XTextWidth16(fonts[fnum], buf, 1);
-			}
-		} else {
-			(*(buf + i)).byte1 = glyph[0];
-			(*(buf + i)).byte2 = glyph[1];
-		}
-		last_fnum = fnum;
-		i++;
-		string += ulen;
-		num_bytes -= ulen;
+XUtf8DrawString(Display 	*display, 
+	        Drawable 	d,
+                XUtf8FontStruct *font_set, 
+	        GC 		gc, 
+	        int 		x, 
+	        int 		y, 
+	        const char	*string,
+                int 		num_bytes) {
+
+  int 		*encodings; /* encodings array */
+  XFontStruct 	**fonts;    /* fonts array */
+  XChar2b 	buf[128];   /* drawing buffer */
+  int 		fnum;       /* index of the current font in the fonts array*/
+  int 		i;          /* current byte in the XChar2b buffer */
+  int 		first;      /* first valid font index */
+  int 		last_fnum;  /* font index of the previous char */
+  int 		nb_font;    /* quantity of fonts in the font array */
+  char 		glyph[2];   /* byte1 and byte1 value of the UTF-8 char */
+  int		*ranges;    /* sub range of iso10646 */
+
+  nb_font = font_set->nb_font;
+
+  if (nb_font < 1) {
+    /* there is no font in the font_set :-( */
+    return;
+  }
+  ranges = font_set->ranges;
+  fonts = font_set->fonts;
+  encodings = font_set->encodings;
+  i = 0;
+  fnum = 0;
+  
+  while(fnum < nb_font && !fonts[fnum]) fnum++;
+  if (fnum >= nb_font) {
+    /* there is no valid font for the X server */
+    return;
+  }
+
+  first = fnum;
+  last_fnum = fnum;
+
+  while (num_bytes > 0) {
+    int 	 ulen;   /* byte length of the UTF-8 char */
+    unsigned int ucs;    /* Unicode value of the UTF-8 char */
+    unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
+
+    if (i > 120) {
+      /*** draw the buffer **/
+      XSetFont(display, gc, fonts[fnum]->fid);
+      XDrawString16(display, d, gc, x, y, buf, i);
+      x += XTextWidth16(fonts[fnum], buf, i);
+      i = 0;
+    }
+
+    ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs); 
+
+    if (ulen < 1) ulen = 1; 
+
+    no_spc = XUtf8IsNonSpacing(ucs);
+    if (no_spc) ucs = no_spc; 
+
+    /* 
+     * find the first encoding which can be used to 	
+     * draw the glyph 				
+     */
+    fnum = first;
+    while (fnum < nb_font) {
+      if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
+	if (encodings[fnum] != 0 || 
+	    (ucs >= ranges[fnum * 2] &&
+	    ucs <= ranges[fnum * 2 + 1])) {
+	  break;
 	}
-
-	XSetFont(display, gc, fonts[fnum]->fid);
-	XDrawString16(display, d, gc, x, y, buf, i);
+      }
+      fnum++;
+    }
+    if (fnum == nb_font) {
+      /* the char is not valid in all encodings ->
+       * draw it using the first font :-(
+       */
+      fnum = first;
+      ucs2fontmap(glyph, '?', encodings[fnum]);
+    }
+
+    if (last_fnum != fnum || no_spc) {
+      XSetFont(display, gc, fonts[last_fnum]->fid);
+      XDrawString16(display, d, gc, x, y, buf, i);
+      x += XTextWidth16(fonts[last_fnum], buf, i);
+      i = 0;
+      (*buf).byte1 = glyph[0];
+      (*buf).byte2 = glyph[1];
+      if (no_spc) {
+	x -= XTextWidth16(fonts[fnum], buf, 1);
+      }
+    } else {
+      (*(buf + i)).byte1 = glyph[0];
+      (*(buf + i)).byte2 = glyph[1];
+    }
+    last_fnum = fnum;
+    i++;
+    string += ulen;
+    num_bytes -= ulen;
+  }
+
+  XSetFont(display, gc, fonts[fnum]->fid);
+  XDrawString16(display, d, gc, x, y, buf, i);
 }
 
 
@@ -574,345 +552,332 @@ XUtf8DrawString(
 /** returns the pixel width of a UTF-8 string				    **/
 /*****************************************************************************/
 int  
-XUtf8TextWidth(
-        XUtf8FontStruct 	*font_set, 
-	const char 	*string,
-        int 		num_bytes)
-{
-	int		x;
-	int 		*encodings; /* encodings array */
-	XFontStruct 	**fonts; /* fonts array */
-	XChar2b 	buf[128]; /* drawing buffer */
-	int 		fnum; /* index of the current font in the fonts array*/
-	int 		i; /* current byte in the XChar2b buffer */
-	int 		first; /* first valid font index */
-	int 		last_fnum; /* font index of the previous char */
-	int 		nb_font;  /* quantity of fonts in the font array */
-	char 		glyph[2]; /* byte1 and byte1 value of the UTF-8 char */
-	int		*ranges; /* sub range of iso10646 */
-
-	nb_font = font_set->nb_font;
-	x = 0;
-
-	if (nb_font < 1) {
-		/* there is no font in the font_set :-( */
-		return x;
+XUtf8TextWidth(XUtf8FontStruct 	*font_set, 
+	       const char 	*string,
+	       int 		num_bytes) {
+
+  int		x;
+  int 		*encodings; /* encodings array */
+  XFontStruct 	**fonts;    /* fonts array */
+  XChar2b 	buf[128];   /* drawing buffer */
+  int 		fnum;       /* index of the current font in the fonts array*/
+  int 		i;          /* current byte in the XChar2b buffer */
+  int 		first;      /* first valid font index */
+  int 		last_fnum;  /* font index of the previous char */
+  int 		nb_font;    /* quantity of fonts in the font array */
+  char 		glyph[2];   /* byte1 and byte1 value of the UTF-8 char */
+  int		*ranges;    /* sub range of iso10646 */
+
+  nb_font = font_set->nb_font;
+  x = 0;
+
+  if (nb_font < 1) {
+    /* there is no font in the font_set :-( */
+    return x;
+  }
+
+  ranges = font_set->ranges;
+  fonts = font_set->fonts;
+  encodings = font_set->encodings;
+  i = 0;
+  fnum = 0;
+  
+  while(fnum < nb_font && !fonts[fnum]) fnum++;
+  if (fnum >= nb_font) {
+    /* there is no valid font for the X server */
+    return x;
+  }
+
+  first = fnum;
+  last_fnum = fnum;
+
+  while (num_bytes > 0) {
+    int 	 ulen;   /* byte length of the UTF-8 char */
+    unsigned int ucs;    /* Unicode value of the UTF-8 char */
+    unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
+
+    if (i > 120) {
+      /*** measure the buffer **/
+      x += XTextWidth16(fonts[fnum], buf, i);
+      i = 0;
+    }
+
+    ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs); 
+
+    if (ulen < 1) ulen = 1; 
+
+    no_spc = XUtf8IsNonSpacing(ucs);
+    if (no_spc) {
+      ucs = no_spc;
+    }
+
+    /* 
+     * find the first encoding which can be used to 	
+     * draw the glyph 				
+     */
+    fnum = first;
+    while (fnum < nb_font) {
+      if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
+	if (encodings[fnum] != 0 || 
+		(ucs >= ranges[fnum * 2] &&
+		ucs <= ranges[fnum * 2 + 1])) {
+	  break;
 	}
-
-	ranges = font_set->ranges;
-	fonts = font_set->fonts;
-	encodings = font_set->encodings;
-	i = 0;
-	fnum = 0;
-	
-	while(fnum < nb_font && !fonts[fnum]) fnum++;
-	if (fnum >= nb_font) {
-		/* there is no valid font for the X server */
-		return x;
-	}
-
-	first = fnum;
-	last_fnum = fnum;
-
-	while (num_bytes > 0) {
-		int 		ulen; /* byte length of the UTF-8 char */
-		unsigned int 	ucs;  /* Unicode value of the UTF-8 char */
-		unsigned int	no_spc; /* Spacing char equivalent of a 
-					   non-spacing char */
-
-		if (i > 120) {
-			/*** measure the buffer **/
-			x += XTextWidth16(fonts[fnum], buf, i);
-			i = 0;
-		}
-
-		ulen = XFastConvertUtf8ToUcs((unsigned char*)string, 
-				num_bytes, &ucs); 
-
-		if (ulen < 1) ulen = 1; 
-
-		no_spc = XUtf8IsNonSpacing(ucs);
-		if (no_spc) {
-			ucs = no_spc;
-		}
-
-		/* 
-		 * find the first encoding which can be used to 	
-		 * draw the glyph 				
-		 */
-		fnum = first;
-		while (fnum < nb_font) {
-			if (fonts[fnum] && 
-				ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) 
-			{
-				if (encodings[fnum] != 0 || 
-					(ucs >= ranges[fnum * 2] &&
-					ucs <= ranges[fnum * 2 + 1]))
-				{
-					break;
-				}
-			}
-			fnum++;
-		}
-		if (fnum == nb_font) {
-			/** the char is not valid in all encodings ->
-			  * draw it using the first font :-( **/
-			fnum = first;
-			ucs2fontmap(glyph, '?', encodings[fnum]);
-		}
-
-		if (last_fnum != fnum || no_spc) {
-			x += XTextWidth16(fonts[last_fnum], buf, i);
-			i = 0;
-			(*buf).byte1 = glyph[0];
-			(*buf).byte2 = glyph[1];
-			if (no_spc) {
-				/* go back to draw the non-spacing char over
-				 *  the previous char */
-				x -= XTextWidth16(fonts[fnum], buf, 1);
-			}
-		} else {
-			(*(buf + i)).byte1 = glyph[0];
-			(*(buf + i)).byte2 = glyph[1];
-		}
-		last_fnum = fnum;
-		i++;
-		string += ulen;
-		num_bytes -= ulen;
-	}
-
-	x += XTextWidth16(fonts[last_fnum], buf, i);
-
-	return x;
+      }
+      fnum++;
+    }
+    if (fnum == nb_font) {
+      /* the char is not valid in all encodings ->
+       * draw it using the first font :-(
+       */
+      fnum = first;
+      ucs2fontmap(glyph, '?', encodings[fnum]);
+    }
+
+    if (last_fnum != fnum || no_spc) {
+      x += XTextWidth16(fonts[last_fnum], buf, i);
+      i = 0;
+      (*buf).byte1 = glyph[0];
+      (*buf).byte2 = glyph[1];
+      if (no_spc) {
+	/* go back to draw the non-spacing char over the previous char */
+	x -= XTextWidth16(fonts[fnum], buf, 1);
+      }
+    } else {
+      (*(buf + i)).byte1 = glyph[0];
+      (*(buf + i)).byte2 = glyph[1];
+    }
+    last_fnum = fnum;
+    i++;
+    string += ulen;
+    num_bytes -= ulen;
+  }
+
+  x += XTextWidth16(fonts[last_fnum], buf, i);
+
+  return x;
 }
 
 /*****************************************************************************/
 /**  get the X font and glyph ID of a UCS char                              **/
 /*****************************************************************************/
 int
-XGetUtf8FontAndGlyph(
-        XUtf8FontStruct  *font_set,
-        unsigned int            ucs,
-	XFontStruct 	**fnt,
-	unsigned short	*id)
-{
-        int             x;
-        int             *encodings; /* encodings array */
-        XFontStruct     **fonts; /* fonts array */
-        int             fnum; /* index of the current font in the fonts array*/
-        int             i; /* current byte in the XChar2b buffer */
-        int             first; /* first valid font index */
-        int             last_fnum; /* font index of the previous char */
-        int             nb_font;  /* quantity of fonts in the font array */
-	char 		glyph[2]; /* byte1 and byte1 value of the UTF-8 char */
-        int             *ranges; /* sub range of iso10646 */
-
-        nb_font = font_set->nb_font;
-        x = 0;
-
-        if (nb_font < 1) {
-                /* there is no font in the font_set :-( */
-                return -1;
-        }
-
-        ranges = font_set->ranges;
-        fonts = font_set->fonts;
-        encodings = font_set->encodings;
-        i = 0;
-        fnum = 0;
-
-        while(fnum < nb_font && !fonts[fnum]) fnum++;
-        if (fnum >= nb_font) {
-                /* there is no valid font for the X server */
-                return -1;
-        }
-
-        first = fnum;
-        last_fnum = fnum;
-
-        /* 
-         * find the first encoding which can be used to         
-         * draw the glyph                               
-         */
-        fnum = first;
-        while (fnum < nb_font) {
-                if (fonts[fnum] &&
-                        ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0)
-                {
-                        if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] &&
-                                ucs <= ranges[fnum * 2 + 1]))
-                        {
-                                break;
-                        }
-                }
-                fnum++;
-        }
-        if (fnum == nb_font) {
-                /** the char is not valid in all encodings ->
-                  * draw it using the first font :-( **/
-                fnum = first;
-                ucs2fontmap(glyph, '?', encodings[fnum]);
-        }
-
-        *id = ((unsigned char)glyph[0] << 8) | (unsigned char)glyph[1] ;
-	*fnt = fonts[fnum];
-        return 0;
+XGetUtf8FontAndGlyph(XUtf8FontStruct  *font_set,
+		     unsigned int     ucs,
+		     XFontStruct      **fnt,
+		     unsigned short   *id) {
+
+  int             x;
+  int             *encodings; /* encodings array */
+  XFontStruct     **fonts;    /* fonts array */
+  int             fnum;       /* index of the current font in the fonts array*/
+  int             i;          /* current byte in the XChar2b buffer */
+  int             first;      /* first valid font index */
+  int             last_fnum;  /* font index of the previous char */
+  int             nb_font;    /* quantity of fonts in the font array */
+  char 		  glyph[2];   /* byte1 and byte1 value of the UTF-8 char */
+  int             *ranges;    /* sub range of iso10646 */
+
+  nb_font = font_set->nb_font;
+  x = 0;
+
+  if (nb_font < 1) {
+    /* there is no font in the font_set :-( */
+    return -1;
+  }
+
+  ranges = font_set->ranges;
+  fonts = font_set->fonts;
+  encodings = font_set->encodings;
+  i = 0;
+  fnum = 0;
+
+  while(fnum < nb_font && !fonts[fnum]) fnum++;
+  if (fnum >= nb_font) {
+    /* there is no valid font for the X server */
+    return -1;
+  }
+
+  first = fnum;
+  last_fnum = fnum;
+
+  /* 
+   * find the first encoding which can be used to         
+   * draw the glyph                               
+   */
+  fnum = first;
+  while (fnum < nb_font) {
+    if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
+      if (encodings[fnum] != 0 || 
+          (ucs >= ranges[fnum * 2] &&
+	  ucs <= ranges[fnum * 2 + 1])) {
+	break;
+      }
+    }
+    fnum++;
+  }
+  if (fnum == nb_font) {
+    /* the char is not valid in all encodings ->
+     * draw it using the first font :-(
+     */
+    fnum = first;
+    ucs2fontmap(glyph, '?', encodings[fnum]);
+  }
+
+  *id = ((unsigned char)glyph[0] << 8) | (unsigned char)glyph[1] ;
+  *fnt = fonts[fnum];
+  return 0;
 }
 
 /*****************************************************************************/
 /** returns the pixel width of a UCS char				    **/
 /*****************************************************************************/
 int
-XUtf8UcsWidth(
-        XUtf8FontStruct  *font_set,
-        unsigned int            ucs)
-{
-	int		x;
-	int 		*encodings; /* encodings array */
-	XFontStruct 	**fonts; /* fonts array */
-	XChar2b 	buf[8]; /* drawing buffer */
-	int 		fnum; /* index of the current font in the fonts array*/
-	int 		i; /* current byte in the XChar2b buffer */
-	int 		first; /* first valid font index */
-	int 		last_fnum; /* font index of the previous char */
-	int 		nb_font;  /* quantity of fonts in the font array */
-	char 		glyph[2]; /* byte1 and byte1 value of the UTF-8 char */
-	int		*ranges; /* sub range of iso10646 */
-
-	nb_font = font_set->nb_font;
-	x = 0;
-
-	if (nb_font < 1) {
-		/* there is no font in the font_set :-( */
-		return x;
-	}
-
-	ranges = font_set->ranges;
-	fonts = font_set->fonts;
-	encodings = font_set->encodings;
-	i = 0;
-	fnum = 0;
-	
-	while(fnum < nb_font && !fonts[fnum]) fnum++;
-	if (fnum >= nb_font) {
-		/* there is no valid font for the X server */
-		return x;
-	}
-
-	first = fnum;
-	last_fnum = fnum;
-
-
-	ucs = XUtf8IsNonSpacing(ucs);
-
-	/* 
-	 * find the first encoding which can be used to 	
-	 * draw the glyph 				
-	 */
-	fnum = first;
-	while (fnum < nb_font) {
-		if (fonts[fnum] && 
-			ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) 
-		{
-			if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] &&
-				ucs <= ranges[fnum * 2 + 1]))
-			{
-				break;
-			}
-		}
-		fnum++;
-	}
-	if (fnum == nb_font) {
-		/** the char is not valid in all encodings ->
-		  * draw it using the first font :-( **/
-		fnum = first;
-		ucs2fontmap(glyph, '?', encodings[fnum]);
-	}
-
-	(*buf).byte1 = glyph[0];
-	(*buf).byte2 = glyph[1];
-
-	x += XTextWidth16(fonts[fnum], buf, 1);
-
-	return x;
+XUtf8UcsWidth(XUtf8FontStruct  *font_set,
+	      unsigned int     ucs) {
+
+  int		x;
+  int 		*encodings; /* encodings array */
+  XFontStruct 	**fonts;    /* fonts array */
+  XChar2b 	buf[8];     /* drawing buffer */
+  int 		fnum;       /* index of the current font in the fonts array*/
+  int 		i;          /* current byte in the XChar2b buffer */
+  int 		first;      /* first valid font index */
+  int 		last_fnum;  /* font index of the previous char */
+  int 		nb_font;    /* quantity of fonts in the font array */
+  char 		glyph[2];   /* byte1 and byte1 value of the UTF-8 char */
+  int		*ranges;    /* sub range of iso10646 */
+
+  nb_font = font_set->nb_font;
+  x = 0;
+
+  if (nb_font < 1) {
+    /* there is no font in the font_set :-( */
+    return x;
+  }
+
+  ranges = font_set->ranges;
+  fonts = font_set->fonts;
+  encodings = font_set->encodings;
+  i = 0;
+  fnum = 0;
+  
+  while(fnum < nb_font && !fonts[fnum]) fnum++;
+  if (fnum >= nb_font) {
+    /* there is no valid font for the X server */
+    return x;
+  }
+
+  first = fnum;
+  last_fnum = fnum;
+
+  ucs = XUtf8IsNonSpacing(ucs);
+
+  /* 
+   * find the first encoding which can be used to 	
+   * draw the glyph 				
+   */
+  fnum = first;
+  while (fnum < nb_font) {
+    if (fonts[fnum] && 
+	ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
+      if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] &&
+	  ucs <= ranges[fnum * 2 + 1])) {
+	break;
+      }
+    }
+    fnum++;
+  }
+  if (fnum == nb_font) {
+    /* the char is not valid in all encodings ->
+     * draw it using the first font :-(
+     */
+    fnum = first;
+    ucs2fontmap(glyph, '?', encodings[fnum]);
+  }
+
+  (*buf).byte1 = glyph[0];
+  (*buf).byte2 = glyph[1];
+
+  x += XTextWidth16(fonts[fnum], buf, 1);
+
+  return x;
 }
 
 /*****************************************************************************/
 /** draw an UTF-8 string and clear the background.	 		    **/
 /*****************************************************************************/
 void
-XUtf8DrawImageString(
-        Display         *display,
-        Drawable        d,
-        XUtf8FontStruct         *font_set,
-        GC              gc,
-        int             x,
-        int             y,
-        const char      *string,
-        int             num_bytes)
-{
-	/* FIXME: must be improved ! */
-	int w;
-	int fill_style;
-	unsigned long foreground;
-	unsigned long background;
-	int function;
-	XGCValues xgcv;
-
-	w = XUtf8TextWidth(font_set, string, num_bytes);
-	
-	XGetGCValues(display, gc, 
-		GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
-	
-	function = xgcv.function;
-	fill_style = xgcv.fill_style;
-	foreground = xgcv.foreground;
-	background = xgcv.background;
-
-	xgcv.function = GXcopy;
-	xgcv.foreground = background;
-	xgcv.background = foreground;
-	xgcv.fill_style = FillSolid;
-
-	XChangeGC(display, gc,
-		GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
-
-	XFillRectangle(display, d, gc, x, y - font_set->ascent, 
-		(unsigned)w, (unsigned)(font_set->ascent + font_set->descent));
-
-	xgcv.function = function;
-	xgcv.foreground = foreground;
-	xgcv.background = background;
-	xgcv.fill_style = fill_style;
-
-	XChangeGC(display, gc,
-		GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
-
-	XUtf8DrawString(display, d, font_set, gc, x, y, string, num_bytes);
+XUtf8DrawImageString(Display         *display,
+		     Drawable        d,
+		     XUtf8FontStruct *font_set,
+		     GC              gc,
+		     int             x,
+		     int             y,
+		     const char      *string,
+		     int             num_bytes) {
+
+  /* FIXME: must be improved ! */
+  int w;
+  int fill_style;
+  unsigned long foreground;
+  unsigned long background;
+  int function;
+  XGCValues xgcv;
+
+  w = XUtf8TextWidth(font_set, string, num_bytes);
+  
+  XGetGCValues(display, gc, 
+	       GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
+  
+  function = xgcv.function;
+  fill_style = xgcv.fill_style;
+  foreground = xgcv.foreground;
+  background = xgcv.background;
+
+  xgcv.function = GXcopy;
+  xgcv.foreground = background;
+  xgcv.background = foreground;
+  xgcv.fill_style = FillSolid;
+
+  XChangeGC(display, gc,
+	    GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
+
+  XFillRectangle(display, d, gc, x, y - font_set->ascent, 
+	         (unsigned)w, (unsigned)(font_set->ascent + font_set->descent));
+
+  xgcv.function = function;
+  xgcv.foreground = foreground;
+  xgcv.background = background;
+  xgcv.fill_style = fill_style;
+
+  XChangeGC(display, gc,
+	    GCFunction|GCForeground|GCBackground|GCFillStyle, &xgcv);
+
+  XUtf8DrawString(display, d, font_set, gc, x, y, string, num_bytes);
 }
 
 /*****************************************************************************/
 /** free the XFontSet and others things created by XCreateUtf8FontSet       **/
 /*****************************************************************************/
 void 
-XFreeUtf8FontStruct(
-	Display 	*dpy, 
-	XUtf8FontStruct *font_set)
-{
-	int i;
-	i = 0;
-	while (i < font_set->nb_font) {
-		if (font_set->fonts[i]) {
-			XFreeFont(dpy, font_set->fonts[i]);
-			free(font_set->font_name_list[i]);
-		}
-		i++;
-	}
-	free(font_set->ranges);
-	free(font_set->font_name_list);
-	free(font_set->fonts);
-	free(font_set->encodings);
-	free(font_set);
+XFreeUtf8FontStruct(Display 	    *dpy, 
+		    XUtf8FontStruct *font_set) {
+
+  int i;
+  i = 0;
+  while (i < font_set->nb_font) {
+    if (font_set->fonts[i]) {
+	XFreeFont(dpy, font_set->fonts[i]);
+	free(font_set->font_name_list[i]);
+    }
+    i++;
+  }
+  free(font_set->ranges);
+  free(font_set->font_name_list);
+  free(font_set->fonts);
+  free(font_set->encodings);
+  free(font_set);
 }
 
 #endif /* X11 only */