summaryrefslogtreecommitdiff
path: root/src/xutf8/utf8Wrap.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/xutf8/utf8Wrap.c')
-rw-r--r--src/xutf8/utf8Wrap.c935
1 files changed, 935 insertions, 0 deletions
diff --git a/src/xutf8/utf8Wrap.c b/src/xutf8/utf8Wrap.c
new file mode 100644
index 000000000..4744db4d4
--- /dev/null
+++ b/src/xutf8/utf8Wrap.c
@@ -0,0 +1,935 @@
+/*
+ * "$Id: $"
+ *
+ * X11 UTF-8 text drawing functions.
+ *
+ * Copyright (c) 2000-2002 by O'ksi'D.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of O'ksi'D nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Author: Jean-Marc Lienher ( http://oksid.ch )
+ */
+
+#if !defined(WIN32) && !defined(__APPLE__)
+
+#include "../../FL/Xutf8.h"
+#include <X11/Xlib.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* External auto generated functions : */
+#include "ucs2fontmap.c"
+/*
+ * extern int ucs2fontmap(char *s, unsigned int ucs, int enc);
+ * extern int encoding_number(const char *enc);
+ * extern const char *encoding_name(int num);
+ */
+
+/*********************************************************************/
+/** extract a list of font from the base font name list **/
+/*********************************************************************/
+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;
+}
+
+/*********************************************************************/
+/** get the font name used as encoding for "fontspecific" encoding **/
+/** (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;
+}
+
+
+/*********************************************************************/
+/** 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 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++;
+ }
+ 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;
+}
+
+/*********************************************************************/
+/** 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++;
+ }
+
+ 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;
+ }
+ }
+ }
+ }
+}
+
+/*********************************************************************/
+/** Creates an array of XFontStruct acording to the comma separated **/
+/** 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;
+ }
+
+ load_fonts(dpy, font_set);
+
+ return font_set;
+}
+
+
+/*****************************************************************************/
+/** 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;
+ }
+
+ 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);
+}
+
+
+/*****************************************************************************/
+/** 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;
+ }
+
+ XSetFont(display, gc, fonts[fnum]->fid);
+ XDrawString16(display, d, gc, x, y, buf, i);
+}
+
+
+
+/*****************************************************************************/
+/** 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;
+ }
+
+ 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;
+}
+
+/*****************************************************************************/
+/** 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;
+}
+
+/*****************************************************************************/
+/** 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;
+}
+
+/*****************************************************************************/
+/** 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);
+}
+
+/*****************************************************************************/
+/** 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);
+}
+
+#endif // X11 only
+
+/*
+ * End of "$Id: $".
+ */
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-08 10:32:15 +0000