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

Comparing rxvt-unicode/src/defaultfont.C (file contents):
Revision 1.10 by pcg, Wed Dec 24 09:07:01 2003 UTC vs.
Revision 1.43 by pcg, Mon Mar 15 07:10:47 2004 UTC

…		…
1	/---------------------------------C----------------------------------;	1	/---------------------------------C----------------------------------;
2	* File: defaultfont.C	2	* File: defaultfont.C
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	* Copyright (c) 2003 Marc Lehmann rxvt@plan9.de>	4	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
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 2 of the License, or
23	#include "rxvt.h"	23	#include "rxvt.h"
24	#include "defaultfont.h"	24	#include "defaultfont.h"
25		25
26	#include <cstdlib>	26	#include <cstdlib>
27		27
28	#define DISPLAY r->Xdisplay	28	#define DISPLAY r->display->display
29	#define DRAWABLE r->TermWin.vt
30	#define GC r->TermWin.gc	29	#define TGC r->TermWin.gc
31		30
32	const struct rxvt_fallback_font {	31	const struct rxvt_fallback_font {
33	codeset cs;	32	codeset cs;
34	const char *name;	33	const char *name;
35	} fallback_fonts[] = {	34	} fallback_fonts[] = {
…		…
62	# if XFT	61	# if XFT
63	// prefer xft for complex scripts	62	// prefer xft for complex scripts
64	{ CS_UNICODE, "xft:Kochi Gothic:antialias=false" },	63	{ CS_UNICODE, "xft:Kochi Gothic:antialias=false" },
65	# endif	64	# endif
66	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },	65	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },
67	{ CS_JIS0208_1983_0, "--mincho--r-------c--jisx0208*-0" },	66	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },
68	{ CS_JIS0212_1990_0, "--mincho--r-------c--jisx0212*-0" },	67	{ CS_JIS0212_1990_0, "--mincho--r-------c--jisx0212*-0" },
69	#endif	68	#endif
70		69
71	#if ENCODING_CN \|\| ENCODING_CN_EXT	70	#if ENCODING_CN \|\| ENCODING_CN_EXT
72	# if XFT	71	# if XFT
73	{ CS_BIG5_EXT, "xft:AR PL Mingti2L Big5" },	72	{ CS_BIG5_EXT, "xft:AR PL Mingti2L Big5" },
74	{ CS_BIG5_EXT, "xft:AR PL KaitiM Big5" },	73	{ CS_BIG5_EXT, "xft:AR PL KaitiM Big5" },
75	{ CS_GB2312_1980_0, "xft:AR PL KaitiM GB" },	74	{ CS_GB2312_1980_0, "xft:AR PL KaitiM GB" },
76	{ CS_GB2312_1980_0, "xft:AR PL SungtiL GB" },	75	{ CS_GB2312_1980_0, "xft:AR PL SungtiL GB" },
77	# endif	76	# endif
		77	{ CS_BIG5, "-----------c-*-big5-0" },
		78	{ CS_BIG5_PLUS, "-----------c-*-big5p-0" },
		79	{ CS_BIG5_EXT, "-----------c-*-big5.eten-0" },
		80	{ CS_CNS11643_1992_1, "-----------c--gb2312-0" },
78	{ CS_CNS11643_1992_1, "-----------c-*-cns11643.1992-1" },	81	{ CS_CNS11643_1992_1, "-----------c--cns11643-1" },
79	{ CS_CNS11643_1992_2, "-----------c-*-cns11643.1992-2" },	82	{ CS_CNS11643_1992_2, "-----------c--cns11643-2" },
80	{ CS_CNS11643_1992_3, "-----------c-*-cns11643.1992-3" },	83	{ CS_CNS11643_1992_3, "-----------c--cns11643-3" },
81	{ CS_CNS11643_1992_4, "-----------c-*-cns11643.1992-4" },	84	{ CS_CNS11643_1992_4, "-----------c--cns11643-4" },
82	{ CS_CNS11643_1992_5, "-----------c-*-cns11643.1992-5" },	85	{ CS_CNS11643_1992_5, "-----------c--cns11643-5" },
83	{ CS_CNS11643_1992_6, "-----------c-*-cns11643.1992-6" },	86	{ CS_CNS11643_1992_6, "-----------c--cns11643-6" },
84	{ CS_CNS11643_1992_7, "-----------c-*-cns11643.1992-7" },	87	{ CS_CNS11643_1992_7, "-----------c--cns11643-7" },
85	{ CS_CNS11643_1992_F, "-----------c-*-cns11643.1992-f" },	88	{ CS_CNS11643_1992_F, "-----------c--cns11643-f" },
86	#endif	89	#endif
87		90
88	#if XFT	91	#if XFT
89	{ CS_UNICODE, "xft:Andale Mono" },	92	{ CS_UNICODE, "xft:Andale Mono" },
90	{ CS_UNICODE, "xft:Arial Unicode MS" },	93	{ CS_UNICODE, "xft:Arial Unicode MS" },
…		…
93	{ CS_UNICODE, "xft:FreeMono" },	96	{ CS_UNICODE, "xft:FreeMono" },
94	{ CS_UNICODE, "--unifont---------c--iso10646-1" },	97	{ CS_UNICODE, "--unifont---------c--iso10646-1" },
95	{ CS_UNICODE, "----r-------c--iso10646-1" },	98	{ CS_UNICODE, "----r-------c--iso10646-1" },
96	{ CS_UNICODE, "----r-------m--iso10646-1" },	99	{ CS_UNICODE, "----r-------m--iso10646-1" },
97		100
		101	#if UNICODE_3 && XFT
		102	{ CS_UNICODE, "xft:Code2001" }, // contains many plane-1 characters
		103	#endif
		104
98	{ CS_UNKNOWN, 0 }	105	{ CS_UNKNOWN, 0 }
99	};	106	};
100		107
101	/////////////////////////////////////////////////////////////////////////////	108	/////////////////////////////////////////////////////////////////////////////
102		109
		110	#if XFT
		111	rxvt_drawable::~rxvt_drawable ()
		112	{
		113	if (xftdrawable)
		114	XftDrawDestroy (xftdrawable);
		115	}
		116
		117	rxvt_drawable::operator XftDraw *()
		118	{
		119	if (!xftdrawable)
		120	xftdrawable = XftDrawCreate (display->display, drawable, display->visual, display->cmap);
		121
		122	return xftdrawable;
		123	}
		124	#endif
		125
		126	/////////////////////////////////////////////////////////////////////////////
		127
103	static void *enc_buf;	128	static void *enc_buf;
104	static uint32_t enc_len;	129	static uint32_t enc_len;
105		130
106	static inline void *	131	static inline void *
107	get_enc_buf (int len)	132	get_enc_buf (uint32_t len)
108	{	133	{
109	if (len > enc_len)	134	if (len > enc_len)
110	{	135	{
111	free (enc_buf);	136	free (enc_buf);
112	enc_buf = malloc (len);	137	enc_buf = malloc (len);
…		…
114		139
115	return enc_buf;	140	return enc_buf;
116	}	141	}
117		142
118	static const char *	143	static const char *
119	enc_char (const text_t *text, int len, codeset cs, bool &zero)	144	enc_char (const text_t *text, uint32_t len, codeset cs, bool &zero)
120	{	145	{
121	uint8_t buf = (uint8_t )get_enc_buf (len);	146	uint8_t buf = (uint8_t )get_enc_buf (len);
122		147
123	while (len--)	148	while (len--)
124	{	149	{
…		…
135		160
136	return (const char *)enc_buf;	161	return (const char *)enc_buf;
137	}	162	}
138		163
139	static const XChar2b *	164	static const XChar2b *
140	enc_xchar2b (const text_t *text, int len, codeset cs, bool &zero)	165	enc_xchar2b (const text_t *text, uint32_t len, codeset cs, bool &zero)
141	{	166	{
142	XChar2b buf = (XChar2b )get_enc_buf (len * sizeof (XChar2b));	167	XChar2b buf = (XChar2b )get_enc_buf (len * sizeof (XChar2b));
143		168
144	while (len--)	169	while (len--)
145	{	170	{
…		…
160	}	185	}
161		186
162	/////////////////////////////////////////////////////////////////////////////	187	/////////////////////////////////////////////////////////////////////////////
163		188
164	void	189	void
165	rxvt_font::clear_rect (int x, int y, int w, int h, int color)	190	rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color)
166	{	191	{
167	if (color == Color_bg)	192	if (color == Color_bg)
168	XClearArea (DISPLAY, DRAWABLE, x, y, w, h, FALSE);	193	XClearArea (d.display->display, d, x, y, w, h, FALSE);
169	else if (color >= 0)	194	else if (color >= 0)
170	{	195	{
		196	#if XFT
		197	XftDrawRect (d, &r->PixColors[color].c, x, y, w, h);
		198	#else
171	XSetForeground (DISPLAY, GC, r->PixColors[color]);	199	XSetForeground (d.display->display, TGC, r->PixColors[color]);
172	XFillRectangle (DISPLAY, DRAWABLE, GC, x, y, w, h);	200	XFillRectangle (d.display->display, d, TGC, x, y, w, h);
		201	#endif
173	}	202	}
174	}	203	}
175		204
176	static const char *linedraw_cmds[128] = {	205	static const char *linedraw_cmds[128 + 32] = {
177	"1hH", "2hH", "1vV", "2vV",	206	"1-", "2-", "1\|", "2\|",
178	0, 0, 0, 0,	207	0, 0, 0, 0,
179	0, 0, 0, 0,	208	0, 0, 0, 0,
180	"1HV", "2H1V", "1H2V", "2HV",	209	"1HV", "2H1V", "1H2V", "2HV",
181		210
182	// 2510	211	// 2510
183	"1hV", "2h1V", "1h2V", "2hV",	212	"1hV", "2h1V", "1h2V", "2hV",
184	"1Hv", "2H1v", "1H2v", "2Hv",	213	"1Hv", "2H1v", "1H2v", "2Hv",
185	"1hv", "2h1v", "1h2v", "2hv",	214	"1hv", "2h1v", "1h2v", "2hv",
186	"1HvV", "2H1vV", "1HV2v", "1Hv2V",	215	"1H\|", "2H1\|", "1HV2v", "1Hv2V",
187		216
188	// 2520	217	// 2520
189	"1H2vV", "2Hv1V", "2HV1v", "2HvV",	218	"1H2\|", "2Hv1V", "2HV1v", "2H\|",
190	"1hvV", "2h1vV", "1hV2v", "1hv2V",	219	"1h\|", "2h1\|", "1hV2v", "1hv2V",
191	"1h2vV", "2hv1V", "1v2hV", "2hvV",	220	"1h2\|", "2hv1V", "1v2hV", "2h\|",
192	"1hHV", "2h1HV", "2H1hV", "2hH1V",	221	"1-V", "2h1HV", "2H1hV", "2-1V",
193		222
194	// 2530	223	// 2530
195	"1hH2V", "2hV1H", "1h2HV", "2hHV",	224	"1-2V", "2hV1H", "1h2HV", "2-V",
196	"1hHv", "1vH2h", "1hv2H", "1v2hH",	225	"1-v", "1vH2h", "1hv2H", "1v2-",
197	"1hH2v", "1H2hv", "1h2Hv", "2hHv",	226	"1-2v", "1H2hv", "1h2Hv", "2-v",
198	"1hHvV", "1vVH2h", "1hvV2H", "1vV2hH",	227	"1-\|", "1\|H2h", "1h\|2H", "1\|2-",
199		228
200	// 2540	229	// 2540
201	"1hHV2v", "1hHv2V", "1hH2vV", "1HV2hv",	230	"1-V2v", "1-v2V", "1-2\|", "1HV2hv",
202	"1hV2Hv", "1Hv2hV", "1hv2HV", "1V2hHv",	231	"1hV2Hv", "1Hv2hV", "1hv2HV", "1V2-v",
203	"1v2hHV", "1H2hvV", "1h2HvV", "2hHvV",	232	"1v2-V", "1H2h\|", "1h2H\|", "2-\|",
204	0, 0, 0, 0,	233	0, 0, 0, 0,
205		234
206	// 2550	235	// 2550
207	0, 0, 0, 0,	236	0, 0, 0, 0,
208	0, 0, 0, 0,	237	0, 0, 0, 0,
…		…
211		240
212	// 2560	241	// 2560
213	0, 0, 0, 0,	242	0, 0, 0, 0,
214	0, 0, 0, 0,	243	0, 0, 0, 0,
215	0, 0, 0, 0,	244	0, 0, 0, 0,
216	0, 0, 0, 0,	245	0, "A", "B", "C",
217		246
218	// 2570	247	// 2570
219	0, "1a", "1b", "1ab",	248	"D", "1/", "1\\", "1/\\",
220	"1h", "1v", "1H", "1V",	249	"1h", "1v", "1H", "1V",
221	"2h", "2v", "2H", "2V",	250	"2h", "2v", "2H", "2V",
222	"1h2H", "1v2V", "1H2h", "1V2v"	251	"1h2H", "1v2V", "1H2h", "1V2v",
		252
		253	// 2580
		254	0, 0, 0, 0,
		255	0, 0, 0, 0,
		256	0, 0, 0, 0,
		257	0, 0, 0, 0,
		258
		259	// 2590
		260	0, 0, 0, 0,
		261	0, 0, "k", "l",
		262	"i", "ikl", "il", "ijk",
		263	"ijl", "j", "jk", "jkl",
223		264
224	// to be done	265	// to be done
225	};	266	};
226		267
227	struct rxvt_font_default : rxvt_font {	268	struct rxvt_font_default : rxvt_font {
…		…
239	bool load (const rxvt_fontprop &prop)	280	bool load (const rxvt_fontprop &prop)
240	{	281	{
241	width = 1; height = 1;	282	width = 1; height = 1;
242	ascent = 1; descent = 0;	283	ascent = 1; descent = 0;
243		284
		285	set_name ("built-in pseudofont");
		286
244	return true;	287	return true;
245	}	288	}
246		289
247	bool has_codepoint (uint32_t unicode)	290	bool has_codepoint (unicode_t unicode)
248	{	291	{
249	if (unicode <= 0x001f)	292	if (unicode <= 0x001f)
250	return true;	293	return true;
		294
251	if (unicode >= 0x0080 && unicode <= 0x009f)	295	if (unicode >= 0x0080 && unicode <= 0x009f)
252	return true;	296	return true;
253		297
254	if (unicode >= 0x2500 && unicode <= 0x257f	298	if (unicode >= 0x2500 && unicode <= 0x257f
255	&& linedraw_cmds[unicode - 0x2500])	299	&& linedraw_cmds[unicode - 0x2500])
		300	return true;
		301
		302	if (unicode >= 0x2580 && unicode <= 0x259f)
		303	return true;
		304
		305	if (IS_COMPOSE (unicode))
256	return true;	306	return true;
257		307
258	switch (unicode)	308	switch (unicode)
259	{	309	{
260	case ZERO_WIDTH_CHAR:	310	case ZERO_WIDTH_CHAR:
…		…
262	}	312	}
263		313
264	return false;	314	return false;
265	}	315	}
266		316
267	void draw (int x, int y,	317	void draw (rxvt_drawable &d, int x, int y,
268	const text_t *text, int len,	318	const text_t *text, int len,
269	int fg, int bg);	319	int fg, int bg);
270	};	320	};
271		321
		322	static void rect_stipple (Display *display, Drawable d, GC gc, int s1, int s2, int x, int y, int w, int h)
		323	{
		324	XGCValues gcv;
		325	char bm[2] = { s1, s2 };
		326
		327	gcv.fill_style = FillStippled;
		328	gcv.stipple = XCreateBitmapFromData (display, d, bm, 2, 2);
		329	gcv.ts_x_origin = x;
		330	gcv.ts_y_origin = y;
		331
		332	if (!gcv.stipple)
		333	return;
		334
		335	XChangeGC (display, gc, GCFillStyle \| GCStipple \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
		336	XFillRectangle (display, d, gc, x, y, w, h);
		337
		338	XFreePixmap (display, gcv.stipple);
		339
		340	gcv.fill_style = FillSolid;
		341	XChangeGC (display, gc, GCFillStyle, &gcv);
		342	}
		343
272	void	344	void
273	rxvt_font_default::draw (int x, int y,	345	rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
274	const text_t *text, int len,	346	const text_t *text, int len,
275	int fg, int bg)	347	int fg, int bg)
276	{	348	{
277	clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	349	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
278		350
279	XSetForeground (DISPLAY, GC, r->PixColors[fg]);	351	XSetForeground (d.display->display, TGC, r->PixColors[fg]);
280		352
281	while (len--)	353	while (len--)
282	{	354	{
		355	#if ENABLE_COMBINING
		356	compose_char *cc;
		357	#endif
283	text_t t = *text++;	358	text_t t = *text++;
284		359
		360	int W = r->TermWin.fwidth , w = (W - 1) / 2;
		361	int H = r->TermWin.fheight, h = (H - 1) / 2;
		362	int x0 = x, x1 = x + w, x2 = x + r->TermWin.fwidth ;
		363	int y0 = y, y1 = y + h, y2 = y + r->TermWin.fheight;
		364
		365	// is it in our linedrawing table?
285	if (t >= 0x2500 & t <= 0x2580 && linedraw_cmds[t - 0x2500])	366	if (t >= 0x2500 & t <= 0x259f && linedraw_cmds[t - 0x2500])
286	{	367	{
287	const char *p = linedraw_cmds[t - 0x2500];	368	const char *p = linedraw_cmds[t - 0x2500];
288		369
289	int x0 = x, x1 = x + r->TermWin.fwidth / 2, x2 = x + r->TermWin.fwidth ;
290	int y0 = y, y1 = y + r->TermWin.fheight / 2, y2 = y + r->TermWin.fheight;
291
292	XGCValues gcv;	370	XGCValues gcv;
		371
		372	gcv.cap_style = CapNotLast;
		373	XChangeGC (d.display->display, TGC, GCCapStyle, &gcv);
293		374
294	while (*p)	375	while (*p)
295	{	376	{
296	switch (*p++)	377	switch (*p++)
297	{	378	{
298	case '1':	379	case '1':
299	gcv.line_width = 0;	380	gcv.line_width = 0;
300	XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);	381	XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
301	break;	382	break;
302		383
303	case '2':	384	case '2':
304	gcv.line_width = 2;	385	gcv.line_width = 3;
305	XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);	386	XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
306	break;	387	break;
307		388
308	case 'h': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y1, x1, y1); break;	389	case 'h': XDrawLine (d.display->display, d, TGC, x0, y1, x1+1, y1 ); break;
309	case 'H': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y1, x2, y1); break;	390	case 'H': XDrawLine (d.display->display, d, TGC, x1, y1, x2 , y1 ); break;
		391	case '-': XDrawLine (d.display->display, d, TGC, x0, y1, x2 , y1 ); break;
310	case 'v': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y0, x1, y1); break;	392	case 'v': XDrawLine (d.display->display, d, TGC, x1, y0, x1 , y1+1); break;
311	case 'V': XDrawLine (DISPLAY, DRAWABLE, GC, x1, y1, x1, y2); break;	393	case 'V': XDrawLine (d.display->display, d, TGC, x1, y1, x1 , y2 ); break;
		394	case '\|': XDrawLine (d.display->display, d, TGC, x1, y0, x1 , y2 ); break;
		395
312	case 'a': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y2, x2, y0); break;	396	case '/' : XDrawLine (d.display->display, d, TGC, x0, y2, x2 , y0 ); break;
313	case 'b': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y0, x2, y2); break;	397	case '\\': XDrawLine (d.display->display, d, TGC, x0, y0, x2 , y2 ); break;
		398
		399	case 'A': XDrawArc (d.display->display, d, TGC, x1 , y1 , W-1, H-1, 9064, 9064); break;
		400	case 'B': XDrawArc (d.display->display, d, TGC, x1-W+1, y1 , W-1, H-1, 064, 9064); break;
		401	case 'C': XDrawArc (d.display->display, d, TGC, x1-W+1, y1-H+1, W-1, H-1, 064, -9064); break;
		402	case 'D': XDrawArc (d.display->display, d, TGC, x1 , y1-H+1, W-1, H-1, -9064, -9064); break;
		403
		404	case 'i': XFillRectangle (d.display->display, d, TGC, x0, y0, x1 - x0 + 1, y1 - y0 + 1); break;
		405	case 'j': XFillRectangle (d.display->display, d, TGC, x1, y0, x2 - x1, y1 - y0 + 1); break;
		406	case 'k': XFillRectangle (d.display->display, d, TGC, x0, y1, x1 - x0 + 1, y2 - y1); break;
		407	case 'l': XFillRectangle (d.display->display, d, TGC, x1, y1, x2 - x1, y2 - y1); break;
314	}	408	}
315	}	409	}
316		410
317	gcv.line_width = 0;	411	gcv.line_width = 0;
318	XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);	412	XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
		413	}
		414
		415	#if ENABLE_COMBINING
		416	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
319	}	417	{
		418	rxvt_font f1 = (fs)[fs->find_font (cc->c1)];
		419	f1->draw (d, x, y, &(t = cc->c1), 1, fg, bg);
		420	if (cc->c2 != NOCHAR)
		421	{
		422	// prefer font of first character, for no good reasons
		423	rxvt_font *f2 = f1->has_codepoint (cc->c2)
		424	? f1
		425	: (*fs)[fs->find_font (cc->c2)];
		426
		427	f2->draw (d, x, y, &(t = cc->c2), 1, fg, -1);
		428	}
		429	}
		430	#endif
320	else	431	else
321	switch (*text++)	432	switch (t)
322	{	433	{
323	case NOCHAR:
324	case ZERO_WIDTH_CHAR:	434	case ZERO_WIDTH_CHAR:
325	break;	435	break;
		436
		437	case 0x2580: XFillRectangle (d.display->display, d, TGC, x0, y0, W, y1 - y0 + 1); break;
		438	case 0x2581: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 7 - 1) / 8, W, H - (H * 7 - 1) / 8); break;
		439	case 0x2582: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 6 - 2) / 8, W, H - (H * 6 - 2) / 8); break;
		440	case 0x2583: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 5 - 3) / 8, W, H - (H * 5 - 3) / 8); break;
		441	case 0x2584: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 4 - 4) / 8, W, H - (H * 4 - 4) / 8); break;
		442	case 0x2585: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 3 - 5) / 8, W, H - (H * 3 - 5) / 8); break;
		443	case 0x2586: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 2 - 6) / 8, W, H - (H * 2 - 6) / 8); break;
		444	case 0x2587: XFillRectangle (d.display->display, d, TGC, x0, y0 + (H * 1 - 7) / 8, W, H - (H * 1 - 7) / 8); break;
		445	case 0x2588: XFillRectangle (d.display->display, d, TGC, x0, y0, W, H); break;
		446	case 0x2589: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 7 - 1) / 8, H); break;
		447	case 0x258a: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 6 - 2) / 8, H); break;
		448	case 0x258b: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 5 - 3) / 8, H); break;
		449	case 0x258c: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 4 - 4) / 8, H); break;
		450	case 0x258d: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 3 - 5) / 8, H); break;
		451	case 0x258e: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 2 - 6) / 8, H); break;
		452	case 0x258f: XFillRectangle (d.display->display, d, TGC, x0, y0, (W * 1 - 7) / 8, H); break;
		453	case 0x2590: XFillRectangle (d.display->display, d, TGC, x1, y0, x2 - x1, H); break;
		454
		455	case 0x2591: rect_stipple (d.display->display, d, TGC, 0x00, 0x01, x0, y0, W, H); break;
		456	case 0x2592: rect_stipple (d.display->display, d, TGC, 0x02, 0x01, x0, y0, W, H); break;
		457	case 0x2593: rect_stipple (d.display->display, d, TGC, 0x01, 0x03, x0, y0, W, H); break;
		458
		459	case 0x2594: XFillRectangle (d.display->display, d, TGC, x0, y0, W, (H * 1 - 7) / 8); break;
		460	case 0x2595: XFillRectangle (d.display->display, d, TGC, x0 + (W * 7 - 1) / 8, y0, W - (W * 7 - 1) / 8, H); break;
		461
326	default:	462	default:
327	XDrawRectangle (DISPLAY, DRAWABLE, GC, x + 2, y + 2, r->TermWin.fwidth - 5, r->TermWin.fheight - 5);	463	int w = 0;
		464	while (len > 0 && *text == NOCHAR)
		465	{
		466	++text;
		467	--len;
		468	w += r->TermWin.fwidth;
		469	}
		470
		471	XDrawRectangle (d.display->display, d, TGC, x + 2, y + 2,
		472	w + r->TermWin.fwidth - 4, r->TermWin.fheight - 4);
		473	x += w;
328	}	474	}
329		475
330	x += r->TermWin.fwidth;	476	x += r->TermWin.fwidth;
331	}	477	}
332	}	478	}
…		…
337	rxvt_font_x11 () { f = 0; }	483	rxvt_font_x11 () { f = 0; }
338		484
339	void clear ();	485	void clear ();
340		486
341	rxvt_fontprop properties ();	487	rxvt_fontprop properties ();
342	rxvt_fontprop properties (XFontStruct *f);
343		488
344	bool load (const rxvt_fontprop &prop);	489	bool load (const rxvt_fontprop &prop);
345		490
346	bool has_codepoint (uint32_t unicode);	491	bool has_codepoint (unicode_t unicode);
347		492
348	void draw (int x, int y,	493	void draw (rxvt_drawable &d, int x, int y,
349	const text_t *text, int len,	494	const text_t *text, int len,
350	int fg, int bg);	495	int fg, int bg);
351		496
352	XFontStruct *f;	497	XFontStruct *f;
353	codeset cs;	498	codeset cs;
354	bool enc2b, encm;	499	bool enc2b, encm;
355		500
356	const char get_property (XFontStruct f, const char property, const char repl) const;	501	const char get_property (XFontStruct f, const char property, const char repl) const;
		502	bool set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth);
		503	bool set_properties (rxvt_fontprop &p, XFontStruct *f);
		504	bool set_properties (rxvt_fontprop &p, const char *name);
357	};	505	};
358		506
359	const char *	507	const char *
360	rxvt_font_x11::get_property (XFontStruct f, const char property, const char *repl) const	508	rxvt_font_x11::get_property (XFontStruct f, const char property, const char *repl) const
361	{	509	{
…		…
368	}	516	}
369		517
370	rxvt_fontprop	518	rxvt_fontprop
371	rxvt_font_x11::properties ()	519	rxvt_font_x11::properties ()
372	{	520	{
373	return properties (f);
374	}
375
376	rxvt_fontprop
377	rxvt_font_x11::properties (XFontStruct *f)
378	{
379	rxvt_fontprop p;	521	rxvt_fontprop p;
		522	set_properties (p, f);
		523	return p;
		524	}
380		525
		526	bool
		527	rxvt_font_x11::set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth)
		528	{
		529	p.width = avgwidth ? (avgwidth + 1) / 10 : (height + 1) / 2;
		530	p.height = height;
		531	p.weight = weight == 'B' \|\| weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;
		532	p.slant = slant == 'r' \|\| slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;
		533
		534	return true;
		535	}
		536
		537	bool
		538	rxvt_font_x11::set_properties (rxvt_fontprop &p, XFontStruct *f)
		539	{
381	const char *weight = get_property (f, "WEIGHT_NAME", "medium");	540	const char *weight = get_property (f, "WEIGHT_NAME", "medium");
382	const char *slant = get_property (f, "SLANT", "r");	541	const char *slant = get_property (f, "SLANT", "r");
383		542
		543	unsigned long height;
		544	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "PIXEL_SIZE", 0), &height))
		545	return false;
		546
384	unsigned long avgwidth;	547	unsigned long avgwidth;
385	p.width = XGetFontProperty (f, XInternAtom (DISPLAY, "AVERAGE_WIDTH", 0), &avgwidth)	548	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "AVERAGE_WIDTH", 0), &avgwidth))
386	? avgwidth / 10	549	avgwidth = 0;
387	: (height + 1) / 2;
388	p.height = height;
389	p.weight = weight == 'B' \|\| weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;
390	p.slant = slant == 'r' \|\| slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;
391		550
392	return p;	551	return set_properties (p, height, weight, slant, avgwidth);
		552	}
		553
		554	bool
		555	rxvt_font_x11::set_properties (rxvt_fontprop &p, const char *name)
		556	{
		557	int slashes = 0;
		558	const char *comp[13];
		559
		560	for (const char c = name; c; c++)
		561	if (*c == '-')
		562	{
		563	comp[slashes++] = c + 1;
		564	if (slashes >= 13)
		565	break;
		566	}
		567
		568	/* can we short-circuit the costly XLoadQueryFont? */
		569	if (slashes >= 13
		570	&& (comp[ 6] >= '1' && comp[ 6] <= '9')
		571	&& (comp[11] >= '0' && comp[11] <= '9'))
		572	return set_properties (p, atoi (comp[6]), comp[2], comp[3], atoi (comp[11]));
		573
		574	XFontStruct *f = XLoadQueryFont (DISPLAY, name);
		575
		576	if (f)
		577	{
		578	// the font should really exist now. if not, we have a problem
		579	// (e.g. if the user did xset fp rehash just when we were searching fonts).
		580	// in that case, just return garbage.
		581	bool ret = set_properties (p, f);
		582	XFreeFont (DISPLAY, f);
		583	return ret;
		584	}
		585	else
		586	return false;
		587	}
		588
		589	// fix the size of scalable fonts
		590	static void
		591	fix_scalable (char buf, const char name, const rxvt_fontprop &prop)
		592	{
		593	int slashes = 0;
		594	const char *size;
		595
		596	for (const char c = name; c; c++)
		597	if (*c == '-')
		598	{
		599	if (slashes == 6)
		600	size = c + 1;
		601
		602	if (++slashes >= 13)
		603	break;
		604	}
		605
		606	if (slashes >= 13 && size[0] == '0')
		607	{
		608	strncpy (buf, name, size - name);
		609	buf += size - name;
		610	buf += sprintf (buf, "%d", prop.height);
		611	strcpy (buf, size + 1);
		612	}
		613	else
		614	strcpy (buf, name);
393	}	615	}
394		616
395	bool	617	bool
396	rxvt_font_x11::load (const rxvt_fontprop &prop)	618	rxvt_font_x11::load (const rxvt_fontprop &prop)
397	{	619	{
398	clear ();	620	clear ();
399		621
400	char **list;	622	char **list;
401	int count;	623	int count;
402	XFontStruct *info;
403	list = XListFontsWithInfo (DISPLAY, name, 128, &count, &info);	624	list = XListFonts (DISPLAY, name, 512, &count);
		625	set_name (0);
404		626
405	if (!list)	627	if (!list)
406	return false;	628	return false;
407		629
408	int bestdiff = 0x7fffffff;	630	int bestdiff = 0x7fffffff;
409	XFontStruct *best = 0;
410	for (int i = 0; i < count; i++)	631	for (int i = 0; i < count; i++)
411	{	632	{
412	XFontStruct *f = info + i;	633	rxvt_fontprop p;
		634	char fname[1024];
		635	fix_scalable (fname, list[i], prop);
413		636
		637	if (!set_properties (p, fname))
		638	continue;
		639
414	if (f->ascent + f->descent <= prop.height) // weed out too large fonts	640	if (p.height > prop.height) // weed out too large fonts
415	{	641	continue;
416	rxvt_fontprop p = properties (f);	642
417	int diff = (prop.height - f->ascent + f->descent) * 32	643	int diff = (prop.height - p.height) * 32
418	+ abs (prop.weight - p.weight)	644	+ abs (prop.weight - p.weight)
419	+ abs (prop.slant - p.slant );	645	+ abs (prop.slant - p.slant );
420		646
421	if (!best // compare against best found so far	647	if (!name // compare against best found so far
422	\|\| diff < bestdiff)	648	\|\| diff < bestdiff)
423	{	649	{
424	best = f;	650	set_name (strdup (fname));
425	bestdiff = diff;	651	bestdiff = diff;
426	}	652	}
427	}
428	}	653	}
429		654
		655	XFreeFontNames (list);
		656
430	if (!best)	657	if (!name)
431	return false;	658	return false;
432
433	set_name (strdup (list[best - info]));
434
435	XFreeFontInfo (list, info, count);
436		659
437	f = XLoadQueryFont (DISPLAY, name);	660	f = XLoadQueryFont (DISPLAY, name);
438		661
439	if (!f)	662	if (!f)
440	return false;	663	return false;
441
442	unsigned long value;
443		664
444	const char *registry = get_property (f, "CHARSET_REGISTRY", 0);	665	const char *registry = get_property (f, "CHARSET_REGISTRY", 0);
445	const char *encoding = get_property (f, "CHARSET_ENCODING", 0);	666	const char *encoding = get_property (f, "CHARSET_ENCODING", 0);
446		667
447	if (registry && encoding)	668	if (registry && encoding)
…		…
522	f = 0;	743	f = 0;
523	}	744	}
524	}	745	}
525		746
526	bool	747	bool
527	rxvt_font_x11::has_codepoint (uint32_t unicode)	748	rxvt_font_x11::has_codepoint (unicode_t unicode)
528	{	749	{
529	uint32_t ch = FROM_UNICODE (cs, unicode);	750	uint32_t ch = FROM_UNICODE (cs, unicode);
530		751
531	if (ch == NOCHAR)	752	if (ch == NOCHAR)
532	return false;	753	return false;
…		…
534	/* check wether the character exists in _this_ font. horrible. */	755	/* check wether the character exists in _this_ font. horrible. */
535	XCharStruct *xcs;	756	XCharStruct *xcs;
536		757
537	if (encm)	758	if (encm)
538	{	759	{
539	int byte1 = ch >> 8;	760	unsigned char byte1 = ch >> 8;
540	int byte2 = ch & 255;	761	unsigned char byte2 = ch & 255;
541		762
542	if (byte1 < f->min_byte1 \|\| byte1 > f->max_byte1	763	if (byte1 < f->min_byte1 \|\| byte1 > f->max_byte1
543	\|\| byte2 < f->min_char_or_byte2 \|\| byte2 > f->max_char_or_byte2)	764	\|\| byte2 < f->min_char_or_byte2 \|\| byte2 > f->max_char_or_byte2)
544	return false;	765	return false;
545		766
…		…
568		789
569	return true;	790	return true;
570	}	791	}
571		792
572	void	793	void
573	rxvt_font_x11::draw (int x, int y,	794	rxvt_font_x11::draw (rxvt_drawable &d, int x, int y,
574	const text_t *text, int len,	795	const text_t *text, int len,
575	int fg, int bg)	796	int fg, int bg)
576	{	797	{
577	// this looks like a mess /.	798	// this looks like a mess /.
578	// and it is a mess /.	799	// and it is a mess /.
…		…
594	{	815	{
595	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);	816	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
596		817
597	if (bg == Color_bg && !slow)	818	if (bg == Color_bg && !slow)
598	{	819	{
599	XChangeGC (DISPLAY, GC, GCForeground \| GCBackground \| GCFont, &v);	820	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);
600	XDrawImageString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	821	XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);
601	}	822	}
602	else	823	else
603	{	824	{
604	clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	825	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
605		826
606	XChangeGC (DISPLAY, GC, GCForeground \| GCFont, &v);	827	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);
607		828
608	if (slow)	829	if (slow)
609	{	830	{
610	do	831	do
611	{	832	{
612	if (xc->byte1 \|\| xc->byte2)	833	if (xc->byte1 \|\| xc->byte2)
613	XDrawString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, 1);	834	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);
614		835
615	x += r->TermWin.fwidth;	836	x += r->TermWin.fwidth;
616	xc++; len--;	837	xc++; len--;
617	}	838	}
618	while (len);	839	while (len);
619	}	840	}
620	else	841	else
621	XDrawString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	842	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);
622	}	843	}
623	}	844	}
624	else	845	else
625	{	846	{
626	const char *xc = enc_char (text, len, cs, slow);	847	const char *xc = enc_char (text, len, cs, slow);
627		848
628	if (bg == Color_bg && !slow)	849	if (bg == Color_bg && !slow)
629	{	850	{
630	XChangeGC (DISPLAY, GC, GCForeground \| GCBackground \| GCFont, &v);	851	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);
631	XDrawImageString (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	852	XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);
632	}	853	}
633	else	854	else
634	{	855	{
635	clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	856	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
636		857
637	XChangeGC (DISPLAY, GC, GCForeground \| GCFont, &v);	858	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);
638		859
639	if (slow)	860	if (slow)
640	{	861	{
641	do	862	do
642	{	863	{
643	if (*xc)	864	if (*xc)
644	XDrawString (DISPLAY, DRAWABLE, GC, x, y + base, xc, 1);	865	XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);
645		866
646	x += r->TermWin.fwidth;	867	x += r->TermWin.fwidth;
647	xc++; len--;	868	xc++; len--;
648	}	869	}
649	while (len);	870	while (len);
650	}	871	}
651	else	872	else
652	XDrawString (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	873	XDrawString (d.display->display, d, TGC, x, y + base, xc, len);
653	}	874	}
654	}	875	}
655	}	876	}
656		877
657	/////////////////////////////////////////////////////////////////////////////	878	/////////////////////////////////////////////////////////////////////////////
…		…
662	//#define SWATHBITS (UNIBITS / 2 + 3) // minimum size for "full" tables	883	//#define SWATHBITS (UNIBITS / 2 + 3) // minimum size for "full" tables
663	#define SWATHBITS 8	884	#define SWATHBITS 8
664	#endif	885	#endif
665		886
666	struct rxvt_font_xft : rxvt_font {	887	struct rxvt_font_xft : rxvt_font {
667	rxvt_font_xft () { f = 0; d = 0; }	888	rxvt_font_xft () { f = 0; }
668		889
669	void clear ();	890	void clear ();
670		891
671	rxvt_fontprop properties ();	892	rxvt_fontprop properties ();
672		893
673	bool load (const rxvt_fontprop &prop);	894	bool load (const rxvt_fontprop &prop);
674		895
675	void draw (int x, int y,	896	void draw (rxvt_drawable &d, int x, int y,
676	const text_t *text, int len,	897	const text_t *text, int len,
677	int fg, int bg);	898	int fg, int bg);
678		899
679	bool has_codepoint (uint32_t unicode);	900	bool has_codepoint (unicode_t unicode);
680		901
681	protected:	902	protected:
682	XftFont *f;	903	XftFont *f;
683	XftDraw *d;
684	};	904	};
685		905
686	void	906	void
687	rxvt_font_xft::clear ()	907	rxvt_font_xft::clear ()
688	{	908	{
689	if (f)	909	if (f)
690	{	910	{
691	XftFontClose (DISPLAY, f);	911	XftFontClose (DISPLAY, f);
692	f = 0;	912	f = 0;
693	}
694
695	if (d)
696	{
697	XftDrawDestroy (d);
698	d = 0;
699	}	913	}
700	}	914	}
701		915
702	rxvt_fontprop	916	rxvt_fontprop
703	rxvt_font_xft::properties ()	917	rxvt_font_xft::properties ()
…		…
736	FcPatternAddInteger (p, FC_WEIGHT, prop.weight);	950	FcPatternAddInteger (p, FC_WEIGHT, prop.weight);
737		951
738	if (FcPatternGet (p, FC_SLANT, 0, &v) != FcResultMatch)	952	if (FcPatternGet (p, FC_SLANT, 0, &v) != FcResultMatch)
739	FcPatternAddInteger (p, FC_SLANT, prop.slant);	953	FcPatternAddInteger (p, FC_SLANT, prop.slant);
740		954
		955	#if 0 // clipping unfortunately destroys our precious double-width-characters
741	// clip width, we can't do better, or can we?	956	// clip width, we can't do better, or can we?
742	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)	957	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
743	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);	958	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
		959	#endif
744		960
745	//FcPatternAddBool (p, FC_MINSPACE, 1);	961	//FcPatternAddBool (p, FC_MINSPACE, 1);
746		962
747	XftResult result;	963	XftResult result;
748	FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);	964	FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);
…		…
802		1018
803	return true;	1019	return true;
804	}	1020	}
805		1021
806	bool	1022	bool
807	rxvt_font_xft::has_codepoint (uint32_t unicode)	1023	rxvt_font_xft::has_codepoint (unicode_t unicode)
808	{	1024	{
809	return XftCharExists (DISPLAY, f, unicode);	1025	return XftCharExists (DISPLAY, f, unicode);
810	}	1026	}
811		1027
812	void	1028	void
813	rxvt_font_xft::draw (int x, int y,	1029	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
814	const text_t *text, int len,	1030	const text_t *text, int len,
815	int fg, int bg)	1031	int fg, int bg)
816	{	1032	{
817	if (!d)
818	{
819	dR;
820	d = XftDrawCreate (DISPLAY, DRAWABLE, XVISUAL, XCMAP);
821	}
822
823	if (bg >= 0 && bg != Color_bg)
824	XftDrawRect (d, &r->PixColors[bg].c, x, y, r->TermWin.fwidth * len, r->TermWin.fheight);
825	else
826	clear_rect (x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	1033	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);
827		1034
828	if (!slow && width == r->TermWin.fwidth)	1035	if (!slow && width == r->TermWin.fwidth && 0)
829	{	1036	{
830	if (sizeof (text_t) == sizeof (FcChar16))	1037	if (sizeof (text_t) == sizeof (FcChar16))
831	XftDrawString16 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar16 *)text, len);	1038	XftDrawString16 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar16 *)text, len);
832	else	1039	else
833	XftDrawString32 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar32 *)text, len);	1040	XftDrawString32 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar32 *)text, len);
…		…
836	{	1043	{
837	while (len)	1044	while (len)
838	{	1045	{
839	if (text != NOCHAR && text != ' ')	1046	if (text != NOCHAR && text != ' ')
840	{	1047	{
		1048	int fwidth = r->TermWin.fwidth;
		1049	if (len >= 2 && text[1] == NOCHAR)
		1050	fwidth *= 2;
		1051
		1052	XGlyphInfo extents;
841	if (sizeof (text_t) == sizeof (FcChar16))	1053	if (sizeof (text_t) == sizeof (FcChar16))
842	XftDrawString16 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar16 *)text, 1);	1054	{
		1055	XftTextExtents16 (d.display->display, f, (const FcChar16 *)text, 1, &extents);
		1056	XftDrawString16 (d, &r->PixColors[fg].c, f, x + extents.x + (fwidth - extents.width) / 2,
		1057	y + r->TermWin.fbase, (const FcChar16 *)text, 1);
		1058	}
843	else	1059	else
844	XftDrawString32 (d, &r->PixColors[fg].c, f, x, y + r->TermWin.fbase, (const FcChar32 *)text, 1);	1060	{
		1061	XGlyphInfo extents;
		1062	XftTextExtents32 (d.display->display, f, (const FcChar32 *)text, 1, &extents);
		1063	XftDrawString32 (d, &r->PixColors[fg].c, f, x + extents.x + (fwidth - extents.width) / 2,
		1064	y + r->TermWin.fbase, (const FcChar32 *)text, 1);
		1065	}
845	}	1066	}
846		1067
847	x += r->TermWin.fwidth;	1068	x += r->TermWin.fwidth;
848	text++;	1069	text++;
849	len--;	1070	len--;
…		…
853	#endif	1074	#endif
854		1075
855	/////////////////////////////////////////////////////////////////////////////	1076	/////////////////////////////////////////////////////////////////////////////
856		1077
857	rxvt_fontset::rxvt_fontset (rxvt_t r)	1078	rxvt_fontset::rxvt_fontset (rxvt_t r)
858	#ifdef EXPLICIT_CONTEXT
859	: r(r)	1079	: r (r)
860	#endif
861	{	1080	{
862	clear ();	1081	clear ();
863	}	1082	}
864		1083
865	rxvt_fontset::~rxvt_fontset ()	1084	rxvt_fontset::~rxvt_fontset ()
…		…
868	}	1087	}
869		1088
870	void	1089	void
871	rxvt_fontset::clear ()	1090	rxvt_fontset::clear ()
872	{	1091	{
873	for (rxvt_font **i = fonts.begin (); i != fonts.end(); i++)	1092	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
874	FONT_UNREF (*i);	1093	FONT_UNREF (*i);
875		1094
876	fonts.clear ();	1095	fonts.clear ();
877	base_id = 0;	1096	base_id = 0;
878	base_prop.height = 0x7fffffff;	1097	base_prop.height = 0x7fffffff;
…		…
905	f = new rxvt_font_x11;	1124	f = new rxvt_font_x11;
906	}	1125	}
907	else	1126	else
908	f = new rxvt_font_x11;	1127	f = new rxvt_font_x11;
909		1128
		1129	f->fs = this;
910	f->set_term (r);	1130	f->set_term (r);
911	f->set_name (strdup (name));	1131	f->set_name (strdup (name));
912		1132
913	f->cs = cs;	1133	f->cs = cs;
914	f->loaded = false;	1134	f->loaded = false;
…		…
932		1152
933	if (*desc == '[')	1153	if (*desc == '[')
934	{	1154	{
935	fprintf (stderr, "extra font parameters not yet supported, skipping.\n");	1155	fprintf (stderr, "extra font parameters not yet supported, skipping.\n");
936		1156
937	const char *extra = desc++;	1157	//const char *extra = desc++; // not yet used
938		1158
939	desc = strchr (desc, ']');	1159	desc = strchr (desc, ']');
940		1160
941	if (!desc)	1161	if (!desc)
942	{	1162	{
…		…
981	}	1201	}
982		1202
983	return true;	1203	return true;
984	}	1204	}
985		1205
986	void	1206	bool
987	rxvt_fontset::populate (const char *desc)	1207	rxvt_fontset::populate (const char *desc)
988	{	1208	{
989	clear ();	1209	clear ();
990		1210
991	fonts.push_back (new_font (0, CS_UNICODE));	1211	fonts.push_back (new_font (0, CS_UNICODE));
…		…
995		1215
996	if (!base_id)	1216	if (!base_id)
997	base_id = 1;	1217	base_id = 1;
998		1218
999	// we currently need a base-font, no matter what	1219	// we currently need a base-font, no matter what
1000	if (fonts.size () <= base_id \|\| !realize_font (base_id))	1220	if ((int)fonts.size () <= base_id \|\| !realize_font (base_id))
1001	{	1221	{
		1222	puts ("unable to load specified font (s), falling back to 'fixed'\n");
1002	add_fonts ("fixed");	1223	add_fonts ("fixed");
1003	base_id = fonts.size () - 1;	1224	base_id = fonts.size () - 1;
1004	}	1225	}
1005		1226
1006	if (fonts.size () <= base_id \|\| !realize_font (base_id))	1227	if ((int)fonts.size () <= base_id \|\| !realize_font (base_id))
1007	{	1228	return false;
1008	fprintf (stderr, "unable to load a base font, please provide one using -fn fontname\n");
1009	exit (1);
1010	}
1011		1229
1012	base_prop = fonts[base_id]->properties ();	1230	base_prop = fonts[base_id]->properties ();
		1231
		1232	return true;
1013	}	1233	}
1014		1234
1015	int	1235	int
1016	rxvt_fontset::find_font (uint32_t unicode)	1236	rxvt_fontset::find_font (unicode_t unicode)
1017	{	1237	{
1018	for (int i = 0; i < fonts.size (); i++)	1238	for (unsigned int i = 0; i < fonts.size (); i++)
1019	{	1239	{
1020	rxvt_font *f = fonts[i];	1240	rxvt_font *f = fonts[i];
1021		1241
1022	if (!f->loaded)	1242	if (!f->loaded)
1023	{	1243	{

Diff Legend

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

Comparing rxvt-unicode/src/defaultfont.C (file contents): Revision 1.10 by pcg, Wed Dec 24 09:07:01 2003 UTC vs. Revision 1.43 by pcg, Mon Mar 15 07:10:47 2004 UTC

Diff Legend

Comparing rxvt-unicode/src/defaultfont.C (file contents):
Revision 1.10 by pcg, Wed Dec 24 09:07:01 2003 UTC vs.
Revision 1.43 by pcg, Mon Mar 15 07:10:47 2004 UTC