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

Comparing rxvt-unicode/src/defaultfont.C (file contents):
Revision 1.6 by pcg, Wed Dec 17 22:29:03 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
21		21
22	#include "../config.h"	22	#include "../config.h"
23	#include "rxvt.h"	23	#include "rxvt.h"
24	#include "defaultfont.h"	24	#include "defaultfont.h"
25		25
		26	#include <cstdlib>
		27
26	#define DISPLAY r->Xdisplay	28	#define DISPLAY r->display->display
27	#define DRAWABLE r->TermWin.vt
28	#define GC r->TermWin.gc	29	#define TGC r->TermWin.gc
29		30
30	const struct rxvt_fallback_font {	31	const struct rxvt_fallback_font {
31	codeset cs;	32	codeset cs;
32	const char *name;	33	const char *name;
33	} fallback_fonts[] = {	34	} fallback_fonts[] = {
…		…
57		58
58	// japanese	59	// japanese
59	#if ENCODING_JP \|\| ENCODING_JP_EXT	60	#if ENCODING_JP \|\| ENCODING_JP_EXT
60	# if XFT	61	# if XFT
61	// prefer xft for complex scripts	62	// prefer xft for complex scripts
62	{ CS_UNICODE, "xft:Kochi Gothic" },	63	{ CS_UNICODE, "xft:Kochi Gothic:antialias=false" },
63	# endif	64	# endif
64	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },	65	{ CS_JIS0201_1976_0, "--mincho--r-------c--jisx0201*-0" },
65	{ CS_JIS0208_1983_0, "--mincho--r-------c--jisx0208*-0" },	66	{ CS_JIS0208_1990_0, "--mincho--r-------c--jisx0208*-0" },
66	{ CS_JIS0212_1990_0, "--mincho--r-------c--jisx0212*-0" },	67	{ CS_JIS0212_1990_0, "--mincho--r-------c--jisx0212*-0" },
67	#endif	68	#endif
68		69
69	#if ENCODING_CN \|\| ENCODING_CN_EXT	70	#if ENCODING_CN \|\| ENCODING_CN_EXT
70	# if XFT	71	# if XFT
71	{ CS_BIG5_EXT, "xft:AR PL Mingti2L Big5" },	72	{ CS_BIG5_EXT, "xft:AR PL Mingti2L Big5" },
72	{ CS_BIG5_EXT, "xft:AR PL KaitiM Big5" },	73	{ CS_BIG5_EXT, "xft:AR PL KaitiM Big5" },
73	{ CS_GB2312_1980_0, "xft:AR PL KaitiM GB" },	74	{ CS_GB2312_1980_0, "xft:AR PL KaitiM GB" },
74	{ CS_GB2312_1980_0, "xft:AR PL SungtiL GB" },	75	{ CS_GB2312_1980_0, "xft:AR PL SungtiL GB" },
75	# 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" },
76	{ CS_CNS11643_1992_1, "----r-------c--cns11643.1992-1" },	81	{ CS_CNS11643_1992_1, "-----------c--cns11643-1" },
77	{ CS_CNS11643_1992_2, "----r-------c--cns11643.1992-2" },	82	{ CS_CNS11643_1992_2, "-----------c--cns11643-2" },
78	{ CS_CNS11643_1992_3, "----r-------c--cns11643.1992-3" },	83	{ CS_CNS11643_1992_3, "-----------c--cns11643-3" },
79	{ CS_CNS11643_1992_4, "----r-------c--cns11643.1992-4" },	84	{ CS_CNS11643_1992_4, "-----------c--cns11643-4" },
80	{ CS_CNS11643_1992_5, "----r-------c--cns11643.1992-5" },	85	{ CS_CNS11643_1992_5, "-----------c--cns11643-5" },
81	{ CS_CNS11643_1992_6, "----r-------c--cns11643.1992-6" },	86	{ CS_CNS11643_1992_6, "-----------c--cns11643-6" },
82	{ CS_CNS11643_1992_7, "----r-------c--cns11643.1992-7" },	87	{ CS_CNS11643_1992_7, "-----------c--cns11643-7" },
83	{ CS_CNS11643_1992_F, "----r-------c--cns11643.1992-f" },	88	{ CS_CNS11643_1992_F, "-----------c--cns11643-f" },
84	#endif	89	#endif
85		90
86	#if XFT	91	#if XFT
87	{ CS_UNICODE, "xft:Andale Mono" },	92	{ CS_UNICODE, "xft:Andale Mono" },
88	{ CS_UNICODE, "xft:Arial Unicode MS" },	93	{ CS_UNICODE, "xft:Arial Unicode MS" },
89	#endif	94	#endif
90	{ CS_UNICODE, "--lucidatypewriter--r-------m-*-iso10646-1" },	95	{ CS_UNICODE, "--lucidatypewriter---------m--iso10646-1" },
		96	{ CS_UNICODE, "xft:FreeMono" },
		97	{ CS_UNICODE, "--unifont---------c--iso10646-1" },
		98	{ CS_UNICODE, "----r-------c--iso10646-1" },
91	{ CS_UNICODE, "----r-------m--iso10646-1" },	99	{ CS_UNICODE, "----r-------m--iso10646-1" },
92	{ CS_UNICODE, "----r-------m--iso10646-1" },	100
93	{ CS_UNICODE, "----r-------m--iso10646-1" },	101	#if UNICODE_3 && XFT
		102	{ CS_UNICODE, "xft:Code2001" }, // contains many plane-1 characters
		103	#endif
94		104
95	{ CS_UNKNOWN, 0 }	105	{ CS_UNKNOWN, 0 }
96	};	106	};
97		107
98	/////////////////////////////////////////////////////////////////////////////	108	/////////////////////////////////////////////////////////////////////////////
99		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
100	static void *enc_buf;	128	static void *enc_buf;
101	static uint32_t enc_len;	129	static uint32_t enc_len;
102		130
103	static inline void *	131	static inline void *
104	get_enc_buf (int len)	132	get_enc_buf (uint32_t len)
105	{	133	{
106	if (len > enc_len)	134	if (len > enc_len)
107	{	135	{
108	free (enc_buf);	136	free (enc_buf);
109	enc_buf = malloc (len);	137	enc_buf = malloc (len);
…		…
111		139
112	return enc_buf;	140	return enc_buf;
113	}	141	}
114		142
115	static const char *	143	static const char *
116	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)
117	{	145	{
118	uint8_t buf = (uint8_t )get_enc_buf (len);	146	uint8_t buf = (uint8_t )get_enc_buf (len);
119		147
120	while (len--)	148	while (len--)
121	{	149	{
…		…
132		160
133	return (const char *)enc_buf;	161	return (const char *)enc_buf;
134	}	162	}
135		163
136	static const XChar2b *	164	static const XChar2b *
137	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)
138	{	166	{
139	XChar2b buf = (XChar2b )get_enc_buf (len * sizeof (XChar2b));	167	XChar2b buf = (XChar2b )get_enc_buf (len * sizeof (XChar2b));
140		168
141	while (len--)	169	while (len--)
142	{	170	{
…		…
157	}	185	}
158		186
159	/////////////////////////////////////////////////////////////////////////////	187	/////////////////////////////////////////////////////////////////////////////
160		188
161	void	189	void
162	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)
163	{	191	{
164	if (color == Color_bg)	192	if (color == Color_bg)
165	XClearArea (DISPLAY, DRAWABLE, x, y, w, h, FALSE);	193	XClearArea (d.display->display, d, x, y, w, h, FALSE);
166	else if (color >= 0)	194	else if (color >= 0)
167	{	195	{
		196	#if XFT
		197	XftDrawRect (d, &r->PixColors[color].c, x, y, w, h);
		198	#else
168	XSetForeground (DISPLAY, GC, r->PixColors[color]);	199	XSetForeground (d.display->display, TGC, r->PixColors[color]);
169	XFillRectangle (DISPLAY, DRAWABLE, GC, x, y, w, h);	200	XFillRectangle (d.display->display, d, TGC, x, y, w, h);
		201	#endif
170	}	202	}
171	}	203	}
172		204
173	static const char *linedraw_cmds[128] = {	205	static const char *linedraw_cmds[128 + 32] = {
174	"1hH", "2hH", "1vV", "2vV",	206	"1-", "2-", "1\|", "2\|",
175	0, 0, 0, 0,	207	0, 0, 0, 0,
176	0, 0, 0, 0,	208	0, 0, 0, 0,
177	"1HV", "2H1V", "1H2V", "2HV",	209	"1HV", "2H1V", "1H2V", "2HV",
178		210
179	// 2510	211	// 2510
180	"1hV", "2h1V", "1h2V", "2hV",	212	"1hV", "2h1V", "1h2V", "2hV",
181	"1Hv", "2H1v", "1H2v", "2Hv",	213	"1Hv", "2H1v", "1H2v", "2Hv",
182	"1hv", "2h1v", "1h2v", "2hv",	214	"1hv", "2h1v", "1h2v", "2hv",
183	"1HvV", "2H1vV", "1HV2v", "1Hv2V",	215	"1H\|", "2H1\|", "1HV2v", "1Hv2V",
184		216
185	// 2520	217	// 2520
186	"1H2vV", "2Hv1V", "2HV1v", "2HvV",	218	"1H2\|", "2Hv1V", "2HV1v", "2H\|",
187	"1hvV", "2h1vV", "1hV2v", "1hv2V",	219	"1h\|", "2h1\|", "1hV2v", "1hv2V",
188	"1h2vV", "2hv1V", "1v2hV", "2hvV",	220	"1h2\|", "2hv1V", "1v2hV", "2h\|",
189	"1hHV", "2h1HV", "2H1hV", "2hH1V",	221	"1-V", "2h1HV", "2H1hV", "2-1V",
190		222
191	// 2530	223	// 2530
192	"1hH2V", "2hV1H", "1h2HV", "2hHV",	224	"1-2V", "2hV1H", "1h2HV", "2-V",
193	"1hHv", "1vH2h", "1hv2H", "1v2hH",	225	"1-v", "1vH2h", "1hv2H", "1v2-",
194	"1hH2v", "1H2hv", "1h2Hv", "2hHv",	226	"1-2v", "1H2hv", "1h2Hv", "2-v",
195	"1hHvV", "1vVH2h", "1hvV2H", "1vV2hH",	227	"1-\|", "1\|H2h", "1h\|2H", "1\|2-",
196		228
197	// 2540	229	// 2540
198	"1hHV2v", "1hHv2V", "1hH2vV", "1HV2hv",	230	"1-V2v", "1-v2V", "1-2\|", "1HV2hv",
199	"1hV2Hv", "1Hv2hV", "1hv2HV", "1V2hHv",	231	"1hV2Hv", "1Hv2hV", "1hv2HV", "1V2-v",
200	"1v2hHV", "1H2hvV", "1h2HvV", "2hHvV",	232	"1v2-V", "1H2h\|", "1h2H\|", "2-\|",
201	0, 0, 0, 0,	233	0, 0, 0, 0,
202		234
203	// 2550	235	// 2550
204	0, 0, 0, 0,	236	0, 0, 0, 0,
205	0, 0, 0, 0,	237	0, 0, 0, 0,
…		…
208		240
209	// 2560	241	// 2560
210	0, 0, 0, 0,	242	0, 0, 0, 0,
211	0, 0, 0, 0,	243	0, 0, 0, 0,
212	0, 0, 0, 0,	244	0, 0, 0, 0,
213	0, 0, 0, 0,	245	0, "A", "B", "C",
214		246
215	// 2570	247	// 2570
216	0, "1a", "1b", "1ab",	248	"D", "1/", "1\\", "1/\\",
217	"1h", "1v", "1H", "1V",	249	"1h", "1v", "1H", "1V",
218	"2h", "2v", "2H", "2V",	250	"2h", "2v", "2H", "2V",
219	"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",
220		264
221	// to be done	265	// to be done
222	};	266	};
223		267
224	struct rxvt_font_default : rxvt_font {	268	struct rxvt_font_default : rxvt_font {
225	bool load (int maxheight)	269	rxvt_fontprop properties ()
		270	{
		271	rxvt_fontprop p;
		272
		273	p.width = p.height = 1;
		274	p.weight = rxvt_fontprop::medium;
		275	p.slant = rxvt_fontprop::roman;
		276
		277	return p;
		278	}
		279
		280	bool load (const rxvt_fontprop &prop)
226	{	281	{
227	width = 1; height = 1;	282	width = 1; height = 1;
228	ascent = 1; descent = 0;	283	ascent = 1; descent = 0;
229		284
		285	set_name ("built-in pseudofont");
		286
230	return true;	287	return true;
231	}	288	}
232		289
233	bool has_codepoint (uint32_t unicode)	290	bool has_codepoint (unicode_t unicode)
234	{	291	{
235	if (unicode <= 0x001f)	292	if (unicode <= 0x001f)
236	return true;	293	return true;
		294
237	if (unicode >= 0x0080 && unicode <= 0x009f)	295	if (unicode >= 0x0080 && unicode <= 0x009f)
238	return true;	296	return true;
239		297
240	if (unicode >= 0x2500 && unicode <= 0x257f	298	if (unicode >= 0x2500 && unicode <= 0x257f
241	&& 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))
242	return true;	306	return true;
243		307
244	switch (unicode)	308	switch (unicode)
245	{	309	{
246	case ZERO_WIDTH_CHAR:	310	case ZERO_WIDTH_CHAR:
…		…
248	}	312	}
249		313
250	return false;	314	return false;
251	}	315	}
252		316
253	void draw (int x, int y,	317	void draw (rxvt_drawable &d, int x, int y,
254	const text_t *text, int len,	318	const text_t *text, int len,
255	int fg, int bg);	319	int fg, int bg);
256	};	320	};
257		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
258	void	344	void
259	rxvt_font_default::draw (int x, int y,	345	rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
260	const text_t *text, int len,	346	const text_t *text, int len,
261	int fg, int bg)	347	int fg, int bg)
262	{	348	{
263	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);
264		350
265	XSetForeground (DISPLAY, GC, r->PixColors[fg]);	351	XSetForeground (d.display->display, TGC, r->PixColors[fg]);
266		352
267	while (len--)	353	while (len--)
268	{	354	{
		355	#if ENABLE_COMBINING
		356	compose_char *cc;
		357	#endif
269	text_t t = *text++;	358	text_t t = *text++;
270		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?
271	if (t >= 0x2500 & t <= 0x2580 && linedraw_cmds[t - 0x2500])	366	if (t >= 0x2500 & t <= 0x259f && linedraw_cmds[t - 0x2500])
272	{	367	{
273	const char *p = linedraw_cmds[t - 0x2500];	368	const char *p = linedraw_cmds[t - 0x2500];
274		369
275	int x0 = x, x1 = x + r->TermWin.fwidth / 2, x2 = x + r->TermWin.fwidth ;
276	int y0 = y, y1 = y + r->TermWin.fheight / 2, y2 = y + r->TermWin.fheight;
277
278	XGCValues gcv;	370	XGCValues gcv;
		371
		372	gcv.cap_style = CapNotLast;
		373	XChangeGC (d.display->display, TGC, GCCapStyle, &gcv);
279		374
280	while (*p)	375	while (*p)
281	{	376	{
282	switch (*p++)	377	switch (*p++)
283	{	378	{
284	case '1':	379	case '1':
285	gcv.line_width = 0;	380	gcv.line_width = 0;
286	XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);	381	XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
287	break;	382	break;
288		383
289	case '2':	384	case '2':
290	gcv.line_width = 2;	385	gcv.line_width = 3;
291	XChangeGC (DISPLAY, GC, GCLineWidth, &gcv);	386	XChangeGC (d.display->display, TGC, GCLineWidth, &gcv);
292	break;	387	break;
293		388
294	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;
295	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;
296	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;
297	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
298	case 'a': XDrawLine (DISPLAY, DRAWABLE, GC, x0, y2, x2, y0); break;	396	case '/' : XDrawLine (d.display->display, d, TGC, x0, y2, x2 , y0 ); break;
299	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;
300	}	408	}
301	}	409	}
302		410
303	gcv.line_width = 0;	411	gcv.line_width = 0;
304	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]))
305	}	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
306	else	431	else
307	switch (*text++)	432	switch (t)
308	{	433	{
309	case NOCHAR:
310	case ZERO_WIDTH_CHAR:	434	case ZERO_WIDTH_CHAR:
311	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
312	default:	462	default:
313	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;
314	}	474	}
315		475
316	x += r->TermWin.fwidth;	476	x += r->TermWin.fwidth;
317	}	477	}
318	}	478	}
…		…
322	struct rxvt_font_x11 : rxvt_font {	482	struct rxvt_font_x11 : rxvt_font {
323	rxvt_font_x11 () { f = 0; }	483	rxvt_font_x11 () { f = 0; }
324		484
325	void clear ();	485	void clear ();
326		486
327	bool load (int maxheight);	487	rxvt_fontprop properties ();
328		488
		489	bool load (const rxvt_fontprop &prop);
		490
329	bool has_codepoint (uint32_t unicode);	491	bool has_codepoint (unicode_t unicode);
330		492
331	void draw (int x, int y,	493	void draw (rxvt_drawable &d, int x, int y,
332	const text_t *text, int len,	494	const text_t *text, int len,
333	int fg, int bg);	495	int fg, int bg);
334		496
335	XFontStruct *f;	497	XFontStruct *f;
336	codeset cs;	498	codeset cs;
337	bool enc2b, encm;	499	bool enc2b, encm;
338		500
339	const char get_property (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);
340	};	505	};
341		506
342	const char *	507	const char *
343	rxvt_font_x11::get_property (const char property, const char repl) const	508	rxvt_font_x11::get_property (XFontStruct f, const char property, const char *repl) const
344	{	509	{
345	unsigned long value;	510	unsigned long value;
346		511
347	if (XGetFontProperty (f, XInternAtom (DISPLAY, property, 0), &value))	512	if (XGetFontProperty (f, XInternAtom (DISPLAY, property, 0), &value))
348	return XGetAtomName (DISPLAY, value);	513	return XGetAtomName (DISPLAY, value);
349	else	514	else
350	return repl;	515	return repl;
351	}	516	}
352		517
		518	rxvt_fontprop
		519	rxvt_font_x11::properties ()
		520	{
		521	rxvt_fontprop p;
		522	set_properties (p, f);
		523	return p;
		524	}
		525
353	bool	526	bool
354	rxvt_font_x11::load (int maxheight)	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	{
		540	const char *weight = get_property (f, "WEIGHT_NAME", "medium");
		541	const char *slant = get_property (f, "SLANT", "r");
		542
		543	unsigned long height;
		544	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "PIXEL_SIZE", 0), &height))
		545	return false;
		546
		547	unsigned long avgwidth;
		548	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "AVERAGE_WIDTH", 0), &avgwidth))
		549	avgwidth = 0;
		550
		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);
		615	}
		616
		617	bool
		618	rxvt_font_x11::load (const rxvt_fontprop &prop)
355	{	619	{
356	clear ();	620	clear ();
357		621
358	char **list;	622	char **list;
359	int count;	623	int count;
360	XFontStruct *info;
361	list = XListFontsWithInfo (DISPLAY, name, 128, &count, &info);	624	list = XListFonts (DISPLAY, name, 512, &count);
		625	set_name (0);
362		626
363	if (!list)	627	if (!list)
364	return false;	628	return false;
365		629
366	XFontStruct *best = 0;	630	int bestdiff = 0x7fffffff;
367	for (int i = 0; i < count; i++)	631	for (int i = 0; i < count; i++)
368	{	632	{
369	XFontStruct *f = info + i;	633	rxvt_fontprop p;
370	if (f->ascent + f->descent <= maxheight) // weed out too large fonts	634	char fname[1024];
		635	fix_scalable (fname, list[i], prop);
		636
		637	if (!set_properties (p, fname))
		638	continue;
		639
		640	if (p.height > prop.height) // weed out too large fonts
		641	continue;
		642
		643	int diff = (prop.height - p.height) * 32
		644	+ abs (prop.weight - p.weight)
		645	+ abs (prop.slant - p.slant );
		646
371	if (!best // compare against best found so far	647	if (!name // compare against best found so far
372	\|\| best->ascent + best->descent < f->ascent + f->descent)	648	\|\| diff < bestdiff)
		649	{
		650	set_name (strdup (fname));
373	best = f;	651	bestdiff = diff;
		652	}
374	}	653	}
375		654
376	set_name (strdup (list[best - info]));	655	XFreeFontNames (list);
377		656
378	XFreeFontInfo (list, info, count);	657	if (!name)
		658	return false;
379		659
380	f = XLoadQueryFont (DISPLAY, name);	660	f = XLoadQueryFont (DISPLAY, name);
381		661
382	if (!f)	662	if (!f)
383	return false;	663	return false;
384		664
385	unsigned long value;
386
387	const char *registry = get_property ("CHARSET_REGISTRY", 0);	665	const char *registry = get_property (f, "CHARSET_REGISTRY", 0);
388	const char *encoding = get_property ("CHARSET_ENCODING", 0);	666	const char *encoding = get_property (f, "CHARSET_ENCODING", 0);
389		667
390	if (registry && encoding)	668	if (registry && encoding)
391	{	669	{
392	char charset[64];	670	char charset[64];
393	snprintf (charset, 64, "%s-%s", registry, encoding);	671	snprintf (charset, 64, "%s-%s", registry, encoding);
394		672
395	cs = codeset_from_name (charset);	673	cs = codeset_from_name (charset);
396	}	674	}
397	else	675	else
398	{	676	{
399	const char *charset = get_property ("FONT", 0);	677	const char *charset = get_property (f, "FONT", 0);
400		678
401	if (!charset)	679	if (!charset)
402	charset = name;	680	charset = name;
403		681
404	int count = 13;	682	int count = 13;
…		…
417		695
418	ascent = f->ascent;	696	ascent = f->ascent;
419	descent = f->descent;	697	descent = f->descent;
420	height = ascent + descent;	698	height = ascent + descent;
421		699
422	prop = false;	700	slow = false;
423		701
424	if (f->min_bounds.width == f->max_bounds.width)	702	if (f->min_bounds.width == f->max_bounds.width)
425	width = f->min_bounds.width;	703	width = f->min_bounds.width;
426	else if (f->per_char == NULL)	704	else if (f->per_char == NULL)
427	width = f->max_bounds.width;	705	width = f->max_bounds.width;
428	else	706	else
429	{	707	{
430	prop = true;	708	slow = true;
431		709
432	int N = f->max_char_or_byte2 - f->min_char_or_byte2;	710	int N = f->max_char_or_byte2 - f->min_char_or_byte2;
433		711
434	if (encm)	712	if (encm)
435	N += (f->max_byte1 - f->min_byte1)	713	N += (f->max_byte1 - f->min_byte1)
…		…
465	f = 0;	743	f = 0;
466	}	744	}
467	}	745	}
468		746
469	bool	747	bool
470	rxvt_font_x11::has_codepoint (uint32_t unicode)	748	rxvt_font_x11::has_codepoint (unicode_t unicode)
471	{	749	{
472	uint32_t ch = FROM_UNICODE (cs, unicode);	750	uint32_t ch = FROM_UNICODE (cs, unicode);
473		751
474	if (ch == NOCHAR)	752	if (ch == NOCHAR)
475	return false;	753	return false;
…		…
477	/* check wether the character exists in _this_ font. horrible. */	755	/* check wether the character exists in _this_ font. horrible. */
478	XCharStruct *xcs;	756	XCharStruct *xcs;
479		757
480	if (encm)	758	if (encm)
481	{	759	{
482	int byte1 = ch >> 8;	760	unsigned char byte1 = ch >> 8;
483	int byte2 = ch & 255;	761	unsigned char byte2 = ch & 255;
484		762
485	if (byte1 < f->min_byte1 \|\| byte1 > f->max_byte1	763	if (byte1 < f->min_byte1 \|\| byte1 > f->max_byte1
486	\|\| 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)
487	return false;	765	return false;
488		766
…		…
511		789
512	return true;	790	return true;
513	}	791	}
514		792
515	void	793	void
516	rxvt_font_x11::draw (int x, int y,	794	rxvt_font_x11::draw (rxvt_drawable &d, int x, int y,
517	const text_t *text, int len,	795	const text_t *text, int len,
518	int fg, int bg)	796	int fg, int bg)
519	{	797	{
520	// this looks like a mess /.	798	// this looks like a mess /.
521	// and it is a mess /.	799	// and it is a mess /.
522	// yet we are trying to be perfect /.	800	// yet we are trying to be perfect /.
523	// but the result still isn't perfect /.	801	// but the result still isn't perfect /.
524		802
525	bool slow = prop	803	bool slow = this->slow
526	\|\| width != r->TermWin.fwidth	804	\|\| width != r->TermWin.fwidth
527	\|\| height != r->TermWin.fheight;	805	\|\| height != r->TermWin.fheight;
528		806
529	int base = r->TermWin.fbase;	807	int base = r->TermWin.fbase;
530		808
…		…
537	{	815	{
538	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);	816	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
539		817
540	if (bg == Color_bg && !slow)	818	if (bg == Color_bg && !slow)
541	{	819	{
542	XChangeGC (DISPLAY, GC, GCForeground \| GCBackground \| GCFont, &v);	820	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);
543	XDrawImageString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	821	XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);
544	}	822	}
545	else	823	else
546	{	824	{
547	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);
548		826
549	XChangeGC (DISPLAY, GC, GCForeground \| GCFont, &v);	827	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);
550		828
551	if (slow)	829	if (slow)
552	{	830	{
553	do	831	do
554	{	832	{
555	if (xc->byte1 \|\| xc->byte2)	833	if (xc->byte1 \|\| xc->byte2)
556	XDrawString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, 1);	834	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);
557		835
558	x += r->TermWin.fwidth;	836	x += r->TermWin.fwidth;
559	xc++; len--;	837	xc++; len--;
560	}	838	}
561	while (len);	839	while (len);
562	}	840	}
563	else	841	else
564	XDrawString16 (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	842	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);
565	}	843	}
566	}	844	}
567	else	845	else
568	{	846	{
569	const char *xc = enc_char (text, len, cs, slow);	847	const char *xc = enc_char (text, len, cs, slow);
570		848
571	if (bg == Color_bg && !slow)	849	if (bg == Color_bg && !slow)
572	{	850	{
573	XChangeGC (DISPLAY, GC, GCForeground \| GCBackground \| GCFont, &v);	851	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);
574	XDrawImageString (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	852	XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);
575	}	853	}
576	else	854	else
577	{	855	{
578	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);
579		857
580	XChangeGC (DISPLAY, GC, GCForeground \| GCFont, &v);	858	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);
581		859
582	if (slow)	860	if (slow)
583	{	861	{
584	do	862	do
585	{	863	{
586	if (*xc)	864	if (*xc)
587	XDrawString (DISPLAY, DRAWABLE, GC, x, y + base, xc, 1);	865	XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);
588		866
589	x += r->TermWin.fwidth;	867	x += r->TermWin.fwidth;
590	xc++; len--;	868	xc++; len--;
591	}	869	}
592	while (len);	870	while (len);
593	}	871	}
594	else	872	else
595	XDrawString (DISPLAY, DRAWABLE, GC, x, y + base, xc, len);	873	XDrawString (d.display->display, d, TGC, x, y + base, xc, len);
596	}	874	}
597	}	875	}
598	}	876	}
599		877
600	/////////////////////////////////////////////////////////////////////////////	878	/////////////////////////////////////////////////////////////////////////////
…		…
605	//#define SWATHBITS (UNIBITS / 2 + 3) // minimum size for "full" tables	883	//#define SWATHBITS (UNIBITS / 2 + 3) // minimum size for "full" tables
606	#define SWATHBITS 8	884	#define SWATHBITS 8
607	#endif	885	#endif
608		886
609	struct rxvt_font_xft : rxvt_font {	887	struct rxvt_font_xft : rxvt_font {
610	#if 0
611	enum {
612	SWATHCOUNT = 1 << (21 - UNIBITS),
613	SWATHSIZE = 1 << (SWATHBITS - 5)
614	};
615	typedef uint32_t swath[SWATHSIZE];
616
617	swath *cvr[SWATHCOUNT];
618	#endif
619
620	#if 0
621	void gen_coverage_swath (unsigned int page);
622
623	bool has_char (uint32_t ch)
624	{
625	unsigned int page = ch >> SWATHBITS;
626	unsigned int idx = ch & ((1 << SWATHBITS) - 1);
627
628	if (page >= SWATHCOUNT)
629	return false;
630
631	if (!cvr[page]) gen_coverage_swath (page);
632
633	return cvr[page][idx >> 5] & (1 << (idx & 31));
634	}
635	#endif
636	rxvt_font_xft () { f = 0; d = 0; }	888	rxvt_font_xft () { f = 0; }
637		889
638	void clear ();	890	void clear ();
639		891
640	bool load (int maxheight);	892	rxvt_fontprop properties ();
641		893
642	void draw (int x, int y,	894	bool load (const rxvt_fontprop &prop);
		895
		896	void draw (rxvt_drawable &d, int x, int y,
643	const text_t *text, int len,	897	const text_t *text, int len,
644	int fg, int bg);	898	int fg, int bg);
645		899
646	bool has_codepoint (uint32_t unicode);	900	bool has_codepoint (unicode_t unicode);
647		901
648	protected:	902	protected:
649	XftFont *f;	903	XftFont *f;
650	XftDraw *d;
651
652	#if 0
653	virtual void populate_coverage_swath (uint32_t lo, uint32_t hi) = 0;
654	void set_swath (uint32_t ch)
655	{
656	cvr[ch >> SWATHBITS] \|= 1 << (ch & ((1 << SWATHBITS) - 1));
657	}
658	#endif
659	};	904	};
660		905
661	void	906	void
662	rxvt_font_xft::clear ()	907	rxvt_font_xft::clear ()
663	{	908	{
664	if (f)	909	if (f)
665	{	910	{
666	XftFontClose (DISPLAY, f);	911	XftFontClose (DISPLAY, f);
667	f = 0;	912	f = 0;
668	}	913	}
		914	}
669		915
670	if (d)	916	rxvt_fontprop
671	{	917	rxvt_font_xft::properties ()
672	XftDrawDestroy (d);	918	{
673	d = 0;	919	rxvt_fontprop p;
674	}
675		920
676	#if 0	921	FT_Face face = XftLockFace (f);
677	for (int i = 0; i < SWATHCOUNT; i++)	922
678	delete cvr[i];	923	p.width = width; p.height = height;
679	#endif	924	p.weight = face->style_flags & FT_STYLE_FLAG_BOLD ? rxvt_fontprop::bold : rxvt_fontprop::medium;
		925	p.slant = face->style_flags & FT_STYLE_FLAG_ITALIC ? rxvt_fontprop::italic : rxvt_fontprop::roman;
		926
		927	XftUnlockFace (f);
		928
		929	return p;
680	}	930	}
681		931
682	bool	932	bool
683	rxvt_font_xft::load (int maxheight)	933	rxvt_font_xft::load (const rxvt_fontprop &prop)
684	{	934	{
685	#if 0	935	#if 0
686	for (int i = 0; i < SWATHCOUNT; i++)	936	for (int i = 0; i < SWATHCOUNT; i++)
687	cvr[i] = 0;	937	cvr[i] = 0;
688	#endif	938	#endif
689		939
690	clear ();	940	clear ();
691		941
692	f = XftFontOpenName (DISPLAY, DefaultScreen (DISPLAY), name);	942	FcPattern p = FcNameParse ((FcChar8 ) name);
		943
		944	if (!p)
		945	return false;
		946
		947	FcValue v;
		948
		949	if (FcPatternGet (p, FC_WEIGHT, 0, &v) != FcResultMatch)
		950	FcPatternAddInteger (p, FC_WEIGHT, prop.weight);
		951
		952	if (FcPatternGet (p, FC_SLANT, 0, &v) != FcResultMatch)
		953	FcPatternAddInteger (p, FC_SLANT, prop.slant);
		954
		955	#if 0 // clipping unfortunately destroys our precious double-width-characters
		956	// clip width, we can't do better, or can we?
		957	if (FcPatternGet (p, FC_CHAR_WIDTH, 0, &v) != FcResultMatch)
		958	FcPatternAddInteger (p, FC_CHAR_WIDTH, prop.width);
		959	#endif
		960
		961	//FcPatternAddBool (p, FC_MINSPACE, 1);
		962
		963	XftResult result;
		964	FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);
		965
		966	FcPatternDestroy (p);
		967
		968	if (!match)
		969	return false;
		970
		971	f = XftFontOpenPattern (DISPLAY, match);
693		972
694	if (!f)	973	if (!f)
		974	{
		975	FcPatternDestroy (match);
695	return false;	976	return false;
		977	}
696		978
697	FT_Face face = XftLockFace (f);	979	FT_Face face = XftLockFace (f);
698		980
699	prop = !FT_IS_FIXED_WIDTH (face);	981	slow = !FT_IS_FIXED_WIDTH (face);
700		982
701	int ftheight = 0;	983	int ftheight = 0;
702		984
703	for (;;)	985	for (;;)
704	{	986	{
…		…
706	FcChar8 c;	988	FcChar8 c;
707		989
708	c = 'i'; XftTextExtents8 (DISPLAY, f, &c, 1, &g1);	990	c = 'i'; XftTextExtents8 (DISPLAY, f, &c, 1, &g1);
709	c = 'W'; XftTextExtents8 (DISPLAY, f, &c, 1, &g2);	991	c = 'W'; XftTextExtents8 (DISPLAY, f, &c, 1, &g2);
710		992
711	prop = prop \|\| g1.xOff != g2.xOff; // don't simply trust the font	993	if (g1.xOff != g2.xOff) // don't simply trust the font
		994	slow = true;
712		995
713	width = g2.xOff;	996	width = g2.xOff;
714	ascent = (face->size->metrics.ascender + 63) >> 6;	997	ascent = (face->size->metrics.ascender + 63) >> 6;
715	descent = (-face->size->metrics.descender + 63) >> 6;	998	descent = (-face->size->metrics.descender + 63) >> 6;
716	height = ascent + descent;	999	height = ascent + descent;
717		1000
718	if (height <= maxheight \|\| !maxheight)	1001	if (height <= prop.height \|\| !prop.height)
719	break;	1002	break;
720		1003
721	if (ftheight)	1004	if (ftheight)
722	{	1005	{
723	// take smaller steps near the end	1006	// take smaller steps near the end
724	if (height > maxheight + 1) ftheight++;	1007	if (height > prop.height + 1) ftheight++;
725	if (height > maxheight + 2) ftheight++;	1008	if (height > prop.height + 2) ftheight++;
726	if (height > maxheight + 3) ftheight++;	1009	if (height > prop.height + 3) ftheight++;
727		1010
728	FT_Set_Pixel_Sizes (face, 0, ftheight -= height - maxheight);	1011	FT_Set_Pixel_Sizes (face, 0, ftheight -= height - prop.height);
729	}	1012	}
730	else	1013	else
731	FT_Set_Pixel_Sizes (face, 0, ftheight = maxheight);	1014	FT_Set_Pixel_Sizes (face, 0, ftheight = prop.height);
732	}	1015	}
733		1016
734	XftUnlockFace (f);	1017	XftUnlockFace (f);
735		1018
736	return true;	1019	return true;
737	}	1020	}
738		1021
739	#if 0
740	void rxvt_font::gen_coverage_swath (unsigned int page)
741	{
742	cvr[page] = new swath;
743
744	for (int i = 0; i < SWATHSIZE; i++)
745	cvr[page][i] = 0;
746
747	populate_coverage_swath (cvr[page], page << SWATHBITS, ((page + 1) << SWATHBITS) - 1);
748	}
749	#endif
750
751	bool	1022	bool
752	rxvt_font_xft::has_codepoint (uint32_t unicode)	1023	rxvt_font_xft::has_codepoint (unicode_t unicode)
753	{	1024	{
754	return XftCharExists (DISPLAY, f, unicode);	1025	return XftCharExists (DISPLAY, f, unicode);
755	}	1026	}
756		1027
757	void	1028	void
758	rxvt_font_xft::draw (int x, int y,	1029	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
759	const text_t *text, int len,	1030	const text_t *text, int len,
760	int fg, int bg)	1031	int fg, int bg)
761	{	1032	{
762	if (!d)
763	{
764	dR;
765	d = XftDrawCreate (DISPLAY, DRAWABLE, XVISUAL, XCMAP);
766	}
767
768	if (bg >= 0 && bg != Color_bg)
769	XftDrawRect (d, &r->PixColors[bg].c, x, y, r->TermWin.fwidth * len, r->TermWin.fheight);
770	else
771	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);
772		1034
773	if (!prop && width == r->TermWin.fwidth)	1035	if (!slow && width == r->TermWin.fwidth && 0)
774	{	1036	{
775	if (sizeof (text_t) == sizeof (FcChar16))	1037	if (sizeof (text_t) == sizeof (FcChar16))
776	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);
777	else	1039	else
778	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);
…		…
781	{	1043	{
782	while (len)	1044	while (len)
783	{	1045	{
784	if (text != NOCHAR && text != ' ')	1046	if (text != NOCHAR && text != ' ')
785	{	1047	{
		1048	int fwidth = r->TermWin.fwidth;
		1049	if (len >= 2 && text[1] == NOCHAR)
		1050	fwidth *= 2;
		1051
		1052	XGlyphInfo extents;
786	if (sizeof (text_t) == sizeof (FcChar16))	1053	if (sizeof (text_t) == sizeof (FcChar16))
787	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	}
788	else	1059	else
789	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	}
790	}	1066	}
791		1067
792	x += r->TermWin.fwidth;	1068	x += r->TermWin.fwidth;
793	text++;	1069	text++;
794	len--;	1070	len--;
…		…
798	#endif	1074	#endif
799		1075
800	/////////////////////////////////////////////////////////////////////////////	1076	/////////////////////////////////////////////////////////////////////////////
801		1077
802	rxvt_fontset::rxvt_fontset (rxvt_t r)	1078	rxvt_fontset::rxvt_fontset (rxvt_t r)
803	#ifdef EXPLICIT_CONTEXT
804	: r(r)	1079	: r (r)
805	#endif
806	{	1080	{
807	clear ();	1081	clear ();
808	}	1082	}
809		1083
810	rxvt_fontset::~rxvt_fontset ()	1084	rxvt_fontset::~rxvt_fontset ()
…		…
813	}	1087	}
814		1088
815	void	1089	void
816	rxvt_fontset::clear ()	1090	rxvt_fontset::clear ()
817	{	1091	{
818	for (rxvt_font **i = fonts.begin (); i != fonts.end(); i++)	1092	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
819	FONT_UNREF (*i);	1093	FONT_UNREF (*i);
820		1094
821	fonts.clear ();	1095	fonts.clear ();
822	base_id = 0;	1096	base_id = 0;
823	height = 0x7fffffff;	1097	base_prop.height = 0x7fffffff;
		1098	base_prop.weight = rxvt_fontprop::medium;
		1099	base_prop.slant = rxvt_fontprop::roman;
824		1100
825	fallback = fallback_fonts;	1101	fallback = fallback_fonts;
826	}	1102	}
827		1103
828	rxvt_font *	1104	rxvt_font *
…		…
848	f = new rxvt_font_x11;	1124	f = new rxvt_font_x11;
849	}	1125	}
850	else	1126	else
851	f = new rxvt_font_x11;	1127	f = new rxvt_font_x11;
852		1128
		1129	f->fs = this;
853	f->set_term (r);	1130	f->set_term (r);
854	f->set_name (strdup (name));	1131	f->set_name (strdup (name));
855		1132
856	f->cs = cs;	1133	f->cs = cs;
857	f->loaded = false;	1134	f->loaded = false;
…		…
875		1152
876	if (*desc == '[')	1153	if (*desc == '[')
877	{	1154	{
878	fprintf (stderr, "extra font parameters not yet supported, skipping.\n");	1155	fprintf (stderr, "extra font parameters not yet supported, skipping.\n");
879		1156
880	const char *extra = desc++;	1157	//const char *extra = desc++; // not yet used
881		1158
882	desc = strchr (desc, ']');	1159	desc = strchr (desc, ']');
883		1160
884	if (!desc)	1161	if (!desc)
885	{	1162	{
…		…
915	if (fonts[i]->loaded)	1192	if (fonts[i]->loaded)
916	return true;	1193	return true;
917		1194
918	fonts[i]->loaded = true;	1195	fonts[i]->loaded = true;
919		1196
920	if (!fonts[i]->load (height))	1197	if (!fonts[i]->load (base_prop))
921	{	1198	{
922	fonts[i]->cs = CS_UNKNOWN;	1199	fonts[i]->cs = CS_UNKNOWN;
923	return false;	1200	return false;
924	}	1201	}
925		1202
926	return true;	1203	return true;
927	}	1204	}
928		1205
929	void	1206	bool
930	rxvt_fontset::populate (const char *desc)	1207	rxvt_fontset::populate (const char *desc)
931	{	1208	{
932	clear ();	1209	clear ();
933		1210
934	fonts.push_back (new_font (0, CS_UNICODE));	1211	fonts.push_back (new_font (0, CS_UNICODE));
…		…
938		1215
939	if (!base_id)	1216	if (!base_id)
940	base_id = 1;	1217	base_id = 1;
941		1218
942	// we currently need a base-font, no matter what	1219	// we currently need a base-font, no matter what
943	if (fonts.size () <= base_id)	1220	if ((int)fonts.size () <= base_id \|\| !realize_font (base_id))
944	{	1221	{
		1222	puts ("unable to load specified font (s), falling back to 'fixed'\n");
945	add_fonts ("fixed");	1223	add_fonts ("fixed");
946	base_id = 1;	1224	base_id = fonts.size () - 1;
947	}	1225	}
948		1226
949	if (fonts.size () <= base_id \|\| !realize_font (base_id))	1227	if ((int)fonts.size () <= base_id \|\| !realize_font (base_id))
950	{	1228	return false;
951	fprintf (stderr, "unable to load a base font, please provide one using -fn fontname\n");
952	exit (1);
953	}
954		1229
955	height = fonts[base_id]->height;	1230	base_prop = fonts[base_id]->properties ();
956		1231
957	/add_fonts ("-efont-fixed-medium-r-normal--14------iso10646-1,"/	1232	return true;
958	}	1233	}
959		1234
960	int	1235	int
961	rxvt_fontset::find_font (uint32_t unicode)	1236	rxvt_fontset::find_font (unicode_t unicode)
962	{	1237	{
963	for (int i = 0; i < fonts.size (); i++)	1238	for (unsigned int i = 0; i < fonts.size (); i++)
964	{	1239	{
965	rxvt_font *f = fonts[i];	1240	rxvt_font *f = fonts[i];
966		1241
967	if (!f->loaded)	1242	if (!f->loaded)
968	{	1243	{

Diff Legend

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

Comparing rxvt-unicode/src/defaultfont.C (file contents): Revision 1.6 by pcg, Wed Dec 17 22:29:03 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.6 by pcg, Wed Dec 17 22:29:03 2003 UTC vs.
Revision 1.43 by pcg, Mon Mar 15 07:10:47 2004 UTC