[ViewVC] Diff of: cvs/rxvt-unicode/src/rxvtfont.C

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.133 by root, Wed Jan 23 06:49:30 2008 UTC vs.
Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC

…		…
1	/----------------------------------------------------------------------	1	/----------------------------------------------------------------------
2	* File: rxvtfont.C	2	* File: rxvtfont.C
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	* Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>	4	* Copyright (c) 2003-2008 Marc Lehmann <schmorp@schmorp.de>
5	* - original version.	5	* - original version.
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	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	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	9	* the Free Software Foundation; either version 3 of the License, or
10	* (at your option) any later version.	10	* (at your option) any later version.
11	*	11	*
12	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22	#include "../config.h"	22	#include "../config.h"
23	#include "rxvt.h"	23	#include "rxvt.h"
24	#include "rxvtutil.h"	24	#include "rxvtutil.h"
25	#include "rxvtfont.h"	25	#include "rxvtfont.h"
26		26
27	#include <cstdlib>	27	#include <stdlib.h>
28		28
29	#include <inttypes.h>	29	#include <inttypes.h>
		30
		31	#if XFT
		32	# include <fontconfig/fontconfig.h>
		33	#endif
30		34
31	#define MAX_OVERLAP_ROMAN (8 + 2) // max. character width in 8ths of the base width	35	#define MAX_OVERLAP_ROMAN (8 + 2) // max. character width in 8ths of the base width
32	#define MAX_OVERLAP_ITALIC (8 + 3) // max. overlap for italic fonts	36	#define MAX_OVERLAP_ITALIC (8 + 3) // max. overlap for italic fonts
33		37
34	#define OVERLAP_OK(w,wcw,prop) ((w) <= ( \	38	#define OVERLAP_OK(w,wcw,prop) ((w) <= ( \
35	(prop)->slant >= rxvt_fontprop::italic \	39	(prop)->slant >= rxvt_fontprop::italic \
36	? ((prop)->width * (wcw) * MAX_OVERLAP_ITALIC + 7) >> 3 \	40	? ((prop)->width * (wcw) * MAX_OVERLAP_ITALIC + 7) >> 3 \
37	: ((prop)->width * (wcw) * MAX_OVERLAP_ROMAN + 7) >> 3 \	41	: ((prop)->width * (wcw) * MAX_OVERLAP_ROMAN + 7) >> 3 \
38	))	42	))
39		43
40	const struct rxvt_fallback_font {	44	static const struct rxvt_fallback_font {
41	codeset cs;	45	codeset cs;
42	const char *name;	46	const char *name;
43	} fallback_fonts[] = {	47	} fallback_fonts[] = {
44	{ CS_ISO8859_1, "----r-------c-*-iso8859-1" },	48	{ CS_ISO8859_1, "----r-------c-*-iso8859-1" },
45	{ CS_ISO8859_15, "----r-------c-*-iso8859-15" },	49	{ CS_ISO8859_15, "----r-------c-*-iso8859-15" },
…		…
79		83
80	// japanese	84	// japanese
81	#if ENCODING_JP \|\| ENCODING_JP_EXT	85	#if ENCODING_JP \|\| ENCODING_JP_EXT
82	# if XFT	86	# if XFT
83	// prefer xft for complex scripts	87	// prefer xft for complex scripts
		88	{ CS_JIS0208_1990_0, "xft:Sazanami Mincho:antialias=false" },
84	{ CS_JIS0208_1990_0, "xft:Kochi Gothic:antialias=false" },	89	{ CS_JIS0208_1990_0, "xft:Kochi Gothic:antialias=false" },
85	{ CS_JIS0208_1990_0, "xft:Sazanami Mincho:antialias=false" },
86	{ CS_JIS0208_1990_0, "xft:Mincho:antialias=false" },	90	{ CS_JIS0208_1990_0, "xft:Mincho:antialias=false" },
87	{ CS_JIS0208_1990_0, "xft::lang=ja:antialias=false" },	91	{ CS_JIS0208_1990_0, "xft::lang=ja:antialias=false" },
88	# endif	92	# endif
89	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },	93	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },
90	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },	94	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },
…		…
128	{ CS_KSC5601_1987_0, "xft:Baekmuk Gulim:antialias=false" },	132	{ CS_KSC5601_1987_0, "xft:Baekmuk Gulim:antialias=false" },
129	{ CS_KSC5601_1987_0, "xft::lang=ko:antialias=false" },	133	{ CS_KSC5601_1987_0, "xft::lang=ko:antialias=false" },
130	# endif	134	# endif
131	#endif	135	#endif
132		136
133	{ CS_UNICODE, "--lucidatypewriter---------m--iso10646-1" },
134	//{ CS_UNICODE, "--unifont---------c--iso10646-1" }, // this gem of a font has actual dotted circles within the combining character glyphs.	137	//{ CS_UNICODE, "--unifont---------c--iso10646-1" }, // this gem of a font has actual dotted circles within the combining character glyphs.
135	#if XFT	138	#if XFT
136	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },	139	{ CS_UNICODE, "xft:DejaVu Sans Mono:antialias=false:autohint=true" },
137	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },	140	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },
138	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },	141	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },
139	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false:autohint=false" },	142	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false:autohint=false" },
140		143
141	// FreeMono is usually uglier than x fonts, so try after the others	144	// FreeMono is usually uglier than x fonts, so try after the others
142	{ CS_UNICODE, "xft:FreeMono:autohint=true" },	145	{ CS_UNICODE, "xft:FreeMono:autohint=true" },
143	#endif	146	#endif
144		147
…		…
155	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',	158	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',
156	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ	159	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ
157	0x304c, 0x672c, // が本	160	0x304c, 0x672c, // が本
158	};	161	};
159		162
160	#define NUM_EXTENT_TEST_CHARS (sizeof (extent_test_chars) / sizeof (extent_test_chars[0]))
161
162	#define dTermDisplay Display *disp = term->dpy	163	#define dTermDisplay Display *disp = term->dpy
163	#define dTermGC GC gc = term->gc	164	#define dTermGC GC gc = term->gc
164		165
165	/////////////////////////////////////////////////////////////////////////////	166	/////////////////////////////////////////////////////////////////////////////
166		167
…		…
216	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset)	217	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset)
217	{	218	{
218	}	219	}
219		220
220	void	221	void
221	rxvt_font::set_name (char *name)	222	rxvt_font::set_name (char *name_)
222	{	223	{
223	if (this->name == name)	224	if (name == name_)
224	return;	225	return;
225		226
226	if (this->name) free (this->name); // let the compiler optimize	227	if (name) free (name); // let the compiler optimize
227	this->name = name;	228	name = name_;
228	}	229	}
229		230
230	void	231	void
231	rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color) const	232	rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color) const
232	{	233	{
…		…
236	if (color == Color_bg \|\| color == Color_transparent)	237	if (color == Color_bg \|\| color == Color_transparent)
237	XClearArea (disp, d, x, y, w, h, false);	238	XClearArea (disp, d, x, y, w, h, false);
238	else if (color >= 0)	239	else if (color >= 0)
239	{	240	{
240	#if XFT	241	#if XFT
241	bool done = false;	242	Picture dst;
242		243
243	# ifdef HAVE_BG_PIXMAP	244	# ifdef HAVE_IMG
244	if (term->bgPixmap.pixmap && color >= 0 && !term->pix_colors[color].is_opaque ())	245	if (term->bg_img
245	{	246	&& !term->pix_colors[color].is_opaque ()
246	Picture dst = XftDrawPicture (d);	247	&& ((dst = XftDrawPicture (d))))
247
248	if (dst != 0)
249	{	248	{
250	XClearArea (disp, d, x, y, w, h, false);	249	XClearArea (disp, d, x, y, w, h, false);
		250
251	Picture solid_color_pict = XftDrawSrcPicture (d, &term->pix_colors[color].c);	251	Picture solid_color_pict = XftDrawSrcPicture (d, &term->pix_colors[color].c);
252	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, x, y, w, h);	252	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, x, y, w, h);
253	done = true;
254	}	253	}
255	}	254	else
256	# endif	255	# endif
257	if (!done)
258	XftDrawRect (d, &term->pix_colors[color].c, x, y, w, h);	256	XftDrawRect (d, &term->pix_colors[color].c, x, y, w, h);
259		257
260	#else	258	#else
261	XSetForeground (disp, gc, term->pix_colors[color]);	259	XSetForeground (disp, gc, term->pix_colors[color]);
262	XFillRectangle (disp, d, gc, x, y, w, h);	260	XFillRectangle (disp, d, gc, x, y, w, h);
…		…
264	}	262	}
265	}	263	}
266		264
267	/////////////////////////////////////////////////////////////////////////////	265	/////////////////////////////////////////////////////////////////////////////
268		266
269	struct rxvt_font_default : rxvt_font {	267	struct rxvt_font_default : rxvt_font
		268	{
270	struct rxvt_fontset *fs;	269	struct rxvt_fontset *fs;
271		270
272	rxvt_font_default (rxvt_fontset *fs)	271	rxvt_font_default (rxvt_fontset *fs)
273	: rxvt_font ()	272	: rxvt_font ()
274	{	273	{
…		…
314	if (unicode >= 0x2500 && unicode <= 0x259f &&	313	if (unicode >= 0x2500 && unicode <= 0x259f &&
315	!term->option (Opt_skipBuiltinGlyphs))	314	!term->option (Opt_skipBuiltinGlyphs))
316	return true;	315	return true;
317	#endif	316	#endif
318		317
319	if (IS_COMPOSE (unicode))	318	// we do not check for IS_COMPOSE here, as this would
320	return true;	319	// rob other fonts from taking over.
321		320
322	switch (unicode)	321	switch (unicode)
323	{	322	{
324	case ZERO_WIDTH_CHAR:	323	case ZERO_WIDTH_CHAR:
325	case NOCHAR:	324	case NOCHAR:
…		…
346		345
347	XSetForeground (disp, gc, term->pix_colors[fg]);	346	XSetForeground (disp, gc, term->pix_colors[fg]);
348		347
349	while (len)	348	while (len)
350	{	349	{
		350	const text_t *tp = text;
		351	text_t t = *tp;
		352
		353	while (++text, --len && *text == NOCHAR)
		354	;
		355
351	#if ENABLE_COMBINING	356	#if ENABLE_COMBINING
352	compose_char *cc;	357	compose_char *cc;
353	#endif	358	#endif
354	const text_t *tp = text;
355	text_t t = *tp;
356
357	while (++text, --len && *text == NOCHAR)
358	;
359
360	int width = text - tp;	359	int width = text - tp;
361	int fwidth = term->fwidth * width;	360	int fwidth = term->fwidth * width;
362		361
363	#ifdef BUILTIN_GLYPHS	362	#ifdef BUILTIN_GLYPHS
364	if (0x2500 <= t && t <= 0x259f)	363	if (0x2500 <= t && t <= 0x259f)
…		…
446	#endif	445	#endif
447	#if ENABLE_COMBINING	446	#if ENABLE_COMBINING
448	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))	447	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
449	{	448	{
450	min_it (width, 2); // we only support wcwidth up to 2	449	min_it (width, 2); // we only support wcwidth up to 2
451
452	text_t chrs[2];	450	text_t chrs[2];
453	chrs [1] = NOCHAR;	451	chrs [1] = NOCHAR;
454		452
455	*chrs = cc->c1;	453	*chrs = cc->c1;
456	rxvt_font f1 = (fs)[fs->find_font (cc->c1)];	454	rxvt_font f1 = (fs)[fs->find_font_idx (cc->c1)];
457	f1->draw (d, x, y, chrs, width, fg, bg);	455	f1->draw (d, x, y, chrs, width, fg, bg);
458		456
459	if (cc->c2 != NOCHAR)	457	if (cc->c2 != NOCHAR)
460	{	458	{
461	bool careful;	459	bool careful;
462		460
463	// prefer font of first character, for no good reasons	461	// prefer font of first character, for no good reasons
464	*chrs = cc->c2;	462	*chrs = cc->c2;
465	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)	463	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)
466	? f1	464	? f1
467	: (*fs)[fs->find_font (cc->c2)];	465	: (*fs)[fs->find_font_idx (cc->c2)];
468		466
469	f2->draw (d, x, y, chrs, width, fg, Color_none);	467	f2->draw (d, x, y, chrs, width, fg, Color_none);
470	}	468	}
471	}	469	}
472	#endif	470	#endif
…		…
476	case '\t':	474	case '\t':
477	case ZERO_WIDTH_CHAR:	475	case ZERO_WIDTH_CHAR:
478	case NOCHAR:	476	case NOCHAR:
479	break;	477	break;
480		478
		479	/*
		480	* If the base font does not support variation selectors, treat them as ZWC.
		481	* a point could be made to do this for all wcwidth == 0 characters, but I
		482	* decided against that until more data is available.
		483	*/
		484	case 0xfe00: case 0xfe01: case 0xfe02: case 0xfe03: case 0xfe04: case 0xfe05: case 0xfe06: case 0xfe07:
		485	case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b: case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
		486	break;
		487
481	default:	488	default:
482	XDrawRectangle (disp, d, gc, x + 2, y + 2,	489	XDrawRectangle (disp, d, gc, x + 2, y + 2,
483	fwidth - 4, term->fheight - 4);	490	fwidth - 4, term->fheight - 4);
484	}	491	}
485		492
486	x += fwidth;	493	x += fwidth;
487	}	494	}
488	}	495	}
489		496
		497	struct rxvt_font_overflow : rxvt_font
		498	{
		499	struct rxvt_fontset *fs;
		500
		501	rxvt_font_overflow (rxvt_fontset *fs)
		502	: rxvt_font ()
		503	{
		504	this->fs = fs;
		505	}
		506
		507	rxvt_fontprop properties ()
		508	{
		509	rxvt_fontprop p;
		510
		511	p.width = p.height = 1;
		512	p.ascent = rxvt_fontprop::unset;
		513	p.weight = rxvt_fontprop::medium;
		514	p.slant = rxvt_fontprop::roman;
		515
		516	return p;
		517	}
		518
		519	bool load (const rxvt_fontprop &prop, bool force_prop)
		520	{
		521	width = 1; height = 1;
		522	ascent = 1; descent = 0;
		523
		524	set_name (strdup ("built-in rendition overflow font"));
		525
		526	return true;
		527	}
		528
		529	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
		530	{
		531	return false;
		532	}
		533
		534	void draw (rxvt_drawable &d, int x, int y,
		535	const text_t *text, int len,
		536	int fg, int bg)
		537	{
		538	while (len)
		539	{
		540	int fid = fs->find_font_idx (*text);
		541	int w = 1;
		542	while (w < len && text[w] == NOCHAR)
		543	w++;
		544	(*fs)[fid]->draw (d, x, y, text, w, fg, bg);
		545	text += w;
		546	len -= w;
		547	x += term->fwidth * w;
		548	}
		549	}
		550	};
		551
490	/////////////////////////////////////////////////////////////////////////////	552	/////////////////////////////////////////////////////////////////////////////
491		553
492	struct rxvt_font_x11 : rxvt_font {	554	struct rxvt_font_x11 : rxvt_font
		555	{
493	rxvt_font_x11 () { f = 0; }	556	rxvt_font_x11 () { f = 0; }
494		557
495	void clear ();	558	void clear ();
496		559
497	rxvt_fontprop properties ();	560	rxvt_fontprop properties ();
…		…
502		565
503	void draw (rxvt_drawable &d, int x, int y,	566	void draw (rxvt_drawable &d, int x, int y,
504	const text_t *text, int len,	567	const text_t *text, int len,
505	int fg, int bg);	568	int fg, int bg);
506		569
507	bool slow; // wether this is a proportional font or has other funny characteristics	570	bool slow; // whether this is a proportional font or has other funny characteristics
508	XFontStruct *f;	571	XFontStruct *f;
509	bool enc2b, encm;	572	bool enc2b, encm;
510		573
511	char get_property (XFontStruct f, Atom property, const char *repl) const;	574	char get_property (XFontStruct f, Atom property, const char *repl) const;
512	bool set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth);	575	bool set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth);
…		…
669	f = XLoadQueryFont (disp, name);	732	f = XLoadQueryFont (disp, name);
670		733
671	if (!f)	734	if (!f)
672	return false;	735	return false;
673		736
674	char *new_name = get_property (f, XA_FONT, name);	737	char *new_name = get_property (f, XA_FONT, 0);
675		738
676	if (new_name)	739	if (new_name)
677	set_name (new_name);	740	set_name (new_name);
678	else	741	else
679	rxvt_warn ("font '%s' has no FONT property, continuing without.", name);	742	rxvt_warn ("font '%s' has no FONT property, continuing without.\n", name);
680		743
681	XFreeFont (disp, f);	744	XFreeFont (disp, f);
682	f = 0;	745	f = 0;
683	}	746	}
684		747
…		…
741	free (fname);	804	free (fname);
742	if (replace_field (&fname, list[i], 11, '0', "0"))	805	if (replace_field (&fname, list[i], 11, '0', "0"))
743	diff += 300; // more heavily penalize what looks like scaled bitmap fonts	806	diff += 300; // more heavily penalize what looks like scaled bitmap fonts
744	}	807	}
745		808
746	if (!set_properties (p, fname))	809	if (!set_properties (p, fname)
		810	// also weed out too large fonts
		811	\|\| (prop.height != rxvt_fontprop::unset
		812	&& p.height > prop.height))
		813	{
		814	free (fname);
747	continue;	815	continue;
748		816	}
749	if (prop.height != rxvt_fontprop::unset
750	&& p.height > prop.height) // weed out too large fonts
751	continue;
752		817
753	if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;	818	if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;
754	if (prop.weight != rxvt_fontprop::unset) diff += abs (prop.weight - p.weight);	819	if (prop.weight != rxvt_fontprop::unset) diff += abs (prop.weight - p.weight);
755	if (prop.slant != rxvt_fontprop::unset) diff += abs (prop.slant - p.slant);	820	if (prop.slant != rxvt_fontprop::unset) diff += abs (prop.slant - p.slant);
756	//if (prop.width != rxvt_fontprop::unset) diff += abs (prop.width - p.width);	821	//if (prop.width != rxvt_fontprop::unset) diff += abs (prop.width - p.width);
…		…
762	XFreeFontNames (list);	827	XFreeFontNames (list);
763		828
764	// this loop only iterates when the guessed font-size is too small	829	// this loop only iterates when the guessed font-size is too small
765	for (;;)	830	for (;;)
766	{	831	{
767	font_weight *best = fonts + count - 1;	832	font_weight *best = fonts;
768		833
769	for (font_weight *w = best; w-- > fonts; )	834	for (font_weight *w = fonts + 1; w < fonts + count; w++)
770	if (w->diff <= best->diff)	835	if (w->diff < best->diff)
771	best = w;	836	best = w;
772		837
773	if (!best->name	838	if (!best->name
774	\|\| !(f = XLoadQueryFont (disp, best->name)))	839	\|\| !(f = XLoadQueryFont (disp, best->name)))
775	break;	840	break;
…		…
795	return false;	860	return false;
796		861
797	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);	862	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);
798	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);	863	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);
799		864
		865	cs = CS_UNKNOWN;
		866
800	if (registry && encoding)	867	if (registry && encoding)
801	{	868	{
802	char charset[64];	869	char charset[64];
803	snprintf (charset, 64, "%s-%s", registry, encoding);	870	snprintf (charset, 64, "%s-%s", registry, encoding);
804		871
805	cs = codeset_from_name (charset);	872	cs = codeset_from_name (charset);
806	}	873
807	else	874	if (cs == CS_UNKNOWN)
		875	rxvt_warn ("%s: cannot deduce encoding from registry/encoding properties \"%s\", ignoring font.\n", name, charset);
808	{	876	}
		877
		878	free (registry);
		879	free (encoding);
		880
		881	if (cs == CS_UNKNOWN)
		882	{
809	const char *charset = get_property (f, XA_FONT, 0);	883	char *value = get_property (f, XA_FONT, 0);
		884	const char *charset = value;
810		885
811	if (!charset)	886	if (!charset)
812	charset = name;	887	charset = name;
813		888
814	int count = 13;	889	int count = 13;
815	while (*charset)	890	while (*charset)
816	if (*charset++ == '-' && !--count)	891	if (*charset++ == '-' && !--count)
817	break;	892	break;
818		893
819	cs = codeset_from_name (charset);	894	cs = codeset_from_name (charset);
		895	if (cs == CS_UNKNOWN)
		896	rxvt_warn ("%s: cannot deduce encoding from font name property \"%s\", ignoring font.\n", name, charset);
		897
		898	free (value);
		899	}
		900
		901	if (cs == CS_UNKNOWN)
820	}	902	{
821		903	clear ();
822	free (registry);	904	return false;
823	free (encoding);	905	}
824		906
825	if (cs == CS_UNICODE)	907	if (cs == CS_UNICODE)
826	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font	908	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font
827		909
828	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;	910	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;
…		…
853	}	935	}
854	#endif	936	#endif
855		937
856	width = 1;	938	width = 1;
857		939
858	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	940	for (uint16_t *t = extent_test_chars; t < extent_test_chars + ecb_array_length (extent_test_chars); t++)
859	{	941	{
860	if (FROM_UNICODE (cs, *t) == NOCHAR)	942	if (FROM_UNICODE (cs, *t) == NOCHAR)
861	continue;	943	continue;
862		944
863	// ignore characters we wouldn't use anyways	945	// ignore characters we wouldn't use anyways
864	bool careful;	946	bool careful;
865	if (!has_char (*t, &prop, careful))	947	if (!has_char (*t, &prop, careful))
866	continue;	948	continue;
867		949
868	XChar2b ch = { t >> 8, t };	950	// the casts are needed in C++11 (see 8.5.1)
		951	XChar2b ch = { (unsigned char)(t >> 8), (unsigned char)t };
869		952
870	XCharStruct g;	953	XCharStruct g;
871	int dir_ret, asc_ret, des_ret;	954	int dir_ret, asc_ret, des_ret;
872	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);	955	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);
873		956
…		…
875	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;	958	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;
876		959
877	if (width < g.width) width = g.width;	960	if (width < g.width) width = g.width;
878	}	961	}
879		962
880	if (cs == CS_UNKNOWN)	963	#if 0 // do it per-character
		964	if (prop && width > prop->width)
881	{	965	{
882	fprintf (stderr, "unable to deduce codeset, ignoring font '%s'\n", name);
883
884	clear ();	966	clear ();
885	return false;	967	return false;
886	}	968	}
887
888	#if 0 // do it per-character
889	if (prop && width > prop->width)
890	{
891	clear ();
892	return false;
893	}
894	#endif	969	#endif
895		970
896	return true;	971	return true;
897	}	972	}
898		973
…		…
907	}	982	}
908		983
909	bool	984	bool
910	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	985	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
911	{	986	{
		987	careful = false;
		988
912	uint32_t ch = FROM_UNICODE (cs, unicode);	989	uint32_t ch = FROM_UNICODE (cs, unicode);
913		990
914	if (ch == NOCHAR)	991	if (ch == NOCHAR)
915	return false;	992	return false;
916		993
917	/* check wether the character exists in _this_ font. horrible. */	994	/* check whether the character exists in _this_ font. horrible. */
918	XCharStruct *xcs;	995	XCharStruct *xcs;
919		996
920	if (encm)	997	if (encm)
921	{	998	{
922	unsigned char byte1 = ch >> 8;	999	unsigned char byte1 = ch >> 8;
…		…
952	return false;	1029	return false;
953		1030
954	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1031	if (!prop \|\| prop->width == rxvt_fontprop::unset)
955	return true;	1032	return true;
956		1033
957	// check wether character overlaps previous/next character	1034	// check whether character overlaps previous/next character
958	int w = xcs->rbearing - xcs->lbearing;	1035	int w = xcs->rbearing - xcs->lbearing;
959	int wcw = max (WCWIDTH (unicode), 1);	1036	int wcw = max (WCWIDTH (unicode), 1);
960		1037
961	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;	1038	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;
962		1039
…		…
979	dTermDisplay;	1056	dTermDisplay;
980	dTermGC;	1057	dTermGC;
981		1058
982	bool slow = this->slow	1059	bool slow = this->slow
983	\|\| width != term->fwidth	1060	\|\| width != term->fwidth
984	\|\| height != term->fheight;	1061	\|\| height != term->fheight
		1062	\|\| ascent != f->ascent;
985		1063
986	int base = ascent; // sorry, incorrect: term->fbase;	1064	int base = ascent; // sorry, incorrect: term->fbase;
987		1065
988	XGCValues v;	1066	XGCValues v;
989	v.foreground = term->pix_colors[fg];	1067	v.foreground = term->pix_colors[fg];
…		…
1057		1135
1058	/////////////////////////////////////////////////////////////////////////////	1136	/////////////////////////////////////////////////////////////////////////////
1059		1137
1060	#if XFT	1138	#if XFT
1061		1139
1062	struct rxvt_font_xft : rxvt_font {	1140	struct rxvt_font_xft : rxvt_font
		1141	{
		1142	#if XFT_CHAR_CACHE
		1143	// we cache the qascii range xoffsets in the name of speed,
		1144	// expecting terminals to deal mostly with these characters
		1145	// we also assume the xoff always fits into uint8_t,
		1146	// which is questionable, but let's see...
		1147	// also, it is uncomfortably big, due to the uints.
		1148	enum { char_cache_min = 0x20, char_cache_max = 0x7e };
		1149	uint8_t xoff_cache [char_cache_max - char_cache_min + 1];
		1150	FT_UInt glyph_cache [char_cache_max - char_cache_min + 1];
		1151	#endif
		1152
1063	rxvt_font_xft () { f = 0; }	1153	rxvt_font_xft ()
		1154	{
		1155	f = 0;
		1156	}
1064		1157
1065	void clear ();	1158	void clear ();
1066		1159
1067	rxvt_fontprop properties ();	1160	rxvt_fontprop properties ();
1068		1161
…		…
1136	FcPatternAddInteger (p, FC_SLANT, prop.slant);	1229	FcPatternAddInteger (p, FC_SLANT, prop.slant);
1137		1230
1138	#if 0 // clipping unfortunately destroys our precious double-width-characters	1231	#if 0 // clipping unfortunately destroys our precious double-width-characters
1139	// clip width, we can't do better, or can we?	1232	// clip width, we can't do better, or can we?
1140	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)	1233	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
1141	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop->width);	1234	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
1142	#endif	1235	#endif
1143		1236
1144	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)	1237	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)
1145	FcPatternAddBool (p, FC_MINSPACE, 1);	1238	FcPatternAddBool (p, FC_MINSPACE, 1);
1146		1239
…		…
1158	int ftheight = 0;	1251	int ftheight = 0;
1159	bool success = true;	1252	bool success = true;
1160		1253
1161	for (;;)	1254	for (;;)
1162	{	1255	{
		1256	p = FcPatternDuplicate (match);
1163	f = XftFontOpenPattern (disp, FcPatternDuplicate (match));	1257	f = XftFontOpenPattern (disp, p);
1164		1258
1165	if (!f)	1259	if (!f)
1166	{	1260	{
		1261	FcPatternDestroy (p);
1167	success = false;	1262	success = false;
1168	break;	1263	break;
1169	}	1264	}
1170		1265
1171	FT_Face face = XftLockFace (f);	1266	FT_Face face = XftLockFace (f);
		1267
		1268	// fuck me plenty: XftLockFace can actually return 0. try not to crash.
		1269	// we also assume blindly that if the first lock succeeeds, then subsequent
		1270	// locks will also succeed.
		1271	if (!face)
		1272	{
		1273	XftFontClose (disp, f);
		1274	success = false;
		1275	break;
		1276	}
1172		1277
1173	ascent = (face->size->metrics.ascender + 63) >> 6;	1278	ascent = (face->size->metrics.ascender + 63) >> 6;
1174	descent = (-face->size->metrics.descender + 63) >> 6;	1279	descent = (-face->size->metrics.descender + 63) >> 6;
1175	height = max (ascent + descent, (face->size->metrics.height + 63) >> 6);	1280	height = max (ascent + descent, (face->size->metrics.height + 63) >> 6);
1176	width = 0;	1281	width = 0;
…		…
1179		1284
1180	XftUnlockFace (f);	1285	XftUnlockFace (f);
1181		1286
1182	int glheight = height;	1287	int glheight = height;
1183		1288
1184	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	1289	for (uint16_t *t = extent_test_chars; t < extent_test_chars + ecb_array_length (extent_test_chars); t++)
1185	{	1290	{
1186	FcChar16 ch = *t;	1291	FcChar16 ch = *t;
1187		1292
1188	if (cs != CS_UNICODE	1293	if (cs != CS_UNICODE
1189	&& ch > 0x100	1294	&& ch > 0x100
…		…
1208	if (glheight < g.height - g.y) glheight = g.height - g.y;	1313	if (glheight < g.height - g.y) glheight = g.height - g.y;
1209	}	1314	}
1210		1315
1211	if (!width)	1316	if (!width)
1212	{	1317	{
1213	rxvt_warn ("unable to calculate font width for '%s', ignoring.\n", name);	1318	rxvt_warn ("unable to calculate font width for '%s', using max_advance_width.\n", name);
1214		1319	width = f->max_advance_width;
1215	XftFontClose (disp, f);
1216	f = 0;
1217
1218	success = false;
1219	break;	1320	break;
1220	}	1321	}
1221		1322
1222	if (prop.height == rxvt_fontprop::unset	1323	if (prop.height == rxvt_fontprop::unset
1223	\|\| (height <= prop.height && glheight <= prop.height)	1324	\|\| (height <= prop.height && glheight <= prop.height)
…		…
1250	clear ();	1351	clear ();
1251	success = false;	1352	success = false;
1252	}	1353	}
1253	#endif	1354	#endif
1254		1355
		1356	#if XFT_CHAR_CACHE
		1357	// populate char cache
		1358	for (FcChar16 ch = char_cache_min; ch <= char_cache_max; ++ch)
		1359	{
		1360	FT_UInt glyph = XftCharIndex (disp, f, ch);
		1361	glyph_cache [ch - char_cache_min] = glyph;
		1362
		1363	XGlyphInfo g;
		1364	XftGlyphExtents (disp, f, &glyph, 1, &g);
		1365	xoff_cache [ch - char_cache_min] = g.xOff;
		1366	}
		1367	#endif
		1368
1255	return success;	1369	return success;
1256	}	1370	}
1257		1371
1258	bool	1372	bool
1259	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	1373	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
1260	{	1374	{
1261	careful = false;	1375	careful = false;
1262		1376
		1377	// handle non-bmp chars when text_t is 16 bit
		1378	#if ENABLE_COMBINING && !UNICODE_3
		1379	if (ecb_expect_false (IS_COMPOSE (unicode)))
		1380	if (compose_char *cc = rxvt_composite [unicode])
		1381	if (cc->c2 == NOCHAR)
		1382	unicode = cc->c1;
		1383	else
		1384	return false;
		1385	else
		1386	return false;
		1387	#endif
		1388
		1389	FcChar32 chr = unicode;
		1390
1263	if (!XftCharExists (term->dpy, f, unicode))	1391	if (!XftCharExists (term->dpy, f, chr))
1264	return false;	1392	return false;
1265		1393
1266	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1394	if (!prop \|\| prop->width == rxvt_fontprop::unset)
1267	return true;	1395	return true;
1268		1396
1269	// check character against base font bounding box	1397	int wcw = max (WCWIDTH (chr), 1);
1270	FcChar32 ch = unicode;	1398
1271	XGlyphInfo g;	1399	XGlyphInfo g;
1272	XftTextExtents32 (term->dpy, f, &ch, 1, &g);	1400	XftTextExtents32 (term->dpy, f, &chr, 1, &g);
		1401
		1402	int cwidth = prop->width * wcw;
		1403
		1404	// use same adjustments as in ->draw, see there
		1405	g.x += g.xOff ? cwidth - g.xOff >> 1 : 0;
		1406	g.x += g.xOff ? 0 : cwidth;
1273		1407
1274	int w = g.width - g.x;	1408	int w = g.width - g.x;
1275	int wcw = max (WCWIDTH (unicode), 1);
1276		1409
1277	careful = g.x > 0 \|\| w > prop->width * wcw;	1410	careful = g.x > 0 \|\| w > cwidth;
1278		1411
1279	if (careful && !OVERLAP_OK (w, wcw, prop))	1412	if (careful && !OVERLAP_OK (w, wcw, prop))
1280	return false;	1413	return false;
1281		1414
1282	// this weeds out _totally_ broken fonts, or glyphs	1415	// this weeds out _totally_ broken fonts, or glyphs
…		…
1289	void	1422	void
1290	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,	1423	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
1291	const text_t *text, int len,	1424	const text_t *text, int len,
1292	int fg, int bg)	1425	int fg, int bg)
1293	{	1426	{
1294	XGlyphInfo extents;	1427	XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);
1295	XftGlyphSpec enc = (XftGlyphSpec )rxvt_temp_buf (len * sizeof (XftGlyphSpec));
1296	XftGlyphSpec *ep = enc;	1428	XftGlyphSpec *ep = enc;
1297		1429
1298	dTermDisplay;	1430	dTermDisplay;
1299	dTermGC;	1431	dTermGC;
1300		1432
1301	int w = term->fwidth * len;	1433	int w = term->fwidth * len;
1302	int h = term->fheight;	1434	int h = term->fheight;
1303		1435
1304	/*
1305	* Maybe make buffering into a resource flag? Compile time option doesn't seems like a
1306	* good idea from the perspective of packaging for wide variety of user configs.
1307	*/
1308	bool buffered = bg >= Color_transparent;	1436	bool buffered = bg >= Color_transparent
1309	#ifdef FORCE_UNBUFFERED_XFT	1437	&& term->option (Opt_buffered);
1310	buffered = false;
1311	#endif
1312		1438
1313	// cut trailing spaces	1439	// cut trailing spaces
1314	while (len && text [len - 1] == ' ')	1440	while (len && text [len - 1] == ' ')
1315	len--;	1441	len--;
1316		1442
…		…
1318	int y_ = buffered ? 0 : y;	1444	int y_ = buffered ? 0 : y;
1319		1445
1320	while (len)	1446	while (len)
1321	{	1447	{
1322	int cwidth = term->fwidth;	1448	int cwidth = term->fwidth;
1323	FcChar32 fc = *text++; len--;	1449	FcChar32 chr = *text++; len--;
1324		1450
1325	while (len && *text == NOCHAR)	1451	while (len && *text == NOCHAR)
1326	text++, len--, cwidth += term->fwidth;	1452	text++, len--, cwidth += term->fwidth;
1327		1453
1328	if (fc != ' ') // skip spaces	1454	if (chr != ' ') // skip spaces
		1455	{
		1456	// handle non-bmp chars when text_t is 16 bit
		1457	#if ENABLE_COMBINING && !UNICODE_3
		1458	if (ecb_expect_false (IS_COMPOSE (chr)))
		1459	if (compose_char *cc = rxvt_composite [chr])
		1460	if (cc->c2 == NOCHAR)
		1461	chr = cc->c1;
		1462	#endif
		1463
		1464	#if 0
		1465	FT_UInt glyphs [decltype (exp)::max_size];
		1466
		1467	for (int i = 0; i < nchrs; ++i)
		1468	glyphs [i] = XftCharIndex (disp, f, chrs [i]);
		1469
		1470	for (int i = 0; i < nchrs; ++i)
1329	{	1471	{
		1472	XGlyphInfo ep;
		1473	XftGlyphExtents (disp, f, glyphs+i, 1, &ep);
		1474	printf ("gs %4x g %4x + %3d,%3d o %3d,%3d wh %3d,%3d\n", chrs[i],glyphs[i],ep.x,ep.y,ep.xOff,ep.yOff,ep.width,ep.height);
		1475	}
		1476	#endif
		1477
		1478	FT_UInt glyph;
		1479	int xOff;
		1480
		1481	#if XFT_CHAR_CACHE
		1482	if (ecb_expect_true (IN_RANGE_INC (chr, char_cache_min, char_cache_max)))
		1483	{
		1484	glyph = glyph_cache [chr - char_cache_min];
		1485	xOff = xoff_cache [chr - char_cache_min];
		1486	}
		1487	else
		1488	#endif
		1489	{
1330	FT_UInt glyph = XftCharIndex (disp, f, fc);	1490	glyph = XftCharIndex (disp, f, chr);
		1491	XGlyphInfo extents;
1331	XftGlyphExtents (disp, f, &glyph, 1, &extents);	1492	XftGlyphExtents (disp, f, &glyph, 1, &extents);
		1493	xOff = extents.xOff;
		1494	}
1332		1495
1333	ep->glyph = glyph;	1496	ep->glyph = glyph;
1334	ep->x = x_ + (cwidth - extents.xOff >> 1);	1497	ep->x = x_;
1335	ep->y = y_ + ascent;	1498	ep->y = y_ + ascent;
1336		1499
1337	if (extents.xOff == 0)	1500	// the xft font cell might differ from the terminal font cell,
		1501	// in which case we use the average between the two.
		1502	ep->x += xOff ? cwidth - xOff >> 1 : 0;
		1503
		1504	// xft/freetype represent combining characters as characters with zero
		1505	// width rendered over the previous character with some fonts, while
		1506	// in other fonts, they are considered normal characters, while yet
		1507	// in other fonts, they are shifted all over the place.
		1508	// we handle the first two cases by keying off on xOff being 0
		1509	// for zero-width chars. normally, we would add extents.xOff
		1510	// of the base character here, but we don't have that, so we use cwidth.
1338	ep->x = x_ + cwidth;	1511	ep->x += xOff ? 0 : cwidth;
1339		1512
1340	ep++;	1513	++ep;
1341	}	1514	}
1342		1515
1343	x_ += cwidth;	1516	x_ += cwidth;
1344	}	1517	}
1345		1518
1346	if (buffered)	1519	if (buffered)
1347	{	1520	{
1348	if (ep != enc)	1521	if (ep != enc)
1349	{	1522	{
1350	bool back_rendered = false;
1351	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);	1523	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);
1352		1524
1353	#ifdef HAVE_BG_PIXMAP	1525	#ifdef HAVE_IMG
		1526	Picture dst = 0; // the only assignment is done conditionally in the following if condition
		1527
1354	if (term->bgPixmap.pixmap)	1528	if (term->bg_img
		1529	&& (bg == Color_transparent \|\| bg == Color_bg
		1530	\|\| (bg >= 0 && !term->pix_colors[bg].is_opaque () && ((dst = XftDrawPicture (d2))))))
1355	{	1531	{
1356	Picture dst = 0;	1532	int src_x = x, src_y = y;
1357		1533
1358	if (bg >= 0 && term->pix_colors[bg].is_opaque ())	1534	if (term->bg_flags & rxvt_term::BG_IS_TRANSPARENT)
1359	XftDrawRect (d2, &term->pix_colors[bg].c, 0, 0, w, h);	1535	{
		1536	src_x += term->window_vt_x;
		1537	src_y += term->window_vt_y;
		1538	}
		1539
		1540	if (term->bg_img->w >= src_x + w
		1541	&& term->bg_img->h >= src_y + h)
		1542	{
		1543	XCopyArea (disp, term->bg_img->pm, d2, gc,
		1544	src_x, src_y, w, h, 0, 0);
		1545	}
1360	else	1546	else
1361	dst = XftDrawPicture (d2);	1547	{
		1548	XGCValues gcv;
		1549
		1550	gcv.fill_style = FillTiled;
		1551	gcv.tile = term->bg_img->pm;
		1552	gcv.ts_x_origin = -src_x;
		1553	gcv.ts_y_origin = -src_y;
		1554
		1555	XChangeGC (disp, gc,
		1556	GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin \| GCFillStyle,
		1557	&gcv);
		1558
		1559	XFillRectangle (disp, d2, gc, 0, 0, w, h);
		1560
		1561	gcv.fill_style = FillSolid;
		1562	XChangeGC (disp, gc, GCFillStyle, &gcv);
		1563	}
1362		1564
1363	if (dst)	1565	if (dst)
1364	{	1566	{
1365	int src_x = x, src_y = y;
1366
1367	if (term->bgPixmap.is_parentOrigin ())
1368	{
1369	src_x += term->window_vt_x;
1370	src_y += term->window_vt_y;
1371	}
1372
1373	if (term->bgPixmap.pmap_width >= src_x+w
1374	&& term->bgPixmap.pmap_height >= src_y+h)
1375	{
1376	XCopyArea (disp, term->bgPixmap.pixmap, d2, gc,
1377	src_x, src_y, w, h, 0, 0);
1378	}
1379	else
1380	{
1381	XGCValues gcv;
1382
1383	gcv.fill_style = FillTiled;
1384	gcv.tile = term->bgPixmap.pixmap;
1385	gcv.ts_x_origin = -src_x;
1386	gcv.ts_y_origin = -src_y;
1387
1388	XChangeGC (disp, gc,
1389	GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin \| GCFillStyle,
1390	&gcv);
1391
1392	XFillRectangle (disp, d2, gc, 0, 0, w, h);
1393
1394	gcv.fill_style = FillSolid;
1395	XChangeGC (disp, gc, GCFillStyle, &gcv);
1396	}
1397
1398	if (bg >= 0)
1399	{
1400	Picture solid_color_pict = XftDrawSrcPicture (d2, &term->pix_colors[bg].c);	1567	Picture solid_color_pict = XftDrawSrcPicture (d2, &term->pix_colors[bg].c);
		1568
		1569	// dst can only be set when bg >= 0
1401	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, 0, 0, w, h);	1570	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, 0, 0, w, h);
1402	}
1403
1404	back_rendered = true;
1405	}	1571	}
1406	}	1572	}
		1573	else
1407	#endif	1574	#endif
1408
1409	if (!back_rendered)
1410	XftDrawRect (d2, &term->pix_colors[bg < 0 ? Color_bg : bg].c, 0, 0, w, h);	1575	XftDrawRect (d2, &term->pix_colors[bg >= 0 ? bg : Color_bg].c, 0, 0, w, h);
1411		1576
1412	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);	1577	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);
1413	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);	1578	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);
1414	}	1579	}
1415	else	1580	else
…		…
1443	prop.width = prop.height = prop.ascent = prop.weight = prop.slant	1608	prop.width = prop.height = prop.ascent = prop.weight = prop.slant
1444	= rxvt_fontprop::unset;	1609	= rxvt_fontprop::unset;
1445	force_prop = false;	1610	force_prop = false;
1446		1611
1447	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)	1612	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
1448	FONT_UNREF (*i);	1613	(*i)->unref ();
1449		1614
1450	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)	1615	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)
1451	delete *p;	1616	delete *p;
1452		1617
1453	free (fontdesc); fontdesc = 0;	1618	free (fontdesc); fontdesc = 0;
…		…
1455	fonts.clear ();	1620	fonts.clear ();
1456		1621
1457	fallback = fallback_fonts;	1622	fallback = fallback_fonts;
1458	}	1623	}
1459		1624
		1625	void
		1626	rxvt_fontset::prepare_font (rxvt_font *font, codeset cs)
		1627	{
		1628	font->set_term (term);
		1629
		1630	font->cs = cs;
		1631	font->loaded = false;
		1632	}
		1633
1460	rxvt_font *	1634	rxvt_font *
1461	rxvt_fontset::new_font (const char *name, codeset cs)	1635	rxvt_fontset::new_font (const char *name, codeset cs)
1462	{	1636	{
1463	rxvt_font *f;	1637	rxvt_font *f;
1464		1638
…		…
1480	f = new rxvt_font_x11;	1654	f = new rxvt_font_x11;
1481	}	1655	}
1482	else	1656	else
1483	f = new rxvt_font_x11;	1657	f = new rxvt_font_x11;
1484		1658
1485	f->set_term (term);
1486	f->set_name (strdup (name));	1659	f->set_name (strdup (name));
1487		1660	prepare_font (f, cs);
1488	f->cs = cs;
1489	f->loaded = false;
1490		1661
1491	return f;	1662	return f;
1492	}	1663	}
1493		1664
1494	/////////////////////////////////////////////////////////////////////////////	1665	/////////////////////////////////////////////////////////////////////////////
		1666
		1667	void
		1668	rxvt_fontset::push_font (rxvt_font *font)
		1669	{
		1670	// the fontCount index is reserved for the overflow font, it is only
		1671	// necessary when we get fontCount or more fonts, as they cannot be
		1672	// represented in the rendition.
		1673	if (fonts.size () == fontCount)
		1674	{
		1675	rxvt_font *f = new rxvt_font_overflow (this);
		1676
		1677	prepare_font (f, CS_UNICODE);
		1678	fonts.push_back (f);
		1679	}
		1680
		1681	fonts.push_back (font);
		1682	}
1495		1683
1496	void	1684	void
1497	rxvt_fontset::add_fonts (const char *desc)	1685	rxvt_fontset::add_fonts (const char *desc)
1498	{	1686	{
1499	if (desc)	1687	if (desc)
…		…
1528	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);	1716	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);
1529	else	1717	else
1530	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);	1718	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);
1531		1719
1532	desc++;	1720	desc++;
1533	while (*desc <= ' ') desc++;	1721	while (desc <= ' ' && desc) desc++;
1534	}	1722	}
1535		1723
1536	end = strchr (desc, ',');	1724	end = strchr (desc, ',');
1537	if (!end)	1725	if (!end)
1538	end = desc + strlen (desc);	1726	end = desc + strlen (desc);
…		…
1540	if (end - desc < 511)	1728	if (end - desc < 511)
1541	{	1729	{
1542	memcpy (buf, desc, end - desc);	1730	memcpy (buf, desc, end - desc);
1543	buf[end - desc] = 0;	1731	buf[end - desc] = 0;
1544		1732
1545	fonts.push_back (new_font (buf, cs));	1733	push_font (new_font (buf, cs));
1546	}	1734	}
1547	else	1735	else
1548	rxvt_warn ("fontset element too long (>511 bytes), ignored.");	1736	rxvt_warn ("fontset element too long (>511 bytes), ignored.\n");
1549		1737
1550	desc = end + 1;	1738	desc = end + 1;
1551	}	1739	}
1552	while (*end);	1740	while (*end);
1553	}	1741	}
…		…
1578	{	1766	{
1579	clear ();	1767	clear ();
1580		1768
1581	fontdesc = strdup (desc);	1769	fontdesc = strdup (desc);
1582		1770
1583	fonts.push_back (new_font (0, CS_UNICODE));	1771	push_font (new_font (0, CS_UNICODE));
1584	realize_font (0);	1772	realize_font (0);
1585		1773
1586	add_fonts (desc);	1774	add_fonts (desc);
1587		1775
1588	return true;	1776	return true;
…		…
1597		1785
1598	return -1;	1786	return -1;
1599	}	1787	}
1600		1788
1601	int	1789	int
1602	rxvt_fontset::find_font (unicode_t unicode)	1790	rxvt_fontset::find_font_idx (unicode_t unicode)
1603	{	1791	{
1604	if (unicode >= 1<<20)	1792	// this limits fmap size. it has to accommodate COMPOSE_HI when UNICODE_3
		1793	if (unicode > 0x1fffff)
1605	return 0;	1794	return 0;
1606		1795
1607	unicode_t hi = unicode >> 8;	1796	unicode_t hi = unicode >> 8;
1608		1797
1609	if (hi < fmap.size ()	1798	if (hi < fmap.size ())
1610	&& fmap[hi]	1799	if (pagemap *pm = fmap[hi])
1611	&& (*fmap[hi])[unicode & 0xff] != 0xff)	1800	if ((*pm)[unicode & 0xff] != 0xff)
1612	return (*fmap[hi])[unicode & 0xff];	1801	return (*pm)[unicode & 0xff];
1613		1802
1614	unsigned int i;	1803	unsigned int i;
1615		1804
1616	for (i = 0; i < fonts.size (); i++)	1805	for (i = 0; i < fonts.size (); i++)
1617	{	1806	{
…		…
1633	goto next_font;	1822	goto next_font;
1634		1823
1635	bool careful;	1824	bool careful;
1636	if (f->has_char (unicode, &prop, careful))	1825	if (f->has_char (unicode, &prop, careful))
1637	{	1826	{
1638	if (careful)	1827	i = (i << 1) \| careful;
1639	i \|= 128;
1640		1828
1641	goto found;	1829	goto found;
1642	}	1830	}
1643		1831
1644	next_font:	1832	next_font:
1645	if (i == fonts.size () - 1)	1833	if (i == fonts.size () - 1)
1646	{	1834	{
		1835	// compose characters are handled by the default font, unless another font takes over
		1836	// we do not go via the fallback list for speed reasons.
		1837	if (IS_COMPOSE (unicode))
		1838	return 0;
		1839
1647	if (fallback->name)	1840	if (fallback->name)
1648	{	1841	{
1649	// search through the fallback list	1842	// search through the fallback list
1650	fonts.push_back (new_font (fallback->name, fallback->cs));	1843	push_font (new_font (fallback->name, fallback->cs));
1651	fallback++;	1844	fallback++;
1652	}	1845	}
1653	else	1846	else
1654	{	1847	{
1655	// try to find a new font.	1848	// try to find a new font.
…		…
1657	// way to configure this and xft is easier to hack in,	1850	// way to configure this and xft is easier to hack in,
1658	// while x11 has more framework in place already.	1851	// while x11 has more framework in place already.
1659	// TODO: this is a real resource hog, xft takes ages(?)	1852	// TODO: this is a real resource hog, xft takes ages(?)
1660	#if XFT && USE_SLOW_LOOKUP	1853	#if XFT && USE_SLOW_LOOKUP
1661	// grab the first xft font that seems suitable	1854	// grab the first xft font that seems suitable
		1855	// TOOD: should go first for cellchar (spacing 110) then mono, then else
1662	FcPattern *p = FcPatternCreate ();	1856	FcPattern *p = FcPatternCreate ();
1663		1857
1664	FcCharSet *s = FcCharSetCreate ();	1858	FcCharSet *s = FcCharSetCreate ();
1665	FcCharSetAddChar (s, unicode);	1859	FcCharSetAddChar (s, unicode);
1666	FcPatternAddCharSet (p, FC_CHARSET, s);	1860	FcPatternAddCharSet (p, FC_CHARSET, s);
…		…
1686	FcPatternDestroy (match);	1880	FcPatternDestroy (match);
1687		1881
1688	if (find_font (font) < 0)	1882	if (find_font (font) < 0)
1689	{	1883	{
1690	char fontname[4096];	1884	char fontname[4096];
1691	sprintf (fontname, "xft:%-.4090s", font);	1885	snprintf (fontname, sizeof (fontname), "xft:%s", font);
1692		1886
1693	fonts.push_back (new_font (fontname, CS_UNICODE));	1887	push_font (new_font (fontname, CS_UNICODE));
1694	}	1888	}
1695		1889
1696	free (font);	1890	free (font);
1697	}	1891	}
1698	#endif	1892	#endif
…		…
1710	while (hi >= fmap.size ())	1904	while (hi >= fmap.size ())
1711	fmap.push_back (0);	1905	fmap.push_back (0);
1712		1906
1713	if (!fmap[hi])	1907	if (!fmap[hi])
1714	{	1908	{
1715	fmap[hi] = (pagemap *)new pagemap;	1909	fmap[hi] = new pagemap;
1716	memset (fmap[hi], 0xff, sizeof (pagemap));	1910	memset (fmap[hi], 0xff, sizeof (pagemap));
1717	}	1911	}
1718		1912
1719	(*fmap[hi])[unicode & 0xff] = i;	1913	(*fmap[hi])[unicode & 0xff] = i;
1720	}	1914	}
1721		1915
1722	return i;	1916	return i;
1723	}	1917	}
1724		1918
1725
1726

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/rxvtfont.C (file contents): Revision 1.133 by root, Wed Jan 23 06:49:30 2008 UTC vs. Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.133 by root, Wed Jan 23 06:49:30 2008 UTC vs.
Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC