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

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.199 by root, Thu Jun 17 00:08:35 2021 UTC vs.
Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC

…		…
134	# endif	134	# endif
135	#endif	135	#endif
136		136
137	//{ CS_UNICODE, "--unifont---------c--iso10646-1" }, // this gem of a font has actual dotted circles within the combining character glyphs.	137	//{ CS_UNICODE, "--unifont---------c--iso10646-1" }, // this gem of a font has actual dotted circles within the combining character glyphs.
138	#if XFT	138	#if XFT
139	{ CS_UNICODE, "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },	139	{ CS_UNICODE, "xft:DejaVu Sans Mono:antialias=false:autohint=true" },
140	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },	140	{ CS_UNICODE, "xft:Courier New:antialias=false:autohint=true" },
141	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },	141	{ CS_UNICODE, "xft:Andale Mono:antialias=false:autohint=false" },
142	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false:autohint=false" },	142	{ CS_UNICODE, "xft:Arial Unicode MS:antialias=false:autohint=false" },
143		143
144	// FreeMono is usually uglier than x fonts, so try after the others	144	// FreeMono is usually uglier than x fonts, so try after the others
145	{ CS_UNICODE, "xft:FreeMono:autohint=true" },	145	{ CS_UNICODE, "xft:FreeMono:autohint=true" },
146	#endif	146	#endif
147		147
…		…
313	if (unicode >= 0x2500 && unicode <= 0x259f &&	313	if (unicode >= 0x2500 && unicode <= 0x259f &&
314	!term->option (Opt_skipBuiltinGlyphs))	314	!term->option (Opt_skipBuiltinGlyphs))
315	return true;	315	return true;
316	#endif	316	#endif
317		317
318	if (IS_COMPOSE (unicode))	318	// we do not check for IS_COMPOSE here, as this would
319	return true;	319	// rob other fonts from taking over.
320		320
321	switch (unicode)	321	switch (unicode)
322	{	322	{
323	case ZERO_WIDTH_CHAR:	323	case ZERO_WIDTH_CHAR:
324	case NOCHAR:	324	case NOCHAR:
…		…
345		345
346	XSetForeground (disp, gc, term->pix_colors[fg]);	346	XSetForeground (disp, gc, term->pix_colors[fg]);
347		347
348	while (len)	348	while (len)
349	{	349	{
		350	const text_t *tp = text;
		351	text_t t = *tp;
		352
		353	while (++text, --len && *text == NOCHAR)
		354	;
		355
350	#if ENABLE_COMBINING	356	#if ENABLE_COMBINING
351	compose_char *cc;	357	compose_char *cc;
352	#endif	358	#endif
353	const text_t *tp = text;
354	text_t t = *tp;
355
356	while (++text, --len && *text == NOCHAR)
357	;
358
359	int width = text - tp;	359	int width = text - tp;
360	int fwidth = term->fwidth * width;	360	int fwidth = term->fwidth * width;
361		361
362	#ifdef BUILTIN_GLYPHS	362	#ifdef BUILTIN_GLYPHS
363	if (0x2500 <= t && t <= 0x259f)	363	if (0x2500 <= t && t <= 0x259f)
…		…
445	#endif	445	#endif
446	#if ENABLE_COMBINING	446	#if ENABLE_COMBINING
447	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))	447	else if (IS_COMPOSE (t) && (cc = rxvt_composite[t]))
448	{	448	{
449	min_it (width, 2); // we only support wcwidth up to 2	449	min_it (width, 2); // we only support wcwidth up to 2
450
451	text_t chrs[2];	450	text_t chrs[2];
452	chrs [1] = NOCHAR;	451	chrs [1] = NOCHAR;
453		452
454	*chrs = cc->c1;	453	*chrs = cc->c1;
455	rxvt_font f1 = (fs)[fs->find_font_idx (cc->c1)];	454	rxvt_font f1 = (fs)[fs->find_font_idx (cc->c1)];
…		…
1138		1137
1139	#if XFT	1138	#if XFT
1140		1139
1141	struct rxvt_font_xft : rxvt_font	1140	struct rxvt_font_xft : rxvt_font
1142	{	1141	{
		1142	#if XFT_CHAR_CACHE
		1143	// we cache the qascii range xoffsets in the name of speed,
		1144	// expecting terminals to deal mostly with these characters
		1145	// we also assume the xoff always fits into uint8_t,
		1146	// which is questionable, but let's see...
		1147	// also, it is uncomfortably big, due to the uints.
		1148	enum { char_cache_min = 0x20, char_cache_max = 0x7e };
		1149	uint8_t xoff_cache [char_cache_max - char_cache_min + 1];
		1150	FT_UInt glyph_cache [char_cache_max - char_cache_min + 1];
		1151	#endif
		1152
1143	rxvt_font_xft ()	1153	rxvt_font_xft ()
1144	{	1154	{
1145	f = 0;	1155	f = 0;
1146	}	1156	}
1147		1157
…		…
1253	break;	1263	break;
1254	}	1264	}
1255		1265
1256	FT_Face face = XftLockFace (f);	1266	FT_Face face = XftLockFace (f);
1257		1267
		1268	// fuck me plenty: XftLockFace can actually return 0. try not to crash.
		1269	// we also assume blindly that if the first lock succeeeds, then subsequent
		1270	// locks will also succeed.
		1271	if (!face)
		1272	{
		1273	XftFontClose (disp, f);
		1274	success = false;
		1275	break;
		1276	}
		1277
1258	ascent = (face->size->metrics.ascender + 63) >> 6;	1278	ascent = (face->size->metrics.ascender + 63) >> 6;
1259	descent = (-face->size->metrics.descender + 63) >> 6;	1279	descent = (-face->size->metrics.descender + 63) >> 6;
1260	height = max (ascent + descent, (face->size->metrics.height + 63) >> 6);	1280	height = max (ascent + descent, (face->size->metrics.height + 63) >> 6);
1261	width = 0;	1281	width = 0;
1262		1282
…		…
1293	if (glheight < g.height - g.y) glheight = g.height - g.y;	1313	if (glheight < g.height - g.y) glheight = g.height - g.y;
1294	}	1314	}
1295		1315
1296	if (!width)	1316	if (!width)
1297	{	1317	{
1298	rxvt_warn ("unable to calculate font width for '%s', ignoring.\n", name);	1318	rxvt_warn ("unable to calculate font width for '%s', using max_advance_width.\n", name);
1299		1319	width = f->max_advance_width;
1300	XftFontClose (disp, f);
1301	f = 0;
1302
1303	success = false;
1304	break;	1320	break;
1305	}	1321	}
1306		1322
1307	if (prop.height == rxvt_fontprop::unset	1323	if (prop.height == rxvt_fontprop::unset
1308	\|\| (height <= prop.height && glheight <= prop.height)	1324	\|\| (height <= prop.height && glheight <= prop.height)
…		…
1335	clear ();	1351	clear ();
1336	success = false;	1352	success = false;
1337	}	1353	}
1338	#endif	1354	#endif
1339		1355
		1356	#if XFT_CHAR_CACHE
		1357	// populate char cache
		1358	for (FcChar16 ch = char_cache_min; ch <= char_cache_max; ++ch)
		1359	{
		1360	FT_UInt glyph = XftCharIndex (disp, f, ch);
		1361	glyph_cache [ch - char_cache_min] = glyph;
		1362
		1363	XGlyphInfo g;
		1364	XftGlyphExtents (disp, f, &glyph, 1, &g);
		1365	xoff_cache [ch - char_cache_min] = g.xOff;
		1366	}
		1367	#endif
		1368
1340	return success;	1369	return success;
1341	}	1370	}
1342		1371
1343	bool	1372	bool
1344	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const	1373	rxvt_font_xft::has_char (unicode_t unicode, const rxvt_fontprop *prop, bool &careful) const
1345	{	1374	{
1346	careful = false;	1375	careful = false;
1347		1376
		1377	// handle non-bmp chars when text_t is 16 bit
		1378	#if ENABLE_COMBINING && !UNICODE_3
		1379	if (ecb_expect_false (IS_COMPOSE (unicode)))
		1380	if (compose_char *cc = rxvt_composite [unicode])
		1381	if (cc->c2 == NOCHAR)
		1382	unicode = cc->c1;
		1383	else
		1384	return false;
		1385	else
		1386	return false;
		1387	#endif
		1388
		1389	FcChar32 chr = unicode;
		1390
1348	if (!XftCharExists (term->dpy, f, unicode))	1391	if (!XftCharExists (term->dpy, f, chr))
1349	return false;	1392	return false;
1350		1393
1351	if (!prop \|\| prop->width == rxvt_fontprop::unset)	1394	if (!prop \|\| prop->width == rxvt_fontprop::unset)
1352	return true;	1395	return true;
1353		1396
1354	// check character against base font bounding box	1397	int wcw = max (WCWIDTH (chr), 1);
1355	FcChar32 ch = unicode;	1398
1356	XGlyphInfo g;	1399	XGlyphInfo g;
1357	XftTextExtents32 (term->dpy, f, &ch, 1, &g);	1400	XftTextExtents32 (term->dpy, f, &chr, 1, &g);
		1401
		1402	int cwidth = prop->width * wcw;
		1403
		1404	// use same adjustments as in ->draw, see there
		1405	g.x += g.xOff ? cwidth - g.xOff >> 1 : 0;
		1406	g.x += g.xOff ? 0 : cwidth;
1358		1407
1359	int w = g.width - g.x;	1408	int w = g.width - g.x;
1360	int wcw = max (WCWIDTH (unicode), 1);
1361		1409
1362	careful = g.x > 0 \|\| w > prop->width * wcw;	1410	careful = g.x > 0 \|\| w > cwidth;
1363		1411
1364	if (careful && !OVERLAP_OK (w, wcw, prop))	1412	if (careful && !OVERLAP_OK (w, wcw, prop))
1365	return false;	1413	return false;
1366		1414
1367	// this weeds out _totally_ broken fonts, or glyphs	1415	// this weeds out _totally_ broken fonts, or glyphs
…		…
1374	void	1422	void
1375	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,	1423	rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
1376	const text_t *text, int len,	1424	const text_t *text, int len,
1377	int fg, int bg)	1425	int fg, int bg)
1378	{	1426	{
1379	XGlyphInfo extents;
1380	XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);	1427	XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);
1381	XftGlyphSpec *ep = enc;	1428	XftGlyphSpec *ep = enc;
1382		1429
1383	dTermDisplay;	1430	dTermDisplay;
1384	dTermGC;	1431	dTermGC;
…		…
1397	int y_ = buffered ? 0 : y;	1444	int y_ = buffered ? 0 : y;
1398		1445
1399	while (len)	1446	while (len)
1400	{	1447	{
1401	int cwidth = term->fwidth;	1448	int cwidth = term->fwidth;
1402	FcChar32 fc = *text++; len--;	1449	FcChar32 chr = *text++; len--;
1403		1450
1404	while (len && *text == NOCHAR)	1451	while (len && *text == NOCHAR)
1405	text++, len--, cwidth += term->fwidth;	1452	text++, len--, cwidth += term->fwidth;
1406		1453
1407	if (fc != ' ') // skip spaces	1454	if (chr != ' ') // skip spaces
		1455	{
		1456	// handle non-bmp chars when text_t is 16 bit
		1457	#if ENABLE_COMBINING && !UNICODE_3
		1458	if (ecb_expect_false (IS_COMPOSE (chr)))
		1459	if (compose_char *cc = rxvt_composite [chr])
		1460	if (cc->c2 == NOCHAR)
		1461	chr = cc->c1;
		1462	#endif
		1463
		1464	#if 0
		1465	FT_UInt glyphs [decltype (exp)::max_size];
		1466
		1467	for (int i = 0; i < nchrs; ++i)
		1468	glyphs [i] = XftCharIndex (disp, f, chrs [i]);
		1469
		1470	for (int i = 0; i < nchrs; ++i)
1408	{	1471	{
		1472	XGlyphInfo ep;
		1473	XftGlyphExtents (disp, f, glyphs+i, 1, &ep);
		1474	printf ("gs %4x g %4x + %3d,%3d o %3d,%3d wh %3d,%3d\n", chrs[i],glyphs[i],ep.x,ep.y,ep.xOff,ep.yOff,ep.width,ep.height);
		1475	}
		1476	#endif
		1477
		1478	FT_UInt glyph;
		1479	int xOff;
		1480
		1481	#if XFT_CHAR_CACHE
		1482	if (ecb_expect_true (IN_RANGE_INC (chr, char_cache_min, char_cache_max)))
		1483	{
		1484	glyph = glyph_cache [chr - char_cache_min];
		1485	xOff = xoff_cache [chr - char_cache_min];
		1486	}
		1487	else
		1488	#endif
		1489	{
1409	FT_UInt glyph = XftCharIndex (disp, f, fc);	1490	glyph = XftCharIndex (disp, f, chr);
		1491	XGlyphInfo extents;
1410	XftGlyphExtents (disp, f, &glyph, 1, &extents);	1492	XftGlyphExtents (disp, f, &glyph, 1, &extents);
		1493	xOff = extents.xOff;
		1494	}
1411		1495
1412	ep->glyph = glyph;	1496	ep->glyph = glyph;
1413	ep->x = x_ + (cwidth - extents.xOff >> 1);	1497	ep->x = x_;
1414	ep->y = y_ + ascent;	1498	ep->y = y_ + ascent;
1415		1499
1416	if (extents.xOff == 0)	1500	// the xft font cell might differ from the terminal font cell,
		1501	// in which case we use the average between the two.
		1502	ep->x += xOff ? cwidth - xOff >> 1 : 0;
		1503
		1504	// xft/freetype represent combining characters as characters with zero
		1505	// width rendered over the previous character with some fonts, while
		1506	// in other fonts, they are considered normal characters, while yet
		1507	// in other fonts, they are shifted all over the place.
		1508	// we handle the first two cases by keying off on xOff being 0
		1509	// for zero-width chars. normally, we would add extents.xOff
		1510	// of the base character here, but we don't have that, so we use cwidth.
1417	ep->x = x_ + cwidth;	1511	ep->x += xOff ? 0 : cwidth;
1418		1512
1419	ep++;	1513	++ep;
1420	}	1514	}
1421		1515
1422	x_ += cwidth;	1516	x_ += cwidth;
1423	}	1517	}
1424		1518
…		…
1693	}	1787	}
1694		1788
1695	int	1789	int
1696	rxvt_fontset::find_font_idx (unicode_t unicode)	1790	rxvt_fontset::find_font_idx (unicode_t unicode)
1697	{	1791	{
1698	if (unicode >= 1<<20)	1792	// this limits fmap size. it has to accommodate COMPOSE_HI when UNICODE_3
		1793	if (unicode > 0x1fffff)
1699	return 0;	1794	return 0;
1700		1795
1701	unicode_t hi = unicode >> 8;	1796	unicode_t hi = unicode >> 8;
1702		1797
1703	if (hi < fmap.size ()	1798	if (hi < fmap.size ())
1704	&& fmap[hi]	1799	if (pagemap *pm = fmap[hi])
1705	&& (*fmap[hi])[unicode & 0xff] != 0xff)	1800	if ((*pm)[unicode & 0xff] != 0xff)
1706	return (*fmap[hi])[unicode & 0xff];	1801	return (*pm)[unicode & 0xff];
1707		1802
1708	unsigned int i;	1803	unsigned int i;
1709		1804
1710	for (i = 0; i < fonts.size (); i++)	1805	for (i = 0; i < fonts.size (); i++)
1711	{	1806	{
…		…
1735	}	1830	}
1736		1831
1737	next_font:	1832	next_font:
1738	if (i == fonts.size () - 1)	1833	if (i == fonts.size () - 1)
1739	{	1834	{
		1835	// compose characters are handled by the default font, unless another font takes over
		1836	// we do not go via the fallback list for speed reasons.
		1837	if (IS_COMPOSE (unicode))
		1838	return 0;
		1839
1740	if (fallback->name)	1840	if (fallback->name)
1741	{	1841	{
1742	// search through the fallback list	1842	// search through the fallback list
1743	push_font (new_font (fallback->name, fallback->cs));	1843	push_font (new_font (fallback->name, fallback->cs));
1744	fallback++;	1844	fallback++;

Diff Legend

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

Comparing rxvt-unicode/src/rxvtfont.C (file contents): Revision 1.199 by root, Thu Jun 17 00:08:35 2021 UTC vs. Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.199 by root, Thu Jun 17 00:08:35 2021 UTC vs.
Revision 1.221 by root, Thu Aug 26 03:58:29 2021 UTC