unix/gtkfont.c

   1 /*
   2  * Unified font management for GTK.
   3  *
   4  * PuTTY is willing to use both old-style X server-side bitmap
   5  * fonts _and_ GTK2/Pango client-side fonts. This requires us to
   6  * do a bit of work to wrap the two wildly different APIs into
   7  * forms the rest of the code can switch between seamlessly, and
   8  * also requires a custom font selector capable of handling both
   9  * types of font.
  10  */
  11
  12 #include <assert.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 #include <gtk/gtk.h>
  17 #if !GTK_CHECK_VERSION(3,0,0)
  18 #include <gdk/gdkkeysyms.h>
  19 #endif
  20
  21 #define MAY_REFER_TO_GTK_IN_HEADERS
  22
  23 #include "putty.h"
  24 #include "gtkfont.h"
  25 #include "gtkcompat.h"
  26 #include "gtkmisc.h"
  27 #include "tree234.h"
  28
  29 #ifndef NOT_X_WINDOWS
  30 #include <gdk/gdkx.h>
  31 #include <X11/Xlib.h>
  32 #include <X11/Xutil.h>
  33 #include <X11/Xatom.h>
  34 #endif
  35
  36 /*
  37  * Future work:
  38  *
  39  *  - it would be nice to have a display of the current font name,
  40  *    and in particular whether it's client- or server-side,
  41  *    during the progress of the font selector.
  42  */
  43
  44 #if !GLIB_CHECK_VERSION(1,3,7)
  45 #define g_ascii_strcasecmp g_strcasecmp
  46 #define g_ascii_strncasecmp g_strncasecmp
  47 #endif
  48
  49 /*
  50  * Ad-hoc vtable mechanism to allow font structures to be
  51  * polymorphic.
  52  *
  53  * Any instance of `unifont' used in the vtable functions will
  54  * actually be the first element of a larger structure containing
  55  * data specific to the subtype. This is permitted by the ISO C
  56  * provision that one may safely cast between a pointer to a
  57  * structure and a pointer to its first element.
  58  */
  59
  60 #define FONTFLAG_CLIENTSIDE    0x0001
  61 #define FONTFLAG_SERVERSIDE    0x0002
  62 #define FONTFLAG_SERVERALIAS   0x0004
  63 #define FONTFLAG_NONMONOSPACED 0x0008
  64
  65 #define FONTFLAG_SORT_MASK     0x0007 /* used to disambiguate font families */
  66
  67 typedef void (*fontsel_add_entry)(void *ctx, const char *realfontname,
  68                                   const char *family, const char *charset,
  69                                   const char *style, const char *stylekey,
  70                                   int size, int flags,
  71                                   const struct unifont_vtable *fontclass);
  72
  73 struct unifont_vtable {
  74     /*
  75      * `Methods' of the `class'.
  76      */
  77     unifont *(*create)(GtkWidget *widget, const char *name, int wide, int bold,
  78                        int shadowoffset, int shadowalways);
  79     unifont *(*create_fallback)(GtkWidget *widget, int height, int wide,
  80                                 int bold, int shadowoffset, int shadowalways);
  81     void (*destroy)(unifont *font);
  82     int (*has_glyph)(unifont *font, wchar_t glyph);
  83     void (*draw_text)(unifont_drawctx *ctx, unifont *font,
  84                       int x, int y, const wchar_t *string, int len,
  85                       int wide, int bold, int cellwidth);
  86     void (*draw_combining)(unifont_drawctx *ctx, unifont *font,
  87                            int x, int y, const wchar_t *string, int len,
  88                            int wide, int bold, int cellwidth);
  89     void (*enum_fonts)(GtkWidget *widget,
  90                        fontsel_add_entry callback, void *callback_ctx);
  91     char *(*canonify_fontname)(GtkWidget *widget, const char *name, int *size,
  92                                int *flags, int resolve_aliases);
  93     char *(*scale_fontname)(GtkWidget *widget, const char *name, int size);
  94     char *(*size_increment)(unifont *font, int increment);
  95
  96     /*
  97      * `Static data members' of the `class'.
  98      */
  99     const char *prefix;
 100 };
 101
 102 #ifndef NOT_X_WINDOWS
 103
 104 /* ----------------------------------------------------------------------
 105  * X11 font implementation, directly using Xlib calls. Conditioned out
 106  * if X11 fonts aren't available at all (e.g. building with GTK3 for a
 107  * back end other than X).
 108  */
 109
 110 static int x11font_has_glyph(unifont *font, wchar_t glyph);
 111 static void x11font_draw_text(unifont_drawctx *ctx, unifont *font,
 112                               int x, int y, const wchar_t *string, int len,
 113                               int wide, int bold, int cellwidth);
 114 static void x11font_draw_combining(unifont_drawctx *ctx, unifont *font,
 115                                    int x, int y, const wchar_t *string,
 116                                    int len, int wide, int bold, int cellwidth);
 117 static unifont *x11font_create(GtkWidget *widget, const char *name,
 118                                int wide, int bold,
 119                                int shadowoffset, int shadowalways);
 120 static void x11font_destroy(unifont *font);
 121 static void x11font_enum_fonts(GtkWidget *widget,
 122                                fontsel_add_entry callback, void *callback_ctx);
 123 static char *x11font_canonify_fontname(GtkWidget *widget, const char *name,
 124                                        int *size, int *flags,
 125                                        int resolve_aliases);
 126 static char *x11font_scale_fontname(GtkWidget *widget, const char *name,
 127                                     int size);
 128 static char *x11font_size_increment(unifont *font, int increment);
 129
 130 #ifdef DRAW_TEXT_CAIRO
 131 struct cairo_cached_glyph {
 132     cairo_surface_t *surface;
 133     unsigned char *bitmap;
 134 };
 135 #endif
 136
 137 /*
 138  * Structure storing a single physical XFontStruct, plus associated
 139  * data.
 140  */
 141 typedef struct x11font_individual {
 142     /* The XFontStruct itself. */
 143     XFontStruct *xfs;
 144
 145     /*
 146      * The `allocated' flag indicates whether we've tried to fetch
 147      * this subfont already (thus distinguishing xfs==NULL because we
 148      * haven't tried yet from xfs==NULL because we tried and failed,
 149      * so that we don't keep trying and failing subsequently).
 150      */
 151     int allocated;
 152
 153 #ifdef DRAW_TEXT_CAIRO
 154     /*
 155      * A cache of glyph bitmaps downloaded from the X server when
 156      * we're in Cairo rendering mode. If glyphcache itself is
 157      * non-NULL, then entries in [0,nglyphs) are expected to be
 158      * initialised to either NULL or a bitmap pointer.
 159      */
 160     struct cairo_cached_glyph *glyphcache;
 161     int nglyphs;
 162
 163     /*
 164      * X server paraphernalia for actually downloading the glyphs.
 165      */
 166     Pixmap pixmap;
 167     GC gc;
 168     int pixwidth, pixheight, pixoriginx, pixoriginy;
 169
 170     /*
 171      * Paraphernalia for loading the resulting bitmaps into Cairo.
 172      */
 173     int rowsize, allsize, indexflip;
 174 #endif
 175
 176 } x11font_individual;
 177
 178 struct x11font {
 179     struct unifont u;
 180     /*
 181      * Individual physical X fonts. We store a number of these, for
 182      * automatically guessed bold and wide variants.
 183      */
 184     x11font_individual fonts[4];
 185     /*
 186      * `sixteen_bit' is true iff the font object is indexed by
 187      * values larger than a byte. That is, this flag tells us
 188      * whether we use XDrawString or XDrawString16, etc.
 189      */
 190     int sixteen_bit;
 191     /*
 192      * `variable' is true iff the font is non-fixed-pitch. This
 193      * enables some code which takes greater care over character
 194      * positioning during text drawing.
 195      */
 196     int variable;
 197     /*
 198      * real_charset is the charset used when translating text into the
 199      * font's internal encoding inside draw_text(). This need not be
 200      * the same as the public_charset provided to the client; for
 201      * example, public_charset might be CS_ISO8859_1 while
 202      * real_charset is CS_ISO8859_1_X11.
 203      */
 204     int real_charset;
 205     /*
 206      * Data passed in to unifont_create().
 207      */
 208     int wide, bold, shadowoffset, shadowalways;
 209 };
 210
 211 static const struct unifont_vtable x11font_vtable = {
 212     x11font_create,
 213     NULL,                              /* no fallback fonts in X11 */
 214     x11font_destroy,
 215     x11font_has_glyph,
 216     x11font_draw_text,
 217     x11font_draw_combining,
 218     x11font_enum_fonts,
 219     x11font_canonify_fontname,
 220     x11font_scale_fontname,
 221     x11font_size_increment,
 222     "server",
 223 };
 224
 225 #define XLFD_STRING_PARTS_LIST(S,I)             \
 226     S(foundry)                                  \
 227     S(family_name)                              \
 228     S(weight_name)                              \
 229     S(slant)                                    \
 230     S(setwidth_name)                            \
 231     S(add_style_name)                           \
 232     I(pixel_size)                               \
 233     I(point_size)                               \
 234     I(resolution_x)                             \
 235     I(resolution_y)                             \
 236     S(spacing)                                  \
 237     I(average_width)                            \
 238     S(charset_registry)                         \
 239     S(charset_encoding)                         \
 240     /* end of list */
 241
 242 /* Special value for int fields that xlfd_recompose will render as "*" */
 243 #define XLFD_INT_WILDCARD INT_MIN
 244
 245 struct xlfd_decomposed {
 246 #define STR_FIELD(f) const char *f;
 247 #define INT_FIELD(f) int f;
 248     XLFD_STRING_PARTS_LIST(STR_FIELD, INT_FIELD)
 249 #undef STR_FIELD
 250 #undef INT_FIELD
 251 };
 252
 253 static struct xlfd_decomposed *xlfd_decompose(const char *xlfd)
 254 {
 255     void *mem;
 256     char *p, *components[14];
 257     struct xlfd_decomposed *dec;
 258     int i;
 259
 260     if (!xlfd)
 261         return NULL;
 262
 263     mem = smalloc(sizeof(struct xlfd_decomposed) + strlen(xlfd) + 1);
 264     p = ((char *)mem) + sizeof(struct xlfd_decomposed);
 265     strcpy(p, xlfd);
 266     dec = (struct xlfd_decomposed *)mem;
 267
 268     for (i = 0; i < 14; i++) {
 269         if (*p != '-') {
 270             /* Malformed XLFD: not enough '-' */
 271             sfree(mem);
 272             return NULL;
 273         }
 274         *p++ = '\0';
 275         components[i] = p;
 276         p += strcspn(p, "-");
 277     }
 278     if (*p) {
 279         /* Malformed XLFD: too many '-' */
 280         sfree(mem);
 281         return NULL;
 282     }
 283
 284     i = 0;
 285 #define STORE_STR(f) dec->f = components[i++];
 286 #define STORE_INT(f) dec->f = atoi(components[i++]);
 287     XLFD_STRING_PARTS_LIST(STORE_STR, STORE_INT)
 288 #undef STORE_STR
 289 #undef STORE_INT
 290
 291     return dec;
 292 }
 293
 294 static char *xlfd_recompose(const struct xlfd_decomposed *dec)
 295 {
 296 #define FMT_STR(f) "-%s"
 297 #define ARG_STR(f) , dec->f
 298 #define FMT_INT(f) "%s%.*d"
 299 #define ARG_INT(f)                                      \
 300         , dec->f == XLFD_INT_WILDCARD ? "-*" : "-"      \
 301         , dec->f == XLFD_INT_WILDCARD ? 0 : 1           \
 302         , dec->f == XLFD_INT_WILDCARD ? 0 : dec->f
 303     return dupprintf(XLFD_STRING_PARTS_LIST(FMT_STR, FMT_INT)
 304                      XLFD_STRING_PARTS_LIST(ARG_STR, ARG_INT));
 305 #undef FMT_STR
 306 #undef ARG_STR
 307 #undef FMT_INT
 308 #undef ARG_INT
 309 }
 310
 311 static char *x11_guess_derived_font_name(XFontStruct *xfs, int bold, int wide)
 312 {
 313     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 314     Atom fontprop = XInternAtom(disp, "FONT", False);
 315     unsigned long ret;
 316     if (XGetFontProperty(xfs, fontprop, &ret)) {
 317         char *name = XGetAtomName(disp, (Atom)ret);
 318         struct xlfd_decomposed *xlfd = xlfd_decompose(name);
 319         if (!xlfd)
 320             return NULL;
 321
 322         if (bold)
 323             xlfd->weight_name = "bold";
 324
 325         if (wide) {
 326             /* Width name obviously may have changed. */
 327             /* Additional style may now become e.g. `ja' or `ko'. */
 328             xlfd->setwidth_name = xlfd->add_style_name = "*";
 329
 330             /* Expect to double the average width. */
 331             xlfd->average_width *= 2;
 332         }
 333
 334         {
 335             char *ret = xlfd_recompose(xlfd);
 336             sfree(xlfd);
 337             return ret;
 338         }
 339     }
 340     return NULL;
 341 }
 342
 343 static int x11_font_width(XFontStruct *xfs, int sixteen_bit)
 344 {
 345     if (sixteen_bit) {
 346         XChar2b space;
 347         space.byte1 = 0;
 348         space.byte2 = '0';
 349         return XTextWidth16(xfs, &space, 1);
 350     } else {
 351         return XTextWidth(xfs, "0", 1);
 352     }
 353 }
 354
 355 static const XCharStruct *x11_char_struct(
 356     XFontStruct *xfs, unsigned char byte1, unsigned char byte2)
 357 {
 358     int index;
 359
 360     /*
 361      * The man page for XQueryFont is rather confusing about how the
 362      * per_char array in the XFontStruct is laid out, because it gives
 363      * formulae for determining the two-byte X character code _from_
 364      * an index into the per_char array. Going the other way, it's
 365      * rather simpler:
 366      *
 367      * The valid character codes have byte1 between min_byte1 and
 368      * max_byte1 inclusive, and byte2 between min_char_or_byte2 and
 369      * max_char_or_byte2 inclusive. This gives a rectangle of size
 370      * (max_byte2-min_byte1+1) by
 371      * (max_char_or_byte2-min_char_or_byte2+1), which is precisely the
 372      * rectangle encoded in the per_char array. Hence, given a
 373      * character code which is valid in the sense that it falls
 374      * somewhere in that rectangle, its index in per_char is given by
 375      * setting
 376      *
 377      *   x = byte2 - min_char_or_byte2
 378      *   y = byte1 - min_byte1
 379      *   index = y * (max_char_or_byte2-min_char_or_byte2+1) + x
 380      *
 381      * If min_byte1 and min_byte2 are both zero, that's a special case
 382      * which can be treated as if min_byte2 was 1 instead, i.e. the
 383      * per_char array just runs from min_char_or_byte2 to
 384      * max_char_or_byte2 inclusive, and byte1 should always be zero.
 385      */
 386
 387     if (byte2 < xfs->min_char_or_byte2 || byte2 > xfs->max_char_or_byte2)
 388         return FALSE;
 389
 390     if (xfs->min_byte1 == 0 && xfs->max_byte1 == 0) {
 391         index = byte2 - xfs->min_char_or_byte2;
 392     } else {
 393         if (byte1 < xfs->min_byte1 || byte1 > xfs->max_byte1)
 394             return FALSE;
 395         index = ((byte2 - xfs->min_char_or_byte2) +
 396                  ((byte1 - xfs->min_byte1) *
 397                   (xfs->max_char_or_byte2 - xfs->min_char_or_byte2 + 1)));
 398     }
 399
 400     if (!xfs->per_char)   /* per_char NULL => everything in range exists */
 401         return &xfs->max_bounds;
 402
 403     return &xfs->per_char[index];
 404 }
 405
 406 static int x11_font_has_glyph(
 407     XFontStruct *xfs, unsigned char byte1, unsigned char byte2)
 408 {
 409     /*
 410      * Not to be confused with x11font_has_glyph, which is a method of
 411      * the x11font 'class' and hence takes a unifont as argument. This
 412      * is the low-level function which grubs about in an actual
 413      * XFontStruct to see if a given glyph exists.
 414      *
 415      * We must do this ourselves rather than letting Xlib's
 416      * XTextExtents16 do the job, because XTextExtents will helpfully
 417      * substitute the font's default_char for any missing glyph and
 418      * not tell us it did so, which precisely won't help us find out
 419      * which glyphs _are_ missing.
 420      */
 421     const XCharStruct *xcs = x11_char_struct(xfs, byte1, byte2);
 422     return xcs && (xcs->ascent + xcs->descent > 0 || xcs->width > 0);
 423 }
 424
 425 static unifont *x11font_create(GtkWidget *widget, const char *name,
 426                                int wide, int bold,
 427                                int shadowoffset, int shadowalways)
 428 {
 429     struct x11font *xfont;
 430     XFontStruct *xfs;
 431     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 432     Atom charset_registry, charset_encoding, spacing;
 433     unsigned long registry_ret, encoding_ret, spacing_ret;
 434     int pubcs, realcs, sixteen_bit, variable;
 435     int i;
 436
 437     xfs = XLoadQueryFont(disp, name);
 438     if (!xfs)
 439         return NULL;
 440
 441     charset_registry = XInternAtom(disp, "CHARSET_REGISTRY", False);
 442     charset_encoding = XInternAtom(disp, "CHARSET_ENCODING", False);
 443
 444     pubcs = realcs = CS_NONE;
 445     sixteen_bit = FALSE;
 446     variable = TRUE;
 447
 448     if (XGetFontProperty(xfs, charset_registry, &registry_ret) &&
 449         XGetFontProperty(xfs, charset_encoding, &encoding_ret)) {
 450         char *reg, *enc;
 451         reg = XGetAtomName(disp, (Atom)registry_ret);
 452         enc = XGetAtomName(disp, (Atom)encoding_ret);
 453         if (reg && enc) {
 454             char *encoding = dupcat(reg, "-", enc, NULL);
 455             pubcs = realcs = charset_from_xenc(encoding);
 456
 457             /*
 458              * iso10646-1 is the only wide font encoding we
 459              * support. In this case, we expect clients to give us
 460              * UTF-8, which this module must internally convert
 461              * into 16-bit Unicode.
 462              */
 463             if (!strcasecmp(encoding, "iso10646-1")) {
 464                 sixteen_bit = TRUE;
 465                 pubcs = realcs = CS_UTF8;
 466             }
 467
 468             /*
 469              * Hack for X line-drawing characters: if the primary font
 470              * is encoded as ISO-8859-1, and has valid glyphs in the
 471              * low character positions, it is assumed that those
 472              * glyphs are the VT100 line-drawing character set.
 473              */
 474             if (pubcs == CS_ISO8859_1) {
 475                 int ch;
 476                 for (ch = 1; ch < 32; ch++)
 477                     if (!x11_font_has_glyph(xfs, 0, ch))
 478                         break;
 479                 if (ch == 32)
 480                     realcs = CS_ISO8859_1_X11;
 481             }
 482
 483             sfree(encoding);
 484         }
 485     }
 486
 487     spacing = XInternAtom(disp, "SPACING", False);
 488     if (XGetFontProperty(xfs, spacing, &spacing_ret)) {
 489         char *spc;
 490         spc = XGetAtomName(disp, (Atom)spacing_ret);
 491
 492         if (spc && strchr("CcMm", spc[0]))
 493             variable = FALSE;
 494     }
 495
 496     xfont = snew(struct x11font);
 497     xfont->u.vt = &x11font_vtable;
 498     xfont->u.width = x11_font_width(xfs, sixteen_bit);
 499     xfont->u.ascent = xfs->ascent;
 500     xfont->u.descent = xfs->descent;
 501     xfont->u.height = xfont->u.ascent + xfont->u.descent;
 502     xfont->u.public_charset = pubcs;
 503     xfont->u.want_fallback = TRUE;
 504 #ifdef DRAW_TEXT_GDK
 505     xfont->u.preferred_drawtype = DRAWTYPE_GDK;
 506 #elif defined DRAW_TEXT_CAIRO
 507     xfont->u.preferred_drawtype = DRAWTYPE_CAIRO;
 508 #else
 509 #error No drawtype available at all
 510 #endif
 511     xfont->real_charset = realcs;
 512     xfont->sixteen_bit = sixteen_bit;
 513     xfont->variable = variable;
 514     xfont->wide = wide;
 515     xfont->bold = bold;
 516     xfont->shadowoffset = shadowoffset;
 517     xfont->shadowalways = shadowalways;
 518
 519     for (i = 0; i < lenof(xfont->fonts); i++) {
 520         xfont->fonts[i].xfs = NULL;
 521         xfont->fonts[i].allocated = FALSE;
 522 #ifdef DRAW_TEXT_CAIRO
 523         xfont->fonts[i].glyphcache = NULL;
 524         xfont->fonts[i].nglyphs = 0;
 525         xfont->fonts[i].pixmap = None;
 526         xfont->fonts[i].gc = None;
 527 #endif
 528     }
 529     xfont->fonts[0].xfs = xfs;
 530     xfont->fonts[0].allocated = TRUE;
 531
 532     return (unifont *)xfont;
 533 }
 534
 535 static void x11font_destroy(unifont *font)
 536 {
 537     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 538     struct x11font *xfont = (struct x11font *)font;
 539     int i;
 540
 541     for (i = 0; i < lenof(xfont->fonts); i++) {
 542         if (xfont->fonts[i].xfs)
 543             XFreeFont(disp, xfont->fonts[i].xfs);
 544 #ifdef DRAW_TEXT_CAIRO
 545         if (xfont->fonts[i].gc != None)
 546             XFreeGC(disp, xfont->fonts[i].gc);
 547         if (xfont->fonts[i].pixmap != None)
 548             XFreePixmap(disp, xfont->fonts[i].pixmap);
 549         if (xfont->fonts[i].glyphcache) {
 550             int j;
 551             for (j = 0; j < xfont->fonts[i].nglyphs; j++) {
 552                 cairo_surface_destroy(xfont->fonts[i].glyphcache[j].surface);
 553                 sfree(xfont->fonts[i].glyphcache[j].bitmap);
 554             }
 555             sfree(xfont->fonts[i].glyphcache);
 556         }
 557 #endif
 558     }
 559     sfree(font);
 560 }
 561
 562 static void x11_alloc_subfont(struct x11font *xfont, int sfid)
 563 {
 564     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 565     char *derived_name = x11_guess_derived_font_name
 566         (xfont->fonts[0].xfs, sfid & 1, !!(sfid & 2));
 567     xfont->fonts[sfid].xfs = XLoadQueryFont(disp, derived_name);
 568     xfont->fonts[sfid].allocated = TRUE;
 569     sfree(derived_name);
 570     /* Note that xfont->fonts[sfid].xfs may still be NULL, if XLQF failed. */
 571 }
 572
 573 static int x11font_has_glyph(unifont *font, wchar_t glyph)
 574 {
 575     struct x11font *xfont = (struct x11font *)font;
 576
 577     if (xfont->sixteen_bit) {
 578         /*
 579          * This X font has 16-bit character indices, which means
 580          * we can directly use our Unicode input value.
 581          */
 582         return x11_font_has_glyph(xfont->fonts[0].xfs,
 583                                   glyph >> 8, glyph & 0xFF);
 584     } else {
 585         /*
 586          * This X font has 8-bit indices, so we must convert to the
 587          * appropriate character set.
 588          */
 589         char sbstring[2];
 590         int sblen = wc_to_mb(xfont->real_charset, 0, &glyph, 1,
 591                              sbstring, 2, "", NULL, NULL);
 592         if (sblen == 0 || !sbstring[0])
 593             return FALSE;              /* not even in the charset */
 594
 595         return x11_font_has_glyph(xfont->fonts[0].xfs, 0,
 596                                   (unsigned char)sbstring[0]);
 597     }
 598 }
 599
 600 #if !GTK_CHECK_VERSION(2,0,0)
 601 #define GDK_DRAWABLE_XID(d) GDK_WINDOW_XWINDOW(d) /* GTK1's name for this */
 602 #elif GTK_CHECK_VERSION(3,0,0)
 603 #define GDK_DRAWABLE_XID(d) GDK_WINDOW_XID(d) /* GTK3's name for this */
 604 #endif
 605
 606 static int x11font_width_16(unifont_drawctx *ctx, x11font_individual *xfi,
 607                             const void *vstring, int start, int length)
 608 {
 609     const XChar2b *string = (const XChar2b *)vstring;
 610     return XTextWidth16(xfi->xfs, string+start, length);
 611 }
 612
 613 static int x11font_width_8(unifont_drawctx *ctx, x11font_individual *xfi,
 614                            const void *vstring, int start, int length)
 615 {
 616     const char *string = (const char *)vstring;
 617     return XTextWidth(xfi->xfs, string+start, length);
 618 }
 619
 620 #ifdef DRAW_TEXT_GDK
 621 static void x11font_gdk_setup(unifont_drawctx *ctx, x11font_individual *xfi)
 622 {
 623     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 624     XSetFont(disp, GDK_GC_XGC(ctx->u.gdk.gc), xfi->xfs->fid);
 625 }
 626
 627 static void x11font_gdk_draw_16(unifont_drawctx *ctx,
 628                                 x11font_individual *xfi, int x, int y,
 629                                 const void *vstring, int start, int length)
 630 {
 631     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 632     const XChar2b *string = (const XChar2b *)vstring;
 633     XDrawString16(disp, GDK_DRAWABLE_XID(ctx->u.gdk.target),
 634                   GDK_GC_XGC(ctx->u.gdk.gc), x, y, string+start, length);
 635 }
 636
 637 static void x11font_gdk_draw_8(unifont_drawctx *ctx,
 638                                x11font_individual *xfi, int x, int y,
 639                                const void *vstring, int start, int length)
 640 {
 641     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 642     const char *string = (const char *)vstring;
 643     XDrawString(disp, GDK_DRAWABLE_XID(ctx->u.gdk.target),
 644                 GDK_GC_XGC(ctx->u.gdk.gc), x, y, string+start, length);
 645 }
 646 #endif
 647
 648 #ifdef DRAW_TEXT_CAIRO
 649 static void x11font_cairo_setup(unifont_drawctx *ctx, x11font_individual *xfi)
 650 {
 651     if (xfi->pixmap == None) {
 652         Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 653         XGCValues gcvals;
 654         GdkWindow *widgetwin = gtk_widget_get_window(ctx->u.cairo.widget);
 655         int widgetscr = GDK_SCREEN_XNUMBER(gdk_window_get_screen(widgetwin));
 656
 657         xfi->pixwidth =
 658             xfi->xfs->max_bounds.rbearing - xfi->xfs->min_bounds.lbearing;
 659         xfi->pixheight =
 660             xfi->xfs->max_bounds.ascent + xfi->xfs->max_bounds.descent;
 661         xfi->pixoriginx = -xfi->xfs->min_bounds.lbearing;
 662         xfi->pixoriginy = xfi->xfs->max_bounds.ascent;
 663
 664         xfi->rowsize = cairo_format_stride_for_width(CAIRO_FORMAT_A1,
 665                                                      xfi->pixwidth);
 666         xfi->allsize = xfi->rowsize * xfi->pixheight;
 667
 668         {
 669             /*
 670              * Test host endianness and use it to set xfi->indexflip,
 671              * which is XORed into our left-shift counts in order to
 672              * implement the CAIRO_FORMAT_A1 specification, in which
 673              * each bitmap byte is oriented LSB-first on little-endian
 674              * platforms and MSB-first on big-endian ones.
 675              *
 676              * This is the same technique Cairo itself uses to test
 677              * endianness, so hopefully it'll work in any situation
 678              * where Cairo is usable at all.
 679              */
 680             static const int endianness_test = 1;
 681             xfi->indexflip = (*((char *) &endianness_test) == 1) ? 0 : 7;
 682         }
 683
 684         xfi->pixmap = XCreatePixmap
 685             (disp,
 686              GDK_DRAWABLE_XID(gtk_widget_get_window(ctx->u.cairo.widget)),
 687              xfi->pixwidth, xfi->pixheight, 1);
 688         gcvals.foreground = WhitePixel(disp, widgetscr);
 689         gcvals.background = BlackPixel(disp, widgetscr);
 690         gcvals.font = xfi->xfs->fid;
 691         xfi->gc = XCreateGC(disp, xfi->pixmap,
 692                             GCForeground | GCBackground | GCFont, &gcvals);
 693     }
 694 }
 695
 696 static void x11font_cairo_cache_glyph(x11font_individual *xfi, int glyphindex)
 697 {
 698     XImage *image;
 699     int x, y;
 700     unsigned char *bitmap;
 701     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 702     const XCharStruct *xcs = x11_char_struct(xfi->xfs, glyphindex >> 8,
 703                                              glyphindex & 0xFF);
 704
 705     bitmap = snewn(xfi->allsize, unsigned char);
 706     memset(bitmap, 0, xfi->allsize);
 707
 708     image = XGetImage(disp, xfi->pixmap, 0, 0,
 709                       xfi->pixwidth, xfi->pixheight, AllPlanes, XYPixmap);
 710     for (y = xfi->pixoriginy - xcs->ascent;
 711          y < xfi->pixoriginy + xcs->descent; y++) {
 712         for (x = xfi->pixoriginx + xcs->lbearing;
 713              x < xfi->pixoriginx + xcs->rbearing; x++) {
 714             unsigned long pixel = XGetPixel(image, x, y);
 715             if (pixel) {
 716                 int byteindex = y * xfi->rowsize + x/8;
 717                 int bitindex = (x & 7) ^ xfi->indexflip;
 718                 bitmap[byteindex] |= 1U << bitindex;
 719             }
 720         }
 721     }
 722     XDestroyImage(image);
 723
 724     if (xfi->nglyphs <= glyphindex) {
 725         /* Round up to the next multiple of 256 on the general
 726          * principle that Unicode characters come in contiguous blocks
 727          * often used together */
 728         int old_nglyphs = xfi->nglyphs;
 729         xfi->nglyphs = (glyphindex + 0x100) & ~0xFF;
 730         xfi->glyphcache = sresize(xfi->glyphcache, xfi->nglyphs,
 731                                   struct cairo_cached_glyph);
 732
 733         while (old_nglyphs < xfi->nglyphs) {
 734             xfi->glyphcache[old_nglyphs].surface = NULL;
 735             xfi->glyphcache[old_nglyphs].bitmap = NULL;
 736             old_nglyphs++;
 737         }
 738     }
 739     xfi->glyphcache[glyphindex].bitmap = bitmap;
 740     xfi->glyphcache[glyphindex].surface = cairo_image_surface_create_for_data
 741         (bitmap, CAIRO_FORMAT_A1, xfi->pixwidth, xfi->pixheight, xfi->rowsize);
 742 }
 743
 744 static void x11font_cairo_draw_glyph(unifont_drawctx *ctx,
 745                                      x11font_individual *xfi, int x, int y,
 746                                      int glyphindex)
 747 {
 748     if (xfi->glyphcache[glyphindex].surface) {
 749         cairo_mask_surface(ctx->u.cairo.cr,
 750                            xfi->glyphcache[glyphindex].surface,
 751                            x - xfi->pixoriginx, y - xfi->pixoriginy);
 752     }
 753 }
 754
 755 static void x11font_cairo_draw_16(unifont_drawctx *ctx,
 756                                   x11font_individual *xfi, int x, int y,
 757                                   const void *vstring, int start, int length)
 758 {
 759     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 760     const XChar2b *string = (const XChar2b *)vstring + start;
 761     int i;
 762     for (i = 0; i < length; i++) {
 763         if (x11_font_has_glyph(xfi->xfs, string[i].byte1, string[i].byte2)) {
 764             int glyphindex = (256 * (unsigned char)string[i].byte1 +
 765                               (unsigned char)string[i].byte2);
 766             if (glyphindex >= xfi->nglyphs ||
 767                 !xfi->glyphcache[glyphindex].surface) {
 768                 XDrawImageString16(disp, xfi->pixmap, xfi->gc,
 769                                    xfi->pixoriginx, xfi->pixoriginy,
 770                                    string+i, 1);
 771                 x11font_cairo_cache_glyph(xfi, glyphindex);
 772             }
 773             x11font_cairo_draw_glyph(ctx, xfi, x, y, glyphindex);
 774             x += XTextWidth16(xfi->xfs, string+i, 1);
 775         }
 776     }
 777 }
 778
 779 static void x11font_cairo_draw_8(unifont_drawctx *ctx,
 780                                  x11font_individual *xfi, int x, int y,
 781                                  const void *vstring, int start, int length)
 782 {
 783     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 784     const char *string = (const char *)vstring + start;
 785     int i;
 786     for (i = 0; i < length; i++) {
 787         if (x11_font_has_glyph(xfi->xfs, 0, string[i])) {
 788             int glyphindex = (unsigned char)string[i];
 789             if (glyphindex >= xfi->nglyphs ||
 790                 !xfi->glyphcache[glyphindex].surface) {
 791                 XDrawImageString(disp, xfi->pixmap, xfi->gc,
 792                                  xfi->pixoriginx, xfi->pixoriginy,
 793                                  string+i, 1);
 794                 x11font_cairo_cache_glyph(xfi, glyphindex);
 795             }
 796             x11font_cairo_draw_glyph(ctx, xfi, x, y, glyphindex);
 797             x += XTextWidth(xfi->xfs, string+i, 1);
 798         }
 799     }
 800 }
 801 #endif /* DRAW_TEXT_CAIRO */
 802
 803 struct x11font_drawfuncs {
 804     int (*width)(unifont_drawctx *ctx, x11font_individual *xfi,
 805                  const void *vstring, int start, int length);
 806     void (*setup)(unifont_drawctx *ctx, x11font_individual *xfi);
 807     void (*draw)(unifont_drawctx *ctx, x11font_individual *xfi, int x, int y,
 808                  const void *vstring, int start, int length);
 809 };
 810
 811 /*
 812  * This array has two entries per compiled-in drawtype; of each pair,
 813  * the first is for an 8-bit font and the second for 16-bit.
 814  */
 815 static const struct x11font_drawfuncs x11font_drawfuncs[2*DRAWTYPE_NTYPES] = {
 816 #ifdef DRAW_TEXT_GDK
 817     /* gdk, 8-bit */
 818     {
 819         x11font_width_8,
 820         x11font_gdk_setup,
 821         x11font_gdk_draw_8,
 822     },
 823     /* gdk, 16-bit */
 824     {
 825         x11font_width_16,
 826         x11font_gdk_setup,
 827         x11font_gdk_draw_16,
 828     },
 829 #endif
 830 #ifdef DRAW_TEXT_CAIRO
 831     /* cairo, 8-bit */
 832     {
 833         x11font_width_8,
 834         x11font_cairo_setup,
 835         x11font_cairo_draw_8,
 836     },
 837     /* [3] cairo, 16-bit */
 838     {
 839         x11font_width_16,
 840         x11font_cairo_setup,
 841         x11font_cairo_draw_16,
 842     },
 843 #endif
 844 };
 845
 846 static void x11font_really_draw_text(const struct x11font_drawfuncs *dfns,
 847                                      unifont_drawctx *ctx,
 848                                      x11font_individual *xfi, int x, int y,
 849                                      const void *string, int nchars,
 850                                      int shadowoffset,
 851                                      int fontvariable, int cellwidth)
 852 {
 853     int start = 0, step, nsteps, centre;
 854
 855     if (fontvariable) {
 856         /*
 857          * In a variable-pitch font, we draw one character at a
 858          * time, and centre it in the character cell.
 859          */
 860         step = 1;
 861         nsteps = nchars;
 862         centre = TRUE;
 863     } else {
 864         /*
 865          * In a fixed-pitch font, we can draw the whole lot in one go.
 866          */
 867         step = nchars;
 868         nsteps = 1;
 869         centre = FALSE;
 870     }
 871
 872     dfns->setup(ctx, xfi);
 873
 874     while (nsteps-- > 0) {
 875         int X = x;
 876         if (centre)
 877             X += (cellwidth - dfns->width(ctx, xfi, string, start, step)) / 2;
 878
 879         dfns->draw(ctx, xfi, X, y, string, start, step);
 880         if (shadowoffset)
 881             dfns->draw(ctx, xfi, X + shadowoffset, y, string, start, step);
 882
 883         x += cellwidth;
 884         start += step;
 885     }
 886 }
 887
 888 static void x11font_draw_text(unifont_drawctx *ctx, unifont *font,
 889                               int x, int y, const wchar_t *string, int len,
 890                               int wide, int bold, int cellwidth)
 891 {
 892     struct x11font *xfont = (struct x11font *)font;
 893     int sfid;
 894     int shadowoffset = 0;
 895     int mult = (wide ? 2 : 1);
 896     int index = 2 * (int)ctx->type;
 897
 898     wide -= xfont->wide;
 899     bold -= xfont->bold;
 900
 901     /*
 902      * Decide which subfont we're using, and whether we have to
 903      * use shadow bold.
 904      */
 905     if (xfont->shadowalways && bold) {
 906         shadowoffset = xfont->shadowoffset;
 907         bold = 0;
 908     }
 909     sfid = 2 * wide + bold;
 910     if (!xfont->fonts[sfid].allocated)
 911         x11_alloc_subfont(xfont, sfid);
 912     if (bold && !xfont->fonts[sfid].xfs) {
 913         bold = 0;
 914         shadowoffset = xfont->shadowoffset;
 915         sfid = 2 * wide + bold;
 916         if (!xfont->fonts[sfid].allocated)
 917             x11_alloc_subfont(xfont, sfid);
 918     }
 919
 920     if (!xfont->fonts[sfid].xfs)
 921         return;                        /* we've tried our best, but no luck */
 922
 923     if (xfont->sixteen_bit) {
 924         /*
 925          * This X font has 16-bit character indices, which means
 926          * we can directly use our Unicode input string.
 927          */
 928         XChar2b *xcs;
 929         int i;
 930
 931         xcs = snewn(len, XChar2b);
 932         for (i = 0; i < len; i++) {
 933             xcs[i].byte1 = string[i] >> 8;
 934             xcs[i].byte2 = string[i];
 935         }
 936
 937         x11font_really_draw_text(x11font_drawfuncs + index + 1, ctx,
 938                                  &xfont->fonts[sfid], x, y,
 939                                  xcs, len, shadowoffset,
 940                                  xfont->variable, cellwidth * mult);
 941         sfree(xcs);
 942     } else {
 943         /*
 944          * This X font has 8-bit indices, so we must convert to the
 945          * appropriate character set.
 946          */
 947         char *sbstring = snewn(len+1, char);
 948         int sblen = wc_to_mb(xfont->real_charset, 0, string, len,
 949                              sbstring, len+1, ".", NULL, NULL);
 950         x11font_really_draw_text(x11font_drawfuncs + index + 0, ctx,
 951                                  &xfont->fonts[sfid], x, y,
 952                                  sbstring, sblen, shadowoffset,
 953                                  xfont->variable, cellwidth * mult);
 954         sfree(sbstring);
 955     }
 956 }
 957
 958 static void x11font_draw_combining(unifont_drawctx *ctx, unifont *font,
 959                                    int x, int y, const wchar_t *string,
 960                                    int len, int wide, int bold, int cellwidth)
 961 {
 962     /*
 963      * For server-side fonts, there's no sophisticated system for
 964      * combining characters intelligently, so the best we can do is to
 965      * overprint them on each other in the obvious way.
 966      */
 967     int i;
 968     for (i = 0; i < len; i++)
 969         x11font_draw_text(ctx, font, x, y, string+i, 1, wide, bold, cellwidth);
 970 }
 971
 972 static void x11font_enum_fonts(GtkWidget *widget,
 973                                fontsel_add_entry callback, void *callback_ctx)
 974 {
 975     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
 976     char **fontnames;
 977     char *tmp = NULL;
 978     int nnames, i, max, tmpsize;
 979
 980     max = 32768;
 981     while (1) {
 982         fontnames = XListFonts(disp, "*", max, &nnames);
 983         if (nnames >= max) {
 984             XFreeFontNames(fontnames);
 985             max *= 2;
 986         } else
 987             break;
 988     }
 989
 990     tmpsize = 0;
 991
 992     for (i = 0; i < nnames; i++) {
 993         struct xlfd_decomposed *xlfd = xlfd_decompose(fontnames[i]);
 994         if (xlfd) {
 995             char *p, *font, *style, *stylekey, *charset;
 996             int weightkey, slantkey, setwidthkey;
 997             int thistmpsize;
 998
 999             /*
1000              * Convert a dismembered XLFD into the format we'll be
1001              * using in the font selector.
1002              */
1003
1004             thistmpsize = 4 * strlen(fontnames[i]) + 256;
1005             if (tmpsize < thistmpsize) {
1006                 tmpsize = thistmpsize;
1007                 tmp = sresize(tmp, tmpsize, char);
1008             }
1009             p = tmp;
1010
1011             /*
1012              * Font name is in the form "family (foundry)". (This is
1013              * what the GTK 1.2 X font selector does, and it seems to
1014              * come out looking reasonably sensible.)
1015              */
1016             font = p;
1017             p += 1 + sprintf(p, "%s (%s)", xlfd->family_name, xlfd->foundry);
1018
1019             /*
1020              * Character set.
1021              */
1022             charset = p;
1023             p += 1 + sprintf(p, "%s-%s", xlfd->charset_registry,
1024                              xlfd->charset_encoding);
1025
1026             /*
1027              * Style is a mixture of quite a lot of the fields,
1028              * with some strange formatting.
1029              */
1030             style = p;
1031             p += sprintf(p, "%s", xlfd->weight_name[0] ? xlfd->weight_name :
1032                          "regular");
1033             if (!g_ascii_strcasecmp(xlfd->slant, "i"))
1034                 p += sprintf(p, " italic");
1035             else if (!g_ascii_strcasecmp(xlfd->slant, "o"))
1036                 p += sprintf(p, " oblique");
1037             else if (!g_ascii_strcasecmp(xlfd->slant, "ri"))
1038                 p += sprintf(p, " reverse italic");
1039             else if (!g_ascii_strcasecmp(xlfd->slant, "ro"))
1040                 p += sprintf(p, " reverse oblique");
1041             else if (!g_ascii_strcasecmp(xlfd->slant, "ot"))
1042                 p += sprintf(p, " other-slant");
1043             if (xlfd->setwidth_name[0] &&
1044                 g_ascii_strcasecmp(xlfd->setwidth_name, "normal"))
1045                 p += sprintf(p, " %s", xlfd->setwidth_name);
1046             if (!g_ascii_strcasecmp(xlfd->spacing, "m"))
1047                 p += sprintf(p, " [M]");
1048             if (!g_ascii_strcasecmp(xlfd->spacing, "c"))
1049                 p += sprintf(p, " [C]");
1050             if (xlfd->add_style_name[0])
1051                 p += sprintf(p, " %s", xlfd->add_style_name);
1052
1053             /*
1054              * Style key is the same stuff as above, but with a
1055              * couple of transformations done on it to make it
1056              * sort more sensibly.
1057              */
1058             p++;
1059             stylekey = p;
1060             if (!g_ascii_strcasecmp(xlfd->weight_name, "medium") ||
1061                 !g_ascii_strcasecmp(xlfd->weight_name, "regular") ||
1062                 !g_ascii_strcasecmp(xlfd->weight_name, "normal") ||
1063                 !g_ascii_strcasecmp(xlfd->weight_name, "book"))
1064                 weightkey = 0;
1065             else if (!g_ascii_strncasecmp(xlfd->weight_name, "demi", 4) ||
1066                      !g_ascii_strncasecmp(xlfd->weight_name, "semi", 4))
1067                 weightkey = 1;
1068             else
1069                 weightkey = 2;
1070             if (!g_ascii_strcasecmp(xlfd->slant, "r"))
1071                 slantkey = 0;
1072             else if (!g_ascii_strncasecmp(xlfd->slant, "r", 1))
1073                 slantkey = 2;
1074             else
1075                 slantkey = 1;
1076             if (!g_ascii_strcasecmp(xlfd->setwidth_name, "normal"))
1077                 setwidthkey = 0;
1078             else
1079                 setwidthkey = 1;
1080
1081             p += sprintf(
1082                 p, "%04d%04d%s%04d%04d%s%04d%04d%s%04d%s%04d%s",
1083                 weightkey, (int)strlen(xlfd->weight_name), xlfd->weight_name,
1084                 slantkey, (int)strlen(xlfd->slant), xlfd->slant,
1085                 setwidthkey,
1086                 (int)strlen(xlfd->setwidth_name), xlfd->setwidth_name,
1087                 (int)strlen(xlfd->spacing), xlfd->spacing,
1088                 (int)strlen(xlfd->add_style_name), xlfd->add_style_name);
1089
1090             assert(p - tmp < thistmpsize);
1091
1092             /*
1093              * Flags: we need to know whether this is a monospaced
1094              * font, which we do by examining the spacing field
1095              * again.
1096              */
1097             flags = FONTFLAG_SERVERSIDE;
1098             if (!strchr("CcMm", xlfd->spacing[0]))
1099                 flags |= FONTFLAG_NONMONOSPACED;
1100
1101             /*
1102              * Some fonts have a pixel size of zero, meaning they're
1103              * treated as scalable. For these purposes, we only want
1104              * fonts whose pixel size we actually know, so filter
1105              * those out.
1106              */
1107             if (xlfd->pixel_size)
1108                 callback(callback_ctx, fontnames[i], font, charset,
1109                          style, stylekey, xlfd->pixel_size, flags,
1110                          &x11font_vtable);
1111
1112             sfree(xlfd);
1113         } else {
1114             /*
1115              * This isn't an XLFD, so it must be an alias.
1116              * Transmit it with mostly null data.
1117              *
1118              * It would be nice to work out if it's monospaced
1119              * here, but at the moment I can't see that being
1120              * anything but computationally hideous. Ah well.
1121              */
1122             callback(callback_ctx, fontnames[i], fontnames[i], NULL,
1123                      NULL, NULL, 0, FONTFLAG_SERVERALIAS, &x11font_vtable);
1124
1125             sfree(xlfd);
1126         }
1127     }
1128     XFreeFontNames(fontnames);
1129     sfree(tmp);
1130 }
1131
1132 static char *x11font_canonify_fontname(GtkWidget *widget, const char *name,
1133                                        int *size, int *flags,
1134                                        int resolve_aliases)
1135 {
1136     /*
1137      * When given an X11 font name to try to make sense of for a
1138      * font selector, we must attempt to load it (to see if it
1139      * exists), and then canonify it by extracting its FONT
1140      * property, which should give its full XLFD even if what we
1141      * originally had was a wildcard.
1142      *
1143      * However, we must carefully avoid canonifying font
1144      * _aliases_, unless specifically asked to, because the font
1145      * selector treats them as worthwhile in their own right.
1146      */
1147     XFontStruct *xfs;
1148     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
1149     Atom fontprop, fontprop2;
1150     unsigned long ret;
1151
1152     xfs = XLoadQueryFont(disp, name);
1153
1154     if (!xfs)
1155         return NULL;                   /* didn't make sense to us, sorry */
1156
1157     fontprop = XInternAtom(disp, "FONT", False);
1158
1159     if (XGetFontProperty(xfs, fontprop, &ret)) {
1160         char *newname = XGetAtomName(disp, (Atom)ret);
1161         if (newname) {
1162             unsigned long fsize = 12;
1163
1164             fontprop2 = XInternAtom(disp, "PIXEL_SIZE", False);
1165             if (XGetFontProperty(xfs, fontprop2, &fsize) && fsize > 0) {
1166                 *size = fsize;
1167                 XFreeFont(disp, xfs);
1168                 if (flags) {
1169                     if (name[0] == '-' || resolve_aliases)
1170                         *flags = FONTFLAG_SERVERSIDE;
1171                     else
1172                         *flags = FONTFLAG_SERVERALIAS;
1173                 }
1174                 return dupstr(name[0] == '-' || resolve_aliases ?
1175                               newname : name);
1176             }
1177         }
1178     }
1179
1180     XFreeFont(disp, xfs);
1181
1182     return NULL;                       /* something went wrong */
1183 }
1184
1185 static char *x11font_scale_fontname(GtkWidget *widget, const char *name,
1186                                     int size)
1187 {
1188     return NULL;                       /* shan't */
1189 }
1190
1191 static char *x11font_size_increment(unifont *font, int increment)
1192 {
1193     struct x11font *xfont = (struct x11font *)font;
1194     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
1195     Atom fontprop = XInternAtom(disp, "FONT", False);
1196     char *returned_name = NULL;
1197     unsigned long ret;
1198     if (XGetFontProperty(xfont->fonts[0].xfs, fontprop, &ret)) {
1199         struct xlfd_decomposed *xlfd;
1200         struct xlfd_decomposed *xlfd_best;
1201         char *wc;
1202         char **fontnames;
1203         int nnames, i, max;
1204
1205         xlfd = xlfd_decompose(XGetAtomName(disp, (Atom)ret));
1206         if (!xlfd)
1207             return NULL;
1208
1209         /*
1210          * Form a wildcard consisting of everything in the
1211          * original XLFD except for the size-related fields.
1212          */
1213         {
1214             struct xlfd_decomposed xlfd_wc = *xlfd; /* structure copy */
1215             xlfd_wc.pixel_size = XLFD_INT_WILDCARD;
1216             xlfd_wc.point_size = XLFD_INT_WILDCARD;
1217             xlfd_wc.average_width = XLFD_INT_WILDCARD;
1218             wc = xlfd_recompose(&xlfd_wc);
1219         }
1220
1221         /*
1222          * Fetch all the font names matching that wildcard.
1223          */
1224         max = 32768;
1225         while (1) {
1226             fontnames = XListFonts(disp, wc, max, &nnames);
1227             if (nnames >= max) {
1228                 XFreeFontNames(fontnames);
1229                 max *= 2;
1230             } else
1231                 break;
1232         }
1233
1234         sfree(wc);
1235
1236         /*
1237          * Iterate over those to find the one closest in size to the
1238          * original font, in the correct direction.
1239          */
1240
1241 #define FLIPPED_SIZE(xlfd) \
1242         (((xlfd)->pixel_size + (xlfd)->point_size) * \
1243          (increment < 0 ? -1 : +1))
1244
1245         xlfd_best = NULL;
1246         for (i = 0; i < nnames; i++) {
1247             struct xlfd_decomposed *xlfd2 = xlfd_decompose(fontnames[i]);
1248             if (!xlfd2)
1249                 continue;
1250
1251             if (xlfd2->pixel_size != 0 &&
1252                 FLIPPED_SIZE(xlfd2) > FLIPPED_SIZE(xlfd) &&
1253                 (!xlfd_best || FLIPPED_SIZE(xlfd2)<FLIPPED_SIZE(xlfd_best))) {
1254                 sfree(xlfd_best);
1255                 xlfd_best = xlfd2;
1256                 xlfd2 = NULL;
1257             }
1258
1259             sfree(xlfd2);
1260         }
1261
1262 #undef FLIPPED_SIZE
1263
1264         if (xlfd_best) {
1265             char *bare_returned_name = xlfd_recompose(xlfd_best);
1266             returned_name = dupcat(
1267                 xfont->u.vt->prefix, ":", bare_returned_name,
1268                 (const char *)NULL);
1269             sfree(bare_returned_name);
1270         }
1271
1272         XFreeFontNames(fontnames);
1273         sfree(xlfd);
1274         sfree(xlfd_best);
1275     }
1276     return returned_name;
1277 }
1278
1279 #endif /* NOT_X_WINDOWS */
1280
1281 #if GTK_CHECK_VERSION(2,0,0)
1282
1283 /* ----------------------------------------------------------------------
1284  * Pango font implementation (for GTK 2 only).
1285  */
1286
1287 #if defined PANGO_PRE_1POINT4 && !defined PANGO_PRE_1POINT6
1288 #define PANGO_PRE_1POINT6              /* make life easier for pre-1.4 folk */
1289 #endif
1290
1291 static int pangofont_has_glyph(unifont *font, wchar_t glyph);
1292 static void pangofont_draw_text(unifont_drawctx *ctx, unifont *font,
1293                                 int x, int y, const wchar_t *string, int len,
1294                                 int wide, int bold, int cellwidth);
1295 static void pangofont_draw_combining(unifont_drawctx *ctx, unifont *font,
1296                                      int x, int y, const wchar_t *string,
1297                                      int len, int wide, int bold,
1298                                      int cellwidth);
1299 static unifont *pangofont_create(GtkWidget *widget, const char *name,
1300                                  int wide, int bold,
1301                                  int shadowoffset, int shadowalways);
1302 static unifont *pangofont_create_fallback(GtkWidget *widget, int height,
1303                                           int wide, int bold,
1304                                           int shadowoffset, int shadowalways);
1305 static void pangofont_destroy(unifont *font);
1306 static void pangofont_enum_fonts(GtkWidget *widget, fontsel_add_entry callback,
1307                                  void *callback_ctx);
1308 static char *pangofont_canonify_fontname(GtkWidget *widget, const char *name,
1309                                          int *size, int *flags,
1310                                          int resolve_aliases);
1311 static char *pangofont_scale_fontname(GtkWidget *widget, const char *name,
1312                                       int size);
1313 static char *pangofont_size_increment(unifont *font, int increment);
1314
1315 struct pangofont {
1316     struct unifont u;
1317     /*
1318      * Pango objects.
1319      */
1320     PangoFontDescription *desc;
1321     PangoFontset *fset;
1322     /*
1323      * The containing widget.
1324      */
1325     GtkWidget *widget;
1326     /*
1327      * Data passed in to unifont_create().
1328      */
1329     int bold, shadowoffset, shadowalways;
1330     /*
1331      * Cache of character widths, indexed by Unicode code point. In
1332      * pixels; -1 means we haven't asked Pango about this character
1333      * before.
1334      */
1335     int *widthcache;
1336     unsigned nwidthcache;
1337 };
1338
1339 static const struct unifont_vtable pangofont_vtable = {
1340     pangofont_create,
1341     pangofont_create_fallback,
1342     pangofont_destroy,
1343     pangofont_has_glyph,
1344     pangofont_draw_text,
1345     pangofont_draw_combining,
1346     pangofont_enum_fonts,
1347     pangofont_canonify_fontname,
1348     pangofont_scale_fontname,
1349     pangofont_size_increment,
1350     "client",
1351 };
1352
1353 /*
1354  * This function is used to rigorously validate a
1355  * PangoFontDescription. Later versions of Pango have a nasty
1356  * habit of accepting _any_ old string as input to
1357  * pango_font_description_from_string and returning a font
1358  * description which can actually be used to display text, even if
1359  * they have to do it by falling back to their most default font.
1360  * This is doubtless helpful in some situations, but not here,
1361  * because we need to know if a Pango font string actually _makes
1362  * sense_ in order to fall back to treating it as an X font name
1363  * if it doesn't. So we check that the font family is actually one
1364  * supported by Pango.
1365  */
1366 static int pangofont_check_desc_makes_sense(PangoContext *ctx,
1367                                             PangoFontDescription *desc)
1368 {
1369 #ifndef PANGO_PRE_1POINT6
1370     PangoFontMap *map;
1371 #endif
1372     PangoFontFamily **families;
1373     int i, nfamilies, matched;
1374
1375     /*
1376      * Ask Pango for a list of font families, and iterate through
1377      * them to see if one of them matches the family in the
1378      * PangoFontDescription.
1379      */
1380 #ifndef PANGO_PRE_1POINT6
1381     map = pango_context_get_font_map(ctx);
1382     if (!map)
1383         return FALSE;
1384     pango_font_map_list_families(map, &families, &nfamilies);
1385 #else
1386     pango_context_list_families(ctx, &families, &nfamilies);
1387 #endif
1388
1389     matched = FALSE;
1390     for (i = 0; i < nfamilies; i++) {
1391         if (!g_ascii_strcasecmp(pango_font_family_get_name(families[i]),
1392                                 pango_font_description_get_family(desc))) {
1393             matched = TRUE;
1394             break;
1395         }
1396     }
1397     g_free(families);
1398
1399     return matched;
1400 }
1401
1402 static unifont *pangofont_create_internal(GtkWidget *widget,
1403                                           PangoContext *ctx,
1404                                           PangoFontDescription *desc,
1405                                           int wide, int bold,
1406                                           int shadowoffset, int shadowalways)
1407 {
1408     struct pangofont *pfont;
1409 #ifndef PANGO_PRE_1POINT6
1410     PangoFontMap *map;
1411 #endif
1412     PangoFontset *fset;
1413     PangoFontMetrics *metrics;
1414
1415 #ifndef PANGO_PRE_1POINT6
1416     map = pango_context_get_font_map(ctx);
1417     if (!map) {
1418         pango_font_description_free(desc);
1419         return NULL;
1420     }
1421     fset = pango_font_map_load_fontset(map, ctx, desc,
1422                                        pango_context_get_language(ctx));
1423 #else
1424     fset = pango_context_load_fontset(ctx, desc,
1425                                       pango_context_get_language(ctx));
1426 #endif
1427     if (!fset) {
1428         pango_font_description_free(desc);
1429         return NULL;
1430     }
1431     metrics = pango_fontset_get_metrics(fset);
1432     if (!metrics ||
1433         pango_font_metrics_get_approximate_digit_width(metrics) == 0) {
1434         pango_font_description_free(desc);
1435         g_object_unref(fset);
1436         return NULL;
1437     }
1438
1439     pfont = snew(struct pangofont);
1440     pfont->u.vt = &pangofont_vtable;
1441     pfont->u.width =
1442         PANGO_PIXELS(pango_font_metrics_get_approximate_digit_width(metrics));
1443     pfont->u.ascent = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics));
1444     pfont->u.descent = PANGO_PIXELS(pango_font_metrics_get_descent(metrics));
1445     pfont->u.height = pfont->u.ascent + pfont->u.descent;
1446     pfont->u.want_fallback = FALSE;
1447 #ifdef DRAW_TEXT_CAIRO
1448     pfont->u.preferred_drawtype = DRAWTYPE_CAIRO;
1449 #elif defined DRAW_TEXT_GDK
1450     pfont->u.preferred_drawtype = DRAWTYPE_GDK;
1451 #else
1452 #error No drawtype available at all
1453 #endif
1454     /* The Pango API is hardwired to UTF-8 */
1455     pfont->u.public_charset = CS_UTF8;
1456     pfont->desc = desc;
1457     pfont->fset = fset;
1458     pfont->widget = widget;
1459     pfont->bold = bold;
1460     pfont->shadowoffset = shadowoffset;
1461     pfont->shadowalways = shadowalways;
1462     pfont->widthcache = NULL;
1463     pfont->nwidthcache = 0;
1464
1465     pango_font_metrics_unref(metrics);
1466
1467     return (unifont *)pfont;
1468 }
1469
1470 static unifont *pangofont_create(GtkWidget *widget, const char *name,
1471                                  int wide, int bold,
1472                                  int shadowoffset, int shadowalways)
1473 {
1474     PangoContext *ctx;
1475     PangoFontDescription *desc;
1476
1477     desc = pango_font_description_from_string(name);
1478     if (!desc)
1479         return NULL;
1480     ctx = gtk_widget_get_pango_context(widget);
1481     if (!ctx) {
1482         pango_font_description_free(desc);
1483         return NULL;
1484     }
1485     if (!pangofont_check_desc_makes_sense(ctx, desc)) {
1486         pango_font_description_free(desc);
1487         return NULL;
1488     }
1489     return pangofont_create_internal(widget, ctx, desc, wide, bold,
1490                                      shadowoffset, shadowalways);
1491 }
1492
1493 static unifont *pangofont_create_fallback(GtkWidget *widget, int height,
1494                                           int wide, int bold,
1495                                           int shadowoffset, int shadowalways)
1496 {
1497     PangoContext *ctx;
1498     PangoFontDescription *desc;
1499
1500     desc = pango_font_description_from_string("Monospace");
1501     if (!desc)
1502         return NULL;
1503     ctx = gtk_widget_get_pango_context(widget);
1504     if (!ctx) {
1505         pango_font_description_free(desc);
1506         return NULL;
1507     }
1508     pango_font_description_set_absolute_size(desc, height * PANGO_SCALE);
1509     return pangofont_create_internal(widget, ctx, desc, wide, bold,
1510                                      shadowoffset, shadowalways);
1511 }
1512
1513 static void pangofont_destroy(unifont *font)
1514 {
1515     struct pangofont *pfont = (struct pangofont *)font;
1516     pango_font_description_free(pfont->desc);
1517     sfree(pfont->widthcache);
1518     g_object_unref(pfont->fset);
1519     sfree(font);
1520 }
1521
1522 static int pangofont_char_width(PangoLayout *layout, struct pangofont *pfont,
1523                                 wchar_t uchr, const char *utfchr, int utflen)
1524 {
1525     /*
1526      * Here we check whether a character has the same width as the
1527      * character cell it'll be drawn in. Because profiling showed that
1528      * asking Pango for text sizes was a huge bottleneck when we were
1529      * calling it every time we needed to know this, we instead call
1530      * it only on characters we don't already know about, and cache
1531      * the results.
1532      */
1533
1534     if ((unsigned)uchr >= pfont->nwidthcache) {
1535         unsigned newsize = ((int)uchr + 0x100) & ~0xFF;
1536         pfont->widthcache = sresize(pfont->widthcache, newsize, int);
1537         while (pfont->nwidthcache < newsize)
1538             pfont->widthcache[pfont->nwidthcache++] = -1;
1539     }
1540
1541     if (pfont->widthcache[uchr] < 0) {
1542         PangoRectangle rect;
1543         pango_layout_set_text(layout, utfchr, utflen);
1544         pango_layout_get_extents(layout, NULL, &rect);
1545         pfont->widthcache[uchr] = rect.width;
1546     }
1547
1548     return pfont->widthcache[uchr];
1549 }
1550
1551 static int pangofont_has_glyph(unifont *font, wchar_t glyph)
1552 {
1553     /* Pango implements font fallback, so assume it has everything */
1554     return TRUE;
1555 }
1556
1557 #ifdef DRAW_TEXT_GDK
1558 static void pango_gdk_draw_layout(unifont_drawctx *ctx,
1559                                   gint x, gint y, PangoLayout *layout)
1560 {
1561     gdk_draw_layout(ctx->u.gdk.target, ctx->u.gdk.gc, x, y, layout);
1562 }
1563 #endif
1564
1565 #ifdef DRAW_TEXT_CAIRO
1566 static void pango_cairo_draw_layout(unifont_drawctx *ctx,
1567                                     gint x, gint y, PangoLayout *layout)
1568 {
1569     cairo_move_to(ctx->u.cairo.cr, x, y);
1570     pango_cairo_show_layout(ctx->u.cairo.cr, layout);
1571 }
1572 #endif
1573
1574 static void pangofont_draw_internal(unifont_drawctx *ctx, unifont *font,
1575                                     int x, int y, const wchar_t *string,
1576                                     int len, int wide, int bold, int cellwidth,
1577                                     int combining)
1578 {
1579     struct pangofont *pfont = (struct pangofont *)font;
1580     PangoLayout *layout;
1581     PangoRectangle rect;
1582     char *utfstring, *utfptr;
1583     int utflen;
1584     int shadowbold = FALSE;
1585     void (*draw_layout)(unifont_drawctx *ctx,
1586                         gint x, gint y, PangoLayout *layout) = NULL;
1587
1588 #ifdef DRAW_TEXT_GDK
1589     if (ctx->type == DRAWTYPE_GDK) {
1590         draw_layout = pango_gdk_draw_layout;
1591     }
1592 #endif
1593 #ifdef DRAW_TEXT_CAIRO
1594     if (ctx->type == DRAWTYPE_CAIRO) {
1595         draw_layout = pango_cairo_draw_layout;
1596     }
1597 #endif
1598
1599     if (wide)
1600         cellwidth *= 2;
1601
1602     y -= pfont->u.ascent;
1603
1604     layout = pango_layout_new(gtk_widget_get_pango_context(pfont->widget));
1605     pango_layout_set_font_description(layout, pfont->desc);
1606     if (bold > pfont->bold) {
1607         if (pfont->shadowalways)
1608             shadowbold = TRUE;
1609         else {
1610             PangoFontDescription *desc2 =
1611                 pango_font_description_copy_static(pfont->desc);
1612             pango_font_description_set_weight(desc2, PANGO_WEIGHT_BOLD);
1613             pango_layout_set_font_description(layout, desc2);
1614         }
1615     }
1616
1617     /*
1618      * Pango always expects UTF-8, so convert the input wide character
1619      * string to UTF-8.
1620      */
1621     utfstring = snewn(len*6+1, char); /* UTF-8 has max 6 bytes/char */
1622     utflen = wc_to_mb(CS_UTF8, 0, string, len,
1623                       utfstring, len*6+1, ".", NULL, NULL);
1624
1625     utfptr = utfstring;
1626     while (utflen > 0) {
1627         int clen, n;
1628         int desired = cellwidth * PANGO_SCALE;
1629
1630         /*
1631          * We want to display every character from this string in
1632          * the centre of its own character cell. In the worst case,
1633          * this requires a separate text-drawing call for each
1634          * character; but in the common case where the font is
1635          * properly fixed-width, we can draw many characters in one
1636          * go which is much faster.
1637          *
1638          * This still isn't really ideal. If you look at what
1639          * happens in the X protocol as a result of all of this, you
1640          * find - naturally enough - that each call to
1641          * gdk_draw_layout() generates a separate set of X RENDER
1642          * operations involving creating a picture, setting a clip
1643          * rectangle, doing some drawing and undoing the whole lot.
1644          * In an ideal world, we should _always_ be able to turn the
1645          * contents of this loop into a single RenderCompositeGlyphs
1646          * operation which internally specifies inter-character
1647          * deltas to get the spacing right, which would give us full
1648          * speed _even_ in the worst case of a non-fixed-width font.
1649          * However, Pango's architecture and documentation are so
1650          * unhelpful that I have no idea how if at all to persuade
1651          * them to do that.
1652          */
1653
1654         if (combining) {
1655             /*
1656              * For a character with combining stuff, we just dump the
1657              * whole lot in one go, and expect it to take up just one
1658              * character cell.
1659              */
1660             clen = utflen;
1661             n = 1;
1662         } else {
1663             /*
1664              * Start by extracting a single UTF-8 character from the
1665              * string.
1666              */
1667             clen = 1;
1668             while (clen < utflen &&
1669                    (unsigned char)utfptr[clen] >= 0x80 &&
1670                    (unsigned char)utfptr[clen] < 0xC0)
1671                 clen++;
1672             n = 1;
1673
1674             if (is_rtl(string[0]) ||
1675                 pangofont_char_width(layout, pfont, string[n-1],
1676                                      utfptr, clen) != desired) {
1677                 /*
1678                  * If this character is a right-to-left one, or has an
1679                  * unusual width, then we must display it on its own.
1680                  */
1681             } else {
1682                 /*
1683                  * Try to amalgamate a contiguous string of characters
1684                  * with the expected sensible width, for the common case
1685                  * in which we're using a monospaced font and everything
1686                  * works as expected.
1687                  */
1688                 while (clen < utflen) {
1689                     int oldclen = clen;
1690                     clen++;                    /* skip UTF-8 introducer byte */
1691                     while (clen < utflen &&
1692                            (unsigned char)utfptr[clen] >= 0x80 &&
1693                            (unsigned char)utfptr[clen] < 0xC0)
1694                         clen++;
1695                     n++;
1696                     if (is_rtl(string[n-1]) ||
1697                         pangofont_char_width(layout, pfont,
1698                                              string[n-1], utfptr + oldclen,
1699                                              clen - oldclen) != desired) {
1700                         clen = oldclen;
1701                         n--;
1702                         break;
1703                     }
1704                 }
1705             }
1706         }
1707
1708         pango_layout_set_text(layout, utfptr, clen);
1709         pango_layout_get_pixel_extents(layout, NULL, &rect);
1710
1711         draw_layout(ctx,
1712                     x + (n*cellwidth - rect.width)/2,
1713                     y + (pfont->u.height - rect.height)/2, layout);
1714         if (shadowbold)
1715             draw_layout(ctx,
1716                         x + (n*cellwidth - rect.width)/2 + pfont->shadowoffset,
1717                         y + (pfont->u.height - rect.height)/2, layout);
1718
1719         utflen -= clen;
1720         utfptr += clen;
1721         string += n;
1722         x += n * cellwidth;
1723     }
1724
1725     sfree(utfstring);
1726
1727     g_object_unref(layout);
1728 }
1729
1730 static void pangofont_draw_text(unifont_drawctx *ctx, unifont *font,
1731                                 int x, int y, const wchar_t *string, int len,
1732                                 int wide, int bold, int cellwidth)
1733 {
1734     pangofont_draw_internal(ctx, font, x, y, string, len, wide, bold,
1735                             cellwidth, FALSE);
1736 }
1737
1738 static void pangofont_draw_combining(unifont_drawctx *ctx, unifont *font,
1739                                      int x, int y, const wchar_t *string,
1740                                      int len, int wide, int bold,
1741                                      int cellwidth)
1742 {
1743     wchar_t *tmpstring = NULL;
1744     if (mk_wcwidth(string[0]) == 0) {
1745         /*
1746          * If we've been told to draw a sequence of _only_ combining
1747          * characters, prefix a space so that they have something to
1748          * combine with.
1749          */
1750         tmpstring = snewn(len+1, wchar_t);
1751         memcpy(tmpstring+1, string, len * sizeof(wchar_t));
1752         tmpstring[0] = L' ';
1753         string = tmpstring;
1754         len++;
1755     }
1756     pangofont_draw_internal(ctx, font, x, y, string, len, wide, bold,
1757                             cellwidth, TRUE);
1758     sfree(tmpstring);
1759 }
1760
1761 /*
1762  * Dummy size value to be used when converting a
1763  * PangoFontDescription of a scalable font to a string for
1764  * internal use.
1765  */
1766 #define PANGO_DUMMY_SIZE 12
1767
1768 static void pangofont_enum_fonts(GtkWidget *widget, fontsel_add_entry callback,
1769                                  void *callback_ctx)
1770 {
1771     PangoContext *ctx;
1772 #ifndef PANGO_PRE_1POINT6
1773     PangoFontMap *map;
1774 #endif
1775     PangoFontFamily **families;
1776     int i, nfamilies;
1777
1778     ctx = gtk_widget_get_pango_context(widget);
1779     if (!ctx)
1780         return;
1781
1782     /*
1783      * Ask Pango for a list of font families, and iterate through
1784      * them.
1785      */
1786 #ifndef PANGO_PRE_1POINT6
1787     map = pango_context_get_font_map(ctx);
1788     if (!map)
1789         return;
1790     pango_font_map_list_families(map, &families, &nfamilies);
1791 #else
1792     pango_context_list_families(ctx, &families, &nfamilies);
1793 #endif
1794     for (i = 0; i < nfamilies; i++) {
1795         PangoFontFamily *family = families[i];
1796         const char *familyname;
1797         int flags;
1798         PangoFontFace **faces;
1799         int j, nfaces;
1800
1801         /*
1802          * Set up our flags for this font family, and get the name
1803          * string.
1804          */
1805         flags = FONTFLAG_CLIENTSIDE;
1806 #ifndef PANGO_PRE_1POINT4
1807         /*
1808          * In very early versions of Pango, we can't tell
1809          * monospaced fonts from non-monospaced.
1810          */
1811         if (!pango_font_family_is_monospace(family))
1812             flags |= FONTFLAG_NONMONOSPACED;
1813 #endif
1814         familyname = pango_font_family_get_name(family);
1815
1816         /*
1817          * Go through the available font faces in this family.
1818          */
1819         pango_font_family_list_faces(family, &faces, &nfaces);
1820         for (j = 0; j < nfaces; j++) {
1821             PangoFontFace *face = faces[j];
1822             PangoFontDescription *desc;
1823             const char *facename;
1824             int *sizes;
1825             int k, nsizes, dummysize;
1826
1827             /*
1828              * Get the face name string.
1829              */
1830             facename = pango_font_face_get_face_name(face);
1831
1832             /*
1833              * Set up a font description with what we've got so
1834              * far. We'll fill in the size field manually and then
1835              * call pango_font_description_to_string() to give the
1836              * full real name of the specific font.
1837              */
1838             desc = pango_font_face_describe(face);
1839
1840             /*
1841              * See if this font has a list of specific sizes.
1842              */
1843 #ifndef PANGO_PRE_1POINT4
1844             pango_font_face_list_sizes(face, &sizes, &nsizes);
1845 #else
1846             /*
1847              * In early versions of Pango, that call wasn't
1848              * supported; we just have to assume everything is
1849              * scalable.
1850              */
1851             sizes = NULL;
1852 #endif
1853             if (!sizes) {
1854                 /*
1855                  * Write a single entry with a dummy size.
1856                  */
1857                 dummysize = PANGO_DUMMY_SIZE * PANGO_SCALE;
1858                 sizes = &dummysize;
1859                 nsizes = 1;
1860             }
1861
1862             /*
1863              * If so, go through them one by one.
1864              */
1865             for (k = 0; k < nsizes; k++) {
1866                 char *fullname;
1867                 char stylekey[128];
1868
1869                 pango_font_description_set_size(desc, sizes[k]);
1870
1871                 fullname = pango_font_description_to_string(desc);
1872
1873                 /*
1874                  * Construct the sorting key for font styles.
1875                  */
1876                 {
1877                     char *p = stylekey;
1878                     int n;
1879
1880                     n = pango_font_description_get_weight(desc);
1881                     /* Weight: normal, then lighter, then bolder */
1882                     if (n <= PANGO_WEIGHT_NORMAL)
1883                         n = PANGO_WEIGHT_NORMAL - n;
1884                     p += sprintf(p, "%4d", n);
1885
1886                     n = pango_font_description_get_style(desc);
1887                     p += sprintf(p, " %2d", n);
1888
1889                     n = pango_font_description_get_stretch(desc);
1890                     /* Stretch: closer to normal sorts earlier */
1891                     n = 2 * abs(PANGO_STRETCH_NORMAL - n) +
1892                         (n < PANGO_STRETCH_NORMAL);
1893                     p += sprintf(p, " %2d", n);
1894
1895                     n = pango_font_description_get_variant(desc);
1896                     p += sprintf(p, " %2d", n);
1897
1898                 }
1899
1900                 /*
1901                  * Got everything. Hand off to the callback.
1902                  * (The charset string is NULL, because only
1903                  * server-side X fonts use it.)
1904                  */
1905                 callback(callback_ctx, fullname, familyname, NULL, facename,
1906                          stylekey,
1907                          (sizes == &dummysize ? 0 : PANGO_PIXELS(sizes[k])),
1908                          flags, &pangofont_vtable);
1909
1910                 g_free(fullname);
1911             }
1912             if (sizes != &dummysize)
1913                 g_free(sizes);
1914
1915             pango_font_description_free(desc);
1916         }
1917         g_free(faces);
1918     }
1919     g_free(families);
1920 }
1921
1922 static char *pangofont_canonify_fontname(GtkWidget *widget, const char *name,
1923                                          int *size, int *flags,
1924                                          int resolve_aliases)
1925 {
1926     /*
1927      * When given a Pango font name to try to make sense of for a
1928      * font selector, we must normalise it to PANGO_DUMMY_SIZE and
1929      * extract its original size (in pixels) into the `size' field.
1930      */
1931     PangoContext *ctx;
1932 #ifndef PANGO_PRE_1POINT6
1933     PangoFontMap *map;
1934 #endif
1935     PangoFontDescription *desc;
1936     PangoFontset *fset;
1937     PangoFontMetrics *metrics;
1938     char *newname, *retname;
1939
1940     desc = pango_font_description_from_string(name);
1941     if (!desc)
1942         return NULL;
1943     ctx = gtk_widget_get_pango_context(widget);
1944     if (!ctx) {
1945         pango_font_description_free(desc);
1946         return NULL;
1947     }
1948     if (!pangofont_check_desc_makes_sense(ctx, desc)) {
1949         pango_font_description_free(desc);
1950         return NULL;
1951     }
1952 #ifndef PANGO_PRE_1POINT6
1953     map = pango_context_get_font_map(ctx);
1954     if (!map) {
1955         pango_font_description_free(desc);
1956         return NULL;
1957     }
1958     fset = pango_font_map_load_fontset(map, ctx, desc,
1959                                        pango_context_get_language(ctx));
1960 #else
1961     fset = pango_context_load_fontset(ctx, desc,
1962                                       pango_context_get_language(ctx));
1963 #endif
1964     if (!fset) {
1965         pango_font_description_free(desc);
1966         return NULL;
1967     }
1968     metrics = pango_fontset_get_metrics(fset);
1969     if (!metrics ||
1970         pango_font_metrics_get_approximate_digit_width(metrics) == 0) {
1971         pango_font_description_free(desc);
1972         g_object_unref(fset);
1973         return NULL;
1974     }
1975
1976     *size = PANGO_PIXELS(pango_font_description_get_size(desc));
1977     *flags = FONTFLAG_CLIENTSIDE;
1978     pango_font_description_set_size(desc, PANGO_DUMMY_SIZE * PANGO_SCALE);
1979     newname = pango_font_description_to_string(desc);
1980     retname = dupstr(newname);
1981     g_free(newname);
1982
1983     pango_font_metrics_unref(metrics);
1984     pango_font_description_free(desc);
1985     g_object_unref(fset);
1986
1987     return retname;
1988 }
1989
1990 static char *pangofont_scale_fontname(GtkWidget *widget, const char *name,
1991                                       int size)
1992 {
1993     PangoFontDescription *desc;
1994     char *newname, *retname;
1995
1996     desc = pango_font_description_from_string(name);
1997     if (!desc)
1998         return NULL;
1999     pango_font_description_set_size(desc, size * PANGO_SCALE);
2000     newname = pango_font_description_to_string(desc);
2001     retname = dupstr(newname);
2002     g_free(newname);
2003     pango_font_description_free(desc);
2004
2005     return retname;
2006 }
2007
2008 static char *pangofont_size_increment(unifont *font, int increment)
2009 {
2010     struct pangofont *pfont = (struct pangofont *)font;
2011     PangoFontDescription *desc;
2012     int size;
2013     char *newname, *retname;
2014
2015     desc = pango_font_description_copy_static(pfont->desc);
2016
2017     size = pango_font_description_get_size(desc);
2018     size += PANGO_SCALE * increment;
2019
2020     if (size <= 0) {
2021         retname = NULL;
2022     } else {
2023         pango_font_description_set_size(desc, size);
2024         newname = pango_font_description_to_string(desc);
2025         retname = dupcat(pfont->u.vt->prefix, ":",
2026                          newname, (const char *)NULL);
2027         g_free(newname);
2028     }
2029
2030     pango_font_description_free(desc);
2031     return retname;
2032 }
2033
2034 #endif /* GTK_CHECK_VERSION(2,0,0) */
2035
2036 /* ----------------------------------------------------------------------
2037  * Outermost functions which do the vtable dispatch.
2038  */
2039
2040 /*
2041  * Complete list of font-type subclasses. Listed in preference
2042  * order for unifont_create(). (That is, in the extremely unlikely
2043  * event that the same font name is valid as both a Pango and an
2044  * X11 font, it will be interpreted as the former in the absence
2045  * of an explicit type-disambiguating prefix.)
2046  *
2047  * The 'multifont' subclass is omitted here, as discussed above.
2048  */
2049 static const struct unifont_vtable *unifont_types[] = {
2050 #if GTK_CHECK_VERSION(2,0,0)
2051     &pangofont_vtable,
2052 #endif
2053 #ifndef NOT_X_WINDOWS
2054     &x11font_vtable,
2055 #endif
2056 };
2057
2058 /*
2059  * Function which takes a font name and processes the optional
2060  * scheme prefix. Returns the tail of the font name suitable for
2061  * passing to individual font scheme functions, and also provides
2062  * a subrange of the unifont_types[] array above.
2063  *
2064  * The return values `start' and `end' denote a half-open interval
2065  * in unifont_types[]; that is, the correct way to iterate over
2066  * them is
2067  *
2068  *   for (i = start; i < end; i++) {...}
2069  */
2070 static const char *unifont_do_prefix(const char *name, int *start, int *end)
2071 {
2072     int colonpos = strcspn(name, ":");
2073     int i;
2074
2075     if (name[colonpos]) {
2076         /*
2077          * There's a colon prefix on the font name. Use it to work
2078          * out which subclass to use.
2079          */
2080         for (i = 0; i < lenof(unifont_types); i++) {
2081             if (strlen(unifont_types[i]->prefix) == colonpos &&
2082                 !strncmp(unifont_types[i]->prefix, name, colonpos)) {
2083                 *start = i;
2084                 *end = i+1;
2085                 return name + colonpos + 1;
2086             }
2087         }
2088         /*
2089          * None matched, so return an empty scheme list to prevent
2090          * any scheme from being called at all.
2091          */
2092         *start = *end = 0;
2093         return name + colonpos + 1;
2094     } else {
2095         /*
2096          * No colon prefix, so just use all the subclasses.
2097          */
2098         *start = 0;
2099         *end = lenof(unifont_types);
2100         return name;
2101     }
2102 }
2103
2104 unifont *unifont_create(GtkWidget *widget, const char *name, int wide,
2105                         int bold, int shadowoffset, int shadowalways)
2106 {
2107     int i, start, end;
2108
2109     name = unifont_do_prefix(name, &start, &end);
2110
2111     for (i = start; i < end; i++) {
2112         unifont *ret = unifont_types[i]->create(widget, name, wide, bold,
2113                                                 shadowoffset, shadowalways);
2114         if (ret)
2115             return ret;
2116     }
2117     return NULL;                       /* font not found in any scheme */
2118 }
2119
2120 void unifont_destroy(unifont *font)
2121 {
2122     font->vt->destroy(font);
2123 }
2124
2125 void unifont_draw_text(unifont_drawctx *ctx, unifont *font,
2126                        int x, int y, const wchar_t *string, int len,
2127                        int wide, int bold, int cellwidth)
2128 {
2129     font->vt->draw_text(ctx, font, x, y, string, len, wide, bold, cellwidth);
2130 }
2131
2132 void unifont_draw_combining(unifont_drawctx *ctx, unifont *font,
2133                             int x, int y, const wchar_t *string, int len,
2134                             int wide, int bold, int cellwidth)
2135 {
2136     font->vt->draw_combining(ctx, font, x, y, string, len, wide, bold,
2137                              cellwidth);
2138 }
2139
2140 char *unifont_size_increment(unifont *font, int increment)
2141 {
2142     return font->vt->size_increment(font, increment);
2143 }
2144
2145 /* ----------------------------------------------------------------------
2146  * Multiple-font wrapper. This is a type of unifont which encapsulates
2147  * up to two other unifonts, permitting missing glyphs in the main
2148  * font to be filled in by a fallback font.
2149  *
2150  * This is a type of unifont just like the previous two, but it has a
2151  * separate constructor which is manually called by the client, so it
2152  * doesn't appear in the list of available font types enumerated by
2153  * unifont_create. This means it's not used by unifontsel either, so
2154  * it doesn't need to support any methods except draw_text and
2155  * destroy.
2156  */
2157
2158 static void multifont_draw_text(unifont_drawctx *ctx, unifont *font,
2159                                 int x, int y, const wchar_t *string, int len,
2160                                 int wide, int bold, int cellwidth);
2161 static void multifont_draw_combining(unifont_drawctx *ctx, unifont *font,
2162                                      int x, int y, const wchar_t *string,
2163                                      int len, int wide, int bold,
2164                                      int cellwidth);
2165 static void multifont_destroy(unifont *font);
2166 static char *multifont_size_increment(unifont *font, int increment);
2167
2168 struct multifont {
2169     struct unifont u;
2170     unifont *main;
2171     unifont *fallback;
2172 };
2173
2174 static const struct unifont_vtable multifont_vtable = {
2175     NULL,                             /* creation is done specially */
2176     NULL,
2177     multifont_destroy,
2178     NULL,
2179     multifont_draw_text,
2180     multifont_draw_combining,
2181     NULL,
2182     NULL,
2183     NULL,
2184     multifont_size_increment,
2185     "client",
2186 };
2187
2188 unifont *multifont_create(GtkWidget *widget, const char *name,
2189                           int wide, int bold,
2190                           int shadowoffset, int shadowalways)
2191 {
2192     int i;
2193     unifont *font, *fallback;
2194     struct multifont *mfont;
2195
2196     font = unifont_create(widget, name, wide, bold,
2197                           shadowoffset, shadowalways);
2198     if (!font)
2199         return NULL;
2200
2201     fallback = NULL;
2202     if (font->want_fallback) {
2203         for (i = 0; i < lenof(unifont_types); i++) {
2204             if (unifont_types[i]->create_fallback) {
2205                 fallback = unifont_types[i]->create_fallback
2206                     (widget, font->height, wide, bold,
2207                      shadowoffset, shadowalways);
2208                 if (fallback)
2209                     break;
2210             }
2211         }
2212     }
2213
2214     /*
2215      * Construct our multifont. Public members are all copied from the
2216      * primary font we're wrapping.
2217      */
2218     mfont = snew(struct multifont);
2219     mfont->u.vt = &multifont_vtable;
2220     mfont->u.width = font->width;
2221     mfont->u.ascent = font->ascent;
2222     mfont->u.descent = font->descent;
2223     mfont->u.height = font->height;
2224     mfont->u.public_charset = font->public_charset;
2225     mfont->u.want_fallback = FALSE; /* shouldn't be needed, but just in case */
2226     mfont->u.preferred_drawtype = font->preferred_drawtype;
2227     mfont->main = font;
2228     mfont->fallback = fallback;
2229
2230     return (unifont *)mfont;
2231 }
2232
2233 static void multifont_destroy(unifont *font)
2234 {
2235     struct multifont *mfont = (struct multifont *)font;
2236     unifont_destroy(mfont->main);
2237     if (mfont->fallback)
2238         unifont_destroy(mfont->fallback);
2239     sfree(font);
2240 }
2241
2242 typedef void (*unifont_draw_func_t)(unifont_drawctx *ctx, unifont *font,
2243                                     int x, int y, const wchar_t *string,
2244                                     int len, int wide, int bold,
2245                                     int cellwidth);
2246
2247 static void multifont_draw_main(unifont_drawctx *ctx, unifont *font, int x,
2248                                 int y, const wchar_t *string, int len,
2249                                 int wide, int bold, int cellwidth,
2250                                 int cellinc, unifont_draw_func_t draw)
2251 {
2252     struct multifont *mfont = (struct multifont *)font;
2253     unifont *f;
2254     int ok, i;
2255
2256     while (len > 0) {
2257         /*
2258          * Find a maximal sequence of characters which are, or are
2259          * not, supported by our main font.
2260          */
2261         ok = mfont->main->vt->has_glyph(mfont->main, string[0]);
2262         for (i = 1;
2263              i < len &&
2264              !mfont->main->vt->has_glyph(mfont->main, string[i]) == !ok;
2265              i++);
2266
2267         /*
2268          * Now display it.
2269          */
2270         f = ok ? mfont->main : mfont->fallback;
2271         if (f)
2272             draw(ctx, f, x, y, string, i, wide, bold, cellwidth);
2273         string += i;
2274         len -= i;
2275         x += i * cellinc;
2276     }
2277 }
2278
2279 static void multifont_draw_text(unifont_drawctx *ctx, unifont *font, int x,
2280                                 int y, const wchar_t *string, int len,
2281                                 int wide, int bold, int cellwidth)
2282 {
2283     multifont_draw_main(ctx, font, x, y, string, len, wide, bold,
2284                         cellwidth, cellwidth, unifont_draw_text);
2285 }
2286
2287 static void multifont_draw_combining(unifont_drawctx *ctx, unifont *font,
2288                                      int x, int y, const wchar_t *string,
2289                                      int len, int wide, int bold,
2290                                      int cellwidth)
2291 {
2292     multifont_draw_main(ctx, font, x, y, string, len, wide, bold,
2293                         cellwidth, 0, unifont_draw_combining);
2294 }
2295
2296 static char *multifont_size_increment(unifont *font, int increment)
2297 {
2298     struct multifont *mfont = (struct multifont *)font;
2299     return unifont_size_increment(mfont->main, increment);
2300 }
2301
2302 #if GTK_CHECK_VERSION(2,0,0)
2303
2304 /* ----------------------------------------------------------------------
2305  * Implementation of a unified font selector. Used on GTK 2 only;
2306  * for GTK 1 we still use the standard font selector.
2307  */
2308
2309 typedef struct fontinfo fontinfo;
2310
2311 typedef struct unifontsel_internal {
2312     /* This must be the structure's first element, for cross-casting */
2313     unifontsel u;
2314     GtkListStore *family_model, *style_model, *size_model;
2315     GtkWidget *family_list, *style_list, *size_entry, *size_list;
2316     GtkWidget *filter_buttons[4];
2317     int n_filter_buttons;
2318     GtkWidget *preview_area;
2319 #ifndef NO_BACKING_PIXMAPS
2320     GdkPixmap *preview_pixmap;
2321 #endif
2322     int preview_width, preview_height;
2323     GdkColor preview_fg, preview_bg;
2324     int filter_flags;
2325     tree234 *fonts_by_realname, *fonts_by_selorder;
2326     fontinfo *selected;
2327     int selsize, intendedsize;
2328     int inhibit_response;  /* inhibit callbacks when we change GUI controls */
2329 } unifontsel_internal;
2330
2331 /*
2332  * The structure held in the tree234s. All the string members are
2333  * part of the same allocated area, so don't need freeing
2334  * separately.
2335  */
2336 struct fontinfo {
2337     char *realname;
2338     char *family, *charset, *style, *stylekey;
2339     int size, flags;
2340     /*
2341      * Fallback sorting key, to permit multiple identical entries
2342      * to exist in the selorder tree.
2343      */
2344     int index;
2345     /*
2346      * Indices mapping fontinfo structures to indices in the list
2347      * boxes. sizeindex is irrelevant if the font is scalable
2348      * (size==0).
2349      */
2350     int familyindex, styleindex, sizeindex;
2351     /*
2352      * The class of font.
2353      */
2354     const struct unifont_vtable *fontclass;
2355 };
2356
2357 struct fontinfo_realname_find {
2358     const char *realname;
2359     int flags;
2360 };
2361
2362 static int strnullcasecmp(const char *a, const char *b)
2363 {
2364     int i;
2365
2366     /*
2367      * If exactly one of the inputs is NULL, it compares before
2368      * the other one.
2369      */
2370     if ((i = (!b) - (!a)) != 0)
2371         return i;
2372
2373     /*
2374      * NULL compares equal.
2375      */
2376     if (!a)
2377         return 0;
2378
2379     /*
2380      * Otherwise, ordinary strcasecmp.
2381      */
2382     return g_ascii_strcasecmp(a, b);
2383 }
2384
2385 static int fontinfo_realname_compare(void *av, void *bv)
2386 {
2387     fontinfo *a = (fontinfo *)av;
2388     fontinfo *b = (fontinfo *)bv;
2389     int i;
2390
2391     if ((i = strnullcasecmp(a->realname, b->realname)) != 0)
2392         return i;
2393     if ((a->flags & FONTFLAG_SORT_MASK) != (b->flags & FONTFLAG_SORT_MASK))
2394         return ((a->flags & FONTFLAG_SORT_MASK) <
2395                 (b->flags & FONTFLAG_SORT_MASK) ? -1 : +1);
2396     return 0;
2397 }
2398
2399 static int fontinfo_realname_find(void *av, void *bv)
2400 {
2401     struct fontinfo_realname_find *a = (struct fontinfo_realname_find *)av;
2402     fontinfo *b = (fontinfo *)bv;
2403     int i;
2404
2405     if ((i = strnullcasecmp(a->realname, b->realname)) != 0)
2406         return i;
2407     if ((a->flags & FONTFLAG_SORT_MASK) != (b->flags & FONTFLAG_SORT_MASK))
2408         return ((a->flags & FONTFLAG_SORT_MASK) <
2409                 (b->flags & FONTFLAG_SORT_MASK) ? -1 : +1);
2410     return 0;
2411 }
2412
2413 static int fontinfo_selorder_compare(void *av, void *bv)
2414 {
2415     fontinfo *a = (fontinfo *)av;
2416     fontinfo *b = (fontinfo *)bv;
2417     int i;
2418     if ((i = strnullcasecmp(a->family, b->family)) != 0)
2419         return i;
2420     /*
2421      * Font class comes immediately after family, so that fonts
2422      * from different classes with the same family
2423      */
2424     if ((a->flags & FONTFLAG_SORT_MASK) != (b->flags & FONTFLAG_SORT_MASK))
2425         return ((a->flags & FONTFLAG_SORT_MASK) <
2426                 (b->flags & FONTFLAG_SORT_MASK) ? -1 : +1);
2427     if ((i = strnullcasecmp(a->charset, b->charset)) != 0)
2428         return i;
2429     if ((i = strnullcasecmp(a->stylekey, b->stylekey)) != 0)
2430         return i;
2431     if ((i = strnullcasecmp(a->style, b->style)) != 0)
2432         return i;
2433     if (a->size != b->size)
2434         return (a->size < b->size ? -1 : +1);
2435     if (a->index != b->index)
2436         return (a->index < b->index ? -1 : +1);
2437     return 0;
2438 }
2439
2440 static void unifontsel_draw_preview_text(unifontsel_internal *fs);
2441
2442 static void unifontsel_deselect(unifontsel_internal *fs)
2443 {
2444     fs->selected = NULL;
2445     gtk_list_store_clear(fs->style_model);
2446     gtk_list_store_clear(fs->size_model);
2447     gtk_widget_set_sensitive(fs->u.ok_button, FALSE);
2448     gtk_widget_set_sensitive(fs->size_entry, FALSE);
2449     unifontsel_draw_preview_text(fs);
2450 }
2451
2452 static void unifontsel_setup_familylist(unifontsel_internal *fs)
2453 {
2454     GtkTreeIter iter;
2455     int i, listindex, minpos = -1, maxpos = -1;
2456     char *currfamily = NULL;
2457     int currflags = -1;
2458     fontinfo *info;
2459
2460     fs->inhibit_response = TRUE;
2461
2462     gtk_list_store_clear(fs->family_model);
2463     listindex = 0;
2464
2465     /*
2466      * Search through the font tree for anything matching our
2467      * current filter criteria. When we find one, add its font
2468      * name to the list box.
2469      */
2470     for (i = 0 ;; i++) {
2471         info = (fontinfo *)index234(fs->fonts_by_selorder, i);
2472         /*
2473          * info may be NULL if we've just run off the end of the
2474          * tree. We must still do a processing pass in that
2475          * situation, in case we had an unfinished font record in
2476          * progress.
2477          */
2478         if (info && (info->flags &~ fs->filter_flags)) {
2479             info->familyindex = -1;
2480             continue;                  /* we're filtering out this font */
2481         }
2482         if (!info || strnullcasecmp(currfamily, info->family) ||
2483             currflags != (info->flags & FONTFLAG_SORT_MASK)) {
2484             /*
2485              * We've either finished a family, or started a new
2486              * one, or both.
2487              */
2488             if (currfamily) {
2489                 gtk_list_store_append(fs->family_model, &iter);
2490                 gtk_list_store_set(fs->family_model, &iter,
2491                                    0, currfamily, 1, minpos, 2, maxpos+1, -1);
2492                 listindex++;
2493             }
2494             if (info) {
2495                 minpos = i;
2496                 currfamily = info->family;
2497                 currflags = info->flags & FONTFLAG_SORT_MASK;
2498             }
2499         }
2500         if (!info)
2501             break;                     /* now we're done */
2502         info->familyindex = listindex;
2503         maxpos = i;
2504     }
2505
2506     /*
2507      * If we've just filtered out the previously selected font,
2508      * deselect it thoroughly.
2509      */
2510     if (fs->selected && fs->selected->familyindex < 0)
2511         unifontsel_deselect(fs);
2512
2513     fs->inhibit_response = FALSE;
2514 }
2515
2516 static void unifontsel_setup_stylelist(unifontsel_internal *fs,
2517                                        int start, int end)
2518 {
2519     GtkTreeIter iter;
2520     int i, listindex, minpos = -1, maxpos = -1, started = FALSE;
2521     char *currcs = NULL, *currstyle = NULL;
2522     fontinfo *info;
2523
2524     gtk_list_store_clear(fs->style_model);
2525     listindex = 0;
2526     started = FALSE;
2527
2528     /*
2529      * Search through the font tree for anything matching our
2530      * current filter criteria. When we find one, add its charset
2531      * and/or style name to the list box.
2532      */
2533     for (i = start; i <= end; i++) {
2534         if (i == end)
2535             info = NULL;
2536         else
2537             info = (fontinfo *)index234(fs->fonts_by_selorder, i);
2538         /*
2539          * info may be NULL if we've just run off the end of the
2540          * relevant data. We must still do a processing pass in
2541          * that situation, in case we had an unfinished font
2542          * record in progress.
2543          */
2544         if (info && (info->flags &~ fs->filter_flags)) {
2545             info->styleindex = -1;
2546             continue;                  /* we're filtering out this font */
2547         }
2548         if (!info || !started || strnullcasecmp(currcs, info->charset) ||
2549              strnullcasecmp(currstyle, info->style)) {
2550             /*
2551              * We've either finished a style/charset, or started a
2552              * new one, or both.
2553              */
2554             started = TRUE;
2555             if (currstyle) {
2556                 gtk_list_store_append(fs->style_model, &iter);
2557                 gtk_list_store_set(fs->style_model, &iter,
2558                                    0, currstyle, 1, minpos, 2, maxpos+1,
2559                                    3, TRUE, 4, PANGO_WEIGHT_NORMAL, -1);
2560                 listindex++;
2561             }
2562             if (info) {
2563                 minpos = i;
2564                 if (info->charset && strnullcasecmp(currcs, info->charset)) {
2565                     gtk_list_store_append(fs->style_model, &iter);
2566                     gtk_list_store_set(fs->style_model, &iter,
2567                                        0, info->charset, 1, -1, 2, -1,
2568                                        3, FALSE, 4, PANGO_WEIGHT_BOLD, -1);
2569                     listindex++;
2570                 }
2571                 currcs = info->charset;
2572                 currstyle = info->style;
2573             }
2574         }
2575         if (!info)
2576             break;                     /* now we're done */
2577         info->styleindex = listindex;
2578         maxpos = i;
2579     }
2580 }
2581
2582 static const int unifontsel_default_sizes[] = { 10, 12, 14, 16, 20, 24, 32 };
2583
2584 static void unifontsel_setup_sizelist(unifontsel_internal *fs,
2585                                       int start, int end)
2586 {
2587     GtkTreeIter iter;
2588     int i, listindex;
2589     char sizetext[40];
2590     fontinfo *info;
2591
2592     gtk_list_store_clear(fs->size_model);
2593     listindex = 0;
2594
2595     /*
2596      * Search through the font tree for anything matching our
2597      * current filter criteria. When we find one, add its font
2598      * name to the list box.
2599      */
2600     for (i = start; i < end; i++) {
2601         info = (fontinfo *)index234(fs->fonts_by_selorder, i);
2602         if (info->flags &~ fs->filter_flags) {
2603             info->sizeindex = -1;
2604             continue;                  /* we're filtering out this font */
2605         }
2606         if (info->size) {
2607             sprintf(sizetext, "%d", info->size);
2608             info->sizeindex = listindex;
2609             gtk_list_store_append(fs->size_model, &iter);
2610             gtk_list_store_set(fs->size_model, &iter,
2611                                0, sizetext, 1, i, 2, info->size, -1);
2612             listindex++;
2613         } else {
2614             int j;
2615
2616             assert(i == start);
2617             assert(i+1 == end);
2618
2619             for (j = 0; j < lenof(unifontsel_default_sizes); j++) {
2620                 sprintf(sizetext, "%d", unifontsel_default_sizes[j]);
2621                 gtk_list_store_append(fs->size_model, &iter);
2622                 gtk_list_store_set(fs->size_model, &iter, 0, sizetext, 1, i,
2623                                    2, unifontsel_default_sizes[j], -1);
2624                 listindex++;
2625             }
2626         }
2627     }
2628 }
2629
2630 static void unifontsel_set_filter_buttons(unifontsel_internal *fs)
2631 {
2632     int i;
2633
2634     for (i = 0; i < fs->n_filter_buttons; i++) {
2635         int flagbit = GPOINTER_TO_INT(g_object_get_data
2636                                       (G_OBJECT(fs->filter_buttons[i]),
2637                                        "user-data"));
2638         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fs->filter_buttons[i]),
2639                                      !!(fs->filter_flags & flagbit));
2640     }
2641 }
2642
2643 static void unifontsel_draw_preview_text_inner(unifont_drawctx *dctx,
2644                                                unifontsel_internal *fs)
2645 {
2646     unifont *font;
2647     char *sizename = NULL;
2648     fontinfo *info = fs->selected;
2649
2650     if (info) {
2651         sizename = info->fontclass->scale_fontname
2652             (GTK_WIDGET(fs->u.window), info->realname, fs->selsize);
2653         font = info->fontclass->create(GTK_WIDGET(fs->u.window),
2654                                        sizename ? sizename : info->realname,
2655                                        FALSE, FALSE, 0, 0);
2656     } else
2657         font = NULL;
2658
2659 #ifdef DRAW_TEXT_GDK
2660     if (dctx->type == DRAWTYPE_GDK) {
2661         gdk_gc_set_foreground(dctx->u.gdk.gc, &fs->preview_bg);
2662         gdk_draw_rectangle(dctx->u.gdk.target, dctx->u.gdk.gc, 1, 0, 0,
2663                            fs->preview_width, fs->preview_height);
2664         gdk_gc_set_foreground(dctx->u.gdk.gc, &fs->preview_fg);
2665     }
2666 #endif
2667 #ifdef DRAW_TEXT_CAIRO
2668     if (dctx->type == DRAWTYPE_CAIRO) {
2669         cairo_set_source_rgb(dctx->u.cairo.cr,
2670                              fs->preview_bg.red / 65535.0,
2671                              fs->preview_bg.green / 65535.0,
2672                              fs->preview_bg.blue / 65535.0);
2673         cairo_paint(dctx->u.cairo.cr);
2674         cairo_set_source_rgb(dctx->u.cairo.cr,
2675                              fs->preview_fg.red / 65535.0,
2676                              fs->preview_fg.green / 65535.0,
2677                              fs->preview_fg.blue / 65535.0);
2678     }
2679 #endif
2680
2681     if (font) {
2682         /*
2683          * The pangram used here is rather carefully
2684          * constructed: it contains a sequence of very narrow
2685          * letters (`jil') and a pair of adjacent very wide
2686          * letters (`wm').
2687          *
2688          * If the user selects a proportional font, it will be
2689          * coerced into fixed-width character cells when used
2690          * in the actual terminal window. We therefore display
2691          * it the same way in the preview pane, so as to show
2692          * it the way it will actually be displayed - and we
2693          * deliberately pick a pangram which will show the
2694          * resulting miskerning at its worst.
2695          *
2696          * We aren't trying to sell people these fonts; we're
2697          * trying to let them make an informed choice. Better
2698          * that they find out the problems with using
2699          * proportional fonts in terminal windows here than
2700          * that they go to the effort of selecting their font
2701          * and _then_ realise it was a mistake.
2702          */
2703         info->fontclass->draw_text(dctx, font,
2704                                    0, font->ascent,
2705                                    L"bankrupt jilted showmen quiz convex fogey",
2706                                    41, FALSE, FALSE, font->width);
2707         info->fontclass->draw_text(dctx, font,
2708                                    0, font->ascent + font->height,
2709                                    L"BANKRUPT JILTED SHOWMEN QUIZ CONVEX FOGEY",
2710                                    41, FALSE, FALSE, font->width);
2711         /*
2712          * The ordering of punctuation here is also selected
2713          * with some specific aims in mind. I put ` and '
2714          * together because some software (and people) still
2715          * use them as matched quotes no matter what Unicode
2716          * might say on the matter, so people can quickly
2717          * check whether they look silly in a candidate font.
2718          * The sequence #_@ is there to let people judge the
2719          * suitability of the underscore as an effectively
2720          * alphabetic character (since that's how it's often
2721          * used in practice, at least by programmers).
2722          */
2723         info->fontclass->draw_text(dctx, font,
2724                                    0, font->ascent + font->height * 2,
2725                                    L"0123456789!?,.:;<>()[]{}\\/`'\"+*-=~#_@|%&^$",
2726                                    42, FALSE, FALSE, font->width);
2727
2728         info->fontclass->destroy(font);
2729     }
2730
2731     sfree(sizename);
2732 }
2733
2734 static void unifontsel_draw_preview_text(unifontsel_internal *fs)
2735 {
2736     unifont_drawctx dctx;
2737     GdkWindow *target;
2738
2739 #ifndef NO_BACKING_PIXMAPS
2740     target = fs->preview_pixmap;
2741 #else
2742     target = gtk_widget_get_window(fs->preview_area);
2743 #endif
2744     if (!target) /* we may be called when we haven't created everything yet */
2745         return;
2746
2747     dctx.type = DRAWTYPE_DEFAULT;
2748 #ifdef DRAW_TEXT_GDK
2749     if (dctx.type == DRAWTYPE_GDK) {
2750         dctx.u.gdk.target = target;
2751         dctx.u.gdk.gc = gdk_gc_new(target);
2752     }
2753 #endif
2754 #ifdef DRAW_TEXT_CAIRO
2755     if (dctx.type == DRAWTYPE_CAIRO) {
2756         dctx.u.cairo.widget = GTK_WIDGET(fs->preview_area);
2757         dctx.u.cairo.cr = gdk_cairo_create(target);
2758     }
2759 #endif
2760
2761     unifontsel_draw_preview_text_inner(&dctx, fs);
2762
2763 #ifdef DRAW_TEXT_GDK
2764     if (dctx.type == DRAWTYPE_GDK) {
2765         gdk_gc_unref(dctx.u.gdk.gc);
2766     }
2767 #endif
2768 #ifdef DRAW_TEXT_CAIRO
2769     if (dctx.type == DRAWTYPE_CAIRO) {
2770         cairo_destroy(dctx.u.cairo.cr);
2771     }
2772 #endif
2773
2774     gdk_window_invalidate_rect(gtk_widget_get_window(fs->preview_area),
2775                                NULL, FALSE);
2776 }
2777
2778 static void unifontsel_select_font(unifontsel_internal *fs,
2779                                    fontinfo *info, int size, int leftlist,
2780                                    int size_is_explicit)
2781 {
2782     int index;
2783     int minval, maxval;
2784     gboolean success;
2785     GtkTreePath *treepath;
2786     GtkTreeIter iter;
2787
2788     fs->inhibit_response = TRUE;
2789
2790     fs->selected = info;
2791     fs->selsize = size;
2792     if (size_is_explicit)
2793         fs->intendedsize = size;
2794
2795     gtk_widget_set_sensitive(fs->u.ok_button, TRUE);
2796
2797     /*
2798      * Find the index of this fontinfo in the selorder list.
2799      */
2800     index = -1;
2801     findpos234(fs->fonts_by_selorder, info, NULL, &index);
2802     assert(index >= 0);
2803
2804     /*
2805      * Adjust the font selector flags and redo the font family
2806      * list box, if necessary.
2807      */
2808     if (leftlist <= 0 &&
2809         (fs->filter_flags | info->flags) != fs->filter_flags) {
2810         fs->filter_flags |= info->flags;
2811         unifontsel_set_filter_buttons(fs);
2812         unifontsel_setup_familylist(fs);
2813     }
2814
2815     /*
2816      * Find the appropriate family name and select it in the list.
2817      */
2818     assert(info->familyindex >= 0);
2819     treepath = gtk_tree_path_new_from_indices(info->familyindex, -1);
2820     gtk_tree_selection_select_path
2821         (gtk_tree_view_get_selection(GTK_TREE_VIEW(fs->family_list)),
2822          treepath);
2823     gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(fs->family_list),
2824                                  treepath, NULL, FALSE, 0.0, 0.0);
2825     success = gtk_tree_model_get_iter(GTK_TREE_MODEL(fs->family_model),
2826                                       &iter, treepath);
2827     assert(success);
2828     gtk_tree_path_free(treepath);
2829
2830     /*
2831      * Now set up the font style list.
2832      */
2833     gtk_tree_model_get(GTK_TREE_MODEL(fs->family_model), &iter,
2834                        1, &minval, 2, &maxval, -1);
2835     if (leftlist <= 1)
2836         unifontsel_setup_stylelist(fs, minval, maxval);
2837
2838     /*
2839      * Find the appropriate style name and select it in the list.
2840      */
2841     if (info->style) {
2842         assert(info->styleindex >= 0);
2843         treepath = gtk_tree_path_new_from_indices(info->styleindex, -1);
2844         gtk_tree_selection_select_path
2845             (gtk_tree_view_get_selection(GTK_TREE_VIEW(fs->style_list)),
2846              treepath);
2847         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(fs->style_list),
2848                                      treepath, NULL, FALSE, 0.0, 0.0);
2849         gtk_tree_model_get_iter(GTK_TREE_MODEL(fs->style_model),
2850                                 &iter, treepath);
2851         gtk_tree_path_free(treepath);
2852
2853         /*
2854          * And set up the size list.
2855          */
2856         gtk_tree_model_get(GTK_TREE_MODEL(fs->style_model), &iter,
2857                            1, &minval, 2, &maxval, -1);
2858         if (leftlist <= 2)
2859             unifontsel_setup_sizelist(fs, minval, maxval);
2860
2861         /*
2862          * Find the appropriate size, and select it in the list.
2863          */
2864         if (info->size) {
2865             assert(info->sizeindex >= 0);
2866             treepath = gtk_tree_path_new_from_indices(info->sizeindex, -1);
2867             gtk_tree_selection_select_path
2868                 (gtk_tree_view_get_selection(GTK_TREE_VIEW(fs->size_list)),
2869                  treepath);
2870             gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(fs->size_list),
2871                                          treepath, NULL, FALSE, 0.0, 0.0);
2872             gtk_tree_path_free(treepath);
2873             size = info->size;
2874         } else {
2875             int j;
2876             for (j = 0; j < lenof(unifontsel_default_sizes); j++)
2877                 if (unifontsel_default_sizes[j] == size) {
2878                     treepath = gtk_tree_path_new_from_indices(j, -1);
2879                     gtk_tree_view_set_cursor(GTK_TREE_VIEW(fs->size_list),
2880                                              treepath, NULL, FALSE);
2881                     gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(fs->size_list),
2882                                                  treepath, NULL, FALSE, 0.0,
2883                                                  0.0);
2884                     gtk_tree_path_free(treepath);
2885                 }
2886         }
2887
2888         /*
2889          * And set up the font size text entry box.
2890          */
2891         {
2892             char sizetext[40];
2893             sprintf(sizetext, "%d", size);
2894             gtk_entry_set_text(GTK_ENTRY(fs->size_entry), sizetext);
2895         }
2896     } else {
2897         if (leftlist <= 2)
2898             unifontsel_setup_sizelist(fs, 0, 0);
2899         gtk_entry_set_text(GTK_ENTRY(fs->size_entry), "");
2900     }
2901
2902     /*
2903      * Grey out the font size edit box if we're not using a
2904      * scalable font.
2905      */
2906     gtk_editable_set_editable(GTK_EDITABLE(fs->size_entry),
2907                               fs->selected->size == 0);
2908     gtk_widget_set_sensitive(fs->size_entry, fs->selected->size == 0);
2909
2910     unifontsel_draw_preview_text(fs);
2911
2912     fs->inhibit_response = FALSE;
2913 }
2914
2915 static void unifontsel_button_toggled(GtkToggleButton *tb, gpointer data)
2916 {
2917     unifontsel_internal *fs = (unifontsel_internal *)data;
2918     int newstate = gtk_toggle_button_get_active(tb);
2919     int newflags;
2920     int flagbit = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tb),
2921                                                     "user-data"));
2922
2923     if (newstate)
2924         newflags = fs->filter_flags | flagbit;
2925     else
2926         newflags = fs->filter_flags & ~flagbit;
2927
2928     if (fs->filter_flags != newflags) {
2929         fs->filter_flags = newflags;
2930         unifontsel_setup_familylist(fs);
2931     }
2932 }
2933
2934 static void unifontsel_add_entry(void *ctx, const char *realfontname,
2935                                  const char *family, const char *charset,
2936                                  const char *style, const char *stylekey,
2937                                  int size, int flags,
2938                                  const struct unifont_vtable *fontclass)
2939 {
2940     unifontsel_internal *fs = (unifontsel_internal *)ctx;
2941     fontinfo *info;
2942     int totalsize;
2943     char *p;
2944
2945     totalsize = sizeof(fontinfo) + strlen(realfontname) +
2946         (family ? strlen(family) : 0) + (charset ? strlen(charset) : 0) +
2947         (style ? strlen(style) : 0) + (stylekey ? strlen(stylekey) : 0) + 10;
2948     info = (fontinfo *)smalloc(totalsize);
2949     info->fontclass = fontclass;
2950     p = (char *)info + sizeof(fontinfo);
2951     info->realname = p;
2952     strcpy(p, realfontname);
2953     p += 1+strlen(p);
2954     if (family) {
2955         info->family = p;
2956         strcpy(p, family);
2957         p += 1+strlen(p);
2958     } else
2959         info->family = NULL;
2960     if (charset) {
2961         info->charset = p;
2962         strcpy(p, charset);
2963         p += 1+strlen(p);
2964     } else
2965         info->charset = NULL;
2966     if (style) {
2967         info->style = p;
2968         strcpy(p, style);
2969         p += 1+strlen(p);
2970     } else
2971         info->style = NULL;
2972     if (stylekey) {
2973         info->stylekey = p;
2974         strcpy(p, stylekey);
2975         p += 1+strlen(p);
2976     } else
2977         info->stylekey = NULL;
2978     assert(p - (char *)info <= totalsize);
2979     info->size = size;
2980     info->flags = flags;
2981     info->index = count234(fs->fonts_by_selorder);
2982
2983     /*
2984      * It's just conceivable that a misbehaving font enumerator
2985      * might tell us about the same font real name more than once,
2986      * in which case we should silently drop the new one.
2987      */
2988     if (add234(fs->fonts_by_realname, info) != info) {
2989         sfree(info);
2990         return;
2991     }
2992     /*
2993      * However, we should never get a duplicate key in the
2994      * selorder tree, because the index field carefully
2995      * disambiguates otherwise identical records.
2996      */
2997     add234(fs->fonts_by_selorder, info);
2998 }
2999
3000 static fontinfo *update_for_intended_size(unifontsel_internal *fs,
3001                                           fontinfo *info)
3002 {
3003     fontinfo info2, *below, *above;
3004     int pos;
3005
3006     /*
3007      * Copy the info structure. This doesn't copy its dynamic
3008      * string fields, but that's unimportant because all we're
3009      * going to do is to adjust the size field and use it in one
3010      * tree search.
3011      */
3012     info2 = *info;
3013     info2.size = fs->intendedsize;
3014
3015     /*
3016      * Search in the tree to find the fontinfo structure which
3017      * best approximates the size the user last requested.
3018      */
3019     below = findrelpos234(fs->fonts_by_selorder, &info2, NULL,
3020                           REL234_LE, &pos);
3021     if (!below)
3022         pos = -1;
3023     above = index234(fs->fonts_by_selorder, pos+1);
3024
3025     /*
3026      * See if we've found it exactly, which is an easy special
3027      * case. If we have, it'll be in `below' and not `above',
3028      * because we did a REL234_LE rather than REL234_LT search.
3029      */
3030     if (below && !fontinfo_selorder_compare(&info2, below))
3031         return below;
3032
3033     /*
3034      * Now we've either found two suitable fonts, one smaller and
3035      * one larger, or we're at one or other extreme end of the
3036      * scale. Find out which, by NULLing out either of below and
3037      * above if it differs from this one in any respect but size
3038      * (and the disambiguating index field). Bear in mind, also,
3039      * that either one might _already_ be NULL if we're at the
3040      * extreme ends of the font list.
3041      */
3042     if (below) {
3043         info2.size = below->size;
3044         info2.index = below->index;
3045         if (fontinfo_selorder_compare(&info2, below))
3046             below = NULL;
3047     }
3048     if (above) {
3049         info2.size = above->size;
3050         info2.index = above->index;
3051         if (fontinfo_selorder_compare(&info2, above))
3052             above = NULL;
3053     }
3054
3055     /*
3056      * Now return whichever of above and below is non-NULL, if
3057      * that's unambiguous.
3058      */
3059     if (!above)
3060         return below;
3061     if (!below)
3062         return above;
3063
3064     /*
3065      * And now we really do have to make a choice about whether to
3066      * round up or down. We'll do it by rounding to nearest,
3067      * breaking ties by rounding up.
3068      */
3069     if (above->size - fs->intendedsize <= fs->intendedsize - below->size)
3070         return above;
3071     else
3072         return below;
3073 }
3074
3075 static void family_changed(GtkTreeSelection *treeselection, gpointer data)
3076 {
3077     unifontsel_internal *fs = (unifontsel_internal *)data;
3078     GtkTreeModel *treemodel;
3079     GtkTreeIter treeiter;
3080     int minval;
3081     fontinfo *info;
3082
3083     if (fs->inhibit_response)          /* we made this change ourselves */
3084         return;
3085
3086     if (!gtk_tree_selection_get_selected(treeselection, &treemodel, &treeiter))
3087         return;
3088
3089     gtk_tree_model_get(treemodel, &treeiter, 1, &minval, -1);
3090     info = (fontinfo *)index234(fs->fonts_by_selorder, minval);
3091     info = update_for_intended_size(fs, info);
3092     if (!info)
3093         return; /* _shouldn't_ happen unless font list is completely funted */
3094     if (!info->size)
3095         fs->selsize = fs->intendedsize;   /* font is scalable */
3096     unifontsel_select_font(fs, info, info->size ? info->size : fs->selsize,
3097                            1, FALSE);
3098 }
3099
3100 static void style_changed(GtkTreeSelection *treeselection, gpointer data)
3101 {
3102     unifontsel_internal *fs = (unifontsel_internal *)data;
3103     GtkTreeModel *treemodel;
3104     GtkTreeIter treeiter;
3105     int minval;
3106     fontinfo *info;
3107
3108     if (fs->inhibit_response)          /* we made this change ourselves */
3109         return;
3110
3111     if (!gtk_tree_selection_get_selected(treeselection, &treemodel, &treeiter))
3112         return;
3113
3114     gtk_tree_model_get(treemodel, &treeiter, 1, &minval, -1);
3115     if (minval < 0)
3116         return;                    /* somehow a charset heading got clicked */
3117     info = (fontinfo *)index234(fs->fonts_by_selorder, minval);
3118     info = update_for_intended_size(fs, info);
3119     if (!info)
3120         return; /* _shouldn't_ happen unless font list is completely funted */
3121     if (!info->size)
3122         fs->selsize = fs->intendedsize;   /* font is scalable */
3123     unifontsel_select_font(fs, info, info->size ? info->size : fs->selsize,
3124                            2, FALSE);
3125 }
3126
3127 static void size_changed(GtkTreeSelection *treeselection, gpointer data)
3128 {
3129     unifontsel_internal *fs = (unifontsel_internal *)data;
3130     GtkTreeModel *treemodel;
3131     GtkTreeIter treeiter;
3132     int minval, size;
3133     fontinfo *info;
3134
3135     if (fs->inhibit_response)          /* we made this change ourselves */
3136         return;
3137
3138     if (!gtk_tree_selection_get_selected(treeselection, &treemodel, &treeiter))
3139         return;
3140
3141     gtk_tree_model_get(treemodel, &treeiter, 1, &minval, 2, &size, -1);
3142     info = (fontinfo *)index234(fs->fonts_by_selorder, minval);
3143     unifontsel_select_font(fs, info, info->size ? info->size : size, 3, TRUE);
3144 }
3145
3146 static void size_entry_changed(GtkEditable *ed, gpointer data)
3147 {
3148     unifontsel_internal *fs = (unifontsel_internal *)data;
3149     const char *text;
3150     int size;
3151
3152     if (fs->inhibit_response)          /* we made this change ourselves */
3153         return;
3154
3155     text = gtk_entry_get_text(GTK_ENTRY(ed));
3156     size = atoi(text);
3157
3158     if (size > 0) {
3159         assert(fs->selected->size == 0);
3160         unifontsel_select_font(fs, fs->selected, size, 3, TRUE);
3161     }
3162 }
3163
3164 static void alias_resolve(GtkTreeView *treeview, GtkTreePath *path,
3165                           GtkTreeViewColumn *column, gpointer data)
3166 {
3167     unifontsel_internal *fs = (unifontsel_internal *)data;
3168     GtkTreeIter iter;
3169     int minval, newsize;
3170     fontinfo *info, *newinfo;
3171     char *newname;
3172
3173     if (fs->inhibit_response)          /* we made this change ourselves */
3174         return;
3175
3176     gtk_tree_model_get_iter(GTK_TREE_MODEL(fs->family_model), &iter, path);
3177     gtk_tree_model_get(GTK_TREE_MODEL(fs->family_model), &iter, 1,&minval, -1);
3178     info = (fontinfo *)index234(fs->fonts_by_selorder, minval);
3179     if (info) {
3180         int flags;
3181         struct fontinfo_realname_find f;
3182
3183         newname = info->fontclass->canonify_fontname
3184             (GTK_WIDGET(fs->u.window), info->realname, &newsize, &flags, TRUE);
3185
3186         f.realname = newname;
3187         f.flags = flags;
3188         newinfo = find234(fs->fonts_by_realname, &f, fontinfo_realname_find);
3189
3190         sfree(newname);
3191         if (!newinfo)
3192             return;                    /* font name not in our index */
3193         if (newinfo == info)
3194             return;   /* didn't change under canonification => not an alias */
3195         unifontsel_select_font(fs, newinfo,
3196                                newinfo->size ? newinfo->size : newsize,
3197                                1, TRUE);
3198     }
3199 }
3200
3201 #if GTK_CHECK_VERSION(3,0,0)
3202 static gint unifontsel_draw_area(GtkWidget *widget, cairo_t *cr, gpointer data)
3203 {
3204     unifontsel_internal *fs = (unifontsel_internal *)data;
3205     unifont_drawctx dctx;
3206
3207     dctx.type = DRAWTYPE_CAIRO;
3208     dctx.u.cairo.widget = widget;
3209     dctx.u.cairo.cr = cr;
3210     unifontsel_draw_preview_text_inner(&dctx, fs);
3211
3212     return TRUE;
3213 }
3214 #else
3215 static gint unifontsel_expose_area(GtkWidget *widget, GdkEventExpose *event,
3216                                    gpointer data)
3217 {
3218     unifontsel_internal *fs = (unifontsel_internal *)data;
3219
3220 #ifndef NO_BACKING_PIXMAPS
3221     if (fs->preview_pixmap) {
3222         gdk_draw_pixmap(gtk_widget_get_window(widget),
3223                         (gtk_widget_get_style(widget)->fg_gc
3224                          [gtk_widget_get_state(widget)]),
3225                         fs->preview_pixmap,
3226                         event->area.x, event->area.y,
3227                         event->area.x, event->area.y,
3228                         event->area.width, event->area.height);
3229     }
3230 #else
3231     unifontsel_draw_preview_text(fs);
3232 #endif
3233
3234     return TRUE;
3235 }
3236 #endif
3237
3238 static gint unifontsel_configure_area(GtkWidget *widget,
3239                                       GdkEventConfigure *event, gpointer data)
3240 {
3241 #ifndef NO_BACKING_PIXMAPS
3242     unifontsel_internal *fs = (unifontsel_internal *)data;
3243     int ox, oy, nx, ny, x, y;
3244
3245     /*
3246      * Enlarge the pixmap, but never shrink it.
3247      */
3248     ox = fs->preview_width;
3249     oy = fs->preview_height;
3250     x = event->width;
3251     y = event->height;
3252     if (x > ox || y > oy) {
3253         if (fs->preview_pixmap)
3254             gdk_pixmap_unref(fs->preview_pixmap);
3255
3256         nx = (x > ox ? x : ox);
3257         ny = (y > oy ? y : oy);
3258         fs->preview_pixmap = gdk_pixmap_new(gtk_widget_get_window(widget),
3259                                             nx, ny, -1);
3260         fs->preview_width = nx;
3261         fs->preview_height = ny;
3262
3263         unifontsel_draw_preview_text(fs);
3264     }
3265 #endif
3266
3267     gdk_window_invalidate_rect(gtk_widget_get_window(widget), NULL, FALSE);
3268
3269     return TRUE;
3270 }
3271
3272 unifontsel *unifontsel_new(const char *wintitle)
3273 {
3274     unifontsel_internal *fs = snew(unifontsel_internal);
3275     GtkWidget *table, *label, *w, *ww, *scroll;
3276     GtkListStore *model;
3277     GtkTreeViewColumn *column;
3278     int lists_height, preview_height, font_width, style_width, size_width;
3279     int i;
3280
3281     fs->inhibit_response = FALSE;
3282     fs->selected = NULL;
3283
3284     {
3285         int width, height;
3286
3287         /*
3288          * Invent some magic size constants.
3289          */
3290         get_label_text_dimensions("Quite Long Font Name (Foundry)",
3291                                   &width, &height);
3292         font_width = width;
3293         lists_height = 14 * height;
3294         preview_height = 5 * height;
3295
3296         get_label_text_dimensions("Italic Extra Condensed", &width, &height);
3297         style_width = width;
3298
3299         get_label_text_dimensions("48000", &width, &height);
3300         size_width = width;
3301     }
3302
3303     /*
3304      * Create the dialog box and initialise the user-visible
3305      * fields in the returned structure.
3306      */
3307     fs->u.user_data = NULL;
3308     fs->u.window = GTK_WINDOW(gtk_dialog_new());
3309     gtk_window_set_title(fs->u.window, wintitle);
3310     fs->u.cancel_button = gtk_dialog_add_button
3311         (GTK_DIALOG(fs->u.window), STANDARD_CANCEL_LABEL, GTK_RESPONSE_CANCEL);
3312     fs->u.ok_button = gtk_dialog_add_button
3313         (GTK_DIALOG(fs->u.window), STANDARD_OK_LABEL, GTK_RESPONSE_OK);
3314     gtk_widget_grab_default(fs->u.ok_button);
3315
3316     /*
3317      * Now set up the internal fields, including in particular all
3318      * the controls that actually allow the user to select fonts.
3319      */
3320 #if GTK_CHECK_VERSION(3,0,0)
3321     table = gtk_grid_new();
3322     gtk_grid_set_column_spacing(GTK_GRID(table), 8);
3323 #else
3324     table = gtk_table_new(8, 3, FALSE);
3325     gtk_table_set_col_spacings(GTK_TABLE(table), 8);
3326 #endif
3327     gtk_widget_show(table);
3328
3329 #if GTK_CHECK_VERSION(3,0,0)
3330     /* GtkAlignment has become deprecated and we use the "margin"
3331      * property */
3332     w = table;
3333     g_object_set(G_OBJECT(w), "margin", 8, (const char *)NULL);
3334 #elif GTK_CHECK_VERSION(2,4,0)
3335     /* GtkAlignment seems to be the simplest way to put padding round things */
3336     w = gtk_alignment_new(0, 0, 1, 1);
3337     gtk_alignment_set_padding(GTK_ALIGNMENT(w), 8, 8, 8, 8);
3338     gtk_container_add(GTK_CONTAINER(w), table);
3339     gtk_widget_show(w);
3340 #else
3341     /* In GTK < 2.4, even that isn't available */
3342     w = table;
3343 #endif
3344
3345     gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area
3346                                (GTK_DIALOG(fs->u.window))),
3347                        w, TRUE, TRUE, 0);
3348
3349     label = gtk_label_new_with_mnemonic("_Font:");
3350     gtk_widget_show(label);
3351     align_label_left(GTK_LABEL(label));
3352 #if GTK_CHECK_VERSION(3,0,0)
3353     gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
3354     g_object_set(G_OBJECT(label), "hexpand", TRUE, (const char *)NULL);
3355 #else
3356     gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
3357 #endif
3358
3359     /*
3360      * The Font list box displays only a string, but additionally
3361      * stores two integers which give the limits within the
3362      * tree234 of the font entries covered by this list entry.
3363      */
3364     model = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
3365     w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
3366     gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(w), FALSE);
3367     gtk_label_set_mnemonic_widget(GTK_LABEL(label), w);
3368     gtk_widget_show(w);
3369     column = gtk_tree_view_column_new_with_attributes
3370         ("Font", gtk_cell_renderer_text_new(),
3371          "text", 0, (char *)NULL);
3372     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
3373     gtk_tree_view_append_column(GTK_TREE_VIEW(w), column);
3374     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(w))),
3375                      "changed", G_CALLBACK(family_changed), fs);
3376     g_signal_connect(G_OBJECT(w), "row-activated",
3377                      G_CALLBACK(alias_resolve), fs);
3378
3379     scroll = gtk_scrolled_window_new(NULL, NULL);
3380     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
3381                                         GTK_SHADOW_IN);
3382     gtk_container_add(GTK_CONTAINER(scroll), w);
3383     gtk_widget_show(scroll);
3384     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
3385                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3386     gtk_widget_set_size_request(scroll, font_width, lists_height);
3387 #if GTK_CHECK_VERSION(3,0,0)
3388     gtk_grid_attach(GTK_GRID(table), scroll, 0, 1, 1, 2);
3389     g_object_set(G_OBJECT(scroll), "expand", TRUE, (const char *)NULL);
3390 #else
3391     gtk_table_attach(GTK_TABLE(table), scroll, 0, 1, 1, 3, GTK_FILL,
3392                      GTK_EXPAND | GTK_FILL, 0, 0);
3393 #endif
3394     fs->family_model = model;
3395     fs->family_list = w;
3396
3397     label = gtk_label_new_with_mnemonic("_Style:");
3398     gtk_widget_show(label);
3399     align_label_left(GTK_LABEL(label));
3400 #if GTK_CHECK_VERSION(3,0,0)
3401     gtk_grid_attach(GTK_GRID(table), label, 1, 0, 1, 1);
3402     g_object_set(G_OBJECT(label), "hexpand", TRUE, (const char *)NULL);
3403 #else
3404     gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
3405 #endif
3406
3407     /*
3408      * The Style list box can contain insensitive elements (character
3409      * set headings for server-side fonts), so we add an extra column
3410      * to the list store to hold that information. Also, since GTK3 at
3411      * least doesn't seem to display insensitive elements differently
3412      * by default, we add a further column to change their style.
3413      */
3414     model = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT,
3415                                G_TYPE_BOOLEAN, G_TYPE_INT);
3416     w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
3417     gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(w), FALSE);
3418     gtk_label_set_mnemonic_widget(GTK_LABEL(label), w);
3419     gtk_widget_show(w);
3420     column = gtk_tree_view_column_new_with_attributes
3421         ("Style", gtk_cell_renderer_text_new(),
3422          "text", 0, "sensitive", 3, "weight", 4, (char *)NULL);
3423     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
3424     gtk_tree_view_append_column(GTK_TREE_VIEW(w), column);
3425     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(w))),
3426                      "changed", G_CALLBACK(style_changed), fs);
3427
3428     scroll = gtk_scrolled_window_new(NULL, NULL);
3429     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
3430                                         GTK_SHADOW_IN);
3431     gtk_container_add(GTK_CONTAINER(scroll), w);
3432     gtk_widget_show(scroll);
3433     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
3434                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3435     gtk_widget_set_size_request(scroll, style_width, lists_height);
3436 #if GTK_CHECK_VERSION(3,0,0)
3437     gtk_grid_attach(GTK_GRID(table), scroll, 1, 1, 1, 2);
3438     g_object_set(G_OBJECT(scroll), "expand", TRUE, (const char *)NULL);
3439 #else
3440     gtk_table_attach(GTK_TABLE(table), scroll, 1, 2, 1, 3, GTK_FILL,
3441                      GTK_EXPAND | GTK_FILL, 0, 0);
3442 #endif
3443     fs->style_model = model;
3444     fs->style_list = w;
3445
3446     label = gtk_label_new_with_mnemonic("Si_ze:");
3447     gtk_widget_show(label);
3448     align_label_left(GTK_LABEL(label));
3449 #if GTK_CHECK_VERSION(3,0,0)
3450     gtk_grid_attach(GTK_GRID(table), label, 2, 0, 1, 1);
3451     g_object_set(G_OBJECT(label), "hexpand", TRUE, (const char *)NULL);
3452 #else
3453     gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1, GTK_FILL, 0, 0, 0);
3454 #endif
3455
3456     /*
3457      * The Size label attaches primarily to a text input box so
3458      * that the user can select a size of their choice. The list
3459      * of available sizes is secondary.
3460      */
3461     fs->size_entry = w = gtk_entry_new();
3462     gtk_label_set_mnemonic_widget(GTK_LABEL(label), w);
3463     gtk_widget_set_size_request(w, size_width, -1);
3464     gtk_widget_show(w);
3465 #if GTK_CHECK_VERSION(3,0,0)
3466     gtk_grid_attach(GTK_GRID(table), w, 2, 1, 1, 1);
3467     g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
3468 #else
3469     gtk_table_attach(GTK_TABLE(table), w, 2, 3, 1, 2, GTK_FILL, 0, 0, 0);
3470 #endif
3471     g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(size_entry_changed),
3472                      fs);
3473
3474     model = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
3475     w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
3476     gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(w), FALSE);
3477     gtk_widget_show(w);
3478     column = gtk_tree_view_column_new_with_attributes
3479         ("Size", gtk_cell_renderer_text_new(),
3480          "text", 0, (char *)NULL);
3481     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
3482     gtk_tree_view_append_column(GTK_TREE_VIEW(w), column);
3483     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(w))),
3484                      "changed", G_CALLBACK(size_changed), fs);
3485
3486     scroll = gtk_scrolled_window_new(NULL, NULL);
3487     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
3488                                         GTK_SHADOW_IN);
3489     gtk_container_add(GTK_CONTAINER(scroll), w);
3490     gtk_widget_show(scroll);
3491     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
3492                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3493 #if GTK_CHECK_VERSION(3,0,0)
3494     gtk_grid_attach(GTK_GRID(table), scroll, 2, 2, 1, 1);
3495     g_object_set(G_OBJECT(scroll), "expand", TRUE, (const char *)NULL);
3496 #else
3497     gtk_table_attach(GTK_TABLE(table), scroll, 2, 3, 2, 3, GTK_FILL,
3498                      GTK_EXPAND | GTK_FILL, 0, 0);
3499 #endif
3500     fs->size_model = model;
3501     fs->size_list = w;
3502
3503     /*
3504      * Preview widget.
3505      */
3506     fs->preview_area = gtk_drawing_area_new();
3507 #ifndef NO_BACKING_PIXMAPS
3508     fs->preview_pixmap = NULL;
3509 #endif
3510     fs->preview_width = 0;
3511     fs->preview_height = 0;
3512     fs->preview_fg.pixel = fs->preview_bg.pixel = 0;
3513     fs->preview_fg.red = fs->preview_fg.green = fs->preview_fg.blue = 0x0000;
3514     fs->preview_bg.red = fs->preview_bg.green = fs->preview_bg.blue = 0xFFFF;
3515 #if !GTK_CHECK_VERSION(3,0,0)
3516     gdk_colormap_alloc_color(gdk_colormap_get_system(), &fs->preview_fg,
3517                              FALSE, FALSE);
3518     gdk_colormap_alloc_color(gdk_colormap_get_system(), &fs->preview_bg,
3519                              FALSE, FALSE);
3520 #endif
3521 #if GTK_CHECK_VERSION(3,0,0)
3522     g_signal_connect(G_OBJECT(fs->preview_area), "draw",
3523                      G_CALLBACK(unifontsel_draw_area), fs);
3524 #else
3525     g_signal_connect(G_OBJECT(fs->preview_area), "expose_event",
3526                      G_CALLBACK(unifontsel_expose_area), fs);
3527 #endif
3528     g_signal_connect(G_OBJECT(fs->preview_area), "configure_event",
3529                      G_CALLBACK(unifontsel_configure_area), fs);
3530     gtk_widget_set_size_request(fs->preview_area, 1, preview_height);
3531     gtk_widget_show(fs->preview_area);
3532     ww = fs->preview_area;
3533     w = gtk_frame_new(NULL);
3534     gtk_container_add(GTK_CONTAINER(w), ww);
3535     gtk_widget_show(w);
3536
3537 #if GTK_CHECK_VERSION(3,0,0)
3538     /* GtkAlignment has become deprecated and we use the "margin"
3539      * property */
3540     g_object_set(G_OBJECT(w), "margin", 8, (const char *)NULL);
3541 #elif GTK_CHECK_VERSION(2,4,0)
3542     ww = w;
3543     /* GtkAlignment seems to be the simplest way to put padding round things */
3544     w = gtk_alignment_new(0, 0, 1, 1);
3545     gtk_alignment_set_padding(GTK_ALIGNMENT(w), 8, 8, 8, 8);
3546     gtk_container_add(GTK_CONTAINER(w), ww);
3547     gtk_widget_show(w);
3548 #endif
3549
3550     ww = w;
3551     w = gtk_frame_new("Preview of font");
3552     gtk_container_add(GTK_CONTAINER(w), ww);
3553     gtk_widget_show(w);
3554 #if GTK_CHECK_VERSION(3,0,0)
3555     gtk_grid_attach(GTK_GRID(table), w, 0, 3, 3, 1);
3556     g_object_set(G_OBJECT(w), "expand", TRUE, (const char *)NULL);
3557 #else
3558     gtk_table_attach(GTK_TABLE(table), w, 0, 3, 3, 4,
3559                      GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 8);
3560 #endif
3561
3562     /*
3563      * We only provide the checkboxes for client- and server-side
3564      * fonts if we have the X11 back end available, because that's the
3565      * only situation in which more than one class of font is
3566      * available anyway.
3567      */
3568     fs->n_filter_buttons = 0;
3569 #ifndef NOT_X_WINDOWS
3570     w = gtk_check_button_new_with_label("Show client-side fonts");
3571     g_object_set_data(G_OBJECT(w), "user-data",
3572                       GINT_TO_POINTER(FONTFLAG_CLIENTSIDE));
3573     g_signal_connect(G_OBJECT(w), "toggled",
3574                      G_CALLBACK(unifontsel_button_toggled), fs);
3575     gtk_widget_show(w);
3576     fs->filter_buttons[fs->n_filter_buttons++] = w;
3577 #if GTK_CHECK_VERSION(3,0,0)
3578     gtk_grid_attach(GTK_GRID(table), w, 0, 4, 3, 1);
3579     g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
3580 #else
3581     gtk_table_attach(GTK_TABLE(table), w, 0, 3, 4, 5, GTK_FILL, 0, 0, 0);
3582 #endif
3583     w = gtk_check_button_new_with_label("Show server-side fonts");
3584     g_object_set_data(G_OBJECT(w), "user-data",
3585                       GINT_TO_POINTER(FONTFLAG_SERVERSIDE));
3586     g_signal_connect(G_OBJECT(w), "toggled",
3587                      G_CALLBACK(unifontsel_button_toggled), fs);
3588     gtk_widget_show(w);
3589     fs->filter_buttons[fs->n_filter_buttons++] = w;
3590 #if GTK_CHECK_VERSION(3,0,0)
3591     gtk_grid_attach(GTK_GRID(table), w, 0, 5, 3, 1);
3592     g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
3593 #else
3594     gtk_table_attach(GTK_TABLE(table), w, 0, 3, 5, 6, GTK_FILL, 0, 0, 0);
3595 #endif
3596     w = gtk_check_button_new_with_label("Show server-side font aliases");
3597     g_object_set_data(G_OBJECT(w), "user-data",
3598                       GINT_TO_POINTER(FONTFLAG_SERVERALIAS));
3599     g_signal_connect(G_OBJECT(w), "toggled",
3600                      G_CALLBACK(unifontsel_button_toggled), fs);
3601     gtk_widget_show(w);
3602     fs->filter_buttons[fs->n_filter_buttons++] = w;
3603 #if GTK_CHECK_VERSION(3,0,0)
3604     gtk_grid_attach(GTK_GRID(table), w, 0, 6, 3, 1);
3605     g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
3606 #else
3607     gtk_table_attach(GTK_TABLE(table), w, 0, 3, 6, 7, GTK_FILL, 0, 0, 0);
3608 #endif
3609 #endif /* NOT_X_WINDOWS */
3610     w = gtk_check_button_new_with_label("Show non-monospaced fonts");
3611     g_object_set_data(G_OBJECT(w), "user-data",
3612                       GINT_TO_POINTER(FONTFLAG_NONMONOSPACED));
3613     g_signal_connect(G_OBJECT(w), "toggled",
3614                      G_CALLBACK(unifontsel_button_toggled), fs);
3615     gtk_widget_show(w);
3616     fs->filter_buttons[fs->n_filter_buttons++] = w;
3617 #if GTK_CHECK_VERSION(3,0,0)
3618     gtk_grid_attach(GTK_GRID(table), w, 0, 7, 3, 1);
3619     g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL);
3620 #else
3621     gtk_table_attach(GTK_TABLE(table), w, 0, 3, 7, 8, GTK_FILL, 0, 0, 0);
3622 #endif
3623
3624     assert(fs->n_filter_buttons <= lenof(fs->filter_buttons));
3625     fs->filter_flags = FONTFLAG_CLIENTSIDE | FONTFLAG_SERVERSIDE |
3626         FONTFLAG_SERVERALIAS;
3627     unifontsel_set_filter_buttons(fs);
3628
3629     /*
3630      * Go and find all the font names, and set up our master font
3631      * list.
3632      */
3633     fs->fonts_by_realname = newtree234(fontinfo_realname_compare);
3634     fs->fonts_by_selorder = newtree234(fontinfo_selorder_compare);
3635     for (i = 0; i < lenof(unifont_types); i++)
3636         unifont_types[i]->enum_fonts(GTK_WIDGET(fs->u.window),
3637                                      unifontsel_add_entry, fs);
3638
3639     /*
3640      * And set up the initial font names list.
3641      */
3642     unifontsel_setup_familylist(fs);
3643
3644     fs->selsize = fs->intendedsize = 13;   /* random default */
3645     gtk_widget_set_sensitive(fs->u.ok_button, FALSE);
3646
3647     return (unifontsel *)fs;
3648 }
3649
3650 void unifontsel_destroy(unifontsel *fontsel)
3651 {
3652     unifontsel_internal *fs = (unifontsel_internal *)fontsel;
3653     fontinfo *info;
3654
3655 #ifndef NO_BACKING_PIXMAPS
3656     if (fs->preview_pixmap)
3657         gdk_pixmap_unref(fs->preview_pixmap);
3658 #endif
3659
3660     freetree234(fs->fonts_by_selorder);
3661     while ((info = delpos234(fs->fonts_by_realname, 0)) != NULL)
3662         sfree(info);
3663     freetree234(fs->fonts_by_realname);
3664
3665     gtk_widget_destroy(GTK_WIDGET(fs->u.window));
3666     sfree(fs);
3667 }
3668
3669 void unifontsel_set_name(unifontsel *fontsel, const char *fontname)
3670 {
3671     unifontsel_internal *fs = (unifontsel_internal *)fontsel;
3672     int i, start, end, size, flags;
3673     const char *fontname2 = NULL;
3674     fontinfo *info;
3675
3676     /*
3677      * Provide a default if given an empty or null font name.
3678      */
3679     if (!fontname || !*fontname)
3680         fontname = DEFAULT_GTK_FONT;
3681
3682     /*
3683      * Call the canonify_fontname function.
3684      */
3685     fontname = unifont_do_prefix(fontname, &start, &end);
3686     for (i = start; i < end; i++) {
3687         fontname2 = unifont_types[i]->canonify_fontname
3688             (GTK_WIDGET(fs->u.window), fontname, &size, &flags, FALSE);
3689         if (fontname2)
3690             break;
3691     }
3692     if (i == end)
3693         return;                        /* font name not recognised */
3694
3695     /*
3696      * Now look up the canonified font name in our index.
3697      */
3698     {
3699         struct fontinfo_realname_find f;
3700         f.realname = fontname2;
3701         f.flags = flags;
3702         info = find234(fs->fonts_by_realname, &f, fontinfo_realname_find);
3703     }
3704
3705     /*
3706      * If we've found the font, and its size field is either
3707      * correct or zero (the latter indicating a scalable font),
3708      * then we're done. Otherwise, try looking up the original
3709      * font name instead.
3710      */
3711     if (!info || (info->size != size && info->size != 0)) {
3712         struct fontinfo_realname_find f;
3713         f.realname = fontname;
3714         f.flags = flags;
3715
3716         info = find234(fs->fonts_by_realname, &f, fontinfo_realname_find);
3717         if (!info || info->size != size)
3718             return;                    /* font name not in our index */
3719     }
3720
3721     /*
3722      * Now we've got a fontinfo structure and a font size, so we
3723      * know everything we need to fill in all the fields in the
3724      * dialog.
3725      */
3726     unifontsel_select_font(fs, info, size, 0, TRUE);
3727 }
3728
3729 char *unifontsel_get_name(unifontsel *fontsel)
3730 {
3731     unifontsel_internal *fs = (unifontsel_internal *)fontsel;
3732     char *name;
3733
3734     if (!fs->selected)
3735         return NULL;
3736
3737     if (fs->selected->size == 0) {
3738         name = fs->selected->fontclass->scale_fontname
3739             (GTK_WIDGET(fs->u.window), fs->selected->realname, fs->selsize);
3740         if (name) {
3741             char *ret = dupcat(fs->selected->fontclass->prefix, ":",
3742                                name, NULL);
3743             sfree(name);
3744             return ret;
3745         }
3746     }
3747
3748     return dupcat(fs->selected->fontclass->prefix, ":",
3749                   fs->selected->realname, NULL);
3750 }
3751
3752 #endif /* GTK_CHECK_VERSION(2,0,0) */