Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 2371 insertions, 0 deletions

diff --git a/nx-X11/programs/xterm/fontutils.c b/nx-X11/programs/xterm/fontutils.c
new file mode 100644
index 000000000..fb4c6373c
--- /dev/null
+++ b/nx-X11/programs/xterm/fontutils.c
@@ -0,0 +1,2371 @@
+/* $XTermId: fontutils.c,v 1.184 2005/11/03 13:17:27 tom Exp $ */
+
+/*
+ * $XFree86: xc/programs/xterm/fontutils.c,v 1.55 2005/11/03 13:17:27 dickey Exp $
+ */
+
+/************************************************************
+
+Copyright 1998-2004,2005 by Thomas E. Dickey
+
+                        All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name(s) of the above copyright
+holders shall not be used in advertising or otherwise to promote the
+sale, use or other dealings in this Software without prior written
+authorization.
+
+********************************************************/
+
+/*
+ * A portion of this module (for FontNameProperties) was adapted from EMU 1.3;
+ * it constructs font names with specific properties changed, e.g., for bold
+ * and double-size characters.
+ */
+
+#define RES_OFFSET(field)	XtOffsetOf(SubResourceRec, field)
+
+#include <fontutils.h>
+#include <X11/Xmu/Drawing.h>
+
+#include <main.h>
+#include <data.h>
+#include <menu.h>
+#include <xstrings.h>
+#include <xterm.h>
+
+#include <stdio.h>
+#include <ctype.h>
+
+/* from X11/Xlibint.h - not all vendors install this file */
+#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
+			     (((cs)->rbearing|(cs)->lbearing| \
+			       (cs)->ascent|(cs)->descent) == 0))
+
+#define CI_GET_CHAR_INFO_1D(fs,col,def,cs) \
+{ \
+    cs = def; \
+    if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
+	if (fs->per_char == NULL) { \
+	    cs = &fs->min_bounds; \
+	} else { \
+	    cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
+	    if (CI_NONEXISTCHAR(cs)) cs = def; \
+	} \
+    } \
+}
+
+#define CI_GET_CHAR_INFO_2D(fs,row,col,def,cs) \
+{ \
+    cs = def; \
+    if (row >= fs->min_byte1 && row <= fs->max_byte1 && \
+	col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
+	if (fs->per_char == NULL) { \
+	    cs = &fs->min_bounds; \
+	} else { \
+	    cs = &fs->per_char[((row - fs->min_byte1) * \
+				(fs->max_char_or_byte2 - \
+				 fs->min_char_or_byte2 + 1)) + \
+			       (col - fs->min_char_or_byte2)]; \
+	    if (CI_NONEXISTCHAR(cs)) cs = def; \
+	} \
+    } \
+}
+
+#define MAX_FONTNAME 200
+
+/*
+ * A structure to hold the relevant properties from a font
+ * we need to make a well formed font name for it.
+ */
+typedef struct {
+    /* registry, foundry, family */
+    char *beginning;
+    /* weight */
+    char *weight;
+    /* slant */
+    char *slant;
+    /* wideness */
+    char *wideness;
+    /* add style */
+    char *add_style;
+    int pixel_size;
+    char *point_size;
+    int res_x;
+    int res_y;
+    char *spacing;
+    int average_width;
+    /* charset registry, charset encoding */
+    char *end;
+} FontNameProperties;
+
+#if OPT_SHIFT_FONTS
+static void lookupOneFontSize(TScreen *, int);
+#endif
+
+/*
+ * Returns the fields from start to stop in a dash- separated string.  This
+ * function will modify the source, putting '\0's in the appropiate place and
+ * moving the beginning forward to after the '\0'
+ *
+ * This will NOT work for the last field (but we won't need it).
+ */
+static char *
+n_fields(char **source, int start, int stop)
+{
+    int i;
+    char *str, *str1;
+
+    /*
+     * find the start-1th dash
+     */
+    for (i = start - 1, str = *source; i; i--, str++)
+	if ((str = strchr(str, '-')) == 0)
+	    return 0;
+
+    /*
+     * find the stopth dash
+     */
+    for (i = stop - start + 1, str1 = str; i; i--, str1++)
+	if ((str1 = strchr(str1, '-')) == 0)
+	    return 0;
+
+    /*
+     * put a \0 at the end of the fields
+     */
+    *(str1 - 1) = '\0';
+
+    /*
+     * move source forward
+     */
+    *source = str1;
+
+    return str;
+}
+
+/*
+ * Gets the font properties from a given font structure.  We use the FONT name
+ * to find them out, since that seems easier.
+ *
+ * Returns a pointer to a static FontNameProperties structure
+ * or NULL on error.
+ */
+static FontNameProperties *
+get_font_name_props(Display * dpy, XFontStruct * fs, char *result)
+{
+    static FontNameProperties props;
+    static char *last_name;
+
+    XFontProp *fp;
+    int i;
+    Atom fontatom = XInternAtom(dpy, "FONT", False);
+    char *name;
+    char *str;
+
+    /*
+     * first get the full font name
+     */
+    for (name = 0, i = 0, fp = fs->properties;
+	 i < fs->n_properties;
+	 i++, fp++)
+	if (fp->name == fontatom)
+	    name = XGetAtomName(dpy, fp->card32);
+
+    if (name == 0)
+	return 0;
+
+    /*
+     * XGetAtomName allocates memory - don't leak
+     */
+    if (last_name != 0)
+	XFree(last_name);
+    last_name = name;
+
+    if (result != 0) {
+	if (strlen(name) < MAX_FONTNAME - 1) {
+	    strcpy(result, name);
+	} else {
+	    TRACE(("fontname too large: %s\n", name));
+	    return 0;
+	}
+    }
+
+    /*
+     * Now split it up into parts and put them in
+     * their places. Since we are using parts of
+     * the original string, we must not free the Atom Name
+     */
+
+    /* registry, foundry, family */
+    if ((props.beginning = n_fields(&name, 1, 3)) == 0)
+	return 0;
+
+    /* weight is the next */
+    if ((props.weight = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* slant */
+    if ((props.slant = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* width */
+    if ((props.wideness = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* add style */
+    if ((props.add_style = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* pixel size */
+    if ((str = n_fields(&name, 1, 1)) == 0)
+	return 0;
+    if ((props.pixel_size = atoi(str)) == 0)
+	return 0;
+
+    /* point size */
+    if ((props.point_size = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* res_x */
+    if ((str = n_fields(&name, 1, 1)) == 0)
+	return 0;
+    if ((props.res_x = atoi(str)) == 0)
+	return 0;
+
+    /* res_y */
+    if ((str = n_fields(&name, 1, 1)) == 0)
+	return 0;
+    if ((props.res_y = atoi(str)) == 0)
+	return 0;
+
+    /* spacing */
+    if ((props.spacing = n_fields(&name, 1, 1)) == 0)
+	return 0;
+
+    /* average width */
+    if ((str = n_fields(&name, 1, 1)) == 0)
+	return 0;
+    if ((props.average_width = atoi(str)) == 0)
+	return 0;
+
+    /* the rest: charset registry and charset encoding */
+    props.end = name;
+
+    return &props;
+}
+
+#define ALLOCHUNK(n) ((n | 127) + 1)
+
+static void
+alloca_fontname(char **result, unsigned next)
+{
+    unsigned last = (*result != 0) ? strlen(*result) : 0;
+    unsigned have = (*result != 0) ? ALLOCHUNK(last) : 0;
+    unsigned want = last + next + 2;
+
+    if (want >= have) {
+	want = ALLOCHUNK(want);
+	if (last != 0) {
+	    *result = TypeRealloc(char, want, *result);
+	} else {
+	    if ((*result = TypeMallocN(char, want)) != 0)
+		**result = '\0';
+	}
+    }
+}
+
+static void
+append_fontname_str(char **result, char *value)
+{
+    if (value == 0)
+	value = "*";
+    alloca_fontname(result, strlen(value));
+    if (*result != 0) {
+	if (**result != '\0')
+	    strcat(*result, "-");
+	strcat(*result, value);
+    }
+}
+
+static void
+append_fontname_num(char **result, int value)
+{
+    if (value < 0) {
+	append_fontname_str(result, "*");
+    } else {
+	char temp[100];
+	sprintf(temp, "%d", value);
+	append_fontname_str(result, temp);
+    }
+}
+
+/*
+ * Take the given font props and try to make a well formed font name specifying
+ * the same base font and size and everything, but with different weight/width
+ * according to the parameters.  The return value is allocated, should be freed
+ * by the caller.
+ */
+static char *
+derive_font_name(FontNameProperties * props,
+		 char *use_weight,
+		 int use_average_width,
+		 char *use_encoding)
+{
+    char *result = 0;
+
+    append_fontname_str(&result, props->beginning);
+    append_fontname_str(&result, use_weight);
+    append_fontname_str(&result, props->slant);
+    append_fontname_str(&result, 0);
+    append_fontname_str(&result, 0);
+    append_fontname_num(&result, props->pixel_size);
+    append_fontname_str(&result, props->point_size);
+    append_fontname_num(&result, props->res_x);
+    append_fontname_num(&result, props->res_y);
+    append_fontname_str(&result, props->spacing);
+    append_fontname_num(&result, use_average_width);
+    append_fontname_str(&result, use_encoding);
+
+    return result;
+}
+
+static char *
+bold_font_name(FontNameProperties * props, int use_average_width)
+{
+    return derive_font_name(props, "bold", use_average_width, props->end);
+}
+
+#if OPT_WIDE_CHARS
+#define derive_wide_font(props, weight) \
+	derive_font_name(props, weight, props->average_width * 2, "ISO10646-1")
+
+static char *
+wide_font_name(FontNameProperties * props)
+{
+    return derive_wide_font(props, "medium");
+}
+
+static char *
+widebold_font_name(FontNameProperties * props)
+{
+    return derive_wide_font(props, "bold");
+}
+#endif /* OPT_WIDE_CHARS */
+
+#if OPT_DEC_CHRSET
+/*
+ * Take the given font props and try to make a well formed font name specifying
+ * the same base font but changed depending on the given attributes and chrset.
+ *
+ * For double width fonts, we just double the X-resolution, for double height
+ * fonts we double the pixel-size and Y-resolution
+ */
+char *
+xtermSpecialFont(TScreen * screen, unsigned atts, unsigned chrset)
+{
+#if OPT_TRACE
+    static char old_spacing[80];
+    static FontNameProperties old_props;
+#endif
+    FontNameProperties *props;
+    char *result = 0;
+    char *weight;
+    int pixel_size;
+    int res_x;
+    int res_y;
+
+    props = get_font_name_props(screen->display, screen->fnt_norm, (char *) 0);
+    if (props == 0)
+	return result;
+
+    pixel_size = props->pixel_size;
+    res_x = props->res_x;
+    res_y = props->res_y;
+    if (atts & BOLD)
+	weight = "bold";
+    else
+	weight = props->weight;
+
+    if (CSET_DOUBLE(chrset))
+	res_x *= 2;
+
+    if (chrset == CSET_DHL_TOP
+	|| chrset == CSET_DHL_BOT) {
+	res_y *= 2;
+	pixel_size *= 2;
+    }
+#if OPT_TRACE
+    if (old_props.res_x != res_x
+	|| old_props.res_x != res_y
+	|| old_props.pixel_size != pixel_size
+	|| strcmp(old_props.spacing, props->spacing)) {
+	TRACE(("xtermSpecialFont(atts = %#x, chrset = %#x)\n", atts, chrset));
+	TRACE(("res_x      = %d\n", res_x));
+	TRACE(("res_y      = %d\n", res_y));
+	TRACE(("point_size = %s\n", props->point_size));
+	TRACE(("pixel_size = %d\n", pixel_size));
+	TRACE(("spacing    = %s\n", props->spacing));
+	old_props.res_x = res_x;
+	old_props.res_x = res_y;
+	old_props.pixel_size = pixel_size;
+	old_props.spacing = strcpy(old_spacing, props->spacing);
+    }
+#endif
+
+    append_fontname_str(&result, props->beginning);
+    append_fontname_str(&result, weight);
+    append_fontname_str(&result, props->slant);
+    append_fontname_str(&result, props->wideness);
+    append_fontname_str(&result, props->add_style);
+    append_fontname_num(&result, pixel_size);
+    append_fontname_str(&result, props->point_size);
+    append_fontname_num(&result, (atts & NORESOLUTION) ? -1 : res_x);
+    append_fontname_num(&result, (atts & NORESOLUTION) ? -1 : res_y);
+    append_fontname_str(&result, props->spacing);
+    append_fontname_str(&result, 0);
+    append_fontname_str(&result, props->end);
+
+    return result;
+}
+#endif /* OPT_DEC_CHRSET */
+
+/*
+ * Case-independent comparison for font-names, including wildcards.
+ * XLFD allows '?' as a wildcard, but we do not handle that (no one seems
+ * to use it).
+ */
+static Bool
+same_font_name(char *pattern, char *match)
+{
+    while (*pattern && *match) {
+	if (*pattern == *match) {
+	    pattern++;
+	    match++;
+	} else if (*pattern == '*' || *match == '*') {
+	    if (same_font_name(pattern + 1, match)) {
+		return True;
+	    } else if (same_font_name(pattern, match + 1)) {
+		return True;
+	    } else {
+		return False;
+	    }
+	} else {
+	    int p = char2lower(*pattern++);
+	    int m = char2lower(*match++);
+	    if (p != m)
+		return False;
+	}
+    }
+    return (*pattern == *match);	/* both should be NUL */
+}
+
+/*
+ * Double-check the fontname that we asked for versus what the font server
+ * actually gave us.  The larger fixed fonts do not always have a matching bold
+ * font, and the font server may try to scale another font or otherwise
+ * substitute a mismatched font.
+ *
+ * If we cannot get what we requested, we will fallback to the original
+ * behavior, which simulates bold by overstriking each character at one pixel
+ * offset.
+ */
+static int
+got_bold_font(Display * dpy, XFontStruct * fs, char *requested)
+{
+    char actual[MAX_FONTNAME];
+    int got;
+
+    if (get_font_name_props(dpy, fs, actual) == 0)
+	got = 0;
+    else
+	got = same_font_name(requested, actual);
+    return got;
+}
+
+/*
+ * If the font server tries to adjust another font, it may not adjust it
+ * properly.  Check that the bounding boxes are compatible.  Otherwise we'll
+ * leave trash on the display when we mix normal and bold fonts.
+ */
+static int
+same_font_size(XtermWidget xw, XFontStruct * nfs, XFontStruct * bfs)
+{
+    TRACE(("same_font_size height %d/%d, min %d/%d max %d/%d\n",
+	   nfs->ascent + nfs->descent,
+	   bfs->ascent + bfs->descent,
+	   nfs->min_bounds.width, bfs->min_bounds.width,
+	   nfs->max_bounds.width, bfs->max_bounds.width));
+    return xw->screen.free_bold_box
+	|| ((nfs->ascent + nfs->descent) == (bfs->ascent + bfs->descent)
+	    && (nfs->min_bounds.width == bfs->min_bounds.width
+		|| nfs->min_bounds.width == bfs->min_bounds.width + 1)
+	    && (nfs->max_bounds.width == bfs->max_bounds.width
+		|| nfs->max_bounds.width == bfs->max_bounds.width + 1));
+}
+
+/*
+ * Check if the font looks like it has fixed width
+ */
+static int
+is_fixed_font(XFontStruct * fs)
+{
+    if (fs)
+	return (fs->min_bounds.width == fs->max_bounds.width);
+    return 1;
+}
+
+/*
+ * Check if the font looks like a double width font (i.e. contains
+ * characters of width X and 2X
+ */
+#if OPT_WIDE_CHARS
+static int
+is_double_width_font(XFontStruct * fs)
+{
+    return ((2 * fs->min_bounds.width) == fs->max_bounds.width);
+}
+#else
+#define is_double_width_font(fs) 0
+#endif
+
+#if OPT_WIDE_CHARS && OPT_RENDERFONT && defined(HAVE_TYPE_FCCHAR32)
+#define HALF_WIDTH_TEST_STRING "1234567890"
+
+/* '1234567890' in Chinese characters in UTF-8 */
+#define FULL_WIDTH_TEST_STRING "\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89" \
+                               "\xe5\x9b\x9b\xe4\xba\x94" \
+			       "\xef\xa7\x91\xe4\xb8\x83\xe5\x85\xab" \
+			       "\xe4\xb9\x9d\xef\xa6\xb2"
+
+/* '1234567890' in Korean script in UTF-8 */
+#define FULL_WIDTH_TEST_STRING2 "\xec\x9d\xbc\xec\x9d\xb4\xec\x82\xbc" \
+                                "\xec\x82\xac\xec\x98\xa4" \
+			        "\xec\x9c\xa1\xec\xb9\xa0\xed\x8c\x94" \
+			        "\xea\xb5\xac\xec\x98\x81"
+
+#define HALF_WIDTH_CHAR1  0x0031	/* 'l' */
+#define HALF_WIDTH_CHAR2  0x0057	/* 'W' */
+#define FULL_WIDTH_CHAR1  0x4E00	/* CJK Ideograph 'number one' */
+#define FULL_WIDTH_CHAR2  0xAC00	/* Korean script syllable 'Ka' */
+
+static int
+is_double_width_font_xft(Display * dpy, XftFont * font)
+{
+    XGlyphInfo gi1, gi2;
+    FcChar32 c1 = HALF_WIDTH_CHAR1, c2 = HALF_WIDTH_CHAR2;
+    char *fwstr = FULL_WIDTH_TEST_STRING;
+    char *hwstr = HALF_WIDTH_TEST_STRING;
+
+    /* Some Korean fonts don't have Chinese characters at all. */
+    if (!XftCharExists(dpy, font, FULL_WIDTH_CHAR1)) {
+	if (!XftCharExists(dpy, font, FULL_WIDTH_CHAR2))
+	    return 0;		/* Not a CJK font */
+	else			/* a Korean font without CJK Ideographs */
+	    fwstr = FULL_WIDTH_TEST_STRING2;
+    }
+
+    XftTextExtents32(dpy, font, &c1, 1, &gi1);
+    XftTextExtents32(dpy, font, &c2, 1, &gi2);
+    if (gi1.xOff != gi2.xOff)	/* Not a fixed-width font */
+	return 0;
+
+    XftTextExtentsUtf8(dpy, font, (FcChar8 *) hwstr, (int) strlen(hwstr), &gi1);
+    XftTextExtentsUtf8(dpy, font, (FcChar8 *) fwstr, (int) strlen(fwstr), &gi2);
+
+    /*
+     * fontconfig and Xft prior to 2.2(?) set the width of half-width
+     * characters identical to that of full-width character in CJK double-width
+     * (bi-width / monospace) font even though the former is half as wide as
+     * the latter.  This was fixed sometime before the release of fontconfig
+     * 2.2 in early 2003.  See
+     *  http://bugzilla.mozilla.org/show_bug.cgi?id=196312
+     * In the meantime, we have to check both possibilities.
+     */
+    return ((2 * gi1.xOff == gi2.xOff) || (gi1.xOff == gi2.xOff));
+}
+#else
+#define is_double_width_font_xft(dpy, xftfont) 0
+#endif
+
+#define EmptyFont(fs) (fs != 0 \
+		   && ((fs)->ascent + (fs)->descent == 0 \
+		    || (fs)->max_bounds.width == 0))
+
+#define FontSize(fs) (((fs)->ascent + (fs)->descent) \
+		    *  (fs)->max_bounds.width)
+
+const VTFontNames *
+xtermFontName(char *normal)
+{
+    static VTFontNames data;
+    memset(&data, 0, sizeof(data));
+    data.f_n = normal;
+    return &data;
+}
+
+static void
+cache_menu_font_name(TScreen * screen, int fontnum, int which, const char *name)
+{
+    if (name != 0) {
+	char *last = screen->menu_font_names[fontnum][which];
+	if (last != 0) {
+	    if (strcmp(last, name)) {
+		free(last);
+		TRACE(("caching menu fontname %d.%d %s\n", fontnum, which, name));
+		screen->menu_font_names[fontnum][which] = x_strdup(name);
+	    }
+	} else {
+	    TRACE(("caching menu fontname %d.%d %s\n", fontnum, which, name));
+	    screen->menu_font_names[fontnum][which] = x_strdup(name);
+	}
+    }
+}
+
+int
+xtermLoadFont(XtermWidget xw,
+	      const VTFontNames * fonts,
+	      Bool doresize,
+	      int fontnum)
+{
+    TScreen *screen = &(xw->screen);
+
+    VTFontNames myfonts;
+    /* FIXME: use XFreeFontInfo */
+    FontNameProperties *fp;
+    XFontStruct *nfs = NULL;
+    XFontStruct *bfs = NULL;
+#if OPT_WIDE_CHARS
+    XFontStruct *wfs = NULL;
+    XFontStruct *wbfs = NULL;
+#endif
+    XGCValues xgcv;
+    unsigned long mask;
+    GC new_normalGC = NULL;
+    GC new_normalboldGC = NULL;
+    GC new_reverseGC = NULL;
+    GC new_reverseboldGC = NULL;
+    Pixel new_normal;
+    Pixel new_revers;
+    char *tmpname = NULL;
+    char normal[MAX_FONTNAME];
+    Bool proportional = False;
+
+    memset(&myfonts, 0, sizeof(myfonts));
+    if (fonts != 0)
+	myfonts = *fonts;
+    if (myfonts.f_n == 0)
+	return 0;
+
+    if (fontnum == fontMenu_fontescape
+	&& myfonts.f_n != screen->MenuFontName(fontnum)) {
+	if ((tmpname = x_strdup(myfonts.f_n)) == 0)
+	    return 0;
+    }
+
+    TRACE(("xtermLoadFont #%d normal %s\n", fontnum, NonNull(myfonts.f_n)));
+    TRACE(("xtermLoadFont #%d bold   %s\n", fontnum, NonNull(myfonts.f_b)));
+#if OPT_WIDE_CHARS
+    TRACE(("xtermLoadFont #%d wide   %s\n", fontnum, NonNull(myfonts.f_w)));
+    TRACE(("xtermLoadFont #%d w/bold %s\n", fontnum, NonNull(myfonts.f_wb)));
+#endif
+
+    if (!(nfs = XLoadQueryFont(screen->display, myfonts.f_n)))
+	goto bad;
+    if (EmptyFont(nfs))
+	goto bad;		/* can't use a 0-sized font */
+
+    strcpy(normal, myfonts.f_n);
+    if (myfonts.f_b == 0) {
+	fp = get_font_name_props(screen->display, nfs, normal);
+	if (fp != 0) {
+	    myfonts.f_b = bold_font_name(fp, fp->average_width);
+	    if ((bfs = XLoadQueryFont(screen->display, myfonts.f_b)) == 0) {
+		myfonts.f_b = bold_font_name(fp, -1);
+		bfs = XLoadQueryFont(screen->display, myfonts.f_b);
+	    }
+	    TRACE(("...derived bold %s\n", myfonts.f_b));
+	}
+	if (fp == 0 || bfs == 0) {
+	    bfs = nfs;
+	    TRACE(("...cannot load a matching bold font\n"));
+	} else if (same_font_size(xw, nfs, bfs)
+		   && got_bold_font(screen->display, bfs, myfonts.f_b)) {
+	    TRACE(("...got a matching bold font\n"));
+	    cache_menu_font_name(screen, fontnum, fBold, myfonts.f_b);
+	} else {
+	    XFreeFont(screen->display, bfs);
+	    bfs = nfs;
+	    TRACE(("...did not get a matching bold font\n"));
+	}
+    } else if ((bfs = XLoadQueryFont(screen->display, myfonts.f_b)) == 0) {
+	bfs = nfs;
+	TRACE(("...cannot load bold font %s\n", myfonts.f_b));
+    } else {
+	cache_menu_font_name(screen, fontnum, fBold, myfonts.f_b);
+    }
+
+    /*
+     * If there is no widefont specified, fake it by doubling AVERAGE_WIDTH
+     * of normal fonts XLFD, and asking for it.  This plucks out 18x18ja
+     * and 12x13ja as the corresponding fonts for 9x18 and 6x13.
+     */
+    if_OPT_WIDE_CHARS(screen, {
+	char bold[MAX_FONTNAME];
+
+	if (myfonts.f_w != 0) {
+	    cache_menu_font_name(screen, fontnum, fWide, myfonts.f_w);
+	} else if (!is_double_width_font(nfs)) {
+	    fp = get_font_name_props(screen->display, nfs, normal);
+	    if (fp != 0) {
+		myfonts.f_w = wide_font_name(fp);
+		TRACE(("...derived wide %s\n", myfonts.f_w));
+		cache_menu_font_name(screen, fontnum, fWide, myfonts.f_w);
+	    }
+	}
+
+	if (myfonts.f_w) {
+	    wfs = XLoadQueryFont(screen->display, myfonts.f_w);
+	} else {
+	    wfs = nfs;
+	}
+
+	if (myfonts.f_wb != 0) {
+	    cache_menu_font_name(screen, fontnum, fWBold, myfonts.f_wb);
+	} else if (!is_double_width_font(bfs)) {
+	    fp = get_font_name_props(screen->display, bfs, bold);
+	    if (fp != 0) {
+		myfonts.f_wb = widebold_font_name(fp);
+		TRACE(("...derived wide/bold %s\n", myfonts.f_wb));
+		cache_menu_font_name(screen, fontnum, fWBold, myfonts.f_wb);
+	    }
+	}
+
+	if (myfonts.f_wb) {
+	    wbfs = XLoadQueryFont(screen->display, myfonts.f_wb);
+	} else if (is_double_width_font(bfs)) {
+	    wbfs = bfs;
+	} else {
+	    wbfs = wfs;
+	    TRACE(("...cannot load wide bold font %s\n", myfonts.f_wb));
+	}
+
+	if (EmptyFont(wbfs))
+	    goto bad;		/* can't use a 0-sized font */
+    });
+
+    /*
+     * Most of the time this call to load the font will succeed, even if
+     * there is no wide font :  the X server doubles the width of the
+     * normal font, or similar.
+     *
+     * But if it did fail for some reason, then nevermind.
+     */
+    if (EmptyFont(bfs))
+	goto bad;		/* can't use a 0-sized font */
+
+    if (!same_font_size(xw, nfs, bfs)
+	&& (is_fixed_font(nfs) && is_fixed_font(bfs))) {
+	TRACE(("...ignoring mismatched normal/bold fonts\n"));
+	XFreeFont(screen->display, bfs);
+	bfs = nfs;
+    }
+
+    if_OPT_WIDE_CHARS(screen, {
+	if (wfs != 0
+	    && wbfs != 0
+	    && !same_font_size(xw, wfs, wbfs)
+	    && (is_fixed_font(wfs) && is_fixed_font(wbfs))) {
+	    TRACE(("...ignoring mismatched normal/bold wide fonts\n"));
+	    XFreeFont(screen->display, wbfs);
+	    wbfs = wfs;
+	}
+    });
+
+    /*
+     * Normal/bold fonts should be the same width.  Also, the min/max
+     * values should be the same.
+     */
+    if (!is_fixed_font(nfs)
+	|| !is_fixed_font(bfs)
+	|| nfs->max_bounds.width != bfs->max_bounds.width) {
+	TRACE(("Proportional font! normal %d/%d, bold %d/%d\n",
+	       nfs->min_bounds.width,
+	       nfs->max_bounds.width,
+	       bfs->min_bounds.width,
+	       bfs->max_bounds.width));
+	proportional = True;
+    }
+
+    if_OPT_WIDE_CHARS(screen, {
+	if (wfs != 0
+	    && wbfs != 0
+	    && (!is_fixed_font(wfs)
+		|| !is_fixed_font(wbfs)
+		|| wfs->max_bounds.width != wbfs->max_bounds.width)) {
+	    TRACE(("Proportional font! wide %d/%d, wide bold %d/%d\n",
+		   wfs->min_bounds.width,
+		   wfs->max_bounds.width,
+		   wbfs->min_bounds.width,
+		   wbfs->max_bounds.width));
+	    proportional = True;
+	}
+    });
+
+    /* TODO : enforce that the width of the wide font is 2* the width
+       of the narrow font */
+
+    mask = (GCFont | GCForeground | GCBackground | GCGraphicsExposures |
+	    GCFunction);
+
+    new_normal = getXtermForeground(xw->flags, xw->cur_foreground);
+    new_revers = getXtermBackground(xw->flags, xw->cur_background);
+
+    xgcv.font = nfs->fid;
+    xgcv.foreground = new_normal;
+    xgcv.background = new_revers;
+    xgcv.graphics_exposures = True;	/* default */
+    xgcv.function = GXcopy;
+
+    new_normalGC = XtGetGC((Widget) xw, mask, &xgcv);
+    if (!new_normalGC)
+	goto bad;
+
+    if (nfs == bfs) {		/* there is no bold font */
+	new_normalboldGC = new_normalGC;
+    } else {
+	xgcv.font = bfs->fid;
+	new_normalboldGC = XtGetGC((Widget) xw, mask, &xgcv);
+	if (!new_normalboldGC)
+	    goto bad;
+    }
+
+    xgcv.font = nfs->fid;
+    xgcv.foreground = new_revers;
+    xgcv.background = new_normal;
+    new_reverseGC = XtGetGC((Widget) xw, mask, &xgcv);
+    if (!new_reverseGC)
+	goto bad;
+
+    if (nfs == bfs) {		/* there is no bold font */
+	new_reverseboldGC = new_reverseGC;
+    } else {
+	xgcv.font = bfs->fid;
+	new_reverseboldGC = XtGetGC((Widget) xw, mask, &xgcv);
+	if (!new_reverseboldGC)
+	    goto bad;
+    }
+
+    if (NormalGC(screen) != NormalBoldGC(screen))
+	XtReleaseGC((Widget) xw, NormalBoldGC(screen));
+    XtReleaseGC((Widget) xw, NormalGC(screen));
+
+    if (ReverseGC(screen) != ReverseBoldGC(screen))
+	XtReleaseGC((Widget) xw, ReverseBoldGC(screen));
+    XtReleaseGC((Widget) xw, ReverseGC(screen));
+
+    NormalGC(screen) = new_normalGC;
+    NormalBoldGC(screen) = new_normalboldGC;
+    ReverseGC(screen) = new_reverseGC;
+    ReverseBoldGC(screen) = new_reverseboldGC;
+
+    /*
+     * If we're switching fonts, free the old ones.  Otherwise we'll leak
+     * the memory that is associated with the old fonts.  The
+     * XLoadQueryFont call allocates a new XFontStruct.
+     */
+    if (screen->fnt_bold != 0
+	&& screen->fnt_bold != screen->fnt_norm)
+	XFreeFont(screen->display, screen->fnt_bold);
+    if (screen->fnt_norm != 0)
+	XFreeFont(screen->display, screen->fnt_norm);
+
+    screen->fnt_norm = nfs;
+    screen->fnt_bold = bfs;
+#if OPT_WIDE_CHARS
+    screen->fnt_dwd = wfs;
+    if (wbfs == NULL)
+	wbfs = wfs;
+    screen->fnt_dwdb = wbfs;
+#endif
+    screen->fnt_prop = proportional;
+    screen->fnt_boxes = True;
+
+#if OPT_BOX_CHARS
+    /*
+     * Xterm uses character positions 1-31 of a font for the line-drawing
+     * characters.  Check that they are all present.  The null character
+     * (0) is special, and is not used.
+     */
+#if OPT_RENDERFONT
+    if (UsingRenderFont(xw)) {
+	/*
+	 * FIXME: we shouldn't even be here if we're using Xft.
+	 */
+	screen->fnt_boxes = False;
+	TRACE(("assume Xft missing line-drawing chars\n"));
+    } else
+#endif
+    {
+	unsigned ch;
+
+	for (ch = 1; ch < 32; ch++) {
+	    unsigned n = ch;
+#if OPT_WIDE_CHARS
+	    if (screen->utf8_mode || screen->unicode_font) {
+		n = dec2ucs(ch);
+		if (n == UCS_REPL)
+		    continue;
+	    }
+#endif
+	    if (xtermMissingChar(xw, n, nfs)) {
+		TRACE(("missing normal char #%d\n", n));
+		screen->fnt_boxes = False;
+		break;
+	    }
+	    if (xtermMissingChar(xw, n, bfs)) {
+		TRACE(("missing bold char #%d\n", n));
+		screen->fnt_boxes = False;
+		break;
+	    }
+	}
+    }
+    TRACE(("Will %suse internal line-drawing characters\n",
+	   screen->fnt_boxes ? "not " : ""));
+#endif
+
+    screen->enbolden = screen->bold_mode
+	&& ((nfs == bfs) || same_font_name(normal, myfonts.f_b));
+    TRACE(("Will %suse 1-pixel offset/overstrike to simulate bold\n",
+	   screen->enbolden ? "" : "not "));
+
+    set_menu_font(False);
+    screen->menu_font_number = fontnum;
+    set_menu_font(True);
+    if (tmpname) {		/* if setting escape or sel */
+	if (screen->MenuFontName(fontnum))
+	    free(screen->MenuFontName(fontnum));
+	screen->MenuFontName(fontnum) = tmpname;
+	if (fontnum == fontMenu_fontescape) {
+	    set_sensitivity(xw->screen.fontMenu,
+			    fontMenuEntries[fontMenu_fontescape].widget,
+			    True);
+	}
+#if OPT_SHIFT_FONTS
+	screen->menu_font_sizes[fontnum] = FontSize(nfs);
+#endif
+    }
+    set_cursor_gcs(screen);
+    xtermUpdateFontInfo(xw, doresize);
+    return 1;
+
+  bad:
+    if (tmpname)
+	free(tmpname);
+    if (new_normalGC)
+	XtReleaseGC((Widget) xw, new_normalGC);
+    if (new_normalboldGC && new_normalGC != new_normalboldGC)
+	XtReleaseGC((Widget) xw, new_normalboldGC);
+    if (new_reverseGC)
+	XtReleaseGC((Widget) xw, new_reverseGC);
+    if (new_reverseboldGC && new_reverseGC != new_reverseboldGC)
+	XtReleaseGC((Widget) xw, new_reverseboldGC);
+    if (nfs)
+	XFreeFont(screen->display, nfs);
+    if (bfs && nfs != bfs)
+	XFreeFont(screen->display, bfs);
+#if OPT_WIDE_CHARS
+    if (wfs)
+	XFreeFont(screen->display, wfs);
+    if (wbfs && wbfs != wfs)
+	XFreeFont(screen->display, wbfs);
+#endif
+    return 0;
+}
+
+#if OPT_LOAD_VTFONTS || OPT_WIDE_CHARS
+/*
+ * Collect font-names that we can modify with the load-vt-fonts() action.
+ */
+typedef struct {
+    VTFontNames default_font;
+    char *menu_font_names[fontMenu_lastBuiltin + 1][fMAX];
+} SubResourceRec;
+
+#define MERGE_SUBFONT(src,dst,name) \
+	if (dst.name == 0) { \
+	    TRACE(("MERGE_SUBFONT " #dst "." #name " merge %s\n", NonNull(src.name))); \
+	    dst.name = src.name; \
+	} else { \
+	    TRACE(("MERGE_SUBFONT " #dst "." #name " found %s\n", NonNull(dst.name))); \
+	}
+
+#define COPY_MENU_FONTS(src,dst) \
+	TRACE(("COPY_MENU_FONTS " #src " to " #dst "\n")); \
+	for (n = fontMenu_fontdefault; n <= fontMenu_lastBuiltin; ++n) { \
+	    for (m = 0; m < fMAX; ++m) { \
+		dst.menu_font_names[n][m] = src.menu_font_names[n][m]; \
+	    } \
+	}
+
+/*
+ * Load the "VT" font names from the given subresource name/class.  These
+ * correspond to the VT100 resources.
+ */
+static Bool
+xtermLoadVTFonts(XtermWidget w, char *myName, char *myClass)
+{
+    static Bool initialized = False;
+    static SubResourceRec original, referenceRec, subresourceRec;
+
+    /*
+     * These are duplicates of the VT100 font resources, but with a special
+     * application/classname passed in to distinguish them.
+     */
+    static XtResource font_resources[] =
+    {
+	Sres(XtNfont, XtCFont, default_font.f_n, DEFFONT),
+	Sres(XtNboldFont, XtCBoldFont, default_font.f_b, DEFBOLDFONT),
+#if OPT_WIDE_CHARS
+	Sres(XtNwideFont, XtCWideFont, default_font.f_w, DEFWIDEFONT),
+	Sres(XtNwideBoldFont, XtCWideBoldFont, default_font.f_wb, DEFWIDEBOLDFONT),
+#endif
+	Sres(XtNfont1, XtCFont1, MenuFontName(fontMenu_font1), NULL),
+	Sres(XtNfont2, XtCFont2, MenuFontName(fontMenu_font2), NULL),
+	Sres(XtNfont3, XtCFont3, MenuFontName(fontMenu_font3), NULL),
+	Sres(XtNfont4, XtCFont4, MenuFontName(fontMenu_font4), NULL),
+	Sres(XtNfont5, XtCFont5, MenuFontName(fontMenu_font5), NULL),
+	Sres(XtNfont6, XtCFont6, MenuFontName(fontMenu_font6), NULL),
+    };
+    Cardinal n, m;
+    Bool status = True;
+
+    if (!initialized) {
+
+	initialized = True;
+	TRACE(("xtermLoadVTFonts saving original\n"));
+	original.default_font = w->misc.default_font;
+	COPY_MENU_FONTS(w->screen, original);
+    }
+
+    if (myName == 0 || *myName == 0) {
+	TRACE(("xtermLoadVTFonts restoring original\n"));
+	w->misc.default_font = original.default_font;
+	COPY_MENU_FONTS(original, w->screen);
+	for (n = 0; n < XtNumber(original.menu_font_names); ++n)
+	    w->screen.MenuFontName(n) = original.MenuFontName(n);
+    } else {
+	TRACE(("xtermLoadVTFonts(%s, %s)\n", myName, myClass));
+
+	memset(&subresourceRec, 0, sizeof(subresourceRec));
+	XtGetSubresources((Widget) w, (XtPointer) &subresourceRec,
+			  myName, myClass,
+			  font_resources,
+			  (Cardinal) XtNumber(font_resources),
+			  NULL, (Cardinal) 0);
+
+	if (memcmp(&referenceRec, &subresourceRec, sizeof(referenceRec))) {
+
+	    /*
+	     * If a particular resource value was not found, use the original.
+	     */
+	    MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_n);
+	    MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_b);
+#if OPT_WIDE_CHARS
+	    MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_w);
+	    MERGE_SUBFONT(w->misc, subresourceRec, default_font.f_wb);
+#endif
+	    for (n = fontMenu_font1; n <= fontMenu_lastBuiltin; ++n)
+		MERGE_SUBFONT(w->screen, subresourceRec, MenuFontName(n));
+
+	    /*
+	     * Finally, copy the subresource data to the widget.
+	     */
+	    w->misc.default_font = subresourceRec.default_font;
+	    COPY_MENU_FONTS(subresourceRec, w->screen);
+	    w->screen.MenuFontName(fontMenu_fontdefault) = w->misc.default_font.f_n;
+	} else {
+	    TRACE(("...no resources found\n"));
+	    status = False;
+	}
+    }
+    return status;
+}
+
+#if OPT_WIDE_CHARS
+static Bool
+isWideFont(XFontStruct * fp, char *tag, Bool nullOk)
+{
+    Bool result = False;
+
+    (void) tag;
+    if (fp != 0) {
+	unsigned count = 0;
+	if (fp->min_byte1 == 0 && fp->max_byte1 == 0) {
+	    count = fp->max_char_or_byte2 - fp->min_char_or_byte2;
+	} else if (fp->min_char_or_byte2 < 256
+		   && fp->max_char_or_byte2 < 256) {
+	    unsigned first = (fp->min_byte1 << 8) + fp->min_char_or_byte2;
+	    unsigned last = (fp->max_byte1 << 8) + fp->max_char_or_byte2;
+	    count = last + 1 - first;
+	}
+	TRACE(("isWideFont(%s) found %d cells\n", tag, count));
+	result = (count > 256) ? True : False;
+    } else {
+	result = nullOk;
+    }
+    return result;
+}
+
+static Bool
+currentFontsAreWide(XtermWidget w, Bool nullOk)
+{
+    Bool result = True;
+    TScreen *screen = &(w->screen);
+
+    result = (isWideFont(screen->fnt_norm, "normal", nullOk)
+	      && isWideFont(screen->fnt_bold, "bold", nullOk)
+	      && isWideFont(screen->fnt_dwd, "wide", nullOk)
+	      && isWideFont(screen->fnt_dwdb, "wide-bold", nullOk));
+
+    TRACE(("currentFontsAreWide returns %d\n", result));
+    return result;
+}
+
+/*
+ * If the current fonts are not wide, load the UTF8 fonts.
+ *
+ * Called during initialization (for wide-character mode), the fonts have not
+ * been setup, so we pass nullOk=True to currentFontsAreWide().
+ *
+ * Called after initialization, e.g., in response to the UTF-8 menu entry
+ * (starting from narrow character mode), it checks if the fonts are not wide.
+ */
+Bool
+xtermLoadWideFonts(XtermWidget w, Bool nullOk)
+{
+    Bool result = currentFontsAreWide(w, nullOk);
+
+    /* FIXME: add a test for wide-font */
+    if (!result) {
+	result = xtermLoadVTFonts(w, "utf8Fonts", "Utf8Fonts");
+    }
+    TRACE(("xtermLoadWideFonts:%d\n", result));
+    return result;
+}
+#endif /* OPT_WIDE_CHARS */
+
+/*
+ * Restore the default fonts, i.e., if we had switched to wide-fonts.
+ */
+Bool
+xtermLoadDefaultFonts(XtermWidget w)
+{
+    Bool result;
+    result = xtermLoadVTFonts(w, NULL, NULL);
+    TRACE(("xtermLoadDefaultFonts:%d\n", result));
+    return result;
+}
+#endif /* OPT_LOAD_VTFONTS || OPT_WIDE_CHARS */
+
+#if OPT_LOAD_VTFONTS
+void
+HandleLoadVTFonts(Widget w GCC_UNUSED,
+		  XEvent * event GCC_UNUSED,
+		  String * params GCC_UNUSED,
+		  Cardinal *param_count GCC_UNUSED)
+{
+    static char empty[] = "";	/* appease strict compilers */
+
+    char buf[80];
+    char *myName = (*param_count > 0) ? params[0] : empty;
+    char *convert = (*param_count > 1) ? params[1] : myName;
+    char *myClass = (char *) MyStackAlloc(strlen(convert), buf);
+    int n;
+
+    TRACE(("HandleLoadVTFonts(%d)\n", *param_count));
+    strcpy(myClass, convert);
+    if (*param_count == 1
+	&& islower(CharOf(myClass[0])))
+	myClass[0] = toupper(CharOf(myClass[0]));
+
+    if (xtermLoadVTFonts(term, myName, myClass)) {
+	/*
+	 * When switching fonts, try to preserve the font-menu selection, since
+	 * it is less surprising to do that (if the font-switching can be
+	 * undone) than to switch to "Default".
+	 */
+	int font_number = term->screen.menu_font_number;
+	if (font_number > fontMenu_lastBuiltin)
+	    font_number = fontMenu_lastBuiltin;
+	for (n = 0; n < NMENUFONTS; ++n)
+	    term->screen.menu_font_sizes[n] = 0;
+	SetVTFont(term, font_number, True,
+		  ((font_number == fontMenu_fontdefault)
+		   ? &(term->misc.default_font)
+		   : NULL));
+    }
+
+    MyStackFree(myClass, buf);
+}
+#endif /* OPT_LOAD_VTFONTS */
+
+/*
+ * Set the limits for the box that outlines the cursor.
+ */
+void
+xtermSetCursorBox(TScreen * screen)
+{
+    static XPoint VTbox[NBOX];
+    XPoint *vp;
+
+    vp = &VTbox[1];
+    (vp++)->x = FontWidth(screen) - 1;
+    (vp++)->y = FontHeight(screen) - 1;
+    (vp++)->x = -(FontWidth(screen) - 1);
+    vp->y = -(FontHeight(screen) - 1);
+    screen->box = VTbox;
+}
+
+#define CACHE_XFT(dst,src) if (src != 0) {\
+	    dst[fontnum] = src;\
+	    TRACE(("%s[%d] = %d (%d,%d) by %d\n",\
+		#dst,\
+	    	fontnum,\
+		src->height,\
+		src->ascent,\
+		src->descent,\
+		src->max_advance_width));\
+	}
+
+#if OPT_RENDERFONT
+static XftFont *
+xtermOpenXft(Display * dpy, XftPattern * pat, const char *tag GCC_UNUSED)
+{
+    XftPattern *match;
+    XftResult status;
+    XftFont *result = 0;
+
+    if (pat != 0) {
+	match = XftFontMatch(dpy, DefaultScreen(dpy), pat, &status);
+	result = XftFontOpenPattern(dpy, match);
+	if ((result == 0) && match) {
+	    TRACE(("...did not match %s font\n", tag));
+	    XftPatternDestroy(match);
+	} else {
+	    TRACE(("...matched %s font\n", tag));
+	}
+    }
+    return result;
+}
+#endif
+
+/*
+ * Compute useful values for the font/window sizes
+ */
+void
+xtermComputeFontInfo(XtermWidget xw,
+		     struct _vtwin *win,
+		     XFontStruct * font,
+		     int sbwidth)
+{
+    TScreen *screen = &(xw->screen);
+
+    int i, j, width, height;
+
+#if OPT_RENDERFONT
+    /*
+     * xterm contains a lot of references to fonts, assuming they are fixed
+     * size.  This chunk of code overrides the actual font-selection (see
+     * drawXtermText()), if the user has selected render-font.  All of the
+     * font-loading for fixed-fonts still goes on whether or not this chunk
+     * overrides it.
+     */
+    if (xw->misc.render_font && !IsIconWin(screen, win)) {
+	Display *dpy = screen->display;
+	int fontnum = screen->menu_font_number;
+	XftFont *norm = screen->renderFontNorm[fontnum];
+	XftFont *bold = screen->renderFontBold[fontnum];
+	XftFont *ital = screen->renderFontItal[fontnum];
+#if OPT_RENDERWIDE
+	XftFont *wnorm = screen->renderWideNorm[fontnum];
+	XftFont *wbold = screen->renderWideBold[fontnum];
+	XftFont *wital = screen->renderWideItal[fontnum];
+#endif
+
+	if (norm == 0 && xw->misc.face_name) {
+	    XftPattern *pat;
+	    double face_size = xw->misc.face_size;
+
+	    TRACE(("xtermComputeFontInfo norm(face %s, size %f)\n",
+		   xw->misc.face_name,
+		   xw->misc.face_size));
+
+#if OPT_SHIFT_FONTS
+	    /*
+	     * If the user is switching font-sizes, make it follow the same
+	     * ratios to the default as the fixed fonts would, for easy
+	     * comparison.  There will be some differences since the fixed
+	     * fonts have a variety of height/width ratios, but this is simpler
+	     * than adding another resource value - and as noted above, the
+	     * data for the fixed fonts are available.
+	     */
+	    lookupOneFontSize(screen, fontnum);
+	    if (fontnum != fontMenu_fontdefault) {
+		int num = screen->menu_font_sizes[fontnum];
+		int den = screen->menu_font_sizes[0];
+		face_size = (1.0 * face_size * num) / den;
+		TRACE(("scaled using %d/%d -> %f\n", num, den, face_size));
+	    }
+#endif
+
+	    pat = XftNameParse(xw->misc.face_name);
+	    XftPatternBuild(pat,
+			    XFT_FAMILY, XftTypeString, "mono",
+			    XFT_SIZE, XftTypeDouble, face_size,
+			    XFT_SPACING, XftTypeInteger, XFT_MONO,
+			    (void *) 0);
+	    norm = xtermOpenXft(dpy, pat, "normal");
+
+	    if (norm != 0) {
+		XftPatternBuild(pat,
+				XFT_WEIGHT, XftTypeInteger, XFT_WEIGHT_BOLD,
+				XFT_CHAR_WIDTH, XftTypeInteger, norm->max_advance_width,
+				(void *) 0);
+		bold = xtermOpenXft(dpy, pat, "bold");
+
+#if OPT_ISO_COLORS
+		if (screen->italicULMode) {
+		    XftPatternBuild(pat,
+				    XFT_SLANT, XftTypeInteger, XFT_SLANT_ITALIC,
+				    XFT_CHAR_WIDTH, XftTypeInteger, norm->max_advance_width,
+				    (void *) 0);
+		    ital = xtermOpenXft(dpy, pat, "italic");
+		}
+#endif /* OPT_ISO_COLORS */
+
+		/*
+		 * FIXME:  just assume that the corresponding font has no
+		 * graphics characters.
+		 */
+		if (screen->fnt_boxes) {
+		    screen->fnt_boxes = False;
+		    TRACE(("Xft opened - will %suse internal line-drawing characters\n",
+			   screen->fnt_boxes ? "not " : ""));
+		}
+	    }
+
+	    if (pat)
+		XftPatternDestroy(pat);
+
+	    CACHE_XFT(screen->renderFontNorm, norm);
+	    CACHE_XFT(screen->renderFontBold, bold);
+	    CACHE_XFT(screen->renderFontItal, ital);
+
+	    /*
+	     * See xtermXftDrawString().
+	     */
+#if OPT_RENDERWIDE
+	    if (norm != 0 && screen->wide_chars) {
+		char *face_name = (xw->misc.face_wide_name
+				   ? xw->misc.face_wide_name
+				   : xw->misc.face_name);
+		int char_width = norm->max_advance_width * 2;
+
+		TRACE(("xtermComputeFontInfo wide(face %s, char_width %d)\n",
+		       face_name,
+		       char_width));
+
+		pat = XftNameParse(xw->misc.face_name);
+		XftPatternBuild(pat,
+				XFT_FAMILY, XftTypeString, face_name,
+				XFT_SIZE, XftTypeDouble, face_size,
+				XFT_SPACING, XftTypeInteger, XFT_MONO,
+				XFT_CHAR_WIDTH, XftTypeInteger, char_width,
+				(void *) 0);
+		wnorm = xtermOpenXft(dpy, pat, "wide");
+
+		if (wnorm != 0) {
+		    XftPatternBuild(pat,
+				    XFT_FAMILY, XftTypeString, face_name,
+				    XFT_SIZE, XftTypeDouble, face_size,
+				    XFT_SPACING, XftTypeInteger, XFT_MONO,
+				    XFT_CHAR_WIDTH, XftTypeInteger, char_width,
+				    XFT_WEIGHT, XftTypeInteger, XFT_WEIGHT_BOLD,
+				    (void *) 0);
+		    wbold = xtermOpenXft(dpy, pat, "wide-bold");
+
+		    if (screen->italicULMode) {
+			XftPatternBuild(pat,
+					XFT_FAMILY, XftTypeString, face_name,
+					XFT_SIZE, XftTypeDouble, face_size,
+					XFT_SPACING, XftTypeInteger, XFT_MONO,
+					XFT_CHAR_WIDTH, XftTypeInteger, char_width,
+					XFT_SLANT, XftTypeInteger, XFT_SLANT_ITALIC,
+					(void *) 0);
+			wital = xtermOpenXft(dpy, pat, "wide-italic");
+		    }
+		}
+
+		if (pat)
+		    XftPatternDestroy(pat);
+
+		CACHE_XFT(screen->renderWideNorm, wnorm);
+		CACHE_XFT(screen->renderWideBold, wbold);
+		CACHE_XFT(screen->renderWideItal, wital);
+	    }
+#endif
+	}
+	if (norm == 0) {
+	    xw->misc.render_font = False;
+	    update_font_renderfont();
+	} else {
+	    win->f_width = norm->max_advance_width;
+	    win->f_height = norm->height;
+	    win->f_ascent = norm->ascent;
+	    win->f_descent = norm->descent;
+	    if (win->f_height < win->f_ascent + win->f_descent)
+		win->f_height = win->f_ascent + win->f_descent;
+	    if (is_double_width_font_xft(screen->display, norm))
+		win->f_width >>= 1;
+	}
+    }
+    if (!xw->misc.render_font || IsIconWin(screen, win))
+#endif
+    {
+	if (is_double_width_font(font)) {
+	    win->f_width = (font->min_bounds.width);
+	} else {
+	    win->f_width = (font->max_bounds.width);
+	}
+	win->f_height = (font->ascent + font->descent);
+	win->f_ascent = font->ascent;
+	win->f_descent = font->descent;
+    }
+    i = 2 * screen->border + sbwidth;
+    j = 2 * screen->border;
+    width = MaxCols(screen) * win->f_width + i;
+    height = MaxRows(screen) * win->f_height + j;
+    win->fullwidth = width;
+    win->fullheight = height;
+    win->width = width - i;
+    win->height = height - j;
+
+    TRACE(("xtermComputeFontInfo window %dx%d (full %dx%d), fontsize %dx%d (asc %d, dsc %d)\n",
+	   win->height,
+	   win->width,
+	   win->fullheight,
+	   win->fullwidth,
+	   win->f_height,
+	   win->f_width,
+	   win->f_ascent,
+	   win->f_descent));
+}
+
+/* save this information as a side-effect for double-sized characters */
+void
+xtermSaveFontInfo(TScreen * screen, XFontStruct * font)
+{
+    screen->fnt_wide = (font->max_bounds.width);
+    screen->fnt_high = (font->ascent + font->descent);
+    TRACE(("xtermSaveFontInfo %dx%d\n", screen->fnt_high, screen->fnt_wide));
+}
+
+/*
+ * After loading a new font, update the structures that use its size.
+ */
+void
+xtermUpdateFontInfo(XtermWidget xw, Bool doresize)
+{
+    TScreen *screen = &(xw->screen);
+
+    int scrollbar_width;
+    struct _vtwin *win = &(screen->fullVwin);
+
+    scrollbar_width = (xw->misc.scrollbar
+		       ? (screen->scrollWidget->core.width +
+			  screen->scrollWidget->core.border_width)
+		       : 0);
+    xtermComputeFontInfo(xw, win, screen->fnt_norm, scrollbar_width);
+    xtermSaveFontInfo(screen, screen->fnt_norm);
+
+    if (doresize) {
+	if (VWindow(screen)) {
+	    XClearWindow(screen->display, VWindow(screen));
+	}
+	TRACE(("xtermUpdateFontInfo {{\n"));
+	DoResizeScreen(xw);	/* set to the new natural size */
+	if (screen->scrollWidget)
+	    ResizeScrollBar(xw);
+	Redraw();
+	TRACE(("... }} xtermUpdateFontInfo\n"));
+#ifdef SCROLLBAR_RIGHT
+	updateRightScrollbar(term);
+#endif
+    }
+    xtermSetCursorBox(screen);
+}
+
+#if OPT_BOX_CHARS
+
+/*
+ * Returns true if the given character is missing from the specified font.
+ */
+Bool
+xtermMissingChar(XtermWidget xw, unsigned ch, XFontStruct * font)
+{
+    if (font != 0
+	&& font->per_char != 0
+	&& !font->all_chars_exist) {
+	static XCharStruct dft, *tmp = &dft, *pc = 0;
+
+	if (font->max_byte1 == 0) {
+#if OPT_WIDE_CHARS
+	    if (ch > 255) {
+		TRACE(("xtermMissingChar %#04x (row)\n", ch));
+		return True;
+	    }
+#endif
+	    CI_GET_CHAR_INFO_1D(font, E2A(ch), tmp, pc);
+	}
+#if OPT_WIDE_CHARS
+	else {
+	    CI_GET_CHAR_INFO_2D(font, (ch >> 8), (ch & 0xff), tmp, pc);
+	}
+#else
+
+	if (!pc)
+	    return False;	/* Urgh! */
+#endif
+
+	if (CI_NONEXISTCHAR(pc)) {
+	    TRACE(("xtermMissingChar %#04x (!exists)\n", ch));
+	    return True;
+	}
+    }
+    if (ch < 32
+	&& xw->screen.force_box_chars) {
+	TRACE(("xtermMissingChar %#04x (forced off)\n", ch));
+	return True;
+    }
+    return False;
+}
+
+/*
+ * The grid is arbitrary, enough resolution that nothing's lost in
+ * initialization.
+ */
+#define BOX_HIGH 60
+#define BOX_WIDE 60
+
+#define MID_HIGH (BOX_HIGH/2)
+#define MID_WIDE (BOX_WIDE/2)
+
+#define CHR_WIDE ((9*BOX_WIDE)/10)
+#define CHR_HIGH ((9*BOX_HIGH)/10)
+
+/*
+ * ...since we'll scale the values anyway.
+ */
+#define SCALE_X(n) n = (n * (font_width-1)) / (BOX_WIDE-1)
+#define SCALE_Y(n) n = (n * (font_height-1)) / (BOX_HIGH-1)
+
+#define SEG(x0,y0,x1,y1) x0,y0, x1,y1
+
+/*
+ * Draw the given graphic character, if it is simple enough (i.e., a
+ * line-drawing character).
+ */
+void
+xtermDrawBoxChar(XtermWidget xw,
+		 unsigned ch,
+		 unsigned flags,
+		 GC gc,
+		 int x,
+		 int y)
+{
+    TScreen *screen = &(xw->screen);
+    /* *INDENT-OFF* */
+    static const short glyph_ht[] = {
+	SEG(  0,	    0,		  0,	      5*MID_HIGH/6),	/* H */
+	SEG(6*BOX_WIDE/10,  0,		6*BOX_WIDE/10,5*MID_HIGH/6),
+	SEG(  0,	  5*MID_HIGH/12,6*BOX_WIDE/10,5*MID_HIGH/12),
+	SEG(2*BOX_WIDE/10,  MID_HIGH,	  CHR_WIDE,	MID_HIGH),	/* T */
+	SEG(6*BOX_WIDE/10,  MID_HIGH,	6*BOX_WIDE/10,	CHR_HIGH),
+	-1
+    }, glyph_ff[] = {
+	SEG(  0,	    0,		6*BOX_WIDE/10,	0),		/* F */
+	SEG(  0,	  5*MID_HIGH/12,6*CHR_WIDE/12,5*MID_HIGH/12),
+	SEG(  0,	    0,		0*BOX_WIDE/3, 5*MID_HIGH/6),
+	SEG(1*BOX_WIDE/3,   MID_HIGH,	  CHR_WIDE,	MID_HIGH),	/* F */
+	SEG(1*BOX_WIDE/3, 8*MID_HIGH/6,10*CHR_WIDE/12,8*MID_HIGH/6),
+	SEG(1*BOX_WIDE/3,   MID_HIGH,	1*BOX_WIDE/3,	CHR_HIGH),
+	-1
+    }, glyph_lf[] = {
+	SEG(  0,	    0,		  0,	      5*MID_HIGH/6),	/* L */
+	SEG(  0,	  5*MID_HIGH/6,	6*BOX_WIDE/10,5*MID_HIGH/6),
+	SEG(1*BOX_WIDE/3,   MID_HIGH,	  CHR_WIDE,	MID_HIGH),	/* F */
+	SEG(1*BOX_WIDE/3, 8*MID_HIGH/6,10*CHR_WIDE/12,8*MID_HIGH/6),
+	SEG(1*BOX_WIDE/3,   MID_HIGH,	1*BOX_WIDE/3,	CHR_HIGH),
+	-1
+    }, glyph_nl[] = {
+	SEG(  0,	  5*MID_HIGH/6,	  0,		0),		/* N */
+	SEG(  0,	    0,		5*BOX_WIDE/6, 5*MID_HIGH/6),
+	SEG(5*BOX_WIDE/6, 5*MID_HIGH/6, 5*BOX_WIDE/6,	0),
+	SEG(1*BOX_WIDE/3,   MID_HIGH,	1*BOX_WIDE/3,	CHR_HIGH),	/* L */
+	SEG(1*BOX_WIDE/3,   CHR_HIGH,	  CHR_WIDE,	CHR_HIGH),
+	-1
+    }, glyph_vt[] = {
+	SEG(  0,	    0,		5*BOX_WIDE/12,5*MID_HIGH/6),	/* V */
+	SEG(5*BOX_WIDE/12,5*MID_HIGH/6, 5*BOX_WIDE/6,	0),
+	SEG(2*BOX_WIDE/10,  MID_HIGH,	  CHR_WIDE,	MID_HIGH),	/* T */
+	SEG(6*BOX_WIDE/10,  MID_HIGH,	6*BOX_WIDE/10,	CHR_HIGH),
+	-1
+    }, plus_or_minus[] =
+    {
+	SEG(  0,	  5*BOX_HIGH/6,	  CHR_WIDE,   5*BOX_HIGH/6),
+	SEG(  MID_WIDE,	  2*BOX_HIGH/6,	  MID_WIDE,   4*BOX_HIGH/6),
+	SEG(  0,	  3*BOX_HIGH/6,	  CHR_WIDE,   3*BOX_HIGH/6),
+	-1
+    }, lower_right_corner[] =
+    {
+	SEG(  0,	    MID_HIGH,	  MID_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    MID_HIGH,	  MID_WIDE,	0),
+	-1
+    }, upper_right_corner[] =
+    {
+	SEG(  0,	    MID_HIGH,	  MID_WIDE,	MID_HIGH),
+	SEG( MID_WIDE,	    MID_HIGH,	  MID_WIDE,	BOX_HIGH),
+	-1
+    }, upper_left_corner[] =
+    {
+	SEG(  MID_WIDE,	    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    MID_HIGH,	  MID_WIDE,	BOX_HIGH),
+	-1
+    }, lower_left_corner[] =
+    {
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    MID_WIDE,	  BOX_WIDE,	MID_HIGH),
+	-1
+    }, cross[] =
+    {
+	SEG(  0,	    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	BOX_HIGH),
+	-1
+    }, scan_line_1[] =
+    {
+	SEG(  0,	    0,		  BOX_WIDE,	0),
+	-1
+    }, scan_line_3[] =
+    {
+	SEG(  0,	    BOX_HIGH/4,	  BOX_WIDE,	BOX_HIGH/4),
+	-1
+    }, scan_line_7[] =
+    {
+	SEG( 0,		    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	-1
+    }, scan_line_9[] =
+    {
+	SEG(  0,	  3*BOX_HIGH/4,	  BOX_WIDE,   3*BOX_HIGH/4),
+	-1
+    }, horizontal_line[] =
+    {
+	SEG(  0,	    BOX_HIGH,	  BOX_WIDE,	BOX_HIGH),
+	-1
+    }, left_tee[] =
+    {
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	BOX_HIGH),
+	SEG(  MID_WIDE,	    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	-1
+    }, right_tee[] =
+    {
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	BOX_HIGH),
+	SEG(  MID_WIDE,	    MID_HIGH,	  0,		MID_HIGH),
+	-1
+    }, bottom_tee[] =
+    {
+	SEG(  0,	    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	MID_HIGH),
+	-1
+    }, top_tee[] =
+    {
+	SEG(  0,	    MID_HIGH,	  BOX_WIDE,	MID_HIGH),
+	SEG(  MID_WIDE,	    MID_HIGH,	  MID_WIDE,	BOX_HIGH),
+	-1
+    }, vertical_line[] =
+    {
+	SEG(  MID_WIDE,	    0,		  MID_WIDE,	BOX_HIGH),
+	-1
+    }, less_than_or_equal[] =
+    {
+	SEG(  CHR_WIDE,	    BOX_HIGH/3,	  0,		MID_HIGH),
+	SEG(  CHR_WIDE,	  2*BOX_HIGH/3,	  0,		MID_HIGH),
+	SEG(  0,	  3*BOX_HIGH/4,	  CHR_WIDE,   3*BOX_HIGH/4),
+	-1
+    }, greater_than_or_equal[] =
+    {
+	SEG(  0,	    BOX_HIGH/3,	  CHR_WIDE,	MID_HIGH),
+	SEG(  0,	  2*BOX_HIGH/3,	  CHR_WIDE,	MID_HIGH),
+	SEG(  0,	  3*BOX_HIGH/4,	  CHR_WIDE,   3*BOX_HIGH/4),
+	-1
+    }, greek_pi[] =
+    {
+	SEG(  0,	    MID_HIGH,	  CHR_WIDE,	MID_HIGH),
+	SEG(5*CHR_WIDE/6,   MID_HIGH,	5*CHR_WIDE/6,	CHR_HIGH),
+	SEG(2*CHR_WIDE/6,   MID_HIGH,	2*CHR_WIDE/6,	CHR_HIGH),
+	-1
+    }, not_equal_to[] =
+    {
+	SEG(2*BOX_WIDE/3, 1*BOX_HIGH/3, 1*BOX_WIDE/3,	CHR_HIGH),
+	SEG(  0,	  2*BOX_HIGH/3,	  CHR_WIDE,   2*BOX_HIGH/3),
+	SEG(  0,	    MID_HIGH,	  CHR_WIDE,	MID_HIGH),
+	-1
+    };
+    /* *INDENT-ON* */
+
+    static const short *lines[] =
+    {
+	0,			/* 00 (unused) */
+	0,			/* 01 diamond */
+	0,			/* 02 box */
+	glyph_ht,		/* 03 HT */
+	glyph_ff,		/* 04 FF */
+	0,			/* 05 CR */
+	glyph_lf,		/* 06 LF */
+	0,			/* 07 degrees (small circle) */
+	plus_or_minus,		/* 08 */
+	glyph_nl,		/* 09 */
+	glyph_vt,		/* 0A */
+	lower_right_corner,	/* 0B */
+	upper_right_corner,	/* 0C */
+	upper_left_corner,	/* 0D */
+	lower_left_corner,	/* 0E */
+	cross,			/* 0F */
+	scan_line_1,		/* 10 */
+	scan_line_3,		/* 11 */
+	scan_line_7,		/* 12 */
+	scan_line_9,		/* 13 */
+	horizontal_line,	/* 14 */
+	left_tee,		/* 15 */
+	right_tee,		/* 16 */
+	bottom_tee,		/* 17 */
+	top_tee,		/* 18 */
+	vertical_line,		/* 19 */
+	less_than_or_equal,	/* 1A */
+	greater_than_or_equal,	/* 1B */
+	greek_pi,		/* 1C */
+	not_equal_to,		/* 1D */
+	0,			/* 1E LB */
+	0,			/* 1F bullet */
+    };
+
+    XGCValues values;
+    unsigned long mask;
+    GC gc2;
+    const short *p;
+    unsigned font_width = ((flags & DOUBLEWFONT) ? 2 : 1) * screen->fnt_wide;
+    unsigned font_height = ((flags & DOUBLEHFONT) ? 2 : 1) * screen->fnt_high;
+
+#if OPT_WIDE_CHARS
+    /*
+     * Try to show line-drawing characters if we happen to be in UTF-8
+     * mode, but have gotten an old-style font.
+     */
+    if (screen->utf8_mode
+#if OPT_RENDERFONT
+	&& !UsingRenderFont(xw)
+#endif
+	&& (ch > 127)
+	&& (ch != UCS_REPL)) {
+	unsigned n;
+	for (n = 1; n < 32; n++) {
+	    if (dec2ucs(n) == ch
+		&& !xtermMissingChar(xw, n, (flags & BOLD)
+				     ? screen->fnt_bold
+				     : screen->fnt_norm)) {
+		TRACE(("...use xterm-style linedrawing\n"));
+		ch = n;
+		break;
+	    }
+	}
+    }
+#endif
+
+    TRACE(("DRAW_BOX(%d) cell %dx%d at %d,%d%s\n",
+	   ch, font_height, font_width, y, x,
+	   (ch >= (sizeof(lines) / sizeof(lines[0]))
+	    ? "-BAD"
+	    : "")));
+
+    if (!XGetGCValues(screen->display, gc, GCBackground, &values))
+	return;
+
+    mask = GCForeground;
+    if (ch == 2) {
+	values.tile =
+	    XmuCreateStippledPixmap(XtScreen((Widget) xw),
+				    getXtermForeground(xw->flags, xw->cur_foreground),
+				    getXtermBackground(xw->flags, xw->cur_background),
+				    xw->core.depth);
+	if (values.stipple != XtUnspecifiedPixmap) {
+	    mask |= GCBackground | GCTile | GCFillStyle;
+	    values.fill_style = FillTiled;
+	} else {
+	    ch = (unsigned) (~0);	/* make this not match anything */
+	}
+    } else {
+	values.foreground = values.background;
+    }
+    gc2 = XCreateGC(screen->display,
+		    VWindow(screen),
+		    mask,
+		    &values);
+
+    if (!(flags & NOBACKGROUND)) {
+	XFillRectangle(screen->display, VWindow(screen), gc2, x, y,
+		       font_width,
+		       font_height);
+    }
+
+    XCopyGC(screen->display, gc, (1 << GCLastBit) - 1, gc2);
+    XSetLineAttributes(screen->display, gc2,
+		       (flags & BOLD)
+		       ? ((font_height > 12)
+			  ? font_height / 12
+			  : 1)
+		       : ((font_height > 16)
+			  ? font_height / 16
+			  : 1),
+		       LineSolid,
+		       CapProjecting,
+		       JoinMiter);
+
+    if (ch == 1) {		/* diamond */
+	XPoint points[5];
+	int npoints = 5, n;
+
+	points[0].x = MID_WIDE;
+	points[0].y = BOX_HIGH / 4;
+
+	points[1].x = 3 * BOX_WIDE / 4;
+	points[1].y = MID_HIGH;
+
+	points[2].x = points[0].x;
+	points[2].y = 3 * BOX_HIGH / 4;
+
+	points[3].x = BOX_WIDE / 4;
+	points[3].y = points[1].y;
+
+	points[4].x = points[0].x;
+	points[4].y = points[0].y;
+
+	for (n = 0; n < npoints; ++n) {
+	    SCALE_X(points[n].x);
+	    SCALE_Y(points[n].y);
+	    points[n].x += x;
+	    points[n].y += y;
+	}
+
+	XFillPolygon(screen->display,
+		     VWindow(screen), gc2,
+		     points, npoints,
+		     Convex, CoordModeOrigin);
+    } else if (ch == 2) {	/* box */
+	XmuReleaseStippledPixmap(XtScreen((Widget) xw), values.tile);
+    } else if (ch == 7) {	/* degrees */
+	unsigned width = (BOX_WIDE / 3);
+	int x_coord = MID_WIDE - (width / 2);
+	int y_coord = MID_HIGH - width;
+
+	SCALE_X(x_coord);
+	SCALE_Y(y_coord);
+	SCALE_X(width);
+
+	XDrawArc(screen->display,
+		 VWindow(screen), gc2,
+		 x + x_coord, y + y_coord, width, width,
+		 0,
+		 360 * 64);
+    } else if (ch == 0x1f) {	/* bullet */
+	unsigned width = 7 * BOX_WIDE / 10;
+	int x_coord = MID_WIDE - (width / 3);
+	int y_coord = MID_HIGH - (width / 3);
+
+	SCALE_X(x_coord);
+	SCALE_Y(y_coord);
+	SCALE_X(width);
+
+	XFillArc(screen->display,
+		 VWindow(screen), gc2,
+		 x + x_coord, y + y_coord, width, width,
+		 0,
+		 360 * 64);
+    } else if (ch < (sizeof(lines) / sizeof(lines[0]))
+	       && (p = lines[ch]) != 0) {
+	int coord[4];
+	int n = 0;
+	while (*p >= 0) {
+	    coord[n++] = *p++;
+	    if (n == 4) {
+		SCALE_X(coord[0]);
+		SCALE_Y(coord[1]);
+		SCALE_X(coord[2]);
+		SCALE_Y(coord[3]);
+		XDrawLine(screen->display,
+			  VWindow(screen), gc2,
+			  x + coord[0], y + coord[1],
+			  x + coord[2], y + coord[3]);
+		n = 0;
+	    }
+	}
+    } else if (screen->force_all_chars) {
+	/* bounding rectangle, for debugging */
+	XDrawRectangle(screen->display, VWindow(screen), gc2, x, y,
+		       font_width - 1,
+		       font_height - 1);
+    }
+
+    XFreeGC(screen->display, gc2);
+}
+
+#if OPT_RENDERFONT && OPT_WIDE_CHARS
+
+/*
+ * Check if the given character has a glyph known to Xft.
+ *
+ * see xc/lib/Xft/xftglyphs.c
+ */
+Bool
+xtermXftMissing(XtermWidget xw, XftFont * font, unsigned wc)
+{
+    unsigned check = XftCharIndex(xw->screen.display, font, wc);
+    Bool result = False;
+
+    if (check == 0) {
+	TRACE(("missingXft %d (%d)\n", wc, ucs2dec(wc)));
+	result = True;
+    }
+    return result;
+}
+
+/*
+ * Check if the character corresponds to one of xterm's internal codes for
+ * line-drawing characters.  That is only a subset of the 1-31 codes used for
+ * graphic characters.  We want to know specifically about the line-drawing
+ * characters because the fonts used by Xft do not always give useful glyphs
+ * for line-drawing, and there is no reliable way to detect this.
+ */
+Bool
+xtermIsLineDrawing(unsigned wc)
+{
+    Bool result;
+    switch (wc) {
+    case 0x0B:			/* lower_right_corner   */
+    case 0x0C:			/* upper_right_corner   */
+    case 0x0D:			/* upper_left_corner    */
+    case 0x0E:			/* lower_left_corner    */
+    case 0x0F:			/* cross                */
+    case 0x10:			/* scan_line_1          */
+    case 0x11:			/* scan_line_3          */
+    case 0x12:			/* scan_line_7          */
+    case 0x13:			/* scan_line_9          */
+    case 0x14:			/* horizontal_line      */
+    case 0x15:			/* left_tee             */
+    case 0x16:			/* right_tee            */
+    case 0x17:			/* bottom_tee           */
+    case 0x18:			/* top_tee              */
+    case 0x19:			/* vertical_line        */
+	result = True;
+	TRACE(("xtermIsLineDrawing %d\n", wc));
+	break;
+    default:
+	result = False;
+	break;
+    }
+    return result;
+}
+#endif /* OPT_RENDERFONT && OPT_WIDE_CHARS */
+
+#endif /* OPT_BOX_CHARS */
+
+#if OPT_WIDE_CHARS
+#define MY_UCS(ucs,dec) case ucs: result = dec; break
+unsigned
+ucs2dec(unsigned ch)
+{
+    unsigned result = ch;
+    if ((ch > 127)
+	&& (ch != UCS_REPL)) {
+	switch (ch) {
+	    MY_UCS(0x25ae, 0);	/* black vertical rectangle                   */
+	    MY_UCS(0x25c6, 1);	/* black diamond                              */
+	    MY_UCS(0x2592, 2);	/* medium shade                               */
+	    MY_UCS(0x2409, 3);	/* symbol for horizontal tabulation           */
+	    MY_UCS(0x240c, 4);	/* symbol for form feed                       */
+	    MY_UCS(0x240d, 5);	/* symbol for carriage return                 */
+	    MY_UCS(0x240a, 6);	/* symbol for line feed                       */
+	    MY_UCS(0x00b0, 7);	/* degree sign                                */
+	    MY_UCS(0x00b1, 8);	/* plus-minus sign                            */
+	    MY_UCS(0x2424, 9);	/* symbol for newline                         */
+	    MY_UCS(0x240b, 10);	/* symbol for vertical tabulation             */
+	    MY_UCS(0x2518, 11);	/* box drawings light up and left             */
+	    MY_UCS(0x2510, 12);	/* box drawings light down and left           */
+	    MY_UCS(0x250c, 13);	/* box drawings light down and right          */
+	    MY_UCS(0x2514, 14);	/* box drawings light up and right            */
+	    MY_UCS(0x253c, 15);	/* box drawings light vertical and horizontal */
+	    MY_UCS(0x23ba, 16);	/* box drawings scan 1                        */
+	    MY_UCS(0x23bb, 17);	/* box drawings scan 3                        */
+	    MY_UCS(0x2500, 18);	/* box drawings light horizontal              */
+	    MY_UCS(0x23bc, 19);	/* box drawings scan 7                        */
+	    MY_UCS(0x23bd, 20);	/* box drawings scan 9                        */
+	    MY_UCS(0x251c, 21);	/* box drawings light vertical and right      */
+	    MY_UCS(0x2524, 22);	/* box drawings light vertical and left       */
+	    MY_UCS(0x2534, 23);	/* box drawings light up and horizontal       */
+	    MY_UCS(0x252c, 24);	/* box drawings light down and horizontal     */
+	    MY_UCS(0x2502, 25);	/* box drawings light vertical                */
+	    MY_UCS(0x2264, 26);	/* less-than or equal to                      */
+	    MY_UCS(0x2265, 27);	/* greater-than or equal to                   */
+	    MY_UCS(0x03c0, 28);	/* greek small letter pi                      */
+	    MY_UCS(0x2260, 29);	/* not equal to                               */
+	    MY_UCS(0x00a3, 30);	/* pound sign                                 */
+	    MY_UCS(0x00b7, 31);	/* middle dot                                 */
+	}
+    }
+    return result;
+}
+
+#undef  MY_UCS
+#define MY_UCS(ucs,dec) case dec: result = ucs; break
+
+unsigned
+dec2ucs(unsigned ch)
+{
+    unsigned result = ch;
+    if (ch < 32) {
+	switch (ch) {
+	    MY_UCS(0x25ae, 0);	/* black vertical rectangle                   */
+	    MY_UCS(0x25c6, 1);	/* black diamond                              */
+	    MY_UCS(0x2592, 2);	/* medium shade                               */
+	    MY_UCS(0x2409, 3);	/* symbol for horizontal tabulation           */
+	    MY_UCS(0x240c, 4);	/* symbol for form feed                       */
+	    MY_UCS(0x240d, 5);	/* symbol for carriage return                 */
+	    MY_UCS(0x240a, 6);	/* symbol for line feed                       */
+	    MY_UCS(0x00b0, 7);	/* degree sign                                */
+	    MY_UCS(0x00b1, 8);	/* plus-minus sign                            */
+	    MY_UCS(0x2424, 9);	/* symbol for newline                         */
+	    MY_UCS(0x240b, 10);	/* symbol for vertical tabulation             */
+	    MY_UCS(0x2518, 11);	/* box drawings light up and left             */
+	    MY_UCS(0x2510, 12);	/* box drawings light down and left           */
+	    MY_UCS(0x250c, 13);	/* box drawings light down and right          */
+	    MY_UCS(0x2514, 14);	/* box drawings light up and right            */
+	    MY_UCS(0x253c, 15);	/* box drawings light vertical and horizontal */
+	    MY_UCS(0x23ba, 16);	/* box drawings scan 1                        */
+	    MY_UCS(0x23bb, 17);	/* box drawings scan 3                        */
+	    MY_UCS(0x2500, 18);	/* box drawings light horizontal              */
+	    MY_UCS(0x23bc, 19);	/* box drawings scan 7                        */
+	    MY_UCS(0x23bd, 20);	/* box drawings scan 9                        */
+	    MY_UCS(0x251c, 21);	/* box drawings light vertical and right      */
+	    MY_UCS(0x2524, 22);	/* box drawings light vertical and left       */
+	    MY_UCS(0x2534, 23);	/* box drawings light up and horizontal       */
+	    MY_UCS(0x252c, 24);	/* box drawings light down and horizontal     */
+	    MY_UCS(0x2502, 25);	/* box drawings light vertical                */
+	    MY_UCS(0x2264, 26);	/* less-than or equal to                      */
+	    MY_UCS(0x2265, 27);	/* greater-than or equal to                   */
+	    MY_UCS(0x03c0, 28);	/* greek small letter pi                      */
+	    MY_UCS(0x2260, 29);	/* not equal to                               */
+	    MY_UCS(0x00a3, 30);	/* pound sign                                 */
+	    MY_UCS(0x00b7, 31);	/* middle dot                                 */
+	}
+    }
+    return result;
+}
+
+#endif /* OPT_WIDE_CHARS */
+
+#if OPT_SHIFT_FONTS
+static XFontStruct *
+xtermFindFont(TScreen * screen, int fontnum)
+{
+    XFontStruct *nfs = 0;
+    char *name;
+
+    if ((name = screen->MenuFontName(fontnum)) != 0
+	&& (nfs = XLoadQueryFont(screen->display, name)) != 0) {
+	if (EmptyFont(nfs)) {
+	    XFreeFont(screen->display, nfs);
+	    nfs = 0;
+	}
+    }
+    return nfs;
+}
+
+static void
+lookupOneFontSize(TScreen * screen, int fontnum)
+{
+    if (screen->menu_font_sizes[fontnum] == 0) {
+	XFontStruct *fs = xtermFindFont(screen, fontnum);
+	screen->menu_font_sizes[fontnum] = -1;
+	if (fs != 0) {
+	    screen->menu_font_sizes[fontnum] = FontSize(fs);
+	    TRACE(("menu_font_sizes[%d] = %ld\n", fontnum,
+		   screen->menu_font_sizes[fontnum]));
+	    XFreeFont(screen->display, fs);
+	}
+    }
+}
+
+/*
+ * Cache the font-sizes so subsequent larger/smaller font actions will go fast.
+ */
+static void
+lookupFontSizes(TScreen * screen)
+{
+    int n;
+
+    for (n = 0; n < NMENUFONTS; n++) {
+	lookupOneFontSize(screen, n);
+    }
+}
+
+/*
+ * Find the index of a larger/smaller font (according to the sign of 'relative'
+ * and its magnitude), starting from the 'old' index.
+ */
+int
+lookupRelativeFontSize(TScreen * screen, int old, int relative)
+{
+    int n, m = -1;
+
+    if (!IsIcon(screen)) {
+	lookupFontSizes(screen);
+	if (relative != 0) {
+	    for (n = 0; n < NMENUFONTS; ++n) {
+		if (screen->menu_font_sizes[n] > 0 &&
+		    screen->menu_font_sizes[n] != screen->menu_font_sizes[old]) {
+		    int cmp_0 = ((screen->menu_font_sizes[n] >
+				  screen->menu_font_sizes[old])
+				 ? relative
+				 : -relative);
+		    int cmp_m = ((m < 0)
+				 ? 1
+				 : ((screen->menu_font_sizes[n] <
+				     screen->menu_font_sizes[m])
+				    ? relative
+				    : -relative));
+		    if (cmp_0 > 0 && cmp_m > 0) {
+			m = n;
+		    }
+		}
+	    }
+	    if (m >= 0) {
+		if (relative > 1)
+		    m = lookupRelativeFontSize(screen, m, relative - 1);
+		else if (relative < -1)
+		    m = lookupRelativeFontSize(screen, m, relative + 1);
+	    }
+	}
+    }
+    return m;
+}
+
+/* ARGSUSED */
+void
+HandleLargerFont(Widget w GCC_UNUSED,
+		 XEvent * event GCC_UNUSED,
+		 String * params GCC_UNUSED,
+		 Cardinal *param_count GCC_UNUSED)
+{
+    if (term->misc.shift_fonts) {
+	TScreen *screen = &term->screen;
+	int m;
+
+	m = lookupRelativeFontSize(screen, screen->menu_font_number, 1);
+	if (m >= 0) {
+	    SetVTFont(term, m, True, NULL);
+	} else {
+	    Bell(XkbBI_MinorError, 0);
+	}
+    }
+}
+
+/* ARGSUSED */
+void
+HandleSmallerFont(Widget w GCC_UNUSED,
+		  XEvent * event GCC_UNUSED,
+		  String * params GCC_UNUSED,
+		  Cardinal *param_count GCC_UNUSED)
+{
+    if (term->misc.shift_fonts) {
+	TScreen *screen = &term->screen;
+	int m;
+
+	m = lookupRelativeFontSize(screen, screen->menu_font_number, -1);
+	if (m >= 0) {
+	    SetVTFont(term, m, True, NULL);
+	} else {
+	    Bell(XkbBI_MinorError, 0);
+	}
+    }
+}
+#endif
+
+/* ARGSUSED */
+void
+HandleSetFont(Widget w GCC_UNUSED,
+	      XEvent * event GCC_UNUSED,
+	      String * params,
+	      Cardinal *param_count)
+{
+    int fontnum;
+    VTFontNames fonts;
+
+    memset(&fonts, 0, sizeof(fonts));
+
+    if (*param_count == 0) {
+	fontnum = fontMenu_fontdefault;
+    } else {
+	Cardinal maxparams = 1;	/* total number of params allowed */
+
+	switch (params[0][0]) {
+	case 'd':
+	case 'D':
+	case '0':
+	    fontnum = fontMenu_fontdefault;
+	    break;
+	case '1':
+	    fontnum = fontMenu_font1;
+	    break;
+	case '2':
+	    fontnum = fontMenu_font2;
+	    break;
+	case '3':
+	    fontnum = fontMenu_font3;
+	    break;
+	case '4':
+	    fontnum = fontMenu_font4;
+	    break;
+	case '5':
+	    fontnum = fontMenu_font5;
+	    break;
+	case '6':
+	    fontnum = fontMenu_font6;
+	    break;
+	case 'e':
+	case 'E':
+	    fontnum = fontMenu_fontescape;
+#if OPT_WIDE_CHARS
+	    maxparams = 5;
+#else
+	    maxparams = 3;
+#endif
+	    break;
+	case 's':
+	case 'S':
+	    fontnum = fontMenu_fontsel;
+	    maxparams = 2;
+	    break;
+	default:
+	    Bell(XkbBI_MinorError, 0);
+	    return;
+	}
+	if (*param_count > maxparams) {		/* see if extra args given */
+	    Bell(XkbBI_MinorError, 0);
+	    return;
+	}
+	switch (*param_count) {	/* assign 'em */
+#if OPT_WIDE_CHARS
+	case 5:
+	    fonts.f_wb = params[4];
+	    /* FALLTHRU */
+	case 4:
+	    fonts.f_w = params[3];
+	    /* FALLTHRU */
+#endif
+	case 3:
+	    fonts.f_b = params[2];
+	    /* FALLTHRU */
+	case 2:
+	    fonts.f_n = params[1];
+	    break;
+	}
+    }
+
+    SetVTFont(term, fontnum, True, &fonts);
+}
+
+void
+SetVTFont(XtermWidget xw,
+	  int which,
+	  Bool doresize,
+	  const VTFontNames * fonts)
+{
+    TScreen *screen = &xw->screen;
+
+    TRACE(("SetVTFont(which=%d, f_n=%s, f_b=%s)\n", which,
+	   (fonts && fonts->f_n) ? fonts->f_n : "<null>",
+	   (fonts && fonts->f_b) ? fonts->f_b : "<null>"));
+
+    if (IsIcon(screen)) {
+	Bell(XkbBI_MinorError, 0);
+    } else if (which >= 0 && which < NMENUFONTS) {
+	VTFontNames myfonts;
+
+	memset(&myfonts, 0, sizeof(myfonts));
+	if (fonts != 0)
+	    myfonts = *fonts;
+
+	if (which == fontMenu_fontsel) {	/* go get the selection */
+	    FindFontSelection(myfonts.f_n, False);
+	    return;
+	} else {
+	    if (myfonts.f_n == 0) {
+		myfonts.f_n = screen->MenuFontName(which);
+		TRACE(("set myfonts.f_n from menu_font_names[%d][fNorm] %s\n",
+		       which, NonNull(myfonts.f_n)));
+	    }
+	    if (myfonts.f_b == 0) {
+		myfonts.f_b = screen->menu_font_names[which][fBold];
+		TRACE(("set myfonts.f_b from menu_font_names[%d][fBold] %s\n",
+		       which, NonNull(myfonts.f_b)));
+	    }
+#if OPT_WIDE_CHARS
+	    if (myfonts.f_w == 0) {
+		myfonts.f_w = screen->menu_font_names[which][fWide];
+		TRACE(("set myfonts.f_w from menu_font_names[%d][fWide] %s\n",
+		       which, NonNull(myfonts.f_w)));
+	    }
+	    if (myfonts.f_wb == 0) {
+		myfonts.f_wb = screen->menu_font_names[which][fWBold];
+		TRACE(("set myfonts.f_wb from menu_font_names[%d][fWBold] %s\n",
+		       which, NonNull(myfonts.f_wb)));
+	    }
+#endif
+	    if (xtermLoadFont(xw,
+			      &myfonts,
+			      doresize, which)) {
+		return;
+	    }
+	}
+    }
+
+    Bell(XkbBI_MinorError, 0);
+    return;
+}