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

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.125 by ayin, Sun Nov 25 11:23:18 2007 UTC vs.
Revision 1.208 by root, Fri Jun 18 01:50:14 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
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	---------------------------------------------------------------------/	20	---------------------------------------------------------------------/
21		21
22	#include "../config.h"	22	#include "../config.h"
23	#include "rxvt.h"	23	#include "rxvt.h"
24	#include "rxvtlib.h"
25	#include "rxvtutil.h"	24	#include "rxvtutil.h"
26	#include "rxvtfont.h"	25	#include "rxvtfont.h"
27		26
28	#include <cstdlib>	27	#include <stdlib.h>
29		28
30	#include <inttypes.h>	29	#include <inttypes.h>
		30
		31	#if XFT
		32	# include <fontconfig/fontconfig.h>
		33	#endif
31		34
32	#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
33	#define MAX_OVERLAP_ITALIC (8 + 3) // max. overlap for italic fonts	36	#define MAX_OVERLAP_ITALIC (8 + 3) // max. overlap for italic fonts
34		37
35	#define OVERLAP_OK(w,wcw,prop) ((w) <= ( \	38	#define OVERLAP_OK(w,wcw,prop) ((w) <= ( \
36	(prop)->slant >= rxvt_fontprop::italic \	39	(prop)->slant >= rxvt_fontprop::italic \
37	? ((prop)->width * (wcw) * MAX_OVERLAP_ITALIC + 7) >> 3 \	40	? ((prop)->width * (wcw) * MAX_OVERLAP_ITALIC + 7) >> 3 \
38	: ((prop)->width * (wcw) * MAX_OVERLAP_ROMAN + 7) >> 3 \	41	: ((prop)->width * (wcw) * MAX_OVERLAP_ROMAN + 7) >> 3 \
39	))	42	))
40		43
41	const struct rxvt_fallback_font {	44	static const struct rxvt_fallback_font {
42	codeset cs;	45	codeset cs;
43	const char *name;	46	const char *name;
44	} fallback_fonts[] = {	47	} fallback_fonts[] = {
45	{ CS_ISO8859_1, "----r-------c-*-iso8859-1" },	48	{ CS_ISO8859_1, "----r-------c-*-iso8859-1" },
46	{ CS_ISO8859_15, "----r-------c-*-iso8859-15" },	49	{ CS_ISO8859_15, "----r-------c-*-iso8859-15" },
…		…
80		83
81	// japanese	84	// japanese
82	#if ENCODING_JP \|\| ENCODING_JP_EXT	85	#if ENCODING_JP \|\| ENCODING_JP_EXT
83	# if XFT	86	# if XFT
84	// prefer xft for complex scripts	87	// prefer xft for complex scripts
		88	{ CS_JIS0208_1990_0, "xft:Sazanami Mincho:antialias=false" },
85	{ CS_JIS0208_1990_0, "xft:Kochi Gothic:antialias=false" },	89	{ CS_JIS0208_1990_0, "xft:Kochi Gothic:antialias=false" },
86	{ CS_JIS0208_1990_0, "xft:Sazanami Mincho:antialias=false" },
87	{ CS_JIS0208_1990_0, "xft:Mincho:antialias=false" },	90	{ CS_JIS0208_1990_0, "xft:Mincho:antialias=false" },
88	{ CS_JIS0208_1990_0, "xft::lang=ja:antialias=false" },	91	{ CS_JIS0208_1990_0, "xft::lang=ja:antialias=false" },
89	# endif	92	# endif
90	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },	93	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },
91	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },	94	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },
…		…
129	{ CS_KSC5601_1987_0, "xft:Baekmuk Gulim:antialias=false" },	132	{ CS_KSC5601_1987_0, "xft:Baekmuk Gulim:antialias=false" },
130	{ CS_KSC5601_1987_0, "xft::lang=ko:antialias=false" },	133	{ CS_KSC5601_1987_0, "xft::lang=ko:antialias=false" },
131	# endif	134	# endif
132	#endif	135	#endif
133		136
134	{ CS_UNICODE, "--lucidatypewriter---------m--iso10646-1" },
135	//{ 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.
136	#if XFT	138	#if XFT
137	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },	139	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },
138	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },	140	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },
139	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },	141	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },
…		…
156	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',	158	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',
157	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ	159	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ
158	0x304c, 0x672c, // が本	160	0x304c, 0x672c, // が本
159	};	161	};
160		162
161	#define NUM_EXTENT_TEST_CHARS (sizeof (extent_test_chars) / sizeof (extent_test_chars[0]))
162
163	#define dTermDisplay Display *disp = term->dpy	163	#define dTermDisplay Display *disp = term->dpy
164	#define dTermGC GC gc = term->gc	164	#define dTermGC GC gc = term->gc
165		165
166	/////////////////////////////////////////////////////////////////////////////	166	/////////////////////////////////////////////////////////////////////////////
167		167
…		…
217	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset)	217	: name(0), width(rxvt_fontprop::unset), height(rxvt_fontprop::unset)
218	{	218	{
219	}	219	}
220		220
221	void	221	void
222	rxvt_font::set_name (char *name)	222	rxvt_font::set_name (char *name_)
223	{	223	{
224	if (this->name == name)	224	if (name == name_)
225	return;	225	return;
226		226
227	if (this->name) free (this->name); // let the compiler optimize	227	if (name) free (name); // let the compiler optimize
228	this->name = name;	228	name = name_;
229	}	229	}
230		230
231	void	231	void
232	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
233	{	233	{
…		…
237	if (color == Color_bg \|\| color == Color_transparent)	237	if (color == Color_bg \|\| color == Color_transparent)
238	XClearArea (disp, d, x, y, w, h, false);	238	XClearArea (disp, d, x, y, w, h, false);
239	else if (color >= 0)	239	else if (color >= 0)
240	{	240	{
241	#if XFT	241	#if XFT
242	bool done = false;	242	Picture dst;
243	#ifdef HAVE_BG_PIXMAP	243
244	if (term->bgPixmap.pixmap && color >= 0 && term->pix_colors[color].c.color.alpha < 0x0ff00)	244	# ifdef HAVE_IMG
245	{	245	if (term->bg_img
		246	&& !term->pix_colors[color].is_opaque ()
246	Picture dst = XftDrawPicture (d);	247	&& ((dst = XftDrawPicture (d))))
247	if (dst != 0)
248	{	248	{
249	XClearArea (disp, d, x, y, w, h, false);	249	XClearArea (disp, d, x, y, w, h, false);
		250
250	Picture solid_color_pict = XftDrawSrcPicture (d, &term->pix_colors[color].c);	251	Picture solid_color_pict = XftDrawSrcPicture (d, &term->pix_colors[color].c);
251	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);
252	done = true;
253	}	253	}
254	}	254	else
255	#endif	255	# endif
256	if (!done)
257	XftDrawRect (d, &term->pix_colors[color].c, x, y, w, h);	256	XftDrawRect (d, &term->pix_colors[color].c, x, y, w, h);
		257
258	#else	258	#else
259	XSetForeground (disp, gc, term->pix_colors[color]);	259	XSetForeground (disp, gc, term->pix_colors[color]);
260	XFillRectangle (disp, d, gc, x, y, w, h);	260	XFillRectangle (disp, d, gc, x, y, w, h);
261	#endif	261	#endif
262	}	262	}
263	}	263	}
264		264
265	/////////////////////////////////////////////////////////////////////////////	265	/////////////////////////////////////////////////////////////////////////////
266		266
267	struct rxvt_font_default : rxvt_font {	267	struct rxvt_font_default : rxvt_font
		268	{
268	struct rxvt_fontset *fs;	269	struct rxvt_fontset *fs;
269		270
270	rxvt_font_default (rxvt_fontset *fs)	271	rxvt_font_default (rxvt_fontset *fs)
271	: rxvt_font ()	272	: rxvt_font ()
272	{	273	{
…		…
312	if (unicode >= 0x2500 && unicode <= 0x259f &&	313	if (unicode >= 0x2500 && unicode <= 0x259f &&
313	!term->option (Opt_skipBuiltinGlyphs))	314	!term->option (Opt_skipBuiltinGlyphs))
314	return true;	315	return true;
315	#endif	316	#endif
316		317
317	if (IS_COMPOSE (unicode))	318	// we do not check for IS_COMPOSE here, as this would
318	return true;	319	// rob other fonts from taking over.
319		320
320	switch (unicode)	321	switch (unicode)
321	{	322	{
322	case ZERO_WIDTH_CHAR:	323	case ZERO_WIDTH_CHAR:
323	case NOCHAR:	324	case NOCHAR:
…		…
344		345
345	XSetForeground (disp, gc, term->pix_colors[fg]);	346	XSetForeground (disp, gc, term->pix_colors[fg]);
346		347
347	while (len)	348	while (len)
348	{	349	{
		350	const text_t *tp = text;
		351	text_t t = *tp;
		352
		353	while (++text, --len && *text == NOCHAR)
		354	;
		355
349	#if ENABLE_COMBINING	356	#if ENABLE_COMBINING
350	compose_char *cc;	357	compose_char *cc;
351	#endif	358	#endif
352	const text_t *tp = text;
353	text_t t = *tp;
354
355	while (++text, --len && *text == NOCHAR)
356	;
357
358	int width = text - tp;	359	int width = text - tp;
359	int fwidth = term->fwidth * width;	360	int fwidth = term->fwidth * width;
360		361
361	#ifdef BUILTIN_GLYPHS	362	#ifdef BUILTIN_GLYPHS
362	if (0x2500 <= t && t <= 0x259f)	363	if (0x2500 <= t && t <= 0x259f)
…		…
444	#endif	445	#endif
445	#if ENABLE_COMBINING	446	#if ENABLE_COMBINING
446	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))	447	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
447	{	448	{
448	min_it (width, 2); // we only support wcwidth up to 2	449	min_it (width, 2); // we only support wcwidth up to 2
449
450	text_t chrs[2];	450	text_t chrs[2];
451	chrs [1] = NOCHAR;	451	chrs [1] = NOCHAR;
452		452
453	*chrs = cc->c1;	453	*chrs = cc->c1;
454	rxvt_font f1 = (fs)[fs->find_font (cc->c1)];	454	rxvt_font f1 = (fs)[fs->find_font_idx (cc->c1)];
455	f1->draw (d, x, y, chrs, width, fg, bg);	455	f1->draw (d, x, y, chrs, width, fg, bg);
456		456
457	if (cc->c2 != NOCHAR)	457	if (cc->c2 != NOCHAR)
458	{	458	{
459	bool careful;	459	bool careful;
460		460
461	// prefer font of first character, for no good reasons	461	// prefer font of first character, for no good reasons
462	*chrs = cc->c2;	462	*chrs = cc->c2;
463	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)	463	rxvt_font *f2 = (f1->has_char (cc->c2, 0, careful) && !careful)
464	? f1	464	? f1
465	: (*fs)[fs->find_font (cc->c2)];	465	: (*fs)[fs->find_font_idx (cc->c2)];
466		466
467	f2->draw (d, x, y, chrs, width, fg, Color_none);	467	f2->draw (d, x, y, chrs, width, fg, Color_none);
468	}	468	}
469	}	469	}
470	#endif	470	#endif
…		…
474	case '\t':	474	case '\t':
475	case ZERO_WIDTH_CHAR:	475	case ZERO_WIDTH_CHAR:
476	case NOCHAR:	476	case NOCHAR:
477	break;	477	break;
478		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
479	default:	488	default:
480	XDrawRectangle (disp, d, gc, x + 2, y + 2,	489	XDrawRectangle (disp, d, gc, x + 2, y + 2,
481	fwidth - 4, term->fheight - 4);	490	fwidth - 4, term->fheight - 4);
482	}	491	}
483		492
484	x += fwidth;	493	x += fwidth;
485	}	494	}
486	}	495	}
487		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
488	/////////////////////////////////////////////////////////////////////////////	552	/////////////////////////////////////////////////////////////////////////////
489		553
490	struct rxvt_font_x11 : rxvt_font {	554	struct rxvt_font_x11 : rxvt_font
		555	{
491	rxvt_font_x11 () { f = 0; }	556	rxvt_font_x11 () { f = 0; }
492		557
493	void clear ();	558	void clear ();
494		559
495	rxvt_fontprop properties ();	560	rxvt_fontprop properties ();
…		…
500		565
501	void draw (rxvt_drawable &d, int x, int y,	566	void draw (rxvt_drawable &d, int x, int y,
502	const text_t *text, int len,	567	const text_t *text, int len,
503	int fg, int bg);	568	int fg, int bg);
504		569
505	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
506	XFontStruct *f;	571	XFontStruct *f;
507	bool enc2b, encm;	572	bool enc2b, encm;
508		573
509	char get_property (XFontStruct f, Atom property, const char *repl) const;	574	char get_property (XFontStruct f, Atom property, const char *repl) const;
510	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);
…		…
632		697
633	if (slashes >= 13 && (!old \|\| *field == old))	698	if (slashes >= 13 && (!old \|\| *field == old))
634	{	699	{
635	size_t len = field - name;	700	size_t len = field - name;
636	ptr = (char )malloc (len + strlen (replace) + strlen (end) + 1);	701	ptr = (char )malloc (len + strlen (replace) + strlen (end) + 1);
637	strncpy (*ptr, name, len);	702	memcpy (*ptr, name, len);
638	strcpy (*ptr + len, replace);	703	strcpy (*ptr + len, replace);
639	strcat (*ptr, end);	704	strcat (*ptr, end);
640		705
641	return true;	706	return true;
642	}	707	}
…		…
667	f = XLoadQueryFont (disp, name);	732	f = XLoadQueryFont (disp, name);
668		733
669	if (!f)	734	if (!f)
670	return false;	735	return false;
671		736
672	char *new_name = get_property (f, XA_FONT, name);	737	char *new_name = get_property (f, XA_FONT, 0);
673		738
674	if (new_name)	739	if (new_name)
675	set_name (new_name);	740	set_name (new_name);
676	else	741	else
677	rxvt_warn ("font '%s' has no FONT property, continuing without.", name);	742	rxvt_warn ("font '%s' has no FONT property, continuing without.\n", name);
678		743
679	XFreeFont (disp, f);	744	XFreeFont (disp, f);
680	f = 0;	745	f = 0;
681	}	746	}
682		747
…		…
739	free (fname);	804	free (fname);
740	if (replace_field (&fname, list[i], 11, '0', "0"))	805	if (replace_field (&fname, list[i], 11, '0', "0"))
741	diff += 300; // more heavily penalize what looks like scaled bitmap fonts	806	diff += 300; // more heavily penalize what looks like scaled bitmap fonts
742	}	807	}
743		808
744	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);
745	continue;	815	continue;
746		816	}
747	if (prop.height != rxvt_fontprop::unset
748	&& p.height > prop.height) // weed out too large fonts
749	continue;
750		817
751	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;
752	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);
753	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);
754	//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);
…		…
760	XFreeFontNames (list);	827	XFreeFontNames (list);
761		828
762	// 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
763	for (;;)	830	for (;;)
764	{	831	{
765	font_weight *best = fonts + count - 1;	832	font_weight *best = fonts;
766		833
767	for (font_weight *w = best; w-- > fonts; )	834	for (font_weight *w = fonts + 1; w < fonts + count; w++)
768	if (w->diff <= best->diff)	835	if (w->diff < best->diff)
769	best = w;	836	best = w;
770		837
771	if (!best->name	838	if (!best->name
772	\|\| !(f = XLoadQueryFont (disp, best->name)))	839	\|\| !(f = XLoadQueryFont (disp, best->name)))
773	break;	840	break;
…		…
793	return false;	860	return false;
794		861
795	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);	862	char *registry = get_property (f, term->xa [XA_CHARSET_REGISTRY], 0);
796	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);	863	char *encoding = get_property (f, term->xa [XA_CHARSET_ENCODING], 0);
797		864
		865	cs = CS_UNKNOWN;
		866
798	if (registry && encoding)	867	if (registry && encoding)
799	{	868	{
800	char charset[64];	869	char charset[64];
801	snprintf (charset, 64, "%s-%s", registry, encoding);	870	snprintf (charset, 64, "%s-%s", registry, encoding);
802		871
803	cs = codeset_from_name (charset);	872	cs = codeset_from_name (charset);
804	}	873
805	else	874	if (cs == CS_UNKNOWN)
		875	rxvt_warn ("%s: cannot deduce encoding from registry/encoding properties \"%s\", ignoring font.\n", name, charset);
806	{	876	}
		877
		878	free (registry);
		879	free (encoding);
		880
		881	if (cs == CS_UNKNOWN)
		882	{
807	const char *charset = get_property (f, XA_FONT, 0);	883	char *value = get_property (f, XA_FONT, 0);
		884	const char *charset = value;
808		885
809	if (!charset)	886	if (!charset)
810	charset = name;	887	charset = name;
811		888
812	int count = 13;	889	int count = 13;
813	while (*charset)	890	while (*charset)
814	if (*charset++ == '-' && !--count)	891	if (*charset++ == '-' && !--count)
815	break;	892	break;
816		893
817	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)
818	}	902	{
819		903	clear ();
820	free (registry);	904	return false;
821	free (encoding);	905	}
822		906
823	if (cs == CS_UNICODE)	907	if (cs == CS_UNICODE)
824	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
825		909
826	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;	910	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;
…		…
851	}	935	}
852	#endif	936	#endif
853		937
854	width = 1;	938	width = 1;
855		939
856	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++)
857	{	941	{
858	if (FROM_UNICODE (cs, *t) == NOCHAR)	942	if (FROM_UNICODE (cs, *t) == NOCHAR)
859	continue;	943	continue;
860		944
861	// ignore characters we wouldn't use anyways	945	// ignore characters we wouldn't use anyways
862	bool careful;	946	bool careful;
863	if (!has_char (*t, &prop, careful))	947	if (!has_char (*t, &prop, careful))
864	continue;	948	continue;
865		949
866	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 };
867		952
868	XCharStruct g;	953	XCharStruct g;
869	int dir_ret, asc_ret, des_ret;	954	int dir_ret, asc_ret, des_ret;
870	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);	955	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);
871		956
…		…
873	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;	958	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;
874		959
875	if (width < g.width) width = g.width;	960	if (width < g.width) width = g.width;
876	}	961	}
877		962
878	if (cs == CS_UNKNOWN)	963	#if 0 // do it per-character
		964	if (prop && width > prop->width)
879	{	965	{
880	fprintf (stderr, "unable to deduce codeset, ignoring font '%s'\n", name);
881
882	clear ();	966	clear ();
883	return false;	967	return false;
884	}	968	}
885
886	#if 0 // do it per-character
887	if (prop && width > prop->width)
888	{
889	clear ();
890	return false;
891	}
892	#endif	969	#endif
893		970
894	return true;	971	return true;
895	}	972	}
896		973
…		…
905	}	982	}
906		983
907	bool	984	bool
908	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
909	{	986	{
		987	careful = false;
		988
910	uint32_t ch = FROM_UNICODE (cs, unicode);	989	uint32_t ch = FROM_UNICODE (cs, unicode);
911		990
912	if (ch == NOCHAR)	991	if (ch == NOCHAR)
913	return false;	992	return false;
914		993
915	/* check wether the character exists in _this_ font. horrible. */	994	/* check whether the character exists in _this_ font. horrible. */
916	XCharStruct *xcs;	995	XCharStruct *xcs;
917		996
918	if (encm)	997	if (encm)
919	{	998	{
920	unsigned char byte1 = ch >> 8;	999	unsigned char byte1 = ch >> 8;
…		…
950	return false;	1029	return false;
951		1030
952	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1031	if (!prop \|\| prop->width == rxvt_fontprop::unset)
953	return true;	1032	return true;
954		1033
955	// check wether character overlaps previous/next character	1034	// check whether character overlaps previous/next character
956	int w = xcs->rbearing - xcs->lbearing;	1035	int w = xcs->rbearing - xcs->lbearing;
957	int wcw = max (WCWIDTH (unicode), 1);	1036	int wcw = max (WCWIDTH (unicode), 1);
958		1037
959	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;	1038	careful = xcs->lbearing < 0 \|\| xcs->rbearing > prop->width * wcw;
960		1039
…		…
977	dTermDisplay;	1056	dTermDisplay;
978	dTermGC;	1057	dTermGC;
979		1058
980	bool slow = this->slow	1059	bool slow = this->slow
981	\|\| width != term->fwidth	1060	\|\| width != term->fwidth
982	\|\| height != term->fheight;	1061	\|\| height != term->fheight
		1062	\|\| ascent != f->ascent;
983		1063
984	int base = ascent; // sorry, incorrect: term->fbase;	1064	int base = ascent; // sorry, incorrect: term->fbase;
985		1065
986	XGCValues v;	1066	XGCValues v;
987	v.foreground = term->pix_colors[fg];	1067	v.foreground = term->pix_colors[fg];
…		…
1055		1135
1056	/////////////////////////////////////////////////////////////////////////////	1136	/////////////////////////////////////////////////////////////////////////////
1057		1137
1058	#if XFT	1138	#if XFT
1059		1139
1060	struct rxvt_font_xft : rxvt_font {	1140	struct rxvt_font_xft : rxvt_font
		1141	{
1061	rxvt_font_xft () { f = 0; }	1142	rxvt_font_xft ()
		1143	{
		1144	f = 0;
		1145	}
1062		1146
1063	void clear ();	1147	void clear ();
1064		1148
1065	rxvt_fontprop properties ();	1149	rxvt_fontprop properties ();
1066		1150
…		…
1134	FcPatternAddInteger (p, FC_SLANT, prop.slant);	1218	FcPatternAddInteger (p, FC_SLANT, prop.slant);
1135		1219
1136	#if 0 // clipping unfortunately destroys our precious double-width-characters	1220	#if 0 // clipping unfortunately destroys our precious double-width-characters
1137	// clip width, we can't do better, or can we?	1221	// clip width, we can't do better, or can we?
1138	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)	1222	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
1139	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop->width);	1223	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
1140	#endif	1224	#endif
1141		1225
1142	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)	1226	if (FcPatternGet (p, FC_MINSPACE, 0, &v) != FcResultMatch)
1143	FcPatternAddBool (p, FC_MINSPACE, 1);	1227	FcPatternAddBool (p, FC_MINSPACE, 1);
1144		1228
…		…
1156	int ftheight = 0;	1240	int ftheight = 0;
1157	bool success = true;	1241	bool success = true;
1158		1242
1159	for (;;)	1243	for (;;)
1160	{	1244	{
		1245	p = FcPatternDuplicate (match);
1161	f = XftFontOpenPattern (disp, FcPatternDuplicate (match));	1246	f = XftFontOpenPattern (disp, p);
1162		1247
1163	if (!f)	1248	if (!f)
1164	{	1249	{
		1250	FcPatternDestroy (p);
1165	success = false;	1251	success = false;
1166	break;	1252	break;
1167	}	1253	}
1168		1254
1169	FT_Face face = XftLockFace (f);	1255	FT_Face face = XftLockFace (f);
…		…
1177		1263
1178	XftUnlockFace (f);	1264	XftUnlockFace (f);
1179		1265
1180	int glheight = height;	1266	int glheight = height;
1181		1267
1182	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	1268	for (uint16_t *t = extent_test_chars; t < extent_test_chars + ecb_array_length (extent_test_chars); t++)
1183	{	1269	{
1184	FcChar16 ch = *t;	1270	FcChar16 ch = *t;
1185		1271
1186	if (cs != CS_UNICODE	1272	if (cs != CS_UNICODE
1187	&& ch > 0x100	1273	&& ch > 0x100
…		…
1206	if (glheight < g.height - g.y) glheight = g.height - g.y;	1292	if (glheight < g.height - g.y) glheight = g.height - g.y;
1207	}	1293	}
1208		1294
1209	if (!width)	1295	if (!width)
1210	{	1296	{
1211	rxvt_warn ("unable to calculate font width for '%s', ignoring.\n", name);	1297	rxvt_warn ("unable to calculate font width for '%s', using max_advance_width.\n", name);
1212		1298	width = f->max_advance_width;
1213	XftFontClose (disp, f);
1214	f = 0;
1215
1216	success = false;
1217	break;	1299	break;
1218	}	1300	}
1219		1301
1220	if (prop.height == rxvt_fontprop::unset	1302	if (prop.height == rxvt_fontprop::unset
1221	\|\| (height <= prop.height && glheight <= prop.height)	1303	\|\| (height <= prop.height && glheight <= prop.height)
…		…
1256	bool	1338	bool
1257	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	1339	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
1258	{	1340	{
1259	careful = false;	1341	careful = false;
1260		1342
		1343	rxvt_compose_expand_static<FcChar32> exp;
		1344	FcChar32 *chrs = exp (unicode);
		1345	int nchrs = exp.length (chrs);
		1346
		1347	// allm chars in sequence must be available
		1348	for (int i = 0; i < nchrs; ++i)
1261	if (!XftCharExists (term->dpy, f, unicode))	1349	if (!XftCharExists (term->dpy, f, chrs [i]))
1262	return false;	1350	return false;
1263		1351
1264	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1352	if (!prop \|\| prop->width == rxvt_fontprop::unset)
1265	return true;	1353	return true;
1266		1354
1267	// check character against base font bounding box	1355	int wcw = max (WCWIDTH (chrs [0]), 1);
1268	FcChar32 ch = unicode;	1356
		1357	// we check against all glyph sizes. this is probably wrong,
		1358	// due to the way ->draw positions these glyphs.
		1359	for (int i = 0; i < nchrs; ++i)
		1360	{
1269	XGlyphInfo g;	1361	XGlyphInfo g;
1270	XftTextExtents32 (term->dpy, f, &ch, 1, &g);	1362	XftTextExtents32 (term->dpy, f, chrs + i, 1, &g);
1271		1363
1272	int w = g.width - g.x;	1364	int w = g.width - g.x;
1273	int wcw = max (WCWIDTH (unicode), 1);
1274		1365
1275	careful = g.x > 0 \|\| w > prop->width * wcw;	1366	careful = g.x > 0 \|\| w > prop->width * wcw;
1276		1367
1277	if (careful && !OVERLAP_OK (w, wcw, prop))	1368	if (careful && !OVERLAP_OK (w, wcw, prop))
1278	return false;	1369	return false;
1279		1370
1280	// this weeds out _totally_ broken fonts, or glyphs	1371	// this weeds out _totally_ broken fonts, or glyphs
1281	if (!OVERLAP_OK (g.xOff, wcw, prop))	1372	if (!OVERLAP_OK (g.xOff, wcw, prop))
1282	return false;	1373	return false;
		1374	}
1283		1375
1284	return true;	1376	return true;
1285	}	1377	}
1286		1378
1287	void	1379	void
1288	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,	1380	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
1289	const text_t *text, int len,	1381	const text_t *text, int len,
1290	int fg, int bg)	1382	int fg, int bg)
1291	{	1383	{
1292	XGlyphInfo extents;	1384	//XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);//D
1293	XftGlyphSpec enc = (XftGlyphSpec )rxvt_temp_buf (len * sizeof (XftGlyphSpec));
1294	XftGlyphSpec *ep = enc;	1385	//XftGlyphSpec *ep = enc;//D
		1386	static vector<XftGlyphSpec> enc; enc.resize (0); // static to avoid malloc, still slow
1295		1387
1296	dTermDisplay;	1388	dTermDisplay;
1297	dTermGC;	1389	dTermGC;
1298		1390
1299	int w = term->fwidth * len;	1391	int w = term->fwidth * len;
1300	int h = term->fheight;	1392	int h = term->fheight;
1301		1393
1302	/* TODO: this logic needs some more thinking, since we no longer do pseudo-transparency.	1394	bool buffered = bg >= Color_transparent
1303	* Maybe make buffering into a resource flag? Compile time option doesn't seems like a	1395	&& term->option (Opt_buffered);
1304	* good idea from the perspective of packaging for wide variety of user configs.	1396
1305	*/
1306	bool buffered = true
1307	#ifdef FORCE_UNBUFFERED_XFT
1308	&& bg >= 0
1309	#endif
1310	;
1311	// cut trailing spaces	1397	// cut trailing spaces
1312	while (len && text [len - 1] == ' ')	1398	while (len && text [len - 1] == ' ')
1313	len--;	1399	len--;
1314		1400
1315	int x_ = buffered ? 0 : x;	1401	int x_ = buffered ? 0 : x;
1316	int y_ = buffered ? 0 : y;	1402	int y_ = buffered ? 0 : y;
1317		1403
1318	while (len)	1404	while (len)
1319	{	1405	{
1320	int cwidth = term->fwidth;	1406	int cwidth = term->fwidth;
		1407
		1408	rxvt_compose_expand_static<FcChar32> exp;
1321	FcChar32 fc = *text++; len--;	1409	FcChar32 chrs = exp (text++); len--;
		1410	int nchrs = exp.length (chrs);
1322		1411
1323	while (len && *text == NOCHAR)	1412	while (len && *text == NOCHAR)
1324	text++, len--, cwidth += term->fwidth;	1413	text++, len--, cwidth += term->fwidth;
1325		1414
1326	if (fc != ' ') // skip spaces	1415	if (chrs [0] != ' ') // skip spaces
		1416	{
		1417	#if 0
		1418	FT_UInt glyphs [decltype (exp)::max_size];
		1419
		1420	for (int i = 0; i < nchrs; ++i)
		1421	glyphs [i] = XftCharIndex (disp, f, chrs [i]);
		1422
		1423	for (int i = 0; i < nchrs; ++i)
1327	{	1424	{
		1425	XGlyphInfo ep;
		1426	XftGlyphExtents (disp, f, glyphs+i, 1, &ep);
		1427	printf ("gs %x g %x + %d,%d o %d,%d wh %d,%d\n", chrs[i],glyphs[i],ep.x,ep.y,ep.xOff,ep.yOff,ep.width,ep.height);
		1428	}
		1429	#endif
		1430
		1431	for (int i = 0; i < nchrs; ++i)
		1432	{
1328	FT_UInt glyph = XftCharIndex (disp, f, fc);	1433	FT_UInt glyph = XftCharIndex (disp, f, chrs [i]);
		1434	XGlyphInfo extents;
1329	XftGlyphExtents (disp, f, &glyph, 1, &extents);	1435	XftGlyphExtents (disp, f, &glyph, 1, &extents);
1330		1436
1331	ep->glyph = glyph;	1437	XftGlyphSpec ep;
		1438
1332	ep->x = x_ + (cwidth - extents.xOff >> 1);	1439	int cx = x_ + (cwidth - extents.xOff >> 1);
1333	ep->y = y_ + ascent;	1440	int cy = y_ + ascent;
1334		1441
		1442	// lone combining char
1335	if (extents.xOff == 0)	1443	if (extents.xOff == 0)
1336	ep->x = x_ + cwidth;	1444	cx = x_ + cwidth;
1337		1445
1338	ep++;	1446	ep.glyph = glyph;
		1447	ep.x = cx + extents.x;
		1448	ep.y = cy;
		1449
		1450	enc.push_back (ep);
		1451	}
1339	}	1452	}
1340		1453
1341	x_ += cwidth;	1454	x_ += cwidth;
1342	}	1455	}
1343		1456
1344	if (buffered)	1457	if (buffered)
1345	{	1458	{
1346	bool back_rendered = false;	1459	if (!enc.empty ())
1347	if (ep != enc)
1348	{	1460	{
1349	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);	1461	rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);
1350		1462
1351	#ifdef HAVE_BG_PIXMAP	1463	#ifdef HAVE_IMG
		1464	Picture dst = 0; // the only assignment is done conditionally in the following if condition
		1465
1352	if (term->bgPixmap.pixmap)	1466	if (term->bg_img
		1467	&& (bg == Color_transparent \|\| bg == Color_bg
		1468	\|\| (bg >= 0 && !term->pix_colors[bg].is_opaque () && ((dst = XftDrawPicture (d2))))))
1353	{	1469	{
1354	Picture dst = 0;	1470	int src_x = x, src_y = y;
1355		1471
1356	if (bg >= 0 && term->pix_colors[bg].c.color.alpha < 0x0ff00)	1472	if (term->bg_flags & rxvt_term::BG_IS_TRANSPARENT)
1357	dst = XftDrawPicture (d2);
1358
1359	if (bg < 0 \|\| dst != 0)
1360	{	1473	{
1361	int src_x = x, src_y = y ;
1362
1363	if (term->bgPixmap.is_parentOrigin ())
1364	{
1365	src_x += term->window_vt_x;	1474	src_x += term->window_vt_x;
1366	src_y += term->window_vt_y;	1475	src_y += term->window_vt_y;
1367	}	1476	}
1368		1477
1369	if (term->bgPixmap.pmap_width >= src_x+w	1478	if (term->bg_img->w >= src_x + w
1370	&& term->bgPixmap.pmap_height >= src_y+h)	1479	&& term->bg_img->h >= src_y + h)
1371	{	1480	{
1372	XCopyArea (disp, term->bgPixmap.pixmap, d2, gc,	1481	XCopyArea (disp, term->bg_img->pm, d2, gc,
1373	src_x, src_y, w, h, 0, 0);	1482	src_x, src_y, w, h, 0, 0);
1374	}	1483	}
1375	else	1484	else
1376	{	1485	{
1377	XGCValues gcv;	1486	XGCValues gcv;
1378		1487
1379	gcv.fill_style = FillTiled;	1488	gcv.fill_style = FillTiled;
1380	gcv.tile = term->bgPixmap.pixmap;	1489	gcv.tile = term->bg_img->pm;
1381	gcv.ts_x_origin = -src_x;	1490	gcv.ts_x_origin = -src_x;
1382	gcv.ts_y_origin = -src_y;	1491	gcv.ts_y_origin = -src_y;
1383		1492
1384	XChangeGC (disp, gc,	1493	XChangeGC (disp, gc,
1385	GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin \| GCFillStyle,	1494	GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin \| GCFillStyle,
1386	&gcv);	1495	&gcv);
1387		1496
1388	XFillRectangle (disp, d2, gc, 0, 0, w, h);	1497	XFillRectangle (disp, d2, gc, 0, 0, w, h);
1389		1498
1390	gcv.fill_style = FillSolid;	1499	gcv.fill_style = FillSolid;
1391	XChangeGC (disp, gc, GCFillStyle, &gcv);	1500	XChangeGC (disp, gc, GCFillStyle, &gcv);
1392	}	1501	}
1393		1502
1394	if (bg >= 0)	1503	if (dst)
1395	{	1504	{
1396	Picture solid_color_pict = XftDrawSrcPicture (d2, &term->pix_colors[bg].c);	1505	Picture solid_color_pict = XftDrawSrcPicture (d2, &term->pix_colors[bg].c);
		1506
		1507	// dst can only be set when bg >= 0
1397	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, 0, 0, w, h);	1508	XRenderComposite (disp, PictOpOver, solid_color_pict, None, dst, 0, 0, 0, 0, 0, 0, w, h);
1398	}
1399
1400	back_rendered = true;
1401	}	1509	}
1402	}	1510	}
		1511	else
1403	#endif	1512	#endif
1404
1405	if (bg >= 0 && !back_rendered)
1406	XftDrawRect (d2, &term->pix_colors[bg].c, 0, 0, w, h);	1513	XftDrawRect (d2, &term->pix_colors[bg >= 0 ? bg : Color_bg].c, 0, 0, w, h);
1407		1514
1408	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);	1515	XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, &enc[0], enc.size ());
1409	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);	1516	XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);
1410	}	1517	}
1411	else	1518	else
1412	clear_rect (d, x, y, w, h, bg);	1519	clear_rect (d, x, y, w, h, bg);
1413	}	1520	}
1414	else	1521	else
1415	{	1522	{
1416	clear_rect (d, x, y, w, h, bg);	1523	clear_rect (d, x, y, w, h, bg);
1417	XftDrawGlyphSpec (d, &term->pix_colors[fg].c, f, enc, ep - enc);	1524	XftDrawGlyphSpec (d, &term->pix_colors[fg].c, f, &enc[0], enc.size ());
1418	}	1525	}
1419	}	1526	}
1420		1527
1421	#endif	1528	#endif
1422		1529
…		…
1439	prop.width = prop.height = prop.ascent = prop.weight = prop.slant	1546	prop.width = prop.height = prop.ascent = prop.weight = prop.slant
1440	= rxvt_fontprop::unset;	1547	= rxvt_fontprop::unset;
1441	force_prop = false;	1548	force_prop = false;
1442		1549
1443	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)	1550	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
1444	FONT_UNREF (*i);	1551	(*i)->unref ();
1445		1552
1446	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)	1553	for (pagemap **p = fmap.begin (); p != fmap.end (); p++)
1447	delete *p;	1554	delete *p;
1448		1555
1449	free (fontdesc); fontdesc = 0;	1556	free (fontdesc); fontdesc = 0;
…		…
1451	fonts.clear ();	1558	fonts.clear ();
1452		1559
1453	fallback = fallback_fonts;	1560	fallback = fallback_fonts;
1454	}	1561	}
1455		1562
		1563	void
		1564	rxvt_fontset::prepare_font (rxvt_font *font, codeset cs)
		1565	{
		1566	font->set_term (term);
		1567
		1568	font->cs = cs;
		1569	font->loaded = false;
		1570	}
		1571
1456	rxvt_font *	1572	rxvt_font *
1457	rxvt_fontset::new_font (const char *name, codeset cs)	1573	rxvt_fontset::new_font (const char *name, codeset cs)
1458	{	1574	{
1459	rxvt_font *f;	1575	rxvt_font *f;
1460		1576
…		…
1476	f = new rxvt_font_x11;	1592	f = new rxvt_font_x11;
1477	}	1593	}
1478	else	1594	else
1479	f = new rxvt_font_x11;	1595	f = new rxvt_font_x11;
1480		1596
1481	f->set_term (term);
1482	f->set_name (strdup (name));	1597	f->set_name (strdup (name));
1483		1598	prepare_font (f, cs);
1484	f->cs = cs;
1485	f->loaded = false;
1486		1599
1487	return f;	1600	return f;
1488	}	1601	}
1489		1602
1490	/////////////////////////////////////////////////////////////////////////////	1603	/////////////////////////////////////////////////////////////////////////////
		1604
		1605	void
		1606	rxvt_fontset::push_font (rxvt_font *font)
		1607	{
		1608	// the fontCount index is reserved for the overflow font, it is only
		1609	// necessary when we get fontCount or more fonts, as they cannot be
		1610	// represented in the rendition.
		1611	if (fonts.size () == fontCount)
		1612	{
		1613	rxvt_font *f = new rxvt_font_overflow (this);
		1614
		1615	prepare_font (f, CS_UNICODE);
		1616	fonts.push_back (f);
		1617	}
		1618
		1619	fonts.push_back (font);
		1620	}
1491		1621
1492	void	1622	void
1493	rxvt_fontset::add_fonts (const char *desc)	1623	rxvt_fontset::add_fonts (const char *desc)
1494	{	1624	{
1495	if (desc)	1625	if (desc)
…		…
1524	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);	1654	cs = codeset_from_name (spec + sizeof ("codeset=") - 1);
1525	else	1655	else
1526	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);	1656	rxvt_warn ("unknown parameter '%s' in font specification, skipping.\n", spec);
1527		1657
1528	desc++;	1658	desc++;
1529	while (*desc <= ' ') desc++;	1659	while (desc <= ' ' && desc) desc++;
1530	}	1660	}
1531		1661
1532	end = strchr (desc, ',');	1662	end = strchr (desc, ',');
1533	if (!end)	1663	if (!end)
1534	end = desc + strlen (desc);	1664	end = desc + strlen (desc);
1535		1665
1536	if (end - desc < 511)	1666	if (end - desc < 511)
1537	{	1667	{
1538	strncpy (buf, desc, end - desc);	1668	memcpy (buf, desc, end - desc);
1539	buf[end - desc] = 0;	1669	buf[end - desc] = 0;
1540		1670
1541	fonts.push_back (new_font (buf, cs));	1671	push_font (new_font (buf, cs));
1542	}	1672	}
1543	else	1673	else
1544	rxvt_warn ("fontset element too long (>511 bytes), ignored.");	1674	rxvt_warn ("fontset element too long (>511 bytes), ignored.\n");
1545		1675
1546	desc = end + 1;	1676	desc = end + 1;
1547	}	1677	}
1548	while (*end);	1678	while (*end);
1549	}	1679	}
…		…
1574	{	1704	{
1575	clear ();	1705	clear ();
1576		1706
1577	fontdesc = strdup (desc);	1707	fontdesc = strdup (desc);
1578		1708
1579	fonts.push_back (new_font (0, CS_UNICODE));	1709	push_font (new_font (0, CS_UNICODE));
1580	realize_font (0);	1710	realize_font (0);
1581		1711
1582	add_fonts (desc);	1712	add_fonts (desc);
1583		1713
1584	return true;	1714	return true;
…		…
1593		1723
1594	return -1;	1724	return -1;
1595	}	1725	}
1596		1726
1597	int	1727	int
1598	rxvt_fontset::find_font (unicode_t unicode)	1728	rxvt_fontset::find_font_idx (unicode_t unicode)
1599	{	1729	{
1600	if (unicode >= 1<<20)	1730	// this limits fmap size. it has to accomodate COMPOSE_HI when UNICODE_3
		1731	if (unicode > 0x1fffff)
1601	return 0;	1732	return 0;
1602		1733
1603	unicode_t hi = unicode >> 8;	1734	unicode_t hi = unicode >> 8;
1604		1735
1605	if (hi < fmap.size ()	1736	if (hi < fmap.size ())
1606	&& fmap[hi]	1737	if (pagemap *pm = fmap[hi])
1607	&& (*fmap[hi])[unicode & 0xff] != 0xff)	1738	if ((*pm)[unicode & 0xff] != 0xff)
1608	return (*fmap[hi])[unicode & 0xff];	1739	return (*pm)[unicode & 0xff];
1609		1740
1610	unsigned int i;	1741	unsigned int i;
1611		1742
1612	for (i = 0; i < fonts.size (); i++)	1743	for (i = 0; i < fonts.size (); i++)
1613	{	1744	{
…		…
1629	goto next_font;	1760	goto next_font;
1630		1761
1631	bool careful;	1762	bool careful;
1632	if (f->has_char (unicode, &prop, careful))	1763	if (f->has_char (unicode, &prop, careful))
1633	{	1764	{
1634	if (careful)	1765	i = (i << 1) \| careful;
1635	i \|= 128;
1636		1766
1637	goto found;	1767	goto found;
1638	}	1768	}
1639		1769
1640	next_font:	1770	next_font:
1641	if (i == fonts.size () - 1)	1771	if (i == fonts.size () - 1)
1642	{	1772	{
		1773	// compose characters are handled by the default font, unless another font takes over
		1774	// we do not go via the fallback list for speed reasons.
		1775	if (IS_COMPOSE (unicode))
		1776	return 0;
		1777
1643	if (fallback->name)	1778	if (fallback->name)
1644	{	1779	{
1645	// search through the fallback list	1780	// search through the fallback list
1646	fonts.push_back (new_font (fallback->name, fallback->cs));	1781	push_font (new_font (fallback->name, fallback->cs));
1647	fallback++;	1782	fallback++;
1648	}	1783	}
1649	else	1784	else
1650	{	1785	{
1651	// try to find a new font.	1786	// try to find a new font.
…		…
1653	// way to configure this and xft is easier to hack in,	1788	// way to configure this and xft is easier to hack in,
1654	// while x11 has more framework in place already.	1789	// while x11 has more framework in place already.
1655	// TODO: this is a real resource hog, xft takes ages(?)	1790	// TODO: this is a real resource hog, xft takes ages(?)
1656	#if XFT && USE_SLOW_LOOKUP	1791	#if XFT && USE_SLOW_LOOKUP
1657	// grab the first xft font that seems suitable	1792	// grab the first xft font that seems suitable
		1793	// TOOD: should go first for cellchar (spacing 110) then mono, then else
1658	FcPattern *p = FcPatternCreate ();	1794	FcPattern *p = FcPatternCreate ();
1659		1795
1660	FcCharSet *s = FcCharSetCreate ();	1796	FcCharSet *s = FcCharSetCreate ();
1661	FcCharSetAddChar (s, unicode);	1797	FcCharSetAddChar (s, unicode);
1662	FcPatternAddCharSet (p, FC_CHARSET, s);	1798	FcPatternAddCharSet (p, FC_CHARSET, s);
…		…
1682	FcPatternDestroy (match);	1818	FcPatternDestroy (match);
1683		1819
1684	if (find_font (font) < 0)	1820	if (find_font (font) < 0)
1685	{	1821	{
1686	char fontname[4096];	1822	char fontname[4096];
1687	sprintf (fontname, "xft:%-.4090s", font);	1823	snprintf (fontname, sizeof (fontname), "xft:%s", font);
1688		1824
1689	fonts.push_back (new_font (fontname, CS_UNICODE));	1825	push_font (new_font (fontname, CS_UNICODE));
1690	}	1826	}
1691		1827
1692	free (font);	1828	free (font);
1693	}	1829	}
1694	#endif	1830	#endif
…		…
1706	while (hi >= fmap.size ())	1842	while (hi >= fmap.size ())
1707	fmap.push_back (0);	1843	fmap.push_back (0);
1708		1844
1709	if (!fmap[hi])	1845	if (!fmap[hi])
1710	{	1846	{
1711	fmap[hi] = (pagemap *)new pagemap;	1847	fmap[hi] = new pagemap;
1712	memset (fmap[hi], 0xff, sizeof (pagemap));	1848	memset (fmap[hi], 0xff, sizeof (pagemap));
1713	}	1849	}
1714		1850
1715	(*fmap[hi])[unicode & 0xff] = i;	1851	(*fmap[hi])[unicode & 0xff] = i;
1716	}	1852	}
1717		1853
1718	return i;	1854	return i;
1719	}	1855	}
1720		1856
1721
1722

Diff Legend

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

Comparing rxvt-unicode/src/rxvtfont.C (file contents): Revision 1.125 by ayin, Sun Nov 25 11:23:18 2007 UTC vs. Revision 1.208 by root, Fri Jun 18 01:50:14 2021 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.125 by ayin, Sun Nov 25 11:23:18 2007 UTC vs.
Revision 1.208 by root, Fri Jun 18 01:50:14 2021 UTC