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

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.56 by root, Fri Dec 10 19:55:55 2004 UTC vs.
Revision 1.85 by root, Wed Jan 25 00:42:21 2006 UTC

…		…
1	/---------------------------------C----------------------------------	1	/---------------------------------C----------------------------------
2	* File: defaultfont.C	2	* File: rxvtfont.C
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>	4	* Copyright (c) 2003-2006 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
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.	15	* GNU General Public License for more details.
16	*	16	*
17	* You should have received a copy of the GNU General Public License	17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software	18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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"
24	#include "rxvtutil.h"	25	#include "rxvtutil.h"
25	#include "rxvtfont.h"	26	#include "rxvtfont.h"
26		27
27	#include <cstdlib>	28	#include <cstdlib>
28	#include <wchar.h>	29	#include <wchar.h>
29	#include <inttypes.h>	30	#include <inttypes.h>
30
31	#define DISPLAY r->display->display
32	#define TGC r->TermWin.gc
33		31
34	#define MAX_OVERLAP (4 + 1) // max. character width in 4ths of the base width	32	#define MAX_OVERLAP (4 + 1) // max. character width in 4ths of the base width
35		33
36	const struct rxvt_fallback_font {	34	const struct rxvt_fallback_font {
37	codeset cs;	35	codeset cs;
…		…
130	{ CS_UNICODE, "--lucidatypewriter---------m--iso10646-1" },	128	{ CS_UNICODE, "--lucidatypewriter---------m--iso10646-1" },
131	{ CS_UNICODE, "--unifont---------c--iso10646-1" },	129	{ CS_UNICODE, "--unifont---------c--iso10646-1" },
132	{ CS_UNICODE, "----r-------c--iso10646-1" },	130	{ CS_UNICODE, "----r-------c--iso10646-1" },
133	{ CS_UNICODE, "----r-------m--iso10646-1" },	131	{ CS_UNICODE, "----r-------m--iso10646-1" },
134	#if XFT	132	#if XFT
135	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true"},	133	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },
136	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },	134	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },
137	{ CS_UNICODE, "xft:Andale Mono:antialias=false" },	135	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },
138	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false" },	136	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false:autohint=false" },
139		137
140	// FreeMono is usually uglier than x fonts, so try last only.	138	// FreeMono is usually uglier than x fonts, so try last only.
141	{ CS_UNICODE, "xft:FreeMono:autohint=true" },	139	{ CS_UNICODE, "xft:FreeMono:autohint=true" },
142	#endif	140	#endif
143		141
144	{ CS_UNKNOWN, 0 }	142	{ CS_UNKNOWN, 0 }
145	};	143	};
146		144
147	// these characters are used to guess the font height and width	145	// these characters are used to guess the font height and width
148	// pango uses a similar algorithm and eosn't trust the font either.	146	// pango uses a similar algorithm and doesn't trust the font either.
149	static uint16_t extent_test_chars[] = {	147	static uint16_t extent_test_chars[] = {
150	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',	148	'0', '1', '8', 'a', 'd', 'x', 'm', 'y', 'g', 'W', 'X', '\'', '_',
151	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ	149	0x00cd, 0x00d5, 0x0114, 0x0177, 0x0643, // ÍÕĔŷﻙ
152	0x304c, 0x672c, // が本	150	0x304c, 0x672c, // が本
153	};	151	};
154		152
155	#define NUM_EXTENT_TEST_CHARS (sizeof (extent_test_chars) / sizeof (extent_test_chars[0]))	153	#define NUM_EXTENT_TEST_CHARS (sizeof (extent_test_chars) / sizeof (extent_test_chars[0]))
156		154
		155	#define dTermDisplay Display *disp = term->display->display
		156	#define dTermGC GC gc = term->gc
		157
157	/////////////////////////////////////////////////////////////////////////////	158	/////////////////////////////////////////////////////////////////////////////
158		159
159	#if XFT	160	#if XFT
160	rxvt_drawable::~rxvt_drawable ()	161	rxvt_drawable::~rxvt_drawable ()
161	{	162	{
…		…
172	}	173	}
173	#endif	174	#endif
174		175
175	/////////////////////////////////////////////////////////////////////////////	176	/////////////////////////////////////////////////////////////////////////////
176		177
177	static void *enc_buf;
178	static uint32_t enc_len;
179
180	static inline void *
181	get_enc_buf (uint32_t len)
182	{
183	if (len > enc_len)
184	{
185	free (enc_buf);
186	enc_buf = malloc (len);
187	enc_len = len;
188	}
189
190	return enc_buf;
191	}
192
193	static const char *	178	static const char *
194	enc_char (const text_t *text, uint32_t len, codeset cs, bool &zero)	179	enc_char (const text_t *text, uint32_t len, codeset cs, bool &zero)
195	{	180	{
196	uint8_t buf = (uint8_t )get_enc_buf (len);	181	uint8_t *buf = rxvt_temp_buf<uint8_t> (len);
		182	uint8_t *res = buf;
197		183
198	while (len--)	184	while (len--)
199	{	185	{
200	uint32_t c = FROM_UNICODE (cs, *text++);	186	uint32_t c = FROM_UNICODE (cs, *text++);
201		187
…		…
206	}	192	}
207		193
208	*buf++ = c;	194	*buf++ = c;
209	}	195	}
210		196
211	return (const char *)enc_buf;	197	return (const char *)res;
212	}	198	}
213		199
214	static const XChar2b *	200	static const XChar2b *
215	enc_xchar2b (const text_t *text, uint32_t len, codeset cs, bool &zero)	201	enc_xchar2b (const text_t *text, uint32_t len, codeset cs, bool &zero)
216	{	202	{
217	XChar2b buf = (XChar2b )get_enc_buf (len * sizeof (XChar2b));	203	XChar2b *buf = rxvt_temp_buf<XChar2b> (len);
		204	XChar2b *res = buf;
218		205
219	while (len--)	206	while (len--)
220	{	207	{
221	uint32_t c = FROM_UNICODE (cs, *text++);	208	uint32_t c = FROM_UNICODE (cs, *text++);
222		209
…		…
229	buf->byte1 = c >> 8;	216	buf->byte1 = c >> 8;
230	buf->byte2 = c;	217	buf->byte2 = c;
231	buf++;	218	buf++;
232	}	219	}
233		220
234	return (XChar2b *)enc_buf;	221	return res;
235	}	222	}
236		223
237	/////////////////////////////////////////////////////////////////////////////	224	/////////////////////////////////////////////////////////////////////////////
238		225
239	void	226	void
…		…
245	if (this->name) free (this->name); // let the compiler optimize	232	if (this->name) free (this->name); // let the compiler optimize
246	this->name = name;	233	this->name = name;
247	}	234	}
248		235
249	void	236	void
250	rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color)	237	rxvt_font::clear_rect (rxvt_drawable &d, int x, int y, int w, int h, int color) const
251	{	238	{
		239	dTermDisplay;
		240	dTermGC;
		241
252	if (color == Color_bg)	242	if (color == Color_bg)
253	XClearArea (d.display->display, d, x, y, w, h, FALSE);	243	XClearArea (disp, d, x, y, w, h, FALSE);
254	else if (color >= 0)	244	else if (color >= 0)
255	{	245	{
256	#if XFT	246	#if XFT
257	XftDrawRect (d, &r->pix_colors[color].c, x, y, w, h);	247	XftDrawRect (d, &term->pix_colors[color].c, x, y, w, h);
258	#else	248	#else
259	XSetForeground (d.display->display, TGC, r->pix_colors[color]);	249	XSetForeground (disp, gc, term->pix_colors[color]);
260	XFillRectangle (d.display->display, d, TGC, x, y, w, h);	250	XFillRectangle (disp, d, gc, x, y, w, h);
261	#endif	251	#endif
262	}	252	}
263	}	253	}
264		254
265	#include "table/linedraw.h"	255	#include "table/linedraw.h"
…		…
276	rxvt_fontprop properties ()	266	rxvt_fontprop properties ()
277	{	267	{
278	rxvt_fontprop p;	268	rxvt_fontprop p;
279		269
280	p.width = p.height = 1;	270	p.width = p.height = 1;
		271	p.ascent = rxvt_fontprop::unset;
281	p.weight = rxvt_fontprop::medium;	272	p.weight = rxvt_fontprop::medium;
282	p.slant = rxvt_fontprop::roman;	273	p.slant = rxvt_fontprop::roman;
283		274
284	return p;	275	return p;
285	}	276	}
…		…
292	set_name (strdup ("built-in support font"));	283	set_name (strdup ("built-in support font"));
293		284
294	return true;	285	return true;
295	}	286	}
296		287
297	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful)	288	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
298	{	289	{
299	careful = false;	290	careful = false;
300		291
301	if (unicode <= 0x001f)	292	if (unicode <= 0x001f)
302	return true;	293	return true;
…		…
305	return false;	296	return false;
306		297
307	if (unicode <= 0x009f)	298	if (unicode <= 0x009f)
308	return true;	299	return true;
309		300
310	if (unicode >= 0x2500 && unicode <= 0x259f)	301	if (unicode >= 0x2500 && unicode <= 0x259f &&
		302	!term->option (Opt_skipBuiltinGlyphs))
311	return true;	303	return true;
312		304
313	if (IS_COMPOSE (unicode))	305	if (IS_COMPOSE (unicode))
314	return true;	306	return true;
315		307
…		…
331	void	323	void
332	rxvt_font_default::draw (rxvt_drawable &d, int x, int y,	324	rxvt_font_default::draw (rxvt_drawable &d, int x, int y,
333	const text_t *text, int len,	325	const text_t *text, int len,
334	int fg, int bg)	326	int fg, int bg)
335	{	327	{
		328	dTermDisplay;
		329	dTermGC;
		330
336	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	331	clear_rect (d, x, y, term->fwidth * len, term->fheight, bg);
337		332
338	XSetForeground (d.display->display, TGC, r->pix_colors[fg]);	333	XSetForeground (disp, gc, term->pix_colors[fg]);
339		334
340	while (len)	335	while (len)
341	{	336	{
342	#if ENABLE_COMBINING	337	#if ENABLE_COMBINING
343	compose_char *cc;	338	compose_char *cc;
…		…
347		342
348	while (++text, --len && *text == NOCHAR)	343	while (++text, --len && *text == NOCHAR)
349	;	344	;
350		345
351	int width = text - tp;	346	int width = text - tp;
352	int fwidth = r->TermWin.fwidth * width;	347	int fwidth = term->fwidth * width;
353		348
354	if (0x2500 <= t && t <= 0x259f)	349	if (0x2500 <= t && t <= 0x259f)
355	{	350	{
356	uint16_t offs = linedraw_offs[t - 0x2500];	351	uint16_t offs = linedraw_offs[t - 0x2500];
357	uint32_t *a = linedraw_command + (offs >> 4);	352	uint32_t *a = linedraw_command + (offs >> 4);
358	uint32_t *b = a + (offs & 15);	353	uint32_t *b = a + (offs & 15);
359		354
360	int W = fwidth;	355	int W = fwidth;
361	int H = r->TermWin.fheight;	356	int H = term->fheight;
362		357
363	int x_[16];	358	int x_[16];
364	int y_[16];	359	int y_[16];
365		360
366	for (int i = 0; i <= 8; i++)	361	for (int i = 0; i <= 8; i++)
…		…
374		369
375	XGCValues gcv;	370	XGCValues gcv;
376		371
377	gcv.cap_style = CapButt;	372	gcv.cap_style = CapButt;
378	gcv.line_width = 0;	373	gcv.line_width = 0;
379	XChangeGC (d.display->display, TGC, GCLineWidth \| GCCapStyle, &gcv);	374	XChangeGC (disp, gc, GCLineWidth \| GCCapStyle, &gcv);
380		375
381	while (a < b)	376	while (a < b)
382	{	377	{
383	uint32_t command = *a++;	378	uint32_t command = *a++;
384		379
…		…
391	int y2 = y_[(command >> 0) & 15];	386	int y2 = y_[(command >> 0) & 15];
392		387
393	switch (op)	388	switch (op)
394	{	389	{
395	case 0: // line	390	case 0: // line
396	XDrawLine (d.display->display, d, TGC, x1, y1, x2, y2);	391	XDrawLine (disp, d, gc, x1, y1, x2, y2);
397	break;	392	break;
398		393
399	case 1: // rectangle, possibly stippled	394	case 1: // rectangle, possibly stippled
400	if (a)	395	if (a)
401	{	396	{
402	static char bm[] = { 0,0 , 3,1 , 1,2 , 1,0 };	397	static char bm[] = { 0,0 , 3,1 , 1,2 , 1,0 };
403		398
404	gcv.fill_style = FillStippled;	399	gcv.fill_style = FillStippled;
405	gcv.stipple = XCreateBitmapFromData (d.display->display, d, bm + a * 2, 2, 2);	400	gcv.stipple = XCreateBitmapFromData (disp, d, bm + a * 2, 2, 2);
406	gcv.ts_x_origin = x;	401	gcv.ts_x_origin = x;
407	gcv.ts_y_origin = y;	402	gcv.ts_y_origin = y;
408		403
409	XChangeGC (d.display->display, TGC,	404	XChangeGC (disp, gc,
410	GCFillStyle \| GCStipple \| GCTileStipXOrigin \| GCTileStipYOrigin,	405	GCFillStyle \| GCStipple \| GCTileStipXOrigin \| GCTileStipYOrigin,
411	&gcv);	406	&gcv);
412	}	407	}
413		408
414	XFillRectangle (d.display->display, d, TGC, x1, y1, x2 - x1 + 1, y2 - y1 + 1);	409	XFillRectangle (disp, d, gc, x1, y1, x2 - x1 + 1, y2 - y1 + 1);
415		410
416	if (a)	411	if (a)
417	{	412	{
418	XFreePixmap (d.display->display, gcv.stipple);	413	XFreePixmap (disp, gcv.stipple);
419	gcv.stipple = 0;	414	gcv.stipple = 0;
420	gcv.fill_style = FillSolid;	415	gcv.fill_style = FillSolid;
421	XChangeGC (d.display->display, TGC, GCFillStyle, &gcv);	416	XChangeGC (disp, gc, GCFillStyle, &gcv);
422	}	417	}
423	break;	418	break;
424	case 2: // arc	419	case 2: // arc
425	XDrawArc (d.display->display, d, TGC,	420	XDrawArc (disp, d, gc,
426	x1 - W/2, y1 - H/2, W-1, H-1,	421	x1 - W/2, y1 - H/2, W-1, H-1,
427	(a - 1) * 9064, (b - 1) 90*64);	422	(a - 1) * 9064, (b - 1) 90*64);
428	break;	423	break;
429	}	424	}
430	}	425	}
…		…
461	case ZERO_WIDTH_CHAR:	456	case ZERO_WIDTH_CHAR:
462	case NOCHAR:	457	case NOCHAR:
463	break;	458	break;
464		459
465	default:	460	default:
466	XDrawRectangle (d.display->display, d, TGC, x + 2, y + 2,	461	XDrawRectangle (disp, d, gc, x + 2, y + 2,
467	fwidth - 4, r->TermWin.fheight - 4);	462	fwidth - 4, term->fheight - 4);
468	}	463	}
469		464
470	x += fwidth;	465	x += fwidth;
471	}	466	}
472	}	467	}
…		…
480		475
481	rxvt_fontprop properties ();	476	rxvt_fontprop properties ();
482		477
483	bool load (const rxvt_fontprop &prop);	478	bool load (const rxvt_fontprop &prop);
484		479
485	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful);	480	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const;
486		481
487	void draw (rxvt_drawable &d, int x, int y,	482	void draw (rxvt_drawable &d, int x, int y,
488	const text_t *text, int len,	483	const text_t *text, int len,
489	int fg, int bg);	484	int fg, int bg);
490		485
…		…
502	char *	497	char *
503	rxvt_font_x11::get_property (XFontStruct f, const char property, const char *repl) const	498	rxvt_font_x11::get_property (XFontStruct f, const char property, const char *repl) const
504	{	499	{
505	unsigned long value;	500	unsigned long value;
506		501
507	if (XGetFontProperty (f, XInternAtom (DISPLAY, property, 0), &value))	502	if (XGetFontProperty (f, XInternAtom (term->display->display, property, 0), &value))
508	return XGetAtomName (DISPLAY, value);	503	return XGetAtomName (term->display->display, value);
509	else	504	else
510	return rxvt_strdup (repl);	505	return rxvt_strdup (repl);
511	}	506	}
512		507
513	rxvt_fontprop	508	rxvt_fontprop
…		…
521	bool	516	bool
522	rxvt_font_x11::set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth)	517	rxvt_font_x11::set_properties (rxvt_fontprop &p, int height, const char weight, const char slant, int avgwidth)
523	{	518	{
524	p.width = avgwidth ? (avgwidth + 1) / 10 : (height + 1) / 2;	519	p.width = avgwidth ? (avgwidth + 1) / 10 : (height + 1) / 2;
525	p.height = height;	520	p.height = height;
		521	p.ascent = rxvt_fontprop::unset;
526	p.weight = weight == 'B' \|\| weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;	522	p.weight = weight == 'B' \|\| weight == 'b' ? rxvt_fontprop::bold : rxvt_fontprop::medium;
527	p.slant = slant == 'r' \|\| slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;	523	p.slant = slant == 'r' \|\| slant == 'R' ? rxvt_fontprop::roman : rxvt_fontprop::italic;
528		524
529	return true;	525	return true;
530	}	526	}
531		527
532	bool	528	bool
533	rxvt_font_x11::set_properties (rxvt_fontprop &p, XFontStruct *f)	529	rxvt_font_x11::set_properties (rxvt_fontprop &p, XFontStruct *f)
534	{	530	{
535	unsigned long height;	531	unsigned long height;
		532
		533	#if 0
536	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "PIXEL_SIZE", 0), &height))	534	if (!XGetFontProperty (f, XInternAtom (term->display->display, "PIXEL_SIZE", 0), &height))
537	return false;	535	return false;
		536	#else
		537	height = f->ascent + f->descent;
		538	#endif
538		539
539	unsigned long avgwidth;	540	unsigned long avgwidth;
540	if (!XGetFontProperty (f, XInternAtom (DISPLAY, "AVERAGE_WIDTH", 0), &avgwidth))	541	if (!XGetFontProperty (f, XInternAtom (term->display->display, "AVERAGE_WIDTH", 0), &avgwidth))
541	avgwidth = 0;	542	avgwidth = 0;
542		543
543	char *weight = get_property (f, "WEIGHT_NAME", "medium");	544	char *weight = get_property (f, "WEIGHT_NAME", "medium");
544	char *slant = get_property (f, "SLANT", "r");	545	char *slant = get_property (f, "SLANT", "r");
545		546
546	set_properties (p, height, weight, slant, avgwidth);	547	set_properties (p, height, weight, slant, avgwidth);
547		548
548	free (weight);	549	free (weight);
549	free (slant);	550	free (slant);
550		551
		552	p.ascent = f->ascent;
		553
551	return true;	554	return true;
552	}	555	}
553		556
554	bool	557	bool
555	rxvt_font_x11::set_properties (rxvt_fontprop &p, const char *name)	558	rxvt_font_x11::set_properties (rxvt_fontprop &p, const char *name)
556	{	559	{
		560	dTermDisplay;
557	int slashes = 0;	561	int slashes = 0;
558	const char *comp[13];	562	const char *comp[13];
559		563
560	for (const char c = name; c; c++)	564	for (const char c = name; c; c++)
561	if (*c == '-')	565	if (*c == '-')
…		…
569	if (slashes >= 13	573	if (slashes >= 13
570	&& (comp[ 6] >= '1' && comp[ 6] <= '9')	574	&& (comp[ 6] >= '1' && comp[ 6] <= '9')
571	&& (comp[11] >= '0' && comp[11] <= '9'))	575	&& (comp[11] >= '0' && comp[11] <= '9'))
572	return set_properties (p, atoi (comp[6]), comp[2], comp[3], atoi (comp[11]));	576	return set_properties (p, atoi (comp[6]), comp[2], comp[3], atoi (comp[11]));
573		577
574	XFontStruct *f = XLoadQueryFont (DISPLAY, name);	578	XFontStruct *f = XLoadQueryFont (disp, name);
575		579
576	if (f)	580	if (f)
577	{	581	{
578	// the font should really exist now. if not, we have a problem	582	// 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).	583	// (e.g. if the user did xset fp rehash just when we were searching fonts).
580	// in that case, just return garbage.	584	// in that case, just return garbage.
581	bool ret = set_properties (p, f);	585	bool ret = set_properties (p, f);
582	XFreeFont (DISPLAY, f);	586	XFreeFont (disp, f);
583	return ret;	587	return ret;
584	}	588	}
585	else	589	else
586	return false;	590	return false;
587	}	591	}
…		…
625	}	629	}
626		630
627	bool	631	bool
628	rxvt_font_x11::load (const rxvt_fontprop &prop)	632	rxvt_font_x11::load (const rxvt_fontprop &prop)
629	{	633	{
		634	dTermDisplay;
		635
630	clear ();	636	clear ();
631		637
632	char field_str[64]; // enough for 128 bits	638	char field_str[64]; // enough for 128 bits
633		639
634	// first morph the font if required	640	// first morph the font if required
…		…
637	{	643	{
638	char fname[1024];	644	char fname[1024];
639		645
640	if (name[0] != '-')	646	if (name[0] != '-')
641	{	647	{
642	f = XLoadQueryFont (DISPLAY, name);	648	f = XLoadQueryFont (disp, name);
643		649
644	if (!f)	650	if (!f)
645	return false;	651	return false;
646		652
647	char *new_name = get_property (f, "FONT", name);	653	char *new_name = get_property (f, "FONT", name);
…		…
649	if (new_name)	655	if (new_name)
650	set_name (new_name);	656	set_name (new_name);
651	else	657	else
652	rxvt_warn ("font '%s' has no FONT property, continuing without.", name);	658	rxvt_warn ("font '%s' has no FONT property, continuing without.", name);
653		659
654	XFreeFont (DISPLAY, f);	660	XFreeFont (disp, f);
655	f = 0;	661	f = 0;
656	}	662	}
657		663
658	if (prop.weight != rxvt_fontprop::unset)	664	if (prop.weight != rxvt_fontprop::unset)
659	{	665	{
…		…
670	? "r" : "i"); // TODO: handle "o"blique, too	676	? "r" : "i"); // TODO: handle "o"blique, too
671	set_name (strdup (fname));	677	set_name (strdup (fname));
672	}	678	}
673	}	679	}
674		680
		681	sprintf (field_str, "%d", prop.height == rxvt_fontprop::unset
		682	? 0 : prop.height);
		683
		684	struct font_weight {
		685	char *name;
		686	int diff;
		687
		688	void clear ()
		689	{
		690	name = 0;
		691	diff = 0x7fffffff;
		692	}
		693
		694	font_weight () { clear (); }
		695	~font_weight () { free (name); }
		696	};
		697
675	char **list;	698	char **list;
676	int count;	699	int count;
677	list = XListFonts (DISPLAY, name, 1024, &count);	700	list = XListFonts (disp, name, 4000, &count);
678		701
679	set_name (0);	702	set_name (0);
680		703
681	if (!list)	704	if (!list)
682	return false;	705	return false;
683		706
684	sprintf (field_str, "%d", prop.height == rxvt_fontprop::unset	707	font_weight *fonts = new font_weight[count];
685	? 0 : prop.height);
686		708
687	int bestdiff = 0x7fffffff;
688	for (int i = 0; i < count; i++)	709	for (int i = 0; i < count; i++)
689	{	710	{
690	rxvt_fontprop p;	711	rxvt_fontprop p;
691	char fname[1024];	712	char fname[1024];
692		713
693	int diff = 0;	714	int diff = 0;
694		715
695	if (replace_field (fname, list[i], 6, '0', field_str))	716	if (replace_field (fname, list[i], 6, '0', field_str))
696	diff += 10; // slightly penalize scalable fonts	717	diff += 10; // slightly penalize scalable fonts
		718	else if (replace_field (fname, list[i], 11, '0', "0"))
		719	diff += 300; // more heavily penalize what looks like scaled bitmap fonts
697		720
698	if (!set_properties (p, fname))	721	if (!set_properties (p, fname))
699	continue;	722	continue;
700		723
701	if (prop.height != rxvt_fontprop::unset	724	if (prop.height != rxvt_fontprop::unset
…		…
705	if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;	728	if (prop.height != rxvt_fontprop::unset) diff += (prop.height - p.height) * 128;
706	if (prop.weight != rxvt_fontprop::unset) diff += abs (prop.weight - p.weight);	729	if (prop.weight != rxvt_fontprop::unset) diff += abs (prop.weight - p.weight);
707	if (prop.slant != rxvt_fontprop::unset) diff += abs (prop.slant - p.slant);	730	if (prop.slant != rxvt_fontprop::unset) diff += abs (prop.slant - p.slant);
708	//if (prop.width != rxvt_fontprop::unset) diff += abs (prop.width - p.width);	731	//if (prop.width != rxvt_fontprop::unset) diff += abs (prop.width - p.width);
709		732
710	if (!name // compare against best found so far	733	fonts[i].name = strdup (fname);
711	\|\| diff < bestdiff)	734	fonts[i].diff = diff;
712	{
713	set_name (strdup (fname));
714	bestdiff = diff;
715	}
716	}	735	}
717		736
718	XFreeFontNames (list);	737	XFreeFontNames (list);
719		738
720	if (!name)	739	// this loop only iterates when the guessed font-size is too small
721	return false;	740	for (;;)
		741	{
		742	font_weight *best = fonts + count - 1;
722		743
723	f = XLoadQueryFont (DISPLAY, name);	744	for (font_weight *w = best; w-- > fonts; )
		745	if (w->diff <= best->diff)
		746	best = w;
		747
		748	if (!best->name
		749	\|\| !(f = XLoadQueryFont (disp, best->name)))
		750	break;
		751
		752	set_name (best->name);
		753	best->clear ();
		754
		755	ascent = f->ascent;
		756	descent = f->descent;
		757	height = ascent + descent;
		758
		759	if (prop.height == rxvt_fontprop::unset
		760	\|\| height <= prop.height)
		761	break; // font is ready for use
		762
		763	// PIXEL_SIZE small enough, but real height too large
		764	clear ();
		765	}
		766
		767	delete [] fonts;
724		768
725	if (!f)	769	if (!f)
726	return false;	770	return false;
727		771
728	char *registry = get_property (f, "CHARSET_REGISTRY", 0);	772	char *registry = get_property (f, "CHARSET_REGISTRY", 0);
…		…
756	if (cs == CS_UNICODE)	800	if (cs == CS_UNICODE)
757	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font	801	cs = CS_UNICODE_16; // X11 can have a max. of 65536 chars per font
758		802
759	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;	803	encm = f->min_byte1 != 0 \|\| f->max_byte1 != 0;
760	enc2b = encm \|\| f->max_char_or_byte2 > 255;	804	enc2b = encm \|\| f->max_char_or_byte2 > 255;
761
762	ascent = f->ascent;
763	descent = f->descent;
764	height = ascent + descent;
765		805
766	slow = false;	806	slow = false;
767		807
768	#if 1 // only used for slow detection, TODO optimize	808	#if 1 // only used for slow detection, TODO optimize
769	if (f->min_bounds.width == f->max_bounds.width)	809	if (f->min_bounds.width == f->max_bounds.width)
…		…
808		848
809	XCharStruct g;	849	XCharStruct g;
810	int dir_ret, asc_ret, des_ret;	850	int dir_ret, asc_ret, des_ret;
811	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);	851	XTextExtents16 (f, &ch, 1, &dir_ret, &asc_ret, &des_ret, &g);
812		852
813	int wcw = wcwidth (*t); if (wcw > 0) g.width = g.width / wcw;	853	int wcw = wcwidth (*t); if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;
814		854
815	if (width < g.width) width = g.width;	855	if (width < g.width) width = g.width;
816	}	856	}
817		857
818	if (cs == CS_UNKNOWN)	858	if (cs == CS_UNKNOWN)
…		…
837	void	877	void
838	rxvt_font_x11::clear ()	878	rxvt_font_x11::clear ()
839	{	879	{
840	if (f)	880	if (f)
841	{	881	{
842	XFreeFont (DISPLAY, f);	882	XFreeFont (term->display->display, f);
843	f = 0;	883	f = 0;
844	}	884	}
845	}	885	}
846		886
847	bool	887	bool
848	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful)	888	rxvt_font_x11::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
849	{	889	{
850	uint32_t ch = FROM_UNICODE (cs, unicode);	890	uint32_t ch = FROM_UNICODE (cs, unicode);
851		891
852	if (ch == NOCHAR)	892	if (ch == NOCHAR)
853	return false;	893	return false;
…		…
893	return true;	933	return true;
894		934
895	// check character against base font bounding box	935	// check character against base font bounding box
896	int w = xcs->width;	936	int w = xcs->width;
897	int wcw = wcwidth (unicode);	937	int wcw = wcwidth (unicode);
898	if (wcw > 0) w /= wcw;	938	if (wcw > 0) w = (w + wcw - 1) / wcw;
899		939
900	careful = w > prop->width;	940	careful = w > prop->width;
901	if (careful && w > prop->width * MAX_OVERLAP >> 2)	941	if (careful && w > prop->width * MAX_OVERLAP >> 2)
902	return false;	942	return false;
903		943
…		…
912	// this looks like a mess /.	952	// this looks like a mess /.
913	// and it is a mess /.	953	// and it is a mess /.
914	// yet we are trying to be perfect /.	954	// yet we are trying to be perfect /.
915	// but the result still isn't perfect /.	955	// but the result still isn't perfect /.
916		956
		957	dTermDisplay;
		958	dTermGC;
		959
917	bool slow = this->slow	960	bool slow = this->slow
918	\|\| width != r->TermWin.fwidth	961	\|\| width != term->fwidth
919	\|\| height != r->TermWin.fheight;	962	\|\| height != term->fheight;
920		963
921	int base = ascent; // sorry, incorrect: r->TermWin.fbase;	964	int base = ascent; // sorry, incorrect: term->fbase;
922		965
923	XGCValues v;	966	XGCValues v;
924	v.foreground = r->pix_colors[fg];	967	v.foreground = term->pix_colors[fg];
925	v.font = f->fid;	968	v.font = f->fid;
926		969
927	if (enc2b)	970	if (enc2b)
928	{	971	{
929	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);	972	const XChar2b *xc = enc_xchar2b (text, len, cs, slow);
930		973
931	if (bg == Color_bg && !slow)	974	if (bg == Color_bg && !slow)
932	{	975	{
933	v.background = r->pix_colors[bg];	976	v.background = term->pix_colors[bg];
934	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);	977	XChangeGC (disp, gc, GCForeground \| GCBackground \| GCFont, &v);
935	XDrawImageString16 (d.display->display, d, TGC, x, y + base, xc, len);	978	XDrawImageString16 (disp, d, gc, x, y + base, xc, len);
936	}	979	}
937	else	980	else
938	{	981	{
939	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	982	clear_rect (d, x, y, term->fwidth * len, term->fheight, bg);
940		983
941	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);	984	XChangeGC (disp, gc, GCForeground \| GCFont, &v);
942		985
943	if (slow)	986	if (slow)
944	{	987	{
945	do	988	do
946	{	989	{
947	if (xc->byte1 \|\| xc->byte2)	990	if (xc->byte1 \|\| xc->byte2)
948	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, 1);	991	XDrawString16 (disp, d, gc, x, y + base, xc, 1);
949		992
950	x += r->TermWin.fwidth;	993	x += term->fwidth;
951	xc++; len--;	994	xc++; len--;
952	}	995	}
953	while (len);	996	while (len);
954	}	997	}
955	else	998	else
956	XDrawString16 (d.display->display, d, TGC, x, y + base, xc, len);	999	XDrawString16 (disp, d, gc, x, y + base, xc, len);
957	}	1000	}
958	}	1001	}
959	else	1002	else
960	{	1003	{
961	const char *xc = enc_char (text, len, cs, slow);	1004	const char *xc = enc_char (text, len, cs, slow);
962		1005
963	if (bg == Color_bg && !slow)	1006	if (bg == Color_bg && !slow)
964	{	1007	{
965	v.background = r->pix_colors[bg];	1008	v.background = term->pix_colors[bg];
966	XChangeGC (d.display->display, TGC, GCForeground \| GCBackground \| GCFont, &v);	1009	XChangeGC (disp, gc, GCForeground \| GCBackground \| GCFont, &v);
967	XDrawImageString (d.display->display, d, TGC, x, y + base, xc, len);	1010	XDrawImageString (disp, d, gc, x, y + base, xc, len);
968	}	1011	}
969	else	1012	else
970	{	1013	{
971	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	1014	clear_rect (d, x, y, term->fwidth * len, term->fheight, bg);
972		1015
973	XChangeGC (d.display->display, TGC, GCForeground \| GCFont, &v);	1016	XChangeGC (disp, gc, GCForeground \| GCFont, &v);
974		1017
975	if (slow)	1018	if (slow)
976	{	1019	{
977	do	1020	do
978	{	1021	{
979	if (*xc)	1022	if (*xc)
980	XDrawString (d.display->display, d, TGC, x, y + base, xc, 1);	1023	XDrawString (disp, d, gc, x, y + base, xc, 1);
981		1024
982	x += r->TermWin.fwidth;	1025	x += term->fwidth;
983	xc++; len--;	1026	xc++; len--;
984	}	1027	}
985	while (len);	1028	while (len);
986	}	1029	}
987	else	1030	else
988	XDrawString (d.display->display, d, TGC, x, y + base, xc, len);	1031	XDrawString (disp, d, gc, x, y + base, xc, len);
989	}	1032	}
990	}	1033	}
991	}	1034	}
992		1035
993	/////////////////////////////////////////////////////////////////////////////	1036	/////////////////////////////////////////////////////////////////////////////
…		…
1005		1048
1006	void draw (rxvt_drawable &d, int x, int y,	1049	void draw (rxvt_drawable &d, int x, int y,
1007	const text_t *text, int len,	1050	const text_t *text, int len,
1008	int fg, int bg);	1051	int fg, int bg);
1009		1052
1010	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &carefull);	1053	bool has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &carefull) const;
1011		1054
1012	protected:	1055	protected:
1013	XftFont *f;	1056	XftFont *f;
1014	};	1057	};
1015		1058
1016	void	1059	void
1017	rxvt_font_xft::clear ()	1060	rxvt_font_xft::clear ()
1018	{	1061	{
1019	if (f)	1062	if (f)
1020	{	1063	{
1021	XftFontClose (DISPLAY, f);	1064	XftFontClose (term->display->display, f);
1022	f = 0;	1065	f = 0;
1023	}	1066	}
1024	}	1067	}
1025		1068
1026	rxvt_fontprop	1069	rxvt_fontprop
…		…
1030		1073
1031	FT_Face face = XftLockFace (f);	1074	FT_Face face = XftLockFace (f);
1032		1075
1033	p.width = width;	1076	p.width = width;
1034	p.height = height;	1077	p.height = height;
		1078	p.ascent = ascent;
1035	p.weight = face->style_flags & FT_STYLE_FLAG_BOLD	1079	p.weight = face->style_flags & FT_STYLE_FLAG_BOLD
1036	? rxvt_fontprop::bold : rxvt_fontprop::medium;	1080	? rxvt_fontprop::bold : rxvt_fontprop::medium;
1037	p.slant = face->style_flags & FT_STYLE_FLAG_ITALIC	1081	p.slant = face->style_flags & FT_STYLE_FLAG_ITALIC
1038	? rxvt_fontprop::italic : rxvt_fontprop::roman;	1082	? rxvt_fontprop::italic : rxvt_fontprop::roman;
1039		1083
…		…
1043	}	1087	}
1044		1088
1045	bool	1089	bool
1046	rxvt_font_xft::load (const rxvt_fontprop &prop)	1090	rxvt_font_xft::load (const rxvt_fontprop &prop)
1047	{	1091	{
		1092	dTermDisplay;
		1093
1048	clear ();	1094	clear ();
1049		1095
1050	FcPattern p = FcNameParse ((FcChar8 ) name);	1096	FcPattern p = FcNameParse ((FcChar8 ) name);
1051		1097
1052	if (!p)	1098	if (!p)
1053	return false;	1099	return false;
1054		1100
1055	FcValue v;	1101	FcValue v;
1056		1102
1057	if (prop.height != rxvt_fontprop::unset	1103	if (prop.height != rxvt_fontprop::unset
1058	\|\| (FcPatternGet (p, FC_PIXEL_SIZE, 0, &v) != FcResultMatch	1104	&& (FcPatternGet (p, FC_PIXEL_SIZE, 0, &v) != FcResultMatch
1059	&& FcPatternGet (p, FC_SIZE, 0, &v) != FcResultMatch))	1105	&& FcPatternGet (p, FC_SIZE, 0, &v) != FcResultMatch))
1060	FcPatternAddInteger (p, FC_PIXEL_SIZE, prop.height);	1106	FcPatternAddInteger (p, FC_PIXEL_SIZE, prop.height);
1061		1107
1062	if (prop.weight != rxvt_fontprop::unset	1108	if (prop.weight != rxvt_fontprop::unset
1063	&& FcPatternGet (p, FC_WEIGHT, 0, &v) != FcResultMatch)	1109	&& FcPatternGet (p, FC_WEIGHT, 0, &v) != FcResultMatch)
…		…
1078		1124
1079	// store generated name so iso14755 view gives better results	1125	// store generated name so iso14755 view gives better results
1080	set_name ((char *)FcNameUnparse (p));	1126	set_name ((char *)FcNameUnparse (p));
1081		1127
1082	XftResult result;	1128	XftResult result;
1083	FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);	1129	FcPattern *match = XftFontMatch (disp, term->display->screen, p, &result);
1084		1130
1085	FcPatternDestroy (p);	1131	FcPatternDestroy (p);
1086		1132
1087	if (!match)	1133	if (!match)
1088	return false;	1134	return false;
…		…
1090	int ftheight = 0;	1136	int ftheight = 0;
1091	bool success = true;	1137	bool success = true;
1092		1138
1093	for (;;)	1139	for (;;)
1094	{	1140	{
1095	f = XftFontOpenPattern (DISPLAY, FcPatternDuplicate (match));	1141	f = XftFontOpenPattern (disp, FcPatternDuplicate (match));
1096		1142
1097	if (!f)	1143	if (!f)
1098	{	1144	{
1099	success = false;	1145	success = false;
1100	break;	1146	break;
…		…
1109		1155
1110	bool scalable = face->face_flags & FT_FACE_FLAG_SCALABLE;	1156	bool scalable = face->face_flags & FT_FACE_FLAG_SCALABLE;
1111		1157
1112	XftUnlockFace (f);	1158	XftUnlockFace (f);
1113		1159
		1160	int glheight = height;
		1161
1114	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )	1162	for (uint16_t *t = extent_test_chars + NUM_EXTENT_TEST_CHARS; t-- > extent_test_chars; )
1115	{	1163	{
1116	FcChar16 ch = *t;	1164	FcChar16 ch = *t;
1117		1165
1118	if (cs != CS_UNICODE	1166	if (cs != CS_UNICODE
…		…
1124	bool careful;	1172	bool careful;
1125	if (!has_char (*t, &prop, careful))	1173	if (!has_char (*t, &prop, careful))
1126	continue;	1174	continue;
1127		1175
1128	XGlyphInfo g;	1176	XGlyphInfo g;
1129	XftTextExtents16 (DISPLAY, f, &ch, 1, &g);	1177	XftTextExtents16 (disp, f, &ch, 1, &g);
		1178
		1179	g.width -= g.x;
1130		1180
1131	int wcw = wcwidth (ch);	1181	int wcw = wcwidth (ch);
1132	if (wcw > 0) g.width = g.width / wcw;	1182	if (wcw > 0) g.width = (g.width + wcw - 1) / wcw;
1133		1183
1134	if (width < g.width) width = g.width;	1184	if (width < g.width ) width = g.width;
1135	if (height < g.height) height = g.height;	1185	if (height < g.height ) height = g.height;
		1186	if (glheight < g.height - g.y) glheight = g.height - g.y;
		1187	}
		1188
		1189	if (!width)
		1190	{
		1191	rxvt_warn ("unable to calculate font width for '%s', ignoring.\n", name);
		1192
		1193	XftFontClose (disp, f);
		1194	f = 0;
		1195
		1196	success = false;
		1197	break;
1136	}	1198	}
1137		1199
1138	if (prop.height == rxvt_fontprop::unset	1200	if (prop.height == rxvt_fontprop::unset
1139	\|\| height <= prop.height	1201	\|\| (height <= prop.height && glheight <= prop.height)
1140	\|\| height <= 2	1202	\|\| height <= 2
1141	\|\| !scalable)	1203	\|\| !scalable)
1142	break;	1204	break;
1143		1205
1144	if (ftheight)	1206	if (ftheight)
…		…
1151	ftheight -= height - prop.height;	1213	ftheight -= height - prop.height;
1152	}	1214	}
1153	else	1215	else
1154	ftheight = prop.height - 1;	1216	ftheight = prop.height - 1;
1155		1217
1156	XftFontClose (DISPLAY, f);	1218	XftFontClose (disp, f);
1157	FcPatternDel (match, FC_PIXEL_SIZE);	1219	FcPatternDel (match, FC_PIXEL_SIZE);
1158	FcPatternAddInteger (match, FC_PIXEL_SIZE, ftheight);	1220	FcPatternAddInteger (match, FC_PIXEL_SIZE, ftheight);
1159	}	1221	}
1160		1222
1161	FcPatternDestroy (match);	1223	FcPatternDestroy (match);
1162		1224
1163	#if 0 // do it per-character	1225	#if 0 // do it per-character
…		…
1170		1232
1171	return success;	1233	return success;
1172	}	1234	}
1173		1235
1174	bool	1236	bool
1175	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful)	1237	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
1176	{	1238	{
1177	careful = false;	1239	careful = false;
1178		1240
1179	if (!XftCharExists (DISPLAY, f, unicode))	1241	if (!XftCharExists (term->display->display, f, unicode))
1180	return false;	1242	return false;
1181		1243
1182	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1244	if (!prop \|\| prop->width == rxvt_fontprop::unset)
1183	return true;	1245	return true;
1184		1246
1185	// check character against base font bounding box	1247	// check character against base font bounding box
1186	FcChar32 ch = unicode;	1248	FcChar32 ch = unicode;
1187	XGlyphInfo g;	1249	XGlyphInfo g;
1188	XftTextExtents32 (DISPLAY, f, &ch, 1, &g);	1250	XftTextExtents32 (term->display->display, f, &ch, 1, &g);
1189		1251
1190	int w = g.width;	1252	int w = g.width - g.x;
1191	int wcw = wcwidth (unicode);	1253	int wcw = wcwidth (unicode);
1192	if (wcw > 0) w /= wcw;	1254	if (wcw > 0) w = (w + wcw - 1) / wcw;
1193		1255
1194	careful = w > prop->width;	1256	careful = w > prop->width;
1195	if (careful && w > prop->width * MAX_OVERLAP >> 2)	1257	if (careful && w > prop->width * MAX_OVERLAP >> 2)
1196	return false;	1258	return false;
1197		1259
…		…
1201	void	1263	void
1202	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,	1264	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
1203	const text_t *text, int len,	1265	const text_t *text, int len,
1204	int fg, int bg)	1266	int fg, int bg)
1205	{	1267	{
1206	clear_rect (d, x, y, r->TermWin.fwidth * len, r->TermWin.fheight, bg);	1268	clear_rect (d, x, y, term->fwidth * len, term->fheight, bg);
1207
1208	int base = ascent; // should be fbase, but that is incorrect
1209		1269
1210	XGlyphInfo extents;	1270	XGlyphInfo extents;
1211	FcChar32 enc = (FcChar32 ) get_enc_buf (len * sizeof (FcChar32));	1271	XftGlyphSpec enc = (XftGlyphSpec )rxvt_temp_buf (len * sizeof (XftGlyphSpec));
1212	FcChar32 *ep = enc;	1272	XftGlyphSpec *ep = enc;
1213	int ewidth = 0;	1273
1214	int xoff = 0;	1274	dTermDisplay;
		1275	dTermGC;
		1276
		1277	// cut trailing spaces
		1278	while (len && text [len - 1] == ' ')
		1279	len--;
1215		1280
1216	while (len)	1281	while (len)
1217	{	1282	{
1218	int cwidth = r->TermWin.fwidth;	1283	int cwidth = term->fwidth;
1219	FcChar32 fc = *text++; len--;	1284	FcChar32 fc = *text++; len--;
1220	FT_UInt gl;
1221		1285
1222	while (len && *text == NOCHAR)	1286	while (len && *text == NOCHAR)
1223	text++, len--, cwidth += r->TermWin.fwidth;	1287	text++, len--, cwidth += term->fwidth;
1224		1288
1225	gl = XftCharIndex (d.display->display, f, fc);	1289	if (fc != ' ') // skip spaces
1226	XftGlyphExtents (d.display->display, f, &gl, 1, &extents);
1227
1228	if (extents.xOff != cwidth && ep != enc)
1229	{
1230	if (xoff > ewidth) xoff = ewidth;
1231	XftDrawGlyphs (d, &r->pix_colors[fg].c, f,
1232	x + (ewidth - xoff >> 1),
1233	y + base, enc, ep - enc);
1234	x += ewidth;
1235
1236	ep = enc;
1237	ewidth = 0;
1238	xoff = 0;
1239	}	1290	{
		1291	FT_UInt glyph = XftCharIndex (disp, f, fc);
		1292	XftGlyphExtents (disp, f, &glyph, 1, &extents);
1240		1293
1241	if (fc == ' ' && ep == enc) // skip leading spaces	1294	ep->glyph = glyph;
		1295	ep->x = x + (cwidth - extents.xOff >> 1);
		1296	ep->y = y + ascent;
		1297	ep++;
1242	{	1298	}
		1299
1243	x += cwidth;	1300	x += cwidth;
1244	continue;
1245	}
1246
1247	else
1248	{
1249	*ep++ = gl;
1250	ewidth += cwidth;
1251	xoff += extents.xOff;
1252	}
1253	}	1301	}
1254		1302
1255	if (ep != enc)	1303	if (ep != enc)
1256	{
1257	if (xoff > ewidth) xoff = ewidth;
1258	XftDrawGlyphs (d, &r->pix_colors[fg].c, f,	1304	XftDrawGlyphSpec (d, &term->pix_colors[fg].c, f, enc, ep - enc);
1259	x + (ewidth - xoff >> 1),
1260	y + base, enc, ep - enc);
1261	}
1262	}	1305	}
1263	#endif	1306	#endif
1264		1307
1265	/////////////////////////////////////////////////////////////////////////////	1308	/////////////////////////////////////////////////////////////////////////////
1266		1309
1267	rxvt_fontset::rxvt_fontset (rxvt_t r)	1310	rxvt_fontset::rxvt_fontset (rxvt_term *term)
1268	: r (r), fontdesc (0)	1311	: fontdesc (0), term (term)
1269	{	1312	{
1270	clear ();	1313	clear ();
1271	}	1314	}
1272		1315
1273	rxvt_fontset::~rxvt_fontset ()	1316	rxvt_fontset::~rxvt_fontset ()
…		…
1276	}	1319	}
1277		1320
1278	void	1321	void
1279	rxvt_fontset::clear ()	1322	rxvt_fontset::clear ()
1280	{	1323	{
1281	prop.width = prop.height = prop.weight = prop.slant	1324	prop.width = prop.height = prop.ascent = prop.weight = prop.slant
1282	= rxvt_fontprop::unset;	1325	= rxvt_fontprop::unset;
1283		1326
1284	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)	1327	for (rxvt_font **i = fonts.begin (); i != fonts.end (); i++)
1285	FONT_UNREF (*i);	1328	FONT_UNREF (*i);
1286		1329
…		…
1317	f = new rxvt_font_x11;	1360	f = new rxvt_font_x11;
1318	}	1361	}
1319	else	1362	else
1320	f = new rxvt_font_x11;	1363	f = new rxvt_font_x11;
1321		1364
1322	f->set_term (r);	1365	f->set_term (term);
1323	f->set_name (strdup (name));	1366	f->set_name (strdup (name));
1324		1367
1325	f->cs = cs;	1368	f->cs = cs;
1326	f->loaded = false;	1369	f->loaded = false;
1327		1370
…		…
1338	char buf[512];	1381	char buf[512];
1339	const char *end;	1382	const char *end;
1340		1383
1341	do	1384	do
1342	{	1385	{
1343	while (*desc <= ' ') desc++;	1386	while (desc && desc <= ' ')
		1387	desc++;
1344		1388
1345	codeset cs = CS_UNICODE;	1389	codeset cs = CS_UNICODE;
1346		1390
1347	if (*desc == '[')	1391	if (*desc == '[')
1348	{	1392	{
…		…
1458	if (FROM_UNICODE (f->cs, unicode) == NOCHAR)	1502	if (FROM_UNICODE (f->cs, unicode) == NOCHAR)
1459	goto next_font;	1503	goto next_font;
1460		1504
1461	if (!realize_font (i))	1505	if (!realize_font (i))
1462	goto next_font;	1506	goto next_font;
		1507
		1508	if (prop.ascent != rxvt_fontprop::unset)
		1509	max_it (f->ascent, prop.ascent);
1463	}	1510	}
1464		1511
1465	if (f->cs == CS_UNKNOWN)	1512	if (f->cs == CS_UNKNOWN)
1466	goto next_font;	1513	goto next_font;
1467		1514
…		…
1506	FcPatternAddInteger (p, FC_SLANT, prop.slant);	1553	FcPatternAddInteger (p, FC_SLANT, prop.slant);
1507	FcPatternAddBool (p, FC_MINSPACE, 1);	1554	FcPatternAddBool (p, FC_MINSPACE, 1);
1508	//FcPatternAddBool (p, FC_ANTIALIAS, 1);	1555	//FcPatternAddBool (p, FC_ANTIALIAS, 1);
1509		1556
1510	XftResult result;	1557	XftResult result;
1511	FcPattern *match = XftFontMatch (DISPLAY, DefaultScreen (DISPLAY), p, &result);	1558	FcPattern *match = XftFontMatch (term->display->display, term->display->screen, p, &result);
1512		1559
1513	FcPatternDestroy (p);	1560	FcPatternDestroy (p);
1514		1561
1515	if (match)	1562	if (match)
1516	{	1563	{

Diff Legend

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

Comparing rxvt-unicode/src/rxvtfont.C (file contents): Revision 1.56 by root, Fri Dec 10 19:55:55 2004 UTC vs. Revision 1.85 by root, Wed Jan 25 00:42:21 2006 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.56 by root, Fri Dec 10 19:55:55 2004 UTC vs.
Revision 1.85 by root, Wed Jan 25 00:42:21 2006 UTC