* I haven't the energy.
*/
+#if !GLIB_CHECK_VERSION(1,3,7)
+#define g_ascii_strcasecmp g_strcasecmp
+#define g_ascii_strncasecmp g_strncasecmp
+#endif
+
/*
* Ad-hoc vtable mechanism to allow font structures to be
* polymorphic.
*/
unifont *(*create)(GtkWidget *widget, const char *name, int wide, int bold,
int shadowoffset, int shadowalways);
+ unifont *(*create_fallback)(GtkWidget *widget, int height, int wide,
+ int bold, int shadowoffset, int shadowalways);
void (*destroy)(unifont *font);
+ int (*has_glyph)(unifont *font, wchar_t glyph);
void (*draw_text)(GdkDrawable *target, GdkGC *gc, unifont *font,
- int x, int y, const char *string, int len, int wide,
+ int x, int y, const wchar_t *string, int len, int wide,
int bold, int cellwidth);
void (*enum_fonts)(GtkWidget *widget,
fontsel_add_entry callback, void *callback_ctx);
* X11 font implementation, directly using Xlib calls.
*/
+static int x11font_has_glyph(unifont *font, wchar_t glyph);
static void x11font_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
- int x, int y, const char *string, int len,
+ int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth);
static unifont *x11font_create(GtkWidget *widget, const char *name,
int wide, int bold,
* positioning during text drawing.
*/
int variable;
+ /*
+ * real_charset is the charset used when translating text into the
+ * font's internal encoding inside draw_text(). This need not be
+ * the same as the public_charset provided to the client; for
+ * example, public_charset might be CS_ISO8859_1 while
+ * real_charset is CS_ISO8859_1_X11.
+ */
+ int real_charset;
/*
* Data passed in to unifont_create().
*/
static const struct unifont_vtable x11font_vtable = {
x11font_create,
+ NULL, /* no fallback fonts in X11 */
x11font_destroy,
+ x11font_has_glyph,
x11font_draw_text,
x11font_enum_fonts,
x11font_canonify_fontname,
}
}
+static int x11_font_has_glyph(XFontStruct *xfs, int byte1, int byte2)
+{
+ int index;
+
+ /*
+ * Not to be confused with x11font_has_glyph, which is a method of
+ * the x11font 'class' and hence takes a unifont as argument. This
+ * is the low-level function which grubs about in an actual
+ * XFontStruct to see if a given glyph exists.
+ *
+ * We must do this ourselves rather than letting Xlib's
+ * XTextExtents16 do the job, because XTextExtents will helpfully
+ * substitute the font's default_char for any missing glyph and
+ * not tell us it did so, which precisely won't help us find out
+ * which glyphs _are_ missing.
+ *
+ * The man page for XQueryFont is rather confusing about how the
+ * per_char array in the XFontStruct is laid out, because it gives
+ * formulae for determining the two-byte X character code _from_
+ * an index into the per_char array. Going the other way, it's
+ * rather simpler:
+ *
+ * The valid character codes have byte1 between min_byte1 and
+ * max_byte1 inclusive, and byte2 between min_char_or_byte2 and
+ * max_char_or_byte2 inclusive. This gives a rectangle of size
+ * (max_byte2-min_byte1+1) by
+ * (max_char_or_byte2-min_char_or_byte2+1), which is precisely the
+ * rectangle encoded in the per_char array. Hence, given a
+ * character code which is valid in the sense that it falls
+ * somewhere in that rectangle, its index in per_char is given by
+ * setting
+ *
+ * x = byte2 - min_char_or_byte2
+ * y = byte1 - min_byte1
+ * index = y * (max_char_or_byte2-min_char_or_byte2+1) + x
+ *
+ * If min_byte1 and min_byte2 are both zero, that's a special case
+ * which can be treated as if min_byte2 was 1 instead, i.e. the
+ * per_char array just runs from min_char_or_byte2 to
+ * max_char_or_byte2 inclusive, and byte1 should always be zero.
+ */
+
+ if (byte2 < xfs->min_char_or_byte2 || byte2 > xfs->max_char_or_byte2)
+ return FALSE;
+
+ if (xfs->min_byte1 == 0 && xfs->max_byte1 == 0) {
+ index = byte2 - xfs->min_char_or_byte2;
+ } else {
+ if (byte1 < xfs->min_byte1 || byte1 > xfs->max_byte1)
+ return FALSE;
+ index = ((byte2 - xfs->min_char_or_byte2) +
+ ((byte1 - xfs->min_byte1) *
+ (xfs->max_char_or_byte2 - xfs->min_char_or_byte2 + 1)));
+ }
+
+ if (!xfs->per_char) /* per_char NULL => everything in range exists */
+ return TRUE;
+
+ return (xfs->per_char[index].ascent + xfs->per_char[index].descent > 0 ||
+ xfs->per_char[index].width > 0);
+}
+
static unifont *x11font_create(GtkWidget *widget, const char *name,
int wide, int bold,
int shadowoffset, int shadowalways)
}
/*
- * Hack for X line-drawing characters: if the primary
- * font is encoded as ISO-8859-1, and has valid glyphs
- * in the first 32 char positions, it is assumed that
- * those glyphs are the VT100 line-drawing character
- * set.
- *
- * Actually, we'll hack even harder by only checking
- * position 0x19 (vertical line, VT100 linedrawing
- * `x'). Then we can check it easily by seeing if the
- * ascent and descent differ.
+ * Hack for X line-drawing characters: if the primary font
+ * is encoded as ISO-8859-1, and has valid glyphs in the
+ * low character positions, it is assumed that those
+ * glyphs are the VT100 line-drawing character set.
*/
if (pubcs == CS_ISO8859_1) {
- int dir, asc, desc;
- XCharStruct cs;
- XChar2b text;
-
- text.byte1 = '\0';
- text.byte2 = '\x12';
- XTextExtents16(xfs, &text, 1, &dir, &asc, &desc, &cs);
- if (asc != desc)
- realcs = CS_ISO8859_1_X11;
- }
+ int ch;
+ for (ch = 1; ch < 32; ch++)
+ if (!x11_font_has_glyph(xfs, 0, ch))
+ break;
+ if (ch == 32)
+ realcs = CS_ISO8859_1_X11;
+ }
sfree(encoding);
}
xfont->u.descent = xfs->descent;
xfont->u.height = xfont->u.ascent + xfont->u.descent;
xfont->u.public_charset = pubcs;
- xfont->u.real_charset = realcs;
+ xfont->u.want_fallback = TRUE;
+ xfont->real_charset = realcs;
xfont->fonts[0] = xfs;
xfont->allocated[0] = TRUE;
xfont->sixteen_bit = sixteen_bit;
/* Note that xfont->fonts[sfid] may still be NULL, if XLQF failed. */
}
+static int x11font_has_glyph(unifont *font, wchar_t glyph)
+{
+ struct x11font *xfont = (struct x11font *)font;
+
+ if (xfont->sixteen_bit) {
+ /*
+ * This X font has 16-bit character indices, which means
+ * we can directly use our Unicode input value.
+ */
+ return x11_font_has_glyph(xfont->fonts[0], glyph >> 8, glyph & 0xFF);
+ } else {
+ /*
+ * This X font has 8-bit indices, so we must convert to the
+ * appropriate character set.
+ */
+ char sbstring[2];
+ int sblen = wc_to_mb(xfont->real_charset, 0, &glyph, 1,
+ sbstring, 2, "", NULL, NULL);
+ if (sblen == 0 || !sbstring[0])
+ return FALSE; /* not even in the charset */
+
+ return x11_font_has_glyph(xfont->fonts[0], 0,
+ (unsigned char)sbstring[0]);
+ }
+}
+
#if !GTK_CHECK_VERSION(2,0,0)
#define GDK_DRAWABLE_XID(d) GDK_WINDOW_XWINDOW(d) /* GTK1's name for this */
#endif
}
static void x11font_draw_text(GdkDrawable *target, GdkGC *gdkgc, unifont *font,
- int x, int y, const char *string, int len,
+ int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth)
{
Display *disp = GDK_DISPLAY();
if (xfont->sixteen_bit) {
/*
* This X font has 16-bit character indices, which means
- * we expect our string to have been passed in UTF-8.
+ * we can directly use our Unicode input string.
*/
XChar2b *xcs;
- wchar_t *wcs;
- int nchars, maxchars, i;
+ int i;
- /*
- * Convert the input string to wide-character Unicode.
- */
- maxchars = 0;
- for (i = 0; i < len; i++)
- if ((unsigned char)string[i] <= 0x7F ||
- (unsigned char)string[i] >= 0xC0)
- maxchars++;
- wcs = snewn(maxchars+1, wchar_t);
- nchars = charset_to_unicode((char **)&string, &len, wcs, maxchars,
- CS_UTF8, NULL, NULL, 0);
- assert(nchars <= maxchars);
- wcs[nchars] = L'\0';
-
- xcs = snewn(nchars, XChar2b);
- for (i = 0; i < nchars; i++) {
- xcs[i].byte1 = wcs[i] >> 8;
- xcs[i].byte2 = wcs[i];
+ xcs = snewn(len, XChar2b);
+ for (i = 0; i < len; i++) {
+ xcs[i].byte1 = string[i] >> 8;
+ xcs[i].byte2 = string[i];
}
x11font_really_draw_text_16(target, xfont->fonts[sfid], gc, x, y,
- xcs, nchars, shadowoffset,
+ xcs, len, shadowoffset,
xfont->variable, cellwidth * mult);
sfree(xcs);
- sfree(wcs);
} else {
+ /*
+ * This X font has 8-bit indices, so we must convert to the
+ * appropriate character set.
+ */
+ char *sbstring = snewn(len+1, char);
+ int sblen = wc_to_mb(xfont->real_charset, 0, string, len,
+ sbstring, len+1, ".", NULL, NULL);
x11font_really_draw_text(target, xfont->fonts[sfid], gc, x, y,
- string, len, shadowoffset,
+ sbstring, sblen, shadowoffset,
xfont->variable, cellwidth * mult);
+ sfree(sbstring);
}
}
style = p;
p += sprintf(p, "%s", components[2][0] ? components[2] :
"regular");
- if (!g_strcasecmp(components[3], "i"))
+ if (!g_ascii_strcasecmp(components[3], "i"))
p += sprintf(p, " italic");
- else if (!g_strcasecmp(components[3], "o"))
+ else if (!g_ascii_strcasecmp(components[3], "o"))
p += sprintf(p, " oblique");
- else if (!g_strcasecmp(components[3], "ri"))
+ else if (!g_ascii_strcasecmp(components[3], "ri"))
p += sprintf(p, " reverse italic");
- else if (!g_strcasecmp(components[3], "ro"))
+ else if (!g_ascii_strcasecmp(components[3], "ro"))
p += sprintf(p, " reverse oblique");
- else if (!g_strcasecmp(components[3], "ot"))
+ else if (!g_ascii_strcasecmp(components[3], "ot"))
p += sprintf(p, " other-slant");
- if (components[4][0] && g_strcasecmp(components[4], "normal"))
+ if (components[4][0] && g_ascii_strcasecmp(components[4], "normal"))
p += sprintf(p, " %s", components[4]);
- if (!g_strcasecmp(components[10], "m"))
+ if (!g_ascii_strcasecmp(components[10], "m"))
p += sprintf(p, " [M]");
- if (!g_strcasecmp(components[10], "c"))
+ if (!g_ascii_strcasecmp(components[10], "c"))
p += sprintf(p, " [C]");
if (components[5][0])
p += sprintf(p, " %s", components[5]);
*/
p++;
stylekey = p;
- if (!g_strcasecmp(components[2], "medium") ||
- !g_strcasecmp(components[2], "regular") ||
- !g_strcasecmp(components[2], "normal") ||
- !g_strcasecmp(components[2], "book"))
+ if (!g_ascii_strcasecmp(components[2], "medium") ||
+ !g_ascii_strcasecmp(components[2], "regular") ||
+ !g_ascii_strcasecmp(components[2], "normal") ||
+ !g_ascii_strcasecmp(components[2], "book"))
weightkey = 0;
- else if (!g_strncasecmp(components[2], "demi", 4) ||
- !g_strncasecmp(components[2], "semi", 4))
+ else if (!g_ascii_strncasecmp(components[2], "demi", 4) ||
+ !g_ascii_strncasecmp(components[2], "semi", 4))
weightkey = 1;
else
weightkey = 2;
- if (!g_strcasecmp(components[3], "r"))
+ if (!g_ascii_strcasecmp(components[3], "r"))
slantkey = 0;
- else if (!g_strncasecmp(components[3], "r", 1))
+ else if (!g_ascii_strncasecmp(components[3], "r", 1))
slantkey = 2;
else
slantkey = 1;
- if (!g_strcasecmp(components[4], "normal"))
+ if (!g_ascii_strcasecmp(components[4], "normal"))
setwidthkey = 0;
else
setwidthkey = 1;
#define PANGO_PRE_1POINT6 /* make life easier for pre-1.4 folk */
#endif
+static int pangofont_has_glyph(unifont *font, wchar_t glyph);
static void pangofont_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
- int x, int y, const char *string, int len,
+ int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth);
static unifont *pangofont_create(GtkWidget *widget, const char *name,
int wide, int bold,
int shadowoffset, int shadowalways);
+static unifont *pangofont_create_fallback(GtkWidget *widget, int height,
+ int wide, int bold,
+ int shadowoffset, int shadowalways);
static void pangofont_destroy(unifont *font);
static void pangofont_enum_fonts(GtkWidget *widget, fontsel_add_entry callback,
void *callback_ctx);
static const struct unifont_vtable pangofont_vtable = {
pangofont_create,
+ pangofont_create_fallback,
pangofont_destroy,
+ pangofont_has_glyph,
pangofont_draw_text,
pangofont_enum_fonts,
pangofont_canonify_fontname,
matched = FALSE;
for (i = 0; i < nfamilies; i++) {
- if (!g_strcasecmp(pango_font_family_get_name(families[i]),
- pango_font_description_get_family(desc))) {
+ if (!g_ascii_strcasecmp(pango_font_family_get_name(families[i]),
+ pango_font_description_get_family(desc))) {
matched = TRUE;
break;
}
return matched;
}
-static unifont *pangofont_create(GtkWidget *widget, const char *name,
- int wide, int bold,
- int shadowoffset, int shadowalways)
+static unifont *pangofont_create_internal(GtkWidget *widget,
+ PangoContext *ctx,
+ PangoFontDescription *desc,
+ int wide, int bold,
+ int shadowoffset, int shadowalways)
{
struct pangofont *pfont;
- PangoContext *ctx;
#ifndef PANGO_PRE_1POINT6
PangoFontMap *map;
#endif
- PangoFontDescription *desc;
PangoFontset *fset;
PangoFontMetrics *metrics;
- desc = pango_font_description_from_string(name);
- if (!desc)
- return NULL;
- ctx = gtk_widget_get_pango_context(widget);
- if (!ctx) {
- pango_font_description_free(desc);
- return NULL;
- }
- if (!pangofont_check_desc_makes_sense(ctx, desc)) {
- pango_font_description_free(desc);
- return NULL;
- }
#ifndef PANGO_PRE_1POINT6
map = pango_context_get_font_map(ctx);
if (!map) {
pfont->u.ascent = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics));
pfont->u.descent = PANGO_PIXELS(pango_font_metrics_get_descent(metrics));
pfont->u.height = pfont->u.ascent + pfont->u.descent;
+ pfont->u.want_fallback = FALSE;
/* The Pango API is hardwired to UTF-8 */
pfont->u.public_charset = CS_UTF8;
- pfont->u.real_charset = CS_UTF8;
pfont->desc = desc;
pfont->fset = fset;
pfont->widget = widget;
return (unifont *)pfont;
}
+static unifont *pangofont_create(GtkWidget *widget, const char *name,
+ int wide, int bold,
+ int shadowoffset, int shadowalways)
+{
+ PangoContext *ctx;
+ PangoFontDescription *desc;
+
+ desc = pango_font_description_from_string(name);
+ if (!desc)
+ return NULL;
+ ctx = gtk_widget_get_pango_context(widget);
+ if (!ctx) {
+ pango_font_description_free(desc);
+ return NULL;
+ }
+ if (!pangofont_check_desc_makes_sense(ctx, desc)) {
+ pango_font_description_free(desc);
+ return NULL;
+ }
+ return pangofont_create_internal(widget, ctx, desc, wide, bold,
+ shadowoffset, shadowalways);
+}
+
+static unifont *pangofont_create_fallback(GtkWidget *widget, int height,
+ int wide, int bold,
+ int shadowoffset, int shadowalways)
+{
+ PangoContext *ctx;
+ PangoFontDescription *desc;
+
+ desc = pango_font_description_from_string("Monospace");
+ if (!desc)
+ return NULL;
+ ctx = gtk_widget_get_pango_context(widget);
+ if (!ctx) {
+ pango_font_description_free(desc);
+ return NULL;
+ }
+ pango_font_description_set_absolute_size(desc, height * PANGO_SCALE);
+ return pangofont_create_internal(widget, ctx, desc, wide, bold,
+ shadowoffset, shadowalways);
+}
+
static void pangofont_destroy(unifont *font)
{
struct pangofont *pfont = (struct pangofont *)font;
sfree(font);
}
+static int pangofont_has_glyph(unifont *font, wchar_t glyph)
+{
+ /* Pango implements font fallback, so assume it has everything */
+ return TRUE;
+}
+
static void pangofont_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
- int x, int y, const char *string, int len,
+ int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth)
{
struct pangofont *pfont = (struct pangofont *)font;
PangoLayout *layout;
PangoRectangle rect;
+ char *utfstring, *utfptr;
+ int utflen;
int shadowbold = FALSE;
if (wide)
}
}
- while (len > 0) {
+ /*
+ * Pango always expects UTF-8, so convert the input wide character
+ * string to UTF-8.
+ */
+ utfstring = snewn(len*6+1, char); /* UTF-8 has max 6 bytes/char */
+ utflen = wc_to_mb(CS_UTF8, 0, string, len,
+ utfstring, len*6+1, ".", NULL, NULL);
+
+ utfptr = utfstring;
+ while (utflen > 0) {
int clen, n;
/*
* string.
*/
clen = 1;
- while (clen < len &&
- (unsigned char)string[clen] >= 0x80 &&
- (unsigned char)string[clen] < 0xC0)
+ while (clen < utflen &&
+ (unsigned char)utfptr[clen] >= 0x80 &&
+ (unsigned char)utfptr[clen] < 0xC0)
clen++;
n = 1;
- /*
- * See if that character has the width we expect.
- */
- pango_layout_set_text(layout, string, clen);
- pango_layout_get_pixel_extents(layout, NULL, &rect);
-
- if (rect.width == cellwidth) {
- /*
- * Try extracting more characters, for as long as they
- * stay well-behaved.
- */
- while (clen < len) {
- int oldclen = clen;
- clen++; /* skip UTF-8 introducer byte */
- while (clen < len &&
- (unsigned char)string[clen] >= 0x80 &&
- (unsigned char)string[clen] < 0xC0)
- clen++;
- n++;
- pango_layout_set_text(layout, string, clen);
- pango_layout_get_pixel_extents(layout, NULL, &rect);
- if (rect.width != n * cellwidth) {
- clen = oldclen;
- n--;
- break;
- }
- }
- }
+ /*
+ * If it's a right-to-left character, we must display it on
+ * its own, to stop Pango helpfully re-reversing our already
+ * reversed text.
+ */
+ if (!is_rtl(string[0])) {
- pango_layout_set_text(layout, string, clen);
+ /*
+ * See if that character has the width we expect.
+ */
+ pango_layout_set_text(layout, utfptr, clen);
+ pango_layout_get_pixel_extents(layout, NULL, &rect);
+
+ if (rect.width == cellwidth) {
+ /*
+ * Try extracting more characters, for as long as they
+ * stay well-behaved.
+ */
+ while (clen < utflen) {
+ int oldclen = clen;
+ clen++; /* skip UTF-8 introducer byte */
+ while (clen < utflen &&
+ (unsigned char)utfptr[clen] >= 0x80 &&
+ (unsigned char)utfptr[clen] < 0xC0)
+ clen++;
+ n++;
+ pango_layout_set_text(layout, utfptr, clen);
+ pango_layout_get_pixel_extents(layout, NULL, &rect);
+ if (rect.width != n * cellwidth) {
+ clen = oldclen;
+ n--;
+ break;
+ }
+ }
+ }
+ }
+
+ pango_layout_set_text(layout, utfptr, clen);
pango_layout_get_pixel_extents(layout, NULL, &rect);
gdk_draw_layout(target, gc, x + (n*cellwidth - rect.width)/2,
y + (pfont->u.height - rect.height)/2, layout);
gdk_draw_layout(target, gc, x + (n*cellwidth - rect.width)/2 + pfont->shadowoffset,
y + (pfont->u.height - rect.height)/2, layout);
- len -= clen;
- string += clen;
+ utflen -= clen;
+ utfptr += clen;
+ string += n;
x += n * cellwidth;
}
+ sfree(utfstring);
+
g_object_unref(layout);
}
* event that the same font name is valid as both a Pango and an
* X11 font, it will be interpreted as the former in the absence
* of an explicit type-disambiguating prefix.)
+ *
+ * The 'multifont' subclass is omitted here, as discussed above.
*/
static const struct unifont_vtable *unifont_types[] = {
#if GTK_CHECK_VERSION(2,0,0)
}
void unifont_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
- int x, int y, const char *string, int len,
+ int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth)
{
font->vt->draw_text(target, gc, font, x, y, string, len,
wide, bold, cellwidth);
}
+/* ----------------------------------------------------------------------
+ * Multiple-font wrapper. This is a type of unifont which encapsulates
+ * up to two other unifonts, permitting missing glyphs in the main
+ * font to be filled in by a fallback font.
+ *
+ * This is a type of unifont just like the previous two, but it has a
+ * separate constructor which is manually called by the client, so it
+ * doesn't appear in the list of available font types enumerated by
+ * unifont_create. This means it's not used by unifontsel either, so
+ * it doesn't need to support any methods except draw_text and
+ * destroy.
+ */
+
+static void multifont_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
+ int x, int y, const wchar_t *string, int len,
+ int wide, int bold, int cellwidth);
+static void multifont_destroy(unifont *font);
+
+struct multifont {
+ struct unifont u;
+ unifont *main;
+ unifont *fallback;
+};
+
+static const struct unifont_vtable multifont_vtable = {
+ NULL, /* creation is done specially */
+ NULL,
+ multifont_destroy,
+ NULL,
+ multifont_draw_text,
+ NULL,
+ NULL,
+ NULL,
+ "client",
+};
+
+unifont *multifont_create(GtkWidget *widget, const char *name,
+ int wide, int bold,
+ int shadowoffset, int shadowalways)
+{
+ int i;
+ unifont *font, *fallback;
+ struct multifont *mfont;
+
+ font = unifont_create(widget, name, wide, bold,
+ shadowoffset, shadowalways);
+ if (!font)
+ return NULL;
+
+ fallback = NULL;
+ if (font->want_fallback) {
+ for (i = 0; i < lenof(unifont_types); i++) {
+ if (unifont_types[i]->create_fallback) {
+ fallback = unifont_types[i]->create_fallback
+ (widget, font->height, wide, bold,
+ shadowoffset, shadowalways);
+ if (fallback)
+ break;
+ }
+ }
+ }
+
+ /*
+ * Construct our multifont. Public members are all copied from the
+ * primary font we're wrapping.
+ */
+ mfont = snew(struct multifont);
+ mfont->u.vt = &multifont_vtable;
+ mfont->u.width = font->width;
+ mfont->u.ascent = font->ascent;
+ mfont->u.descent = font->descent;
+ mfont->u.height = font->height;
+ mfont->u.public_charset = font->public_charset;
+ mfont->u.want_fallback = FALSE; /* shouldn't be needed, but just in case */
+ mfont->main = font;
+ mfont->fallback = fallback;
+
+ return (unifont *)mfont;
+}
+
+static void multifont_destroy(unifont *font)
+{
+ struct multifont *mfont = (struct multifont *)font;
+ unifont_destroy(mfont->main);
+ if (mfont->fallback)
+ unifont_destroy(mfont->fallback);
+ sfree(font);
+}
+
+static void multifont_draw_text(GdkDrawable *target, GdkGC *gc, unifont *font,
+ int x, int y, const wchar_t *string, int len,
+ int wide, int bold, int cellwidth)
+{
+ struct multifont *mfont = (struct multifont *)font;
+ int ok, i;
+
+ while (len > 0) {
+ /*
+ * Find a maximal sequence of characters which are, or are
+ * not, supported by our main font.
+ */
+ ok = mfont->main->vt->has_glyph(mfont->main, string[0]);
+ for (i = 1;
+ i < len &&
+ !mfont->main->vt->has_glyph(mfont->main, string[i]) == !ok;
+ i++);
+
+ /*
+ * Now display it.
+ */
+ unifont_draw_text(target, gc, ok ? mfont->main : mfont->fallback,
+ x, y, string, i, wide, bold, cellwidth);
+ string += i;
+ len -= i;
+ x += i * cellwidth;
+ }
+}
+
#if GTK_CHECK_VERSION(2,0,0)
/* ----------------------------------------------------------------------
/*
* Otherwise, ordinary strcasecmp.
*/
- return g_strcasecmp(a, b);
+ return g_ascii_strcasecmp(a, b);
}
static int fontinfo_realname_compare(void *av, void *bv)
*/
info->fontclass->draw_text(fs->preview_pixmap, gc, font,
0, font->ascent,
- "bankrupt jilted showmen quiz convex fogey",
+ L"bankrupt jilted showmen quiz convex fogey",
41, FALSE, FALSE, font->width);
info->fontclass->draw_text(fs->preview_pixmap, gc, font,
0, font->ascent + font->height,
- "BANKRUPT JILTED SHOWMEN QUIZ CONVEX FOGEY",
+ L"BANKRUPT JILTED SHOWMEN QUIZ CONVEX FOGEY",
41, FALSE, FALSE, font->width);
/*
* The ordering of punctuation here is also selected
*/
info->fontclass->draw_text(fs->preview_pixmap, gc, font,
0, font->ascent + font->height * 2,
- "0123456789!?,.:;<>()[]{}\\/`'\"+*-=~#_@|%&^$",
+ L"0123456789!?,.:;<>()[]{}\\/`'\"+*-=~#_@|%&^$",
42, FALSE, FALSE, font->width);
}
gdk_gc_unref(gc);