d54ecedd79ba381894375d7efae2bc19615f333e
[dana/urxvt.git] / src / rxvtfont.C
1 /*--------------------------------*-C-*---------------------------------*
2  * File:        defaultfont.C
3  *----------------------------------------------------------------------*
4  * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
5  *                              - original version.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  *---------------------------------------------------------------------*/
21
22 #include "../config.h"
23 #include "rxvt.h"
24 #include "rxvtfont.h"
25
26 #include <cstdlib>
27
28 #define DISPLAY  r->display->display
29 #define TGC      r->TermWin.gc
30
31 const struct rxvt_fallback_font {
32   codeset cs;
33   const char *name;
34 } fallback_fonts[] = {
35   { CS_ISO8859_1,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-1"           },
36   { CS_ISO8859_15,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-15"          },
37   { CS_ISO8859_15,   "-*-*-*-r-*--*-*-*-*-c-*-fcd8859-15"          },
38                                                                    
39 #if ENCODING_EU                                                    
40   // cyrillic                                                      
41   { CS_KOI8_R,        "-*-*-*-r-*--*-*-*-*-c-*-koi8-r"             },
42   { CS_KOI8_U,        "-*-*-*-r-*--*-*-*-*-c-*-koi8-u"             },
43                                                                    
44   { CS_ISO8859_2,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-2"           },
45   { CS_ISO8859_3,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-3"           },
46   { CS_ISO8859_4,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-4"           },
47   { CS_ISO8859_5,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-5"           },
48   { CS_ISO8859_6,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-6"           },
49   { CS_ISO8859_7,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-7"           },
50   { CS_ISO8859_8,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-8"           },
51   { CS_ISO8859_9,    "-*-*-*-r-*--*-*-*-*-c-*-iso8859-9"           },
52   { CS_ISO8859_10,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-10"          },
53   { CS_ISO8859_11,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-11"          },
54   { CS_ISO8859_13,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-13"          },
55   { CS_ISO8859_14,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-14"          },
56   { CS_ISO8859_16,   "-*-*-*-r-*--*-*-*-*-c-*-iso8859-16"          },
57 #endif
58
59   // japanese
60 #if ENCODING_JP || ENCODING_JP_EXT
61 # if XFT
62   // prefer xft for complex scripts
63   { CS_UNICODE,        "xft:Kochi Gothic:antialias=false"          },
64 # endif
65   { CS_JIS0201_1976_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0201*-0"  },
66   { CS_JIS0208_1990_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0208*-0"  },
67   { CS_JIS0212_1990_0, "-*-mincho-*-r-*--*-*-*-*-c-*-jisx0212*-0"  },
68   { CS_JIS0201_1976_0, "-*-*-*-r-*--*-*-*-*-c-*-jisx0201*-0"       },
69   { CS_JIS0208_1990_0, "-*-*-*-r-*--*-*-*-*-c-*-jisx0208*-0"       },
70   { CS_JIS0212_1990_0, "-*-*-*-r-*--*-*-*-*-c-*-jisx0212*-0"       },
71 #endif
72
73 #if ENCODING_CN || ENCODING_CN_EXT
74 # if XFT
75   { CS_BIG5_EXT,       "xft:AR PL Mingti2L Big5"                   },
76   { CS_BIG5_EXT,       "xft:AR PL KaitiM Big5"                     },
77   { CS_GB2312_1980_0,  "xft:AR PL KaitiM GB"                       },
78   { CS_GB2312_1980_0,  "xft:AR PL SungtiL GB"                      },
79 # endif
80   { CS_BIG5,            "-*-*-*-*-*-*-*-*-*-*-c-*-big5-0"          },
81   { CS_BIG5_PLUS,       "-*-*-*-*-*-*-*-*-*-*-c-*-big5p-0"         },
82   { CS_BIG5_EXT,        "-*-*-*-*-*-*-*-*-*-*-c-*-big5.eten-0"     },
83   { CS_CNS11643_1992_1, "-*-*-*-*-*-*-*-*-*-*-c-*-gb2312*-0"       },
84   { CS_CNS11643_1992_1, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-1"     },
85   { CS_CNS11643_1992_2, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-2"     },
86   { CS_CNS11643_1992_3, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-3"     },
87   { CS_CNS11643_1992_4, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-4"     },
88   { CS_CNS11643_1992_5, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-5"     },
89   { CS_CNS11643_1992_6, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-6"     },
90   { CS_CNS11643_1992_7, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-7"     },
91   { CS_CNS11643_1992_F, "-*-*-*-*-*-*-*-*-*-*-c-*-cns11643*-f"     },
92 #endif
93
94 #if XFT
95   { CS_UNICODE,      "xft:Andale Mono"                             },
96   { CS_UNICODE,      "xft:Arial Unicode MS"                        },
97 #endif
98   { CS_UNICODE,      "-*-lucidatypewriter-*-*-*-*-*-*-*-*-m-*-iso10646-1" },
99   { CS_UNICODE,      "-*-unifont-*-*-*-*-*-*-*-*-c-*-iso10646-1"   },
100   { CS_UNICODE,      "-*-*-*-r-*-*-*-*-*-*-c-*-iso10646-1"         },
101   { CS_UNICODE,      "-*-*-*-r-*-*-*-*-*-*-m-*-iso10646-1"         },
102 #if XFT
103   // FreeMono is usually uglier than x fonts, so try last only.
104   //{ CS_UNICODE,      "xft:FreeMono"                                },
105 #endif
106
107   { CS_UNKNOWN, 0 }
108 };
109
110 /////////////////////////////////////////////////////////////////////////////
111
112 #if XFT
113 rxvt_drawable::~rxvt_drawable ()
114 {
115   if (xftdrawable)
116     XftDrawDestroy (xftdrawable);
117 }
118
119 rxvt_drawable::operator XftDraw *()
120 {
121   if (!xftdrawable)
122     xftdrawable = XftDrawCreate (display->display, drawable, display->visual, display->cmap);
123
124   return xftdrawable;
125 }
126 #endif
127
128 /////////////////////////////////////////////////////////////////////////////
129
130 static void *enc_buf;
131 static uint32_t enc_len;
132
133 static inline void *
134 get_enc_buf (uint32_t len)
135 {
136   if (len > enc_len)
137     {
138       free (enc_buf);
139       enc_buf = malloc (len);
140       enc_len = len;
141     }
142
143   return enc_buf;
144 }
145
146 static const char *
147 enc_char (const text_t *text, uint32_t len, codeset cs, bool &zero)
148 {
149   uint8_t *buf = (uint8_t *)get_enc_buf (len);
150
151   while (len--)
152     {
153       uint32_t c = FROM_UNICODE (cs, *text++);
154
155       if (c == NOCHAR)
156         {
157           c = 0;
158           zero = true;
159         }
160
161       *buf++ = c;
162     }
163
164   return (const char *)enc_buf;
165 }
166
167 static const XChar2b *
168 enc_xchar2b (const text_t *text, uint32_t len, codeset cs, bool &zero)
169 {
170   XChar2b *buf = (XChar2b *)get_enc_buf (len * sizeof (XChar2b));
171
172   while (len--)
173     {
174       uint32_t c = FROM_UNICODE (cs, *text++);
175
176       if (c == NOCHAR)
177         {
178           c = 0;
179           zero = true;
180         }
181
182       buf->byte1 = c >> 8;
183       buf->byte2 = c;
184       buf++;
185     }
186
187   return (XChar2b *)enc_buf;
188 }
189
190 /////////////////////////////////////////////////////////////////////////////
191
192 void
193 rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color)
194 {
195   if (color == Color_bg)
196     XClearArea (d.display->display, d, x, y, w, h, FALSE);
197   else if (color >= 0)
198     {
199 #if XFT
200       XftDrawRect (d, &r->pix_colors[color].c, x, y, w, h);
201 #else
202       XSetForeground (d.display->display, TGC, r->pix_colors[color]);
203       XFillRectangle (d.display->display, d, TGC, x, y, w, h);
204 #endif
205     }
206 }
207
208 #include "table/linedraw.h"
209
210 struct rxvt_font_default : rxvt_font {
211
212   rxvt_fontprop properties ()
213   {
214     rxvt_fontprop p;
215
216     p.width = p.height = 1;
217     p.weight = rxvt_fontprop::medium;
218     p.slant = rxvt_fontprop::roman;
219
220     return p;
221   }
222
223   bool load (const rxvt_fontprop &prop)
224   {
225     width = 1; height = 1;
226     ascent = 1; descent = 0;
227
228     set_name (strdup ("built-in pseudofont"));
229
230     return true;
231   }
232
233   bool has_codepoint (unicode_t unicode)
234   {
235     if (unicode <= 0x001f)
236       return true;
237
238     if (unicode <= 0x007f)
239       return false;
240
241     if (unicode <= 0x009f)
242       return true;
243
244     if (unicode >= 0x2500 && unicode <= 0x259f)
245       return true;
246
247     if (IS_COMPOSE (unicode))
248       return true;
249
250     switch (unicode)
251       {
252         case ZERO_WIDTH_CHAR:
253           return true;
254       }
255
256     return false;
257   }
258
259   void draw (rxvt_drawable &d, int x, int y,
260              const text_t *text, int len,
261              int fg, int bg);
262 };
263
264 void
265 rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
266                          const text_t *text, int len,
267                          int fg, int bg)
268 {
269   clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
270
271   XSetForeground (d.display->display, TGC, r->pix_colors[fg]);
272
273   while (len--)
274     {
275 #if ENABLE_COMBINING
276       compose_char *cc;
277 #endif
278       text_t t = *text++;
279
280       if (0x2500 <= t && t <= 0x259f)
281         {
282           uint16_t offs = linedraw_offs[t - 0x2500];
283           uint32_t *a = linedraw_command + (offs >> 4);
284           uint32_t *b = a + (offs & 15);
285
286           int W = r->TermWin.fwidth;
287           int H = r->TermWin.fheight;
288
289           int x_[16];
290           int y_[16];
291
292           for (int i = 0; i <= 8; i++)
293             {
294               x_[i] = x + ((W-1) * i + (i*7/8)) / 8;
295               y_[i] = y + ((H-1) * i + (i*7/8)) / 8;
296             }
297
298           x_[10] = x + (W - 1) / 2; x_[9] = x_[10] - 1; x_[11] = x_[10] + 1;
299           y_[10] = y + (H - 1) / 2; y_[9] = y_[10] - 1; y_[11] = y_[10] + 1;
300
301           XGCValues gcv;
302
303           gcv.cap_style = CapButt;
304           gcv.line_width = 0;
305           XChangeGC (d.display->display, TGC, GCLineWidth | GCCapStyle, &gcv);
306
307           while (a < b)
308             {
309               uint32_t command = *a++;
310
311               int op = (command >> 24) & 255;
312               int a  = (command >> 20) & 15;
313               int b  = (command >> 16) & 15;
314               int x1 = x_[(command >> 12) & 15];
315               int y1 = y_[(command >>  8) & 15];
316               int x2 = x_[(command >>  4) & 15];
317               int y2 = y_[(command >>  0) & 15];
318
319               switch (op)
320                 {
321                   case 0: // line
322                     XDrawLine (d.display->display, d, TGC, x1, y1, x2, y2);
323                     break;
324
325                   case 1: // rectangle, possibly stippled
326                     if (a)
327                       {
328                         static char bm[] = { 0,0 , 3,1 , 1,2 , 1,0 };
329  
330                         gcv.fill_style = FillStippled;
331                         gcv.stipple = XCreateBitmapFromData (d.display->display, d, bm + a * 2, 2, 2);
332                         gcv.ts_x_origin = x;
333                         gcv.ts_y_origin = y;
334
335                         XChangeGC (d.display->display, TGC,
336                                    GCFillStyle | GCStipple | GCTileStipXOrigin | GCTileStipYOrigin,
337                                    &gcv);
338                       }
339
340                     XFillRectangle (d.display->display, d, TGC, x1, y1, x2 - x1 + 1, y2 - y1 + 1);
341
342                     if (a)
343                       {
344                         XFreePixmap (d.display->display, gcv.stipple);
345                         gcv.stipple = 0;
346                         gcv.fill_style = FillSolid;
347                         XChangeGC (d.display->display, TGC, GCFillStyle, &gcv);
348                       }
349                     break;
350                   case 2: // arc
351                     XDrawArc (d.display->display, d, TGC,
352                               x1 - W/2, y1 - H/2, W-1, H-1,
353                               (a - 1) * 90*64, (b - 1) * 90*64);
354                     break;
355                 }
356             }
357         }
358 #if ENABLE_COMBINING
359       else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
360         {
361           rxvt_font *f1 = (*fs)[fs->find_font (cc->c1)];
362           f1->draw (d, x, y, &(t = cc->c1), 1, fg, bg);
363           if (cc->c2 != NOCHAR)
364             {
365               // prefer font of first character, for no good reasons
366               rxvt_font *f2 = f1->has_codepoint (cc->c2)
367                                 ? f1
368                                 : (*fs)[fs->find_font (cc->c2)];
369
370               f2->draw (d, x, y, &(t = cc->c2), 1, fg, -1);
371             }
372         }
373 #endif
374       else
375         switch (t)
376           {
377             case ZERO_WIDTH_CHAR:
378               break;
379
380             default:
381               int w = 0;
382               while (len > 0 && *text == NOCHAR)
383                 {
384                   ++text;
385                   --len;
386                   w += r->TermWin.fwidth;
387                 }
388
389               XDrawRectangle (d.display->display, d, TGC, x + 2, y + 2,
390                               w + r->TermWin.fwidth - 4, r->TermWin.fheight - 4);
391               x += w;
392           }
393
394       x += r->TermWin.fwidth;
395     }
396 }
397
398 /////////////////////////////////////////////////////////////////////////////
399
400 struct rxvt_font_x11 : rxvt_font {
401   rxvt_font_x11 () { f = 0; }
402
403   void clear ();
404
405   rxvt_fontprop properties ();
406
407   bool load (const rxvt_fontprop &prop);
408
409   bool has_codepoint (unicode_t unicode);
410
411   void draw (rxvt_drawable &d, int x, int y,
412              const text_t *text, int len,
413              int fg, int bg);
414
415   XFontStruct *f;
416   codeset cs;
417   bool enc2b, encm;
418
419   char *get_property (XFontStruct *f, const char *property, const char *repl) const;
420   bool set_properties (rxvt_fontprop &p, int height, const char *weight, const char *slant, int avgwidth);
421   bool set_properties (rxvt_fontprop &p, XFontStruct *f);
422   bool set_properties (rxvt_fontprop &p, const char *name);
423 };
424
425 char *
426 rxvt_font_x11::get_property (XFontStruct *f, const char *property, const char *repl) const
427 {
428   unsigned long value;
429
430   if (XGetFontProperty (f, XInternAtom (DISPLAY, property, 0), &value))
431     return XGetAtomName (DISPLAY, value);
432   else
433     return rxvt_strdup (repl);
434 }
435
436 rxvt_fontprop
437 rxvt_font_x11::properties ()
438 {
439   rxvt_fontprop p;
440   set_properties (p, f);
441   return p;
442 }
443
444 bool
445 rxvt_font_x11::set_properties (rxvt_fontprop &p, int height, const char *weight, const char *slant, int avgwidth)
446 {
447   p.width = avgwidth ? (avgwidth + 1) / 10 : (height + 1) / 2;
448   p.height = height;
449   p.weight = *weight == 'B' || *weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;
450   p.slant  = *slant == 'r' || *slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;
451
452   return true;
453 }
454
455 bool
456 rxvt_font_x11::set_properties (rxvt_fontprop &p, XFontStruct *f)
457 {
458   unsigned long height;
459   if (!XGetFontProperty (f, XInternAtom (DISPLAY, "PIXEL_SIZE", 0), &height))
460     return false;
461
462   unsigned long avgwidth;
463   if (!XGetFontProperty (f, XInternAtom (DISPLAY, "AVERAGE_WIDTH", 0), &avgwidth))
464     avgwidth = 0;
465
466   char *weight = get_property (f, "WEIGHT_NAME", "medium");
467   char *slant  = get_property (f, "SLANT", "r");
468
469   set_properties (p, height, weight, slant, avgwidth);
470
471   free (weight);
472   free (slant);
473
474   return true;
475 }
476
477 bool
478 rxvt_font_x11::set_properties (rxvt_fontprop &p, const char *name)
479 {
480   int slashes = 0;
481   const char *comp[13];
482
483   for (const char *c = name; *c; c++)
484     if (*c == '-')
485       {
486         comp[slashes++] = c + 1;
487         if (slashes >= 13)
488           break;
489       }
490
491   /* can we short-circuit the costly XLoadQueryFont? */
492   if (slashes >= 13
493       && (*comp[ 6] >= '1' && *comp[ 6] <= '9')
494       && (*comp[11] >= '0' && *comp[11] <= '9'))
495     return set_properties (p, atoi (comp[6]), comp[2], comp[3], atoi (comp[11]));
496
497   XFontStruct *f = XLoadQueryFont (DISPLAY, name);
498
499   if (f)
500     {
501       // the font should really exist now. if not, we have a problem
502       // (e.g. if the user did xset fp rehash just when we were searching fonts).
503       // in that case, just return garbage.
504       bool ret = set_properties (p, f);
505       XFreeFont (DISPLAY, f);
506       return ret;
507     }
508   else
509     return false;
510 }
511
512 // fix the size of scalable fonts
513 static void
514 fix_scalable (char *buf, const char *name, const rxvt_fontprop &prop)
515 {
516   int slashes = 0;
517   const char *size;
518
519   for (const char *c = name; *c; c++)
520     if (*c == '-')
521       {
522         if (slashes == 6)
523           size = c + 1;
524
525         if (++slashes >= 13)
526           break;
527       }
528
529   if (slashes >= 13 && size[0] == '0')
530     {
531       strncpy (buf, name, size - name);
532       buf += size - name;
533       buf += sprintf (buf, "%d", prop.height);
534       strcpy (buf, size + 1);
535     }
536   else
537     strcpy (buf, name);
538 }
539
540 bool
541 rxvt_font_x11::load (const rxvt_fontprop &prop)
542 {
543   clear ();
544
545   char **list;
546   int count;
547   list = XListFonts (DISPLAY, name, 1024, &count);
548   set_name (0);
549
550   if (!list)
551     return false;
552
553   int bestdiff = 0x7fffffff;
554   for (int i = 0; i < count; i++)
555     {
556       rxvt_fontprop p;
557       char fname[1024];
558       fix_scalable (fname, list[i], prop);
559
560       if (!set_properties (p, fname))
561         continue;
562
563       if (p.height > prop.height) // weed out too large fonts
564         continue;
565
566       int diff = (prop.height - p.height) * 32
567                + abs (prop.weight - p.weight)
568                + abs (prop.slant  - p.slant );
569
570       if (!name // compare against best found so far
571           || diff < bestdiff)
572         {
573           set_name (strdup (fname));
574           bestdiff = diff;
575         }
576     }
577
578   XFreeFontNames (list);
579
580   if (!name)
581     return false;
582
583   f = XLoadQueryFont (DISPLAY, name);
584
585   if (!f)
586     return false;
587
588   char *registry = get_property (f, "CHARSET_REGISTRY", 0);
589   char *encoding = get_property (f, "CHARSET_ENCODING", 0);
590
591   if (registry && encoding)
592     {
593       char charset[64];
594       snprintf (charset, 64, "%s-%s", registry, encoding);
595
596       cs = codeset_from_name (charset);
597     }
598   else
599     {
600       const char *charset = get_property (f, "FONT", 0);
601
602       if (!charset)
603         charset = name;
604
605       int count = 13;
606       while (*charset)
607         if (*charset++ == '-' && !--count)
608           break;
609
610       cs = codeset_from_name (charset);
611     }
612
613   free (registry);
614   free (encoding);
615
616   if (cs == CS_UNICODE)
617     cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font
618
619   encm = f->min_byte1 != 0 || f->max_byte1 != 0;
620   enc2b = encm || f->max_char_or_byte2 > 255;
621
622   ascent = f->ascent;
623   descent = f->descent;
624   height = ascent + descent;
625
626   slow = false;
627
628   if (f->min_bounds.width == f->max_bounds.width)
629     width = f->min_bounds.width;
630   else if (f->per_char == NULL)
631     width = f->max_bounds.width;
632   else
633     {
634       slow = true;
635
636       int N = f->max_char_or_byte2 - f->min_char_or_byte2;
637
638       if (encm)
639         N += (f->max_byte1 - f->min_byte1)
640              * (f->max_char_or_byte2 - f->min_char_or_byte2 + 1);
641        
642       while (N)
643         {
644           if (f->per_char[N].width > width)
645             width = f->per_char[N].width;
646
647           --N;
648         }
649     }
650
651   if (cs == CS_UNKNOWN)
652     {
653       fprintf (stderr, "unable to deduce codeset, ignoring font '%s'\n", name);
654
655       clear ();
656
657       return false;
658     }
659
660   return true;
661 }
662
663 void
664 rxvt_font_x11::clear ()
665 {
666   if (f)
667     {
668       XFreeFont (DISPLAY, f);
669       f = 0;
670     }
671 }
672
673 bool
674 rxvt_font_x11::has_codepoint (unicode_t unicode)
675 {
676   uint32_t ch = FROM_UNICODE (cs, unicode);
677
678   if (ch == NOCHAR)
679     return false;
680
681   /* check wether the character exists in _this_ font. horrible. */
682   XCharStruct *xcs;
683
684   if (encm)
685     {
686       unsigned char byte1 = ch >> 8;
687       unsigned char byte2 = ch & 255;
688
689       if (byte1 < f->min_byte1 || byte1 > f->max_byte1
690           || byte2 < f->min_char_or_byte2 || byte2 > f->max_char_or_byte2)
691         return false;
692
693       if (!f->per_char)
694         return true;
695
696       int D = f->max_char_or_byte2 - f->min_char_or_byte2 + 1;
697       int N = (byte1 - f->min_byte1) * D + byte2 - f->min_char_or_byte2;
698
699       xcs = f->per_char + N;
700     }
701   else
702     {
703       if (ch < f->min_char_or_byte2 || ch > f->max_char_or_byte2)
704         return false;
705
706       if (!f->per_char)
707         return true;
708
709       xcs = f->per_char + (ch - f->min_char_or_byte2);
710     }
711
712   if (xcs->lbearing == 0 && xcs->rbearing == 0 && xcs->width == 0
713       && xcs->ascent == 0 && xcs->descent == 0)
714     return false;
715
716   return true;
717 }
718
719 void
720 rxvt_font_x11::draw (rxvt_drawable &d, int x, int y,
721                      const text_t *text, int len,
722                      int fg, int bg)
723 {
724   // this looks like a mess /.
725   // and it is a mess /.
726   // yet we are trying to be perfect /.
727   // but the result still isn't perfect /.
728
729   bool slow = this->slow
730               || width != r->TermWin.fwidth
731               || height != r->TermWin.fheight;
732
733   int base = r->TermWin.fbase;
734
735   XGCValues v;
736   v.foreground = r->pix_colors[fg];
737   v.font = f->fid;
738
739   if (enc2b)
740     {
741       const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
742
743       if (bg == Color_bg && !slow)
744         {
745           v.background = r->pix_colors[bg];
746           XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
747           XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);
748         }
749       else
750         {
751           clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
752
753           XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
754           
755           if (slow)
756             {
757               do
758                 {
759                   if (xc->byte1 || xc->byte2)
760                     XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);
761
762                   x += r->TermWin.fwidth;
763                   xc++; len--;
764                 }
765               while (len);
766             }
767           else
768             XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);
769         }
770     }
771   else
772     {
773       const char *xc = enc_char (text, len, cs, slow);
774
775       if (bg == Color_bg && !slow)
776         {
777           v.background = r->pix_colors[bg];
778           XChangeGC (d.display->display, TGC, GCForeground | GCBackground | GCFont, &v);
779           XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);
780         }
781       else
782         {
783           clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
784
785           XChangeGC (d.display->display, TGC, GCForeground | GCFont, &v);
786           
787           if (slow)
788             {
789               do
790                 {
791                   if (*xc)
792                     XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);
793
794                   x += r->TermWin.fwidth;
795                   xc++; len--;
796                 }
797               while (len);
798             }
799           else
800             XDrawString (d.display->display, d, TGC, x, y + base, xc, len);
801         }
802     }
803 }
804
805 /////////////////////////////////////////////////////////////////////////////
806
807 #if XFT
808 #if 0
809 #define UNIBITS 21
810 //#define SWATHBITS (UNIBITS / 2 + 3) // minimum size for "full" tables
811 #define SWATHBITS 8
812 #endif
813
814 struct rxvt_font_xft : rxvt_font {
815   rxvt_font_xft () { f = 0; }
816
817   void clear ();
818
819   rxvt_fontprop properties ();
820
821   bool load (const rxvt_fontprop &prop);
822
823   void draw (rxvt_drawable &d, int x, int y,
824              const text_t *text, int len,
825              int fg, int bg);
826
827   bool has_codepoint (unicode_t unicode);
828
829 protected:
830   XftFont *f;
831 };
832
833 void
834 rxvt_font_xft::clear ()
835 {
836   if (f)
837     {
838       XftFontClose (DISPLAY, f);
839       f = 0;
840     }
841 }
842
843 rxvt_fontprop
844 rxvt_font_xft::properties ()
845 {
846   rxvt_fontprop p;
847
848   FT_Face face = XftLockFace (f);
849
850   p.width  = width;
851   p.height = height;
852   p.weight = face->style_flags & FT_STYLE_FLAG_BOLD
853                ? rxvt_fontprop::bold : rxvt_fontprop::medium;
854   p.slant  = face->style_flags & FT_STYLE_FLAG_ITALIC
855                ? rxvt_fontprop::italic : rxvt_fontprop::roman;
856
857   XftUnlockFace (f);
858
859   return p;
860 }
861
862 bool
863 rxvt_font_xft::load (const rxvt_fontprop &prop)
864 {
865 #if 0
866   for (int i = 0; i < SWATHCOUNT; i++)
867     cvr[i] = 0;
868 #endif
869
870   clear ();
871
872   FcPattern *p = FcNameParse ((FcChar8 *) name);
873
874   if (!p)
875     return false;
876
877   FcValue v;
878
879   if (FcPatternGet (p, FC_PIXEL_SIZE, 0, &v) != FcResultMatch)
880     FcPatternAddInteger (p, FC_PIXEL_SIZE, prop.height);
881
882   if (FcPatternGet (p, FC_WEIGHT, 0, &v) != FcResultMatch)
883     FcPatternAddInteger (p, FC_WEIGHT, prop.weight);
884
885   if (FcPatternGet (p, FC_SLANT, 0, &v) != FcResultMatch)
886     FcPatternAddInteger (p, FC_SLANT, prop.slant);
887
888   if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)
889     FcPatternAddBool (p, FC_MINSPACE, 1);
890
891 #if 0 // clipping unfortunately destroys our precious double-width-characters
892   // clip width, we can't do better, or can we?
893   if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
894     FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
895 #endif
896
897   XftResult result;
898   FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);
899
900   FcPatternDestroy (p);
901
902   if (!match)
903     return false;
904
905   f = XftFontOpenPattern (DISPLAY, match);
906
907   if (!f)
908     {
909       FcPatternDestroy (match);
910       return false;
911     }
912
913   FT_Face face = XftLockFace (f);
914
915   slow = !FT_IS_FIXED_WIDTH (face);
916
917   int ftheight = 0;
918
919   for (;;)
920     {
921       XGlyphInfo g1, g2;
922       FcChar8 c;
923
924       c = 'i'; XftTextExtents8 (DISPLAY, f, &c, 1, &g1);
925       c = 'W'; XftTextExtents8 (DISPLAY, f, &c, 1, &g2);
926
927       if (g1.xOff != g2.xOff) // don't simply trust the font
928         slow = true;
929
930       width = g2.xOff;
931       ascent = (face->size->metrics.ascender + 63) >> 6;
932       descent = (-face->size->metrics.descender + 63) >> 6;
933       height = ascent + descent;
934
935       if (height <= prop.height || !prop.height)
936         break;
937
938       if (ftheight)
939         {
940           // take smaller steps near the end
941           if (height > prop.height + 1) ftheight++;
942           if (height > prop.height + 2) ftheight++;
943           if (height > prop.height + 3) ftheight++;
944
945           FT_Set_Pixel_Sizes (face, 0, ftheight -= height - prop.height);
946         }
947       else
948         FT_Set_Pixel_Sizes (face, 0, ftheight = prop.height);
949     }
950
951   XftUnlockFace (f);
952
953   return true;
954 }
955
956 bool
957 rxvt_font_xft::has_codepoint (unicode_t unicode)
958 {
959   return XftCharExists (DISPLAY, f, unicode);
960 }
961
962 void
963 rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
964                      const text_t *text, int len,
965                      int fg, int bg)
966 {
967   clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
968
969   if (!slow && width == r->TermWin.fwidth && 0)
970     {
971       if (sizeof (text_t) == sizeof (FcChar16))
972         XftDrawString16 (d, &r->pix_colors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar16 *)text, len);
973       else
974         XftDrawString32 (d, &r->pix_colors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar32 *)text, len);
975     }
976   else
977     {
978       while (len)
979         {
980           if (*text != NOCHAR && *text != ' ')
981             {
982               int fwidth = r->TermWin.fwidth;
983               if (len >= 2 && text[1] == NOCHAR)
984                 fwidth *= 2;
985
986               XGlyphInfo extents;
987               if (sizeof (text_t) == sizeof (FcChar16))
988                 {
989                   XftTextExtents16 (d.display->display, f, (const FcChar16 *)text, 1, &extents);
990                   XftDrawString16 (d, &r->pix_colors[fg].c, f, x + extents.x + (fwidth - extents.width) / 2,
991                                    y + r->TermWin.fbase, (const FcChar16 *)text, 1);
992                 }
993               else
994                 {
995                   XGlyphInfo extents;
996                   XftTextExtents32 (d.display->display, f, (const FcChar32 *)text, 1, &extents);
997                   XftDrawString32 (d, &r->pix_colors[fg].c, f, x + extents.x + (fwidth - extents.width) / 2,
998                                    y + r->TermWin.fbase, (const FcChar32 *)text, 1);
999                 }
1000             }
1001
1002           x += r->TermWin.fwidth;
1003           text++;
1004           len--;
1005         }
1006     }
1007 }
1008 #endif
1009
1010 /////////////////////////////////////////////////////////////////////////////
1011
1012 rxvt_fontset::rxvt_fontset (rxvt_t r)
1013 : r (r), fontdesc (0)
1014 {
1015   clear ();
1016 }
1017
1018 rxvt_fontset::~rxvt_fontset ()
1019 {
1020   clear ();
1021 }
1022
1023 void
1024 rxvt_fontset::clear ()
1025 {
1026   for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
1027     FONT_UNREF (*i);
1028
1029   free (fontdesc); fontdesc = 0;
1030
1031   fonts.clear ();
1032   base_id = 0;
1033   base_prop.height = 0x7fffffff;
1034   base_prop.weight = rxvt_fontprop::medium;
1035   base_prop.slant = rxvt_fontprop::roman;
1036
1037   fallback = fallback_fonts;
1038 }
1039
1040 rxvt_font *
1041 rxvt_fontset::new_font (const char *name, codeset cs)
1042 {
1043   rxvt_font *f;
1044   
1045   if (!name || !*name)
1046     {
1047       name = "";
1048       f = new rxvt_font_default;
1049     }
1050 #if XFT
1051   else if (!strncmp (name, "xft:", 4))
1052     {
1053       name += 4;
1054       f = new rxvt_font_xft;
1055     }
1056 #endif
1057   else if (!strncmp (name, "x:", 2))
1058     {
1059       name += 2;
1060       f = new rxvt_font_x11;
1061     }
1062   else
1063     f = new rxvt_font_x11;
1064
1065   f->fs = this;
1066   f->set_term (r);
1067   f->set_name (strdup (name));
1068
1069   f->cs = cs;
1070   f->loaded = false;
1071
1072   return f;
1073 }
1074
1075 /////////////////////////////////////////////////////////////////////////////
1076
1077 void
1078 rxvt_fontset::add_fonts (const char *desc)
1079 {
1080   if (desc)
1081     {
1082       char buf[512];
1083       const char *end;
1084
1085       do
1086         {
1087           while (*desc <= ' ') desc++;
1088
1089           if (*desc == '[')
1090             {
1091               fprintf (stderr, "extra font parameters not yet supported, skipping.\n");
1092
1093               //const char *extra = desc++; // not yet used
1094
1095               desc = strchr (desc, ']');
1096
1097               if (!desc)
1098                 {
1099                   fprintf (stderr, "ERROR: opening '[' without closing ']' in font specification.\n");
1100                   break;
1101                 }
1102
1103               desc++;
1104               while (*desc <= ' ') desc++;
1105             }
1106
1107           end = strchr (desc, ',');
1108           if (!end)
1109             end = desc + strlen (desc);
1110
1111           if (end - desc < 511)
1112             {
1113               strncpy (buf, desc, end - desc);
1114               buf[end - desc] = 0;
1115
1116               fonts.push_back (new_font (buf, CS_UNICODE));
1117             }
1118
1119           desc = end + 1;
1120         }
1121       while (*end);
1122     }
1123 }
1124
1125 bool
1126 rxvt_fontset::realize_font (int i)
1127 {
1128   if (fonts[i]->loaded)
1129     return true;
1130
1131   fonts[i]->loaded = true;
1132
1133   if (!fonts[i]->load (base_prop))
1134     {
1135       fonts[i]->cs = CS_UNKNOWN;
1136       return false;
1137     }
1138
1139   return true;
1140 }
1141
1142 bool
1143 rxvt_fontset::populate (const char *desc)
1144 {
1145   clear ();
1146
1147   fontdesc = strdup (desc);
1148
1149   fonts.push_back (new_font (0, CS_UNICODE));
1150   realize_font (0);
1151
1152   add_fonts (desc);
1153
1154   if (!base_id)
1155     base_id = 1;
1156
1157   // we currently need a base-font, no matter what
1158   if ((int)fonts.size () <= base_id || !realize_font (base_id))
1159     {
1160       puts ("unable to load specified font (s), falling back to 'fixed'\n");
1161       add_fonts ("fixed");
1162       base_id = fonts.size () - 1;
1163     }
1164
1165   if ((int)fonts.size () <= base_id || !realize_font (base_id))
1166     return false;
1167
1168   base_prop = fonts[base_id]->properties ();
1169
1170   return true;
1171 }
1172
1173 int
1174 rxvt_fontset::find_font (const char *name) const
1175 {
1176   for (rxvt_font *const *f = fonts.begin (); f < fonts.end (); f++)
1177     if ((*f)->name && !strcmp ((*f)->name, name))
1178       return f - fonts.begin ();
1179
1180   return -1;
1181 }
1182
1183 int
1184 rxvt_fontset::find_font (unicode_t unicode, bool bold)
1185 {
1186
1187   for (unsigned int i = !!(0x20 <= unicode && unicode <= 0x7f); // skip pseudo-font for ascii
1188        i < fonts.size ();
1189        i++)
1190     {
1191       rxvt_font *f = fonts[i];
1192
1193       if (!f->loaded)
1194         {
1195           if (FROM_UNICODE (f->cs, unicode) == NOCHAR)
1196             goto next_font;
1197
1198           if (!realize_font (i))
1199             goto next_font;
1200         }
1201
1202       if (f->cs == CS_UNKNOWN)
1203         goto next_font;
1204
1205       if (bold && f->properties ().weight < rxvt_fontprop::bold)
1206         goto next_font;
1207
1208       if (f->has_codepoint (unicode))
1209         return i;
1210
1211     next_font:
1212       if (i == fonts.size () - 1)
1213         {
1214           if (fallback->name)
1215             {
1216               // search through the fallback list
1217               fonts.push_back (new_font (fallback->name, fallback->cs));
1218               fallback++;
1219             }
1220           else if (!bold)
1221             {
1222               // try to find a new font.
1223               // only xft currently supported, as there is no
1224               // way to configure this and xft is easier to hack in,
1225               // while x11 has more framework in place already.
1226 #if XFT
1227               // grab the first xft font that seems suitable
1228               FcPattern *p = FcPatternCreate ();
1229
1230               FcCharSet *s = FcCharSetCreate ();
1231               FcCharSetAddChar (s, unicode);
1232               FcPatternAddCharSet (p, FC_CHARSET, s);
1233               // charsets don't help that much, as xft might return
1234               // a non-matching font even if a better font is available :/
1235
1236               FcPatternAddInteger (p, FC_PIXEL_SIZE, base_prop.height);
1237               FcPatternAddInteger (p, FC_WEIGHT, base_prop.weight);
1238               FcPatternAddInteger (p, FC_SLANT, base_prop.slant);
1239               FcPatternAddBool    (p, FC_MINSPACE, 1);
1240               //FcPatternAddBool    (p, FC_ANTIALIAS, 1);
1241
1242               XftResult result;
1243               FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);
1244
1245               FcPatternDestroy (p);
1246
1247               if (match)
1248                 {
1249                   FcPatternDel (match, FC_CHARSET);
1250                   char *font = (char *)FcNameUnparse (match);
1251                   FcPatternDestroy (match);
1252
1253                   if (find_font (font) < 0)
1254                     {
1255                       char fontname[4096];
1256                       sprintf (fontname, "xft:%-.4090s", font);
1257
1258                       fonts.push_back (new_font (fontname, CS_UNICODE)); 
1259                     }
1260
1261                   free (font);
1262                 }
1263 #endif
1264             }
1265         }
1266     }
1267
1268   // if no bold font found, use a regular one
1269   if (bold)
1270     return find_font (unicode);
1271
1272   return 0; /* we must return SOME font */
1273 }
1274
1275
1276