[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.204 by root, Thu Jun 17 11:45:19 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:Bitstream Vera 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" },
…		…
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
…		…
211	}	212	}
212		213
213	/////////////////////////////////////////////////////////////////////////////	214	/////////////////////////////////////////////////////////////////////////////
214		215
215	rxvt_font::rxvt_font ()	216	rxvt_font::rxvt_font ()
216	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset)	217	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset), can_compose(false)
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)
…		…
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		450
		451	#if NOT_YET
		452	vector<text_t> chrs;
		453	chrs.reserve (rxvt_composite.expand (t));
		454	rxvt_composite.expand (t, &chrs[0]);
		455
		456	while (!chrs.empty ())
		457	{
		458	rxvt_font *f1 = fs->find_font_idx (chrs[0])
		459
		460	int i = 0;
		461	while (i < chrs.size () - 1
		462	&& f1->can_combine
		463	&& f1->has-char (chrs[i + 1], careful)
		464	&& !careful
		465	++i;
		466
		467	(*fs)[f1]->draw (d, x, y, &chrs[0], width, fg, bg);
		468	chrs.erase (&chrs[0], &chrs[i]);
		469	}
		470	#endif
		471
		472	#if 1
452	text_t chrs[2];	473	text_t chrs[2];
453	chrs [1] = NOCHAR;	474	chrs [1] = NOCHAR;
454		475
455	*chrs = cc->c1;	476	*chrs = cc->c1;
456	rxvt_font f1 = (fs)[fs->find_font (cc->c1)];	477	rxvt_font f1 = (fs)[fs->find_font_idx (cc->c1)];
457	f1->draw (d, x, y, chrs, width, fg, bg);	478	f1->draw (d, x, y, chrs, width, fg, bg);
458		479
459	if (cc->c2 != NOCHAR)	480	if (cc->c2 != NOCHAR)
460	{	481	{
461	bool careful;	482	bool careful;
462		483
463	// prefer font of first character, for no good reasons	484	// prefer font of first character, for no good reasons
464	*chrs = cc->c2;	485	*chrs = cc->c2;
465	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)	486	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)
466	? f1	487	? f1
467	: (*fs)[fs->find_font (cc->c2)];	488	: (*fs)[fs->find_font_idx (cc->c2)];
468		489
469	f2->draw (d, x, y, chrs, width, fg, Color_none);	490	f2->draw (d, x, y, chrs, width, fg, Color_none);
470	}	491	}
		492	#endif
471	}	493	}
472	#endif	494	#endif
473	else	495	else
474	switch (t)	496	switch (t)
475	{	497	{
476	case '\t':	498	case '\t':
477	case ZERO_WIDTH_CHAR:	499	case ZERO_WIDTH_CHAR:
478	case NOCHAR:	500	case NOCHAR:
479	break;	501	break;
480		502
		503	/*
		504	* If the base font does not support variation selectors, treat them as ZWC.
		505	* a point could be made to do this for all wcwidth == 0 characters, but I
		506	* decided against that until more data is available.
		507	*/
		508	case 0xfe00: case 0xfe01: case 0xfe02: case 0xfe03: case 0xfe04: case 0xfe05: case 0xfe06: case 0xfe07:
		509	case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b: case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
		510	break;
		511
481	default:	512	default:
482	XDrawRectangle (disp, d, gc, x + 2, y + 2,	513	XDrawRectangle (disp, d, gc, x + 2, y + 2,
483	fwidth - 4, term->fheight - 4);	514	fwidth - 4, term->fheight - 4);
484	}	515	}
485		516
486	x += fwidth;	517	x += fwidth;
487	}	518	}
488	}	519	}
489		520
		521	struct rxvt_font_overflow : rxvt_font
		522	{
		523	struct rxvt_fontset *fs;
		524
		525	rxvt_font_overflow (rxvt_fontset *fs)
		526	: rxvt_font ()
		527	{
		528	this->fs = fs;
		529	}
		530
		531	rxvt_fontprop properties ()
		532	{
		533	rxvt_fontprop p;
		534
		535	p.width = p.height = 1;
		536	p.ascent = rxvt_fontprop::unset;
		537	p.weight = rxvt_fontprop::medium;
		538	p.slant = rxvt_fontprop::roman;
		539
		540	return p;
		541	}
		542
		543	bool load (const rxvt_fontprop &prop, bool force_prop)
		544	{
		545	width = 1; height = 1;
		546	ascent = 1; descent = 0;
		547
		548	set_name (strdup ("built-in rendition overflow font"));
		549
		550	return true;
		551	}
		552
		553	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
		554	{
		555	return false;
		556	}
		557
		558	void draw (rxvt_drawable &d, int x, int y,
		559	const text_t *text, int len,
		560	int fg, int bg)
		561	{
		562	while (len)
		563	{
		564	int fid = fs->find_font_idx (*text);
		565	int w = 1;
		566	while (w < len && text[w] == NOCHAR)
		567	w++;
		568	(*fs)[fid]->draw (d, x, y, text, w, fg, bg);
		569	text += w;
		570	len -= w;
		571	x += term->fwidth * w;
		572	}
		573	}
		574	};
		575
490	/////////////////////////////////////////////////////////////////////////////	576	/////////////////////////////////////////////////////////////////////////////
491		577
492	struct rxvt_font_x11 : rxvt_font {	578	struct rxvt_font_x11 : rxvt_font
		579	{
493	rxvt_font_x11 () { f = 0; }	580	rxvt_font_x11 () { f = 0; }
494		581
495	void clear ();	582	void clear ();
496		583
497	rxvt_fontprop properties ();	584	rxvt_fontprop properties ();
…		…
502		589
503	void draw (rxvt_drawable &d, int x, int y,	590	void draw (rxvt_drawable &d, int x, int y,
504	const text_t *text, int len,	591	const text_t *text, int len,
505	int fg, int bg);	592	int fg, int bg);
506		593
507	bool slow; // wether this is a proportional font or has other funny characteristics	594	bool slow; // whether this is a proportional font or has other funny characteristics
508	XFontStruct *f;	595	XFontStruct *f;
509	bool enc2b, encm;	596	bool enc2b, encm;
510		597
511	char get_property (XFontStruct f, Atom property, const char *repl) const;	598	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);	599	bool set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth);
…		…
669	f = XLoadQueryFont (disp, name);	756	f = XLoadQueryFont (disp, name);
670		757
671	if (!f)	758	if (!f)
672	return false;	759	return false;
673		760
674	char *new_name = get_property (f, XA_FONT, name);	761	char *new_name = get_property (f, XA_FONT, 0);
675		762
676	if (new_name)	763	if (new_name)
677	set_name (new_name);	764	set_name (new_name);
678	else	765	else
679	rxvt_warn ("font '%s' has no FONT property, continuing without.", name);	766	rxvt_warn ("font '%s' has no FONT property, continuing without.\n", name);
680		767
681	XFreeFont (disp, f);	768	XFreeFont (disp, f);
682	f = 0;	769	f = 0;
683	}	770	}
684		771
…		…
741	free (fname);	828	free (fname);
742	if (replace_field (&fname, list[i], 11, '0', "0"))	829	if (replace_field (&fname, list[i], 11, '0', "0"))
743	diff += 300; // more heavily penalize what looks like scaled bitmap fonts	830	diff += 300; // more heavily penalize what looks like scaled bitmap fonts
744	}	831	}
745		832
746	if (!set_properties (p, fname))	833	if (!set_properties (p, fname)
		834	// also weed out too large fonts
		835	\|\| (prop.height != rxvt_fontprop::unset
		836	&& p.height > prop.height))
		837	{
		838	free (fname);
747	continue;	839	continue;
748		840	}
749	if (prop.height != rxvt_fontprop::unset
750	&& p.height > prop.height) // weed out too large fonts
751	continue;
752		841
753	if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;	842	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);	843	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);	844	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);	845	//if (prop.width != rxvt_fontprop::unset) diff += abs (prop.width - p.width);
…		…
762	XFreeFontNames (list);	851	XFreeFontNames (list);
763		852
764	// this loop only iterates when the guessed font-size is too small	853	// this loop only iterates when the guessed font-size is too small
765	for (;;)	854	for (;;)
766	{	855	{
767	font_weight *best = fonts + count - 1;	856	font_weight *best = fonts;
768		857
769	for (font_weight *w = best; w-- > fonts; )	858	for (font_weight *w = fonts + 1; w < fonts + count; w++)
770	if (w->diff <= best->diff)	859	if (w->diff < best->diff)
771	best = w;	860	best = w;
772		861
773	if (!best->name	862	if (!best->name
774	\|\| !(f = XLoadQueryFont (disp, best->name)))	863	\|\| !(f = XLoadQueryFont (disp, best->name)))
775	break;	864	break;
…		…
795	return false;	884	return false;
796		885
797	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);	886	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);
798	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);	887	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);
799		888
		889	cs = CS_UNKNOWN;
		890
800	if (registry && encoding)	891	if (registry && encoding)
801	{	892	{
802	char charset[64];	893	char charset[64];
803	snprintf (charset, 64, "%s-%s", registry, encoding);	894	snprintf (charset, 64, "%s-%s", registry, encoding);
804		895
805	cs = codeset_from_name (charset);	896	cs = codeset_from_name (charset);
806	}	897
807	else	898	if (cs == CS_UNKNOWN)
		899	rxvt_warn ("%s: cannot deduce encoding from registry/encoding properties \"%s\", ignoring font.\n", name, charset);
808	{	900	}
		901
		902	free (registry);
		903	free (encoding);
		904
		905	if (cs == CS_UNKNOWN)
		906	{
809	const char *charset = get_property (f, XA_FONT, 0);	907	char *value = get_property (f, XA_FONT, 0);
		908	const char *charset = value;
810		909
811	if (!charset)	910	if (!charset)
812	charset = name;	911	charset = name;
813		912
814	int count = 13;	913	int count = 13;
815	while (*charset)	914	while (*charset)
816	if (*charset++ == '-' && !--count)	915	if (*charset++ == '-' && !--count)
817	break;	916	break;
818		917
819	cs = codeset_from_name (charset);	918	cs = codeset_from_name (charset);
		919	if (cs == CS_UNKNOWN)
		920	rxvt_warn ("%s: cannot deduce encoding from font name property \"%s\", ignoring font.\n", name, charset);
		921
		922	free (value);
		923	}
		924
		925	if (cs == CS_UNKNOWN)
820	}	926	{
821		927	clear ();
822	free (registry);	928	return false;
823	free (encoding);	929	}
824		930
825	if (cs == CS_UNICODE)	931	if (cs == CS_UNICODE)
826	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font	932	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font
827		933
828	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;	934	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;
…		…
853	}	959	}
854	#endif	960	#endif
855		961
856	width = 1;	962	width = 1;
857		963
858	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	964	for (uint16_t *t = extent_test_chars; t < extent_test_chars + ecb_array_length (extent_test_chars); t++)
859	{	965	{
860	if (FROM_UNICODE (cs, *t) == NOCHAR)	966	if (FROM_UNICODE (cs, *t) == NOCHAR)
861	continue;	967	continue;
862		968
863	// ignore characters we wouldn't use anyways	969	// ignore characters we wouldn't use anyways
864	bool careful;	970	bool careful;
865	if (!has_char (*t, &prop, careful))	971	if (!has_char (*t, &prop, careful))
866	continue;	972	continue;
867		973
868	XChar2b ch = { t >> 8, t };	974	// the casts are needed in C++11 (see 8.5.1)
		975	XChar2b ch = { (unsigned char)(t >> 8), (unsigned char)t };
869		976
870	XCharStruct g;	977	XCharStruct g;
871	int dir_ret, asc_ret, des_ret;	978	int dir_ret, asc_ret, des_ret;
872	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);	979	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);
873		980
…		…
875	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;	982	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;
876		983
877	if (width < g.width) width = g.width;	984	if (width < g.width) width = g.width;
878	}	985	}
879		986
880	if (cs == CS_UNKNOWN)	987	#if 0 // do it per-character
		988	if (prop && width > prop->width)
881	{	989	{
882	fprintf (stderr, "unable to deduce codeset, ignoring font '%s'\n", name);
883
884	clear ();	990	clear ();
885	return false;	991	return false;
886	}	992	}
887
888	#if 0 // do it per-character
889	if (prop && width > prop->width)
890	{
891	clear ();
892	return false;
893	}
894	#endif	993	#endif
895		994
896	return true;	995	return true;
897	}	996	}
898		997
…		…
907	}	1006	}
908		1007
909	bool	1008	bool
910	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	1009	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
911	{	1010	{
		1011	careful = false;
		1012
912	uint32_t ch = FROM_UNICODE (cs, unicode);	1013	uint32_t ch = FROM_UNICODE (cs, unicode);
913		1014
914	if (ch == NOCHAR)	1015	if (ch == NOCHAR)
915	return false;	1016	return false;
916		1017
917	/* check wether the character exists in _this_ font. horrible. */	1018	/* check whether the character exists in _this_ font. horrible. */
918	XCharStruct *xcs;	1019	XCharStruct *xcs;
919		1020
920	if (encm)	1021	if (encm)
921	{	1022	{
922	unsigned char byte1 = ch >> 8;	1023	unsigned char byte1 = ch >> 8;
…		…
952	return false;	1053	return false;
953		1054
954	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1055	if (!prop \|\| prop->width == rxvt_fontprop::unset)
955	return true;	1056	return true;
956		1057
957	// check wether character overlaps previous/next character	1058	// check whether character overlaps previous/next character
958	int w = xcs->rbearing - xcs->lbearing;	1059	int w = xcs->rbearing - xcs->lbearing;
959	int wcw = max (WCWIDTH (unicode), 1);	1060	int wcw = max (WCWIDTH (unicode), 1);
960		1061
961	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;	1062	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;
962		1063
…		…
979	dTermDisplay;	1080	dTermDisplay;
980	dTermGC;	1081	dTermGC;
981		1082
982	bool slow = this->slow	1083	bool slow = this->slow
983	\|\| width != term->fwidth	1084	\|\| width != term->fwidth
984	\|\| height != term->fheight;	1085	\|\| height != term->fheight
		1086	\|\| ascent != f->ascent;
985		1087
986	int base = ascent; // sorry, incorrect: term->fbase;	1088	int base = ascent; // sorry, incorrect: term->fbase;
987		1089
988	XGCValues v;	1090	XGCValues v;
989	v.foreground = term->pix_colors[fg];	1091	v.foreground = term->pix_colors[fg];
…		…
1057		1159
1058	/////////////////////////////////////////////////////////////////////////////	1160	/////////////////////////////////////////////////////////////////////////////
1059		1161
1060	#if XFT	1162	#if XFT
1061		1163
1062	struct rxvt_font_xft : rxvt_font {	1164	struct rxvt_font_xft : rxvt_font
		1165	{
1063	rxvt_font_xft () { f = 0; }	1166	rxvt_font_xft ()
		1167	{
		1168	can_compose = true;
		1169	f = 0;
		1170	}
1064		1171
1065	void clear ();	1172	void clear ();
1066		1173
1067	rxvt_fontprop properties ();	1174	rxvt_fontprop properties ();
1068		1175
…		…
1136	FcPatternAddInteger (p, FC_SLANT, prop.slant);	1243	FcPatternAddInteger (p, FC_SLANT, prop.slant);
1137		1244
1138	#if 0 // clipping unfortunately destroys our precious double-width-characters	1245	#if 0 // clipping unfortunately destroys our precious double-width-characters
1139	// clip width, we can't do better, or can we?	1246	// clip width, we can't do better, or can we?
1140	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)	1247	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
1141	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop->width);	1248	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
1142	#endif	1249	#endif
1143		1250
1144	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)	1251	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)
1145	FcPatternAddBool (p, FC_MINSPACE, 1);	1252	FcPatternAddBool (p, FC_MINSPACE, 1);
1146		1253
…		…
1158	int ftheight = 0;	1265	int ftheight = 0;
1159	bool success = true;	1266	bool success = true;
1160		1267
1161	for (;;)	1268	for (;;)
1162	{	1269	{
		1270	p = FcPatternDuplicate (match);
1163	f = XftFontOpenPattern (disp, FcPatternDuplicate (match));	1271	f = XftFontOpenPattern (disp, p);
1164		1272
1165	if (!f)	1273	if (!f)
1166	{	1274	{
		1275	FcPatternDestroy (p);
1167	success = false;	1276	success = false;
1168	break;	1277	break;
1169	}	1278	}
1170		1279
1171	FT_Face face = XftLockFace (f);	1280	FT_Face face = XftLockFace (f);
…		…
1179		1288
1180	XftUnlockFace (f);	1289	XftUnlockFace (f);
1181		1290
1182	int glheight = height;	1291	int glheight = height;
1183		1292
1184	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	1293	for (uint16_t *t = extent_test_chars; t < extent_test_chars + ecb_array_length (extent_test_chars); t++)
1185	{	1294	{
1186	FcChar16 ch = *t;	1295	FcChar16 ch = *t;
1187		1296
1188	if (cs != CS_UNICODE	1297	if (cs != CS_UNICODE
1189	&& ch > 0x100	1298	&& ch > 0x100
…		…
1208	if (glheight < g.height - g.y) glheight = g.height - g.y;	1317	if (glheight < g.height - g.y) glheight = g.height - g.y;
1209	}	1318	}
1210		1319
1211	if (!width)	1320	if (!width)
1212	{	1321	{
1213	rxvt_warn ("unable to calculate font width for '%s', ignoring.\n", name);	1322	rxvt_warn ("unable to calculate font width for '%s', using max_advance_width.\n", name);
1214		1323	width = f->max_advance_width;
1215	XftFontClose (disp, f);
1216	f = 0;
1217
1218	success = false;
1219	break;	1324	break;
1220	}	1325	}
1221		1326
1222	if (prop.height == rxvt_fontprop::unset	1327	if (prop.height == rxvt_fontprop::unset
1223	\|\| (height <= prop.height && glheight <= prop.height)	1328	\|\| (height <= prop.height && glheight <= prop.height)
…		…
1258	bool	1363	bool
1259	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	1364	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
1260	{	1365	{
1261	careful = false;	1366	careful = false;
1262		1367
		1368	#if ENABLE_COMBINING && !UNICODE_3
		1369	if (ecb_expect_false (IS_COMPOSE (unicode)))
		1370	if (compose_char *cc = rxvt_composite[unicode])
		1371	if (cc->c2 == NOCHAR)
		1372	unicode = cc->c1;
		1373	#endif
		1374
1263	if (!XftCharExists (term->dpy, f, unicode))	1375	if (!XftCharExists (term->dpy, f, unicode))
		1376	return false;
		1377
		1378	// some fonts claim they can render private use chars and then
		1379	// render them as boxes.
		1380	if (ecb_expect_false (IS_COMPOSE (unicode)))
1264	return false;	1381	return false;
1265		1382
1266	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1383	if (!prop \|\| prop->width == rxvt_fontprop::unset)
1267	return true;	1384	return true;
1268		1385
…		…
1290	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,	1407	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
1291	const text_t *text, int len,	1408	const text_t *text, int len,
1292	int fg, int bg)	1409	int fg, int bg)
1293	{	1410	{
1294	XGlyphInfo extents;	1411	XGlyphInfo extents;
1295	XftGlyphSpec enc = (XftGlyphSpec )rxvt_temp_buf (len * sizeof (XftGlyphSpec));	1412	XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);
1296	XftGlyphSpec *ep = enc;	1413	XftGlyphSpec *ep = enc;
1297		1414
1298	dTermDisplay;	1415	dTermDisplay;
1299	dTermGC;	1416	dTermGC;
1300		1417
1301	int w = term->fwidth * len;	1418	int w = term->fwidth * len;
1302	int h = term->fheight;	1419	int h = term->fheight;
1303		1420
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;	1421	bool buffered = bg >= Color_transparent
1309	#ifdef FORCE_UNBUFFERED_XFT	1422	&& term->option (Opt_buffered);
1310	buffered = false;
1311	#endif
1312		1423
1313	// cut trailing spaces	1424	// cut trailing spaces
1314	while (len && text [len - 1] == ' ')	1425	while (len && text [len - 1] == ' ')
1315	len--;	1426	len--;
1316		1427
…		…
1320	while (len)	1431	while (len)
1321	{	1432	{
1322	int cwidth = term->fwidth;	1433	int cwidth = term->fwidth;
1323	FcChar32 fc = *text++; len--;	1434	FcChar32 fc = *text++; len--;
1324		1435
		1436	#if ENABLE_COMBINING && !UNICODE_3
		1437	if (ecb_expect_false (IS_COMPOSE (fc)))
		1438	if (compose_char *cc = rxvt_composite[fc]) // should always be true, but better be safe than sorry
		1439	fc = cc->c1; // c2 must be NOCHAR, as has_char handles it that way
		1440	#endif
		1441
1325	while (len && *text == NOCHAR)	1442	while (len && *text == NOCHAR)
1326	text++, len--, cwidth += term->fwidth;	1443	text++, len--, cwidth += term->fwidth;
1327		1444
1328	if (fc != ' ') // skip spaces	1445	if (fc != ' ') // skip spaces
1329	{	1446	{
…		…
1345		1462
1346	if (buffered)	1463	if (buffered)
1347	{	1464	{
1348	if (ep != enc)	1465	if (ep != enc)
1349	{	1466	{
1350	bool back_rendered = false;
1351	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);	1467	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);
1352		1468
1353	#ifdef HAVE_BG_PIXMAP	1469	#ifdef HAVE_IMG
		1470	Picture dst = 0; // the only assignment is done conditionally in the following if condition
		1471
1354	if (term->bgPixmap.pixmap)	1472	if (term->bg_img
		1473	&& (bg == Color_transparent \|\| bg == Color_bg
		1474	\|\| (bg >= 0 && !term->pix_colors[bg].is_opaque () && ((dst = XftDrawPicture (d2))))))
1355	{	1475	{
1356	Picture dst = 0;	1476	int src_x = x, src_y = y;
1357		1477
1358	if (bg >= 0 && term->pix_colors[bg].is_opaque ())	1478	if (term->bg_flags & rxvt_term::BG_IS_TRANSPARENT)
1359	XftDrawRect (d2, &term->pix_colors[bg].c, 0, 0, w, h);	1479	{
		1480	src_x += term->window_vt_x;
		1481	src_y += term->window_vt_y;
		1482	}
		1483
		1484	if (term->bg_img->w >= src_x + w
		1485	&& term->bg_img->h >= src_y + h)
		1486	{
		1487	XCopyArea (disp, term->bg_img->pm, d2, gc,
		1488	src_x, src_y, w, h, 0, 0);
		1489	}
1360	else	1490	else
1361	dst = XftDrawPicture (d2);	1491	{
		1492	XGCValues gcv;
		1493
		1494	gcv.fill_style = FillTiled;
		1495	gcv.tile = term->bg_img->pm;
		1496	gcv.ts_x_origin = -src_x;
		1497	gcv.ts_y_origin = -src_y;
		1498
		1499	XChangeGC (disp, gc,
		1500	GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin \| GCFillStyle,
		1501	&gcv);
		1502
		1503	XFillRectangle (disp, d2, gc, 0, 0, w, h);
		1504
		1505	gcv.fill_style = FillSolid;
		1506	XChangeGC (disp, gc, GCFillStyle, &gcv);
		1507	}
1362		1508
1363	if (dst)	1509	if (dst)
1364	{	1510	{
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);	1511	Picture solid_color_pict = XftDrawSrcPicture (d2, &term->pix_colors[bg].c);
		1512
		1513	// 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);	1514	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, 0, 0, w, h);
1402	}
1403
1404	back_rendered = true;
1405	}	1515	}
1406	}	1516	}
		1517	else
1407	#endif	1518	#endif
1408
1409	if (!back_rendered)
1410	XftDrawRect (d2, &term->pix_colors[bg < 0 ? Color_bg : bg].c, 0, 0, w, h);	1519	XftDrawRect (d2, &term->pix_colors[bg >= 0 ? bg : Color_bg].c, 0, 0, w, h);
1411		1520
1412	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);	1521	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);
1413	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);	1522	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);
1414	}	1523	}
1415	else	1524	else
…		…
1443	prop.width = prop.height = prop.ascent = prop.weight = prop.slant	1552	prop.width = prop.height = prop.ascent = prop.weight = prop.slant
1444	= rxvt_fontprop::unset;	1553	= rxvt_fontprop::unset;
1445	force_prop = false;	1554	force_prop = false;
1446		1555
1447	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)	1556	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
1448	FONT_UNREF (*i);	1557	(*i)->unref ();
1449		1558
1450	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)	1559	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)
1451	delete *p;	1560	delete *p;
1452		1561
1453	free (fontdesc); fontdesc = 0;	1562	free (fontdesc); fontdesc = 0;
…		…
1455	fonts.clear ();	1564	fonts.clear ();
1456		1565
1457	fallback = fallback_fonts;	1566	fallback = fallback_fonts;
1458	}	1567	}
1459		1568
		1569	void
		1570	rxvt_fontset::prepare_font (rxvt_font *font, codeset cs)
		1571	{
		1572	font->set_term (term);
		1573
		1574	font->cs = cs;
		1575	font->loaded = false;
		1576	}
		1577
1460	rxvt_font *	1578	rxvt_font *
1461	rxvt_fontset::new_font (const char *name, codeset cs)	1579	rxvt_fontset::new_font (const char *name, codeset cs)
1462	{	1580	{
1463	rxvt_font *f;	1581	rxvt_font *f;
1464		1582
…		…
1480	f = new rxvt_font_x11;	1598	f = new rxvt_font_x11;
1481	}	1599	}
1482	else	1600	else
1483	f = new rxvt_font_x11;	1601	f = new rxvt_font_x11;
1484		1602
1485	f->set_term (term);
1486	f->set_name (strdup (name));	1603	f->set_name (strdup (name));
1487		1604	prepare_font (f, cs);
1488	f->cs = cs;
1489	f->loaded = false;
1490		1605
1491	return f;	1606	return f;
1492	}	1607	}
1493		1608
1494	/////////////////////////////////////////////////////////////////////////////	1609	/////////////////////////////////////////////////////////////////////////////
		1610
		1611	void
		1612	rxvt_fontset::push_font (rxvt_font *font)
		1613	{
		1614	// the fontCount index is reserved for the overflow font, it is only
		1615	// necessary when we get fontCount or more fonts, as they cannot be
		1616	// represented in the rendition.
		1617	if (fonts.size () == fontCount)
		1618	{
		1619	rxvt_font *f = new rxvt_font_overflow (this);
		1620
		1621	prepare_font (f, CS_UNICODE);
		1622	fonts.push_back (f);
		1623	}
		1624
		1625	fonts.push_back (font);
		1626	}
1495		1627
1496	void	1628	void
1497	rxvt_fontset::add_fonts (const char *desc)	1629	rxvt_fontset::add_fonts (const char *desc)
1498	{	1630	{
1499	if (desc)	1631	if (desc)
…		…
1528	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);	1660	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);
1529	else	1661	else
1530	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);	1662	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);
1531		1663
1532	desc++;	1664	desc++;
1533	while (*desc <= ' ') desc++;	1665	while (desc <= ' ' && desc) desc++;
1534	}	1666	}
1535		1667
1536	end = strchr (desc, ',');	1668	end = strchr (desc, ',');
1537	if (!end)	1669	if (!end)
1538	end = desc + strlen (desc);	1670	end = desc + strlen (desc);
…		…
1540	if (end - desc < 511)	1672	if (end - desc < 511)
1541	{	1673	{
1542	memcpy (buf, desc, end - desc);	1674	memcpy (buf, desc, end - desc);
1543	buf[end - desc] = 0;	1675	buf[end - desc] = 0;
1544		1676
1545	fonts.push_back (new_font (buf, cs));	1677	push_font (new_font (buf, cs));
1546	}	1678	}
1547	else	1679	else
1548	rxvt_warn ("fontset element too long (>511 bytes), ignored.");	1680	rxvt_warn ("fontset element too long (>511 bytes), ignored.\n");
1549		1681
1550	desc = end + 1;	1682	desc = end + 1;
1551	}	1683	}
1552	while (*end);	1684	while (*end);
1553	}	1685	}
…		…
1578	{	1710	{
1579	clear ();	1711	clear ();
1580		1712
1581	fontdesc = strdup (desc);	1713	fontdesc = strdup (desc);
1582		1714
1583	fonts.push_back (new_font (0, CS_UNICODE));	1715	push_font (new_font (0, CS_UNICODE));
1584	realize_font (0);	1716	realize_font (0);
1585		1717
1586	add_fonts (desc);	1718	add_fonts (desc);
1587		1719
1588	return true;	1720	return true;
…		…
1597		1729
1598	return -1;	1730	return -1;
1599	}	1731	}
1600		1732
1601	int	1733	int
1602	rxvt_fontset::find_font (unicode_t unicode)	1734	rxvt_fontset::find_font_idx (unicode_t unicode)
1603	{	1735	{
1604	if (unicode >= 1<<20)	1736	// this limits fmap size. it has to accomodate COMPOSE_HI when UNICODE_3
		1737	if (unicode > 0x1fffff)
1605	return 0;	1738	return 0;
1606		1739
1607	unicode_t hi = unicode >> 8;	1740	unicode_t hi = unicode >> 8;
1608		1741
1609	if (hi < fmap.size ()	1742	if (hi < fmap.size ())
1610	&& fmap[hi]	1743	if (pagemap *pm = fmap[hi])
1611	&& (*fmap[hi])[unicode & 0xff] != 0xff)	1744	if ((*pm)[unicode & 0xff] != 0xff)
1612	return (*fmap[hi])[unicode & 0xff];	1745	return (*pm)[unicode & 0xff];
1613		1746
1614	unsigned int i;	1747	unsigned int i;
1615		1748
1616	for (i = 0; i < fonts.size (); i++)	1749	for (i = 0; i < fonts.size (); i++)
1617	{	1750	{
…		…
1633	goto next_font;	1766	goto next_font;
1634		1767
1635	bool careful;	1768	bool careful;
1636	if (f->has_char (unicode, &prop, careful))	1769	if (f->has_char (unicode, &prop, careful))
1637	{	1770	{
1638	if (careful)	1771	i = (i << 1) \| careful;
1639	i \|= 128;
1640		1772
1641	goto found;	1773	goto found;
1642	}	1774	}
1643		1775
1644	next_font:	1776	next_font:
1645	if (i == fonts.size () - 1)	1777	if (i == fonts.size () - 1)
1646	{	1778	{
		1779	// compose characters are handled by the default font, unless another font takes over
		1780	// we do not go via the fallback list for speed reasons.
		1781	if (IS_COMPOSE (unicode))
		1782	return 0;
		1783
1647	if (fallback->name)	1784	if (fallback->name)
1648	{	1785	{
1649	// search through the fallback list	1786	// search through the fallback list
1650	fonts.push_back (new_font (fallback->name, fallback->cs));	1787	push_font (new_font (fallback->name, fallback->cs));
1651	fallback++;	1788	fallback++;
1652	}	1789	}
1653	else	1790	else
1654	{	1791	{
1655	// try to find a new font.	1792	// try to find a new font.
…		…
1657	// way to configure this and xft is easier to hack in,	1794	// way to configure this and xft is easier to hack in,
1658	// while x11 has more framework in place already.	1795	// while x11 has more framework in place already.
1659	// TODO: this is a real resource hog, xft takes ages(?)	1796	// TODO: this is a real resource hog, xft takes ages(?)
1660	#if XFT && USE_SLOW_LOOKUP	1797	#if XFT && USE_SLOW_LOOKUP
1661	// grab the first xft font that seems suitable	1798	// grab the first xft font that seems suitable
		1799	// TOOD: should go first for cellchar (spacing 110) then mono, then else
1662	FcPattern *p = FcPatternCreate ();	1800	FcPattern *p = FcPatternCreate ();
1663		1801
1664	FcCharSet *s = FcCharSetCreate ();	1802	FcCharSet *s = FcCharSetCreate ();
1665	FcCharSetAddChar (s, unicode);	1803	FcCharSetAddChar (s, unicode);
1666	FcPatternAddCharSet (p, FC_CHARSET, s);	1804	FcPatternAddCharSet (p, FC_CHARSET, s);
…		…
1686	FcPatternDestroy (match);	1824	FcPatternDestroy (match);
1687		1825
1688	if (find_font (font) < 0)	1826	if (find_font (font) < 0)
1689	{	1827	{
1690	char fontname[4096];	1828	char fontname[4096];
1691	sprintf (fontname, "xft:%-.4090s", font);	1829	snprintf (fontname, sizeof (fontname), "xft:%s", font);
1692		1830
1693	fonts.push_back (new_font (fontname, CS_UNICODE));	1831	push_font (new_font (fontname, CS_UNICODE));
1694	}	1832	}
1695		1833
1696	free (font);	1834	free (font);
1697	}	1835	}
1698	#endif	1836	#endif
…		…
1710	while (hi >= fmap.size ())	1848	while (hi >= fmap.size ())
1711	fmap.push_back (0);	1849	fmap.push_back (0);
1712		1850
1713	if (!fmap[hi])	1851	if (!fmap[hi])
1714	{	1852	{
1715	fmap[hi] = (pagemap *)new pagemap;	1853	fmap[hi] = new pagemap;
1716	memset (fmap[hi], 0xff, sizeof (pagemap));	1854	memset (fmap[hi], 0xff, sizeof (pagemap));
1717	}	1855	}
1718		1856
1719	(*fmap[hi])[unicode & 0xff] = i;	1857	(*fmap[hi])[unicode & 0xff] = i;
1720	}	1858	}
1721		1859
1722	return i;	1860	return i;
1723	}	1861	}
1724		1862
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.204 by root, Thu Jun 17 11:45:19 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.204 by root, Thu Jun 17 11:45:19 2021 UTC